diff --git a/.gitignore b/.gitignore index 69c4c5f2..ef7ac385 100644 --- a/.gitignore +++ b/.gitignore @@ -41,5 +41,5 @@ test_upnp*.cargo/ setup-env.sh cache gupnp-tools -pmocontrol_[0_9]*.txt +pmo*_[0_9]*.txt webapp_[0_9]*.txt \ No newline at end of file diff --git a/pmocache/src/cache.rs b/pmocache/src/cache.rs index eeb2d689..b59125da 100755 --- a/pmocache/src/cache.rs +++ b/pmocache/src/cache.rs @@ -48,15 +48,9 @@ pub fn is_lazy_pk(pk: &str) -> bool { #[derive(Debug, Clone)] pub enum CacheEvent { /// Un fichier a été servi via HTTP - Served { - pk: String, - format: String, - }, + Served { pk: String, format: String }, /// Un fichier lazy a été téléchargé et est maintenant disponible - LazyDownloaded { - lazy_pk: String, - real_pk: String, - }, + LazyDownloaded { lazy_pk: String, real_pk: String }, } /// Informations transmises lors de la diffusion d'un élément du cache via HTTP. @@ -1358,7 +1352,7 @@ impl Cache { let lazy_pk = generate_lazy_pk(url); // Vérifier si ce lazy_pk existe déjà (collision improbable mais...) - if let Ok(Some(_)) = self.db.get_pk_by_lazy_pk(&lazy_pk) { + if let Ok(true) = self.db.has_lazy_entry(&lazy_pk) { bail!("Lazy PK collision for URL: {}", url); } diff --git a/pmocache/src/cache_trait.rs b/pmocache/src/cache_trait.rs index edd0f6d3..42fe8630 100644 --- a/pmocache/src/cache_trait.rs +++ b/pmocache/src/cache_trait.rs @@ -4,7 +4,7 @@ use std::{ sync::Arc, }; -use crate::{CacheConfig, DB}; +use crate::{cache::is_lazy_pk, CacheConfig, DB}; /// Trait générique pour les caches de fichiers /// @@ -145,6 +145,29 @@ pub trait FileCache: Send + Sync { /// Ceci permet le progressive caching: les fichiers en cours de download sont acceptés /// dès que le prebuffer est atteint, sans attendre le marker de completion. async fn is_valid_pk(&self, pk: &str) -> bool { + if is_lazy_pk(pk) { + match self.get_database().has_lazy_entry(pk) { + Ok(true) => { + tracing::debug!( + "is_valid_pk({}): Lazy entry present in DB, download deferred", + pk + ); + return true; + } + Ok(false) => { + tracing::warn!( + "is_valid_pk({}): Lazy pk not registered in DB, rejecting", + pk + ); + return false; + } + Err(e) => { + tracing::error!("is_valid_pk({}): Error while checking lazy pk: {}", pk, e); + return false; + } + } + } + if self.get_database().get(pk, false).is_err() { tracing::debug!("is_valid_pk({}): DB entry not found", pk); return false; diff --git a/pmocache/src/db.rs b/pmocache/src/db.rs index 39fdc9c8..3b799141 100644 --- a/pmocache/src/db.rs +++ b/pmocache/src/db.rs @@ -765,11 +765,11 @@ impl DB { // LAZY PK SUPPORT // ============================================================================ - /// Ajoute une entrée en mode lazy (pk = NULL, lazy_pk rempli) + /// Ajoute une entrée en mode lazy (pk = lazy_pk tant que non téléchargé) /// /// Utilisé pour créer des entries sans télécharger le fichier. - /// Le lazy_pk est calculé à partir de l'URL, le real pk sera calculé - /// lors du téléchargement effectif. + /// Le lazy_pk est calculé à partir de l'URL et sert temporairement + /// également de pk pour satisfaire les contraintes de clé étrangère. /// /// # Arguments /// @@ -784,12 +784,9 @@ impl DB { ) -> rusqlite::Result<()> { let conn = self.lock_conn("add_lazy"); - // Créer une entry avec pk = NULL et lazy_pk rempli - // On utilise une astuce: insérer avec lazy_pk comme clé temporaire - // puis mettre pk à NULL conn.execute( "INSERT INTO asset (pk, lazy_pk, id, collection, hits, last_used) - VALUES (NULL, ?1, ?2, ?3, 0, ?4)", + VALUES (?1, ?1, ?2, ?3, 0, ?4)", params![lazy_pk, id, collection, Utc::now().to_rfc3339()], )?; @@ -805,16 +802,46 @@ impl DB { /// # Returns /// /// * `Ok(Some(pk))` - Le real pk si le fichier a été téléchargé - /// * `Ok(None)` - Pas encore téléchargé (pk = NULL) ou lazy_pk inconnu + /// * `Ok(None)` - Pas encore téléchargé ou lazy_pk inconnu pub fn get_pk_by_lazy_pk(&self, lazy_pk: &str) -> rusqlite::Result> { let conn = self.lock_conn("get_pk_by_lazy_pk"); - conn.query_row( - "SELECT pk FROM asset WHERE lazy_pk = ?1", - [lazy_pk], - |row| row.get(0), - ) - .optional() + let result: Option<(String, Option)> = conn + .query_row( + "SELECT pk, lazy_pk FROM asset WHERE lazy_pk = ?1", + [lazy_pk], + |row| Ok((row.get(0)?, row.get(1)?)), + ) + .optional()?; + + Ok(result.and_then(|(pk, lazy)| { + if let Some(lazy_pk_value) = lazy { + if pk == lazy_pk_value { + None + } else { + Some(pk) + } + } else { + Some(pk) + } + })) + } + + /// Vérifie l'existence d'une entrée lazy sans télécharger le fichier + /// + /// Retourne `true` si une ligne avec `lazy_pk` existe, même si `pk` est `NULL`. + pub fn has_lazy_entry(&self, lazy_pk: &str) -> rusqlite::Result { + let conn = self.lock_conn("has_lazy_entry"); + + let exists: Option = conn + .query_row( + "SELECT 1 FROM asset WHERE lazy_pk = ?1 LIMIT 1", + [lazy_pk], + |row| row.get(0), + ) + .optional()?; + + Ok(exists.is_some()) } /// Transition d'une entry lazy vers downloaded (ajoute le real pk) @@ -827,43 +854,51 @@ impl DB { /// /// * `lazy_pk` - Le lazy PK de l'entry originale /// * `real_pk` - Le real PK calculé après téléchargement - pub fn update_lazy_to_downloaded( - &self, - lazy_pk: &str, - real_pk: &str, - ) -> rusqlite::Result<()> { + pub fn update_lazy_to_downloaded(&self, lazy_pk: &str, real_pk: &str) -> rusqlite::Result<()> { let mut conn = self.lock_conn("update_lazy_to_downloaded"); let tx = conn.transaction()?; - // 1. Récupérer les infos de l'entry lazy - let (collection, id): (Option, Option) = tx + // 1. Récupérer l'entry lazy (pk = lazy_pk tant que pas téléchargé) + let (old_pk, collection, id, hits): (String, Option, Option, i32) = tx .query_row( - "SELECT collection, id FROM asset WHERE lazy_pk = ?1 AND pk IS NULL", + "SELECT pk, collection, id, hits FROM asset WHERE lazy_pk = ?1", [lazy_pk], - |row| Ok((row.get(0)?, row.get(1)?)), + |row| Ok((row.get(0)?, row.get(1)?, row.get(2)?, row.get(3)?)), ) .optional()? .ok_or_else(|| Error::QueryReturnedNoRows)?; - // 2. Supprimer l'entry lazy (pk = NULL) - tx.execute( - "DELETE FROM asset WHERE lazy_pk = ?1 AND pk IS NULL", - [lazy_pk], - )?; + if old_pk == real_pk { + // Rien à faire si déjà commuté + return Ok(()); + } - // 3. Créer nouvelle entry avec pk rempli ET lazy_pk - // Si le real_pk existe déjà (téléchargé via eager mode), on met juste à jour + let now = Utc::now().to_rfc3339(); + let hits_to_add = if hits > 0 { hits } else { 1 }; + + // 2. Créer/mettre à jour l'entry avec le real pk tx.execute( "INSERT INTO asset (pk, lazy_pk, collection, id, hits, last_used) - VALUES (?1, ?2, ?3, ?4, 1, ?5) + VALUES (?1, ?2, ?3, ?4, ?5, ?6) ON CONFLICT(pk) DO UPDATE SET lazy_pk = excluded.lazy_pk, - last_used = excluded.last_used, - hits = hits + 1", - params![real_pk, lazy_pk, collection, id, Utc::now().to_rfc3339()], + collection = COALESCE(excluded.collection, collection), + id = COALESCE(excluded.id, id), + hits = hits + excluded.hits, + last_used = excluded.last_used", + params![real_pk, lazy_pk, collection, id, hits_to_add, now], )?; + // 3. Re-pointer les métadonnées vers le real pk + tx.execute( + "UPDATE metadata SET pk = ?1 WHERE pk = ?2", + params![real_pk, old_pk], + )?; + + // 4. Supprimer l'ancienne entry lazy + tx.execute("DELETE FROM asset WHERE pk = ?1", [old_pk])?; + tx.commit() } @@ -890,11 +925,11 @@ impl DB { // Chercher via origin_url dans metadata // On joint avec asset pour récupérer pk et lazy_pk - let result: Option<(Option, Option)> = conn + let raw: Option<(String, Option)> = conn .query_row( "SELECT a.pk, a.lazy_pk FROM asset a - JOIN metadata m ON (a.pk = m.pk OR a.lazy_pk = m.pk) + JOIN metadata m ON a.pk = m.pk WHERE m.key = 'origin_url' AND m.value = ?1 LIMIT 1", [url], @@ -902,6 +937,18 @@ impl DB { ) .optional()?; + let result = raw.map(|(pk, lazy_pk)| { + if let Some(ref lazy) = lazy_pk { + if pk == *lazy { + (None, Some(lazy.clone())) + } else { + (Some(pk), lazy_pk) + } + } else { + (Some(pk), lazy_pk) + } + }); + Ok(result) } @@ -932,13 +979,7 @@ impl DB { /// /// * `lazy_pk` - Le lazy PK de l'entry /// * `origin_url` - L'URL d'origine à stocker - pub fn set_origin_url_for_lazy( - &self, - lazy_pk: &str, - origin_url: &str, - ) -> rusqlite::Result<()> { - // Pour les entries lazy, on stocke l'origin_url avec lazy_pk comme clé - // dans la table metadata (au lieu de pk qui est NULL) + pub fn set_origin_url_for_lazy(&self, lazy_pk: &str, origin_url: &str) -> rusqlite::Result<()> { self.set_a_metadata_by_key(lazy_pk, "origin_url", Value::String(origin_url.to_owned())) } diff --git a/pmocache/src/pmoserver_ext.rs b/pmocache/src/pmoserver_ext.rs index dd395749..ca3da4f6 100644 --- a/pmocache/src/pmoserver_ext.rs +++ b/pmocache/src/pmoserver_ext.rs @@ -195,7 +195,12 @@ async fn serve_lazy_audio_file( format!("/cache/{}/{}/{}", C::cache_type(), real_pk, param) }; - tracing::debug!("Lazy PK {} downloaded as {}, redirecting to {}", lazy_pk, real_pk, redirect_url); + tracing::debug!( + "Lazy PK {} downloaded as {}, redirecting to {}", + lazy_pk, + real_pk, + redirect_url + ); Redirect::temporary(&redirect_url).into_response() } diff --git a/pmoconfig/examples/encrypt_password.rs b/pmoconfig/examples/encrypt_password.rs index c6a3c59d..5566e5e1 100644 --- a/pmoconfig/examples/encrypt_password.rs +++ b/pmoconfig/examples/encrypt_password.rs @@ -120,7 +120,5 @@ fn print_usage() { println!(" cargo run --example encrypt_password -- test"); println!("\nExamples:"); println!(" cargo run --example encrypt_password -- encrypt \"MySecretPassword\""); - println!( - " cargo run --example encrypt_password -- decrypt \"encrypted:SGVsbG8gV29ybGQh...\"" - ); + println!(" cargo run --example encrypt_password -- decrypt \"encrypted:SGVsbG8gV29ybGQh...\""); } diff --git a/pmoconfig/src/encryption.rs b/pmoconfig/src/encryption.rs index 423c4b1c..15132209 100644 --- a/pmoconfig/src/encryption.rs +++ b/pmoconfig/src/encryption.rs @@ -117,8 +117,8 @@ fn derive_key() -> Result<[u8; 32]> { /// ``` pub fn encrypt_password(password: &str) -> Result { let key = derive_key()?; - let cipher = Aes256Gcm::new_from_slice(&key) - .map_err(|e| anyhow!("Failed to create cipher: {}", e))?; + let cipher = + Aes256Gcm::new_from_slice(&key).map_err(|e| anyhow!("Failed to create cipher: {}", e))?; // Nonce de 96 bits (12 bytes) - dérivé du mot de passe pour avoir // un chiffrement déterministe (même password = même ciphertext) @@ -173,8 +173,8 @@ pub fn decrypt_password(encrypted: &str) -> Result { .ok_or_else(|| anyhow!("Invalid encrypted password format (missing prefix)"))?; let key = derive_key()?; - let cipher = Aes256Gcm::new_from_slice(&key) - .map_err(|e| anyhow!("Failed to create cipher: {}", e))?; + let cipher = + Aes256Gcm::new_from_slice(&key).map_err(|e| anyhow!("Failed to create cipher: {}", e))?; let ciphertext = base64::engine::general_purpose::STANDARD .decode(base64_data) diff --git a/pmocontrol/examples/full_control_point_demo.rs b/pmocontrol/examples/full_control_point_demo.rs index be1c81ff..388dc525 100644 --- a/pmocontrol/examples/full_control_point_demo.rs +++ b/pmocontrol/examples/full_control_point_demo.rs @@ -433,9 +433,7 @@ impl App { } else { for (idx, item) in self.queue_snapshot.iter().enumerate() { let meta = item.metadata.as_ref(); - let title = meta - .and_then(|m| m.title.as_deref()) - .unwrap_or(""); + let title = meta.and_then(|m| m.title.as_deref()).unwrap_or(""); let artist = meta.and_then(|m| m.artist.as_deref()).unwrap_or(""); let prefix = match self.queue_current_index { Some(current) if current == idx => "▶", diff --git a/pmocontrol/src/control_point.rs b/pmocontrol/src/control_point.rs index b8bf5369..baa532b5 100644 --- a/pmocontrol/src/control_point.rs +++ b/pmocontrol/src/control_point.rs @@ -1,8 +1,8 @@ use std::collections::{HashMap, HashSet}; use std::hash::{DefaultHasher, Hash, Hasher}; use std::io::{self, BufRead, BufReader, Read, Write}; -use std::net::{IpAddr, TcpListener, TcpStream, UdpSocket}; use std::marker::PhantomData; +use std::net::{IpAddr, TcpListener, TcpStream, UdpSocket}; use std::ops::{Deref, DerefMut}; use std::sync::{Arc, Mutex, MutexGuard, RwLock}; use std::thread; @@ -10,9 +10,9 @@ use std::time::{Duration, Instant}; use anyhow::{Context, anyhow}; use crossbeam_channel::{Receiver, Sender, unbounded}; -use quick_xml::se::to_string as to_didl_string; use pmodidl::{DIDLLite, Item as DidlItem, Resource as DidlResource}; use pmoupnp::ssdp::SsdpClient; +use quick_xml::se::to_string as to_didl_string; use thiserror::Error; use tracing::{debug, error, info, warn}; use ureq::{Agent, http}; @@ -21,23 +21,22 @@ use xmltree::{Element, XMLNode}; pub mod music_queue; pub mod openhome_queue; -use crate::control_point::music_queue::MusicQueue; -use crate::control_point::openhome_queue::OpenHomeQueue; -use crate::music_renderer::{ - OpenHomeQueueProvider, RendererRuntimeState, set_openhome_queue_provider, -}; -use crate::queue_interne::InternalQueue; use crate::MusicRenderer; use crate::capabilities::{ PlaybackPosition, PlaybackPositionInfo, PlaybackState, PlaybackStatus, TransportControl, VolumeControl, }; +use crate::control_point::music_queue::MusicQueue; +use crate::control_point::openhome_queue::OpenHomeQueue; use crate::discovery::DiscoveryManager; use crate::events::{MediaServerEventBus, RendererEventBus}; use crate::media_server::{MediaBrowser, MediaEntry, MediaServerInfo, MusicServer, ServerId}; use crate::media_server_events::spawn_media_server_event_runtime; use crate::model::TrackMetadata; use crate::model::{MediaServerEvent, RendererEvent, RendererId, RendererInfo}; +use crate::music_renderer::{ + OpenHomeQueueProvider, RendererRuntimeState, set_openhome_queue_provider, +}; #[cfg(feature = "pmoserver")] use crate::openapi::{ CurrentTrackMetadata, FullRendererSnapshot, QueueItem, QueueSnapshotView, RendererBindingView, @@ -46,8 +45,9 @@ use crate::openapi::{ use crate::openhome_client::{OhInfoClient, OhPlaylistClient, parse_track_metadata_from_didl}; use crate::openhome_playlist::{OpenHomePlaylistSnapshot, OpenHomePlaylistTrack}; use crate::openhome_renderer::{format_seconds, map_openhome_state}; -use crate::queue_backend::{EnqueueMode, PlaybackItem, QueueBackend}; use crate::provider::HttpXmlDescriptionProvider; +use crate::queue_backend::{EnqueueMode, PlaybackItem, QueueBackend}; +use crate::queue_interne::InternalQueue; use crate::registry::{DeviceRegistry, DeviceRegistryRead, DeviceUpdate}; use crate::upnp_renderer::UpnpRenderer; @@ -212,12 +212,10 @@ impl ControlPoint { } } PlaylistBackend::PMOQueue => { - runtime_cp - .runtime - .set_music_queue( - &info.id, - MusicQueue::Internal(InternalQueue::new()), - ); + runtime_cp.runtime.set_music_queue( + &info.id, + MusicQueue::Internal(InternalQueue::new()), + ); } } if matches!(backend, PlaylistBackend::OpenHome) { @@ -842,10 +840,7 @@ impl ControlPoint { title: item.metadata.as_ref().and_then(|m| m.title.clone()), artist: item.metadata.as_ref().and_then(|m| m.artist.clone()), album: item.metadata.as_ref().and_then(|m| m.album.clone()), - album_art_uri: item - .metadata - .as_ref() - .and_then(|m| m.album_art_uri.clone()), + album_art_uri: item.metadata.as_ref().and_then(|m| m.album_art_uri.clone()), server_id: Some(item.media_server_id.0.clone()), object_id: Some(item.didl_id.clone()), }) @@ -1741,10 +1736,7 @@ impl RuntimeState { }) } - fn renderer_state_mut( - &self, - id: &RendererId, - ) -> anyhow::Result> { + fn renderer_state_mut(&self, id: &RendererId) -> anyhow::Result> { let mut entries = self.entries.lock().unwrap(); let queue_ptr = { let entry = entries @@ -1997,8 +1989,7 @@ fn refresh_attached_queue_for( container = container_id.as_str(), "Refreshed playlist is empty, clearing queue" ); - runtime - .with_music_queue_mut(renderer_id, |queue| queue.clear_queue())?; + runtime.with_music_queue_mut(renderer_id, |queue| queue.clear_queue())?; // Emit QueueUpdated event event_bus.broadcast(RendererEvent::QueueUpdated { @@ -2023,54 +2014,57 @@ fn refresh_attached_queue_for( new_items .iter() .position(|new_item| new_item.unique_id() == current_uid) - .or_else(|| new_items.iter().position(|new_item| new_item.uri == current.uri)) + .or_else(|| { + new_items + .iter() + .position(|new_item| new_item.uri == current.uri) + }) }); - let final_queue_len = runtime - .with_music_queue_mut(renderer_id, |queue| { - if let Some(idx) = item_found_at { - queue.replace_queue(new_items.clone(), Some(idx))?; - info!( - renderer = renderer_id.0.as_str(), - server = server_id.0.as_str(), - container = container_id.as_str(), - total_items = new_items.len(), - current_index = idx, - upcoming = new_items.len().saturating_sub(idx + 1), - current_preserved = true, - "Refreshed queue from playlist container" - ); - Ok(new_items.len()) - } else if let Some(ref current) = current_item { - let mut combined = Vec::with_capacity(new_items.len() + 1); - combined.push(current.clone()); - combined.extend(new_items.clone()); - queue.replace_queue(combined, Some(0))?; - info!( - renderer = renderer_id.0.as_str(), - server = server_id.0.as_str(), - container = container_id.as_str(), - total_items = new_items.len() + 1, - current_index = 0, - upcoming = new_items.len(), - current_preserved = true, - current_reinserted = true, - "Refreshed queue from playlist container (current item reinserted at start)" - ); - Ok(new_items.len() + 1) - } else { - queue.replace_queue(new_items.clone(), None)?; - info!( - renderer = renderer_id.0.as_str(), - server = server_id.0.as_str(), - container = container_id.as_str(), - total_items = new_items.len(), - current_preserved = false, - "Refreshed queue from playlist container (no current item)" - ); - Ok(new_items.len()) - } - })?; + let final_queue_len = runtime.with_music_queue_mut(renderer_id, |queue| { + if let Some(idx) = item_found_at { + queue.replace_queue(new_items.clone(), Some(idx))?; + info!( + renderer = renderer_id.0.as_str(), + server = server_id.0.as_str(), + container = container_id.as_str(), + total_items = new_items.len(), + current_index = idx, + upcoming = new_items.len().saturating_sub(idx + 1), + current_preserved = true, + "Refreshed queue from playlist container" + ); + Ok(new_items.len()) + } else if let Some(ref current) = current_item { + let mut combined = Vec::with_capacity(new_items.len() + 1); + combined.push(current.clone()); + combined.extend(new_items.clone()); + queue.replace_queue(combined, Some(0))?; + info!( + renderer = renderer_id.0.as_str(), + server = server_id.0.as_str(), + container = container_id.as_str(), + total_items = new_items.len() + 1, + current_index = 0, + upcoming = new_items.len(), + current_preserved = true, + current_reinserted = true, + "Refreshed queue from playlist container (current item reinserted at start)" + ); + Ok(new_items.len() + 1) + } else { + queue.replace_queue(new_items.clone(), None)?; + info!( + renderer = renderer_id.0.as_str(), + server = server_id.0.as_str(), + container = container_id.as_str(), + total_items = new_items.len(), + current_preserved = false, + "Refreshed queue from playlist container (no current item)" + ); + Ok(new_items.len()) + } + })?; // Emit QueueUpdated event event_bus.broadcast(RendererEvent::QueueUpdated { diff --git a/pmocontrol/src/control_point/openhome_queue.rs b/pmocontrol/src/control_point/openhome_queue.rs index 73c4ca63..c410f807 100644 --- a/pmocontrol/src/control_point/openhome_queue.rs +++ b/pmocontrol/src/control_point/openhome_queue.rs @@ -56,8 +56,8 @@ impl OpenHomeQueue { .info_client .as_ref() .and_then(|client| client.id().ok()); - let current_index = current_id - .and_then(|id| track_ids.iter().position(|entry_id| *entry_id == id)); + let current_index = + current_id.and_then(|id| track_ids.iter().position(|entry_id| *entry_id == id)); self.items = items; self.track_ids = track_ids; @@ -76,10 +76,7 @@ impl OpenHomeQueue { title: item.metadata.as_ref().and_then(|m| m.title.clone()), artist: item.metadata.as_ref().and_then(|m| m.artist.clone()), album: item.metadata.as_ref().and_then(|m| m.album.clone()), - album_art_uri: item - .metadata - .as_ref() - .and_then(|m| m.album_art_uri.clone()), + album_art_uri: item.metadata.as_ref().and_then(|m| m.album_art_uri.clone()), }) .collect(); @@ -151,7 +148,10 @@ impl OpenHomeQueue { if id == 0 { Some(0) } else { - self.track_ids.iter().position(|tid| *tid == id).map(|pos| pos + 1) + self.track_ids + .iter() + .position(|tid| *tid == id) + .map(|pos| pos + 1) } }) .unwrap_or_else(|| self.track_ids.len()); @@ -166,13 +166,8 @@ impl OpenHomeQueue { self.current_index = if play { Some(insert_index) } else { - self.current_index.map(|idx| { - if insert_index <= idx { - idx + 1 - } else { - idx - } - }) + self.current_index + .map(|idx| if insert_index <= idx { idx + 1 } else { idx }) }; Ok(new_id) @@ -213,11 +208,7 @@ pub fn didl_id_from_metadata(xml: &str) -> Option { } let parsed = pmodidl::parse_metadata::(xml).ok()?; - parsed - .data - .items - .first() - .map(|item| item.id.clone()) + parsed.data.items.first().map(|item| item.id.clone()) } fn build_metadata_xml(item: &PlaybackItem) -> String { @@ -255,10 +246,7 @@ fn build_metadata_xml(item: &PlaybackItem) -> String { } if let Some(uri) = meta.album_art_uri.as_deref() { let escaped = escape(uri); - xml.push_str(&format!( - "{}", - escaped - )); + xml.push_str(&format!("{}", escaped)); } if let Some(date) = meta.date.as_deref() { let escaped = escape(date); diff --git a/pmocontrol/src/lib.rs b/pmocontrol/src/lib.rs index b11524bb..36f12a98 100644 --- a/pmocontrol/src/lib.rs +++ b/pmocontrol/src/lib.rs @@ -14,9 +14,9 @@ pub mod music_renderer; pub mod openhome_client; pub mod openhome_playlist; pub mod openhome_renderer; +pub mod provider; pub mod queue_backend; pub mod queue_interne; -pub mod provider; pub mod registry; pub mod rendering_control_client; pub mod soap_client; diff --git a/pmocontrol/src/music_renderer.rs b/pmocontrol/src/music_renderer.rs index be6cee6c..140320d3 100644 --- a/pmocontrol/src/music_renderer.rs +++ b/pmocontrol/src/music_renderer.rs @@ -9,9 +9,9 @@ use std::sync::{Arc, OnceLock, RwLock}; use crate::capabilities::{PlaybackPositionInfo, PlaybackStatus}; +use crate::control_point::RendererRuntimeStateMut; use crate::control_point::music_queue::MusicQueue; use crate::control_point::openhome_queue::didl_id_from_metadata; -use crate::control_point::RendererRuntimeStateMut; use crate::media_server::ServerId; use crate::model::{RendererId, RendererInfo, RendererProtocol}; use crate::openhome_client::parse_track_metadata_from_didl; @@ -67,9 +67,7 @@ pub trait OpenHomeQueueProvider: Send + Sync + 'static { static OPENHOME_QUEUE_PROVIDER: OnceLock> = OnceLock::new(); -pub fn set_openhome_queue_provider( - provider: Arc, -) { +pub fn set_openhome_queue_provider(provider: Arc) { let _ = OPENHOME_QUEUE_PROVIDER.set(provider); } @@ -240,11 +238,7 @@ impl MusicRenderer { } } else { let snapshot = self.fetch_openhome_playlist_snapshot()?; - Ok(snapshot - .tracks - .into_iter() - .map(|track| track.id) - .collect()) + Ok(snapshot.tracks.into_iter().map(|track| track.id).collect()) } } diff --git a/pmocontrol/src/queue_backend.rs b/pmocontrol/src/queue_backend.rs index 61ae5b2b..cc5d34da 100644 --- a/pmocontrol/src/queue_backend.rs +++ b/pmocontrol/src/queue_backend.rs @@ -317,9 +317,7 @@ pub trait QueueBackend { .unwrap_or(0); for (offset, it) in items.into_iter().enumerate() { - snapshot - .items - .insert(insert_pos + offset, it); + snapshot.items.insert(insert_pos + offset, it); } } EnqueueMode::ReplaceAll => { diff --git a/pmocontrol/src/queue_interne.rs b/pmocontrol/src/queue_interne.rs index 5d67485f..cc9770f2 100644 --- a/pmocontrol/src/queue_interne.rs +++ b/pmocontrol/src/queue_interne.rs @@ -52,7 +52,10 @@ impl InternalQueue { } else { None }; - Self { items, current_index } + Self { + items, + current_index, + } } /// Exposes a read-only view of the underlying items. diff --git a/pmodidl_026.txt b/pmodidl_026.txt deleted file mode 100644 index bbbd048a..00000000 --- a/pmodidl_026.txt +++ /dev/null @@ -1,972 +0,0 @@ -=============== pmodidl/Cargo.toml ============ -[package] -name = "pmodidl" -version = "0.1.0" -edition = "2024" - -[dependencies] -serde = "1.0.228" -utoipa = { version = "5.4.0", features = ["axum_extras"] } -utoipa-swagger-ui = { version = "9.0.2", features = ["axum"] } -quick-xml = { version = "0.38.3", features = ["serialize"] } -bevy_reflect = "0.17.1" -bevy_reflect_derive = "0.17.1" -pmoutils = { path = "../pmoutils" } -xmltree = "0.10" -========= End of pmodidl/Cargo.toml =========== - -=============== pmodidl/examples/test_serialization.rs ============ -use pmodidl::{DIDLLite, Item, Resource}; - -fn main() { - let item1 = Item { - id: "test1".to_string(), - parent_id: "root".to_string(), - restricted: Some("1".to_string()), - title: "Test Song".to_string(), - creator: Some("Test Artist".to_string()), - class: "object.item.audioItem.musicTrack".to_string(), - artist: Some("Test Artist".to_string()), - album: None, // Pas d'album - genre: None, - album_art: None, // Pas d'albumArtURI - album_art_pk: None, - date: None, - original_track_number: None, - resources: vec![Resource { - protocol_info: "http-get:*:audio/flac:*".to_string(), - bits_per_sample: Some("16".to_string()), - sample_frequency: Some("44100".to_string()), - nr_audio_channels: Some("2".to_string()), - duration: Some("0:03:00".to_string()), - url: "http://example.com/test.flac".to_string(), - }], - descriptions: vec![], - }; - - let didl = DIDLLite { - xmlns: "urn:schemas-upnp-org:metadata-1-0/DIDL-Lite/".to_string(), - xmlns_upnp: Some("urn:schemas-upnp-org:metadata-1-0/upnp/".to_string()), - xmlns_dc: Some("http://purl.org/dc/elements/1.1/".to_string()), - xmlns_dlna: Some("urn:schemas-dlna-org:metadata-1-0/".to_string()), - xmlns_pv: None, - xmlns_sec: None, - containers: vec![], - items: vec![item1], - }; - - let xml = quick_xml::se::to_string(&didl).expect("Serialization failed"); - - println!("=== Output from quick_xml::se::to_string() ==="); - println!("{}", xml); - println!("\n=== Length: {} bytes ===", xml.len()); - println!( - "\n=== Starts with '{}", xml); - println!("{}", with_decl); -} -========= End of pmodidl/examples/test_serialization.rs =========== - -=============== pmodidl/src/lib.rs ============ -//! # pmodidl - DIDL-Lite Parser -//! -//! Parser et utilitaires pour le format DIDL-Lite utilisé dans UPnP/DLNA. - -use bevy_reflect::Reflect; -use pmoutils::ToXmlElement; -use serde::{Deserialize, Serialize}; -use std::borrow::Cow; -use std::collections::HashSet; -use std::fmt::Write; -use std::io::Cursor; -use xmltree::{Element, XMLNode}; - -// ============= Couche d'abstraction générique ============= - -/// Trait pour tout parser de métadonnées média -pub trait MediaMetadataParser: Sized { - type Error: std::error::Error + Send + Sync + 'static; - - /// Parse une chaîne de métadonnées - fn parse(input: &str) -> Result; - - /// Retourne le format du parser - fn format_name() -> &'static str; -} - -/// Enveloppe générique pour tout type de métadonnées parsées -#[derive(Debug, Clone, Serialize, Deserialize, Reflect)] -pub struct ParsedMetadata { - /// Format du document (ex: "DIDL-Lite", "RSS", etc.) - pub format: String, - - /// Données parsées - pub data: T, - - /// Timestamp du parsing (exclu de la réflexion car SystemTime n'implémente pas Reflect) - #[reflect(ignore)] - #[serde(skip_serializing_if = "Option::is_none")] - pub parsed_at: Option, -} - -impl ParsedMetadata { - pub fn new(format: impl Into, data: T) -> Self { - Self { - format: format.into(), - data, - parsed_at: Some(std::time::SystemTime::now()), - } - } - - /// Transforme les données avec une fonction - pub fn map(self, f: F) -> ParsedMetadata - where - F: FnOnce(T) -> U, - { - ParsedMetadata { - format: self.format, - data: f(self.data), - parsed_at: self.parsed_at, - } - } -} - -/// Fonction helper pour parser et envelopper automatiquement -pub fn parse_metadata(input: &str) -> Result, P::Error> { - let data = P::parse(input)?; - Ok(ParsedMetadata::new(P::format_name(), data)) -} - -// ============= Implémentation pour DIDLLite ============= - -impl MediaMetadataParser for DIDLLite { - type Error = quick_xml::de::DeError; - - fn parse(input: &str) -> Result { - let sanitized = sanitize_singleton_elements(input); - quick_xml::de::from_str(sanitized.as_ref()) - } - - fn format_name() -> &'static str { - "DIDL-Lite" - } -} - -/// Type alias pour faciliter l'utilisation -pub type DidlMetadata = ParsedMetadata; - -// ============= Structures DIDL-Lite ============= - -/// Racine d'un document DIDL-Lite -#[derive(Debug, Clone, Serialize, Deserialize, utoipa::ToSchema, Reflect)] -#[serde(rename = "DIDL-Lite")] -pub struct DIDLLite { - #[serde(rename = "@xmlns")] - pub xmlns: String, - - #[serde(rename = "@xmlns:upnp", skip_serializing_if = "Option::is_none")] - pub xmlns_upnp: Option, - - #[serde(rename = "@xmlns:dc", skip_serializing_if = "Option::is_none")] - pub xmlns_dc: Option, - - #[serde(rename = "@xmlns:dlna", skip_serializing_if = "Option::is_none")] - pub xmlns_dlna: Option, - - #[serde(rename = "@xmlns:sec", skip_serializing_if = "Option::is_none")] - pub xmlns_sec: Option, - - #[serde(rename = "@xmlns:pv", skip_serializing_if = "Option::is_none")] - pub xmlns_pv: Option, - - #[serde(rename = "container", default)] - pub containers: Vec, - - #[serde(rename = "item", default)] - pub items: Vec, -} - -/// Container pouvant contenir d'autres containers ou items -#[derive(Debug, Clone, Serialize, Deserialize, utoipa::ToSchema, Reflect)] -pub struct Container { - #[serde(rename = "@id")] - pub id: String, - - #[serde(rename = "@parentID", default)] - pub parent_id: String, - - #[serde(rename = "@restricted", skip_serializing_if = "Option::is_none")] - pub restricted: Option, - - #[serde(rename = "@childCount", skip_serializing_if = "Option::is_none")] - pub child_count: Option, - - #[serde(rename = "@searchable", skip_serializing_if = "Option::is_none")] - pub searchable: Option, - - #[serde(rename = "dc:title", alias = "title")] - pub title: String, - - #[serde(rename = "upnp:class", alias = "class", default)] - pub class: String, - - #[serde(rename = "container", default)] - pub containers: Vec, - - #[serde(rename = "item", default)] - pub items: Vec, -} - -/// Item représentant un objet audio -#[derive(Debug, Clone, Serialize, Deserialize, utoipa::ToSchema, Reflect)] -pub struct Item { - #[serde(rename = "@id")] - pub id: String, - - #[serde(rename = "@parentID", default)] - pub parent_id: String, - - #[serde(rename = "@restricted", skip_serializing_if = "Option::is_none")] - pub restricted: Option, - - #[serde(rename = "dc:title", alias = "title")] - pub title: String, - - #[serde( - rename = "dc:creator", - alias = "creator", - skip_serializing_if = "Option::is_none" - )] - pub creator: Option, - - #[serde(rename = "upnp:class", alias = "class", default)] - pub class: String, - - #[serde( - rename = "upnp:artist", - alias = "artist", - skip_serializing_if = "Option::is_none" - )] - pub artist: Option, - - #[serde( - rename = "upnp:album", - alias = "album", - skip_serializing_if = "Option::is_none" - )] - pub album: Option, - - #[serde( - rename = "upnp:genre", - alias = "genre", - skip_serializing_if = "Option::is_none" - )] - pub genre: Option, - - #[serde( - rename = "upnp:albumArtURI", - alias = "albumArtURI", - skip_serializing_if = "Option::is_none" - )] - pub album_art: Option, - - #[serde(skip)] - pub album_art_pk: Option, - - #[serde( - rename = "dc:date", - alias = "date", - skip_serializing_if = "Option::is_none" - )] - pub date: Option, - - #[serde( - rename = "upnp:originalTrackNumber", - alias = "originalTrackNumber", - skip_serializing_if = "Option::is_none" - )] - pub original_track_number: Option, - - #[serde(rename = "res", default)] - pub resources: Vec, - - #[serde(rename = "desc", default)] - pub descriptions: Vec, -} - -/// Ressource média (fichier audio) -#[derive(Debug, Clone, Serialize, Deserialize, utoipa::ToSchema, Reflect)] -pub struct Resource { - #[serde(rename = "@protocolInfo", default)] - pub protocol_info: String, - - #[serde(rename = "@bitsPerSample", skip_serializing_if = "Option::is_none")] - pub bits_per_sample: Option, - - #[serde(rename = "@sampleFrequency", skip_serializing_if = "Option::is_none")] - pub sample_frequency: Option, - - #[serde(rename = "@nrAudioChannels", skip_serializing_if = "Option::is_none")] - pub nr_audio_channels: Option, - - #[serde(rename = "@duration", skip_serializing_if = "Option::is_none")] - pub duration: Option, - - #[serde(rename = "$text", default)] - pub url: String, -} - -/// Description avec métadonnées additionnelles (replaygain, etc.) -#[derive(Debug, Clone, Serialize, Deserialize, utoipa::ToSchema, Reflect)] -pub struct Description { - #[serde(rename = "@id", skip_serializing_if = "Option::is_none")] - pub id: Option, - - #[serde(rename = "@nameSpace", skip_serializing_if = "Option::is_none")] - pub namespace: Option, - - #[serde(rename = "track_gain", skip_serializing_if = "Option::is_none")] - pub track_gain: Option, - - #[serde(rename = "track_peak", skip_serializing_if = "Option::is_none")] - pub track_peak: Option, -} - -// ============= Implémentation des méthodes ============= - -impl Default for DIDLLite { - fn default() -> Self { - Self { - xmlns: "urn:schemas-upnp-org:metadata-1-0/DIDL-Lite/".to_string(), - xmlns_upnp: Some("urn:schemas-upnp-org:metadata-1-0/upnp/".to_string()), - xmlns_dc: Some("http://purl.org/dc/elements/1.1/".to_string()), - xmlns_dlna: None, - xmlns_sec: None, - xmlns_pv: None, - containers: Vec::new(), - items: Vec::new(), - } - } -} - -impl DIDLLite { - /// Applique les namespaces sur un élément xmltree. - fn set_namespaces(&self, elem: &mut Element) { - elem.attributes.insert("xmlns".into(), self.xmlns.clone()); - if let Some(ref upnp) = self.xmlns_upnp { - elem.attributes.insert("xmlns:upnp".into(), upnp.clone()); - } - if let Some(ref dc) = self.xmlns_dc { - elem.attributes.insert("xmlns:dc".into(), dc.clone()); - } - if let Some(ref dlna) = self.xmlns_dlna { - elem.attributes.insert("xmlns:dlna".into(), dlna.clone()); - } - if let Some(ref sec) = self.xmlns_sec { - elem.attributes.insert("xmlns:sec".into(), sec.clone()); - } - if let Some(ref pv) = self.xmlns_pv { - elem.attributes.insert("xmlns:pv".into(), pv.clone()); - } - } - - /// Itère sur tous les containers de manière récursive - pub fn all_containers(&self) -> impl Iterator { - AllContainersIter::new(&self.containers) - } - - /// Itère sur tous les items de manière récursive - pub fn all_items(&self) -> impl Iterator { - AllItemsIter::new(&self.containers, &self.items) - } - - /// Trouve un container par ID - pub fn get_container_by_id(&self, id: &str) -> Option<&Container> { - self.all_containers().find(|c| c.id == id) - } - - /// Trouve un item par ID - pub fn get_item_by_id(&self, id: &str) -> Option<&Item> { - self.all_items().find(|i| i.id == id) - } - - /// Filtre les containers - pub fn filter_containers(&self, predicate: F) -> impl Iterator - where - F: Fn(&Container) -> bool, - { - self.all_containers().filter(move |c| predicate(c)) - } - - /// Filtre les items - pub fn filter_items(&self, predicate: F) -> impl Iterator - where - F: Fn(&Item) -> bool, - { - self.all_items().filter(move |i| predicate(i)) - } - - /// Génère une représentation Markdown - pub fn to_markdown(&self) -> String { - let mut buf = String::new(); - buf.push_str("### DIDL-Lite Document\n\n"); - - if !self.containers.is_empty() { - buf.push_str("#### Containers\n\n"); - for container in &self.containers { - container.write_markdown(&mut buf, 0); - } - } - - if !self.items.is_empty() { - buf.push_str("#### Items\n\n"); - for item in &self.items { - item.write_markdown(&mut buf, 0); - } - } - - buf - } -} - -impl Container { - /// Itère sur tous les containers enfants récursivement - pub fn all_containers(&self) -> impl Iterator { - AllContainersIter::new(&self.containers) - } - - /// Itère sur tous les items de ce container et ses enfants - pub fn all_items(&self) -> impl Iterator { - AllItemsIter::new(&self.containers, &self.items) - } - - fn write_markdown(&self, buf: &mut String, depth: usize) { - let indent = " ".repeat(depth); - - writeln!(buf, "{}- **Container**: {}", indent, self.title).unwrap(); - writeln!(buf, "{} - ID: `{}`", indent, self.id).unwrap(); - writeln!(buf, "{} - ParentID: `{}`", indent, self.parent_id).unwrap(); - writeln!(buf, "{} - Class: `{}`", indent, self.class).unwrap(); - - if let Some(ref restricted) = self.restricted { - writeln!(buf, "{} - Restricted: `{}`", indent, restricted).unwrap(); - } - if let Some(ref count) = self.child_count { - writeln!(buf, "{} - ChildCount: `{}`", indent, count).unwrap(); - } - - if !self.containers.is_empty() { - writeln!(buf, "{} - Subcontainers:", indent).unwrap(); - for sub in &self.containers { - sub.write_markdown(buf, depth + 2); - } - } - - if !self.items.is_empty() { - writeln!(buf, "{} - Items:", indent).unwrap(); - for item in &self.items { - item.write_markdown(buf, depth + 2); - } - } - - buf.push('\n'); - } -} - -impl Item { - /// Formate la date pour satisfaire les clients stricts (YYYY-MM-DD). Si seule - /// l'année est fournie, on complète avec "-01-01". - fn normalized_date(&self) -> Option { - self.date.as_ref().map(|d| { - let trimmed = d.trim(); - if trimmed.len() == 4 && trimmed.chars().all(|c| c.is_ascii_digit()) { - format!("{}-01-01", trimmed) - } else { - trimmed.to_string() - } - }) - } - - /// Itère sur les ressources audio uniquement - pub fn audio_resources(&self) -> impl Iterator { - self.resources - .iter() - .filter(|r| r.protocol_info.contains("audio/")) - } - - /// Retourne la ressource principale (première disponible) - pub fn primary_resource(&self) -> Option<&Resource> { - self.resources.first() - } - - /// Itère sur les métadonnées sous forme de paires clé-valeur - pub fn metadata(&self) -> impl Iterator { - let mut pairs = Vec::new(); - - pairs.push(("title", self.title.as_str())); - - if let Some(ref artist) = self.artist { - pairs.push(("artist", artist.as_str())); - } - if let Some(ref album) = self.album { - pairs.push(("album", album.as_str())); - } - if let Some(ref genre) = self.genre { - pairs.push(("genre", genre.as_str())); - } - if let Some(ref date) = self.date { - pairs.push(("date", date.as_str())); - } - if let Some(ref track) = self.original_track_number { - pairs.push(("trackNumber", track.as_str())); - } - - for desc in &self.descriptions { - if let Some(ref gain) = desc.track_gain { - pairs.push(("replayGain", gain.as_str())); - } - if let Some(ref peak) = desc.track_peak { - pairs.push(("replayPeak", peak.as_str())); - } - } - - pairs.into_iter() - } - - fn write_markdown(&self, buf: &mut String, depth: usize) { - let indent = " ".repeat(depth); - - writeln!(buf, "{}- **Item**: {}", indent, self.title).unwrap(); - writeln!(buf, "{} - ID: `{}`", indent, self.id).unwrap(); - writeln!(buf, "{} - ParentID: `{}`", indent, self.parent_id).unwrap(); - writeln!(buf, "{} - Class: `{}`", indent, self.class).unwrap(); - - if let Some(ref creator) = self.creator { - writeln!(buf, "{} - Creator: {}", indent, creator).unwrap(); - } - if let Some(ref artist) = self.artist { - writeln!(buf, "{} - Artist: {}", indent, artist).unwrap(); - } - if let Some(ref album) = self.album { - writeln!(buf, "{} - Album: {}", indent, album).unwrap(); - } - if let Some(ref genre) = self.genre { - writeln!(buf, "{} - Genre: {}", indent, genre).unwrap(); - } - if let Some(ref art) = self.album_art { - writeln!(buf, "{} - Album Art: ![Cover]({})", indent, art).unwrap(); - } - if let Some(ref date) = self.date { - writeln!(buf, "{} - Date: {}", indent, date).unwrap(); - } - if let Some(ref track) = self.original_track_number { - writeln!(buf, "{} - Track: {}", indent, track).unwrap(); - } - - if !self.resources.is_empty() { - writeln!(buf, "{} - Resources:", indent).unwrap(); - for res in &self.resources { - writeln!(buf, "{} - URL: {}", indent, res.url).unwrap(); - writeln!(buf, "{} - Protocol: `{}`", indent, res.protocol_info).unwrap(); - if let Some(ref dur) = res.duration { - writeln!(buf, "{} - Duration: `{}`", indent, dur).unwrap(); - } - if let Some(ref bits) = res.bits_per_sample { - writeln!(buf, "{} - BitsPerSample: `{}`", indent, bits).unwrap(); - } - if let Some(ref freq) = res.sample_frequency { - writeln!(buf, "{} - SampleFrequency: `{}`", indent, freq).unwrap(); - } - if let Some(ref channels) = res.nr_audio_channels { - writeln!(buf, "{} - Channels: `{}`", indent, channels).unwrap(); - } - } - } - - if !self.descriptions.is_empty() { - writeln!(buf, "{} - Descriptions:", indent).unwrap(); - for desc in &self.descriptions { - if let Some(ref ns) = desc.namespace { - writeln!(buf, "{} - Namespace: `{}`", indent, ns).unwrap(); - } - if let Some(ref gain) = desc.track_gain { - writeln!(buf, "{} - Track Gain: `{}`", indent, gain).unwrap(); - } - if let Some(ref peak) = desc.track_peak { - writeln!(buf, "{} - Track Peak: `{}`", indent, peak).unwrap(); - } - } - } - - buf.push('\n'); - } -} - -// ============= Implémentation ToXmlElement ============= - -fn text_element(name: &str, value: &str) -> Element { - let mut e = Element::new(name); - e.children.push(XMLNode::Text(value.to_string())); - e -} - -const SINGLETON_ELEMENTS: &[&str] = &[ - "dc:title", - "title", - "dc:creator", - "creator", - "upnp:class", - "class", - "upnp:artist", - "artist", - "upnp:album", - "album", - "upnp:genre", - "genre", - "upnp:albumArtURI", - "albumArtURI", - "dc:date", - "date", - "upnp:originalTrackNumber", - "originalTrackNumber", -]; - -fn sanitize_singleton_elements(input: &str) -> Cow<'_, str> { - if !SINGLETON_ELEMENTS.iter().any(|tag| input.contains(tag)) { - return Cow::Borrowed(input); - } - - let mut cursor = Cursor::new(input.as_bytes()); - let mut root = match Element::parse(&mut cursor) { - Ok(elem) => elem, - Err(_) => return Cow::Borrowed(input), - }; - - if !dedup_singleton_children(&mut root) { - return Cow::Borrowed(input); - } - - let mut buf = Vec::new(); - if root.write(&mut buf).is_err() { - return Cow::Borrowed(input); - } - - String::from_utf8(buf) - .map(Cow::Owned) - .unwrap_or_else(|_| Cow::Borrowed(input)) -} - -fn dedup_singleton_children(element: &mut Element) -> bool { - let mut changed = false; - let mut seen: HashSet = HashSet::new(); - let mut idx = 0; - - while idx < element.children.len() { - let mut remove_current = false; - if let XMLNode::Element(child_elem) = &mut element.children[idx] { - if SINGLETON_ELEMENTS.contains(&child_elem.name.as_str()) - && !seen.insert(child_elem.name.clone()) - { - remove_current = true; - changed = true; - } else if dedup_singleton_children(child_elem) { - changed = true; - } - } - - if remove_current { - element.children.remove(idx); - } else { - idx += 1; - } - } - - changed -} - -impl ToXmlElement for DIDLLite { - fn to_xml_element(&self) -> Element { - let mut root = Element::new("DIDL-Lite"); - self.set_namespaces(&mut root); - for c in &self.containers { - root.children.push(XMLNode::Element(c.to_xml_element())); - } - for i in &self.items { - root.children.push(XMLNode::Element(i.to_xml_element())); - } - root - } -} - -impl ToXmlElement for Container { - fn to_xml_element(&self) -> Element { - let mut elem = Element::new("container"); - elem.attributes.insert("id".into(), self.id.clone()); - elem.attributes - .insert("parentID".into(), self.parent_id.clone()); - if let Some(ref r) = self.restricted { - elem.attributes.insert("restricted".into(), r.clone()); - } - if let Some(ref cc) = self.child_count { - elem.attributes.insert("childCount".into(), cc.clone()); - } - if let Some(ref searchable) = self.searchable { - elem.attributes - .insert("searchable".into(), searchable.clone()); - } - - elem.children - .push(XMLNode::Element(text_element("dc:title", &self.title))); - elem.children - .push(XMLNode::Element(text_element("upnp:class", &self.class))); - - for c in &self.containers { - elem.children.push(XMLNode::Element(c.to_xml_element())); - } - for i in &self.items { - elem.children.push(XMLNode::Element(i.to_xml_element())); - } - - elem - } -} - -impl ToXmlElement for Item { - fn to_xml_element(&self) -> Element { - let mut elem = Element::new("item"); - elem.attributes.insert("id".into(), self.id.clone()); - elem.attributes - .insert("parentID".into(), self.parent_id.clone()); - if let Some(ref r) = self.restricted { - elem.attributes.insert("restricted".into(), r.clone()); - } - - elem.children - .push(XMLNode::Element(text_element("dc:title", &self.title))); - - if let Some(ref c) = self.creator { - elem.children - .push(XMLNode::Element(text_element("dc:creator", c))); - } - - elem.children - .push(XMLNode::Element(text_element("upnp:class", &self.class))); - - if let Some(ref artist) = self.artist { - elem.children - .push(XMLNode::Element(text_element("upnp:artist", artist))); - } - if let Some(ref album) = self.album { - elem.children - .push(XMLNode::Element(text_element("upnp:album", album))); - } - if let Some(ref genre) = self.genre { - elem.children - .push(XMLNode::Element(text_element("upnp:genre", genre))); - } - if let Some(ref art) = self.album_art { - elem.children - .push(XMLNode::Element(text_element("upnp:albumArtURI", art))); - } - if let Some(date) = self.normalized_date() { - elem.children - .push(XMLNode::Element(text_element("dc:date", &date))); - } - if let Some(ref track) = self.original_track_number { - elem.children.push(XMLNode::Element(text_element( - "upnp:originalTrackNumber", - track, - ))); - } - - for res in &self.resources { - elem.children.push(XMLNode::Element(res.to_xml_element())); - } - for desc in &self.descriptions { - elem.children.push(XMLNode::Element(desc.to_xml_element())); - } - - elem - } -} - -impl ToXmlElement for Resource { - fn to_xml_element(&self) -> Element { - let mut elem = Element::new("res"); - elem.attributes - .insert("protocolInfo".into(), self.protocol_info.clone()); - if let Some(ref bps) = self.bits_per_sample { - elem.attributes.insert("bitsPerSample".into(), bps.clone()); - } - if let Some(ref freq) = self.sample_frequency { - elem.attributes - .insert("sampleFrequency".into(), freq.clone()); - } - if let Some(ref ch) = self.nr_audio_channels { - elem.attributes.insert("nrAudioChannels".into(), ch.clone()); - } - if let Some(ref dur) = self.duration { - elem.attributes.insert("duration".into(), dur.clone()); - } - elem.children.push(XMLNode::Text(self.url.clone())); - elem - } -} - -impl ToXmlElement for Description { - fn to_xml_element(&self) -> Element { - let mut elem = Element::new("desc"); - if let Some(ref id) = self.id { - elem.attributes.insert("id".into(), id.clone()); - } - if let Some(ref ns) = self.namespace { - elem.attributes.insert("nameSpace".into(), ns.clone()); - } - if let Some(ref gain) = self.track_gain { - elem.children - .push(XMLNode::Element(text_element("track_gain", gain))); - } - if let Some(ref peak) = self.track_peak { - elem.children - .push(XMLNode::Element(text_element("track_peak", peak))); - } - elem - } -} - -// ============= Itérateurs personnalisés ============= - -struct AllContainersIter<'a> { - stack: Vec<&'a Container>, -} - -impl<'a> AllContainersIter<'a> { - fn new(containers: &'a [Container]) -> Self { - Self { - stack: containers.iter().collect(), - } - } -} - -impl<'a> Iterator for AllContainersIter<'a> { - type Item = &'a Container; - - fn next(&mut self) -> Option { - self.stack.pop().map(|container| { - // Ajouter les enfants à la pile - self.stack.extend(container.containers.iter()); - container - }) - } -} - -struct AllItemsIter<'a> { - containers: Vec<&'a Container>, - current_items: std::slice::Iter<'a, Item>, -} - -impl<'a> AllItemsIter<'a> { - fn new(containers: &'a [Container], items: &'a [Item]) -> Self { - Self { - containers: containers.iter().collect(), - current_items: items.iter(), - } - } -} - -impl<'a> Iterator for AllItemsIter<'a> { - type Item = &'a Item; - - fn next(&mut self) -> Option { - loop { - if let Some(item) = self.current_items.next() { - return Some(item); - } - - let container = self.containers.pop()?; - self.containers.extend(container.containers.iter()); - self.current_items = container.items.iter(); - } - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_parse_simple_didl() { - let xml = r#" - - - Test Song - object.item.audioItem.musicTrack - http://example.com/song.mp3 - - - "#; - - let didl = DIDLLite::parse(xml).unwrap(); - assert_eq!(didl.items.len(), 1); - assert_eq!(didl.items[0].title, "Test Song"); - } - - #[test] - fn test_parse_without_namespaces() { - // Teste un XML sans namespaces explicites (devices UPnP laxistes) - let xml = r#" - - - Test Song - object.item.audioItem.musicTrack - http://example.com/song.mp3 - - - "#; - - let didl = DIDLLite::parse(xml).unwrap(); - assert_eq!(didl.items.len(), 1); - assert_eq!(didl.items[0].title, "Test Song"); - } - - #[test] - fn test_generic_parser() { - let xml = r#" - - - "#; - - // Utiliser le parser générique - let metadata: DidlMetadata = parse_metadata(xml).unwrap(); - - assert_eq!(metadata.format, "DIDL-Lite"); - assert!(metadata.parsed_at.is_some()); - } - - #[test] - fn test_metadata_map() { - let xml = r#" - - - "#; - - let metadata: DidlMetadata = parse_metadata(xml).unwrap(); - - // Transformer les données - let item_count = metadata.map(|didl| didl.items.len()); - - assert_eq!(item_count.format, "DIDL-Lite"); - assert_eq!(item_count.data, 0); - } -} -========= End of pmodidl/src/lib.rs =========== - diff --git a/pmoparadise_011.txt b/pmoparadise_011.txt deleted file mode 100644 index 6c10f232..00000000 --- a/pmoparadise_011.txt +++ /dev/null @@ -1,7970 +0,0 @@ ------------- pmoparadise/src/channels.rs ---------- -//! Radio Paradise channel definitions -//! -//! This module defines the available Radio Paradise channels and their metadata. - -use std::str::FromStr; - -/// Logical identifier for a Radio Paradise channel. -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] -pub enum ParadiseChannelKind { - Main, - Mellow, - Rock, - Eclectic, -} - -impl ParadiseChannelKind { - pub const fn id(self) -> u8 { - match self { - Self::Main => 0, - Self::Mellow => 1, - Self::Rock => 2, - Self::Eclectic => 3, - } - } - - pub const fn slug(self) -> &'static str { - match self { - Self::Main => "main", - Self::Mellow => "mellow", - Self::Rock => "rock", - Self::Eclectic => "eclectic", - } - } - - pub const fn display_name(self) -> &'static str { - match self { - Self::Main => "Main Mix", - Self::Mellow => "Mellow Mix", - Self::Rock => "Rock Mix", - Self::Eclectic => "Eclectic Mix", - } - } - - pub const fn description(self) -> &'static str { - match self { - Self::Main => "Eclectic mix of rock, world, electronica, and more", - Self::Mellow => "Mellower, less aggressive music", - Self::Rock => "Heavier, more guitar-driven music", - Self::Eclectic => "Curated worldwide selection", - } - } -} - -impl FromStr for ParadiseChannelKind { - type Err = anyhow::Error; - - fn from_str(s: &str) -> std::result::Result { - match s.to_ascii_lowercase().as_str() { - "main" | "0" => Ok(Self::Main), - "mellow" | "1" => Ok(Self::Mellow), - "rock" | "2" => Ok(Self::Rock), - "eclectic" | "3" => Ok(Self::Eclectic), - other => Err(anyhow::anyhow!("Unknown Radio Paradise channel: {}", other)), - } - } -} - -/// Metadata descriptor for a channel. -#[derive(Debug, Clone, Copy)] -pub struct ChannelDescriptor { - pub kind: ParadiseChannelKind, - pub id: u8, - pub slug: &'static str, - pub display_name: &'static str, - pub description: &'static str, -} - -impl ChannelDescriptor { - pub const fn new(kind: ParadiseChannelKind) -> Self { - Self { - id: kind.id(), - slug: kind.slug(), - display_name: kind.display_name(), - description: kind.description(), - kind, - } - } -} - -/// All available Radio Paradise channels -pub const ALL_CHANNELS: [ChannelDescriptor; 4] = [ - ChannelDescriptor::new(ParadiseChannelKind::Main), - ChannelDescriptor::new(ParadiseChannelKind::Mellow), - ChannelDescriptor::new(ParadiseChannelKind::Rock), - ChannelDescriptor::new(ParadiseChannelKind::Eclectic), -]; - -/// Returns the maximum valid channel ID -pub const fn max_channel_id() -> u8 { - (ALL_CHANNELS.len() - 1) as u8 -} - -/// Default maximum number of tracks to keep in history -/// -/// This is used as the default if not configured via pmoconfig. -/// Value: 100 tracks - represents ~5-8 hours of playback history -pub const HISTORY_DEFAULT_MAX_TRACKS: usize = 100; - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_channel_ids() { - assert_eq!(ParadiseChannelKind::Main.id(), 0); - assert_eq!(ParadiseChannelKind::Mellow.id(), 1); - assert_eq!(ParadiseChannelKind::Rock.id(), 2); - assert_eq!(ParadiseChannelKind::Eclectic.id(), 3); - } - - #[test] - fn test_max_channel_id() { - assert_eq!(max_channel_id(), 3); - } - - #[test] - fn test_all_channels_length() { - assert_eq!(ALL_CHANNELS.len(), 4); - } - - #[test] - fn test_channel_from_str() { - assert!(matches!( - "main".parse::(), - Ok(ParadiseChannelKind::Main) - )); - assert!(matches!( - "0".parse::(), - Ok(ParadiseChannelKind::Main) - )); - assert!("invalid".parse::().is_err()); - } -} --------End of pmoparadise/src/channels.rs --------- - ------------- pmoparadise/src/client.rs ---------- -//! HTTP client for Radio Paradise API - -use crate::error::{Error, Result}; -use crate::models::{Block, EventId, NowPlaying}; -use reqwest::Client; -use std::time::Duration; -use url::Url; - -/// Default Radio Paradise API base URL -pub const DEFAULT_API_BASE: &str = "https://api.radioparadise.com/api"; - -/// Default block base URL (channel is appended) -pub const DEFAULT_BLOCK_BASE: &str = "https://apps.radioparadise.com/blocks/chan"; - -/// Default image base URL -pub const DEFAULT_IMAGE_BASE: &str = "https://img.radioparadise.com/"; - -/// Default timeout for metadata HTTP requests -pub const DEFAULT_REQUEST_TIMEOUT_SECS: u64 = 30; - -/// Default timeout for large block downloads/streams -/// IMPORTANT: Radio Paradise blocks can be ~20 minutes long, and with backpressure -/// from the audio pipeline, the HTTP stream must stay open for the entire duration. -/// Setting this to 2 hours to safely handle even the longest blocks. -pub const DEFAULT_BLOCK_TIMEOUT_SECS: u64 = 7200; // 2 hours - -/// Default User-Agent -pub const DEFAULT_USER_AGENT: &str = "pmoparadise/0.1.0"; - -/// Default channel (0 = main mix) -pub const DEFAULT_CHANNEL: u8 = 0; - -/// Radio Paradise HTTP client -/// -/// This client provides access to Radio Paradise's streaming API, -/// including metadata retrieval and block streaming. -/// -/// # Example -/// -/// ```no_run -/// use pmoparadise::RadioParadiseClient; -/// -/// #[tokio::main] -/// async fn main() -> Result<(), Box> { -/// let client = RadioParadiseClient::new().await?; -/// let now_playing = client.now_playing().await?; -/// println!("Now playing: {} - {}", -/// now_playing.current_song.as_ref().unwrap().artist, -/// now_playing.current_song.as_ref().unwrap().title); -/// Ok(()) -/// } -/// ``` -#[derive(Debug, Clone)] -pub struct RadioParadiseClient { - pub(crate) client: Client, - api_base: String, - channel: u8, - pub(crate) request_timeout: Duration, - pub(crate) block_timeout: Duration, - next_block_url: Option, -} - -impl RadioParadiseClient { - /// Create a new client with default settings - /// - /// Uses FLAC quality and channel 0 (main mix) - pub async fn new() -> Result { - Self::builder().build().await - } - - /// Create a builder for configuring the client - pub fn builder() -> ClientBuilder { - ClientBuilder::default() - } - - /// Create a client with a custom reqwest::Client - /// - /// Useful for sharing HTTP connection pools or custom proxy settings - /// - /// Note: Uses default settings (channel 0, default timeouts). - /// For more control, use `ClientBuilder::default().client(client).build()`. - pub fn with_client(client: Client) -> Self { - Self { - client, - api_base: DEFAULT_API_BASE.to_string(), - channel: DEFAULT_CHANNEL, - request_timeout: Duration::from_secs(DEFAULT_REQUEST_TIMEOUT_SECS), - block_timeout: Duration::from_secs(DEFAULT_BLOCK_TIMEOUT_SECS), - next_block_url: None, - } - } - - /// Get the current channel (0 = main mix) - pub fn channel(&self) -> u8 { - self.channel - } - - /// Get the block base URL for this client's channel - pub fn block_base(&self) -> String { - format!("{}/{}", DEFAULT_BLOCK_BASE, self.channel) - } - - /// Clone the client with a different channel while preserving other settings. - pub fn clone_with_channel(&self, channel: u8) -> Self { - let mut cloned = self.clone(); - cloned.channel = channel; - cloned.next_block_url = None; - cloned - } - - /// Get a block by event ID - /// - /// If `event` is None, returns the current block. - /// - /// # Arguments - /// - /// * `event` - Optional event ID to fetch a specific block - /// - /// # Example - /// - /// ```no_run - /// # use pmoparadise::RadioParadiseClient; - /// # #[tokio::main] - /// # async fn main() -> Result<(), Box> { - /// let client = RadioParadiseClient::new().await?; - /// - /// // Get current block - /// let current = client.get_block(None).await?; - /// println!("Current block: {} songs", current.song_count()); - /// - /// // Get next block - /// let next = client.get_block(Some(current.end_event)).await?; - /// println!("Next block: {} songs", next.song_count()); - /// # Ok(()) - /// # } - /// ``` - pub async fn get_block(&self, event: Option) -> Result { - let mut url = Url::parse(&format!("{}/get_block", self.api_base))?; - - url.query_pairs_mut() - .append_pair("bitrate", "4") // FLAC lossless - .append_pair("info", "true") - // RP API expects `chan` rather than `channel` for channel selection. - .append_pair("chan", &self.channel.to_string()); - - if let Some(event_id) = event { - url.query_pairs_mut() - .append_pair("event", &event_id.to_string()); - } - - #[cfg(feature = "logging")] - tracing::debug!("Fetching block: {}", url); - - let response = self - .client - .get(url) - .timeout(self.request_timeout) - .send() - .await?; - - if !response.status().is_success() { - return Err(Error::other(format!( - "API returned error status: {}", - response.status() - ))); - } - - let mut block: Block = response.json().await?; - - // Normalize protocol-relative URLs from API (//img.radioparadise.com/) - if let Some(ref base) = block.image_base { - if base.starts_with("//") { - block.image_base = Some(format!("https:{}", base)); - } - } else { - // Fallback if API doesn't provide image_base (should never happen) - block.image_base = Some(DEFAULT_IMAGE_BASE.to_string()); - } - - #[cfg(feature = "logging")] - tracing::debug!( - "Received block: event={}, songs={}", - block.event, - block.song_count() - ); - - Ok(block) - } - - /// Get the currently playing block and song - /// - /// Returns a `NowPlaying` struct with the current block and - /// an estimate of which song is currently playing (first song). - /// - /// Note: Without real-time synchronization, we assume playback - /// starts from the beginning of the block. - pub async fn now_playing(&self) -> Result { - let block = self.get_block(None).await?; - Ok(NowPlaying::from_block(block)) - } - - /// Prefetch metadata for the next block - /// - /// Stores the next block URL internally for seamless transitions. - /// Call this before the current block finishes playing. - /// - /// # Arguments - /// - /// * `current` - The currently playing block - pub async fn prefetch_next(&mut self, current: &Block) -> Result<()> { - let next_block = self.get_block(Some(current.end_event)).await?; - self.next_block_url = Some(next_block.url.clone()); - - #[cfg(feature = "logging")] - tracing::debug!( - "Prefetched next block: {} -> {}", - current.end_event, - next_block.event - ); - - Ok(()) - } - - /// Get the prefetched next block URL - pub fn next_block_url(&self) -> Option<&str> { - self.next_block_url.as_deref() - } - - /// Clear the prefetched next block URL - pub fn clear_next_block(&mut self) { - self.next_block_url = None; - } - - /// Get the internal HTTP client - pub fn http_client(&self) -> &Client { - &self.client - } -} - -/// Builder for configuring a RadioParadiseClient -#[derive(Debug)] -pub struct ClientBuilder { - client: Option, - api_base: String, - channel: u8, - request_timeout: Duration, - block_timeout: Duration, - user_agent: String, - proxy: Option, -} - -impl Default for ClientBuilder { - fn default() -> Self { - Self { - client: None, - api_base: DEFAULT_API_BASE.to_string(), - channel: DEFAULT_CHANNEL, - request_timeout: Duration::from_secs(DEFAULT_REQUEST_TIMEOUT_SECS), - block_timeout: Duration::from_secs(DEFAULT_BLOCK_TIMEOUT_SECS), - user_agent: DEFAULT_USER_AGENT.to_string(), - proxy: None, - } - } -} - -impl ClientBuilder { - /// Create a new builder with default settings - pub fn new() -> Self { - Self::default() - } - - /// Set a custom HTTP client - pub fn client(mut self, client: Client) -> Self { - self.client = Some(client); - self - } - - /// Set the API base URL - pub fn api_base(mut self, url: impl Into) -> Self { - self.api_base = url.into(); - self - } - - /// Set the channel (0 = main mix, 1 = mellow, 2 = rock, 3 = world/etc) - pub fn channel(mut self, channel: u8) -> Self { - self.channel = channel; - self - } - - /// Set the request timeout - pub fn timeout(mut self, timeout: Duration) -> Self { - self.request_timeout = timeout; - self - } - - /// Set the timeout specifically for block downloads/streams - pub fn block_timeout(mut self, timeout: Duration) -> Self { - self.block_timeout = timeout; - self - } - - /// Set a custom User-Agent header - pub fn user_agent(mut self, user_agent: impl Into) -> Self { - self.user_agent = user_agent.into(); - self - } - - /// Set a proxy URL - pub fn proxy(mut self, proxy: impl Into) -> Self { - self.proxy = Some(proxy.into()); - self - } - - /// Build the client - pub async fn build(self) -> Result { - let client = if let Some(client) = self.client { - client - } else { - let mut builder = Client::builder() - .user_agent(&self.user_agent) - .timeout(self.request_timeout); - - if let Some(proxy_url) = &self.proxy { - let proxy = reqwest::Proxy::all(proxy_url) - .map_err(|e| Error::other(format!("Invalid proxy: {}", e)))?; - builder = builder.proxy(proxy); - } - - builder.build()? - }; - - Ok(RadioParadiseClient { - client, - api_base: self.api_base, - channel: self.channel, - request_timeout: self.request_timeout, - block_timeout: self.block_timeout, - next_block_url: None, - }) - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_builder_defaults() { - let builder = ClientBuilder::default(); - assert_eq!(builder.api_base, DEFAULT_API_BASE); - assert_eq!(builder.channel, DEFAULT_CHANNEL); - } -} --------End of pmoparadise/src/client.rs --------- - ------------- pmoparadise/src/config_ext.rs ---------- -//! Extension pour intégrer Radio Paradise dans pmoconfig -//! -//! Ce module fournit le trait `RadioParadiseConfigExt` qui permet d'ajouter facilement -//! des méthodes de gestion de la configuration Radio Paradise à pmoconfig::Config. -//! -//! La configuration est minimale - seulement ce qui doit vraiment être configurable : -//! - Activation/désactivation de la source -//! -//! # Exemple -//! -//! ```rust,ignore -//! use pmoconfig::get_config; -//! use pmoparadise::RadioParadiseConfigExt; -//! -//! let config = get_config(); -//! -//! // Check if enabled -//! if !config.get_paradise_enabled()? { -//! println!("Radio Paradise is disabled"); -//! return Ok(()); -//! } -//! ``` - -use crate::{channels::ParadiseChannelKind, client::DEFAULT_CHANNEL}; -use anyhow::Result; -use pmoconfig::Config; -use serde_yaml::Value; - -/// Trait d'extension pour gérer la configuration Radio Paradise dans pmoconfig -/// -/// Ce trait étend `pmoconfig::Config` avec des méthodes spécifiques -/// à la configuration minimale de Radio Paradise. -/// -/// # Auto-persist des valeurs par défaut -/// -/// Le getter persiste automatiquement la valeur par défaut dans la -/// configuration si elle n'existe pas encore. Cela permet à l'utilisateur de -/// voir la configuration effective dans le fichier YAML et de la modifier facilement. -/// -/// # Exemple -/// -/// ```rust,ignore -/// use pmoconfig::get_config; -/// use pmoparadise::RadioParadiseConfigExt; -/// -/// let config = get_config(); -/// -/// // Premier appel : persiste "enabled: true" dans la config et retourne true -/// let enabled = config.get_paradise_enabled()?; -/// -/// // L'utilisateur peut maintenant éditer cette valeur dans le fichier YAML -/// ``` -pub trait RadioParadiseConfigExt { - /// Vérifie si Radio Paradise est activé - /// - /// # Returns - /// - /// `true` si la source est activée (default), `false` sinon. - /// - /// Si la valeur n'existe pas dans la configuration, elle est automatiquement - /// définie à `true` (activé par défaut) et persistée. - /// - /// # Exemple - /// - /// ```rust,ignore - /// if config.get_paradise_enabled()? { - /// // Initialize Radio Paradise... - /// } - /// ``` - fn get_paradise_enabled(&self) -> Result; - - /// Active ou désactive Radio Paradise - /// - /// # Arguments - /// - /// * `enabled` - `true` pour activer, `false` pour désactiver - /// - /// # Exemple - /// - /// ```rust,ignore - /// // Disable Radio Paradise - /// config.set_paradise_enabled(false)?; - /// ``` - fn set_paradise_enabled(&self, enabled: bool) -> Result<()>; - - /// Récupère le channel par défaut - /// - /// # Returns - /// - /// Le channel par défaut (0 = Main Mix par défaut). - /// - /// Si la valeur n'existe pas dans la configuration, elle est automatiquement - /// définie à "main" et persistée. - /// - /// # Channels disponibles - /// - /// Peut être configuré comme chaîne de caractères ou nombre : - /// - "main" ou 0 = Main Mix (eclectic, diverse mix) - /// - "mellow" ou 1 = Mellow Mix (smooth, chilled music) - /// - "rock" ou 2 = Rock Mix (classic & modern rock) - /// - "eclectic" ou 3 = Eclectic Mix (global sounds) - /// - /// # Exemple de configuration YAML - /// - /// ```yaml - /// sources: - /// radio_paradise: - /// default_channel: mellow # or 1 - /// ``` - /// - /// # Exemple d'utilisation - /// - /// ```rust,ignore - /// let channel = config.get_paradise_default_channel()?; - /// let client = RadioParadiseClient::builder().channel(channel).build().await?; - /// ``` - fn get_paradise_default_channel(&self) -> Result; - - /// Définit le channel par défaut - /// - /// # Arguments - /// - /// * `channel` - Le channel (0-3) - /// - /// La valeur est stockée sous forme de nom convivial ("main", "mellow", etc.) - /// dans le fichier de configuration. - /// - /// # Exemple - /// - /// ```rust,ignore - /// use pmoparadise::channels::ParadiseChannelKind; - /// - /// // Use Mellow Mix by default - /// config.set_paradise_default_channel(ParadiseChannelKind::Mellow.id())?; - /// // Or simply: - /// config.set_paradise_default_channel(1)?; - /// ``` - fn set_paradise_default_channel(&self, channel: u8) -> Result<()>; -} - -impl RadioParadiseConfigExt for Config { - fn get_paradise_enabled(&self) -> Result { - match self.get_value(&["sources", "radio_paradise", "enabled"]) { - Ok(Value::Bool(b)) => Ok(b), - _ => { - // Use default (enabled) and persist it - self.set_paradise_enabled(true)?; - Ok(true) - } - } - } - - fn set_paradise_enabled(&self, enabled: bool) -> Result<()> { - self.set_value( - &["sources", "radio_paradise", "enabled"], - Value::Bool(enabled), - ) - } - - fn get_paradise_default_channel(&self) -> Result { - match self.get_value(&["sources", "radio_paradise", "default_channel"]) { - Ok(Value::String(s)) => { - // Try to parse as channel name (e.g., "main", "mellow", etc.) - match s.parse::() { - Ok(kind) => Ok(kind.id()), - Err(_) => { - // Invalid channel name, use default - self.set_paradise_default_channel(DEFAULT_CHANNEL)?; - Ok(DEFAULT_CHANNEL) - } - } - } - Ok(Value::Number(n)) => { - // Accept numeric channel ID (0-3) - if let Some(ch) = n.as_u64() { - if ch <= 3 { - Ok(ch as u8) - } else { - // Invalid channel number, use default - self.set_paradise_default_channel(DEFAULT_CHANNEL)?; - Ok(DEFAULT_CHANNEL) - } - } else { - // Not a valid number, use default - self.set_paradise_default_channel(DEFAULT_CHANNEL)?; - Ok(DEFAULT_CHANNEL) - } - } - _ => { - // Use default and persist it as "main" (user-friendly) - self.set_value( - &["sources", "radio_paradise", "default_channel"], - Value::String("main".to_string()), - )?; - Ok(DEFAULT_CHANNEL) - } - } - } - - fn set_paradise_default_channel(&self, channel: u8) -> Result<()> { - // Convert channel ID to user-friendly string name - let channel_name = match channel { - 0 => "main", - 1 => "mellow", - 2 => "rock", - 3 => "eclectic", - _ => return Err(anyhow::anyhow!("Invalid channel ID: {}", channel)), - }; - - self.set_value( - &["sources", "radio_paradise", "default_channel"], - Value::String(channel_name.to_string()), - ) - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_trait_exists() { - // Simple test to ensure the trait compiles - } -} --------End of pmoparadise/src/config_ext.rs --------- - ------------- pmoparadise/src/error.rs ---------- -//! Error types for the Radio Paradise client - -/// Result type alias for Radio Paradise operations -pub type Result = std::result::Result; - -/// Errors that can occur when using the Radio Paradise client -#[derive(Debug, thiserror::Error)] -pub enum Error { - /// HTTP request failed - #[error("HTTP request failed: {0}")] - Http(#[from] reqwest::Error), - - /// JSON parsing failed - #[error("JSON parsing failed: {0}")] - Json(#[from] serde_json::Error), - - /// Invalid URL - #[error("Invalid URL: {0}")] - InvalidUrl(#[from] url::ParseError), - - /// IO error - #[error("IO error: {0}")] - Io(#[from] std::io::Error), - - /// Invalid track index - #[error("Invalid track index: {0} (block has {1} tracks)")] - InvalidIndex(usize, usize), - - /// Invalid bitrate - #[error("Invalid bitrate value: {0} (must be 0-4)")] - InvalidBitrate(u8), - - /// Invalid event ID - #[error("Invalid event ID: {0}")] - InvalidEvent(String), - - /// Track not found in block - #[error("Track not found at index {0}")] - TrackNotFound(usize), - - /// Invalid elapsed time - #[error("Invalid elapsed time: {0}ms (exceeds block length)")] - InvalidElapsed(u64), - - /// Timeout error - #[error("Request timeout")] - Timeout, - - /// Generic error - #[error("{0}")] - Other(String), -} - -impl Error { - /// Create a generic error from a string - pub fn other(msg: impl Into) -> Self { - Self::Other(msg.into()) - } -} --------End of pmoparadise/src/error.rs --------- - ------------- pmoparadise/src/lib.rs ---------- -//! # pmoparadise - Radio Paradise Client for Rust -//! -//! `pmoparadise` is an idiomatic Rust client library for accessing Radio Paradise's -//! streaming API. It provides metadata retrieval, block streaming, and optional -//! per-track extraction from FLAC blocks. -//! -//! ## Features -//! -//! - **Metadata Access**: Get current and historical block metadata with song information -//! - **Block Streaming**: Stream continuous FLAC blocks with automatic prefetching -//! - **FLAC Quality**: Lossless CD quality or better -//! - **Per-Track Extraction** (optional): Extract individual tracks from FLAC blocks -//! - **Async/Await**: Built on tokio for efficient async I/O -//! - **Type-Safe**: Strongly typed API with comprehensive error handling -//! -//! ## Quick Start -//! -//! ```no_run -//! use pmoparadise::RadioParadiseClient; -//! -//! #[tokio::main] -//! async fn main() -> Result<(), Box> { -//! // Create a client -//! let client = RadioParadiseClient::new().await?; -//! -//! // Get what's currently playing -//! let now_playing = client.now_playing().await?; -//! -//! if let Some(song) = &now_playing.current_song { -//! println!("Now Playing: {} - {}", song.artist, song.title); -//! if let Some(album) = &song.album { -//! println!("Album: {}", album); -//! } -//! } -//! -//! // Get all songs in the current block -//! for (index, song) in now_playing.block.songs_ordered() { -//! println!(" {}. {} - {} ({}s)", -//! index, -//! song.artist, -//! song.title, -//! song.duration / 1000); -//! } -//! -//! Ok(()) -//! } -//! ``` -//! -//! ## Streaming Blocks -//! -//! Radio Paradise broadcasts music in continuous "blocks" - each block is a single -//! FLAC file containing multiple songs with metadata indicating timing offsets. -//! -//! ```no_run -//! use pmoparadise::RadioParadiseClient; -//! use futures::StreamExt; -//! -//! #[tokio::main] -//! async fn main() -> Result<(), Box> { -//! let client = RadioParadiseClient::new().await?; -//! let block = client.get_block(None).await?; -//! -//! // Stream the block -//! let mut stream = client.stream_block_from_metadata(&block).await?; -//! -//! while let Some(chunk) = stream.next().await { -//! let bytes = chunk?; -//! // Feed to audio player, write to file, etc. -//! } -//! -//! Ok(()) -//! } -//! ``` -//! -//! ## Per-Track Extraction (Feature: `per-track`) -//! -//! **Important**: This is an advanced feature with significant tradeoffs. -//! See the [`track`] module documentation for details. -//! -//! Most applications should stream blocks and use player-based seeking instead. -//! -//! ```no_run -//! # #[cfg(feature = "per-track")] -//! # { -//! use pmoparadise::RadioParadiseClient; -//! use std::path::Path; -//! -//! #[tokio::main] -//! async fn main() -> Result<(), Box> { -//! let client = RadioParadiseClient::new().await?; -//! let block = client.get_block(None).await?; -//! -//! // Extract first track to WAV -//! let mut track = client.open_track_stream(&block, 0).await?; -//! track.export_wav(Path::new("track.wav"))?; -//! -//! // Or get position for player-based seeking (recommended) -//! let (start, duration) = client.track_position_seconds(&block, 0)?; -//! println!("Play with: mpv --start={} --length={} {}", start, duration, block.url); -//! -//! Ok(()) -//! } -//! # } -//! ``` -//! -//! ## Architecture -//! -//! The API is organized into several modules: -//! -//! - [`client`]: Main HTTP client for API access -//! - [`models`]: Data structures for blocks, songs, and metadata -//! - [`stream`]: Block streaming functionality -//! - [`track`]: Per-track extraction (feature-gated) -//! - [`error`]: Error types and result aliases -//! -//! ## Radio Paradise Block Format -//! -//! Radio Paradise streams use a block-based format: -//! -//! - Each block is a single FLAC audio file -//! - Blocks contain multiple songs (typically 10-15 minutes total) -//! - Metadata includes timing offsets (`song[i].elapsed` in ms) for each song -//! - Block URLs follow the pattern: `https://apps.radioparadise.com/blocks/chan/0/4/-.flac` -//! - The `end_event` of one block is the `event` of the next, enabling seamless transitions -//! -//! ## Best Practices -//! -//! ### For Continuous Playback -//! -//! 1. Get current block with `get_block(None)` -//! 2. Stream block with `stream_block_from_metadata()` -//! 3. Use `prefetch_next()` to prepare the next block -//! 4. When current block ends, stream the next block seamlessly -//! -//! ### For Per-Song Seeking -//! -//! **Recommended approach** (efficient): -//! ```bash -//! # Use your audio player's seek capability -//! mpv --start=123.5 --length=234.0 -//! ``` -//! -//! **Alternative** (resource-intensive, requires `per-track` feature): -//! - Download and decode block -//! - Extract specific track to PCM/WAV -//! -//! ## Error Handling -//! -//! All operations return `Result` with detailed error types: -//! -//! ```no_run -//! use pmoparadise::{RadioParadiseClient, Error}; -//! -//! #[tokio::main] -//! async fn main() { -//! let client = RadioParadiseClient::new().await.unwrap(); -//! -//! match client.get_block(Some(99999999)).await { -//! Ok(block) => println!("Got block: {}", block.event), -//! Err(Error::Http(e)) => eprintln!("Network error: {}", e), -//! Err(Error::Json(e)) => eprintln!("Parse error: {}", e), -//! Err(e) => eprintln!("Other error: {}", e), -//! } -//! } -//! ``` -//! -//! ## Audio Streaming (Feature: `pmoaudio`) -//! -//! For direct audio streaming and integration with pmoaudio pipelines, -//! use `RadioParadiseStreamSource`: -//! -//! ```no_run -//! # #[cfg(feature = "pmoaudio")] -//! # { -//! use pmoparadise::{RadioParadiseClient, RadioParadiseStreamSource}; -//! use pmoaudio::pipeline::Node; -//! -//! #[tokio::main] -//! async fn main() -> Result<(), Box> { -//! let client = RadioParadiseClient::new().await?; -//! let stream_source = RadioParadiseStreamSource::new(client, None).await?; -//! -//! // Create audio node from stream source -//! let node = Node::from_logic(stream_source); -//! -//! // Use in pmoaudio pipeline... -//! -//! Ok(()) -//! } -//! # } -//! ``` -//! -//! **RadioParadiseStreamSource**: -//! - Downloads and decodes FLAC blocks in real-time -//! - Automatically detects bit depth (16/24/32-bit) -//! - Inserts track boundaries with metadata -//! - Integrates seamlessly with pmoaudio pipelines -//! -//! ## Cargo Features -//! -//! - `default`: Standard metadata and streaming (no FLAC decoding) -//! - `per-track`: Enable FLAC decoding and per-track extraction (adds `claxon`, `hound`, `tempfile`) -//! - `pmoserver`: Enable REST API extension for pmoserver integration (adds `utoipa`, `axum`) -//! - `pmoaudio`: Enable RadioParadiseStreamSource for pmoaudio integration -//! - `pmoconfig`: Enable configuration integration with pmoconfig -//! - `server`: Enable RadioParadiseSource for UPnP ContentDirectory integration -//! -//! ## See Also -//! -//! - [Radio Paradise](https://radioparadise.com) - Official website -//! - [Radio Paradise API](https://api.radioparadise.com) - API documentation - -pub mod channels; -pub mod client; -pub mod error; -pub mod models; -pub mod source; - -#[cfg(feature = "pmoaudio")] -pub mod node_stats; - -#[cfg(feature = "pmoserver")] -pub mod pmoserver_ext; - -#[cfg(feature = "pmoconfig")] -pub mod config_ext; - -#[cfg(feature = "pmoaudio")] -pub mod radio_paradise_stream_source; - -#[cfg(feature = "pmoaudio")] -pub mod stream_channel; - -#[cfg(feature = "pmoaudio")] -pub mod playlist_feeder; - -// Re-exports for convenience -pub use client::{ClientBuilder, RadioParadiseClient}; -pub use error::{Error, Result}; -pub use models::{Block, DurationMs, EventId, NowPlaying, Song}; -pub use source::RadioParadiseSource; - -#[cfg(feature = "pmoaudio")] -pub use radio_paradise_stream_source::RadioParadiseStreamSource; - -#[cfg(feature = "pmoaudio")] -pub use playlist_feeder::{RadioParadisePlaylistFeeder, END_OF_BLOCKS_SIGNAL}; - -#[cfg(feature = "pmoaudio")] -pub use stream_channel::{ - HistoryFlacStream, HistoryOggStream, HistoryStreamError, ParadiseChannelManager, - ParadiseHistoryBuilder, ParadiseHistoryOptions, ParadiseStreamChannel, - ParadiseStreamChannelConfig, -}; - -#[cfg(feature = "pmoserver")] -pub use pmoserver_ext::{ - create_api_router, RadioParadiseApiDoc, RadioParadiseExt, RadioParadiseState, -}; - -#[cfg(feature = "pmoconfig")] -pub use config_ext::RadioParadiseConfigExt; - -// Version information -pub const VERSION: &str = env!("CARGO_PKG_VERSION"); - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_version() { - assert!(!VERSION.is_empty()); - } -} --------End of pmoparadise/src/lib.rs --------- - ------------- pmoparadise/src/models.rs ---------- -//! Data models for Radio Paradise API responses - -use serde::{Deserialize, Deserializer, Serialize}; -use serde_json::Number; -use std::collections::HashMap; -use url::Url; - -/// Deserialize a string or number into a u64 -fn deserialize_string_or_u64<'de, D>(deserializer: D) -> Result -where - D: Deserializer<'de>, -{ - use serde::de::Error; - - #[derive(Deserialize)] - #[serde(untagged)] - enum StringOrU64 { - String(String), - Number(u64), - } - - match StringOrU64::deserialize(deserializer)? { - StringOrU64::String(s) => s.parse::().map_err(D::Error::custom), - StringOrU64::Number(n) => Ok(n), - } -} - -/// Deserialize a string or number into a f64, then convert to u64 milliseconds -fn deserialize_length<'de, D>(deserializer: D) -> Result -where - D: Deserializer<'de>, -{ - use serde::de::Error; - - #[derive(Deserialize)] - #[serde(untagged)] - enum StringOrNumber { - String(String), - Number(Number), - } - - fn to_milliseconds(value: f64) -> u64 { - if value >= 100_000.0 { - value.round() as u64 - } else { - (value * 1000.0).round() as u64 - } - } - - match StringOrNumber::deserialize(deserializer)? { - StringOrNumber::String(s) => { - let value = s.parse::().map_err(D::Error::custom)?; - Ok(to_milliseconds(value)) - } - StringOrNumber::Number(n) => { - if let Some(int_value) = n.as_u64() { - Ok(to_milliseconds(int_value as f64)) - } else if let Some(float_value) = n.as_f64() { - Ok(to_milliseconds(float_value)) - } else { - Err(D::Error::custom("Invalid number for block length")) - } - } - } -} - -/// Deserialize an optional string or number into Option -fn deserialize_optional_string_or_u32<'de, D>(deserializer: D) -> Result, D::Error> -where - D: Deserializer<'de>, -{ - use serde::de::Error; - - #[derive(Deserialize)] - #[serde(untagged)] - enum StringOrU32 { - String(String), - Number(u32), - } - - let opt = Option::::deserialize(deserializer)?; - match opt { - None => Ok(None), - Some(StringOrU32::String(s)) => { - if s.is_empty() { - Ok(None) - } else { - s.parse::().map(Some).map_err(D::Error::custom) - } - } - Some(StringOrU32::Number(n)) => Ok(Some(n)), - } -} - -/// Deserialize an optional string or number into Option -fn deserialize_optional_string_or_f32<'de, D>(deserializer: D) -> Result, D::Error> -where - D: Deserializer<'de>, -{ - use serde::de::Error; - - #[derive(Deserialize)] - #[serde(untagged)] - enum StringOrF32 { - String(String), - Float(f32), - Int(i32), - } - - let opt = Option::::deserialize(deserializer)?; - match opt { - None => Ok(None), - Some(StringOrF32::String(s)) => { - if s.is_empty() { - Ok(None) - } else { - s.parse::().map(Some).map_err(D::Error::custom) - } - } - Some(StringOrF32::Float(f)) => Ok(Some(f)), - Some(StringOrF32::Int(i)) => Ok(Some(i as f32)), - } -} - -/// Duration in milliseconds -pub type DurationMs = u64; - -/// Event ID for block identification -pub type EventId = u64; - -/// Information about a song/track within a block -#[derive(Debug, Clone, Serialize, Deserialize)] -pub struct Song { - /// Artist name - pub artist: String, - - /// Song title - pub title: String, - - /// Album name (may be missing for promos/announcements) - #[serde(default)] - pub album: Option, - - /// Year of release - /// Note: API returns this as a string, we deserialize to u32 - #[serde(default, deserialize_with = "deserialize_optional_string_or_u32")] - pub year: Option, - - /// Elapsed time from start of block in milliseconds - pub elapsed: DurationMs, - - /// Duration of the track in milliseconds - pub duration: DurationMs, - - /// Cover image filename/path - #[serde(default)] - pub cover: Option, - - /// Rating (0-10) - /// Note: API returns this as a string, we deserialize to f32 - #[serde(default, deserialize_with = "deserialize_optional_string_or_f32")] - pub rating: Option, - - /// Gapless URL for individual song FLAC - /// This URL points to a FLAC file containing only this song - #[serde(default)] - pub gapless_url: Option, - - /// Scheduled playback time on Radio Paradise (Unix timestamp in milliseconds, UTC) - #[serde(default)] - pub sched_time_millis: Option, - - /// Radio Paradise song ID (unique identifier) - #[serde(default)] - pub song_id: Option, - - /// Radio Paradise artist ID (for building artist URLs) - #[serde(default)] - pub artist_id: Option, - - /// Large cover image path (best quality) - #[serde(default)] - pub cover_large: Option, - - /// Additional metadata - #[serde(flatten)] - pub extra: HashMap, -} - -impl Song { - /// Get the end time of this song in the block (elapsed + duration) - pub fn end_time_ms(&self) -> DurationMs { - self.elapsed + self.duration - } - - /// Check if a given timestamp (ms) falls within this song - pub fn contains_timestamp(&self, timestamp_ms: DurationMs) -> bool { - timestamp_ms >= self.elapsed && timestamp_ms < self.end_time_ms() - } - - /// Calcule le timestamp de fin de diffusion (sched_time + duration) - pub fn sched_end_time_ms(&self) -> Option { - self.sched_time_millis.map(|start| start + self.duration) - } - - /// Vérifie si la chanson est encore en lecture ou à venir - pub fn is_still_playing(&self, now_ms: u64) -> bool { - self.sched_end_time_ms() - .map(|end| end >= now_ms) - .unwrap_or(false) - } -} - -/// Image information -#[derive(Debug, Clone, Serialize, Deserialize)] -pub struct ImageInfo { - /// Base URL for images - pub base: String, -} - -/// A block of songs from Radio Paradise -/// -/// Radio Paradise streams music in "blocks" - continuous FLAC files -/// containing multiple songs. Each block contains metadata about all -/// songs within it and timing information for seeking. -#[derive(Debug, Clone, Serialize, Deserialize)] -pub struct Block { - /// Event ID for this block (start event) - /// Note: API returns this as a string, we deserialize to u64 - #[serde(deserialize_with = "deserialize_string_or_u64")] - pub event: EventId, - - /// Event ID for the next block (end event) - /// Note: API returns this as a string, we deserialize to u64 - #[serde(deserialize_with = "deserialize_string_or_u64")] - pub end_event: EventId, - - /// Total length of the block in milliseconds - /// Note: API returns this as a string in seconds (e.g., "1715.54"), we convert to ms - #[serde(deserialize_with = "deserialize_length")] - pub length: DurationMs, - - /// URL to stream this block - pub url: String, - - /// Base URL for cover images - #[serde(default)] - pub image_base: Option, - - /// Scheduled start time for this block (Unix timestamp in milliseconds, UTC) - #[serde(default)] - pub sched_time_millis: Option, - - /// Map of song index (as string) to Song metadata - /// Keys are "0", "1", "2", etc. - #[serde(default)] - pub song: HashMap, - - /// Additional metadata - #[serde(flatten)] - pub extra: HashMap, -} - -impl Block { - /// Scheduled start time in milliseconds if available. - pub fn start_time_millis(&self) -> Option { - if let Some(ts) = self.sched_time_millis { - return Some(ts); - } - self.songs_ordered() - .into_iter() - .find_map(|(_, song)| song.sched_time_millis) - } - - /// Get songs in order by index - pub fn songs_ordered(&self) -> Vec<(usize, &Song)> { - let mut songs: Vec<_> = self - .song - .iter() - .filter_map(|(k, v)| k.parse::().ok().map(|idx| (idx, v))) - .collect(); - songs.sort_by_key(|(idx, _)| *idx); - songs - } - - /// Get a song by index - pub fn get_song(&self, index: usize) -> Option<&Song> { - self.song.get(&index.to_string()) - } - - /// Get the number of songs in this block - pub fn song_count(&self) -> usize { - self.song.len() - } - - /// Get the full URL for a cover image - pub fn cover_url(&self, cover_path: &str) -> Option { - let base = self.image_base.as_ref()?; - let base_url = Url::parse(base).ok()?; - base_url.join(cover_path).ok().map(|url| url.to_string()) - } - - /// Find which song is playing at a given timestamp (ms from block start) - pub fn song_at_timestamp(&self, timestamp_ms: DurationMs) -> Option<(usize, &Song)> { - self.songs_ordered() - .into_iter() - .find(|(_, song)| song.contains_timestamp(timestamp_ms)) - } - - /// Parse the block URL to get start and end event IDs - /// - /// Block URLs follow the pattern: - /// `https://apps.radioparadise.com/blocks/chan/0/4/-.flac` - pub fn parse_url_events(&self) -> Option<(EventId, EventId)> { - let url_path = self.url.split('/').last()?; - let filename = url_path.strip_suffix(".flac")?; - let mut parts = filename.split('-'); - let start = parts.next()?.parse::().ok()?; - let end = parts.next()?.parse::().ok()?; - Some((start, end)) - } -} - -/// Currently playing information -#[derive(Debug, Clone)] -pub struct NowPlaying { - /// The current block - pub block: Block, - - /// Current song index (if determinable) - pub current_song_index: Option, - - /// Current song - pub current_song: Option, - - /// Approximate elapsed time in current block (ms) - /// Note: This is estimated and may not be perfectly accurate - pub block_elapsed_ms: Option, -} - -impl NowPlaying { - /// Create from a block (assumes starting from beginning) - pub fn from_block(block: Block) -> Self { - let (current_song_index, current_song) = block - .get_song(0) - .map(|s| (Some(0), Some(s.clone()))) - .unwrap_or((None, None)); - - Self { - block, - current_song_index, - current_song, - block_elapsed_ms: Some(0), - } - } - - /// Get URL for the current block stream - pub fn stream_url(&self) -> &str { - &self.block.url - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_song_timing() { - let song = Song { - artist: "Test Artist".to_string(), - title: "Test Song".to_string(), - album: Some("Test Album".to_string()), - year: Some(2024), - elapsed: 1000, - duration: 5000, - cover: None, - rating: None, - extra: HashMap::new(), - gapless_url: Some("http://example.com/song.flac".into()), - sched_time_millis: Some(1_700_000_000_000), - song_id: Some("song-id".into()), - artist_id: Some("artist-id".into()), - cover_large: Some("cover-large.jpg".into()), - }; - - assert_eq!(song.end_time_ms(), 6000); - assert!(song.contains_timestamp(3000)); - assert!(!song.contains_timestamp(7000)); - assert!(!song.contains_timestamp(500)); - } - - #[test] - fn test_block_parse() { - let json = r#"{ - "event": 1234, - "end_event": 5678, - "length": 900000, - "url": "https://apps.radioparadise.com/blocks/chan/0/4/1234-5678.flac", - "image_base": "https://img.radioparadise.com/covers/l/", - "song": { - "0": { - "artist": "Miles Davis", - "title": "So What", - "album": "Kind of Blue", - "year": 1959, - "elapsed": 0, - "duration": 540000, - "cover": "B00000I0JF.jpg" - }, - "1": { - "artist": "John Coltrane", - "title": "Giant Steps", - "album": "Giant Steps", - "year": 1960, - "elapsed": 540000, - "duration": 360000, - "cover": "B000002I4U.jpg" - } - } - }"#; - - let block: Block = serde_json::from_str(json).unwrap(); - assert_eq!(block.event, 1234); - assert_eq!(block.end_event, 5678); - assert_eq!(block.song_count(), 2); - - let songs = block.songs_ordered(); - assert_eq!(songs.len(), 2); - assert_eq!(songs[0].1.title, "So What"); - assert_eq!(songs[1].1.title, "Giant Steps"); - - let (start, end) = block.parse_url_events().unwrap(); - assert_eq!(start, 1234); - assert_eq!(end, 5678); - - let (idx, song) = block.song_at_timestamp(600000).unwrap(); - assert_eq!(idx, 1); - assert_eq!(song.title, "Giant Steps"); - } - - #[test] - fn test_block_length_from_seconds_string() { - let json = serde_json::json!({ - "event": 1, - "end_event": 2, - "length": "1715.54", - "url": "https://example.com/block.flac", - "song": {} - }); - - let block: Block = serde_json::from_value(json).unwrap(); - assert_eq!(block.length, 1_715_540); - } - - #[test] - fn test_block_length_from_seconds_integer() { - let json = serde_json::json!({ - "event": 1, - "end_event": 2, - "length": 1800, - "url": "https://example.com/block.flac", - "song": {} - }); - - let block: Block = serde_json::from_value(json).unwrap(); - assert_eq!(block.length, 1_800_000); - } - - #[test] - fn test_block_length_from_milliseconds_integer() { - let json = serde_json::json!({ - "event": 1, - "end_event": 2, - "length": 900_000, - "url": "https://example.com/block.flac", - "song": {} - }); - - let block: Block = serde_json::from_value(json).unwrap(); - assert_eq!(block.length, 900_000); - } - - #[test] - fn test_block_length_from_milliseconds_float() { - let json = serde_json::json!({ - "event": 1, - "end_event": 2, - "length": 900_000.0, - "url": "https://example.com/block.flac", - "song": {} - }); - - let block: Block = serde_json::from_value(json).unwrap(); - assert_eq!(block.length, 900_000); - } -} --------End of pmoparadise/src/models.rs --------- - ------------- pmoparadise/src/node_stats.rs ---------- -//! Node statistics tracking -//! -//! Provides detailed statistics for pipeline nodes to understand -//! data flow, backpressure behavior, and timing. - -use std::sync::atomic::{AtomicU64, AtomicUsize, Ordering}; -use std::sync::Arc; -use std::time::Instant; - -/// Statistics pour un node audio -#[derive(Debug)] -pub struct NodeStats { - /// Nom du node pour identification - pub name: String, - - /// Instant de démarrage du node - pub start_time: Instant, - - /// Nombre total de segments reçus - pub segments_received: AtomicUsize, - - /// Nombre total de segments envoyés - pub segments_sent: AtomicUsize, - - /// Nombre total de bytes traités - pub bytes_processed: AtomicU64, - - /// Nombre de fois où l'envoi a été bloqué (backpressure) - pub backpressure_blocks: AtomicUsize, - - /// Temps total passé bloqué en millisecondes - pub backpressure_time_ms: AtomicU64, - - /// Timestamp du premier segment (secondes) - pub first_segment_timestamp: AtomicU64, // Stocké comme u64 * 1000 pour précision - - /// Timestamp du dernier segment (secondes) - pub last_segment_timestamp: AtomicU64, // Stocké comme u64 * 1000 pour précision -} - -impl NodeStats { - pub fn new(name: impl Into) -> Arc { - Arc::new(Self { - name: name.into(), - start_time: Instant::now(), - segments_received: AtomicUsize::new(0), - segments_sent: AtomicUsize::new(0), - bytes_processed: AtomicU64::new(0), - backpressure_blocks: AtomicUsize::new(0), - backpressure_time_ms: AtomicU64::new(0), - first_segment_timestamp: AtomicU64::new(u64::MAX), - last_segment_timestamp: AtomicU64::new(0), - }) - } - - /// Enregistre la réception d'un segment - pub fn record_segment_received(&self, timestamp_sec: f64) { - self.segments_received.fetch_add(1, Ordering::Relaxed); - - let ts_millis = (timestamp_sec * 1000.0) as u64; - - // Update first timestamp (atomic min) - let mut current = self.first_segment_timestamp.load(Ordering::Relaxed); - while current > ts_millis { - match self.first_segment_timestamp.compare_exchange_weak( - current, - ts_millis, - Ordering::Relaxed, - Ordering::Relaxed, - ) { - Ok(_) => break, - Err(x) => current = x, - } - } - - // Update last timestamp (atomic max) - let mut current = self.last_segment_timestamp.load(Ordering::Relaxed); - while current < ts_millis { - match self.last_segment_timestamp.compare_exchange_weak( - current, - ts_millis, - Ordering::Relaxed, - Ordering::Relaxed, - ) { - Ok(_) => break, - Err(x) => current = x, - } - } - } - - /// Enregistre l'envoi d'un segment - pub fn record_segment_sent(&self, bytes: usize) { - self.segments_sent.fetch_add(1, Ordering::Relaxed); - self.bytes_processed - .fetch_add(bytes as u64, Ordering::Relaxed); - } - - /// Enregistre un événement de backpressure - pub fn record_backpressure(&self, duration_ms: u64) { - self.backpressure_blocks.fetch_add(1, Ordering::Relaxed); - self.backpressure_time_ms - .fetch_add(duration_ms, Ordering::Relaxed); - } - - /// Retourne un rapport formaté des statistiques - pub fn report(&self) -> String { - let elapsed = self.start_time.elapsed().as_secs_f64(); - let received = self.segments_received.load(Ordering::Relaxed); - let sent = self.segments_sent.load(Ordering::Relaxed); - let bytes = self.bytes_processed.load(Ordering::Relaxed); - let bp_blocks = self.backpressure_blocks.load(Ordering::Relaxed); - let bp_time_ms = self.backpressure_time_ms.load(Ordering::Relaxed); - - let first_ts = self.first_segment_timestamp.load(Ordering::Relaxed); - let last_ts = self.last_segment_timestamp.load(Ordering::Relaxed); - - let first_ts_sec = if first_ts == u64::MAX { - 0.0 - } else { - first_ts as f64 / 1000.0 - }; - let last_ts_sec = last_ts as f64 / 1000.0; - let audio_duration = last_ts_sec - first_ts_sec; - - let mb = bytes as f64 / 1_048_576.0; - let throughput_mbps = if elapsed > 0.0 { mb / elapsed } else { 0.0 }; - - format!( - "[{}]\n\ - Elapsed: {:.1}s | Received: {} | Sent: {} | Lost: {}\n\ - Data: {:.1} MB | Throughput: {:.2} MB/s\n\ - Audio: {:.1}s (first: {:.1}s, last: {:.1}s) | Real-time ratio: {:.1}%\n\ - Backpressure: {} blocks, {:.2}s total ({:.1}% of time)", - self.name, - elapsed, - received, - sent, - received.saturating_sub(sent), - mb, - throughput_mbps, - audio_duration, - first_ts_sec, - last_ts_sec, - if audio_duration > 0.0 { - (elapsed / audio_duration) * 100.0 - } else { - 0.0 - }, - bp_blocks, - bp_time_ms as f64 / 1000.0, - if elapsed > 0.0 { - (bp_time_ms as f64 / 1000.0 / elapsed) * 100.0 - } else { - 0.0 - } - ) - } -} --------End of pmoparadise/src/node_stats.rs --------- - ------------- pmoparadise/src/playlist_feeder.rs ---------- -//! RadioParadisePlaylistFeeder - Télécharge et alimente une playlist à partir des blocs RP -//! -//! Architecture simplifiée utilisant les URLs gapless individuelles au lieu du bloc FLAC entier. - -use crate::{client::RadioParadiseClient, models::EventId}; -use anyhow::Result; -use pmoaudiocache::Cache as AudioCache; -use pmocovers::Cache as CoversCache; -use pmoplaylist::{PlaylistManager, ReadHandle, WriteHandle}; -use std::{ - collections::{HashMap, VecDeque}, - sync::Arc, - time::{Duration, SystemTime, UNIX_EPOCH}, -}; -use tokio::sync::Notify; - -/// Signal de fin de blocs -pub const END_OF_BLOCKS_SIGNAL: EventId = EventId::MAX; -const RECENT_BLOCKS_CACHE_SIZE: usize = 10; - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -enum BlockStatus { - Pending, - InProgress, - Done, -} - -struct RecentBlocks { - states: HashMap, - order: VecDeque, - capacity: usize, -} - -impl RecentBlocks { - fn new(capacity: usize) -> Self { - Self { - states: HashMap::new(), - order: VecDeque::new(), - capacity, - } - } - - fn try_enqueue(&mut self, event_id: EventId) -> bool { - match self.states.get(&event_id) { - Some(_) => false, - None => { - self.order.push_back(event_id); - self.states.insert(event_id, BlockStatus::Pending); - self.evict_old_done(); - true - } - } - } - - fn mark_in_progress(&mut self, event_id: EventId) { - if let Some(state) = self.states.get_mut(&event_id) { - *state = BlockStatus::InProgress; - } else { - self.order.push_back(event_id); - self.states.insert(event_id, BlockStatus::InProgress); - } - self.evict_old_done(); - } - - fn mark_done(&mut self, event_id: EventId) { - if let Some(state) = self.states.get_mut(&event_id) { - *state = BlockStatus::Done; - } else { - self.order.push_back(event_id); - self.states.insert(event_id, BlockStatus::Done); - } - self.evict_old_done(); - } - - fn purge(&mut self, event_id: EventId) { - self.states.remove(&event_id); - } - - fn evict_old_done(&mut self) { - while self.order.len() > self.capacity { - let Some(front) = self.order.front().copied() else { - break; - }; - match self.states.get(&front) { - Some(BlockStatus::Done) | None => { - self.order.pop_front(); - self.states.remove(&front); - } - Some(_) => break, - } - } - } -} - -/// Feeder qui télécharge les blocs RP et alimente une playlist -pub struct RadioParadisePlaylistFeeder { - client: RadioParadiseClient, - audio_cache: Arc, - covers_cache: Arc, - playlist_handle: Arc, - block_queue: Arc>>, - notify: Arc, - collection: Option, - recent_blocks: tokio::sync::Mutex, -} - -impl RadioParadisePlaylistFeeder { - /// Crée un nouveau feeder et retourne (feeder, read_handle) - pub async fn new( - client: RadioParadiseClient, - audio_cache: Arc, - covers_cache: Arc, - playlist_id: String, - collection: Option, - ) -> Result<(Self, ReadHandle)> { - let manager = PlaylistManager::get(); - let write_handle = manager - .create_persistent_playlist(playlist_id.clone()) - .await?; - let read_handle = manager.get_read_handle(&playlist_id).await?; - - Ok(( - Self { - client, - audio_cache, - covers_cache, - playlist_handle: Arc::new(write_handle), - block_queue: Arc::new(tokio::sync::Mutex::new(VecDeque::new())), - notify: Arc::new(Notify::new()), - collection, - recent_blocks: tokio::sync::Mutex::new(RecentBlocks::new(RECENT_BLOCKS_CACHE_SIZE)), - }, - read_handle, - )) - } - - /// Enqueue un bloc pour traitement - pub async fn push_block_id(&self, event_id: EventId) { - { - let mut recent = self.recent_blocks.lock().await; - if !recent.try_enqueue(event_id) { - tracing::debug!( - "RadioParadisePlaylistFeeder: Ignoring duplicate enqueue for block {}", - event_id - ); - return; - } - } - - { - let mut queue = self.block_queue.lock().await; - queue.push_back(event_id); - } - self.notify.notify_one(); - } - - async fn mark_in_progress(&self, event_id: EventId) { - let mut recent = self.recent_blocks.lock().await; - recent.mark_in_progress(event_id); - } - - async fn mark_done(&self, event_id: EventId) { - let mut recent = self.recent_blocks.lock().await; - recent.mark_done(event_id); - } - - async fn purge_block_state(&self, event_id: EventId) { - let mut recent = self.recent_blocks.lock().await; - recent.purge(event_id); - } - - pub(crate) async fn retry_block(&self, event_id: EventId) { - self.purge_block_state(event_id).await; - self.push_block_id(event_id).await; - } - - /// Boucle principale de traitement (à exécuter dans une tâche tokio) - pub async fn run(self: Arc) -> Result<()> { - loop { - // Attendre un bloc - let event_id = loop { - { - let mut queue = self.block_queue.lock().await; - if let Some(id) = queue.pop_front() { - if id == END_OF_BLOCKS_SIGNAL { - tracing::info!( - "RadioParadisePlaylistFeeder: END_OF_BLOCKS_SIGNAL received" - ); - return Ok(()); - } - break id; - } - } - self.notify.notified().await; - }; - - self.mark_in_progress(event_id).await; - - // Traiter le bloc - if let Err(e) = self.process_block(event_id).await { - tracing::error!( - "RadioParadisePlaylistFeeder: Failed to process block {}: {}", - event_id, - e - ); - self.purge_block_state(event_id).await; - tracing::debug!( - "RadioParadisePlaylistFeeder: Cleared block {} state after error", - event_id - ); - } else { - self.mark_done(event_id).await; - } - } - } - - /// Traite un bloc : fetch, filtre, download, push playlist - async fn process_block(&self, event_id: EventId) -> Result<()> { - tracing::info!("RadioParadisePlaylistFeeder: Processing block {}", event_id); - - // 1. Fetch le bloc - let block = self.client.get_block(Some(event_id)).await?; - - // 2. Timestamp actuel - let now_ms = SystemTime::now().duration_since(UNIX_EPOCH)?.as_millis() as u64; - - // 3. Filtrer les chansons encore en lecture ou à venir - let songs = block.songs_ordered(); - let mut processed = 0; - - for (idx, song) in songs { - if !song.is_still_playing(now_ms) { - tracing::debug!( - "RadioParadisePlaylistFeeder: Skipping finished song {} - {} (ended at {})", - idx, - song.title, - song.sched_end_time_ms().unwrap_or(0) - ); - continue; - } - - // 4. Télécharger la chanson - let gapless_url = song - .gapless_url - .as_ref() - .ok_or_else(|| anyhow::anyhow!("Missing gapless_url for song {}", idx))?; - - tracing::info!( - "RadioParadisePlaylistFeeder: Downloading song {} - {} by {}", - idx, - song.title, - song.artist - ); - - let pk = self - .audio_cache - .add_from_url(gapless_url, self.collection.as_deref()) - .await?; - - // 5. Sauvegarder les métadonnées - self.save_metadata(&pk, song, &block).await?; - - // 6. Calculer le TTL - let sched_end = song - .sched_end_time_ms() - .ok_or_else(|| anyhow::anyhow!("Cannot calculate TTL without sched_time_millis"))?; - let ttl_ms = sched_end.saturating_sub(now_ms); - let ttl = Duration::from_millis(ttl_ms); - - // 7. Push dans la playlist avec TTL - self.playlist_handle.push_with_ttl(pk.clone(), ttl).await?; - - tracing::info!( - "RadioParadisePlaylistFeeder: Added {} to playlist (pk={}, ttl={}s)", - song.title, - pk, - ttl.as_secs() - ); - - processed += 1; - } - - tracing::info!( - "RadioParadisePlaylistFeeder: Processed block {} - added {} songs to playlist", - event_id, - processed - ); - - Ok(()) - } - - /// Sauvegarde les métadonnées dans le cache audio - async fn save_metadata( - &self, - pk: &str, - song: &crate::models::Song, - block: &crate::models::Block, - ) -> Result<()> { - use pmoaudiocache::AudioTrackMetadataExt; - - let metadata = self.audio_cache.track_metadata(pk); - let mut meta = metadata.write().await; - - // Métadonnées de base - meta.set_title(Some(song.title.clone())).await?; - meta.set_artist(Some(song.artist.clone())).await?; - if let Some(ref album) = song.album { - meta.set_album(Some(album.clone())).await?; - } - if let Some(year) = song.year { - meta.set_year(Some(year)).await?; - } - - // Cover - if let Some(ref cover_large) = song.cover_large { - if let Some(cover_url) = block.cover_url(cover_large) { - meta.set_cover_url(Some(cover_url.clone())).await?; - - // Télécharger la cover - match self - .covers_cache - .add_from_url(&cover_url, self.collection.as_deref()) - .await - { - Ok(cover_pk) => { - meta.set_cover_pk(Some(cover_pk)).await?; - tracing::debug!( - "RadioParadisePlaylistFeeder: Cached cover for {}", - song.title - ); - } - Err(e) => { - tracing::warn!("RadioParadisePlaylistFeeder: Failed to cache cover: {}", e); - } - } - } - } - - Ok(()) - } -} --------End of pmoparadise/src/playlist_feeder.rs --------- - ------------- pmoparadise/src/pmoserver_ext.rs ---------- -//! Extension pmoserver pour Radio Paradise -//! -//! Ce module fournit un trait d'extension pour ajouter facilement l'API Radio Paradise -//! à un serveur pmoserver. - -use crate::channels::{max_channel_id, ChannelDescriptor, ALL_CHANNELS}; -use crate::{Block, NowPlaying, RadioParadiseClient}; -use async_trait::async_trait; -use axum::{ - extract::{Path, Query, State}, - http::StatusCode, - routing::get, - Json, Router, -}; -use serde::{Deserialize, Serialize}; -use std::sync::Arc; -use tokio::sync::RwLock; -use utoipa::{OpenApi, ToSchema}; - -/// État partagé pour l'API Radio Paradise -#[derive(Clone)] -pub struct RadioParadiseState { - client: Arc>, -} - -#[derive(Debug, Default, Deserialize)] -#[serde(default)] -struct ParadiseQuery { - channel: Option, -} - -impl RadioParadiseState { - pub async fn new() -> anyhow::Result { - let client = RadioParadiseClient::new() - .await - .map_err(|e| anyhow::anyhow!("Failed to create RadioParadise client: {}", e))?; - - Ok(Self { - client: Arc::new(RwLock::new(client)), - }) - } - - async fn client_for_params( - &self, - params: &ParadiseQuery, - ) -> Result { - let base_client = { - let client_guard = self.client.read().await; - client_guard.clone() - }; - - let mut client = base_client; - - if let Some(channel) = params.channel { - if channel > max_channel_id() { - tracing::warn!("Invalid Radio Paradise channel requested: {}", channel); - return Err(StatusCode::BAD_REQUEST); - } - client = client.clone_with_channel(channel); - } - - Ok(client) - } -} - -/// Information sur un canal Radio Paradise -#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)] -pub struct ChannelInfo { - /// ID du canal (0-3) - pub id: u8, - /// Nom du canal - pub name: String, - /// Description - pub description: String, -} - -impl From<&ChannelDescriptor> for ChannelInfo { - fn from(descriptor: &ChannelDescriptor) -> Self { - Self { - id: descriptor.id, - name: descriptor.display_name.to_string(), - description: descriptor.description.to_string(), - } - } -} - -/// Réponse avec informations étendues sur le morceau en cours -#[derive(Debug, Clone, Serialize, ToSchema)] -pub struct NowPlayingResponse { - /// Event ID du block actuel - pub event: u64, - /// Event ID du prochain block - pub end_event: u64, - /// URL de streaming du block - pub stream_url: String, - /// Durée totale du block en ms - pub block_length_ms: u64, - /// Index du morceau actuel - pub current_song_index: Option, - /// Morceau actuel - pub current_song: Option, - /// Tous les morceaux du block - pub songs: Vec, -} - -/// Information sur un morceau -#[derive(Debug, Clone, Serialize, ToSchema)] -pub struct SongInfo { - /// Index dans le block - pub index: usize, - /// Artiste - pub artist: String, - /// Titre - pub title: String, - /// Album - pub album: String, - /// Année - pub year: Option, - /// Temps écoulé depuis le début du block (ms) - pub elapsed_ms: u64, - /// Durée du morceau (ms) - pub duration_ms: u64, - /// URL de la pochette - pub cover_url: Option, - /// Note (0-10) - pub rating: Option, -} - -/// Réponse pour un block -#[derive(Debug, Clone, Serialize, ToSchema)] -pub struct BlockResponse { - /// Event ID du block - pub event: u64, - /// Event ID du prochain block - pub end_event: u64, - /// URL de streaming - pub url: String, - /// Durée totale (ms) - pub length_ms: u64, - /// Morceaux du block - pub songs: Vec, -} - -/// Réponse pour l'URL de streaming -#[derive(Debug, Clone, Serialize, ToSchema)] -pub struct StreamUrlResponse { - /// Event ID du block - #[schema(example = 1234567)] - pub event: u64, - /// URL de streaming FLAC - #[schema(example = "https://apps.radioparadise.com/blocks/chan/0/4/1234567-1234580.flac")] - pub stream_url: String, - /// Durée totale (ms) - #[schema(example = 900000)] - pub length_ms: u64, -} - -/// Réponse pour l'URL de pochette -#[derive(Debug, Clone, Serialize, ToSchema)] -pub struct CoverUrlResponse { - /// Event ID du block - #[schema(example = 1234567)] - pub event: u64, - /// Index du morceau - #[schema(example = 0)] - pub song_index: usize, - /// URL de la pochette (résolution complète) - #[schema(example = "https://img.radioparadise.com/covers/l/B00000I0JF.jpg")] - pub cover_url: Option, - /// Type de pochette: "cover" (petite) ou "cover_large" (grande) - #[schema(example = "cover_large")] - pub cover_type: String, -} - -impl From for BlockResponse { - fn from(block: Block) -> Self { - let songs = block - .songs_ordered() - .into_iter() - .map(|(index, song)| SongInfo { - index, - artist: song.artist.clone(), - title: song.title.clone(), - album: song.album.clone().unwrap_or_default(), - year: song.year, - elapsed_ms: song.elapsed, - duration_ms: song.duration, - cover_url: song.cover.as_ref().and_then(|c| block.cover_url(c)), - rating: song.rating, - }) - .collect(); - - Self { - event: block.event, - end_event: block.end_event, - url: block.url, - length_ms: block.length, - songs, - } - } -} - -impl From for NowPlayingResponse { - fn from(np: NowPlaying) -> Self { - let songs: Vec = np - .block - .songs_ordered() - .into_iter() - .map(|(index, song)| SongInfo { - index, - artist: song.artist.clone(), - title: song.title.clone(), - album: song.album.clone().unwrap_or_default(), - year: song.year, - elapsed_ms: song.elapsed, - duration_ms: song.duration, - cover_url: song.cover.as_ref().and_then(|c| np.block.cover_url(c)), - rating: song.rating, - }) - .collect(); - - let current_song = np.current_song.as_ref().and_then(|song| { - let index = np.current_song_index?; - Some(SongInfo { - index, - artist: song.artist.clone(), - title: song.title.clone(), - album: song.album.clone().unwrap_or_default(), - year: song.year, - elapsed_ms: song.elapsed, - duration_ms: song.duration, - cover_url: song.cover.as_ref().and_then(|c| np.block.cover_url(c)), - rating: song.rating, - }) - }); - - Self { - event: np.block.event, - end_event: np.block.end_event, - stream_url: np.block.url, - block_length_ms: np.block.length, - current_song_index: np.current_song_index, - current_song, - songs, - } - } -} - -/// GET /now-playing - Récupère le morceau en cours -#[utoipa::path( - get, - path = "/now-playing", - params( - ("channel" = Option, Query, description = "Channel ID (0-3)") - ), - responses( - (status = 200, description = "Morceau en cours", body = NowPlayingResponse), - (status = 500, description = "Erreur serveur") - ), - tag = "Radio Paradise" -)] -async fn get_now_playing( - State(state): State, - Query(params): Query, -) -> Result, StatusCode> { - let client = state.client_for_params(¶ms).await?; - let now_playing = client.now_playing().await.map_err(|e| { - tracing::error!("Failed to fetch now playing from Radio Paradise: {}", e); - StatusCode::INTERNAL_SERVER_ERROR - })?; - - Ok(Json(now_playing.into())) -} - -/// GET /block/current - Récupère le block actuel -#[utoipa::path( - get, - path = "/block/current", - params( - ("channel" = Option, Query, description = "Channel ID (0-3)") - ), - responses( - (status = 200, description = "Block actuel", body = BlockResponse), - (status = 500, description = "Erreur serveur") - ), - tag = "Radio Paradise" -)] -async fn get_current_block( - State(state): State, - Query(params): Query, -) -> Result, StatusCode> { - let client = state.client_for_params(¶ms).await?; - let block = client.get_block(None).await.map_err(|e| { - tracing::error!("Failed to fetch current block from Radio Paradise: {}", e); - StatusCode::INTERNAL_SERVER_ERROR - })?; - - Ok(Json(block.into())) -} - -/// GET /block/{event_id} - Récupère un block spécifique -#[utoipa::path( - get, - path = "/block/{event_id}", - params( - ("event_id" = u64, Path, description = "Event ID du block"), - ("channel" = Option, Query, description = "Channel ID (0-3)") - ), - responses( - (status = 200, description = "Block demandé", body = BlockResponse), - (status = 500, description = "Erreur serveur") - ), - tag = "Radio Paradise" -)] -async fn get_block_by_id( - State(state): State, - Path(event_id): Path, - Query(params): Query, -) -> Result, StatusCode> { - let client = state.client_for_params(¶ms).await?; - let block = client.get_block(Some(event_id)).await.map_err(|e| { - tracing::error!( - "Failed to fetch block {} from Radio Paradise: {}", - event_id, - e - ); - StatusCode::INTERNAL_SERVER_ERROR - })?; - - Ok(Json(block.into())) -} - -/// GET /channels - Liste les canaux disponibles -#[utoipa::path( - get, - path = "/channels", - responses( - (status = 200, description = "Liste des canaux", body = Vec) - ), - tag = "Radio Paradise" -)] -async fn get_channels() -> Json> { - let channels: Vec = ALL_CHANNELS.iter().map(Into::into).collect(); - Json(channels) -} - -/// GET /block/{event_id}/song/{index} - Récupère un morceau spécifique d'un block -#[utoipa::path( - get, - path = "/block/{event_id}/song/{index}", - params( - ("event_id" = u64, Path, description = "Event ID du block"), - ("index" = usize, Path, description = "Index du morceau (0-based)"), - ("channel" = Option, Query, description = "Channel ID (0-3)") - ), - responses( - (status = 200, description = "Morceau demandé", body = SongInfo), - (status = 404, description = "Morceau non trouvé"), - (status = 500, description = "Erreur serveur") - ), - tag = "Radio Paradise" -)] -async fn get_song_by_index( - State(state): State, - Path((event_id, index)): Path<(u64, usize)>, - Query(params): Query, -) -> Result, StatusCode> { - let client = state.client_for_params(¶ms).await?; - let block = client.get_block(Some(event_id)).await.map_err(|e| { - tracing::error!( - "Failed to fetch block {} from Radio Paradise: {}", - event_id, - e - ); - StatusCode::INTERNAL_SERVER_ERROR - })?; - - let song = block.get_song(index).ok_or_else(|| { - tracing::warn!("Song index {} not found in block {}", index, event_id); - StatusCode::NOT_FOUND - })?; - - let song_info = SongInfo { - index, - artist: song.artist.clone(), - title: song.title.clone(), - album: song.album.clone().unwrap_or_default(), - year: song.year, - elapsed_ms: song.elapsed, - duration_ms: song.duration, - cover_url: song.cover.as_ref().and_then(|c| block.cover_url(c)), - rating: song.rating, - }; - - Ok(Json(song_info)) -} - -/// GET /cover-url/{event_id}/{song_index} - Récupère l'URL de la pochette d'un morceau -/// -/// Utilise automatiquement cover_large si disponible, sinon cover en fallback -#[utoipa::path( - get, - path = "/cover-url/{event_id}/{song_index}", - params( - ("event_id" = u64, Path, description = "Event ID du block"), - ("song_index" = usize, Path, description = "Index du morceau (0-based)"), - ("channel" = Option, Query, description = "Channel ID (0-3)") - ), - responses( - (status = 200, description = "URL de la pochette avec fallback automatique", body = CoverUrlResponse), - (status = 404, description = "Morceau non trouvé"), - (status = 500, description = "Erreur serveur") - ), - tag = "Radio Paradise" -)] -async fn get_cover_url( - State(state): State, - Path((event_id, song_index)): Path<(u64, usize)>, - Query(params): Query, -) -> Result, StatusCode> { - let client = state.client_for_params(¶ms).await?; - let block = client.get_block(Some(event_id)).await.map_err(|e| { - tracing::error!( - "Failed to fetch block {} from Radio Paradise: {}", - event_id, - e - ); - StatusCode::INTERNAL_SERVER_ERROR - })?; - - let song = block.get_song(song_index).ok_or_else(|| { - tracing::warn!("Song index {} not found in block {}", song_index, event_id); - StatusCode::NOT_FOUND - })?; - - // Fallback: cover_large → cover → none - let (cover_url, cover_type) = if let Some(ref cover_large) = song.cover_large { - (block.cover_url(cover_large), "cover_large") - } else if let Some(ref cover) = song.cover { - (block.cover_url(cover), "cover") - } else { - (None, "none") - }; - - Ok(Json(CoverUrlResponse { - event: event_id, - song_index, - cover_url, - cover_type: cover_type.to_string(), - })) -} - -/// GET /stream-url/{event_id} - Récupère l'URL de streaming direct d'un block -#[utoipa::path( - get, - path = "/stream-url/{event_id}", - params( - ("event_id" = u64, Path, description = "Event ID du block (None pour le block actuel)"), - ("channel" = Option, Query, description = "Channel ID (0-3)") - ), - responses( - (status = 200, description = "URL de streaming", body = StreamUrlResponse), - (status = 500, description = "Erreur serveur") - ), - tag = "Radio Paradise" -)] -async fn get_stream_url( - State(state): State, - Path(event_id): Path, - Query(params): Query, -) -> Result, StatusCode> { - let client = state.client_for_params(¶ms).await?; - let block = client.get_block(Some(event_id)).await.map_err(|e| { - tracing::error!( - "Failed to fetch block {} from Radio Paradise: {}", - event_id, - e - ); - StatusCode::INTERNAL_SERVER_ERROR - })?; - - Ok(Json(StreamUrlResponse { - event: block.event, - stream_url: block.url, - length_ms: block.length, - })) -} - -/// Documentation OpenAPI pour l'API Radio Paradise -#[derive(OpenApi)] -#[openapi( - info( - title = "Radio Paradise API", - version = "1.0.0", - description = r#" -# API REST pour Radio Paradise - -Cette API permet d'accéder aux métadonnées et flux de Radio Paradise. - -## Fonctionnalités - -- **Métadonnées en temps réel** : Récupération du morceau en cours et des blocks -- **Multi-canaux** : Support des 4 canaux Radio Paradise (Main, Mellow, Rock, Eclectic) -- **Streaming FLAC** : Accès direct aux URLs de streaming haute qualité -- **Pochettes d'albums** : URLs complètes des couvertures (petite et grande taille) -- **Historique** : Accès aux blocks passés via event_id - -## Canaux disponibles - -- **0: Main Mix** - Eclectic mix of rock, world, electronica, and more -- **1: Mellow Mix** - Mellower, less aggressive music -- **2: Rock Mix** - Heavier, more guitar-driven music -- **3: Eclectic Mix** - Curated worldwide selection - -## Format des données - -### Blocks -Les blocks sont des fichiers FLAC continus contenant plusieurs morceaux. -Chaque block a un `event` (ID de début) et `end_event` (ID du prochain block). - -### Timing -- Tous les temps sont en millisecondes (ms) -- `elapsed_ms` : temps écoulé depuis le début du block -- `duration_ms` : durée du morceau - -## Exemples d'utilisation - -### Récupérer le morceau en cours -``` -GET /api/radioparadise/now-playing?channel=0 -``` - -### Récupérer un block spécifique -``` -GET /api/radioparadise/block/1234567?channel=0 -``` - -### Récupérer la pochette d'un morceau (avec fallback automatique) -``` -GET /api/radioparadise/cover-url/1234567/0?channel=0 -``` - "# - ), - paths( - get_now_playing, - get_current_block, - get_block_by_id, - get_channels, - get_song_by_index, - get_cover_url, - get_stream_url - ), - components(schemas( - NowPlayingResponse, - BlockResponse, - SongInfo, - ChannelInfo, - StreamUrlResponse, - CoverUrlResponse - )), - tags( - (name = "Radio Paradise", description = "Endpoints pour Radio Paradise") - ) -)] -pub struct RadioParadiseApiDoc; - -/// Crée le router pour l'API Radio Paradise -pub fn create_api_router(state: RadioParadiseState) -> Router { - Router::new() - .route("/now-playing", get(get_now_playing)) - .route("/block/current", get(get_current_block)) - .route("/block/{event_id}", get(get_block_by_id)) - .route("/block/{event_id}/song/{index}", get(get_song_by_index)) - .route("/cover-url/{event_id}/{song_index}", get(get_cover_url)) - .route("/stream-url/{event_id}", get(get_stream_url)) - .route("/channels", get(get_channels)) - .with_state(state) -} - -/// Trait d'extension pour pmoserver::Server -/// -/// Permet d'initialiser Radio Paradise avec routes HTTP complètes -#[cfg(feature = "pmoserver")] -#[async_trait] -pub trait RadioParadiseExt { - /// Initialise l'API Radio Paradise - /// - /// # Routes créées - /// - /// - API: `/api/radioparadise/*` - /// - `/now-playing` - /// - `/block/*` - /// - `/channels` - /// - Swagger: `/swagger-ui/radioparadise` - async fn init_radioparadise(&mut self) -> anyhow::Result; -} - -#[cfg(feature = "pmoserver")] -#[async_trait] -impl RadioParadiseExt for pmoserver::Server { - async fn init_radioparadise(&mut self) -> anyhow::Result { - let state = RadioParadiseState::new().await?; - - // Créer le router API - let api_router = create_api_router(state.clone()); - - // L'enregistrer avec OpenAPI - self.add_openapi(api_router, RadioParadiseApiDoc::openapi(), "radioparadise") - .await; - - Ok(state) - } -} --------End of pmoparadise/src/pmoserver_ext.rs --------- - ------------- pmoparadise/src/radio_paradise_stream_source.rs ---------- -//! RadioParadiseStreamSource - Node audio pmoaudio pour Radio Paradise -//! -//! Ce node télécharge et décode les blocs FLAC de Radio Paradise en streaming, -//! avec insertion automatique des TrackBoundary au bon timing. - -use crate::{ - client::RadioParadiseClient, - models::{Block, EventId, Song}, - node_stats::NodeStats, -}; -use futures_util::StreamExt; -use pmoaudio::{ - nodes::{AudioError, TypedAudioNode, DEFAULT_CHUNK_DURATION_MS}, - pipeline::{send_to_children, send_to_children_with_timing, Node, NodeLogic}, - type_constraints::TypeRequirement, - AudioPipelineNode, AudioSegment, SyncMarker, I24, -}; -use pmoflac::decode_audio_stream; -use pmometadata::{MemoryTrackMetadata, TrackMetadata}; -use std::{ - collections::VecDeque, - sync::{Arc, Mutex}, - time::{Duration, Instant}, -}; -use tokio::io::AsyncReadExt; -use tokio::sync::{mpsc, Notify, RwLock}; -use tokio_util::{io::StreamReader, sync::CancellationToken}; - -/// Signal spécial pour indiquer qu'il n'y aura plus de blocs -/// Quand ce blockid est poussé dans la queue, le source termine proprement -/// après avoir fini de traiter le bloc en cours -pub const END_OF_BLOCKS_SIGNAL: EventId = EventId::MAX; - -/// Nombre de blocs récents à mémoriser pour éviter les re-téléchargements -const RECENT_BLOCKS_CACHE_SIZE: usize = 10; - -/// Handle pour alimenter la queue de blocs pendant que la source tourne. -#[derive(Clone, Default)] -pub struct BlockQueueHandle { - queue: Arc>>, - notify: Arc, -} - -impl BlockQueueHandle { - fn new() -> Self { - Self { - queue: Arc::new(Mutex::new(VecDeque::new())), - notify: Arc::new(Notify::new()), - } - } - - /// Enfile un block pour traitement. - pub fn enqueue(&self, event_id: EventId) { - { - let mut queue = self.queue.lock().expect("block queue poisoned"); - queue.push_back(event_id); - } - self.notify.notify_one(); - } - - /// Retire le prochain block s'il existe. - fn pop(&self) -> Option { - let mut queue = self.queue.lock().expect("block queue poisoned"); - queue.pop_front() - } - - /// Nombre d'éléments en attente. - pub fn len(&self) -> usize { - let queue = self.queue.lock().expect("block queue poisoned"); - queue.len() - } - - fn snapshot(&self) -> Vec { - let queue = self.queue.lock().expect("block queue poisoned"); - queue.iter().copied().collect() - } - - fn front(&self) -> Option { - let queue = self.queue.lock().expect("block queue poisoned"); - queue.front().copied() - } - - fn back(&self) -> Option { - let queue = self.queue.lock().expect("block queue poisoned"); - queue.back().copied() - } -} - -// ═══════════════════════════════════════════════════════════════════════════ -// RadioParadiseStreamSourceLogic - Logique métier pure -// ═══════════════════════════════════════════════════════════════════════════ - -/// Logique pure de téléchargement et décodage des blocs Radio Paradise -pub struct RadioParadiseStreamSourceLogic { - client: RadioParadiseClient, - chunk_frames: usize, - recent_blocks: VecDeque, - block_queue: BlockQueueHandle, - stats: Arc, -} - -impl RadioParadiseStreamSourceLogic { - pub fn new(client: RadioParadiseClient, chunk_duration_ms: u32) -> Self { - let handle = BlockQueueHandle::new(); - Self::with_queue(client, chunk_duration_ms, handle) - } - - fn with_queue( - client: RadioParadiseClient, - chunk_duration_ms: u32, - block_queue: BlockQueueHandle, - ) -> Self { - // Calculer chunk_frames pour la durée cible (on suppose 44.1kHz) - let chunk_frames = ((chunk_duration_ms as f64 / 1000.0) * 44100.0) as usize; - - Self { - client, - chunk_frames, - recent_blocks: VecDeque::with_capacity(RECENT_BLOCKS_CACHE_SIZE), - block_queue, - stats: NodeStats::new("RadioParadiseStreamSource"), - } - } - - /// Ajoute un block ID à la file d'attente - pub fn push_block_id(&self, event_id: EventId) { - self.block_queue.enqueue(event_id); - } - - /// Vérifie si un bloc a été téléchargé récemment - fn is_recent_block(&self, event_id: EventId) -> bool { - self.recent_blocks.contains(&event_id) - } - - /// Marque un bloc comme récemment téléchargé (FIFO) - fn mark_block_downloaded(&mut self, event_id: EventId) { - // Retirer tous les éléments excédentaires (garantit <= CACHE_SIZE) - while self.recent_blocks.len() >= RECENT_BLOCKS_CACHE_SIZE { - self.recent_blocks.pop_front(); - } - - // Puis ajouter le nouveau bloc - self.recent_blocks.push_back(event_id); - } - - /// Télécharge et décode un bloc FLAC - /// Retourne (timestamp_final, instant_debut) pour permettre le timing correct - async fn download_and_decode_block( - &mut self, - block: &Block, - output: &[mpsc::Sender>], - stop_token: &CancellationToken, - order: &mut u64, - ) -> Result<(f64, Instant), AudioError> { - // Télécharger le FLAC - tracing::info!( - "Sending HTTP GET request for block FLAC (expected duration: {:.1}min, url: {})", - block.length as f64 / 60000.0, - block.url - ); - let response = self - .client - .client - .get(&block.url) - .timeout(self.client.block_timeout) - .send() - .await - .map_err(|e| AudioError::ProcessingError(format!("Block download failed: {}", e)))?; - - tracing::debug!("HTTP response received, status={}", response.status()); - if !response.status().is_success() { - return Err(AudioError::ProcessingError(format!( - "Block download returned status {}", - response.status() - ))); - } - - // Vérifier la taille du contenu si disponible - if let Some(content_length) = response.content_length() { - tracing::info!( - "HTTP Content-Length: {} bytes ({:.1} MB)", - content_length, - content_length as f64 / 1_048_576.0 - ); - } else { - tracing::warn!("HTTP response has no Content-Length header"); - } - - // Créer un stream reader - tracing::debug!("Creating byte stream reader"); - let byte_stream = response - .bytes_stream() - .map(|result| result.map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e))); - let stream_reader = StreamReader::new(byte_stream); - tracing::debug!("Stream reader created"); - - // Décoder le FLAC - tracing::debug!("Decoding FLAC stream..."); - let mut decoder = decode_audio_stream(stream_reader) - .await - .map_err(|e| AudioError::ProcessingError(format!("FLAC decode failed: {}", e)))?; - - let stream_info = decoder.info().clone(); - let sample_rate = stream_info.sample_rate; - let bits_per_sample = stream_info.bits_per_sample; - tracing::debug!( - "FLAC decoder initialized: {}Hz, {} bits/sample", - sample_rate, - bits_per_sample - ); - - // Préparer les songs ordonnées pour tracking - let songs = block.songs_ordered(); - let mut song_index = 0; - let mut total_samples = 0u64; - tracing::debug!("Block has {} songs", songs.len()); - - // Noter l'instant de début AVANT d'envoyer TopZeroSync - // Ceci permet de synchroniser la durée réelle du bloc - let start_instant = Instant::now(); - - // Envoyer TopZeroSync au début du bloc - tracing::debug!("Sending TopZeroSync to {} outputs", output.len()); - let top_zero = Arc::new(AudioSegment { - order: *order, - timestamp_sec: 0.0, - segment: pmoaudio::_AudioSegment::Sync(Arc::new(SyncMarker::TopZeroSync)), - }); - self.send_to_children(output, top_zero).await?; - tracing::debug!("TopZeroSync sent"); - - // Envoyer TrackBoundary pour la première song AVANT le premier chunk audio - // Même si son elapsed > 0, cela garantit que FlacCacheSink a des métadonnées - // dès le début (sinon il attendrait indéfiniment un TrackBoundary) - let mut next_song: Option<(usize, &Song)> = if let Some((idx, song)) = songs.get(0).copied() - { - tracing::debug!( - "Sending TrackBoundary for first song (idx={}, elapsed={}ms) at timestamp 0", - idx, - song.elapsed - ); - let metadata = song_to_metadata(song, block).await; - let track_boundary = AudioSegment::new_track_boundary( - *order, 0.0, // timestamp = 0 au début du stream - metadata, - ); - self.send_to_children(output, track_boundary).await?; - song_index = 1; - // Le prochain TrackBoundary sera pour la deuxième song quand elapsed_ms >= song.elapsed - songs.get(1).copied() - } else { - None - }; - tracing::debug!("Starting audio chunk loop"); - - // Buffer pour lecture - let bytes_per_sample = (bits_per_sample / 8) as usize; - let frame_bytes = bytes_per_sample * 2; // stereo - let chunk_frames = self.chunk_frames; - let chunk_byte_len = chunk_frames * frame_bytes; - let mut read_buf = vec![0u8; chunk_byte_len * 2]; - let mut pending: Vec = Vec::with_capacity(chunk_byte_len * 2); - - // Traiter les chunks audio - let mut chunk_count = 0; - let mut total_bytes_decoded = 0u64; - let expected_duration_sec = block.length as f64 / 1000.0; - let mut stats_last_log = Instant::now(); - - loop { - // Vérifier stop_token - if stop_token.is_cancelled() { - // Retourner le timestamp actuel et start_instant si on est interrompu - let current_timestamp = total_samples as f64 / sample_rate as f64; - tracing::warn!( - "Block decode CANCELLED: sent {} chunks, {:.2}s duration ({:.1}% of expected {:.2}s), decoded {} bytes", - chunk_count, current_timestamp, - (current_timestamp / expected_duration_sec) * 100.0, - expected_duration_sec, total_bytes_decoded - ); - return Ok((current_timestamp, start_instant)); - } - - // Remplir le buffer - if pending.len() < chunk_byte_len { - let read = decoder - .read(&mut read_buf) - .await - .map_err(|e| AudioError::ProcessingError(format!("Read error: {}", e)))?; - - if read == 0 { - let actual_duration = total_samples as f64 / sample_rate as f64; - let percentage = (actual_duration / expected_duration_sec) * 100.0; - - if percentage < 95.0 { - tracing::error!( - "FLAC decode EOF PREMATURE: sent {} chunks, {:.2}s actual vs {:.2}s expected ({:.1}%), decoded {} bytes", - chunk_count, actual_duration, expected_duration_sec, percentage, total_bytes_decoded - ); - } else { - tracing::info!( - "FLAC decode EOF reached: sent {} chunks, {:.2}s duration ({:.1}% of expected), decoded {} bytes", - chunk_count, actual_duration, percentage, total_bytes_decoded - ); - } - break; // EOF - } - total_bytes_decoded += read as u64; - pending.extend_from_slice(&read_buf[..read]); - } - - if pending.is_empty() { - break; - } - - // Extraire un chunk - let frames_in_pending = pending.len() / frame_bytes; - let frames_to_emit = frames_in_pending.min(chunk_frames); - let take_bytes = frames_to_emit * frame_bytes; - let pcm_data = pending.drain(..take_bytes).collect::>(); - - // Calculer le nombre de frames (samples par canal) - let bytes_per_sample = (bits_per_sample / 8) as usize; - let chunk_len = (pcm_data.len() / (bytes_per_sample * 2)) as u64; // 2 = stereo - - // Vérifier si on doit insérer un TrackBoundary avant ce chunk - if let Some((idx, song)) = next_song { - let elapsed_ms = (total_samples * 1000) / sample_rate as u64; - - if elapsed_ms >= song.elapsed { - // Envoyer TrackBoundary AVANT le chunk (avec le même order) - tracing::debug!( - "Sending TrackBoundary for song {} at elapsed_ms={} (song.elapsed={}, timestamp_sec={:.2})", - idx, elapsed_ms, song.elapsed, (total_samples as f64 / sample_rate as f64) - ); - let metadata = song_to_metadata(song, block).await; - let timestamp_sec = total_samples as f64 / sample_rate as f64; - let track_boundary = - AudioSegment::new_track_boundary(*order, timestamp_sec, metadata); - self.send_to_children(output, track_boundary).await?; - - // Passer à la song suivante - song_index += 1; - next_song = songs.get(song_index).copied(); - tracing::debug!( - "Moved to next song, song_index={}, next_song present={}", - song_index, - next_song.is_some() - ); - } - } - - // Envoyer le chunk audio - let timestamp_sec = total_samples as f64 / sample_rate as f64; - if stats_last_log.elapsed() >= Duration::from_secs(1) { - let real_elapsed = start_instant.elapsed().as_secs_f64(); - tracing::debug!( - "RP timing: chunk={} ts={:.3}s real_elapsed={:.3}s delta={:.3}s chunk_len={} frames", - chunk_count, - timestamp_sec, - real_elapsed, - timestamp_sec - real_elapsed, - chunk_len - ); - stats_last_log = Instant::now(); - } - let audio_segment = pcm_to_audio_segment( - &pcm_data, - *order, - timestamp_sec, - sample_rate, - bits_per_sample, - )?; - self.send_to_children(output, audio_segment).await?; - - *order += 1; - total_samples += chunk_len; - chunk_count += 1; - } - - // Retourner le timestamp du dernier chunk (durée totale du bloc) et l'instant de début - let final_timestamp = total_samples as f64 / sample_rate as f64; - tracing::debug!( - "Block decode complete: {} samples, {:.2}s duration", - total_samples, - final_timestamp - ); - - Ok((final_timestamp, start_instant)) - } - - /// Envoie un segment à tous les enfants - async fn send_to_children( - &self, - output: &[mpsc::Sender>], - segment: Arc, - ) -> Result<(), AudioError> { - let segment_ts = segment.timestamp_sec; - self.stats.record_segment_received(segment_ts); - - let segment_bytes = match &segment.segment { - pmoaudio::_AudioSegment::Chunk(chunk) => chunk.len() * 2 * 4, - _ => 0, - }; - - send_to_children_with_timing( - std::any::type_name::(), - output, - segment, - |i, send_duration, capacity_before| { - tracing::trace!( - "send_to_children: Sending to child {} (channel capacity={}, timestamp={:.3}s)", - i, - capacity_before, - segment_ts - ); - - if send_duration.as_millis() > 10 { - let duration_ms = send_duration.as_millis() as u64; - self.stats.record_backpressure(duration_ms); - tracing::trace!( - "send_to_children: Send to child {} BLOCKED for {:.3}s (channel capacity before send={}, timestamp={:.3}s)", - i, - send_duration.as_secs_f64(), - capacity_before, - segment_ts - ); - } - - self.stats.record_segment_sent(segment_bytes); - }, - ) - .await?; - Ok(()) - } -} - -/// Convertit PCM bytes en AudioSegment -fn pcm_to_audio_segment( - pcm_data: &[u8], - order: u64, - timestamp_sec: f64, - sample_rate: u32, - bits_per_sample: u8, -) -> Result, AudioError> { - use pmoaudio::{AudioChunk, AudioChunkData, _AudioSegment}; - - let bytes_per_sample = (bits_per_sample / 8) as usize; - let channels = 2; // Stereo - let frame_bytes = bytes_per_sample * channels; - let frames = pcm_data.len() / frame_bytes; - - // Valider que la taille des données est correcte - if pcm_data.len() % frame_bytes != 0 { - return Err(AudioError::ProcessingError(format!( - "Invalid PCM data size: {} bytes is not a multiple of frame size {} ({}bit, {} channels)", - pcm_data.len(), - frame_bytes, - bits_per_sample, - channels - ))); - } - - let chunk = match bits_per_sample { - 16 => { - // Type I16 - let mut stereo = Vec::with_capacity(frames); - for frame_idx in 0..frames { - let base = frame_idx * frame_bytes; - let left = i16::from_le_bytes([pcm_data[base], pcm_data[base + 1]]); - let right = i16::from_le_bytes([pcm_data[base + 2], pcm_data[base + 3]]); - stereo.push([left, right]); - } - let chunk_data = AudioChunkData::new(stereo, sample_rate, 0.0); - AudioChunk::I16(chunk_data) - } - 24 => { - // Type I24 avec sign extension correcte - let mut stereo = Vec::with_capacity(frames); - for frame_idx in 0..frames { - let base = frame_idx * frame_bytes; - - // Left channel (bytes 0,1,2) avec sign extension - let left_i32 = { - let mut buf = [0u8; 4]; - buf[..3].copy_from_slice(&pcm_data[base..base + 3]); - // Sign extend si négatif - if pcm_data[base + 2] & 0x80 != 0 { - buf[3] = 0xFF; - } - i32::from_le_bytes(buf) - }; - let left = I24::new(left_i32).ok_or_else(|| { - AudioError::ProcessingError(format!("Invalid I24 value: {}", left_i32)) - })?; - - // Right channel (bytes 3,4,5) avec sign extension - let right_i32 = { - let mut buf = [0u8; 4]; - buf[..3].copy_from_slice(&pcm_data[base + 3..base + 6]); - // Sign extend si négatif - if pcm_data[base + 5] & 0x80 != 0 { - buf[3] = 0xFF; - } - i32::from_le_bytes(buf) - }; - let right = I24::new(right_i32).ok_or_else(|| { - AudioError::ProcessingError(format!("Invalid I24 value: {}", right_i32)) - })?; - - stereo.push([left, right]); - } - let chunk_data = AudioChunkData::new(stereo, sample_rate, 0.0); - AudioChunk::I24(chunk_data) - } - 32 => { - // Type I32 - let mut stereo = Vec::with_capacity(frames); - for frame_idx in 0..frames { - let base = frame_idx * frame_bytes; - let left = i32::from_le_bytes([ - pcm_data[base], - pcm_data[base + 1], - pcm_data[base + 2], - pcm_data[base + 3], - ]); - let right = i32::from_le_bytes([ - pcm_data[base + 4], - pcm_data[base + 5], - pcm_data[base + 6], - pcm_data[base + 7], - ]); - stereo.push([left, right]); - } - let chunk_data = AudioChunkData::new(stereo, sample_rate, 0.0); - AudioChunk::I32(chunk_data) - } - _ => { - return Err(AudioError::ProcessingError(format!( - "Unsupported bit depth: {}", - bits_per_sample - ))) - } - }; - - Ok(Arc::new(AudioSegment { - order, - timestamp_sec, - segment: _AudioSegment::Chunk(Arc::new(chunk)), - })) -} - -/// Convertit Song en TrackMetadata -/// -/// Configure toutes les métadonnées de manière asynchrone et attend que la configuration -/// soit terminée avant de retourner, garantissant que les métadonnées (y compris cover_url) -/// sont disponibles immédiatement pour les nodes suivants -async fn song_to_metadata(song: &Song, block: &Block) -> Arc> { - let metadata = MemoryTrackMetadata::new(); - let metadata_arc = Arc::new(RwLock::new(metadata)) as Arc>; - - // Cloner les données - let title = song.title.clone(); - let artist = song.artist.clone(); - let album = song.album.clone(); - let year = song.year; - let cover_url = song.cover.as_ref().and_then(|cover| block.cover_url(cover)); - - // Configurer les métadonnées de manière synchrone (mais async await) - { - let mut meta = metadata_arc.write().await; - - // Ces méthodes peuvent échouer (retournent Result), donc on log les erreurs - if let Err(e) = meta.set_title(Some(title)).await { - tracing::warn!("Failed to set title: {}", e); - } - if let Err(e) = meta.set_artist(Some(artist)).await { - tracing::warn!("Failed to set artist: {}", e); - } - if let Some(album) = album { - if let Err(e) = meta.set_album(Some(album)).await { - tracing::warn!("Failed to set album: {}", e); - } - } - if let Some(year) = year { - if let Err(e) = meta.set_year(Some(year)).await { - tracing::warn!("Failed to set year: {}", e); - } - } - if let Some(ref url) = cover_url { - tracing::debug!("RadioParadiseStreamSource: Setting cover_url to: {}", url); - if let Err(e) = meta.set_cover_url(Some(url.clone())).await { - tracing::warn!("Failed to set cover_url: {}", e); - } else { - tracing::debug!("RadioParadiseStreamSource: Successfully set cover_url"); - } - } else { - tracing::debug!("RadioParadiseStreamSource: No cover URL available for song"); - } - } - - metadata_arc -} - -#[async_trait::async_trait] -impl NodeLogic for RadioParadiseStreamSourceLogic { - async fn process( - &mut self, - _input: Option>>, - output: Vec>>, - stop_token: CancellationToken, - ) -> Result<(), AudioError> { - tracing::debug!( - "RadioParadiseStreamSource::process() started, block_queue has {} items", - self.block_queue.len() - ); - for (i, event_id) in self.block_queue.snapshot().iter().enumerate() { - tracing::debug!(" block_queue[{}] = {}", i, event_id); - } - - let mut order = 0u64; - let mut last_timestamp = 0.0; - let mut last_start_instant: Option = None; - - loop { - // Attendre un block ID depuis la queue (pas de timeout - mode idle) - tracing::debug!("Waiting for block_id from queue (idle mode, no timeout)..."); - let event_id = loop { - // Vérifier d'abord le stop_token - if stop_token.is_cancelled() { - tracing::info!("Stop token cancelled while waiting for block_id"); - break None; - } - - // Essayer de pop un event_id - if let Some(id) = self.block_queue.pop() { - tracing::debug!("Got event_id {} from queue", id); - - // Vérifier si c'est le signal de fin - if id == END_OF_BLOCKS_SIGNAL { - tracing::info!( - "Received END_OF_BLOCKS_SIGNAL, finishing after current block" - ); - break None; - } - - break Some(id); - } - - tracing::trace!("block_queue is empty, waiting for new events..."); - tokio::select! { - _ = stop_token.cancelled() => break None, - _ = self.block_queue.notify.notified() => {}, - _ = tokio::time::sleep(Duration::from_millis(100)) => {} - }; - }; - - // Si on n'a pas d'event_id, on termine - let event_id = match event_id { - Some(id) => id, - None => { - tracing::info!("No more blocks to process, exiting loop"); - break; - } - }; - - // Vérifier si déjà téléchargé récemment - if self.is_recent_block(event_id) { - tracing::debug!("Block {} was recently downloaded, skipping", event_id); - continue; - } - - // Récupérer les métadonnées du bloc - tracing::debug!("Fetching block metadata for event_id {}...", event_id); - let block = - self.client.get_block(Some(event_id)).await.map_err(|e| { - AudioError::ProcessingError(format!("Failed to get block: {}", e)) - })?; - tracing::debug!("Block metadata received: url={}", block.url); - - // Marquer comme téléchargé - self.mark_block_downloaded(event_id); - - // Télécharger et décoder le bloc - tracing::info!("Starting download and decode for block {}...", event_id); - let (block_duration, start_instant) = self - .download_and_decode_block(&block, &output, &stop_token, &mut order) - .await?; - last_timestamp = block_duration; - last_start_instant = Some(start_instant); - tracing::info!( - "Finished download and decode for block {} (duration: {:.2}s)", - event_id, - block_duration - ); - } - - // Envoyer EndOfStream avec le timestamp du dernier chunk - tracing::info!( - "Sending EndOfStream with timestamp {:.2}s to {} outputs", - last_timestamp, - output.len() - ); - let eos = AudioSegment::new_end_of_stream(order, last_timestamp); - send_to_children(std::any::type_name::(), &output, eos).await?; - - // IMPORTANT: Attendre que tous les channels soient fermés par les enfants - // Cela garantit que tous les chunks (y compris ceux en attente dans les buffers MPSC) - // ont été traités avant que nous ne fermions notre bout - tracing::info!("Waiting for all child nodes to close their channels..."); - for (i, tx) in output.iter().enumerate() { - tracing::debug!("Waiting for child {} to close channel...", i); - tx.closed().await; - tracing::debug!("Child {} channel closed", i); - } - tracing::info!("All child channels closed, pipeline complete"); - - if let Some(start_instant) = last_start_instant { - let total_elapsed = start_instant.elapsed().as_secs_f64(); - tracing::info!( - "Block processing complete: duration={:.2}s, total_elapsed={:.2}s ({:.1}% of real-time)", - last_timestamp, total_elapsed, (total_elapsed / last_timestamp) * 100.0 - ); - } - - // Log des statistiques finales - tracing::info!("\n{}", self.stats.report()); - - Ok(()) - } -} - -// ═══════════════════════════════════════════════════════════════════════════ -// RadioParadiseStreamSource - Wrapper utilisant Node -// ═══════════════════════════════════════════════════════════════════════════ - -pub struct RadioParadiseStreamSource { - inner: Node, - block_handle: BlockQueueHandle, -} - -impl RadioParadiseStreamSource { - /// Crée une nouvelle source Radio Paradise avec durée de chunk par défaut - pub fn new(client: RadioParadiseClient) -> Self { - Self::with_chunk_duration(client, DEFAULT_CHUNK_DURATION_MS as u32) - } - - /// Crée une nouvelle source avec durée de chunk personnalisée - pub fn with_chunk_duration(client: RadioParadiseClient, chunk_duration_ms: u32) -> Self { - let handle = BlockQueueHandle::new(); - let logic = - RadioParadiseStreamSourceLogic::with_queue(client, chunk_duration_ms, handle.clone()); - Self { - inner: Node::new_source(logic), - block_handle: handle, - } - } - - /// Ajoute un block ID à la file d'attente de téléchargement - pub fn push_block_id(&self, event_id: EventId) { - self.block_handle.enqueue(event_id); - } - - /// Retourne un handle permettant d'enfiler des blocks dynamiquement. - pub fn block_handle(&self) -> BlockQueueHandle { - self.block_handle.clone() - } -} - -#[async_trait::async_trait] -impl AudioPipelineNode for RadioParadiseStreamSource { - fn get_tx(&self) -> Option>> { - self.inner.get_tx() - } - - fn register(&mut self, child: Box) { - self.inner.register(child); - } - - async fn run(self: Box, stop_token: CancellationToken) -> Result<(), AudioError> { - Box::new(self.inner).run(stop_token).await - } -} - -impl TypedAudioNode for RadioParadiseStreamSource { - fn input_type(&self) -> Option { - None // Source node - } - - fn output_type(&self) -> Option { - // Radio Paradise FLAC peut être 16-bit, 24-bit, ou 32-bit - // La profondeur est détectée automatiquement depuis le header FLAC - Some(TypeRequirement::any_integer()) - } -} - -#[cfg(test)] -mod tests { - use super::*; - - fn create_test_client() -> RadioParadiseClient { - RadioParadiseClient::with_client(reqwest::Client::new()) - } - - #[test] - fn test_cache_fifo_basic() { - let client = create_test_client(); - let mut logic = - RadioParadiseStreamSourceLogic::new(client, DEFAULT_CHUNK_DURATION_MS as u32); - - // Ajouter 5 blocs - for i in 1..=5 { - logic.mark_block_downloaded(i); - } - - // Vérifier que tous sont dans le cache - for i in 1..=5 { - assert!(logic.is_recent_block(i), "Block {} should be in cache", i); - } - assert_eq!(logic.recent_blocks.len(), 5); - } - - #[test] - fn test_cache_fifo_exactly_10_elements() { - let client = create_test_client(); - let mut logic = - RadioParadiseStreamSourceLogic::new(client, DEFAULT_CHUNK_DURATION_MS as u32); - - // Ajouter exactement 10 blocs - for i in 1..=10 { - logic.mark_block_downloaded(i); - } - - // Vérifier qu'on a exactement 10 éléments - assert_eq!( - logic.recent_blocks.len(), - 10, - "Cache should have exactly 10 elements" - ); - - // Tous devraient être dans le cache - for i in 1..=10 { - assert!(logic.is_recent_block(i), "Block {} should be in cache", i); - } - } - - #[test] - fn test_cache_fifo_eviction_oldest() { - let client = create_test_client(); - let mut logic = - RadioParadiseStreamSourceLogic::new(client, DEFAULT_CHUNK_DURATION_MS as u32); - - // Remplir le cache avec 10 éléments (1..=10) - for i in 1..=10 { - logic.mark_block_downloaded(i); - } - - // Ajouter un 11ème élément - logic.mark_block_downloaded(11); - - // Le cache doit toujours avoir 10 éléments - assert_eq!( - logic.recent_blocks.len(), - 10, - "Cache should still have 10 elements" - ); - - // Le premier (plus ancien) doit avoir été évincé - assert!( - !logic.is_recent_block(1), - "Oldest block (1) should be evicted" - ); - - // Les éléments 2..=11 doivent être présents - for i in 2..=11 { - assert!(logic.is_recent_block(i), "Block {} should be in cache", i); - } - } - - #[test] - fn test_cache_fifo_multiple_evictions() { - let client = create_test_client(); - let mut logic = - RadioParadiseStreamSourceLogic::new(client, DEFAULT_CHUNK_DURATION_MS as u32); - - // Remplir avec 10 éléments - for i in 1..=10 { - logic.mark_block_downloaded(i); - } - - // Ajouter 5 éléments supplémentaires - for i in 11..=15 { - logic.mark_block_downloaded(i); - } - - // Toujours 10 éléments - assert_eq!( - logic.recent_blocks.len(), - 10, - "Cache should have 10 elements" - ); - - // Les 5 premiers doivent avoir été évincés - for i in 1..=5 { - assert!(!logic.is_recent_block(i), "Block {} should be evicted", i); - } - - // Les éléments 6..=15 doivent être présents - for i in 6..=15 { - assert!(logic.is_recent_block(i), "Block {} should be in cache", i); - } - } - - #[test] - fn test_cache_never_exceeds_capacity() { - let client = create_test_client(); - let mut logic = - RadioParadiseStreamSourceLogic::new(client, DEFAULT_CHUNK_DURATION_MS as u32); - - // Vérifier la capacité pré-allouée - assert_eq!(logic.recent_blocks.capacity(), RECENT_BLOCKS_CACHE_SIZE); - - // Ajouter beaucoup d'éléments - for i in 1..=100 { - logic.mark_block_downloaded(i); - - // À chaque itération, vérifier qu'on ne dépasse jamais 10 - assert!( - logic.recent_blocks.len() <= RECENT_BLOCKS_CACHE_SIZE, - "Cache size {} exceeded max {}", - logic.recent_blocks.len(), - RECENT_BLOCKS_CACHE_SIZE - ); - } - - // Finalement, on doit avoir exactement 10 éléments - assert_eq!(logic.recent_blocks.len(), 10); - - // Ce doivent être les 10 derniers (91..=100) - for i in 91..=100 { - assert!(logic.is_recent_block(i), "Block {} should be in cache", i); - } - } - - #[test] - fn test_cache_fifo_order_preserved() { - let client = create_test_client(); - let mut logic = - RadioParadiseStreamSourceLogic::new(client, DEFAULT_CHUNK_DURATION_MS as u32); - - // Ajouter 10 éléments - for i in 1..=10 { - logic.mark_block_downloaded(i); - } - - // Vérifier l'ordre dans la VecDeque (le front devrait être le plus ancien) - let front = logic.recent_blocks.front().copied(); - assert_eq!(front, Some(1), "Front should be the oldest element"); - - let back = logic.recent_blocks.back().copied(); - assert_eq!(back, Some(10), "Back should be the newest element"); - } - - #[test] - fn test_block_queue_push() { - let client = create_test_client(); - let mut logic = - RadioParadiseStreamSourceLogic::new(client, DEFAULT_CHUNK_DURATION_MS as u32); - - // Tester push_block_id - logic.push_block_id(100); - logic.push_block_id(200); - logic.push_block_id(300); - - assert_eq!(logic.block_queue.len(), 3); - assert_eq!(logic.block_queue.front(), Some(100)); - assert_eq!(logic.block_queue.back(), Some(300)); - } -} --------End of pmoparadise/src/radio_paradise_stream_source.rs --------- - ------------- pmoparadise/src/source.rs ---------- -//! RadioParadiseSource - Implementation of MusicSource for Radio Paradise -//! -//! This module provides a UPnP ContentDirectory source for Radio Paradise, -//! exposing live streams and historical playlists for all 4 channels. - -use crate::channels::{ChannelDescriptor, ALL_CHANNELS}; -use pmosource::pmodidl::{Container, Item, Resource}; -use pmosource::{ - async_trait, AudioFormat, BrowseResult, MusicSource, MusicSourceError, Result, - SourceCapabilities, -}; -use std::fmt; -use std::sync::Arc; -use std::time::{Duration, Instant, SystemTime}; -use tokio::sync::RwLock; - -/// Default Radio Paradise image (embedded in binary) -const DEFAULT_IMAGE: &[u8] = include_bytes!("../assets/default.webp"); - -#[cfg(feature = "playlist")] -const LIVE_PLAYLIST_MIN_READY_ITEMS: usize = 5; -#[cfg(feature = "playlist")] -const LIVE_PLAYLIST_READY_TIMEOUT: Duration = Duration::from_secs(10); -#[cfg(feature = "playlist")] -const LIVE_PLAYLIST_READY_POLL: Duration = Duration::from_millis(200); - -/// RadioParadiseSource - UPnP ContentDirectory source for Radio Paradise -/// -/// Provides access to: -/// - Live FLAC streams for all 4 channels (Main, Mellow, Rock, Eclectic) -/// - Historical playlists (FIFO) for each channel -/// -/// # Object ID Schema -/// -/// - Root: `radio-paradise` -/// - Channel container: `radio-paradise:channel:{slug}` -/// - Live stream item: `radio-paradise:channel:{slug}:live` -/// - Live playlist container: `radio-paradise:channel:{slug}:liveplaylist` -/// - Live playlist track: `radio-paradise:channel:{slug}:liveplaylist:track:{pk}` -/// - History container: `radio-paradise:channel:{slug}:history` -/// - History track: `radio-paradise:channel:{slug}:history:track:{pk}` -#[derive(Clone)] -pub struct RadioParadiseSource { - /// Base URL for streaming server (e.g., "http://localhost:8080") - base_url: String, - /// Update counter for change notifications - update_counter: Arc>, - /// Last change timestamp - last_change: Arc>, - /// Tokens des callbacks enregistrés auprès du PlaylistManager - callback_tokens: Arc>>, - /// Notifier optionnel pour signaler les mises à jour de conteneurs au ContentDirectory - container_notifier: Option>, -} - -impl fmt::Debug for RadioParadiseSource { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - f.debug_struct("RadioParadiseSource") - .field("base_url", &self.base_url) - .finish_non_exhaustive() - } -} - -impl RadioParadiseSource { - /// Create a new RadioParadiseSource - /// - /// # Arguments - /// - /// * `base_url` - Base URL for streaming server (e.g., "http://localhost:8080") - /// - /// # Note - /// - /// With the "playlist" feature enabled, this source will use the global PlaylistManager - /// singleton to access history playlists. - pub fn new(base_url: impl Into) -> Self { - Self { - base_url: base_url.into(), - update_counter: Arc::new(RwLock::new(0)), - last_change: Arc::new(RwLock::new(SystemTime::now())), - callback_tokens: Arc::new(std::sync::Mutex::new(Vec::new())), - container_notifier: None, - } - } - - /// Injecte un notifier pour propager les changements de playlists vers le ContentDirectory - pub fn with_container_notifier( - mut self, - notifier: Arc, - ) -> Self { - self.container_notifier = Some(notifier); - self - } - - /// Build a live stream URL for a channel - fn build_live_url(&self, slug: &str) -> String { - format!("{}/radioparadise/stream/{}/flac", self.base_url, slug) - } - - /// Build an OGG-FLAC live stream URL for clients that support it - fn build_live_ogg_url(&self, slug: &str) -> String { - format!("{}/radioparadise/stream/{}/ogg", self.base_url, slug) - } - - /// Incrémente l'update_counter et met à jour last_change - async fn bump_update_counter(&self) { - { - let mut c = self.update_counter.write().await; - *c = c.wrapping_add(1).max(1); - } - let mut lc = self.last_change.write().await; - *lc = SystemTime::now(); - } - - /// Enregistre des callbacks sur les playlists live/historique pour notifier les changements - pub fn attach_playlist_callbacks(self: &Arc) { - use pmoplaylist::PlaylistManager; - - // Préparer les IDs de playlists à surveiller (live + history pour chaque canal) - let ids: Vec = ALL_CHANNELS - .iter() - .flat_map(|ch| { - vec![ - Self::live_playlist_id(ch.slug), - Self::history_playlist_id(ch.slug), - ] - }) - .collect(); - - let mgr = PlaylistManager(); - let mut tokens = self.callback_tokens.lock().unwrap(); - - for pid in ids { - let weak = Arc::downgrade(self); - let pid_clone = pid.clone(); - let token = mgr.register_callback(move |event| { - let pid = pid_clone.clone(); - if event.playlist_id == pid { - // On ne réagit qu'aux mises à jour structurelles (ajout/suppression) - if !matches!(event.kind, pmoplaylist::PlaylistEventKind::Updated) { - return; - } - if let Some(strong) = weak.upgrade() { - tokio::spawn(async move { - strong.bump_update_counter().await; - // Notifier ContentDirectory des conteneurs concernés - let containers: Vec = if pid.contains("history") { - // history playlist -> container history - ALL_CHANNELS - .iter() - .find(|ch| pid.ends_with(ch.slug)) - .map(|ch| { - vec![format!("radio-paradise:channel:{}:history", ch.slug)] - }) - .unwrap_or_default() - } else { - // live playlist -> container liveplaylist - ALL_CHANNELS - .iter() - .find(|ch| pid.ends_with(ch.slug)) - .map(|ch| { - vec![format!( - "radio-paradise:channel:{}:liveplaylist", - ch.slug - )] - }) - .unwrap_or_default() - }; - - if !containers.is_empty() { - if let Some(notifier) = strong.container_notifier.as_ref() { - notifier(&containers); - } - } - }); - } - } - }); - tokens.push(token); - } - } - - /// URL de fallback pour l'image par défaut de la source - fn default_cover_url(&self) -> String { - format!("{}/api/sources/{}/image", self.base_url, self.id()) - } - - /// Fetch current metadata from the live stream - async fn fetch_live_metadata(&self, slug: &str) -> Result> { - let metadata_url = format!("{}/radioparadise/metadata/{}", self.base_url, slug); - - // Try to fetch metadata via HTTP - match reqwest::get(&metadata_url).await { - Ok(response) if response.status().is_success() => { - match response.json::().await { - Ok(json) => { - // Parse metadata from JSON and create an Item - let title = json["title"] - .as_str() - .unwrap_or("Unknown Title") - .to_string(); - let artist = json["artist"].as_str().map(|s| s.to_string()); - let album = json["album"].as_str().map(|s| s.to_string()); - let year = json["year"].as_u64().map(|y| y as u32); - // Préférer l'URL de cache si cover_pk est fourni par le pipeline - let cover_pk = json["cover_pk"].as_str().map(|s| s.to_string()); - let cover_url = cover_pk - .as_ref() - .map(|pk| format!("{}/covers/jpeg/{}", self.base_url, pk)) - .or_else(|| json["cover_url"].as_str().map(|s| s.to_string())) - .or_else(|| Some(self.default_cover_url())); - - // Parse duration from JSON (in seconds as a float) - let duration = json["duration"] - .as_object() - .and_then(|d| d.get("secs")) - .and_then(|s| s.as_f64()) - .or_else(|| json["duration"].as_f64()) - .map(|secs| { - let total_secs = secs as u64; - format!( - "{}:{:02}:{:02}", - total_secs / 3600, - (total_secs % 3600) / 60, - total_secs % 60 - ) - }); - - // Create the item with current metadata - let item = Item { - id: format!("radio-paradise:channel:{}:live", slug), - parent_id: format!("radio-paradise:channel:{}", slug), - restricted: Some("1".to_string()), - title, - creator: artist.clone(), - class: "object.item.audioItem.audioBroadcast".to_string(), - artist, - album, - genre: Some("Radio".to_string()), - album_art: cover_url, - album_art_pk: cover_pk, - date: year.map(|y| y.to_string()), - original_track_number: None, - resources: vec![Resource { - protocol_info: "http-get:*:audio/flac:*".to_string(), - bits_per_sample: None, - sample_frequency: None, - nr_audio_channels: Some("2".to_string()), - duration, - url: self.build_live_url(slug), - }], - descriptions: vec![], - }; - - Ok(Some(item)) - } - Err(_) => Ok(None), - } - } - _ => Ok(None), - } - } - - /// Get the playlist ID for a channel's history - #[cfg(feature = "playlist")] - fn history_playlist_id(slug: &str) -> String { - // Must match the prefix used in ParadiseHistoryBuilder - format!("radio-paradise-history-{}", slug) - } - - /// Live playlist id for a channel - fn live_playlist_id(slug: &str) -> String { - format!("radio-paradise-live-{}", slug) - } - - #[cfg(feature = "playlist")] - async fn wait_for_live_playlist_ready(&self, slug: &str) -> Result<()> { - let playlist_id = Self::live_playlist_id(slug); - let manager = pmoplaylist::PlaylistManager(); - let reader = manager.get_read_handle(&playlist_id).await.map_err(|e| { - MusicSourceError::BrowseError(format!( - "Failed to get live playlist {}: {}", - playlist_id, e - )) - })?; - let start = Instant::now(); - loop { - match reader.remaining().await { - Ok(count) if count >= LIVE_PLAYLIST_MIN_READY_ITEMS => return Ok(()), - Ok(_) => {} - Err(e) => { - return Err(MusicSourceError::BrowseError(format!( - "Failed to inspect live playlist {}: {}", - playlist_id, e - ))); - } - } - - if start.elapsed() >= LIVE_PLAYLIST_READY_TIMEOUT { - tracing::warn!( - "Timeout waiting for live playlist {} to reach {} items", - playlist_id, - LIVE_PLAYLIST_MIN_READY_ITEMS - ); - return Ok(()); - } - - tokio::time::sleep(LIVE_PLAYLIST_READY_POLL).await; - } - } - - /// Get channel descriptor by slug - fn get_channel_by_slug(slug: &str) -> Option<&'static ChannelDescriptor> { - ALL_CHANNELS.iter().find(|ch| ch.slug == slug) - } - - /// Parse an object ID into its components - fn parse_object_id(id: &str) -> ObjectIdType { - let parts: Vec<&str> = id.split(':').collect(); - match parts.as_slice() { - ["radio-paradise"] => ObjectIdType::Root, - ["radio-paradise", "channel", slug] => ObjectIdType::Channel { - slug: (*slug).to_string(), - }, - ["radio-paradise", "channel", slug, "live"] => ObjectIdType::LiveStream { - slug: (*slug).to_string(), - }, - ["radio-paradise", "channel", slug, "liveplaylist"] => ObjectIdType::LivePlaylist { - slug: (*slug).to_string(), - }, - ["radio-paradise", "channel", slug, "liveplaylist", "track", pk] => { - ObjectIdType::LivePlaylistTrack { - slug: (*slug).to_string(), - pk: (*pk).to_string(), - } - } - ["radio-paradise", "channel", slug, "history"] => ObjectIdType::History { - slug: (*slug).to_string(), - }, - ["radio-paradise", "channel", slug, "history", "track", pk] => { - ObjectIdType::HistoryTrack { - slug: (*slug).to_string(), - pk: (*pk).to_string(), - } - } - _ => ObjectIdType::Unknown, - } - } - - /// Build a channel container - fn build_channel_container(&self, descriptor: &ChannelDescriptor) -> Container { - Container { - id: format!("radio-paradise:channel:{}", descriptor.slug), - parent_id: "radio-paradise".to_string(), - restricted: Some("1".to_string()), - child_count: None, - searchable: Some("1".to_string()), - title: descriptor.display_name.to_string(), - class: "object.container".to_string(), - containers: vec![], - items: vec![], - } - } - - /// Build the live playlist container for a channel - fn build_live_playlist_container(&self, descriptor: &ChannelDescriptor) -> Container { - Container { - id: format!("radio-paradise:channel:{}:liveplaylist", descriptor.slug), - parent_id: format!("radio-paradise:channel:{}", descriptor.slug), - restricted: Some("1".to_string()), - child_count: None, - searchable: Some("0".to_string()), - title: format!("{} - Live Playlist", descriptor.display_name), - class: "object.container.playlistContainer".to_string(), - containers: vec![], - items: vec![], - } - } - - /// Build a live stream item for a channel - fn build_live_stream_item(&self, descriptor: &ChannelDescriptor) -> Item { - let stream_url = self.build_live_url(descriptor.slug); - - Item { - id: format!("radio-paradise:channel:{}:live", descriptor.slug), - parent_id: format!("radio-paradise:channel:{}", descriptor.slug), - restricted: Some("1".to_string()), - title: format!("{} - Live Stream", descriptor.display_name), - creator: Some("Radio Paradise".to_string()), - class: "object.item.audioItem.audioBroadcast".to_string(), - artist: Some("Radio Paradise".to_string()), - album: Some(descriptor.display_name.to_string()), - genre: Some("Radio".to_string()), - album_art: Some(self.default_cover_url()), - album_art_pk: None, - date: None, - original_track_number: None, - resources: vec![ - Resource { - protocol_info: "http-get:*:audio/flac:*".to_string(), - bits_per_sample: Some("16".to_string()), - sample_frequency: Some("44100".to_string()), - nr_audio_channels: Some("2".to_string()), - duration: None, - url: stream_url.clone(), - }, - Resource { - protocol_info: "http-get:*:audio/ogg:*".to_string(), - bits_per_sample: Some("16".to_string()), - sample_frequency: Some("44100".to_string()), - nr_audio_channels: Some("2".to_string()), - duration: None, - url: self.build_live_ogg_url(descriptor.slug), - }, - ], - descriptions: vec![], - } - } - - /// Build a history container for a channel - fn build_history_container(&self, descriptor: &ChannelDescriptor) -> Container { - Container { - id: format!("radio-paradise:channel:{}:history", descriptor.slug), - parent_id: format!("radio-paradise:channel:{}", descriptor.slug), - restricted: Some("1".to_string()), - child_count: None, - searchable: Some("1".to_string()), - title: format!("{} - History", descriptor.display_name), - // Expose l'historique comme une playlist jouable - class: "object.container.playlistContainer".to_string(), - containers: vec![], - items: vec![], - } - } - - /// Build a history container with accurate child count from playlist - #[cfg(feature = "playlist")] - async fn build_history_container_with_count( - &self, - descriptor: &ChannelDescriptor, - ) -> Container { - let mut container = self.build_history_container(descriptor); - - // Try to get actual count from playlist - let playlist_id = Self::history_playlist_id(descriptor.slug); - let manager = pmoplaylist::PlaylistManager(); - - if let Ok(reader) = manager.get_read_handle(&playlist_id).await { - if let Ok(count) = reader.remaining().await { - container.child_count = Some(count.to_string()); - } - } - - container - } - - /// Get items from history playlist - #[cfg(feature = "playlist")] - async fn get_history_items( - &self, - slug: &str, - _offset: usize, - count: usize, - ) -> Result> { - let playlist_id = Self::history_playlist_id(slug); - - // Get read handle for the playlist from the singleton - let manager = pmoplaylist::PlaylistManager(); - let reader = manager.get_read_handle(&playlist_id).await.map_err(|e| { - MusicSourceError::BrowseError(format!("Failed to get playlist {}: {}", playlist_id, e)) - })?; - - // Get items from playlist (to_items starts from cursor position) - let mut items = reader.to_items(count).await.map_err(|e| { - MusicSourceError::BrowseError(format!("Failed to read playlist entries: {}", e)) - })?; - - // Transform item IDs, parent_ids, and resource URLs to match Radio Paradise schema - // Expected: radio-paradise:channel:{slug}:history:track:{pk} - // Parent: radio-paradise:channel:{slug}:history - for item in items.iter_mut() { - // Extract cache_pk from the resource URL (last segment) - if let Some(resource) = item.resources.first_mut() { - if let Some(pk) = resource.url.split('/').last() { - // Update item ID and parent ID - item.id = format!("radio-paradise:channel:{}:history:track:{}", slug, pk); - item.parent_id = format!("radio-paradise:channel:{}:history", slug); - - // Convert relative URL to absolute URL - // From: /audio/flac/pk - // To: http://base_url/audio/flac/pk - if resource.url.starts_with('/') { - resource.url = format!("{}{}", self.base_url, resource.url); - } - } - } - - // Fix: Ajouter un genre par défaut si absent - // Certains clients UPnP (comme gupnp-av-cp) requièrent le champ - // pour parser correctement les items de classe musicTrack, même si ce champ - // est optionnel selon la spec UPnP ContentDirectory. - if item.genre.is_none() { - item.genre = Some("Radio Paradise".to_string()); - } - - // Normaliser l'albumArtURI : rendre absolu si chemin relatif, sinon fallback par défaut - if let Some(art) = item.album_art.as_mut() { - if art.starts_with('/') { - *art = format!("{}{}", self.base_url, art); - } - } else { - item.album_art = Some(self.default_cover_url()); - } - } - - Ok(items) - } - - /// Get items from live playlist (current stream queue) - #[cfg(feature = "playlist")] - async fn get_live_playlist_items( - &self, - slug: &str, - _offset: usize, - count: usize, - ) -> Result> { - #[cfg(all(feature = "playlist", feature = "pmoaudio"))] - if let Some(descriptor) = Self::get_channel_by_slug(slug) { - if let Some(manager) = crate::stream_channel::get_global_channel_manager() { - if let Err(e) = manager.prefetch_until_horizon(descriptor.id).await { - tracing::warn!( - "Failed to prefetch live playlist for {}: {}", - descriptor.slug, - e - ); - } - } - } - - #[cfg(feature = "playlist")] - if let Err(e) = self.wait_for_live_playlist_ready(slug).await { - tracing::warn!( - "Failed to wait for live playlist readiness on {}: {}", - slug, - e - ); - } - - let playlist_id = Self::live_playlist_id(slug); - - let manager = pmoplaylist::PlaylistManager(); - let reader = manager.get_read_handle(&playlist_id).await.map_err(|e| { - MusicSourceError::BrowseError(format!( - "Failed to get live playlist {}: {}", - playlist_id, e - )) - })?; - - let mut items = reader.to_items(count).await.map_err(|e| { - MusicSourceError::BrowseError(format!("Failed to read live playlist entries: {}", e)) - })?; - - for item in items.iter_mut() { - // Ajuster id/parent/url pour coller au schéma Radio Paradise - if let Some(resource) = item.resources.first_mut() { - if let Some(pk) = resource.url.split('/').last() { - item.id = format!("radio-paradise:channel:{}:liveplaylist:track:{}", slug, pk); - item.parent_id = format!("radio-paradise:channel:{}:liveplaylist", slug); - - if resource.url.starts_with('/') { - resource.url = format!("{}{}", self.base_url, resource.url); - } - } - } - - if item.genre.is_none() { - item.genre = Some("Radio Paradise".to_string()); - } - - if let Some(art) = item.album_art.as_mut() { - if art.starts_with('/') { - *art = format!("{}{}", self.base_url, art); - } - } else { - item.album_art = Some(self.default_cover_url()); - } - } - - Ok(items) - } - - /// Get a single item from the live playlist by pk - #[cfg(feature = "playlist")] - async fn get_live_playlist_item(&self, slug: &str, pk: &str) -> Result { - let items = self.get_live_playlist_items(slug, 0, 1000).await?; - let expected_id = format!("radio-paradise:channel:{}:liveplaylist:track:{}", slug, pk); - for item in items { - if item.id == expected_id { - return Ok(item); - } - } - Err(MusicSourceError::ObjectNotFound(format!( - "Track with pk {} not found in live playlist", - pk - ))) - } -} - -/// Types of object IDs in the Radio Paradise source -#[derive(Debug, Clone, PartialEq)] -enum ObjectIdType { - Root, - Channel { slug: String }, - LiveStream { slug: String }, - LivePlaylist { slug: String }, - LivePlaylistTrack { slug: String, pk: String }, - History { slug: String }, - HistoryTrack { slug: String, pk: String }, - Unknown, -} - -#[async_trait] -impl MusicSource for RadioParadiseSource { - fn name(&self) -> &str { - "Radio Paradise" - } - - fn id(&self) -> &str { - "radio-paradise" - } - - fn default_image(&self) -> &[u8] { - DEFAULT_IMAGE - } - - async fn root_container(&self) -> Result { - Ok(Container { - id: "radio-paradise".to_string(), - parent_id: "0".to_string(), - restricted: Some("1".to_string()), - // childCount retiré pour éviter les soucis de compatibilité côté CP - child_count: None, - searchable: Some("1".to_string()), - title: "Radio Paradise".to_string(), - class: "object.container".to_string(), - containers: vec![], - items: vec![], - }) - } - - async fn browse(&self, object_id: &str) -> Result { - match Self::parse_object_id(object_id) { - ObjectIdType::Root => { - // Return the 4 channel containers - let containers: Vec = ALL_CHANNELS - .iter() - .map(|ch| self.build_channel_container(ch)) - .collect(); - - Ok(BrowseResult::Containers(containers)) - } - - ObjectIdType::Channel { slug } => { - // Return live stream item + history container - let descriptor = Self::get_channel_by_slug(&slug).ok_or_else(|| { - MusicSourceError::ObjectNotFound(format!("Unknown channel: {}", slug)) - })?; - - let live_item = self.build_live_stream_item(descriptor); - let live_playlist_container = self.build_live_playlist_container(descriptor); - - #[cfg(feature = "playlist")] - let history_container = self.build_history_container_with_count(descriptor).await; - #[cfg(not(feature = "playlist"))] - let history_container = self.build_history_container(descriptor); - - Ok(BrowseResult::Mixed { - containers: vec![live_playlist_container, history_container], - items: vec![live_item], - }) - } - - ObjectIdType::History { slug } => { - // Return history container (for BrowseMetadata) and items (for BrowseDirectChildren) - // The content_handler will filter out the container when browsing direct children - let descriptor = Self::get_channel_by_slug(&slug).ok_or_else(|| { - MusicSourceError::ObjectNotFound(format!("Unknown channel: {}", slug)) - })?; - - #[cfg(feature = "playlist")] - { - let history_container = - self.build_history_container_with_count(descriptor).await; - let items = self.get_history_items(&slug, 0, 100).await?; - Ok(BrowseResult::Mixed { - containers: vec![history_container], - items, - }) - } - - #[cfg(not(feature = "playlist"))] - { - // If playlist feature is disabled, return just the container - let history_container = self.build_history_container(descriptor); - Ok(BrowseResult::Containers(vec![history_container])) - } - } - - ObjectIdType::LiveStream { slug } => { - // Return metadata for the live stream item - let descriptor = Self::get_channel_by_slug(&slug).ok_or_else(|| { - MusicSourceError::ObjectNotFound(format!("Unknown channel: {}", slug)) - })?; - let item = self.build_live_stream_item(descriptor); - Ok(BrowseResult::Items(vec![item])) - } - - ObjectIdType::LivePlaylist { slug } => { - // Playlist du live : container + items - let descriptor = Self::get_channel_by_slug(&slug).ok_or_else(|| { - MusicSourceError::ObjectNotFound(format!("Unknown channel: {}", slug)) - })?; - - #[cfg(feature = "playlist")] - { - let container = self.build_live_playlist_container(descriptor); - let items = self.get_live_playlist_items(&slug, 0, 100).await?; - Ok(BrowseResult::Mixed { - containers: vec![container], - items, - }) - } - - #[cfg(not(feature = "playlist"))] - { - let container = self.build_live_playlist_container(descriptor); - Ok(BrowseResult::Containers(vec![container])) - } - } - - ObjectIdType::HistoryTrack { slug: _, pk: _ } => { - // Return metadata for the history track item - let item = self.get_item(object_id).await?; - Ok(BrowseResult::Items(vec![item])) - } - - ObjectIdType::LivePlaylistTrack { slug, pk } => { - // Détails d'un titre du live (playlist live) - #[cfg(feature = "playlist")] - { - let item = self.get_live_playlist_item(&slug, &pk).await?; - Ok(BrowseResult::Items(vec![item])) - } - - #[cfg(not(feature = "playlist"))] - { - let _ = (slug, pk); - Err(MusicSourceError::NotSupported( - "Playlist feature not enabled".to_string(), - )) - } - } - - ObjectIdType::Unknown => Err(MusicSourceError::ObjectNotFound(format!( - "Unknown object ID: {}", - object_id - ))), - } - } - - async fn resolve_uri(&self, object_id: &str) -> Result { - match Self::parse_object_id(object_id) { - ObjectIdType::LiveStream { slug } => { - // Return live stream URL - Ok(self.build_live_url(&slug)) - } - - ObjectIdType::HistoryTrack { pk, .. } => { - // Return cached audio URL - Ok(format!("{}/cache/audio/{}", self.base_url, pk)) - } - - ObjectIdType::LivePlaylistTrack { pk, .. } => { - // Return cached audio URL - Ok(format!("{}/cache/audio/{}", self.base_url, pk)) - } - - _ => Err(MusicSourceError::ObjectNotFound(format!( - "Cannot resolve URI for object: {}", - object_id - ))), - } - } - - fn capabilities(&self) -> SourceCapabilities { - SourceCapabilities { - supports_fifo: self.supports_fifo(), - supports_search: false, - supports_favorites: false, - supports_playlists: false, - supports_user_content: false, - supports_high_res_audio: true, - max_sample_rate: Some(44100), - supports_multiple_formats: true, - supports_advanced_search: false, - supports_pagination: false, - } - } - - async fn get_available_formats(&self, object_id: &str) -> Result> { - match Self::parse_object_id(object_id) { - ObjectIdType::LiveStream { .. } => Ok(vec![ - AudioFormat { - format_id: "flac".to_string(), - mime_type: "audio/flac".to_string(), - sample_rate: Some(44100), - bit_depth: Some(16), - bitrate: None, - channels: Some(2), - }, - AudioFormat { - format_id: "ogg-flac".to_string(), - mime_type: "audio/ogg".to_string(), - sample_rate: Some(44100), - bit_depth: Some(16), - bitrate: None, - channels: Some(2), - }, - ]), - ObjectIdType::HistoryTrack { .. } => Ok(vec![AudioFormat { - format_id: "flac".to_string(), - mime_type: "audio/flac".to_string(), - sample_rate: Some(44100), - bit_depth: Some(16), - bitrate: None, - channels: Some(2), - }]), - ObjectIdType::LivePlaylistTrack { .. } => Ok(vec![AudioFormat { - format_id: "flac".to_string(), - mime_type: "audio/flac".to_string(), - sample_rate: Some(44100), - bit_depth: Some(16), - bitrate: None, - channels: Some(2), - }]), - _ => Err(MusicSourceError::ObjectNotFound(format!( - "Cannot list formats for object: {}", - object_id - ))), - } - } - - async fn get_item(&self, object_id: &str) -> Result { - match Self::parse_object_id(object_id) { - ObjectIdType::LiveStream { slug } => { - // Try to fetch current metadata from live stream - if let Ok(Some(item)) = self.fetch_live_metadata(&slug).await { - return Ok(item); - } - - // Fallback to static item if metadata fetch fails - let descriptor = Self::get_channel_by_slug(&slug).ok_or_else(|| { - MusicSourceError::ObjectNotFound(format!("Unknown channel: {}", slug)) - })?; - Ok(self.build_live_stream_item(descriptor)) - } - - ObjectIdType::HistoryTrack { slug, pk } => { - // Get from history playlist - #[cfg(feature = "playlist")] - { - let playlist_id = Self::history_playlist_id(&slug); - let manager = pmoplaylist::PlaylistManager(); - let reader = manager.get_read_handle(&playlist_id).await.map_err(|e| { - MusicSourceError::BrowseError(format!( - "Failed to get playlist {}: {}", - playlist_id, e - )) - })?; - - // Try to find the item with this pk - let items = reader.to_items(1000).await.map_err(|e| { - MusicSourceError::BrowseError(format!( - "Failed to read playlist entries: {}", - e - )) - })?; - - // Ajuster les IDs/parent_id/URL pour coller au schéma Radio Paradise, - // comme dans get_history_items. - let mut adjusted = Vec::new(); - for mut item in items { - if let Some(resource) = item.resources.first_mut() { - if let Some(pk2) = resource.url.split('/').last() { - item.id = format!( - "radio-paradise:channel:{}:history:track:{}", - slug, pk2 - ); - item.parent_id = format!("radio-paradise:channel:{}:history", slug); - - if resource.url.starts_with('/') { - resource.url = format!("{}{}", self.base_url, resource.url); - } - } - } - if item.genre.is_none() { - item.genre = Some("Radio Paradise".to_string()); - } - adjusted.push(item); - } - - // Find the item matching this pk in the item ID - let expected_id = - format!("radio-paradise:channel:{}:history:track:{}", slug, pk); - for item in adjusted { - if item.id == expected_id { - return Ok(item); - } - } - - Err(MusicSourceError::ObjectNotFound(format!( - "Track with pk {} not found in history", - pk - ))) - } - - #[cfg(not(feature = "playlist"))] - { - let _ = (slug, pk); - Err(MusicSourceError::NotSupported( - "Playlist feature not enabled".to_string(), - )) - } - } - - ObjectIdType::LivePlaylistTrack { slug, pk } => { - #[cfg(feature = "playlist")] - { - let playlist_id = Self::live_playlist_id(&slug); - let manager = pmoplaylist::PlaylistManager(); - let reader = manager.get_read_handle(&playlist_id).await.map_err(|e| { - MusicSourceError::BrowseError(format!( - "Failed to get live playlist {}: {}", - playlist_id, e - )) - })?; - - let items = reader.to_items(1000).await.map_err(|e| { - MusicSourceError::BrowseError(format!( - "Failed to read live playlist entries: {}", - e - )) - })?; - - for mut item in items { - if let Some(resource) = item.resources.first_mut() { - if let Some(pk2) = resource.url.split('/').last() { - item.id = format!( - "radio-paradise:channel:{}:liveplaylist:track:{}", - slug, pk2 - ); - item.parent_id = - format!("radio-paradise:channel:{}:liveplaylist", slug); - - if resource.url.starts_with('/') { - resource.url = format!("{}{}", self.base_url, resource.url); - } - } - } - - if item.genre.is_none() { - item.genre = Some("Radio Paradise".to_string()); - } - - if let Some(art) = item.album_art.as_mut() { - if art.starts_with('/') { - *art = format!("{}{}", self.base_url, art); - } - } else { - item.album_art = Some(self.default_cover_url()); - } - - let expected_id = - format!("radio-paradise:channel:{}:liveplaylist:track:{}", slug, pk); - if item.id == expected_id { - return Ok(item); - } - } - - Err(MusicSourceError::ObjectNotFound(format!( - "Track with pk {} not found in live playlist", - pk - ))) - } - - #[cfg(not(feature = "playlist"))] - { - let _ = (slug, pk); - Err(MusicSourceError::NotSupported( - "Playlist feature not enabled".to_string(), - )) - } - } - - _ => Err(MusicSourceError::ObjectNotFound(format!( - "Cannot get item for object: {}", - object_id - ))), - } - } - - fn supports_fifo(&self) -> bool { - // History playlists are FIFO - cfg!(feature = "playlist") - } - - async fn append_track(&self, _track: Item) -> Result<()> { - // Tracks are added automatically by FlacCacheSink - Err(MusicSourceError::NotSupported( - "Tracks are automatically added to history by the streaming system".to_string(), - )) - } - - async fn remove_oldest(&self) -> Result> { - // Managed automatically by playlist FIFO - Ok(None) - } - - async fn update_id(&self) -> u32 { - *self.update_counter.read().await - } - - async fn last_change(&self) -> Option { - Some(*self.last_change.read().await) - } - - async fn get_items(&self, offset: usize, count: usize) -> Result> { - // For Radio Paradise, we don't have a global FIFO - // Each channel has its own history - // Return empty for now - clients should browse specific channel histories - let _ = (offset, count); - Ok(vec![]) - } -} --------End of pmoparadise/src/source.rs --------- - ------------- pmoparadise/src/stream_channel_old.rs ---------- -use std::{ - collections::HashMap, - pin::Pin, - sync::{ - atomic::{AtomicUsize, Ordering}, - Arc, - }, - task::{Context, Poll}, - time::Duration, -}; - -use crate::{ - channels::{ChannelDescriptor, ParadiseChannelKind, ALL_CHANNELS}, - client::RadioParadiseClient, - radio_paradise_stream_source::RadioParadiseStreamSource, -}; -use anyhow::{anyhow, Result}; -use pmoaudio::{nodes::DEFAULT_CHANNEL_SIZE, AudioPipelineNode}; -use pmoaudio_ext::{ - FlacCacheSink, FlacClientStream, IcyClientStream, MetadataSnapshot, OggFlacClientStream, - OggFlacStreamHandle, PlaylistSource, StreamHandle, StreamingFlacSink, StreamingOggFlacSink, - TrackBoundaryCoverNode, StreamingSinkOptions, -}; -use pmoaudiocache::Cache as AudioCache; -use pmocovers::Cache as CoverCache; -use pmoflac::EncoderOptions; -use pmoplaylist::WriteHandle; -use thiserror::Error; -use tokio::io::{AsyncRead, ReadBuf}; -use tokio::sync::Notify; -use tokio::task::JoinHandle; -use tokio_util::sync::CancellationToken; -use tracing::{error, info, warn}; - -/// Configuration pour un canal Radio Paradise. -#[derive(Clone, Debug)] -pub struct ParadiseStreamChannelConfig { - /// Durée maximale (en secondes) d'avance acceptée par le broadcast. - pub max_lead_seconds: f64, - pub flac_options: StreamingSinkOptions, - pub ogg_options: StreamingSinkOptions, - pub server_base_url: Option, -} - -impl Default for ParadiseStreamChannelConfig { - fn default() -> Self { - Self { - max_lead_seconds: 1.0, - flac_options: StreamingSinkOptions::flac_defaults(), - ogg_options: StreamingSinkOptions::ogg_defaults(), - server_base_url: None, - } - } -} - -/// Options pour activer l'archivage/historique d'un canal. -pub struct ParadiseHistoryOptions { - pub audio_cache: Arc, - pub cover_cache: Arc, - pub playlist_id: String, - pub playlist_writer: WriteHandle, - pub collection: Option, - pub replay_max_lead_seconds: f64, -} - -/// Builder pratique pour configurer automatiquement les playlists historiques. -#[derive(Clone)] -pub struct ParadiseHistoryBuilder { - pub audio_cache: Arc, - pub cover_cache: Arc, - pub playlist_prefix: String, - pub playlist_title_prefix: Option, - pub max_history_tracks: Option, - pub collection_prefix: Option, - pub replay_max_lead_seconds: f64, -} - -impl ParadiseHistoryBuilder { - pub fn new(audio_cache: Arc, cover_cache: Arc) -> Self { - Self { - audio_cache, - cover_cache, - playlist_prefix: "radio-paradise-history".into(), - playlist_title_prefix: Some("Radio Paradise History".into()), - max_history_tracks: Some(500), - collection_prefix: Some("radio-paradise".into()), - replay_max_lead_seconds: 1.0, - } - } - - pub async fn build_for_channel( - &self, - descriptor: &ChannelDescriptor, - ) -> Result { - let playlist_id = format!("{}-{}", self.playlist_prefix, descriptor.slug); - let manager = pmoplaylist::PlaylistManager(); - let writer = manager - .get_persistent_write_handle(playlist_id.clone()) - .await?; - - if let Some(prefix) = &self.playlist_title_prefix { - let title = format!("{} - {}", prefix, descriptor.display_name); - writer.set_title(title).await?; - } - - if let Some(capacity) = self.max_history_tracks { - writer.set_capacity(Some(capacity)).await?; - } - - let collection = self - .collection_prefix - .as_ref() - .map(|prefix| format!("{}-{}", prefix, descriptor.slug)); - - Ok(ParadiseHistoryOptions { - audio_cache: self.audio_cache.clone(), - cover_cache: self.cover_cache.clone(), - playlist_id, - playlist_writer: writer, - collection, - replay_max_lead_seconds: self.replay_max_lead_seconds, - }) - } -} - -struct HistoryState { - playlist_id: String, - audio_cache: Arc, - replay_max_lead_seconds: f64, -} - -#[cfg(feature = "pmoconfig")] -impl ParadiseStreamChannelConfig { - pub fn from_config(cfg: &pmoconfig::Config, channel: ParadiseChannelKind) -> Self { - use serde_yaml::Value; - let path = [ - "sources", - "radio_paradise", - "channels", - channel.slug(), - "max_lead_seconds", - ]; - match cfg.get_value(&path) { - Ok(Value::Number(num)) => { - if let Some(v) = num.as_f64() { - Self { - max_lead_seconds: v.max(0.1), - flac_options: StreamingSinkOptions::flac_defaults(), - ogg_options: StreamingSinkOptions::ogg_defaults(), - server_base_url: None, - } - } else { - let default = Self::default(); - let _ = - cfg.set_value(&path, Value::String(default.max_lead_seconds.to_string())); - default - } - } - Ok(Value::String(s)) => { - if let Ok(v) = s.parse::() { - Self { - max_lead_seconds: v.max(0.1), - flac_options: StreamingSinkOptions::flac_defaults(), - ogg_options: StreamingSinkOptions::ogg_defaults(), - server_base_url: None, - } - } else { - let default = Self::default(); - let _ = - cfg.set_value(&path, Value::String(default.max_lead_seconds.to_string())); - default - } - } - _ => { - let default = Self::default(); - let _ = cfg.set_value(&path, Value::String(default.max_lead_seconds.to_string())); - default - } - } - } -} - -/// Stream complet (FLAC pur + OGG-FLAC) pour un canal Radio Paradise. -pub struct ParadiseStreamChannel { - descriptor: ChannelDescriptor, - state: Arc, - pipeline_handle: JoinHandle<()>, - feeder_handle: JoinHandle<()>, - history: Option, -} - -impl ParadiseStreamChannel { - /// Crée un canal avec client déjà configuré. - pub fn with_client( - descriptor: ChannelDescriptor, - client: RadioParadiseClient, - config: ParadiseStreamChannelConfig, - cover_cache: Option>, - history: Option, - ) -> Self { - let mut source = RadioParadiseStreamSource::new(client.clone()); - let block_handle = source.block_handle(); - - let (flac_sink, stream_handle) = StreamingFlacSink::with_options( - EncoderOptions::default(), - 16, - config.max_lead_seconds, - config.flac_options.clone(), - ); - let (ogg_sink, ogg_handle) = StreamingOggFlacSink::with_options( - EncoderOptions::default(), - 16, - config.max_lead_seconds, - config.ogg_options.clone(), - ); - - let mut downstream_children: Vec> = Vec::new(); - downstream_children.push(Box::new(flac_sink)); - downstream_children.push(Box::new(ogg_sink)); - - let mut history_state = None; - - if let Some(history_opts) = history { - let ParadiseHistoryOptions { - audio_cache, - cover_cache, - playlist_id, - playlist_writer, - collection, - replay_max_lead_seconds, - } = history_opts; - let mut cache_sink = FlacCacheSink::with_config( - audio_cache.clone(), - cover_cache, - DEFAULT_CHANNEL_SIZE, - EncoderOptions::default(), - collection, - ); - cache_sink.register_playlist(playlist_writer); - downstream_children.push(Box::new(cache_sink)); - history_state = Some(HistoryState { - playlist_id, - audio_cache, - replay_max_lead_seconds, - }); - } - - if let Some(cache) = cover_cache { - let mut cover_node = TrackBoundaryCoverNode::new(cache); - for child in downstream_children { - cover_node.register(child); - } - source.register(Box::new(cover_node)); - } else { - for child in downstream_children { - source.register(child); - } - } - stream_handle.set_auto_stop(false); - ogg_handle.set_auto_stop(false); - - let stop_token = CancellationToken::new(); - let pipeline_stop = stop_token.clone(); - let pipeline_handle = tokio::spawn(async move { - info!( - "RadioParadise stream pipeline started for channel {}", - descriptor.display_name - ); - if let Err(e) = Box::new(source).run(pipeline_stop).await { - error!( - "Pipeline error for channel {}: {}", - descriptor.display_name, e - ); - } - }); - - let state = Arc::new(ChannelState { - descriptor, - config, - client, - block_handle, - stream_handle, - ogg_handle, - active_clients: AtomicUsize::new(0), - activity_notify: Notify::new(), - stop_token, - }); - - let feeder_state = state.clone(); - let feeder_handle = tokio::spawn(async move { - feeder_state.run_scheduler().await; - }); - - Self { - descriptor, - state, - pipeline_handle, - feeder_handle, - history: history_state, - } - } - - /// Crée un canal en construisant automatiquement le client pour ce descriptor. - pub async fn new( - descriptor: ChannelDescriptor, - config: ParadiseStreamChannelConfig, - cover_cache: Option>, - history: Option, - ) -> Result { - let client = RadioParadiseClient::builder() - .channel(descriptor.id) - .build() - .await?; - Ok(Self::with_client( - descriptor, - client, - config, - cover_cache, - history, - )) - } - - /// S'abonne au flux FLAC pur. - pub fn subscribe_flac(&self) -> ChannelFlacStream { - self.state.on_client_added(); - let inner = self.state.stream_handle.subscribe_flac(); - ChannelFlacStream::new(inner, self.state.clone()) - } - - /// S'abonne au flux FLAC + ICY metadata. - pub fn subscribe_icy(&self) -> ChannelIcyStream { - self.state.on_client_added(); - let inner = self.state.stream_handle.subscribe_icy(); - ChannelIcyStream::new(inner, self.state.clone()) - } - - /// S'abonne au flux OGG-FLAC. - pub fn subscribe_ogg(&self) -> ChannelOggStream { - self.state.on_client_added(); - let inner = self.state.ogg_handle.subscribe(); - ChannelOggStream::new(inner, self.state.clone()) - } - - /// Snapshot des métadonnées actuelles. - pub async fn metadata(&self) -> MetadataSnapshot { - self.state.stream_handle.get_metadata().await - } - - /// Nombre de clients actifs. - pub fn active_clients(&self) -> usize { - self.state.active_clients.load(Ordering::SeqCst) - } - - pub fn descriptor(&self) -> ChannelDescriptor { - self.descriptor - } - - /// Lance un pipeline dédié pour rejouer l'historique (FLAC pur) pour un client. - pub async fn stream_history_flac( - &self, - client_id: &str, - ) -> Result { - let history = self - .history - .as_ref() - .ok_or(HistoryStreamError::HistoryDisabled)?; - tracing::info!( - "Starting historical FLAC replay for channel {} (client_id={})", - self.descriptor.display_name, - client_id - ); - - let reader = pmoplaylist::PlaylistManager() - .get_read_handle(&history.playlist_id) - .await - .map_err(|e| HistoryStreamError::Playlist(e.to_string()))?; - let mut source = PlaylistSource::new(reader, history.audio_cache.clone()); - let (flac_sink, handle) = StreamingFlacSink::with_options( - EncoderOptions::default(), - 16, - history.replay_max_lead_seconds, - self.state.config.flac_options.clone(), - ); - source.register(Box::new(flac_sink)); - let stop_token = CancellationToken::new(); - let mut pipeline_source = source; - let stop_clone = stop_token.clone(); - let pipeline = tokio::spawn(async move { - let _ = Box::new(pipeline_source).run(stop_clone).await; - }); - let stream = handle.subscribe_flac(); - Ok(HistoryFlacStream::new(stream, stop_token, pipeline)) - } - - /// Lance un pipeline dédié pour rejouer l'historique (OGG-FLAC) pour un client. - pub async fn stream_history_ogg( - &self, - client_id: &str, - ) -> Result { - let history = self - .history - .as_ref() - .ok_or(HistoryStreamError::HistoryDisabled)?; - tracing::info!( - "Starting historical OGG replay for channel {} (client_id={})", - self.descriptor.display_name, - client_id - ); - - let reader = pmoplaylist::PlaylistManager() - .get_read_handle(&history.playlist_id) - .await - .map_err(|e| HistoryStreamError::Playlist(e.to_string()))?; - let mut source = PlaylistSource::new(reader, history.audio_cache.clone()); - let (ogg_sink, handle) = StreamingOggFlacSink::with_options( - EncoderOptions::default(), - 16, - history.replay_max_lead_seconds, - self.state.config.ogg_options.clone(), - ); - source.register(Box::new(ogg_sink)); - let stop_token = CancellationToken::new(); - let mut pipeline_source = source; - let stop_clone = stop_token.clone(); - let pipeline = tokio::spawn(async move { - let _ = Box::new(pipeline_source).run(stop_clone).await; - }); - let stream = handle.subscribe(); - Ok(HistoryOggStream::new(stream, stop_token, pipeline)) - } -} - -impl Drop for ParadiseStreamChannel { - fn drop(&mut self) { - self.state.stop_token.cancel(); - self.pipeline_handle.abort(); - self.feeder_handle.abort(); - } -} - -struct ChannelState { - descriptor: ChannelDescriptor, - config: ParadiseStreamChannelConfig, - client: RadioParadiseClient, - block_handle: crate::radio_paradise_stream_source::BlockQueueHandle, - stream_handle: StreamHandle, - ogg_handle: OggFlacStreamHandle, - active_clients: AtomicUsize, - activity_notify: Notify, - stop_token: CancellationToken, -} - -impl ChannelState { - fn on_client_added(&self) { - if self.active_clients.fetch_add(1, Ordering::SeqCst) == 0 { - self.activity_notify.notify_one(); - } - } - - fn on_client_removed(&self) { - self.active_clients.fetch_sub(1, Ordering::SeqCst); - } - - async fn wait_for_clients(&self) -> bool { - while self.active_clients.load(Ordering::SeqCst) == 0 { - tokio::select! { - _ = self.stop_token.cancelled() => return false, - _ = self.activity_notify.notified() => {}, - } - } - true - } - - async fn run_scheduler(self: Arc) { - let mut backoff = Duration::from_secs(5); - loop { - if self.stop_token.is_cancelled() { - break; - } - - if !self.wait_for_clients().await { - break; - } - - match self.client.get_block(None).await { - Ok(block) => { - info!( - "Channel {} streaming block {}", - self.descriptor.display_name, block.event - ); - self.block_handle.enqueue(block.event); - let mut next_event = block.end_event; - - loop { - if self.stop_token.is_cancelled() { - return; - } - - if self.active_clients.load(Ordering::SeqCst) == 0 { - break; - } - - match self.client.get_block(Some(next_event)).await { - Ok(next_block) => { - self.block_handle.enqueue(next_block.event); - next_event = next_block.end_event; - backoff = Duration::from_secs(5); - } - Err(e) => { - warn!( - "Failed to fetch next block for channel {}: {}", - self.descriptor.display_name, e - ); - tokio::select! { - _ = self.stop_token.cancelled() => return, - _ = tokio::time::sleep(backoff) => {}, - } - backoff = (backoff * 2).min(Duration::from_secs(60)); - } - } - } - } - Err(e) => { - warn!( - "Failed to fetch current block for channel {}: {}", - self.descriptor.display_name, e - ); - tokio::select! { - _ = self.stop_token.cancelled() => break, - _ = tokio::time::sleep(backoff) => {}, - } - backoff = (backoff * 2).min(Duration::from_secs(60)); - } - } - } - } -} - -macro_rules! wrap_stream { - ($name:ident, $inner:ty) => { - pub struct $name { - inner: $inner, - state: Arc, - } - - impl $name { - fn new(inner: $inner, state: Arc) -> Self { - Self { inner, state } - } - } - - impl AsyncRead for $name { - fn poll_read( - mut self: Pin<&mut Self>, - cx: &mut Context<'_>, - buf: &mut ReadBuf<'_>, - ) -> Poll> { - Pin::new(&mut self.inner).poll_read(cx, buf) - } - } - - impl Drop for $name { - fn drop(&mut self) { - self.state.on_client_removed(); - } - } - }; -} - -wrap_stream!(ChannelFlacStream, FlacClientStream); -wrap_stream!(ChannelIcyStream, IcyClientStream); -wrap_stream!(ChannelOggStream, OggFlacClientStream); - -#[derive(Debug, Error)] -pub enum HistoryStreamError { - #[error("history replay not enabled for this channel")] - HistoryDisabled, - #[error("playlist error: {0}")] - Playlist(String), -} - -pub struct HistoryFlacStream { - inner: FlacClientStream, - stop_token: CancellationToken, - pipeline: Option>, -} - -impl HistoryFlacStream { - fn new( - inner: FlacClientStream, - stop_token: CancellationToken, - pipeline: JoinHandle<()>, - ) -> Self { - Self { - inner, - stop_token, - pipeline: Some(pipeline), - } - } -} - -impl AsyncRead for HistoryFlacStream { - fn poll_read( - mut self: Pin<&mut Self>, - cx: &mut Context<'_>, - buf: &mut ReadBuf<'_>, - ) -> Poll> { - Pin::new(&mut self.inner).poll_read(cx, buf) - } -} - -impl Unpin for HistoryFlacStream {} - -impl Drop for HistoryFlacStream { - fn drop(&mut self) { - self.stop_token.cancel(); - if let Some(handle) = self.pipeline.take() { - handle.abort(); - } - } -} - -pub struct HistoryOggStream { - inner: OggFlacClientStream, - stop_token: CancellationToken, - pipeline: Option>, -} - -impl HistoryOggStream { - fn new( - inner: OggFlacClientStream, - stop_token: CancellationToken, - pipeline: JoinHandle<()>, - ) -> Self { - Self { - inner, - stop_token, - pipeline: Some(pipeline), - } - } -} - -impl AsyncRead for HistoryOggStream { - fn poll_read( - mut self: Pin<&mut Self>, - cx: &mut Context<'_>, - buf: &mut ReadBuf<'_>, - ) -> Poll> { - Pin::new(&mut self.inner).poll_read(cx, buf) - } -} - -impl Unpin for HistoryOggStream {} - -impl Drop for HistoryOggStream { - fn drop(&mut self) { - self.stop_token.cancel(); - if let Some(handle) = self.pipeline.take() { - handle.abort(); - } - } -} - -/// Gestionnaire multi-canaux. -pub struct ParadiseChannelManager { - channels: HashMap>, -} - -impl ParadiseChannelManager { - pub fn new(channels: HashMap>) -> Self { - Self { channels } - } - - pub async fn with_defaults_with_cover_cache( - cover_cache: Option>, - history_builder: Option, - server_base_url: Option, - ) -> Result { - let mut map = HashMap::new(); - for descriptor in ALL_CHANNELS.iter().copied() { - let mut config = ParadiseStreamChannelConfig::default(); - config.server_base_url = server_base_url.clone(); - - let history_opts = if let Some(builder) = &history_builder { - Some( - builder - .build_for_channel(&descriptor) - .await - .map_err(|e| anyhow!("Failed to init history playlist: {}", e))?, - ) - } else { - None - }; - let channel = ParadiseStreamChannel::new( - descriptor, - config, - cover_cache.clone(), - history_opts, - ) - .await?; - map.insert(descriptor.id, Arc::new(channel)); - } - Ok(Self { channels: map }) - } - - pub async fn with_defaults() -> Result { - Self::with_defaults_with_cover_cache(None, None, None).await - } - - pub fn get(&self, id: u8) -> Option> { - self.channels.get(&id).cloned() - } - - pub fn iter(&self) -> impl Iterator> { - self.channels.values() - } -} --------End of pmoparadise/src/stream_channel_old.rs --------- - ------------- pmoparadise/src/stream_channel.rs ---------- -//! Version simplifiée de stream_channel.rs utilisant RadioParadisePlaylistFeeder + PlaylistSource -//! -//! Cette version remplace l'architecture complexe RadioParadiseStreamSource par : -//! - RadioParadisePlaylistFeeder : télécharge les URLs gapless et alimente une playlist -//! - PlaylistSource::with_history() : lit la playlist et gère l'historique automatiquement - -use std::{ - collections::HashMap, - pin::Pin, - sync::{ - atomic::{AtomicUsize, Ordering}, - Arc, - }, - task::{Context, Poll}, - time::{Duration, Instant, SystemTime, UNIX_EPOCH}, -}; - -use crate::{ - channels::{ChannelDescriptor, ParadiseChannelKind, ALL_CHANNELS}, - client::RadioParadiseClient, - models::{Block, EventId}, - playlist_feeder::RadioParadisePlaylistFeeder, -}; -use anyhow::{anyhow, Context as AnyhowContext, Result}; -use once_cell::sync::OnceCell; -use pmoaudio::{AudioError, AudioPipelineNode}; -use pmoaudio_ext::{ - FlacClientStream, IcyClientStream, MetadataSnapshot, OggFlacClientStream, OggFlacStreamHandle, - PlaylistSource, StreamHandle, StreamingFlacSink, StreamingOggFlacSink, StreamingSinkOptions, - TrackBoundaryCoverNode, -}; -use pmoaudiocache::{get_audio_cache, Cache as AudioCache}; -use pmocovers::{get_cover_cache, Cache as CoverCache}; -use pmoflac::EncoderOptions; -use pmoplaylist::PlaylistManager; -use thiserror::Error; -use tokio::io::{AsyncRead, ReadBuf}; -use tokio::sync::{Mutex, Notify}; -use tokio::task::JoinHandle; -use tokio_util::sync::CancellationToken; -use tracing::{error, info, warn}; - -/// Configuration pour un canal Radio Paradise. -#[derive(Clone, Debug)] -pub struct ParadiseStreamChannelConfig { - /// Durée maximale (en secondes) d'avance acceptée par le broadcast. - pub max_lead_seconds: f64, - /// Options pour le flux FLAC pur. - pub flac_options: StreamingSinkOptions, - /// Options pour le flux OGG-FLAC. - pub ogg_options: StreamingSinkOptions, - /// URL de base du serveur (pour les métadonnées, covers...) - pub server_base_url: Option, -} - -impl Default for ParadiseStreamChannelConfig { - fn default() -> Self { - Self { - max_lead_seconds: 3.0, // Compromis live/fluidité : assez pour absorber les transitions - flac_options: StreamingSinkOptions::flac_defaults(), - ogg_options: StreamingSinkOptions::ogg_defaults(), - server_base_url: None, - } - } -} - -/// Options pour activer l'archivage/historique d'un canal. -pub struct ParadiseHistoryOptions { - pub audio_cache: Arc, - pub cover_cache: Arc, - pub playlist_id: String, - pub collection: Option, - pub replay_max_lead_seconds: f64, - pub max_history_tracks: Option, -} - -/// Builder pratique pour configurer automatiquement les playlists historiques. -#[derive(Clone)] -pub struct ParadiseHistoryBuilder { - pub audio_cache: Arc, - pub cover_cache: Arc, - pub playlist_prefix: String, - pub playlist_title_prefix: Option, - pub max_history_tracks: Option, - pub collection_prefix: Option, - pub replay_max_lead_seconds: f64, -} - -impl ParadiseHistoryBuilder { - pub fn new(audio_cache: Arc, cover_cache: Arc) -> Self { - Self { - audio_cache, - cover_cache, - playlist_prefix: "radio-paradise-history".into(), - playlist_title_prefix: Some("Radio Paradise History".into()), - max_history_tracks: Some(500), - collection_prefix: Some("radio-paradise".into()), - replay_max_lead_seconds: 3.0, // Aligné avec le live - } - } - - pub async fn build_for_channel( - &self, - descriptor: &ChannelDescriptor, - ) -> Result { - let playlist_id = format!("{}-{}", self.playlist_prefix, descriptor.slug); - - let collection = self - .collection_prefix - .as_ref() - .map(|prefix| format!("{}-{}", prefix, descriptor.slug)); - - Ok(ParadiseHistoryOptions { - audio_cache: self.audio_cache.clone(), - cover_cache: self.cover_cache.clone(), - playlist_id, - collection, - replay_max_lead_seconds: self.replay_max_lead_seconds, - max_history_tracks: self.max_history_tracks, - }) - } -} - -impl Default for ParadiseHistoryBuilder { - fn default() -> Self { - let audio_cache = get_audio_cache() - .expect("pmoaudiocache::register_audio_cache must be called before using ParadiseHistoryBuilder::default()"); - let cover_cache = get_cover_cache() - .expect("pmocovers::register_cover_cache must be called before using ParadiseHistoryBuilder::default()"); - Self::new(audio_cache, cover_cache) - } -} - -#[cfg(feature = "pmoconfig")] -impl ParadiseStreamChannelConfig { - pub fn from_config(cfg: &pmoconfig::Config, channel: ParadiseChannelKind) -> Self { - use serde_yaml::Value; - let path = [ - "sources", - "radio_paradise", - "channels", - channel.slug(), - "max_lead_seconds", - ]; - match cfg.get_value(&path) { - Ok(Value::Number(num)) => { - if let Some(v) = num.as_f64() { - Self { - max_lead_seconds: v.max(0.1), - flac_options: StreamingSinkOptions::flac_defaults(), - ogg_options: StreamingSinkOptions::ogg_defaults(), - server_base_url: None, - } - } else { - let default = Self::default(); - let _ = - cfg.set_value(&path, Value::String(default.max_lead_seconds.to_string())); - default - } - } - Ok(Value::String(s)) => { - if let Ok(v) = s.parse::() { - Self { - max_lead_seconds: v.max(0.1), - flac_options: StreamingSinkOptions::flac_defaults(), - ogg_options: StreamingSinkOptions::ogg_defaults(), - server_base_url: None, - } - } else { - let default = Self::default(); - let _ = - cfg.set_value(&path, Value::String(default.max_lead_seconds.to_string())); - default - } - } - _ => { - let default = Self::default(); - let _ = cfg.set_value(&path, Value::String(default.max_lead_seconds.to_string())); - default - } - } - } -} - -/// Stream complet (FLAC pur + OGG-FLAC) pour un canal Radio Paradise. -/// -/// Version simplifiée utilisant RadioParadisePlaylistFeeder + PlaylistSource -pub struct ParadiseStreamChannel { - descriptor: ChannelDescriptor, - state: Arc, - pipeline_handle: JoinHandle<()>, - feeder_handle: JoinHandle<()>, -} - -impl ParadiseStreamChannel { - /// Crée un canal avec client déjà configuré. - pub async fn with_client( - descriptor: ChannelDescriptor, - client: RadioParadiseClient, - config: ParadiseStreamChannelConfig, - cover_cache: Option>, - history: Option, - ) -> Result { - // Propager server_base_url dans les options pour que les encoders injectent les covers du cache - let mut config = config; - if let Some(ref base) = config.server_base_url { - config.flac_options = config - .flac_options - .clone() - .with_server_base_url(Some(base.clone())); - config.ogg_options = config - .ogg_options - .clone() - .with_server_base_url(Some(base.clone())); - } - let cover_cache = cover_cache - .or_else(|| history.as_ref().map(|opts| opts.cover_cache.clone())) - .or_else(|| get_cover_cache()); - let manager = PlaylistManager::get(); - - // 1. Créer la playlist live pour ce canal - let live_playlist_id = format!("radio-paradise-live-{}", descriptor.slug); - let (feeder, live_read) = if let Some(ref history_opts) = history { - RadioParadisePlaylistFeeder::new( - client.clone(), - history_opts.audio_cache.clone(), - history_opts.cover_cache.clone(), - live_playlist_id.clone(), - history_opts.collection.clone(), - ) - .await? - } else { - // Pas d'historique, on a besoin quand même d'un cache audio basique - return Err(anyhow!( - "History options required for now (audio cache needed)" - )); - }; - - let feeder = Arc::new(feeder); - - // 2. Créer/récupérer la playlist historique si activée - let history_write = if let Some(ref history_opts) = history { - let write = manager - .get_persistent_write_handle(history_opts.playlist_id.clone()) - .await?; - - // Configurer la capacité - if let Some(capacity) = history_opts.max_history_tracks { - write.set_capacity(Some(capacity)).await?; - } - - // Configurer le titre - let title = format!("Radio Paradise History - {}", descriptor.display_name); - write.set_title(title).await?; - - Some(Arc::new(write)) - } else { - None - }; - - // 3. Créer la source playlist avec historique - let audio_cache = history.as_ref().unwrap().audio_cache.clone(); - let mut source = if let Some(history_write) = history_write.clone() { - PlaylistSource::with_history(live_read, audio_cache.clone(), history_write) - } else { - PlaylistSource::new(live_read, audio_cache.clone()) - }; - - // 4. Créer les sinks de broadcast (FLAC + OGG) - let (flac_sink, stream_handle) = StreamingFlacSink::with_options( - EncoderOptions::default(), - 16, - config.max_lead_seconds, - config.flac_options.clone(), - ); - let (ogg_sink, ogg_handle) = StreamingOggFlacSink::with_options( - EncoderOptions::default(), - 16, - config.max_lead_seconds, - config.ogg_options.clone(), - ); - - let mut downstream_children: Vec> = Vec::new(); - downstream_children.push(Box::new(flac_sink)); - downstream_children.push(Box::new(ogg_sink)); - - // 5. Optionnel : ajouter le nœud de cache de covers - if let Some(cache) = cover_cache { - let mut cover_node = TrackBoundaryCoverNode::new(cache); - for child in downstream_children { - cover_node.register(child); - } - source.register(Box::new(cover_node)); - } else { - for child in downstream_children { - source.register(child); - } - } - - stream_handle.set_auto_stop(false); - ogg_handle.set_auto_stop(false); - - // 6. Lancer le pipeline audio - let stop_token = CancellationToken::new(); - let pipeline_stop = stop_token.clone(); - let channel_display_name = descriptor.display_name; - - let state = Arc::new(ChannelState { - descriptor, - config, - client, - feeder: feeder.clone(), - stream_handle, - ogg_handle, - history_playlist_id: history.map(|h| h.playlist_id), - history_audio_cache: history_write.map(|_| audio_cache), - active_clients: AtomicUsize::new(0), - activity_notify: Notify::new(), - stop_token, - current_block: Mutex::new(None), - prefetch_lock: Mutex::new(()), - }); - - let pipeline_state = state.clone(); - let pipeline_handle = tokio::spawn(async move { - info!( - "RadioParadise stream pipeline started for channel {}", - channel_display_name - ); - if let Err(e) = Box::new(source).run(pipeline_stop).await { - error!("Pipeline error for channel {}: {}", channel_display_name, e); - pipeline_state.handle_pipeline_error(&e).await; - } - }); - - // 7. Lancer le feeder qui traite les blocs - let feeder_runner = feeder.clone(); - tokio::spawn(async move { - if let Err(e) = feeder_runner.run().await { - error!("RadioParadisePlaylistFeeder error: {}", e); - } - }); - - // 8. Lancer le scheduler qui enqueue les blocs - let feeder_state = state.clone(); - let feeder_handle = tokio::spawn(async move { - feeder_state.run_scheduler().await; - }); - - Ok(Self { - descriptor, - state, - pipeline_handle, - feeder_handle, - }) - } - - /// Crée un canal en construisant automatiquement le client pour ce descriptor. - pub async fn new( - descriptor: ChannelDescriptor, - config: ParadiseStreamChannelConfig, - cover_cache: Option>, - history: Option, - ) -> Result { - let client = RadioParadiseClient::builder() - .channel(descriptor.id) - .build() - .await?; - Self::with_client(descriptor, client, config, cover_cache, history).await - } - - /// S'abonne au flux FLAC pur. - pub fn subscribe_flac(&self) -> ChannelFlacStream { - self.state.on_client_added(); - let inner = self.state.stream_handle.subscribe_flac(); - ChannelFlacStream::new(inner, self.state.clone()) - } - - /// S'abonne au flux FLAC + ICY metadata. - pub fn subscribe_icy(&self) -> ChannelIcyStream { - self.state.on_client_added(); - let inner = self.state.stream_handle.subscribe_icy(); - ChannelIcyStream::new(inner, self.state.clone()) - } - - /// S'abonne au flux OGG-FLAC. - pub fn subscribe_ogg(&self) -> ChannelOggStream { - self.state.on_client_added(); - let inner = self.state.ogg_handle.subscribe(); - ChannelOggStream::new(inner, self.state.clone()) - } - - /// Snapshot des métadonnées actuelles. - pub async fn metadata(&self) -> MetadataSnapshot { - self.state.stream_handle.get_metadata().await - } - - /// Nombre de clients actifs. - pub fn active_clients(&self) -> usize { - self.state.active_clients.load(Ordering::SeqCst) - } - - pub fn descriptor(&self) -> ChannelDescriptor { - self.descriptor - } - - /// Lance un pipeline dédié pour rejouer l'historique (FLAC pur) pour un client. - pub async fn stream_history_flac( - &self, - client_id: &str, - ) -> Result { - let history_id = self - .state - .history_playlist_id - .as_ref() - .ok_or(HistoryStreamError::HistoryDisabled)?; - - let audio_cache = self - .state - .history_audio_cache - .as_ref() - .ok_or(HistoryStreamError::HistoryDisabled)?; - - tracing::info!( - "Starting historical FLAC replay for channel {} (client_id={})", - self.descriptor.display_name, - client_id - ); - - let reader = pmoplaylist::PlaylistManager::get() - .get_read_handle(history_id) - .await - .map_err(|e| HistoryStreamError::Playlist(e.to_string()))?; - - let mut source = PlaylistSource::new(reader, audio_cache.clone()); - let (flac_sink, handle) = StreamingFlacSink::with_max_broadcast_lead( - EncoderOptions::default(), - 16, - self.state.config.max_lead_seconds, - ); - source.register(Box::new(flac_sink)); - let stop_token = CancellationToken::new(); - let stop_clone = stop_token.clone(); - let pipeline = tokio::spawn(async move { - let _ = Box::new(source).run(stop_clone).await; - }); - let stream = handle.subscribe_flac(); - Ok(HistoryFlacStream::new(stream, stop_token, pipeline)) - } - - /// Lance un pipeline dédié pour rejouer l'historique (OGG-FLAC) pour un client. - pub async fn stream_history_ogg( - &self, - client_id: &str, - ) -> Result { - let history_id = self - .state - .history_playlist_id - .as_ref() - .ok_or(HistoryStreamError::HistoryDisabled)?; - - let audio_cache = self - .state - .history_audio_cache - .as_ref() - .ok_or(HistoryStreamError::HistoryDisabled)?; - - tracing::info!( - "Starting historical OGG replay for channel {} (client_id={})", - self.descriptor.display_name, - client_id - ); - - let reader = pmoplaylist::PlaylistManager::get() - .get_read_handle(history_id) - .await - .map_err(|e| HistoryStreamError::Playlist(e.to_string()))?; - - let mut source = PlaylistSource::new(reader, audio_cache.clone()); - let (ogg_sink, handle) = StreamingOggFlacSink::with_max_broadcast_lead( - EncoderOptions::default(), - 16, - self.state.config.max_lead_seconds, - ); - source.register(Box::new(ogg_sink)); - let stop_token = CancellationToken::new(); - let stop_clone = stop_token.clone(); - let pipeline = tokio::spawn(async move { - let _ = Box::new(source).run(stop_clone).await; - }); - let stream = handle.subscribe(); - Ok(HistoryOggStream::new(stream, stop_token, pipeline)) - } -} - -impl Drop for ParadiseStreamChannel { - fn drop(&mut self) { - self.state.stop_token.cancel(); - self.pipeline_handle.abort(); - self.feeder_handle.abort(); - } -} - -const MAX_BLOCK_LEAD: Duration = Duration::from_secs(3600); -const BLOCK_LEAD_CHECK_CHUNK: Duration = Duration::from_secs(300); -const LIVE_PREFETCH_MIN_TRACKS: usize = 5; -const LIVE_PREFETCH_TIMEOUT: Duration = Duration::from_secs(10); -const LIVE_PREFETCH_POLL_INTERVAL: Duration = Duration::from_millis(200); -const LIVE_PREFETCH_MAX_BLOCKS: usize = 4; - -static GLOBAL_CHANNEL_MANAGER: OnceCell> = OnceCell::new(); - -struct ChannelState { - descriptor: ChannelDescriptor, - config: ParadiseStreamChannelConfig, - client: RadioParadiseClient, - feeder: Arc, - stream_handle: StreamHandle, - ogg_handle: OggFlacStreamHandle, - history_playlist_id: Option, - history_audio_cache: Option>, - active_clients: AtomicUsize, - activity_notify: Notify, - stop_token: CancellationToken, - current_block: Mutex>, - prefetch_lock: Mutex<()>, -} - -impl ChannelState { - fn current_unix_millis() -> u64 { - SystemTime::now() - .duration_since(UNIX_EPOCH) - .map(|d| d.as_millis() as u64) - .unwrap_or(0) - } - - fn block_lead_delay(&self, block: &Block) -> Option { - let start = block.start_time_millis()?; - let now = Self::current_unix_millis(); - let max_lead_ms = MAX_BLOCK_LEAD.as_millis() as u64; - if start <= now + max_lead_ms { - None - } else { - Some(Duration::from_millis(start - now - max_lead_ms)) - } - } - - fn on_client_added(&self) { - if self.active_clients.fetch_add(1, Ordering::SeqCst) == 0 { - self.activity_notify.notify_one(); - } - } - - fn on_client_removed(&self) { - self.active_clients.fetch_sub(1, Ordering::SeqCst); - } - - async fn wait_for_clients(&self) -> bool { - while self.active_clients.load(Ordering::SeqCst) == 0 { - tokio::select! { - _ = self.stop_token.cancelled() => return false, - _ = self.activity_notify.notified() => {}, - } - } - true - } - - async fn wait_until_block_ready(&self, block: &Block) -> BlockReadiness { - loop { - if self.stop_token.is_cancelled() { - return BlockReadiness::Stopped; - } - if self.active_clients.load(Ordering::SeqCst) == 0 { - return BlockReadiness::NoClients; - } - - if let Some(delay) = self.block_lead_delay(block) { - let sleep_for = delay.min(BLOCK_LEAD_CHECK_CHUNK); - let lead_secs = delay.as_secs_f64(); - info!( - "Block {} scheduled too far in the future ({:.1} min). Sleeping {:?} before retrying.", - block.event, - lead_secs / 60.0, - sleep_for - ); - tokio::select! { - _ = self.stop_token.cancelled() => return BlockReadiness::Stopped, - _ = tokio::time::sleep(sleep_for) => {}, - } - continue; - } - - return BlockReadiness::Ready; - } - } - - fn live_playlist_id(&self) -> String { - format!("radio-paradise-live-{}", self.descriptor.slug) - } - - async fn prefetch_until_horizon(&self) -> Result<()> { - let _guard = self.prefetch_lock.lock().await; - let playlist_id = self.live_playlist_id(); - let manager = PlaylistManager::get(); - let reader = manager - .get_read_handle(&playlist_id) - .await - .with_context(|| format!("Failed to get live playlist {}", playlist_id))?; - let start = Instant::now(); - let mut next_event: Option = None; - let mut attempts = 0usize; - - loop { - let available = reader - .remaining() - .await - .with_context(|| format!("Failed to inspect playlist {}", playlist_id))?; - if available >= LIVE_PREFETCH_MIN_TRACKS { - return Ok(()); - } - - if start.elapsed() >= LIVE_PREFETCH_TIMEOUT { - warn!( - "Prefetch timeout for channel {} ({} tracks available)", - self.descriptor.display_name, available - ); - return Ok(()); - } - - if attempts >= LIVE_PREFETCH_MAX_BLOCKS { - warn!( - "Prefetch block limit reached for channel {} ({} tracks available)", - self.descriptor.display_name, available - ); - return Ok(()); - } - - match self.client.get_block(next_event).await { - Ok(block) => { - attempts += 1; - next_event = Some(block.end_event); - self.feeder.push_block_id(block.event).await; - } - Err(e) => { - warn!( - "Failed to fetch block during prefetch for channel {}: {}", - self.descriptor.display_name, e - ); - return Ok(()); - } - } - - tokio::time::sleep(LIVE_PREFETCH_POLL_INTERVAL).await; - } - } - - async fn set_current_block(&self, event_id: EventId) { - let mut guard = self.current_block.lock().await; - *guard = Some(event_id); - } - - async fn take_current_block(&self) -> Option { - self.current_block.lock().await.take() - } - - async fn handle_pipeline_error(&self, err: &AudioError) { - if let Some(event_id) = self.take_current_block().await { - warn!( - "Pipeline error while streaming block {} on channel {}: {}. Rescheduling block.", - event_id, self.descriptor.display_name, err - ); - self.feeder.retry_block(event_id).await; - } else { - warn!( - "Pipeline error for channel {} but no tracked block: {}", - self.descriptor.display_name, err - ); - } - } - - async fn run_scheduler(self: Arc) { - let mut backoff = Duration::from_secs(5); - 'scheduler: loop { - if self.stop_token.is_cancelled() { - break; - } - - if !self.wait_for_clients().await { - break; - } - - match self.client.get_block(None).await { - Ok(block) => { - match self.wait_until_block_ready(&block).await { - BlockReadiness::Ready => {} - BlockReadiness::NoClients => continue, - BlockReadiness::Stopped => break, - } - info!( - "Channel {} streaming block {}", - self.descriptor.display_name, block.event - ); - self.set_current_block(block.event).await; - self.feeder.push_block_id(block.event).await; - let mut next_event = block.end_event; - - loop { - if self.stop_token.is_cancelled() { - return; - } - - if self.active_clients.load(Ordering::SeqCst) == 0 { - break; - } - - match self.client.get_block(Some(next_event)).await { - Ok(next_block) => { - match self.wait_until_block_ready(&next_block).await { - BlockReadiness::Ready => {} - BlockReadiness::NoClients => break, - BlockReadiness::Stopped => break 'scheduler, - } - self.set_current_block(next_block.event).await; - self.feeder.push_block_id(next_block.event).await; - next_event = next_block.end_event; - backoff = Duration::from_secs(5); - } - Err(e) => { - warn!( - "Failed to fetch next block for channel {}: {}", - self.descriptor.display_name, e - ); - tokio::select! { - _ = self.stop_token.cancelled() => return, - _ = tokio::time::sleep(backoff) => {}, - } - backoff = (backoff * 2).min(Duration::from_secs(60)); - } - } - } - } - Err(e) => { - warn!( - "Failed to fetch current block for channel {}: {}", - self.descriptor.display_name, e - ); - tokio::select! { - _ = self.stop_token.cancelled() => break, - _ = tokio::time::sleep(backoff) => {}, - } - backoff = (backoff * 2).min(Duration::from_secs(60)); - } - } - } - } -} - -enum BlockReadiness { - Ready, - NoClients, - Stopped, -} - -macro_rules! wrap_stream { - ($name:ident, $inner:ty) => { - pub struct $name { - inner: $inner, - state: Arc, - } - - impl $name { - fn new(inner: $inner, state: Arc) -> Self { - Self { inner, state } - } - } - - impl AsyncRead for $name { - fn poll_read( - mut self: Pin<&mut Self>, - cx: &mut Context<'_>, - buf: &mut ReadBuf<'_>, - ) -> Poll> { - Pin::new(&mut self.inner).poll_read(cx, buf) - } - } - - impl Drop for $name { - fn drop(&mut self) { - self.state.on_client_removed(); - } - } - }; -} - -wrap_stream!(ChannelFlacStream, FlacClientStream); -wrap_stream!(ChannelIcyStream, IcyClientStream); -wrap_stream!(ChannelOggStream, OggFlacClientStream); - -#[derive(Debug, Error)] -pub enum HistoryStreamError { - #[error("history replay not enabled for this channel")] - HistoryDisabled, - #[error("playlist error: {0}")] - Playlist(String), -} - -pub struct HistoryFlacStream { - inner: FlacClientStream, - stop_token: CancellationToken, - pipeline: Option>, -} - -impl HistoryFlacStream { - fn new( - inner: FlacClientStream, - stop_token: CancellationToken, - pipeline: JoinHandle<()>, - ) -> Self { - Self { - inner, - stop_token, - pipeline: Some(pipeline), - } - } -} - -impl AsyncRead for HistoryFlacStream { - fn poll_read( - mut self: Pin<&mut Self>, - cx: &mut Context<'_>, - buf: &mut ReadBuf<'_>, - ) -> Poll> { - Pin::new(&mut self.inner).poll_read(cx, buf) - } -} - -impl Unpin for HistoryFlacStream {} - -impl Drop for HistoryFlacStream { - fn drop(&mut self) { - self.stop_token.cancel(); - if let Some(handle) = self.pipeline.take() { - handle.abort(); - } - } -} - -pub struct HistoryOggStream { - inner: OggFlacClientStream, - stop_token: CancellationToken, - pipeline: Option>, -} - -impl HistoryOggStream { - fn new( - inner: OggFlacClientStream, - stop_token: CancellationToken, - pipeline: JoinHandle<()>, - ) -> Self { - Self { - inner, - stop_token, - pipeline: Some(pipeline), - } - } -} - -impl AsyncRead for HistoryOggStream { - fn poll_read( - mut self: Pin<&mut Self>, - cx: &mut Context<'_>, - buf: &mut ReadBuf<'_>, - ) -> Poll> { - Pin::new(&mut self.inner).poll_read(cx, buf) - } -} - -impl Unpin for HistoryOggStream {} - -impl Drop for HistoryOggStream { - fn drop(&mut self) { - self.stop_token.cancel(); - if let Some(handle) = self.pipeline.take() { - handle.abort(); - } - } -} - -/// Gestionnaire multi-canaux. -pub struct ParadiseChannelManager { - channels: HashMap>, -} - -impl ParadiseChannelManager { - pub fn new(channels: HashMap>) -> Self { - Self { channels } - } - - pub async fn with_defaults_with_cover_cache( - cover_cache: Option>, - history_builder: Option, - server_base_url: Option, - ) -> Result { - tracing::warn!( - "➡️ Entering with_defaults_with_cover_cache ({} channels, base_url={:?})", - ALL_CHANNELS.len(), - server_base_url - ); - let mut map = HashMap::new(); - for descriptor in ALL_CHANNELS.iter().copied() { - let mut config = ParadiseStreamChannelConfig::default(); - config.server_base_url = server_base_url.clone(); - - let start = Instant::now(); - tracing::warn!( - "⏳ Initializing Radio Paradise channel {} ({})...", - descriptor.display_name, - descriptor.slug - ); - - let history_opts = if let Some(builder) = &history_builder { - tracing::warn!( - " ⏳ Building history options for channel {} ({})", - descriptor.display_name, - descriptor.slug - ); - Some( - builder - .build_for_channel(&descriptor) - .await - .map_err(|e| anyhow!("Failed to init history playlist: {}", e))?, - ) - } else { - None - }; - tracing::warn!( - " ⏩ History options ready for channel {} ({})", - descriptor.display_name, - descriptor.slug - ); - let channel = match tokio::time::timeout( - Duration::from_secs(20), - ParadiseStreamChannel::new(descriptor, config, cover_cache.clone(), history_opts), - ) - .await - { - Ok(Ok(ch)) => { - tracing::warn!( - "✅ Channel {} ({}) initialized in {:?}", - descriptor.display_name, - descriptor.slug, - start.elapsed() - ); - ch - } - Ok(Err(e)) => { - tracing::error!( - "⚠️ Failed to initialize channel {} ({}): {}", - descriptor.display_name, - descriptor.slug, - e - ); - continue; - } - Err(_) => { - tracing::error!( - "⚠️ Timeout initializing channel {} ({}) after 20s, skipping", - descriptor.display_name, - descriptor.slug - ); - continue; - } - }; - map.insert(descriptor.id, Arc::new(channel)); - } - Ok(Self { channels: map }) - } - - pub async fn with_defaults() -> Result { - Self::with_defaults_with_cover_cache(None, None, None).await - } - - pub fn get(&self, id: u8) -> Option> { - self.channels.get(&id).cloned() - } - - pub fn iter(&self) -> impl Iterator> { - self.channels.values() - } - - pub async fn prefetch_until_horizon(&self, channel_id: u8) -> Result<()> { - let channel = self - .get(channel_id) - .ok_or_else(|| anyhow!("Unknown channel id {}", channel_id))?; - channel.prefetch_until_horizon().await - } -} - -pub fn register_global_channel_manager(manager: Arc) { - let _ = GLOBAL_CHANNEL_MANAGER.set(Arc::downgrade(&manager)); -} - -pub fn get_global_channel_manager() -> Option> { - GLOBAL_CHANNEL_MANAGER.get().and_then(|weak| weak.upgrade()) -} - -impl ParadiseStreamChannel { - pub async fn prefetch_until_horizon(&self) -> Result<()> { - self.state.prefetch_until_horizon().await - } -} --------End of pmoparadise/src/stream_channel.rs --------- - ------------- pmoparadise/examples/download_block.rs ---------- -//! Télécharge un bloc complet de Radio Paradise et sauvegarde toutes les pistes en FLAC -//! -//! Ce programme démontre l'utilisation de la chaîne : -//! 1. RadioParadiseStreamSource - Télécharge et décode un bloc FLAC de Radio Paradise -//! 2. FlacFileSink - Sauvegarde automatiquement chaque piste dans un fichier FLAC séparé -//! -//! La nouvelle architecture AudioPipelineNode permet de : -//! - Télécharger et décoder automatiquement les blocs FLAC de Radio Paradise -//! - Détecter les limites de pistes (TrackBoundary) -//! - Sauvegarder automatiquement chaque piste dans un fichier séparé -//! - Gérer proprement l'arrêt du pipeline avec un CancellationToken -//! -//! Usage: -//! cargo run --example download_block -- -//! -//! Exemple: -//! cargo run --example download_block -- 0 # Main Mix -//! cargo run --example download_block -- 1 # Mellow Mix -//! cargo run --example download_block -- 2 # Rock Mix -//! cargo run --example download_block -- 3 # World/Etc Mix - -use pmoaudio::{AudioPipelineNode, FlacFileSink}; -use pmoparadise::{RadioParadiseClient, RadioParadiseStreamSource}; -use std::env; -use tokio_util::sync::CancellationToken; - -#[tokio::main] -async fn main() -> Result<(), Box> { - // Initialiser tracing pour le debug - tracing_subscriber::fmt() - .with_env_filter( - tracing_subscriber::EnvFilter::from_default_env() - .add_directive(tracing::Level::INFO.into()), - ) - .init(); - - // Récupérer les arguments - let args: Vec = env::args().collect(); - if args.len() != 2 { - eprintln!("Usage: {} ", args[0]); - eprintln!(); - eprintln!("Downloads a complete Radio Paradise block and saves all tracks as FLAC files."); - eprintln!(); - eprintln!("Channel IDs:"); - eprintln!(" 0 - Main Mix (eclectic, diverse mix)"); - eprintln!(" 1 - Mellow Mix (smooth, chilled music)"); - eprintln!(" 2 - Rock Mix (classic & modern rock)"); - eprintln!(" 3 - World/Etc Mix (global sounds)"); - eprintln!(); - eprintln!("Example:"); - eprintln!(" {} 0 # Download Main Mix", args[0]); - eprintln!(" {} 2 # Download Rock Mix", args[0]); - std::process::exit(1); - } - - let channel_id: u8 = match args[1].parse() { - Ok(id) => id, - Err(_) => { - eprintln!("Error: channel_id must be a number between 0 and 3"); - std::process::exit(1); - } - }; - - if channel_id > 3 { - eprintln!("Error: channel_id must be between 0 and 3"); - std::process::exit(1); - } - - println!("=== Radio Paradise Block Downloader ==="); - println!(); - println!("Channel ID: {}", channel_id); - println!(); - - // Créer le client Radio Paradise pour le channel spécifié - println!("Fetching current block metadata..."); - let client = RadioParadiseClient::builder() - .channel(channel_id) - .build() - .await?; - - // Récupérer le bloc actuel - let block = client.get_block(None).await?; - - println!("Block Information:"); - println!(" Event ID: {}", block.event); - println!(" Songs: {}", block.song_count()); - println!(" Duration: {:.1} minutes", block.length as f64 / 60000.0); - println!(); - - // Afficher la liste des pistes - println!("Tracklist:"); - for (index, song) in block.songs_ordered() { - println!( - " {:2}. {} - {} ({})", - index + 1, - song.artist, - song.title, - song.album.as_deref().unwrap_or("Unknown Album") - ); - } - println!(); - - // Créer le répertoire de sortie - let output_dir = format!("./rp_channel_{}block{}", channel_id, block.event); - std::fs::create_dir_all(&output_dir)?; - println!("Output directory: {}", output_dir); - println!(); - - // Créer le pipeline: RadioParadiseStreamSource → FlacFileSink - let mut source = RadioParadiseStreamSource::new(client); - - // Ajouter le bloc à télécharger - source.push_block_id(block.event); - - // Créer le sink qui sauvegarde chaque piste dans un fichier séparé - let base_path = format!("{}/track.flac", output_dir); - let sink = FlacFileSink::new(&base_path); - - // Construire la chaîne: source → sink - source.register(Box::new(sink)); - - // Créer un token d'arrêt - let stop_token = CancellationToken::new(); - - // Gérer Ctrl+C pour arrêt propre - let stop_token_clone = stop_token.clone(); - tokio::spawn(async move { - tokio::signal::ctrl_c().await.ok(); - println!("\n\nReceived Ctrl+C, stopping..."); - stop_token_clone.cancel(); - }); - - // Lancer tout le pipeline - println!("Downloading and processing block..."); - println!("Press Ctrl+C to stop."); - println!(); - let start = std::time::Instant::now(); - - let result = Box::new(source).run(stop_token).await; - - let elapsed = start.elapsed(); - - // Vérifier le résultat - match result { - Ok(()) => { - println!(); - println!( - "✓ Download completed successfully in {:.2}s", - elapsed.as_secs_f64() - ); - println!(" Output directory: {}", output_dir); - println!(); - - // Afficher les fichiers créés - let entries = std::fs::read_dir(&output_dir)?; - let mut files: Vec<_> = entries - .filter_map(|e| e.ok()) - .filter(|e| { - e.path() - .extension() - .and_then(|s| s.to_str()) - .map(|s| s == "flac") - .unwrap_or(false) - }) - .collect(); - files.sort_by_key(|e| e.path()); - - println!("Files created:"); - for (i, entry) in files.iter().enumerate() { - let path = entry.path(); - let metadata = std::fs::metadata(&path)?; - let size_mb = metadata.len() as f64 / (1024.0 * 1024.0); - println!( - " {:2}. {} ({:.2} MB)", - i + 1, - path.file_name().unwrap().to_string_lossy(), - size_mb - ); - } - println!(); - - // Calculer la taille totale - let total_size: u64 = files - .iter() - .filter_map(|e| std::fs::metadata(e.path()).ok()) - .map(|m| m.len()) - .sum(); - println!( - "Total size: {:.2} MB", - total_size as f64 / (1024.0 * 1024.0) - ); - } - Err(e) => { - eprintln!(); - eprintln!("✗ Download error: {}", e); - eprintln!(); - return Err(e.into()); - } - } - - Ok(()) -} --------End of pmoparadise/examples/download_block.rs --------- - ------------- pmoparadise/examples/now_playing.rs ---------- -//! Example: Display currently playing song and block information -//! -//! This example demonstrates: -//! - Creating a Radio Paradise client -//! - Fetching the current block -//! - Displaying song metadata -//! - Generating cover image URLs -//! -//! Run with: cargo run --example now_playing - -use pmoparadise::{RadioParadiseClient, Result}; - -#[tokio::main] -async fn main() -> Result<()> { - // Initialize logging (optional) - #[cfg(feature = "logging")] - tracing_subscriber::fmt::init(); - - println!("Radio Paradise - Now Playing"); - println!("=============================\n"); - - // Create client with default settings (FLAC quality, channel 0) - let client = RadioParadiseClient::new().await?; - - // Get what's currently playing - let now_playing = client.now_playing().await?; - let block = &now_playing.block; - - // Display block information - println!("Block Information:"); - println!(" Event ID: {}", block.event); - println!(" Next Event: {}", block.end_event); - println!(" Duration: {:.1} minutes", block.length as f64 / 60000.0); - println!(" Songs in block: {}", block.song_count()); - println!(" Stream URL: {}\n", block.url); - - // Display current song (if available) - if let Some(song) = &now_playing.current_song { - println!("Now Playing:"); - println!(" Title: {}", song.title); - println!(" Artist: {}", song.artist); - if let Some(ref album) = song.album { - println!(" Album: {}", album); - } - if let Some(year) = song.year { - println!(" Year: {}", year); - } - if let Some(rating) = song.rating { - println!(" Rating: {:.1}/10", rating); - } - println!( - " Duration: {}:{:02}", - song.duration / 60000, - (song.duration % 60000) / 1000 - ); - - // Display cover URL - if let Some(cover) = &song.cover { - if let Some(cover_url) = block.cover_url(cover) { - println!(" Cover: {}", cover_url); - } - } - println!(); - } - - // Display all songs in the block - println!("All Songs in This Block:"); - println!("------------------------"); - - for (index, song) in block.songs_ordered() { - let start_sec = song.elapsed / 1000; - let duration_sec = song.duration / 1000; - - println!( - "{}. [{:02}:{:02}] {} - {} ({:02}:{:02})", - index + 1, - start_sec / 60, - start_sec % 60, - song.artist, - song.title, - duration_sec / 60, - duration_sec % 60 - ); - if let Some(ref album) = song.album { - println!(" Album: {}", album); - } - - if let Some(year) = song.year { - print!(" Year: {}", year); - } - if let Some(rating) = song.rating { - print!(" Rating: {:.1}/10", rating); - } - println!("\n"); - } - - // Show how to get the next block - println!("Fetching Next Block..."); - let next_block = client.get_block(Some(block.end_event)).await?; - println!(" Next block event: {}", next_block.event); - println!(" Songs in next block: {}", next_block.song_count()); - - if let Some((_, first_song)) = next_block.songs_ordered().first() { - println!(" First song: {} - {}", first_song.artist, first_song.title); - } - - Ok(()) -} --------End of pmoparadise/examples/now_playing.rs --------- - ------------- pmoparadise/examples/play_and_cache.rs ---------- -//! Télécharge un bloc Radio Paradise, le cache, et le joue en même temps -//! -//! Ce programme démontre l'utilisation complète de la chaîne : -//! 1. RadioParadiseStreamSource - Télécharge et décode un bloc FLAC -//! 2. FlacCacheSink - Cache chaque piste en FLAC et alimente une playlist -//! 3. PlaylistSource - Lit la playlist pendant le téléchargement -//! 4. TimerNode - Régule le débit pour éviter EOF prématurés (progressive cache) -//! 5. AudioSink - Joue l'audio sur la sortie standard -//! -//! Architecture : -//! ```text -//! Pipeline 1 (Download & Cache): -//! RadioParadiseStreamSource → FlacCacheSink (avec playlist abonnée) -//! -//! Pipeline 2 (Playback): -//! PlaylistSource → TimerNode (rate limiting) → AudioSink -//! ↓ -//! Prévention EOF -//! (3s max lead) -//! ``` -//! -//! Usage: -//! cargo run --example play_and_cache --features full -- -//! -//! Exemple: -//! cargo run --example play_and_cache --features full -- 0 # Main Mix -//! cargo run --example play_and_cache --features full -- 2 # Rock Mix - -use pmoaudio::{AudioPipelineNode, AudioSink, TimerNode}; -use pmoaudio_ext::{FlacCacheSink, PlaylistSource}; -use pmoaudiocache::{ - new_cache_with_consolidation as new_audio_cache, - register_audio_cache as register_global_audio_cache, -}; -use pmocovers::{new_cache_with_consolidation as new_cover_cache, register_cover_cache}; -use pmoparadise::{RadioParadiseClient, RadioParadiseStreamSource}; -use pmoplaylist::register_audio_cache as register_playlist_audio_cache; -use std::env; -use std::sync::Arc; -use tokio_util::sync::CancellationToken; - -#[tokio::main] -async fn main() -> Result<(), Box> { - // Initialiser tracing avec beaucoup de logs - tracing_subscriber::fmt() - .with_env_filter( - tracing_subscriber::EnvFilter::from_default_env() - .add_directive(tracing::Level::DEBUG.into()) - .add_directive("pmoaudio=debug".parse()?) - .add_directive("pmoaudio_ext=debug".parse()?) - .add_directive("pmoplaylist=debug".parse()?) - .add_directive("pmoparadise=debug".parse()?) - .add_directive("pmoaudiocache=debug".parse()?), - ) - .init(); - - tracing::info!("=== Radio Paradise Play & Cache ==="); - - // Récupérer les arguments - let args: Vec = env::args().collect(); - if args.len() < 2 { - eprintln!("Usage: {} [--null-audio]", args[0]); - eprintln!(); - eprintln!("Downloads a Radio Paradise block, caches it, and plays it simultaneously."); - eprintln!(); - eprintln!("Channel IDs:"); - eprintln!(" 0 - Main Mix (eclectic, diverse mix)"); - eprintln!(" 1 - Mellow Mix (smooth, chilled music)"); - eprintln!(" 2 - Rock Mix (classic & modern rock)"); - eprintln!(" 3 - World/Etc Mix (global sounds)"); - eprintln!(); - eprintln!("Options:"); - eprintln!(" --null-audio Don't play audio (for testing without audio device)"); - std::process::exit(1); - } - - let channel_id: u8 = match args[1].parse() { - Ok(id) if id <= 3 => id, - _ => { - eprintln!("Error: channel_id must be a number between 0 and 3"); - std::process::exit(1); - } - }; - - let use_null_audio = args.len() > 2 && args[2] == "--null-audio"; - - tracing::info!("Channel ID: {}", channel_id); - if use_null_audio { - tracing::info!("Using null audio output (no playback)"); - } - - // ═══════════════════════════════════════════════════════════════════════════ - // Initialiser les caches et le gestionnaire de playlist - // ═══════════════════════════════════════════════════════════════════════════ - - let base_dir = - std::env::var("PMO_CONFIG_DIR").unwrap_or_else(|_| "/tmp/pmomusic_test".to_string()); - std::fs::create_dir_all(&base_dir)?; - - tracing::info!("Initializing caches in: {}", base_dir); - - // Créer le cache audio - let audio_cache_dir = format!("{}/audio_cache", base_dir); - std::fs::create_dir_all(&audio_cache_dir)?; - let audio_cache = new_audio_cache(&audio_cache_dir, 1000).await?; - tracing::debug!("Audio cache initialized at: {}", audio_cache_dir); - - // Créer le cache de covers - let cover_cache_dir = format!("{}/cover_cache", base_dir); - std::fs::create_dir_all(&cover_cache_dir)?; - let cover_cache = new_cover_cache(&cover_cache_dir, 100).await?; - tracing::debug!("Cover cache initialized at: {}", cover_cache_dir); - - // Enregistrer le cache audio dans pmoplaylist - // (requis par pmoplaylist pour valider les pks) - register_global_audio_cache(audio_cache.clone()); - register_playlist_audio_cache(audio_cache.clone()); - register_cover_cache(cover_cache.clone()); - tracing::debug!("Audio cache registered in pmoplaylist"); - - // Utiliser le gestionnaire de playlist singleton - tracing::info!("Getting playlist manager..."); - let playlist_manager = pmoplaylist::PlaylistManager(); - tracing::debug!("Playlist manager obtained"); - - // ═══════════════════════════════════════════════════════════════════════════ - // Créer la playlist pour ce channel - // ═══════════════════════════════════════════════════════════════════════════ - - let playlist_id = format!("radio-paradise-ch{}", channel_id); - tracing::info!("Creating playlist: {}", playlist_id); - - // Créer une playlist éphémère (non persistante) pour cet exemple - let writer = playlist_manager - .get_write_handle(playlist_id.clone()) - .await?; - writer - .set_title(format!("Radio Paradise - Channel {}", channel_id)) - .await?; - writer.flush().await?; // Vider la playlist si elle existait - tracing::debug!("Playlist created and flushed"); - - // Créer le reader pour la lecture - let reader = playlist_manager.get_read_handle(&playlist_id).await?; - tracing::debug!("Read handle created"); - - // ═══════════════════════════════════════════════════════════════════════════ - // Récupérer les infos du bloc à télécharger - // ═══════════════════════════════════════════════════════════════════════════ - - tracing::info!("Fetching current block metadata..."); - let client = RadioParadiseClient::builder() - .channel(channel_id) - .build() - .await?; - - let block = client.get_block(None).await?; - - tracing::info!("Block Information:"); - tracing::info!(" Event ID: {}", block.event); - tracing::info!(" Songs: {}", block.song_count()); - tracing::info!(" Duration: {:.1} minutes", block.length as f64 / 60000.0); - tracing::info!(""); - - tracing::info!("Tracklist:"); - for (index, song) in block.songs_ordered() { - tracing::info!( - " {:2}. {} - {} ({})", - index + 1, - song.artist, - song.title, - song.album.as_deref().unwrap_or("Unknown Album") - ); - } - tracing::info!(""); - - // ═══════════════════════════════════════════════════════════════════════════ - // Pipeline 1: Téléchargement et cache - // ═══════════════════════════════════════════════════════════════════════════ - - tracing::info!("Creating download pipeline..."); - - // Créer la source Radio Paradise - let mut download_source = RadioParadiseStreamSource::new(client); - download_source.push_block_id(block.event); - tracing::debug!( - "RadioParadiseStreamSource created with block {}", - block.event - ); - - // Créer le sink de cache FLAC - let mut cache_sink = FlacCacheSink::new(audio_cache.clone(), cover_cache.clone()); - cache_sink.register_playlist(writer); - tracing::debug!("FlacCacheSink created and registered with playlist"); - - // Connecter source → sink - download_source.register(Box::new(cache_sink)); - tracing::info!("Download pipeline connected: RadioParadiseStreamSource → FlacCacheSink"); - - // ═══════════════════════════════════════════════════════════════════════════ - // Pipeline 2: Lecture depuis la playlist - // ═══════════════════════════════════════════════════════════════════════════ - - tracing::info!("Creating playback pipeline..."); - - // Créer la source playlist - let mut playlist_source = PlaylistSource::new(reader, audio_cache.clone()); - tracing::debug!("PlaylistSource created"); - - // Créer le timer node pour réguler le débit (empêche EOF prématurés) - // Tolère 3 secondes d'avance max pour permettre le buffering - let mut timer = TimerNode::new(3.0); - tracing::debug!("TimerNode created (max_lead_time=3.0s)"); - - // Créer le sink audio - let audio_sink = if use_null_audio { - AudioSink::with_null_output() - } else { - AudioSink::new() - }; - tracing::debug!("AudioSink created"); - - // Connecter timer → audio (AVANT de mettre timer dans une Box) - timer.register(Box::new(audio_sink)); - - // Connecter playlist → timer - playlist_source.register(Box::new(timer)); - tracing::info!("Playback pipeline connected: PlaylistSource → TimerNode → AudioSink"); - - // ═══════════════════════════════════════════════════════════════════════════ - // Lancer les deux pipelines en parallèle - // ═══════════════════════════════════════════════════════════════════════════ - - tracing::info!(""); - tracing::info!("========================================"); - tracing::info!("Starting both pipelines..."); - tracing::info!("Pipeline 1: Downloading and caching"); - tracing::info!("Pipeline 2: Playing from playlist"); - tracing::info!("========================================"); - tracing::info!(""); - - let stop_token = CancellationToken::new(); - let stop_token_download = stop_token.clone(); - let stop_token_playback = stop_token.clone(); - - // Gérer Ctrl+C - let stop_token_ctrl_c = stop_token.clone(); - tokio::spawn(async move { - tokio::signal::ctrl_c().await.ok(); - tracing::warn!("Received Ctrl+C, stopping..."); - stop_token_ctrl_c.cancel(); - }); - - let start = std::time::Instant::now(); - - // Lancer les deux pipelines en parallèle - let download_handle = tokio::spawn(async move { - tracing::info!("[DOWNLOAD] Pipeline starting..."); - let result = Box::new(download_source).run(stop_token_download).await; - match &result { - Ok(()) => tracing::info!("[DOWNLOAD] Pipeline completed successfully"), - Err(e) => tracing::error!("[DOWNLOAD] Pipeline error: {}", e), - } - result - }); - - let playback_handle = tokio::spawn(async move { - // Pas de sleep - le cache progressif permet de démarrer immédiatement - // dès que le prebuffer (512 KB) est atteint - tracing::info!("[PLAYBACK] Pipeline starting (will wait for prebuffer)..."); - let result = Box::new(playlist_source).run(stop_token_playback).await; - match &result { - Ok(()) => tracing::info!("[PLAYBACK] Pipeline completed successfully"), - Err(e) => tracing::error!("[PLAYBACK] Pipeline error: {}", e), - } - result - }); - - // Attendre les deux pipelines - let (download_result, playback_result) = tokio::join!(download_handle, playback_handle); - - let elapsed = start.elapsed(); - - // Vérifier les résultats - match (download_result, playback_result) { - (Ok(Ok(())), Ok(Ok(()))) => { - tracing::info!(""); - tracing::info!("========================================"); - tracing::info!("✓ Both pipelines completed successfully"); - tracing::info!(" Total time: {:.2}s", elapsed.as_secs_f64()); - tracing::info!("========================================"); - } - (download_res, playback_res) => { - tracing::error!(""); - tracing::error!("========================================"); - if let Err(e) = download_res { - tracing::error!("✗ Download pipeline error: {:?}", e); - } else if let Ok(Err(e)) = download_res { - tracing::error!("✗ Download pipeline error: {}", e); - } - if let Err(e) = playback_res { - tracing::error!("✗ Playback pipeline error: {:?}", e); - } else if let Ok(Err(e)) = playback_res { - tracing::error!("✗ Playback pipeline error: {}", e); - } - tracing::error!("========================================"); - return Err("Pipeline error".into()); - } - } - - Ok(()) -} --------End of pmoparadise/examples/play_and_cache.rs --------- - ------------- pmoparadise/examples/serve_channels.rs ---------- -//! Minimal HTTP server exposing all four Radio Paradise channels. -//! -//! Routes: -//! - `/radioparadise/stream//flac` -//! - `/radioparadise/stream//ogg` -//! - `/radioparadise/stream//icy` -//! - `/radioparadise/stream//historic//flac` -//! - `/radioparadise/stream//historic//ogg` -//! - `/radioparadise/metadata/` - -use std::{fs, sync::Arc}; - -use axum::{ - body::Body, - extract::{Path, State}, - http::{ - header::{ACCEPT_RANGES, CACHE_CONTROL, CONNECTION, CONTENT_TYPE}, - StatusCode, - }, - response::{IntoResponse, Response}, - routing::get, - Json, Router, -}; -use pmoaudiocache::{ - new_cache_with_consolidation as new_audio_cache, - register_audio_cache as register_global_audio_cache, -}; -use pmocovers::{new_cache_with_consolidation as new_cover_cache, register_cover_cache}; -use pmoparadise::{channels::ALL_CHANNELS, ParadiseChannelManager, ParadiseHistoryBuilder}; -use pmoplaylist::register_audio_cache as register_playlist_audio_cache; -use pmoserver::{init_logging, ServerBuilder}; -use tokio_util::io::ReaderStream; -use tracing::{error, info}; - -#[derive(Clone)] -struct AppState { - manager: Arc, -} - -#[tokio::main] -async fn main() -> anyhow::Result<()> { - let _ = init_logging(); - - // Préparer les caches partagés - let cover_cache_dir = "./cache/rp_covers"; - let audio_cache_dir = "./cache/rp_audio"; - fs::create_dir_all(cover_cache_dir)?; - fs::create_dir_all(audio_cache_dir)?; - - let cover_cache = new_cover_cache(cover_cache_dir, 500).await?; - let audio_cache = new_audio_cache(audio_cache_dir, 1000).await?; - register_global_audio_cache(audio_cache.clone()); - register_playlist_audio_cache(audio_cache.clone()); - register_cover_cache(cover_cache.clone()); - let _playlist_manager = pmoplaylist::PlaylistManager(); - - let history_builder = ParadiseHistoryBuilder { - audio_cache: audio_cache.clone(), - cover_cache: cover_cache.clone(), - playlist_prefix: "radio-paradise-history".into(), - playlist_title_prefix: Some("Radio Paradise History".into()), - max_history_tracks: Some(500), - collection_prefix: Some("radioparadise".into()), - replay_max_lead_seconds: 1.0, - }; - - info!("Initializing Radio Paradise channels..."); - let server_base_url = format!("http://localhost:{}", 8080); - let manager = Arc::new( - ParadiseChannelManager::with_defaults_with_cover_cache( - Some(cover_cache), - Some(history_builder), - Some(server_base_url), - ) - .await?, - ); - let app_state = Arc::new(AppState { - manager: manager.clone(), - }); - - let mut server = ServerBuilder::new("RadioParadiseChannels", "http://localhost", 8080).build(); - - for descriptor in ALL_CHANNELS.iter() { - let slug = descriptor.slug; - let flac_path = format!("/radioparadise/stream/{}/flac", slug); - let ogg_path = format!("/radioparadise/stream/{}/ogg", slug); - let icy_path = format!("/radioparadise/stream/{}/icy", slug); - let history_path = format!("/radioparadise/stream/{}/historic", slug); - let meta_path = format!("/radioparadise/metadata/{}", slug); - let channel_id = descriptor.id; - - server - .add_handler_with_state( - &flac_path, - move |State(state): State>| { - let manager = state.manager.clone(); - async move { stream_flac(manager, channel_id).await } - }, - app_state.clone(), - ) - .await; - - server - .add_handler_with_state( - &ogg_path, - move |State(state): State>| { - let manager = state.manager.clone(); - async move { stream_ogg(manager, channel_id).await } - }, - app_state.clone(), - ) - .await; - - server - .add_handler_with_state( - &icy_path, - move |State(state): State>| { - let manager = state.manager.clone(); - async move { stream_icy(manager, channel_id).await } - }, - app_state.clone(), - ) - .await; - - let history_router = Router::new() - .route( - "/{client_id}/flac", - get({ - let manager = manager.clone(); - move |Path(client_id): Path| { - let manager = manager.clone(); - async move { stream_history_flac(manager, channel_id, client_id).await } - } - }), - ) - .route( - "/{client_id}/ogg", - get({ - let manager = manager.clone(); - move |Path(client_id): Path| { - let manager = manager.clone(); - async move { stream_history_ogg(manager, channel_id, client_id).await } - } - }), - ); - - server.add_router(&history_path, history_router).await; - - server - .add_handler_with_state( - &meta_path, - move |State(state): State>| { - let manager = state.manager.clone(); - async move { get_metadata(manager, channel_id).await } - }, - app_state.clone(), - ) - .await; - } - - info!("========================================"); - info!("Radio Paradise streaming server running on http://localhost:8080"); - info!("Available channels:"); - for descriptor in ALL_CHANNELS.iter() { - info!( - " {}: /radioparadise/stream/{}/flac (also /ogg, /icy, metadata, /historic//(flac|ogg))", - descriptor.display_name, descriptor.slug - ); - } - info!("Press Ctrl+C to stop."); - info!("========================================"); - - server.start().await; - server.wait().await; - Ok(()) -} - -async fn stream_flac( - manager: Arc, - channel_id: u8, -) -> Result { - let channel = manager.get(channel_id).ok_or(StatusCode::NOT_FOUND)?; - let stream = channel.subscribe_flac(); - Ok(Response::builder() - .status(StatusCode::OK) - .header(CONTENT_TYPE, "audio/flac") - .header(CACHE_CONTROL, "no-store, no-transform") - .header(CONNECTION, "keep-alive") - .header(ACCEPT_RANGES, "none") - .body(Body::from_stream(ReaderStream::new(stream))) - .unwrap()) -} - -async fn stream_ogg( - manager: Arc, - channel_id: u8, -) -> Result { - let channel = manager.get(channel_id).ok_or(StatusCode::NOT_FOUND)?; - let stream = channel.subscribe_ogg(); - Ok(Response::builder() - .status(StatusCode::OK) - .header(CONTENT_TYPE, "application/ogg") - .header(CACHE_CONTROL, "no-store, no-transform") - .header(CONNECTION, "keep-alive") - .header(ACCEPT_RANGES, "none") - .body(Body::from_stream(ReaderStream::new(stream))) - .unwrap()) -} - -async fn stream_icy( - manager: Arc, - channel_id: u8, -) -> Result { - let channel = manager.get(channel_id).ok_or(StatusCode::NOT_FOUND)?; - let stream = channel.subscribe_icy(); - Ok(Response::builder() - .status(StatusCode::OK) - .header(CONTENT_TYPE, "audio/flac") - .header(CACHE_CONTROL, "no-store, no-transform") - .header(CONNECTION, "keep-alive") - .header(ACCEPT_RANGES, "none") - .header("icy-metaint", "16000") - .body(Body::from_stream(ReaderStream::new(stream))) - .unwrap()) -} - -async fn get_metadata( - manager: Arc, - channel_id: u8, -) -> Result { - let channel = manager.get(channel_id).ok_or(StatusCode::NOT_FOUND)?; - let metadata = channel.metadata().await; - Ok(Json(metadata)) -} - -async fn stream_history_flac( - manager: Arc, - channel_id: u8, - client_id: String, -) -> Result { - let channel = manager.get(channel_id).ok_or(StatusCode::NOT_FOUND)?; - let stream = channel.stream_history_flac(&client_id).await.map_err(|e| { - error!( - "Failed to start historical FLAC stream for channel {} (client_id={}): {}", - channel_id, client_id, e - ); - StatusCode::INTERNAL_SERVER_ERROR - })?; - Ok(Response::builder() - .status(StatusCode::OK) - .header(CONTENT_TYPE, "audio/flac") - .header(CACHE_CONTROL, "no-store, no-transform") - .header(CONNECTION, "keep-alive") - .header(ACCEPT_RANGES, "none") - .body(Body::from_stream(ReaderStream::new(stream))) - .unwrap()) -} - -async fn stream_history_ogg( - manager: Arc, - channel_id: u8, - client_id: String, -) -> Result { - let channel = manager.get(channel_id).ok_or(StatusCode::NOT_FOUND)?; - let stream = channel.stream_history_ogg(&client_id).await.map_err(|e| { - error!( - "Failed to start historical OGG stream for channel {} (client_id={}): {}", - channel_id, client_id, e - ); - StatusCode::INTERNAL_SERVER_ERROR - })?; - Ok(Response::builder() - .status(StatusCode::OK) - .header(CONTENT_TYPE, "application/ogg") - .header(CACHE_CONTROL, "no-store, no-transform") - .header(CONNECTION, "keep-alive") - .header(ACCEPT_RANGES, "none") - .body(Body::from_stream(ReaderStream::new(stream))) - .unwrap()) -} --------End of pmoparadise/examples/serve_channels.rs --------- - ------------- pmoparadise/examples/single_channel_server.rs ---------- -//! Simple web server that exposes one Radio Paradise channel over HTTP. -//! -//! Usage: -//! ```bash -//! cargo run --example single_channel_server --features full -- main -//! ``` -//! Valid arguments are either the slug (`main`, `mellow`, `rock`, `eclectic`) or -//! the numeric channel id (`0`..`3`). When no argument is provided, the example -//! defaults to the “main” mix. - -use axum::{ - body::Body, - extract::{Path, Request, State}, - http::StatusCode, - response::{IntoResponse, Response}, - routing::get, - Json, Router, -}; -use pmoaudio_ext::StreamingSinkOptions; -use pmoaudiocache::{ - new_cache_with_consolidation as new_audio_cache, - register_audio_cache as register_global_audio_cache, -}; -use pmocovers::{ - new_cache_with_consolidation as new_cover_cache, register_cover_cache, Cache as CoverCache, -}; -use pmoparadise::{ - channels::{ChannelDescriptor, ALL_CHANNELS}, - ParadiseHistoryBuilder, ParadiseStreamChannel, ParadiseStreamChannelConfig, -}; -use pmoplaylist::register_audio_cache as register_playlist_audio_cache; -use std::{fs, net::SocketAddr, sync::Arc}; -use tokio::net::TcpListener; -use tokio_util::io::ReaderStream; -use tracing::info; - -#[derive(Clone)] -struct AppState { - channel: Arc, - descriptor: ChannelDescriptor, - cover_cache: Arc, -} - -#[tokio::main] -async fn main() -> anyhow::Result<()> { - let env_filter = tracing_subscriber::EnvFilter::try_from_default_env() - .unwrap_or_else(|_| tracing_subscriber::EnvFilter::new("info")); - - tracing_subscriber::fmt().with_env_filter(env_filter).init(); - - let descriptor = pick_descriptor(std::env::args().nth(1))?; - info!( - "Selected Radio Paradise channel: {} ({})", - descriptor.display_name, descriptor.slug - ); - - // Prepare caches under ./cache/single-channel - let cache_root = "./cache/single-channel"; - let audio_cache_dir = format!("{}/audio", cache_root); - let cover_cache_dir = format!("{}/covers", cache_root); - fs::create_dir_all(&audio_cache_dir)?; - fs::create_dir_all(&cover_cache_dir)?; - - let audio_cache = new_audio_cache(&audio_cache_dir, 1000).await?; - let cover_cache = new_cover_cache(&cover_cache_dir, 200).await?; - register_global_audio_cache(audio_cache.clone()); - register_playlist_audio_cache(audio_cache.clone()); - register_cover_cache(cover_cache.clone()); - - let mut history_builder = ParadiseHistoryBuilder::new(audio_cache.clone(), cover_cache.clone()); - history_builder.playlist_prefix = format!("single-channel-history-{}", descriptor.slug); - history_builder.collection_prefix = Some(format!("single-channel-{}", descriptor.slug)); - let history_opts = history_builder.build_for_channel(&descriptor).await?; - - let mut channel_config = ParadiseStreamChannelConfig::default(); - // Base URL for cover images in stream metadata - let server_base_url = "http://localhost:8080".to_string(); - - // Configuration commune pour FLAC et OGG - let common_options = StreamingSinkOptions::flac_defaults() - .with_default_artist(Some("Radio Paradise".to_string())) - .with_default_title(descriptor.display_name.to_string()) - .with_server_base_url(Some(server_base_url.clone())); - - channel_config.flac_options = common_options.clone(); - channel_config.ogg_options = StreamingSinkOptions::ogg_defaults() - .with_default_artist(Some("Radio Paradise".to_string())) - .with_default_title(descriptor.display_name.to_string()) - .with_server_base_url(Some(server_base_url)); - - let channel = Arc::new( - ParadiseStreamChannel::new( - descriptor, - channel_config, - Some(cover_cache.clone()), - Some(history_opts), - ) - .await?, - ); - - let state = AppState { - channel, - descriptor, - cover_cache, - }; - - let app = Router::new() - .route("/stream/flac", get(stream_flac)) - .route("/stream/ogg", get(stream_ogg)) - .route("/metadata", get(get_metadata)) - .route("/covers/image/{pk}", get(get_cover)) - .with_state(state); - - let addr: SocketAddr = ([0, 0, 0, 0], 8080).into(); - info!("========================================"); - info!("HTTP server listening on http://{addr}"); - info!("Available endpoints:"); - info!(" - /stream/flac : FLAC audio stream"); - info!(" - /stream/ogg : OGG-FLAC audio stream"); - info!(" - /metadata : Current track metadata (JSON)"); - info!(" - /covers/image/{{pk}} : Album cover images (WebP)"); - info!("========================================"); - info!("Connect with a FLAC player: ffplay http://localhost:8080/stream/flac"); - info!("Connect with an OGG-FLAC player: ffplay http://localhost:8080/stream/ogg"); - - let listener = TcpListener::bind(addr).await?; - axum::serve(listener, app.into_make_service()).await?; - - Ok(()) -} - -async fn stream_flac(State(state): State) -> Result { - let stream = state.channel.subscribe_flac(); - let body = Body::from_stream(ReaderStream::new(stream)); - Response::builder() - .status(StatusCode::OK) - .header("Content-Type", "audio/flac") - .header( - "X-PMO-Channel", - format!( - "{} ({})", - state.descriptor.display_name, state.descriptor.slug - ), - ) - .body(body) - .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR) -} - -async fn stream_ogg(State(state): State) -> Result { - let stream = state.channel.subscribe_ogg(); - let body = Body::from_stream(ReaderStream::new(stream)); - Response::builder() - .status(StatusCode::OK) - .header("Content-Type", "audio/ogg") - .header( - "X-PMO-Channel", - format!( - "{} ({})", - state.descriptor.display_name, state.descriptor.slug - ), - ) - .body(body) - .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR) -} - -async fn get_metadata( - State(state): State, - request: Request, -) -> Result { - let mut metadata = state.channel.metadata().await; - - // Si cover_pk est disponible, construire l'URL complète depuis les headers - // Format: /covers/image/{pk} (correspond à la structure du cache pmocovers) - if let Some(ref pk) = metadata.cover_pk { - let base_url = extract_base_url(&request); - metadata.cover_url = Some(format!("{}/covers/image/{}", base_url, pk)); - } - - Ok(Json(metadata)) -} - -/// Extrait l'URL de base depuis les headers HTTP de la requête -/// Supporte les proxies avec X-Forwarded-Host et X-Forwarded-Proto -fn extract_base_url(request: &Request) -> String { - let headers = request.headers(); - - // Déterminer le schéma (http ou https) - let scheme = headers - .get("x-forwarded-proto") - .and_then(|h| h.to_str().ok()) - .unwrap_or("http"); - - // Déterminer le host - let host = headers - .get("x-forwarded-host") - .or_else(|| headers.get("host")) - .and_then(|h| h.to_str().ok()) - .unwrap_or("localhost:8080"); - - format!("{}://{}", scheme, host) -} - -async fn get_cover( - State(state): State, - Path(pk): Path, -) -> Result { - // Récupérer le chemin de la cover depuis le cache - // Le cache retourne un PathBuf pointant vers le fichier .webp - let cover_path = state.cover_cache.get(&pk).await.map_err(|e| { - tracing::error!("Failed to get cover path for {}: {}", pk, e); - StatusCode::NOT_FOUND - })?; - - // Lire le fichier - let cover_data = tokio::fs::read(&cover_path).await.map_err(|e| { - tracing::error!("Failed to read cover file {:?}: {}", cover_path, e); - StatusCode::NOT_FOUND - })?; - - Response::builder() - .status(StatusCode::OK) - .header("Content-Type", "image/webp") - .header("Cache-Control", "public, max-age=86400") - .body(Body::from(cover_data)) - .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR) -} - -fn pick_descriptor(arg: Option) -> anyhow::Result { - if let Some(token) = arg { - if let Some(desc) = ALL_CHANNELS.iter().find(|c| c.slug == token) { - return Ok(*desc); - } - if let Ok(id) = token.parse::() { - if let Some(desc) = ALL_CHANNELS.iter().find(|c| c.id == id) { - return Ok(*desc); - } - } - anyhow::bail!("Unknown channel identifier: {token}"); - } - Ok(ALL_CHANNELS[0]) -} --------End of pmoparadise/examples/single_channel_server.rs --------- - ------------- pmoparadise/examples/stream_block.rs ---------- -//! Streams a Radio Paradise block via HTTP using pmoserver -//! -//! This example demonstrates streaming a single Radio Paradise block -//! using the StreamingFlacSink over HTTP via pmoserver. Perfect for -//! testing with VLC or other media players that support HTTP streaming. -//! -//! The example streams ONE block then terminates cleanly using END_OF_BLOCKS_SIGNAL. -//! For continuous streaming, push multiple block_ids without the END signal. -//! -//! Architecture: -//! ```text -//! RadioParadiseStreamSource → TimerBufferNode → StreamingFlacSink -//! ↓ -//! StreamHandle -//! ↓ -//! pmoserver (Axum) -//! ↓ -//! VLC / Media Player Client -//! ``` -//! -//! Usage: -//! cargo run --example stream_block --features full -- -//! -//! Example: -//! cargo run --example stream_block --features full -- 0 # Main Mix -//! -//! Then open in VLC: -//! vlc http://localhost:8080/test/stream (pure FLAC) -//! vlc http://localhost:8080/test/stream-ogg (OGG-FLAC streaming container) -//! vlc http://localhost:8080/test/stream-icy (FLAC + ICY metadata) -//! -//! To check current metadata: -//! curl http://localhost:8080/test/metadata - -use axum::{ - body::Body, - extract::State, - http::{HeaderMap, StatusCode}, - response::{IntoResponse, Response}, -}; -use pmoaudio::{AudioPipelineNode, TimerBufferNode}; -use pmoaudio_ext::{StreamingFlacSink, StreamingOggFlacSink}; -use pmoflac::EncoderOptions; -use pmoparadise::{RadioParadiseClient, RadioParadiseStreamSource, END_OF_BLOCKS_SIGNAL}; -use pmoserver::{init_logging, ServerBuilder}; -use std::env; -use std::sync::Arc; -use tokio_util::io::ReaderStream; -use tokio_util::sync::CancellationToken; - -/// Shared application state -struct AppState { - stream_handle: pmoaudio_ext::StreamHandle, - ogg_handle: pmoaudio_ext::OggFlacStreamHandle, -} - -/// Main HTTP handler for streaming (pure FLAC, no ICY metadata) -async fn stream_handler( - State(state): State>, - _headers: HeaderMap, -) -> Result { - tracing::info!("New client connected (pure FLAC mode)"); - - // Pure FLAC stream without ICY metadata - let flac_stream = state.stream_handle.subscribe_flac(); - - Ok(Response::builder() - .status(StatusCode::OK) - .header("Content-Type", "audio/flac") - .header("Cache-Control", "no-cache, no-store") - .body(Body::from_stream(ReaderStream::new(flac_stream))) - .unwrap()) -} - -/// ICY streaming handler (FLAC with embedded metadata) -async fn stream_icy_handler( - State(state): State>, - _headers: HeaderMap, -) -> Result { - tracing::info!("New client connected (ICY mode)"); - - // FLAC stream with ICY metadata - let icy_stream = state.stream_handle.subscribe_icy(); - - Ok(Response::builder() - .status(StatusCode::OK) - .header("Content-Type", "audio/flac") - .header("icy-metaint", "16000") - .header("icy-name", "Radio Paradise Stream Test") - .header("icy-genre", "Eclectic") - .header("icy-pub", "1") - .header("Cache-Control", "no-cache, no-store") - .body(Body::from_stream(ReaderStream::new(icy_stream))) - .unwrap()) -} - -/// OGG-FLAC streaming handler -async fn stream_ogg_handler( - State(state): State>, - _headers: HeaderMap, -) -> Result { - tracing::info!("New client connected (OGG-FLAC mode)"); - - // OGG-FLAC stream - let ogg_stream = state.ogg_handle.subscribe(); - - Ok(Response::builder() - .status(StatusCode::OK) - .header("Content-Type", "audio/ogg") - .header("Cache-Control", "no-cache, no-store") - .body(Body::from_stream(ReaderStream::new(ogg_stream))) - .unwrap()) -} - -/// Metadata endpoint (JSON) -async fn metadata_handler(State(state): State>) -> impl IntoResponse { - let metadata = state.stream_handle.get_metadata().await; - axum::Json(metadata) -} - -/// Health check endpoint -async fn health_handler() -> &'static str { - "OK" -} - -#[tokio::main] -async fn main() -> Result<(), Box> { - // Initialize logging via pmoserver - let _log_state = init_logging(); - - tracing::info!("=== Radio Paradise HTTP Streaming Test ==="); - - // Parse arguments - let args: Vec = env::args().collect(); - if args.len() < 2 { - eprintln!("Usage: {} ", args[0]); - eprintln!(); - eprintln!("Streams a Radio Paradise block via HTTP for testing."); - eprintln!(); - eprintln!("Channel IDs:"); - eprintln!(" 0 - Main Mix (eclectic, diverse mix)"); - eprintln!(" 1 - Mellow Mix (smooth, chilled music)"); - eprintln!(" 2 - Rock Mix (classic & modern rock)"); - eprintln!(" 3 - World/Etc Mix (global sounds)"); - eprintln!(); - eprintln!("After starting, open in VLC:"); - eprintln!(" vlc http://localhost:8080/test/stream (pure FLAC)"); - eprintln!(" vlc http://localhost:8080/test/stream-ogg (OGG-FLAC container)"); - eprintln!(" vlc http://localhost:8080/test/stream-icy (FLAC + ICY metadata)"); - std::process::exit(1); - } - - let channel_id: u8 = match args[1].parse() { - Ok(id) if id <= 3 => id, - _ => { - eprintln!("Error: channel_id must be a number between 0 and 3"); - std::process::exit(1); - } - }; - - tracing::info!("Channel ID: {}", channel_id); - - // ═══════════════════════════════════════════════════════════════════════════ - // Fetch block metadata - // ═══════════════════════════════════════════════════════════════════════════ - - tracing::info!("Fetching current block metadata..."); - let client = RadioParadiseClient::builder() - .channel(channel_id) - .build() - .await?; - - let block = client.get_block(None).await?; - - tracing::info!("Block Information:"); - tracing::info!(" Event ID: {}", block.event); - tracing::info!(" Songs: {}", block.song_count()); - tracing::info!(" Duration: {:.1} minutes", block.length as f64 / 60000.0); - tracing::info!(""); - - tracing::info!("Tracklist:"); - for (index, song) in block.songs_ordered() { - tracing::info!( - " {:2}. {} - {} ({})", - index + 1, - song.artist, - song.title, - song.album.as_deref().unwrap_or("Unknown Album") - ); - } - tracing::info!(""); - - // ═══════════════════════════════════════════════════════════════════════════ - // Create streaming pipelines (FLAC and OGG-FLAC) - // ═══════════════════════════════════════════════════════════════════════════ - - tracing::info!("Creating streaming pipelines..."); - - // Encoder options (shared) - let encoder_options = EncoderOptions { - compression_level: 5, - verify: false, - ..Default::default() - }; - - // ───────────────────────────────────────────────────────────────────────── - // Unique pipeline feeding both FLAC and OGG sinks - // ───────────────────────────────────────────────────────────────────────── - - let mut source = RadioParadiseStreamSource::new(client); - source.push_block_id(block.event); - source.push_block_id(END_OF_BLOCKS_SIGNAL); // Signal: no more blocks after this one - tracing::debug!( - "RadioParadiseStreamSource created with block {} + END signal", - block.event - ); - - // Use SMALL channel size to make backpressure plus fan-out manageable. - let buffer_sec = 0.1; - let max_lead_time = buffer_sec; - let channel_size = 512; - tracing::debug!( - "Using channel size: {} chunks ({:.1}s buffer à 50ms/chunk)", - channel_size, - channel_size as f64 * 0.05 - ); - - let mut timer_node = TimerBufferNode::with_channel_size(buffer_sec, channel_size); - tracing::debug!( - "TimerBufferNode created with {:.1}s buffer, {} chunk queue", - buffer_sec, - channel_size - ); - - // Streaming sinks - let (streaming_sink, stream_handle) = - StreamingFlacSink::with_max_broadcast_lead(encoder_options.clone(), 16, max_lead_time); - tracing::debug!("StreamingFlacSink created"); - - let (ogg_sink, ogg_handle) = - StreamingOggFlacSink::with_max_broadcast_lead(encoder_options, 16, max_lead_time); - tracing::debug!("StreamingOggFlacSink created"); - - // timer_node.register(Box::new(streaming_sink)); - // timer_node.register(Box::new(ogg_sink)); - // source.register(Box::new(timer_node)); - - source.register(Box::new(streaming_sink)); - source.register(Box::new(ogg_sink)); - - tracing::info!("Pipeline connected: StreamSource → TimerBufferNode → {{FLAC, OGG}} sinks"); - - // ═══════════════════════════════════════════════════════════════════════════ - // Setup pmoserver with streaming routes - // ═══════════════════════════════════════════════════════════════════════════ - - tracing::info!("Setting up pmoserver..."); - - let mut server = - ServerBuilder::new("RadioParadiseStreamTest", "http://localhost", 8080).build(); - - let app_state = Arc::new(AppState { - stream_handle, - ogg_handle, - }); - - // Add streaming routes - let base = "/radioparadise/test"; - server - .add_handler_with_state( - &format!("{}/stream", base), - stream_handler, - app_state.clone(), - ) - .await; - server - .add_handler_with_state( - &format!("{}/stream-icy", base), - stream_icy_handler, - app_state.clone(), - ) - .await; - server - .add_handler_with_state( - &format!("{}/stream-ogg", base), - stream_ogg_handler, - app_state.clone(), - ) - .await; - - // Add metadata route - server - .add_handler_with_state( - &format!("{}/metadata", base), - metadata_handler, - app_state.clone(), - ) - .await; - - // Add health check - server.add_handler("/test/health", health_handler).await; - - tracing::info!(""); - tracing::info!("========================================"); - tracing::info!("Ready to stream!"); - tracing::info!(""); - tracing::info!("Pure FLAC stream (for VLC, standard players):"); - tracing::info!(" vlc http://localhost:8080{}/stream", base); - tracing::info!(""); - tracing::info!("OGG-FLAC stream (streaming container with metadata support):"); - tracing::info!(" vlc http://localhost:8080{}/stream-ogg", base); - tracing::info!(""); - tracing::info!("FLAC + ICY metadata stream (for ICY-aware clients):"); - tracing::info!(" http://localhost:8080{}/stream-icy", base); - tracing::info!(""); - tracing::info!("Metadata endpoint (JSON):"); - tracing::info!(" curl http://localhost:8080{}/metadata", base); - tracing::info!("========================================"); - tracing::info!(""); - - // ═══════════════════════════════════════════════════════════════════════════ - // Start pipelines and server - // ═══════════════════════════════════════════════════════════════════════════ - - let stop_token = CancellationToken::new(); - let pipeline_stop = stop_token.clone(); - - // Start shared pipeline in background - let pipeline_handle = tokio::spawn(async move { - tracing::info!("[PIPELINE] Starting..."); - let result = Box::new(source).run(pipeline_stop).await; - match &result { - Ok(()) => tracing::info!("[PIPELINE] Completed successfully"), - Err(e) => tracing::error!("[PIPELINE] Error: {}", e), - } - result - }); - - // Start pmoserver (blocks until Ctrl+C) - tracing::info!("[SERVER] Starting pmoserver..."); - server.start().await; - server.wait().await; - - // Server stopped, cancel pipelines - tracing::info!("Server stopped, canceling pipelines..."); - stop_token.cancel(); - - // Wait for pipeline to finish - match pipeline_handle.await { - Ok(Ok(())) => tracing::info!("Pipeline completed successfully"), - Ok(Err(e)) => tracing::error!("Pipeline error: {}", e), - Err(e) => tracing::error!("Pipeline task error: {}", e), - } - - tracing::info!("Shutdown complete"); - Ok(()) -} --------End of pmoparadise/examples/stream_block.rs --------- - diff --git a/pmoparadise_012.txt b/pmoparadise_012.txt deleted file mode 100644 index 6c10f232..00000000 --- a/pmoparadise_012.txt +++ /dev/null @@ -1,7970 +0,0 @@ ------------- pmoparadise/src/channels.rs ---------- -//! Radio Paradise channel definitions -//! -//! This module defines the available Radio Paradise channels and their metadata. - -use std::str::FromStr; - -/// Logical identifier for a Radio Paradise channel. -#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] -pub enum ParadiseChannelKind { - Main, - Mellow, - Rock, - Eclectic, -} - -impl ParadiseChannelKind { - pub const fn id(self) -> u8 { - match self { - Self::Main => 0, - Self::Mellow => 1, - Self::Rock => 2, - Self::Eclectic => 3, - } - } - - pub const fn slug(self) -> &'static str { - match self { - Self::Main => "main", - Self::Mellow => "mellow", - Self::Rock => "rock", - Self::Eclectic => "eclectic", - } - } - - pub const fn display_name(self) -> &'static str { - match self { - Self::Main => "Main Mix", - Self::Mellow => "Mellow Mix", - Self::Rock => "Rock Mix", - Self::Eclectic => "Eclectic Mix", - } - } - - pub const fn description(self) -> &'static str { - match self { - Self::Main => "Eclectic mix of rock, world, electronica, and more", - Self::Mellow => "Mellower, less aggressive music", - Self::Rock => "Heavier, more guitar-driven music", - Self::Eclectic => "Curated worldwide selection", - } - } -} - -impl FromStr for ParadiseChannelKind { - type Err = anyhow::Error; - - fn from_str(s: &str) -> std::result::Result { - match s.to_ascii_lowercase().as_str() { - "main" | "0" => Ok(Self::Main), - "mellow" | "1" => Ok(Self::Mellow), - "rock" | "2" => Ok(Self::Rock), - "eclectic" | "3" => Ok(Self::Eclectic), - other => Err(anyhow::anyhow!("Unknown Radio Paradise channel: {}", other)), - } - } -} - -/// Metadata descriptor for a channel. -#[derive(Debug, Clone, Copy)] -pub struct ChannelDescriptor { - pub kind: ParadiseChannelKind, - pub id: u8, - pub slug: &'static str, - pub display_name: &'static str, - pub description: &'static str, -} - -impl ChannelDescriptor { - pub const fn new(kind: ParadiseChannelKind) -> Self { - Self { - id: kind.id(), - slug: kind.slug(), - display_name: kind.display_name(), - description: kind.description(), - kind, - } - } -} - -/// All available Radio Paradise channels -pub const ALL_CHANNELS: [ChannelDescriptor; 4] = [ - ChannelDescriptor::new(ParadiseChannelKind::Main), - ChannelDescriptor::new(ParadiseChannelKind::Mellow), - ChannelDescriptor::new(ParadiseChannelKind::Rock), - ChannelDescriptor::new(ParadiseChannelKind::Eclectic), -]; - -/// Returns the maximum valid channel ID -pub const fn max_channel_id() -> u8 { - (ALL_CHANNELS.len() - 1) as u8 -} - -/// Default maximum number of tracks to keep in history -/// -/// This is used as the default if not configured via pmoconfig. -/// Value: 100 tracks - represents ~5-8 hours of playback history -pub const HISTORY_DEFAULT_MAX_TRACKS: usize = 100; - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_channel_ids() { - assert_eq!(ParadiseChannelKind::Main.id(), 0); - assert_eq!(ParadiseChannelKind::Mellow.id(), 1); - assert_eq!(ParadiseChannelKind::Rock.id(), 2); - assert_eq!(ParadiseChannelKind::Eclectic.id(), 3); - } - - #[test] - fn test_max_channel_id() { - assert_eq!(max_channel_id(), 3); - } - - #[test] - fn test_all_channels_length() { - assert_eq!(ALL_CHANNELS.len(), 4); - } - - #[test] - fn test_channel_from_str() { - assert!(matches!( - "main".parse::(), - Ok(ParadiseChannelKind::Main) - )); - assert!(matches!( - "0".parse::(), - Ok(ParadiseChannelKind::Main) - )); - assert!("invalid".parse::().is_err()); - } -} --------End of pmoparadise/src/channels.rs --------- - ------------- pmoparadise/src/client.rs ---------- -//! HTTP client for Radio Paradise API - -use crate::error::{Error, Result}; -use crate::models::{Block, EventId, NowPlaying}; -use reqwest::Client; -use std::time::Duration; -use url::Url; - -/// Default Radio Paradise API base URL -pub const DEFAULT_API_BASE: &str = "https://api.radioparadise.com/api"; - -/// Default block base URL (channel is appended) -pub const DEFAULT_BLOCK_BASE: &str = "https://apps.radioparadise.com/blocks/chan"; - -/// Default image base URL -pub const DEFAULT_IMAGE_BASE: &str = "https://img.radioparadise.com/"; - -/// Default timeout for metadata HTTP requests -pub const DEFAULT_REQUEST_TIMEOUT_SECS: u64 = 30; - -/// Default timeout for large block downloads/streams -/// IMPORTANT: Radio Paradise blocks can be ~20 minutes long, and with backpressure -/// from the audio pipeline, the HTTP stream must stay open for the entire duration. -/// Setting this to 2 hours to safely handle even the longest blocks. -pub const DEFAULT_BLOCK_TIMEOUT_SECS: u64 = 7200; // 2 hours - -/// Default User-Agent -pub const DEFAULT_USER_AGENT: &str = "pmoparadise/0.1.0"; - -/// Default channel (0 = main mix) -pub const DEFAULT_CHANNEL: u8 = 0; - -/// Radio Paradise HTTP client -/// -/// This client provides access to Radio Paradise's streaming API, -/// including metadata retrieval and block streaming. -/// -/// # Example -/// -/// ```no_run -/// use pmoparadise::RadioParadiseClient; -/// -/// #[tokio::main] -/// async fn main() -> Result<(), Box> { -/// let client = RadioParadiseClient::new().await?; -/// let now_playing = client.now_playing().await?; -/// println!("Now playing: {} - {}", -/// now_playing.current_song.as_ref().unwrap().artist, -/// now_playing.current_song.as_ref().unwrap().title); -/// Ok(()) -/// } -/// ``` -#[derive(Debug, Clone)] -pub struct RadioParadiseClient { - pub(crate) client: Client, - api_base: String, - channel: u8, - pub(crate) request_timeout: Duration, - pub(crate) block_timeout: Duration, - next_block_url: Option, -} - -impl RadioParadiseClient { - /// Create a new client with default settings - /// - /// Uses FLAC quality and channel 0 (main mix) - pub async fn new() -> Result { - Self::builder().build().await - } - - /// Create a builder for configuring the client - pub fn builder() -> ClientBuilder { - ClientBuilder::default() - } - - /// Create a client with a custom reqwest::Client - /// - /// Useful for sharing HTTP connection pools or custom proxy settings - /// - /// Note: Uses default settings (channel 0, default timeouts). - /// For more control, use `ClientBuilder::default().client(client).build()`. - pub fn with_client(client: Client) -> Self { - Self { - client, - api_base: DEFAULT_API_BASE.to_string(), - channel: DEFAULT_CHANNEL, - request_timeout: Duration::from_secs(DEFAULT_REQUEST_TIMEOUT_SECS), - block_timeout: Duration::from_secs(DEFAULT_BLOCK_TIMEOUT_SECS), - next_block_url: None, - } - } - - /// Get the current channel (0 = main mix) - pub fn channel(&self) -> u8 { - self.channel - } - - /// Get the block base URL for this client's channel - pub fn block_base(&self) -> String { - format!("{}/{}", DEFAULT_BLOCK_BASE, self.channel) - } - - /// Clone the client with a different channel while preserving other settings. - pub fn clone_with_channel(&self, channel: u8) -> Self { - let mut cloned = self.clone(); - cloned.channel = channel; - cloned.next_block_url = None; - cloned - } - - /// Get a block by event ID - /// - /// If `event` is None, returns the current block. - /// - /// # Arguments - /// - /// * `event` - Optional event ID to fetch a specific block - /// - /// # Example - /// - /// ```no_run - /// # use pmoparadise::RadioParadiseClient; - /// # #[tokio::main] - /// # async fn main() -> Result<(), Box> { - /// let client = RadioParadiseClient::new().await?; - /// - /// // Get current block - /// let current = client.get_block(None).await?; - /// println!("Current block: {} songs", current.song_count()); - /// - /// // Get next block - /// let next = client.get_block(Some(current.end_event)).await?; - /// println!("Next block: {} songs", next.song_count()); - /// # Ok(()) - /// # } - /// ``` - pub async fn get_block(&self, event: Option) -> Result { - let mut url = Url::parse(&format!("{}/get_block", self.api_base))?; - - url.query_pairs_mut() - .append_pair("bitrate", "4") // FLAC lossless - .append_pair("info", "true") - // RP API expects `chan` rather than `channel` for channel selection. - .append_pair("chan", &self.channel.to_string()); - - if let Some(event_id) = event { - url.query_pairs_mut() - .append_pair("event", &event_id.to_string()); - } - - #[cfg(feature = "logging")] - tracing::debug!("Fetching block: {}", url); - - let response = self - .client - .get(url) - .timeout(self.request_timeout) - .send() - .await?; - - if !response.status().is_success() { - return Err(Error::other(format!( - "API returned error status: {}", - response.status() - ))); - } - - let mut block: Block = response.json().await?; - - // Normalize protocol-relative URLs from API (//img.radioparadise.com/) - if let Some(ref base) = block.image_base { - if base.starts_with("//") { - block.image_base = Some(format!("https:{}", base)); - } - } else { - // Fallback if API doesn't provide image_base (should never happen) - block.image_base = Some(DEFAULT_IMAGE_BASE.to_string()); - } - - #[cfg(feature = "logging")] - tracing::debug!( - "Received block: event={}, songs={}", - block.event, - block.song_count() - ); - - Ok(block) - } - - /// Get the currently playing block and song - /// - /// Returns a `NowPlaying` struct with the current block and - /// an estimate of which song is currently playing (first song). - /// - /// Note: Without real-time synchronization, we assume playback - /// starts from the beginning of the block. - pub async fn now_playing(&self) -> Result { - let block = self.get_block(None).await?; - Ok(NowPlaying::from_block(block)) - } - - /// Prefetch metadata for the next block - /// - /// Stores the next block URL internally for seamless transitions. - /// Call this before the current block finishes playing. - /// - /// # Arguments - /// - /// * `current` - The currently playing block - pub async fn prefetch_next(&mut self, current: &Block) -> Result<()> { - let next_block = self.get_block(Some(current.end_event)).await?; - self.next_block_url = Some(next_block.url.clone()); - - #[cfg(feature = "logging")] - tracing::debug!( - "Prefetched next block: {} -> {}", - current.end_event, - next_block.event - ); - - Ok(()) - } - - /// Get the prefetched next block URL - pub fn next_block_url(&self) -> Option<&str> { - self.next_block_url.as_deref() - } - - /// Clear the prefetched next block URL - pub fn clear_next_block(&mut self) { - self.next_block_url = None; - } - - /// Get the internal HTTP client - pub fn http_client(&self) -> &Client { - &self.client - } -} - -/// Builder for configuring a RadioParadiseClient -#[derive(Debug)] -pub struct ClientBuilder { - client: Option, - api_base: String, - channel: u8, - request_timeout: Duration, - block_timeout: Duration, - user_agent: String, - proxy: Option, -} - -impl Default for ClientBuilder { - fn default() -> Self { - Self { - client: None, - api_base: DEFAULT_API_BASE.to_string(), - channel: DEFAULT_CHANNEL, - request_timeout: Duration::from_secs(DEFAULT_REQUEST_TIMEOUT_SECS), - block_timeout: Duration::from_secs(DEFAULT_BLOCK_TIMEOUT_SECS), - user_agent: DEFAULT_USER_AGENT.to_string(), - proxy: None, - } - } -} - -impl ClientBuilder { - /// Create a new builder with default settings - pub fn new() -> Self { - Self::default() - } - - /// Set a custom HTTP client - pub fn client(mut self, client: Client) -> Self { - self.client = Some(client); - self - } - - /// Set the API base URL - pub fn api_base(mut self, url: impl Into) -> Self { - self.api_base = url.into(); - self - } - - /// Set the channel (0 = main mix, 1 = mellow, 2 = rock, 3 = world/etc) - pub fn channel(mut self, channel: u8) -> Self { - self.channel = channel; - self - } - - /// Set the request timeout - pub fn timeout(mut self, timeout: Duration) -> Self { - self.request_timeout = timeout; - self - } - - /// Set the timeout specifically for block downloads/streams - pub fn block_timeout(mut self, timeout: Duration) -> Self { - self.block_timeout = timeout; - self - } - - /// Set a custom User-Agent header - pub fn user_agent(mut self, user_agent: impl Into) -> Self { - self.user_agent = user_agent.into(); - self - } - - /// Set a proxy URL - pub fn proxy(mut self, proxy: impl Into) -> Self { - self.proxy = Some(proxy.into()); - self - } - - /// Build the client - pub async fn build(self) -> Result { - let client = if let Some(client) = self.client { - client - } else { - let mut builder = Client::builder() - .user_agent(&self.user_agent) - .timeout(self.request_timeout); - - if let Some(proxy_url) = &self.proxy { - let proxy = reqwest::Proxy::all(proxy_url) - .map_err(|e| Error::other(format!("Invalid proxy: {}", e)))?; - builder = builder.proxy(proxy); - } - - builder.build()? - }; - - Ok(RadioParadiseClient { - client, - api_base: self.api_base, - channel: self.channel, - request_timeout: self.request_timeout, - block_timeout: self.block_timeout, - next_block_url: None, - }) - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_builder_defaults() { - let builder = ClientBuilder::default(); - assert_eq!(builder.api_base, DEFAULT_API_BASE); - assert_eq!(builder.channel, DEFAULT_CHANNEL); - } -} --------End of pmoparadise/src/client.rs --------- - ------------- pmoparadise/src/config_ext.rs ---------- -//! Extension pour intégrer Radio Paradise dans pmoconfig -//! -//! Ce module fournit le trait `RadioParadiseConfigExt` qui permet d'ajouter facilement -//! des méthodes de gestion de la configuration Radio Paradise à pmoconfig::Config. -//! -//! La configuration est minimale - seulement ce qui doit vraiment être configurable : -//! - Activation/désactivation de la source -//! -//! # Exemple -//! -//! ```rust,ignore -//! use pmoconfig::get_config; -//! use pmoparadise::RadioParadiseConfigExt; -//! -//! let config = get_config(); -//! -//! // Check if enabled -//! if !config.get_paradise_enabled()? { -//! println!("Radio Paradise is disabled"); -//! return Ok(()); -//! } -//! ``` - -use crate::{channels::ParadiseChannelKind, client::DEFAULT_CHANNEL}; -use anyhow::Result; -use pmoconfig::Config; -use serde_yaml::Value; - -/// Trait d'extension pour gérer la configuration Radio Paradise dans pmoconfig -/// -/// Ce trait étend `pmoconfig::Config` avec des méthodes spécifiques -/// à la configuration minimale de Radio Paradise. -/// -/// # Auto-persist des valeurs par défaut -/// -/// Le getter persiste automatiquement la valeur par défaut dans la -/// configuration si elle n'existe pas encore. Cela permet à l'utilisateur de -/// voir la configuration effective dans le fichier YAML et de la modifier facilement. -/// -/// # Exemple -/// -/// ```rust,ignore -/// use pmoconfig::get_config; -/// use pmoparadise::RadioParadiseConfigExt; -/// -/// let config = get_config(); -/// -/// // Premier appel : persiste "enabled: true" dans la config et retourne true -/// let enabled = config.get_paradise_enabled()?; -/// -/// // L'utilisateur peut maintenant éditer cette valeur dans le fichier YAML -/// ``` -pub trait RadioParadiseConfigExt { - /// Vérifie si Radio Paradise est activé - /// - /// # Returns - /// - /// `true` si la source est activée (default), `false` sinon. - /// - /// Si la valeur n'existe pas dans la configuration, elle est automatiquement - /// définie à `true` (activé par défaut) et persistée. - /// - /// # Exemple - /// - /// ```rust,ignore - /// if config.get_paradise_enabled()? { - /// // Initialize Radio Paradise... - /// } - /// ``` - fn get_paradise_enabled(&self) -> Result; - - /// Active ou désactive Radio Paradise - /// - /// # Arguments - /// - /// * `enabled` - `true` pour activer, `false` pour désactiver - /// - /// # Exemple - /// - /// ```rust,ignore - /// // Disable Radio Paradise - /// config.set_paradise_enabled(false)?; - /// ``` - fn set_paradise_enabled(&self, enabled: bool) -> Result<()>; - - /// Récupère le channel par défaut - /// - /// # Returns - /// - /// Le channel par défaut (0 = Main Mix par défaut). - /// - /// Si la valeur n'existe pas dans la configuration, elle est automatiquement - /// définie à "main" et persistée. - /// - /// # Channels disponibles - /// - /// Peut être configuré comme chaîne de caractères ou nombre : - /// - "main" ou 0 = Main Mix (eclectic, diverse mix) - /// - "mellow" ou 1 = Mellow Mix (smooth, chilled music) - /// - "rock" ou 2 = Rock Mix (classic & modern rock) - /// - "eclectic" ou 3 = Eclectic Mix (global sounds) - /// - /// # Exemple de configuration YAML - /// - /// ```yaml - /// sources: - /// radio_paradise: - /// default_channel: mellow # or 1 - /// ``` - /// - /// # Exemple d'utilisation - /// - /// ```rust,ignore - /// let channel = config.get_paradise_default_channel()?; - /// let client = RadioParadiseClient::builder().channel(channel).build().await?; - /// ``` - fn get_paradise_default_channel(&self) -> Result; - - /// Définit le channel par défaut - /// - /// # Arguments - /// - /// * `channel` - Le channel (0-3) - /// - /// La valeur est stockée sous forme de nom convivial ("main", "mellow", etc.) - /// dans le fichier de configuration. - /// - /// # Exemple - /// - /// ```rust,ignore - /// use pmoparadise::channels::ParadiseChannelKind; - /// - /// // Use Mellow Mix by default - /// config.set_paradise_default_channel(ParadiseChannelKind::Mellow.id())?; - /// // Or simply: - /// config.set_paradise_default_channel(1)?; - /// ``` - fn set_paradise_default_channel(&self, channel: u8) -> Result<()>; -} - -impl RadioParadiseConfigExt for Config { - fn get_paradise_enabled(&self) -> Result { - match self.get_value(&["sources", "radio_paradise", "enabled"]) { - Ok(Value::Bool(b)) => Ok(b), - _ => { - // Use default (enabled) and persist it - self.set_paradise_enabled(true)?; - Ok(true) - } - } - } - - fn set_paradise_enabled(&self, enabled: bool) -> Result<()> { - self.set_value( - &["sources", "radio_paradise", "enabled"], - Value::Bool(enabled), - ) - } - - fn get_paradise_default_channel(&self) -> Result { - match self.get_value(&["sources", "radio_paradise", "default_channel"]) { - Ok(Value::String(s)) => { - // Try to parse as channel name (e.g., "main", "mellow", etc.) - match s.parse::() { - Ok(kind) => Ok(kind.id()), - Err(_) => { - // Invalid channel name, use default - self.set_paradise_default_channel(DEFAULT_CHANNEL)?; - Ok(DEFAULT_CHANNEL) - } - } - } - Ok(Value::Number(n)) => { - // Accept numeric channel ID (0-3) - if let Some(ch) = n.as_u64() { - if ch <= 3 { - Ok(ch as u8) - } else { - // Invalid channel number, use default - self.set_paradise_default_channel(DEFAULT_CHANNEL)?; - Ok(DEFAULT_CHANNEL) - } - } else { - // Not a valid number, use default - self.set_paradise_default_channel(DEFAULT_CHANNEL)?; - Ok(DEFAULT_CHANNEL) - } - } - _ => { - // Use default and persist it as "main" (user-friendly) - self.set_value( - &["sources", "radio_paradise", "default_channel"], - Value::String("main".to_string()), - )?; - Ok(DEFAULT_CHANNEL) - } - } - } - - fn set_paradise_default_channel(&self, channel: u8) -> Result<()> { - // Convert channel ID to user-friendly string name - let channel_name = match channel { - 0 => "main", - 1 => "mellow", - 2 => "rock", - 3 => "eclectic", - _ => return Err(anyhow::anyhow!("Invalid channel ID: {}", channel)), - }; - - self.set_value( - &["sources", "radio_paradise", "default_channel"], - Value::String(channel_name.to_string()), - ) - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_trait_exists() { - // Simple test to ensure the trait compiles - } -} --------End of pmoparadise/src/config_ext.rs --------- - ------------- pmoparadise/src/error.rs ---------- -//! Error types for the Radio Paradise client - -/// Result type alias for Radio Paradise operations -pub type Result = std::result::Result; - -/// Errors that can occur when using the Radio Paradise client -#[derive(Debug, thiserror::Error)] -pub enum Error { - /// HTTP request failed - #[error("HTTP request failed: {0}")] - Http(#[from] reqwest::Error), - - /// JSON parsing failed - #[error("JSON parsing failed: {0}")] - Json(#[from] serde_json::Error), - - /// Invalid URL - #[error("Invalid URL: {0}")] - InvalidUrl(#[from] url::ParseError), - - /// IO error - #[error("IO error: {0}")] - Io(#[from] std::io::Error), - - /// Invalid track index - #[error("Invalid track index: {0} (block has {1} tracks)")] - InvalidIndex(usize, usize), - - /// Invalid bitrate - #[error("Invalid bitrate value: {0} (must be 0-4)")] - InvalidBitrate(u8), - - /// Invalid event ID - #[error("Invalid event ID: {0}")] - InvalidEvent(String), - - /// Track not found in block - #[error("Track not found at index {0}")] - TrackNotFound(usize), - - /// Invalid elapsed time - #[error("Invalid elapsed time: {0}ms (exceeds block length)")] - InvalidElapsed(u64), - - /// Timeout error - #[error("Request timeout")] - Timeout, - - /// Generic error - #[error("{0}")] - Other(String), -} - -impl Error { - /// Create a generic error from a string - pub fn other(msg: impl Into) -> Self { - Self::Other(msg.into()) - } -} --------End of pmoparadise/src/error.rs --------- - ------------- pmoparadise/src/lib.rs ---------- -//! # pmoparadise - Radio Paradise Client for Rust -//! -//! `pmoparadise` is an idiomatic Rust client library for accessing Radio Paradise's -//! streaming API. It provides metadata retrieval, block streaming, and optional -//! per-track extraction from FLAC blocks. -//! -//! ## Features -//! -//! - **Metadata Access**: Get current and historical block metadata with song information -//! - **Block Streaming**: Stream continuous FLAC blocks with automatic prefetching -//! - **FLAC Quality**: Lossless CD quality or better -//! - **Per-Track Extraction** (optional): Extract individual tracks from FLAC blocks -//! - **Async/Await**: Built on tokio for efficient async I/O -//! - **Type-Safe**: Strongly typed API with comprehensive error handling -//! -//! ## Quick Start -//! -//! ```no_run -//! use pmoparadise::RadioParadiseClient; -//! -//! #[tokio::main] -//! async fn main() -> Result<(), Box> { -//! // Create a client -//! let client = RadioParadiseClient::new().await?; -//! -//! // Get what's currently playing -//! let now_playing = client.now_playing().await?; -//! -//! if let Some(song) = &now_playing.current_song { -//! println!("Now Playing: {} - {}", song.artist, song.title); -//! if let Some(album) = &song.album { -//! println!("Album: {}", album); -//! } -//! } -//! -//! // Get all songs in the current block -//! for (index, song) in now_playing.block.songs_ordered() { -//! println!(" {}. {} - {} ({}s)", -//! index, -//! song.artist, -//! song.title, -//! song.duration / 1000); -//! } -//! -//! Ok(()) -//! } -//! ``` -//! -//! ## Streaming Blocks -//! -//! Radio Paradise broadcasts music in continuous "blocks" - each block is a single -//! FLAC file containing multiple songs with metadata indicating timing offsets. -//! -//! ```no_run -//! use pmoparadise::RadioParadiseClient; -//! use futures::StreamExt; -//! -//! #[tokio::main] -//! async fn main() -> Result<(), Box> { -//! let client = RadioParadiseClient::new().await?; -//! let block = client.get_block(None).await?; -//! -//! // Stream the block -//! let mut stream = client.stream_block_from_metadata(&block).await?; -//! -//! while let Some(chunk) = stream.next().await { -//! let bytes = chunk?; -//! // Feed to audio player, write to file, etc. -//! } -//! -//! Ok(()) -//! } -//! ``` -//! -//! ## Per-Track Extraction (Feature: `per-track`) -//! -//! **Important**: This is an advanced feature with significant tradeoffs. -//! See the [`track`] module documentation for details. -//! -//! Most applications should stream blocks and use player-based seeking instead. -//! -//! ```no_run -//! # #[cfg(feature = "per-track")] -//! # { -//! use pmoparadise::RadioParadiseClient; -//! use std::path::Path; -//! -//! #[tokio::main] -//! async fn main() -> Result<(), Box> { -//! let client = RadioParadiseClient::new().await?; -//! let block = client.get_block(None).await?; -//! -//! // Extract first track to WAV -//! let mut track = client.open_track_stream(&block, 0).await?; -//! track.export_wav(Path::new("track.wav"))?; -//! -//! // Or get position for player-based seeking (recommended) -//! let (start, duration) = client.track_position_seconds(&block, 0)?; -//! println!("Play with: mpv --start={} --length={} {}", start, duration, block.url); -//! -//! Ok(()) -//! } -//! # } -//! ``` -//! -//! ## Architecture -//! -//! The API is organized into several modules: -//! -//! - [`client`]: Main HTTP client for API access -//! - [`models`]: Data structures for blocks, songs, and metadata -//! - [`stream`]: Block streaming functionality -//! - [`track`]: Per-track extraction (feature-gated) -//! - [`error`]: Error types and result aliases -//! -//! ## Radio Paradise Block Format -//! -//! Radio Paradise streams use a block-based format: -//! -//! - Each block is a single FLAC audio file -//! - Blocks contain multiple songs (typically 10-15 minutes total) -//! - Metadata includes timing offsets (`song[i].elapsed` in ms) for each song -//! - Block URLs follow the pattern: `https://apps.radioparadise.com/blocks/chan/0/4/-.flac` -//! - The `end_event` of one block is the `event` of the next, enabling seamless transitions -//! -//! ## Best Practices -//! -//! ### For Continuous Playback -//! -//! 1. Get current block with `get_block(None)` -//! 2. Stream block with `stream_block_from_metadata()` -//! 3. Use `prefetch_next()` to prepare the next block -//! 4. When current block ends, stream the next block seamlessly -//! -//! ### For Per-Song Seeking -//! -//! **Recommended approach** (efficient): -//! ```bash -//! # Use your audio player's seek capability -//! mpv --start=123.5 --length=234.0 -//! ``` -//! -//! **Alternative** (resource-intensive, requires `per-track` feature): -//! - Download and decode block -//! - Extract specific track to PCM/WAV -//! -//! ## Error Handling -//! -//! All operations return `Result` with detailed error types: -//! -//! ```no_run -//! use pmoparadise::{RadioParadiseClient, Error}; -//! -//! #[tokio::main] -//! async fn main() { -//! let client = RadioParadiseClient::new().await.unwrap(); -//! -//! match client.get_block(Some(99999999)).await { -//! Ok(block) => println!("Got block: {}", block.event), -//! Err(Error::Http(e)) => eprintln!("Network error: {}", e), -//! Err(Error::Json(e)) => eprintln!("Parse error: {}", e), -//! Err(e) => eprintln!("Other error: {}", e), -//! } -//! } -//! ``` -//! -//! ## Audio Streaming (Feature: `pmoaudio`) -//! -//! For direct audio streaming and integration with pmoaudio pipelines, -//! use `RadioParadiseStreamSource`: -//! -//! ```no_run -//! # #[cfg(feature = "pmoaudio")] -//! # { -//! use pmoparadise::{RadioParadiseClient, RadioParadiseStreamSource}; -//! use pmoaudio::pipeline::Node; -//! -//! #[tokio::main] -//! async fn main() -> Result<(), Box> { -//! let client = RadioParadiseClient::new().await?; -//! let stream_source = RadioParadiseStreamSource::new(client, None).await?; -//! -//! // Create audio node from stream source -//! let node = Node::from_logic(stream_source); -//! -//! // Use in pmoaudio pipeline... -//! -//! Ok(()) -//! } -//! # } -//! ``` -//! -//! **RadioParadiseStreamSource**: -//! - Downloads and decodes FLAC blocks in real-time -//! - Automatically detects bit depth (16/24/32-bit) -//! - Inserts track boundaries with metadata -//! - Integrates seamlessly with pmoaudio pipelines -//! -//! ## Cargo Features -//! -//! - `default`: Standard metadata and streaming (no FLAC decoding) -//! - `per-track`: Enable FLAC decoding and per-track extraction (adds `claxon`, `hound`, `tempfile`) -//! - `pmoserver`: Enable REST API extension for pmoserver integration (adds `utoipa`, `axum`) -//! - `pmoaudio`: Enable RadioParadiseStreamSource for pmoaudio integration -//! - `pmoconfig`: Enable configuration integration with pmoconfig -//! - `server`: Enable RadioParadiseSource for UPnP ContentDirectory integration -//! -//! ## See Also -//! -//! - [Radio Paradise](https://radioparadise.com) - Official website -//! - [Radio Paradise API](https://api.radioparadise.com) - API documentation - -pub mod channels; -pub mod client; -pub mod error; -pub mod models; -pub mod source; - -#[cfg(feature = "pmoaudio")] -pub mod node_stats; - -#[cfg(feature = "pmoserver")] -pub mod pmoserver_ext; - -#[cfg(feature = "pmoconfig")] -pub mod config_ext; - -#[cfg(feature = "pmoaudio")] -pub mod radio_paradise_stream_source; - -#[cfg(feature = "pmoaudio")] -pub mod stream_channel; - -#[cfg(feature = "pmoaudio")] -pub mod playlist_feeder; - -// Re-exports for convenience -pub use client::{ClientBuilder, RadioParadiseClient}; -pub use error::{Error, Result}; -pub use models::{Block, DurationMs, EventId, NowPlaying, Song}; -pub use source::RadioParadiseSource; - -#[cfg(feature = "pmoaudio")] -pub use radio_paradise_stream_source::RadioParadiseStreamSource; - -#[cfg(feature = "pmoaudio")] -pub use playlist_feeder::{RadioParadisePlaylistFeeder, END_OF_BLOCKS_SIGNAL}; - -#[cfg(feature = "pmoaudio")] -pub use stream_channel::{ - HistoryFlacStream, HistoryOggStream, HistoryStreamError, ParadiseChannelManager, - ParadiseHistoryBuilder, ParadiseHistoryOptions, ParadiseStreamChannel, - ParadiseStreamChannelConfig, -}; - -#[cfg(feature = "pmoserver")] -pub use pmoserver_ext::{ - create_api_router, RadioParadiseApiDoc, RadioParadiseExt, RadioParadiseState, -}; - -#[cfg(feature = "pmoconfig")] -pub use config_ext::RadioParadiseConfigExt; - -// Version information -pub const VERSION: &str = env!("CARGO_PKG_VERSION"); - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_version() { - assert!(!VERSION.is_empty()); - } -} --------End of pmoparadise/src/lib.rs --------- - ------------- pmoparadise/src/models.rs ---------- -//! Data models for Radio Paradise API responses - -use serde::{Deserialize, Deserializer, Serialize}; -use serde_json::Number; -use std::collections::HashMap; -use url::Url; - -/// Deserialize a string or number into a u64 -fn deserialize_string_or_u64<'de, D>(deserializer: D) -> Result -where - D: Deserializer<'de>, -{ - use serde::de::Error; - - #[derive(Deserialize)] - #[serde(untagged)] - enum StringOrU64 { - String(String), - Number(u64), - } - - match StringOrU64::deserialize(deserializer)? { - StringOrU64::String(s) => s.parse::().map_err(D::Error::custom), - StringOrU64::Number(n) => Ok(n), - } -} - -/// Deserialize a string or number into a f64, then convert to u64 milliseconds -fn deserialize_length<'de, D>(deserializer: D) -> Result -where - D: Deserializer<'de>, -{ - use serde::de::Error; - - #[derive(Deserialize)] - #[serde(untagged)] - enum StringOrNumber { - String(String), - Number(Number), - } - - fn to_milliseconds(value: f64) -> u64 { - if value >= 100_000.0 { - value.round() as u64 - } else { - (value * 1000.0).round() as u64 - } - } - - match StringOrNumber::deserialize(deserializer)? { - StringOrNumber::String(s) => { - let value = s.parse::().map_err(D::Error::custom)?; - Ok(to_milliseconds(value)) - } - StringOrNumber::Number(n) => { - if let Some(int_value) = n.as_u64() { - Ok(to_milliseconds(int_value as f64)) - } else if let Some(float_value) = n.as_f64() { - Ok(to_milliseconds(float_value)) - } else { - Err(D::Error::custom("Invalid number for block length")) - } - } - } -} - -/// Deserialize an optional string or number into Option -fn deserialize_optional_string_or_u32<'de, D>(deserializer: D) -> Result, D::Error> -where - D: Deserializer<'de>, -{ - use serde::de::Error; - - #[derive(Deserialize)] - #[serde(untagged)] - enum StringOrU32 { - String(String), - Number(u32), - } - - let opt = Option::::deserialize(deserializer)?; - match opt { - None => Ok(None), - Some(StringOrU32::String(s)) => { - if s.is_empty() { - Ok(None) - } else { - s.parse::().map(Some).map_err(D::Error::custom) - } - } - Some(StringOrU32::Number(n)) => Ok(Some(n)), - } -} - -/// Deserialize an optional string or number into Option -fn deserialize_optional_string_or_f32<'de, D>(deserializer: D) -> Result, D::Error> -where - D: Deserializer<'de>, -{ - use serde::de::Error; - - #[derive(Deserialize)] - #[serde(untagged)] - enum StringOrF32 { - String(String), - Float(f32), - Int(i32), - } - - let opt = Option::::deserialize(deserializer)?; - match opt { - None => Ok(None), - Some(StringOrF32::String(s)) => { - if s.is_empty() { - Ok(None) - } else { - s.parse::().map(Some).map_err(D::Error::custom) - } - } - Some(StringOrF32::Float(f)) => Ok(Some(f)), - Some(StringOrF32::Int(i)) => Ok(Some(i as f32)), - } -} - -/// Duration in milliseconds -pub type DurationMs = u64; - -/// Event ID for block identification -pub type EventId = u64; - -/// Information about a song/track within a block -#[derive(Debug, Clone, Serialize, Deserialize)] -pub struct Song { - /// Artist name - pub artist: String, - - /// Song title - pub title: String, - - /// Album name (may be missing for promos/announcements) - #[serde(default)] - pub album: Option, - - /// Year of release - /// Note: API returns this as a string, we deserialize to u32 - #[serde(default, deserialize_with = "deserialize_optional_string_or_u32")] - pub year: Option, - - /// Elapsed time from start of block in milliseconds - pub elapsed: DurationMs, - - /// Duration of the track in milliseconds - pub duration: DurationMs, - - /// Cover image filename/path - #[serde(default)] - pub cover: Option, - - /// Rating (0-10) - /// Note: API returns this as a string, we deserialize to f32 - #[serde(default, deserialize_with = "deserialize_optional_string_or_f32")] - pub rating: Option, - - /// Gapless URL for individual song FLAC - /// This URL points to a FLAC file containing only this song - #[serde(default)] - pub gapless_url: Option, - - /// Scheduled playback time on Radio Paradise (Unix timestamp in milliseconds, UTC) - #[serde(default)] - pub sched_time_millis: Option, - - /// Radio Paradise song ID (unique identifier) - #[serde(default)] - pub song_id: Option, - - /// Radio Paradise artist ID (for building artist URLs) - #[serde(default)] - pub artist_id: Option, - - /// Large cover image path (best quality) - #[serde(default)] - pub cover_large: Option, - - /// Additional metadata - #[serde(flatten)] - pub extra: HashMap, -} - -impl Song { - /// Get the end time of this song in the block (elapsed + duration) - pub fn end_time_ms(&self) -> DurationMs { - self.elapsed + self.duration - } - - /// Check if a given timestamp (ms) falls within this song - pub fn contains_timestamp(&self, timestamp_ms: DurationMs) -> bool { - timestamp_ms >= self.elapsed && timestamp_ms < self.end_time_ms() - } - - /// Calcule le timestamp de fin de diffusion (sched_time + duration) - pub fn sched_end_time_ms(&self) -> Option { - self.sched_time_millis.map(|start| start + self.duration) - } - - /// Vérifie si la chanson est encore en lecture ou à venir - pub fn is_still_playing(&self, now_ms: u64) -> bool { - self.sched_end_time_ms() - .map(|end| end >= now_ms) - .unwrap_or(false) - } -} - -/// Image information -#[derive(Debug, Clone, Serialize, Deserialize)] -pub struct ImageInfo { - /// Base URL for images - pub base: String, -} - -/// A block of songs from Radio Paradise -/// -/// Radio Paradise streams music in "blocks" - continuous FLAC files -/// containing multiple songs. Each block contains metadata about all -/// songs within it and timing information for seeking. -#[derive(Debug, Clone, Serialize, Deserialize)] -pub struct Block { - /// Event ID for this block (start event) - /// Note: API returns this as a string, we deserialize to u64 - #[serde(deserialize_with = "deserialize_string_or_u64")] - pub event: EventId, - - /// Event ID for the next block (end event) - /// Note: API returns this as a string, we deserialize to u64 - #[serde(deserialize_with = "deserialize_string_or_u64")] - pub end_event: EventId, - - /// Total length of the block in milliseconds - /// Note: API returns this as a string in seconds (e.g., "1715.54"), we convert to ms - #[serde(deserialize_with = "deserialize_length")] - pub length: DurationMs, - - /// URL to stream this block - pub url: String, - - /// Base URL for cover images - #[serde(default)] - pub image_base: Option, - - /// Scheduled start time for this block (Unix timestamp in milliseconds, UTC) - #[serde(default)] - pub sched_time_millis: Option, - - /// Map of song index (as string) to Song metadata - /// Keys are "0", "1", "2", etc. - #[serde(default)] - pub song: HashMap, - - /// Additional metadata - #[serde(flatten)] - pub extra: HashMap, -} - -impl Block { - /// Scheduled start time in milliseconds if available. - pub fn start_time_millis(&self) -> Option { - if let Some(ts) = self.sched_time_millis { - return Some(ts); - } - self.songs_ordered() - .into_iter() - .find_map(|(_, song)| song.sched_time_millis) - } - - /// Get songs in order by index - pub fn songs_ordered(&self) -> Vec<(usize, &Song)> { - let mut songs: Vec<_> = self - .song - .iter() - .filter_map(|(k, v)| k.parse::().ok().map(|idx| (idx, v))) - .collect(); - songs.sort_by_key(|(idx, _)| *idx); - songs - } - - /// Get a song by index - pub fn get_song(&self, index: usize) -> Option<&Song> { - self.song.get(&index.to_string()) - } - - /// Get the number of songs in this block - pub fn song_count(&self) -> usize { - self.song.len() - } - - /// Get the full URL for a cover image - pub fn cover_url(&self, cover_path: &str) -> Option { - let base = self.image_base.as_ref()?; - let base_url = Url::parse(base).ok()?; - base_url.join(cover_path).ok().map(|url| url.to_string()) - } - - /// Find which song is playing at a given timestamp (ms from block start) - pub fn song_at_timestamp(&self, timestamp_ms: DurationMs) -> Option<(usize, &Song)> { - self.songs_ordered() - .into_iter() - .find(|(_, song)| song.contains_timestamp(timestamp_ms)) - } - - /// Parse the block URL to get start and end event IDs - /// - /// Block URLs follow the pattern: - /// `https://apps.radioparadise.com/blocks/chan/0/4/-.flac` - pub fn parse_url_events(&self) -> Option<(EventId, EventId)> { - let url_path = self.url.split('/').last()?; - let filename = url_path.strip_suffix(".flac")?; - let mut parts = filename.split('-'); - let start = parts.next()?.parse::().ok()?; - let end = parts.next()?.parse::().ok()?; - Some((start, end)) - } -} - -/// Currently playing information -#[derive(Debug, Clone)] -pub struct NowPlaying { - /// The current block - pub block: Block, - - /// Current song index (if determinable) - pub current_song_index: Option, - - /// Current song - pub current_song: Option, - - /// Approximate elapsed time in current block (ms) - /// Note: This is estimated and may not be perfectly accurate - pub block_elapsed_ms: Option, -} - -impl NowPlaying { - /// Create from a block (assumes starting from beginning) - pub fn from_block(block: Block) -> Self { - let (current_song_index, current_song) = block - .get_song(0) - .map(|s| (Some(0), Some(s.clone()))) - .unwrap_or((None, None)); - - Self { - block, - current_song_index, - current_song, - block_elapsed_ms: Some(0), - } - } - - /// Get URL for the current block stream - pub fn stream_url(&self) -> &str { - &self.block.url - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_song_timing() { - let song = Song { - artist: "Test Artist".to_string(), - title: "Test Song".to_string(), - album: Some("Test Album".to_string()), - year: Some(2024), - elapsed: 1000, - duration: 5000, - cover: None, - rating: None, - extra: HashMap::new(), - gapless_url: Some("http://example.com/song.flac".into()), - sched_time_millis: Some(1_700_000_000_000), - song_id: Some("song-id".into()), - artist_id: Some("artist-id".into()), - cover_large: Some("cover-large.jpg".into()), - }; - - assert_eq!(song.end_time_ms(), 6000); - assert!(song.contains_timestamp(3000)); - assert!(!song.contains_timestamp(7000)); - assert!(!song.contains_timestamp(500)); - } - - #[test] - fn test_block_parse() { - let json = r#"{ - "event": 1234, - "end_event": 5678, - "length": 900000, - "url": "https://apps.radioparadise.com/blocks/chan/0/4/1234-5678.flac", - "image_base": "https://img.radioparadise.com/covers/l/", - "song": { - "0": { - "artist": "Miles Davis", - "title": "So What", - "album": "Kind of Blue", - "year": 1959, - "elapsed": 0, - "duration": 540000, - "cover": "B00000I0JF.jpg" - }, - "1": { - "artist": "John Coltrane", - "title": "Giant Steps", - "album": "Giant Steps", - "year": 1960, - "elapsed": 540000, - "duration": 360000, - "cover": "B000002I4U.jpg" - } - } - }"#; - - let block: Block = serde_json::from_str(json).unwrap(); - assert_eq!(block.event, 1234); - assert_eq!(block.end_event, 5678); - assert_eq!(block.song_count(), 2); - - let songs = block.songs_ordered(); - assert_eq!(songs.len(), 2); - assert_eq!(songs[0].1.title, "So What"); - assert_eq!(songs[1].1.title, "Giant Steps"); - - let (start, end) = block.parse_url_events().unwrap(); - assert_eq!(start, 1234); - assert_eq!(end, 5678); - - let (idx, song) = block.song_at_timestamp(600000).unwrap(); - assert_eq!(idx, 1); - assert_eq!(song.title, "Giant Steps"); - } - - #[test] - fn test_block_length_from_seconds_string() { - let json = serde_json::json!({ - "event": 1, - "end_event": 2, - "length": "1715.54", - "url": "https://example.com/block.flac", - "song": {} - }); - - let block: Block = serde_json::from_value(json).unwrap(); - assert_eq!(block.length, 1_715_540); - } - - #[test] - fn test_block_length_from_seconds_integer() { - let json = serde_json::json!({ - "event": 1, - "end_event": 2, - "length": 1800, - "url": "https://example.com/block.flac", - "song": {} - }); - - let block: Block = serde_json::from_value(json).unwrap(); - assert_eq!(block.length, 1_800_000); - } - - #[test] - fn test_block_length_from_milliseconds_integer() { - let json = serde_json::json!({ - "event": 1, - "end_event": 2, - "length": 900_000, - "url": "https://example.com/block.flac", - "song": {} - }); - - let block: Block = serde_json::from_value(json).unwrap(); - assert_eq!(block.length, 900_000); - } - - #[test] - fn test_block_length_from_milliseconds_float() { - let json = serde_json::json!({ - "event": 1, - "end_event": 2, - "length": 900_000.0, - "url": "https://example.com/block.flac", - "song": {} - }); - - let block: Block = serde_json::from_value(json).unwrap(); - assert_eq!(block.length, 900_000); - } -} --------End of pmoparadise/src/models.rs --------- - ------------- pmoparadise/src/node_stats.rs ---------- -//! Node statistics tracking -//! -//! Provides detailed statistics for pipeline nodes to understand -//! data flow, backpressure behavior, and timing. - -use std::sync::atomic::{AtomicU64, AtomicUsize, Ordering}; -use std::sync::Arc; -use std::time::Instant; - -/// Statistics pour un node audio -#[derive(Debug)] -pub struct NodeStats { - /// Nom du node pour identification - pub name: String, - - /// Instant de démarrage du node - pub start_time: Instant, - - /// Nombre total de segments reçus - pub segments_received: AtomicUsize, - - /// Nombre total de segments envoyés - pub segments_sent: AtomicUsize, - - /// Nombre total de bytes traités - pub bytes_processed: AtomicU64, - - /// Nombre de fois où l'envoi a été bloqué (backpressure) - pub backpressure_blocks: AtomicUsize, - - /// Temps total passé bloqué en millisecondes - pub backpressure_time_ms: AtomicU64, - - /// Timestamp du premier segment (secondes) - pub first_segment_timestamp: AtomicU64, // Stocké comme u64 * 1000 pour précision - - /// Timestamp du dernier segment (secondes) - pub last_segment_timestamp: AtomicU64, // Stocké comme u64 * 1000 pour précision -} - -impl NodeStats { - pub fn new(name: impl Into) -> Arc { - Arc::new(Self { - name: name.into(), - start_time: Instant::now(), - segments_received: AtomicUsize::new(0), - segments_sent: AtomicUsize::new(0), - bytes_processed: AtomicU64::new(0), - backpressure_blocks: AtomicUsize::new(0), - backpressure_time_ms: AtomicU64::new(0), - first_segment_timestamp: AtomicU64::new(u64::MAX), - last_segment_timestamp: AtomicU64::new(0), - }) - } - - /// Enregistre la réception d'un segment - pub fn record_segment_received(&self, timestamp_sec: f64) { - self.segments_received.fetch_add(1, Ordering::Relaxed); - - let ts_millis = (timestamp_sec * 1000.0) as u64; - - // Update first timestamp (atomic min) - let mut current = self.first_segment_timestamp.load(Ordering::Relaxed); - while current > ts_millis { - match self.first_segment_timestamp.compare_exchange_weak( - current, - ts_millis, - Ordering::Relaxed, - Ordering::Relaxed, - ) { - Ok(_) => break, - Err(x) => current = x, - } - } - - // Update last timestamp (atomic max) - let mut current = self.last_segment_timestamp.load(Ordering::Relaxed); - while current < ts_millis { - match self.last_segment_timestamp.compare_exchange_weak( - current, - ts_millis, - Ordering::Relaxed, - Ordering::Relaxed, - ) { - Ok(_) => break, - Err(x) => current = x, - } - } - } - - /// Enregistre l'envoi d'un segment - pub fn record_segment_sent(&self, bytes: usize) { - self.segments_sent.fetch_add(1, Ordering::Relaxed); - self.bytes_processed - .fetch_add(bytes as u64, Ordering::Relaxed); - } - - /// Enregistre un événement de backpressure - pub fn record_backpressure(&self, duration_ms: u64) { - self.backpressure_blocks.fetch_add(1, Ordering::Relaxed); - self.backpressure_time_ms - .fetch_add(duration_ms, Ordering::Relaxed); - } - - /// Retourne un rapport formaté des statistiques - pub fn report(&self) -> String { - let elapsed = self.start_time.elapsed().as_secs_f64(); - let received = self.segments_received.load(Ordering::Relaxed); - let sent = self.segments_sent.load(Ordering::Relaxed); - let bytes = self.bytes_processed.load(Ordering::Relaxed); - let bp_blocks = self.backpressure_blocks.load(Ordering::Relaxed); - let bp_time_ms = self.backpressure_time_ms.load(Ordering::Relaxed); - - let first_ts = self.first_segment_timestamp.load(Ordering::Relaxed); - let last_ts = self.last_segment_timestamp.load(Ordering::Relaxed); - - let first_ts_sec = if first_ts == u64::MAX { - 0.0 - } else { - first_ts as f64 / 1000.0 - }; - let last_ts_sec = last_ts as f64 / 1000.0; - let audio_duration = last_ts_sec - first_ts_sec; - - let mb = bytes as f64 / 1_048_576.0; - let throughput_mbps = if elapsed > 0.0 { mb / elapsed } else { 0.0 }; - - format!( - "[{}]\n\ - Elapsed: {:.1}s | Received: {} | Sent: {} | Lost: {}\n\ - Data: {:.1} MB | Throughput: {:.2} MB/s\n\ - Audio: {:.1}s (first: {:.1}s, last: {:.1}s) | Real-time ratio: {:.1}%\n\ - Backpressure: {} blocks, {:.2}s total ({:.1}% of time)", - self.name, - elapsed, - received, - sent, - received.saturating_sub(sent), - mb, - throughput_mbps, - audio_duration, - first_ts_sec, - last_ts_sec, - if audio_duration > 0.0 { - (elapsed / audio_duration) * 100.0 - } else { - 0.0 - }, - bp_blocks, - bp_time_ms as f64 / 1000.0, - if elapsed > 0.0 { - (bp_time_ms as f64 / 1000.0 / elapsed) * 100.0 - } else { - 0.0 - } - ) - } -} --------End of pmoparadise/src/node_stats.rs --------- - ------------- pmoparadise/src/playlist_feeder.rs ---------- -//! RadioParadisePlaylistFeeder - Télécharge et alimente une playlist à partir des blocs RP -//! -//! Architecture simplifiée utilisant les URLs gapless individuelles au lieu du bloc FLAC entier. - -use crate::{client::RadioParadiseClient, models::EventId}; -use anyhow::Result; -use pmoaudiocache::Cache as AudioCache; -use pmocovers::Cache as CoversCache; -use pmoplaylist::{PlaylistManager, ReadHandle, WriteHandle}; -use std::{ - collections::{HashMap, VecDeque}, - sync::Arc, - time::{Duration, SystemTime, UNIX_EPOCH}, -}; -use tokio::sync::Notify; - -/// Signal de fin de blocs -pub const END_OF_BLOCKS_SIGNAL: EventId = EventId::MAX; -const RECENT_BLOCKS_CACHE_SIZE: usize = 10; - -#[derive(Clone, Copy, Debug, PartialEq, Eq)] -enum BlockStatus { - Pending, - InProgress, - Done, -} - -struct RecentBlocks { - states: HashMap, - order: VecDeque, - capacity: usize, -} - -impl RecentBlocks { - fn new(capacity: usize) -> Self { - Self { - states: HashMap::new(), - order: VecDeque::new(), - capacity, - } - } - - fn try_enqueue(&mut self, event_id: EventId) -> bool { - match self.states.get(&event_id) { - Some(_) => false, - None => { - self.order.push_back(event_id); - self.states.insert(event_id, BlockStatus::Pending); - self.evict_old_done(); - true - } - } - } - - fn mark_in_progress(&mut self, event_id: EventId) { - if let Some(state) = self.states.get_mut(&event_id) { - *state = BlockStatus::InProgress; - } else { - self.order.push_back(event_id); - self.states.insert(event_id, BlockStatus::InProgress); - } - self.evict_old_done(); - } - - fn mark_done(&mut self, event_id: EventId) { - if let Some(state) = self.states.get_mut(&event_id) { - *state = BlockStatus::Done; - } else { - self.order.push_back(event_id); - self.states.insert(event_id, BlockStatus::Done); - } - self.evict_old_done(); - } - - fn purge(&mut self, event_id: EventId) { - self.states.remove(&event_id); - } - - fn evict_old_done(&mut self) { - while self.order.len() > self.capacity { - let Some(front) = self.order.front().copied() else { - break; - }; - match self.states.get(&front) { - Some(BlockStatus::Done) | None => { - self.order.pop_front(); - self.states.remove(&front); - } - Some(_) => break, - } - } - } -} - -/// Feeder qui télécharge les blocs RP et alimente une playlist -pub struct RadioParadisePlaylistFeeder { - client: RadioParadiseClient, - audio_cache: Arc, - covers_cache: Arc, - playlist_handle: Arc, - block_queue: Arc>>, - notify: Arc, - collection: Option, - recent_blocks: tokio::sync::Mutex, -} - -impl RadioParadisePlaylistFeeder { - /// Crée un nouveau feeder et retourne (feeder, read_handle) - pub async fn new( - client: RadioParadiseClient, - audio_cache: Arc, - covers_cache: Arc, - playlist_id: String, - collection: Option, - ) -> Result<(Self, ReadHandle)> { - let manager = PlaylistManager::get(); - let write_handle = manager - .create_persistent_playlist(playlist_id.clone()) - .await?; - let read_handle = manager.get_read_handle(&playlist_id).await?; - - Ok(( - Self { - client, - audio_cache, - covers_cache, - playlist_handle: Arc::new(write_handle), - block_queue: Arc::new(tokio::sync::Mutex::new(VecDeque::new())), - notify: Arc::new(Notify::new()), - collection, - recent_blocks: tokio::sync::Mutex::new(RecentBlocks::new(RECENT_BLOCKS_CACHE_SIZE)), - }, - read_handle, - )) - } - - /// Enqueue un bloc pour traitement - pub async fn push_block_id(&self, event_id: EventId) { - { - let mut recent = self.recent_blocks.lock().await; - if !recent.try_enqueue(event_id) { - tracing::debug!( - "RadioParadisePlaylistFeeder: Ignoring duplicate enqueue for block {}", - event_id - ); - return; - } - } - - { - let mut queue = self.block_queue.lock().await; - queue.push_back(event_id); - } - self.notify.notify_one(); - } - - async fn mark_in_progress(&self, event_id: EventId) { - let mut recent = self.recent_blocks.lock().await; - recent.mark_in_progress(event_id); - } - - async fn mark_done(&self, event_id: EventId) { - let mut recent = self.recent_blocks.lock().await; - recent.mark_done(event_id); - } - - async fn purge_block_state(&self, event_id: EventId) { - let mut recent = self.recent_blocks.lock().await; - recent.purge(event_id); - } - - pub(crate) async fn retry_block(&self, event_id: EventId) { - self.purge_block_state(event_id).await; - self.push_block_id(event_id).await; - } - - /// Boucle principale de traitement (à exécuter dans une tâche tokio) - pub async fn run(self: Arc) -> Result<()> { - loop { - // Attendre un bloc - let event_id = loop { - { - let mut queue = self.block_queue.lock().await; - if let Some(id) = queue.pop_front() { - if id == END_OF_BLOCKS_SIGNAL { - tracing::info!( - "RadioParadisePlaylistFeeder: END_OF_BLOCKS_SIGNAL received" - ); - return Ok(()); - } - break id; - } - } - self.notify.notified().await; - }; - - self.mark_in_progress(event_id).await; - - // Traiter le bloc - if let Err(e) = self.process_block(event_id).await { - tracing::error!( - "RadioParadisePlaylistFeeder: Failed to process block {}: {}", - event_id, - e - ); - self.purge_block_state(event_id).await; - tracing::debug!( - "RadioParadisePlaylistFeeder: Cleared block {} state after error", - event_id - ); - } else { - self.mark_done(event_id).await; - } - } - } - - /// Traite un bloc : fetch, filtre, download, push playlist - async fn process_block(&self, event_id: EventId) -> Result<()> { - tracing::info!("RadioParadisePlaylistFeeder: Processing block {}", event_id); - - // 1. Fetch le bloc - let block = self.client.get_block(Some(event_id)).await?; - - // 2. Timestamp actuel - let now_ms = SystemTime::now().duration_since(UNIX_EPOCH)?.as_millis() as u64; - - // 3. Filtrer les chansons encore en lecture ou à venir - let songs = block.songs_ordered(); - let mut processed = 0; - - for (idx, song) in songs { - if !song.is_still_playing(now_ms) { - tracing::debug!( - "RadioParadisePlaylistFeeder: Skipping finished song {} - {} (ended at {})", - idx, - song.title, - song.sched_end_time_ms().unwrap_or(0) - ); - continue; - } - - // 4. Télécharger la chanson - let gapless_url = song - .gapless_url - .as_ref() - .ok_or_else(|| anyhow::anyhow!("Missing gapless_url for song {}", idx))?; - - tracing::info!( - "RadioParadisePlaylistFeeder: Downloading song {} - {} by {}", - idx, - song.title, - song.artist - ); - - let pk = self - .audio_cache - .add_from_url(gapless_url, self.collection.as_deref()) - .await?; - - // 5. Sauvegarder les métadonnées - self.save_metadata(&pk, song, &block).await?; - - // 6. Calculer le TTL - let sched_end = song - .sched_end_time_ms() - .ok_or_else(|| anyhow::anyhow!("Cannot calculate TTL without sched_time_millis"))?; - let ttl_ms = sched_end.saturating_sub(now_ms); - let ttl = Duration::from_millis(ttl_ms); - - // 7. Push dans la playlist avec TTL - self.playlist_handle.push_with_ttl(pk.clone(), ttl).await?; - - tracing::info!( - "RadioParadisePlaylistFeeder: Added {} to playlist (pk={}, ttl={}s)", - song.title, - pk, - ttl.as_secs() - ); - - processed += 1; - } - - tracing::info!( - "RadioParadisePlaylistFeeder: Processed block {} - added {} songs to playlist", - event_id, - processed - ); - - Ok(()) - } - - /// Sauvegarde les métadonnées dans le cache audio - async fn save_metadata( - &self, - pk: &str, - song: &crate::models::Song, - block: &crate::models::Block, - ) -> Result<()> { - use pmoaudiocache::AudioTrackMetadataExt; - - let metadata = self.audio_cache.track_metadata(pk); - let mut meta = metadata.write().await; - - // Métadonnées de base - meta.set_title(Some(song.title.clone())).await?; - meta.set_artist(Some(song.artist.clone())).await?; - if let Some(ref album) = song.album { - meta.set_album(Some(album.clone())).await?; - } - if let Some(year) = song.year { - meta.set_year(Some(year)).await?; - } - - // Cover - if let Some(ref cover_large) = song.cover_large { - if let Some(cover_url) = block.cover_url(cover_large) { - meta.set_cover_url(Some(cover_url.clone())).await?; - - // Télécharger la cover - match self - .covers_cache - .add_from_url(&cover_url, self.collection.as_deref()) - .await - { - Ok(cover_pk) => { - meta.set_cover_pk(Some(cover_pk)).await?; - tracing::debug!( - "RadioParadisePlaylistFeeder: Cached cover for {}", - song.title - ); - } - Err(e) => { - tracing::warn!("RadioParadisePlaylistFeeder: Failed to cache cover: {}", e); - } - } - } - } - - Ok(()) - } -} --------End of pmoparadise/src/playlist_feeder.rs --------- - ------------- pmoparadise/src/pmoserver_ext.rs ---------- -//! Extension pmoserver pour Radio Paradise -//! -//! Ce module fournit un trait d'extension pour ajouter facilement l'API Radio Paradise -//! à un serveur pmoserver. - -use crate::channels::{max_channel_id, ChannelDescriptor, ALL_CHANNELS}; -use crate::{Block, NowPlaying, RadioParadiseClient}; -use async_trait::async_trait; -use axum::{ - extract::{Path, Query, State}, - http::StatusCode, - routing::get, - Json, Router, -}; -use serde::{Deserialize, Serialize}; -use std::sync::Arc; -use tokio::sync::RwLock; -use utoipa::{OpenApi, ToSchema}; - -/// État partagé pour l'API Radio Paradise -#[derive(Clone)] -pub struct RadioParadiseState { - client: Arc>, -} - -#[derive(Debug, Default, Deserialize)] -#[serde(default)] -struct ParadiseQuery { - channel: Option, -} - -impl RadioParadiseState { - pub async fn new() -> anyhow::Result { - let client = RadioParadiseClient::new() - .await - .map_err(|e| anyhow::anyhow!("Failed to create RadioParadise client: {}", e))?; - - Ok(Self { - client: Arc::new(RwLock::new(client)), - }) - } - - async fn client_for_params( - &self, - params: &ParadiseQuery, - ) -> Result { - let base_client = { - let client_guard = self.client.read().await; - client_guard.clone() - }; - - let mut client = base_client; - - if let Some(channel) = params.channel { - if channel > max_channel_id() { - tracing::warn!("Invalid Radio Paradise channel requested: {}", channel); - return Err(StatusCode::BAD_REQUEST); - } - client = client.clone_with_channel(channel); - } - - Ok(client) - } -} - -/// Information sur un canal Radio Paradise -#[derive(Debug, Clone, Serialize, Deserialize, ToSchema)] -pub struct ChannelInfo { - /// ID du canal (0-3) - pub id: u8, - /// Nom du canal - pub name: String, - /// Description - pub description: String, -} - -impl From<&ChannelDescriptor> for ChannelInfo { - fn from(descriptor: &ChannelDescriptor) -> Self { - Self { - id: descriptor.id, - name: descriptor.display_name.to_string(), - description: descriptor.description.to_string(), - } - } -} - -/// Réponse avec informations étendues sur le morceau en cours -#[derive(Debug, Clone, Serialize, ToSchema)] -pub struct NowPlayingResponse { - /// Event ID du block actuel - pub event: u64, - /// Event ID du prochain block - pub end_event: u64, - /// URL de streaming du block - pub stream_url: String, - /// Durée totale du block en ms - pub block_length_ms: u64, - /// Index du morceau actuel - pub current_song_index: Option, - /// Morceau actuel - pub current_song: Option, - /// Tous les morceaux du block - pub songs: Vec, -} - -/// Information sur un morceau -#[derive(Debug, Clone, Serialize, ToSchema)] -pub struct SongInfo { - /// Index dans le block - pub index: usize, - /// Artiste - pub artist: String, - /// Titre - pub title: String, - /// Album - pub album: String, - /// Année - pub year: Option, - /// Temps écoulé depuis le début du block (ms) - pub elapsed_ms: u64, - /// Durée du morceau (ms) - pub duration_ms: u64, - /// URL de la pochette - pub cover_url: Option, - /// Note (0-10) - pub rating: Option, -} - -/// Réponse pour un block -#[derive(Debug, Clone, Serialize, ToSchema)] -pub struct BlockResponse { - /// Event ID du block - pub event: u64, - /// Event ID du prochain block - pub end_event: u64, - /// URL de streaming - pub url: String, - /// Durée totale (ms) - pub length_ms: u64, - /// Morceaux du block - pub songs: Vec, -} - -/// Réponse pour l'URL de streaming -#[derive(Debug, Clone, Serialize, ToSchema)] -pub struct StreamUrlResponse { - /// Event ID du block - #[schema(example = 1234567)] - pub event: u64, - /// URL de streaming FLAC - #[schema(example = "https://apps.radioparadise.com/blocks/chan/0/4/1234567-1234580.flac")] - pub stream_url: String, - /// Durée totale (ms) - #[schema(example = 900000)] - pub length_ms: u64, -} - -/// Réponse pour l'URL de pochette -#[derive(Debug, Clone, Serialize, ToSchema)] -pub struct CoverUrlResponse { - /// Event ID du block - #[schema(example = 1234567)] - pub event: u64, - /// Index du morceau - #[schema(example = 0)] - pub song_index: usize, - /// URL de la pochette (résolution complète) - #[schema(example = "https://img.radioparadise.com/covers/l/B00000I0JF.jpg")] - pub cover_url: Option, - /// Type de pochette: "cover" (petite) ou "cover_large" (grande) - #[schema(example = "cover_large")] - pub cover_type: String, -} - -impl From for BlockResponse { - fn from(block: Block) -> Self { - let songs = block - .songs_ordered() - .into_iter() - .map(|(index, song)| SongInfo { - index, - artist: song.artist.clone(), - title: song.title.clone(), - album: song.album.clone().unwrap_or_default(), - year: song.year, - elapsed_ms: song.elapsed, - duration_ms: song.duration, - cover_url: song.cover.as_ref().and_then(|c| block.cover_url(c)), - rating: song.rating, - }) - .collect(); - - Self { - event: block.event, - end_event: block.end_event, - url: block.url, - length_ms: block.length, - songs, - } - } -} - -impl From for NowPlayingResponse { - fn from(np: NowPlaying) -> Self { - let songs: Vec = np - .block - .songs_ordered() - .into_iter() - .map(|(index, song)| SongInfo { - index, - artist: song.artist.clone(), - title: song.title.clone(), - album: song.album.clone().unwrap_or_default(), - year: song.year, - elapsed_ms: song.elapsed, - duration_ms: song.duration, - cover_url: song.cover.as_ref().and_then(|c| np.block.cover_url(c)), - rating: song.rating, - }) - .collect(); - - let current_song = np.current_song.as_ref().and_then(|song| { - let index = np.current_song_index?; - Some(SongInfo { - index, - artist: song.artist.clone(), - title: song.title.clone(), - album: song.album.clone().unwrap_or_default(), - year: song.year, - elapsed_ms: song.elapsed, - duration_ms: song.duration, - cover_url: song.cover.as_ref().and_then(|c| np.block.cover_url(c)), - rating: song.rating, - }) - }); - - Self { - event: np.block.event, - end_event: np.block.end_event, - stream_url: np.block.url, - block_length_ms: np.block.length, - current_song_index: np.current_song_index, - current_song, - songs, - } - } -} - -/// GET /now-playing - Récupère le morceau en cours -#[utoipa::path( - get, - path = "/now-playing", - params( - ("channel" = Option, Query, description = "Channel ID (0-3)") - ), - responses( - (status = 200, description = "Morceau en cours", body = NowPlayingResponse), - (status = 500, description = "Erreur serveur") - ), - tag = "Radio Paradise" -)] -async fn get_now_playing( - State(state): State, - Query(params): Query, -) -> Result, StatusCode> { - let client = state.client_for_params(¶ms).await?; - let now_playing = client.now_playing().await.map_err(|e| { - tracing::error!("Failed to fetch now playing from Radio Paradise: {}", e); - StatusCode::INTERNAL_SERVER_ERROR - })?; - - Ok(Json(now_playing.into())) -} - -/// GET /block/current - Récupère le block actuel -#[utoipa::path( - get, - path = "/block/current", - params( - ("channel" = Option, Query, description = "Channel ID (0-3)") - ), - responses( - (status = 200, description = "Block actuel", body = BlockResponse), - (status = 500, description = "Erreur serveur") - ), - tag = "Radio Paradise" -)] -async fn get_current_block( - State(state): State, - Query(params): Query, -) -> Result, StatusCode> { - let client = state.client_for_params(¶ms).await?; - let block = client.get_block(None).await.map_err(|e| { - tracing::error!("Failed to fetch current block from Radio Paradise: {}", e); - StatusCode::INTERNAL_SERVER_ERROR - })?; - - Ok(Json(block.into())) -} - -/// GET /block/{event_id} - Récupère un block spécifique -#[utoipa::path( - get, - path = "/block/{event_id}", - params( - ("event_id" = u64, Path, description = "Event ID du block"), - ("channel" = Option, Query, description = "Channel ID (0-3)") - ), - responses( - (status = 200, description = "Block demandé", body = BlockResponse), - (status = 500, description = "Erreur serveur") - ), - tag = "Radio Paradise" -)] -async fn get_block_by_id( - State(state): State, - Path(event_id): Path, - Query(params): Query, -) -> Result, StatusCode> { - let client = state.client_for_params(¶ms).await?; - let block = client.get_block(Some(event_id)).await.map_err(|e| { - tracing::error!( - "Failed to fetch block {} from Radio Paradise: {}", - event_id, - e - ); - StatusCode::INTERNAL_SERVER_ERROR - })?; - - Ok(Json(block.into())) -} - -/// GET /channels - Liste les canaux disponibles -#[utoipa::path( - get, - path = "/channels", - responses( - (status = 200, description = "Liste des canaux", body = Vec) - ), - tag = "Radio Paradise" -)] -async fn get_channels() -> Json> { - let channels: Vec = ALL_CHANNELS.iter().map(Into::into).collect(); - Json(channels) -} - -/// GET /block/{event_id}/song/{index} - Récupère un morceau spécifique d'un block -#[utoipa::path( - get, - path = "/block/{event_id}/song/{index}", - params( - ("event_id" = u64, Path, description = "Event ID du block"), - ("index" = usize, Path, description = "Index du morceau (0-based)"), - ("channel" = Option, Query, description = "Channel ID (0-3)") - ), - responses( - (status = 200, description = "Morceau demandé", body = SongInfo), - (status = 404, description = "Morceau non trouvé"), - (status = 500, description = "Erreur serveur") - ), - tag = "Radio Paradise" -)] -async fn get_song_by_index( - State(state): State, - Path((event_id, index)): Path<(u64, usize)>, - Query(params): Query, -) -> Result, StatusCode> { - let client = state.client_for_params(¶ms).await?; - let block = client.get_block(Some(event_id)).await.map_err(|e| { - tracing::error!( - "Failed to fetch block {} from Radio Paradise: {}", - event_id, - e - ); - StatusCode::INTERNAL_SERVER_ERROR - })?; - - let song = block.get_song(index).ok_or_else(|| { - tracing::warn!("Song index {} not found in block {}", index, event_id); - StatusCode::NOT_FOUND - })?; - - let song_info = SongInfo { - index, - artist: song.artist.clone(), - title: song.title.clone(), - album: song.album.clone().unwrap_or_default(), - year: song.year, - elapsed_ms: song.elapsed, - duration_ms: song.duration, - cover_url: song.cover.as_ref().and_then(|c| block.cover_url(c)), - rating: song.rating, - }; - - Ok(Json(song_info)) -} - -/// GET /cover-url/{event_id}/{song_index} - Récupère l'URL de la pochette d'un morceau -/// -/// Utilise automatiquement cover_large si disponible, sinon cover en fallback -#[utoipa::path( - get, - path = "/cover-url/{event_id}/{song_index}", - params( - ("event_id" = u64, Path, description = "Event ID du block"), - ("song_index" = usize, Path, description = "Index du morceau (0-based)"), - ("channel" = Option, Query, description = "Channel ID (0-3)") - ), - responses( - (status = 200, description = "URL de la pochette avec fallback automatique", body = CoverUrlResponse), - (status = 404, description = "Morceau non trouvé"), - (status = 500, description = "Erreur serveur") - ), - tag = "Radio Paradise" -)] -async fn get_cover_url( - State(state): State, - Path((event_id, song_index)): Path<(u64, usize)>, - Query(params): Query, -) -> Result, StatusCode> { - let client = state.client_for_params(¶ms).await?; - let block = client.get_block(Some(event_id)).await.map_err(|e| { - tracing::error!( - "Failed to fetch block {} from Radio Paradise: {}", - event_id, - e - ); - StatusCode::INTERNAL_SERVER_ERROR - })?; - - let song = block.get_song(song_index).ok_or_else(|| { - tracing::warn!("Song index {} not found in block {}", song_index, event_id); - StatusCode::NOT_FOUND - })?; - - // Fallback: cover_large → cover → none - let (cover_url, cover_type) = if let Some(ref cover_large) = song.cover_large { - (block.cover_url(cover_large), "cover_large") - } else if let Some(ref cover) = song.cover { - (block.cover_url(cover), "cover") - } else { - (None, "none") - }; - - Ok(Json(CoverUrlResponse { - event: event_id, - song_index, - cover_url, - cover_type: cover_type.to_string(), - })) -} - -/// GET /stream-url/{event_id} - Récupère l'URL de streaming direct d'un block -#[utoipa::path( - get, - path = "/stream-url/{event_id}", - params( - ("event_id" = u64, Path, description = "Event ID du block (None pour le block actuel)"), - ("channel" = Option, Query, description = "Channel ID (0-3)") - ), - responses( - (status = 200, description = "URL de streaming", body = StreamUrlResponse), - (status = 500, description = "Erreur serveur") - ), - tag = "Radio Paradise" -)] -async fn get_stream_url( - State(state): State, - Path(event_id): Path, - Query(params): Query, -) -> Result, StatusCode> { - let client = state.client_for_params(¶ms).await?; - let block = client.get_block(Some(event_id)).await.map_err(|e| { - tracing::error!( - "Failed to fetch block {} from Radio Paradise: {}", - event_id, - e - ); - StatusCode::INTERNAL_SERVER_ERROR - })?; - - Ok(Json(StreamUrlResponse { - event: block.event, - stream_url: block.url, - length_ms: block.length, - })) -} - -/// Documentation OpenAPI pour l'API Radio Paradise -#[derive(OpenApi)] -#[openapi( - info( - title = "Radio Paradise API", - version = "1.0.0", - description = r#" -# API REST pour Radio Paradise - -Cette API permet d'accéder aux métadonnées et flux de Radio Paradise. - -## Fonctionnalités - -- **Métadonnées en temps réel** : Récupération du morceau en cours et des blocks -- **Multi-canaux** : Support des 4 canaux Radio Paradise (Main, Mellow, Rock, Eclectic) -- **Streaming FLAC** : Accès direct aux URLs de streaming haute qualité -- **Pochettes d'albums** : URLs complètes des couvertures (petite et grande taille) -- **Historique** : Accès aux blocks passés via event_id - -## Canaux disponibles - -- **0: Main Mix** - Eclectic mix of rock, world, electronica, and more -- **1: Mellow Mix** - Mellower, less aggressive music -- **2: Rock Mix** - Heavier, more guitar-driven music -- **3: Eclectic Mix** - Curated worldwide selection - -## Format des données - -### Blocks -Les blocks sont des fichiers FLAC continus contenant plusieurs morceaux. -Chaque block a un `event` (ID de début) et `end_event` (ID du prochain block). - -### Timing -- Tous les temps sont en millisecondes (ms) -- `elapsed_ms` : temps écoulé depuis le début du block -- `duration_ms` : durée du morceau - -## Exemples d'utilisation - -### Récupérer le morceau en cours -``` -GET /api/radioparadise/now-playing?channel=0 -``` - -### Récupérer un block spécifique -``` -GET /api/radioparadise/block/1234567?channel=0 -``` - -### Récupérer la pochette d'un morceau (avec fallback automatique) -``` -GET /api/radioparadise/cover-url/1234567/0?channel=0 -``` - "# - ), - paths( - get_now_playing, - get_current_block, - get_block_by_id, - get_channels, - get_song_by_index, - get_cover_url, - get_stream_url - ), - components(schemas( - NowPlayingResponse, - BlockResponse, - SongInfo, - ChannelInfo, - StreamUrlResponse, - CoverUrlResponse - )), - tags( - (name = "Radio Paradise", description = "Endpoints pour Radio Paradise") - ) -)] -pub struct RadioParadiseApiDoc; - -/// Crée le router pour l'API Radio Paradise -pub fn create_api_router(state: RadioParadiseState) -> Router { - Router::new() - .route("/now-playing", get(get_now_playing)) - .route("/block/current", get(get_current_block)) - .route("/block/{event_id}", get(get_block_by_id)) - .route("/block/{event_id}/song/{index}", get(get_song_by_index)) - .route("/cover-url/{event_id}/{song_index}", get(get_cover_url)) - .route("/stream-url/{event_id}", get(get_stream_url)) - .route("/channels", get(get_channels)) - .with_state(state) -} - -/// Trait d'extension pour pmoserver::Server -/// -/// Permet d'initialiser Radio Paradise avec routes HTTP complètes -#[cfg(feature = "pmoserver")] -#[async_trait] -pub trait RadioParadiseExt { - /// Initialise l'API Radio Paradise - /// - /// # Routes créées - /// - /// - API: `/api/radioparadise/*` - /// - `/now-playing` - /// - `/block/*` - /// - `/channels` - /// - Swagger: `/swagger-ui/radioparadise` - async fn init_radioparadise(&mut self) -> anyhow::Result; -} - -#[cfg(feature = "pmoserver")] -#[async_trait] -impl RadioParadiseExt for pmoserver::Server { - async fn init_radioparadise(&mut self) -> anyhow::Result { - let state = RadioParadiseState::new().await?; - - // Créer le router API - let api_router = create_api_router(state.clone()); - - // L'enregistrer avec OpenAPI - self.add_openapi(api_router, RadioParadiseApiDoc::openapi(), "radioparadise") - .await; - - Ok(state) - } -} --------End of pmoparadise/src/pmoserver_ext.rs --------- - ------------- pmoparadise/src/radio_paradise_stream_source.rs ---------- -//! RadioParadiseStreamSource - Node audio pmoaudio pour Radio Paradise -//! -//! Ce node télécharge et décode les blocs FLAC de Radio Paradise en streaming, -//! avec insertion automatique des TrackBoundary au bon timing. - -use crate::{ - client::RadioParadiseClient, - models::{Block, EventId, Song}, - node_stats::NodeStats, -}; -use futures_util::StreamExt; -use pmoaudio::{ - nodes::{AudioError, TypedAudioNode, DEFAULT_CHUNK_DURATION_MS}, - pipeline::{send_to_children, send_to_children_with_timing, Node, NodeLogic}, - type_constraints::TypeRequirement, - AudioPipelineNode, AudioSegment, SyncMarker, I24, -}; -use pmoflac::decode_audio_stream; -use pmometadata::{MemoryTrackMetadata, TrackMetadata}; -use std::{ - collections::VecDeque, - sync::{Arc, Mutex}, - time::{Duration, Instant}, -}; -use tokio::io::AsyncReadExt; -use tokio::sync::{mpsc, Notify, RwLock}; -use tokio_util::{io::StreamReader, sync::CancellationToken}; - -/// Signal spécial pour indiquer qu'il n'y aura plus de blocs -/// Quand ce blockid est poussé dans la queue, le source termine proprement -/// après avoir fini de traiter le bloc en cours -pub const END_OF_BLOCKS_SIGNAL: EventId = EventId::MAX; - -/// Nombre de blocs récents à mémoriser pour éviter les re-téléchargements -const RECENT_BLOCKS_CACHE_SIZE: usize = 10; - -/// Handle pour alimenter la queue de blocs pendant que la source tourne. -#[derive(Clone, Default)] -pub struct BlockQueueHandle { - queue: Arc>>, - notify: Arc, -} - -impl BlockQueueHandle { - fn new() -> Self { - Self { - queue: Arc::new(Mutex::new(VecDeque::new())), - notify: Arc::new(Notify::new()), - } - } - - /// Enfile un block pour traitement. - pub fn enqueue(&self, event_id: EventId) { - { - let mut queue = self.queue.lock().expect("block queue poisoned"); - queue.push_back(event_id); - } - self.notify.notify_one(); - } - - /// Retire le prochain block s'il existe. - fn pop(&self) -> Option { - let mut queue = self.queue.lock().expect("block queue poisoned"); - queue.pop_front() - } - - /// Nombre d'éléments en attente. - pub fn len(&self) -> usize { - let queue = self.queue.lock().expect("block queue poisoned"); - queue.len() - } - - fn snapshot(&self) -> Vec { - let queue = self.queue.lock().expect("block queue poisoned"); - queue.iter().copied().collect() - } - - fn front(&self) -> Option { - let queue = self.queue.lock().expect("block queue poisoned"); - queue.front().copied() - } - - fn back(&self) -> Option { - let queue = self.queue.lock().expect("block queue poisoned"); - queue.back().copied() - } -} - -// ═══════════════════════════════════════════════════════════════════════════ -// RadioParadiseStreamSourceLogic - Logique métier pure -// ═══════════════════════════════════════════════════════════════════════════ - -/// Logique pure de téléchargement et décodage des blocs Radio Paradise -pub struct RadioParadiseStreamSourceLogic { - client: RadioParadiseClient, - chunk_frames: usize, - recent_blocks: VecDeque, - block_queue: BlockQueueHandle, - stats: Arc, -} - -impl RadioParadiseStreamSourceLogic { - pub fn new(client: RadioParadiseClient, chunk_duration_ms: u32) -> Self { - let handle = BlockQueueHandle::new(); - Self::with_queue(client, chunk_duration_ms, handle) - } - - fn with_queue( - client: RadioParadiseClient, - chunk_duration_ms: u32, - block_queue: BlockQueueHandle, - ) -> Self { - // Calculer chunk_frames pour la durée cible (on suppose 44.1kHz) - let chunk_frames = ((chunk_duration_ms as f64 / 1000.0) * 44100.0) as usize; - - Self { - client, - chunk_frames, - recent_blocks: VecDeque::with_capacity(RECENT_BLOCKS_CACHE_SIZE), - block_queue, - stats: NodeStats::new("RadioParadiseStreamSource"), - } - } - - /// Ajoute un block ID à la file d'attente - pub fn push_block_id(&self, event_id: EventId) { - self.block_queue.enqueue(event_id); - } - - /// Vérifie si un bloc a été téléchargé récemment - fn is_recent_block(&self, event_id: EventId) -> bool { - self.recent_blocks.contains(&event_id) - } - - /// Marque un bloc comme récemment téléchargé (FIFO) - fn mark_block_downloaded(&mut self, event_id: EventId) { - // Retirer tous les éléments excédentaires (garantit <= CACHE_SIZE) - while self.recent_blocks.len() >= RECENT_BLOCKS_CACHE_SIZE { - self.recent_blocks.pop_front(); - } - - // Puis ajouter le nouveau bloc - self.recent_blocks.push_back(event_id); - } - - /// Télécharge et décode un bloc FLAC - /// Retourne (timestamp_final, instant_debut) pour permettre le timing correct - async fn download_and_decode_block( - &mut self, - block: &Block, - output: &[mpsc::Sender>], - stop_token: &CancellationToken, - order: &mut u64, - ) -> Result<(f64, Instant), AudioError> { - // Télécharger le FLAC - tracing::info!( - "Sending HTTP GET request for block FLAC (expected duration: {:.1}min, url: {})", - block.length as f64 / 60000.0, - block.url - ); - let response = self - .client - .client - .get(&block.url) - .timeout(self.client.block_timeout) - .send() - .await - .map_err(|e| AudioError::ProcessingError(format!("Block download failed: {}", e)))?; - - tracing::debug!("HTTP response received, status={}", response.status()); - if !response.status().is_success() { - return Err(AudioError::ProcessingError(format!( - "Block download returned status {}", - response.status() - ))); - } - - // Vérifier la taille du contenu si disponible - if let Some(content_length) = response.content_length() { - tracing::info!( - "HTTP Content-Length: {} bytes ({:.1} MB)", - content_length, - content_length as f64 / 1_048_576.0 - ); - } else { - tracing::warn!("HTTP response has no Content-Length header"); - } - - // Créer un stream reader - tracing::debug!("Creating byte stream reader"); - let byte_stream = response - .bytes_stream() - .map(|result| result.map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e))); - let stream_reader = StreamReader::new(byte_stream); - tracing::debug!("Stream reader created"); - - // Décoder le FLAC - tracing::debug!("Decoding FLAC stream..."); - let mut decoder = decode_audio_stream(stream_reader) - .await - .map_err(|e| AudioError::ProcessingError(format!("FLAC decode failed: {}", e)))?; - - let stream_info = decoder.info().clone(); - let sample_rate = stream_info.sample_rate; - let bits_per_sample = stream_info.bits_per_sample; - tracing::debug!( - "FLAC decoder initialized: {}Hz, {} bits/sample", - sample_rate, - bits_per_sample - ); - - // Préparer les songs ordonnées pour tracking - let songs = block.songs_ordered(); - let mut song_index = 0; - let mut total_samples = 0u64; - tracing::debug!("Block has {} songs", songs.len()); - - // Noter l'instant de début AVANT d'envoyer TopZeroSync - // Ceci permet de synchroniser la durée réelle du bloc - let start_instant = Instant::now(); - - // Envoyer TopZeroSync au début du bloc - tracing::debug!("Sending TopZeroSync to {} outputs", output.len()); - let top_zero = Arc::new(AudioSegment { - order: *order, - timestamp_sec: 0.0, - segment: pmoaudio::_AudioSegment::Sync(Arc::new(SyncMarker::TopZeroSync)), - }); - self.send_to_children(output, top_zero).await?; - tracing::debug!("TopZeroSync sent"); - - // Envoyer TrackBoundary pour la première song AVANT le premier chunk audio - // Même si son elapsed > 0, cela garantit que FlacCacheSink a des métadonnées - // dès le début (sinon il attendrait indéfiniment un TrackBoundary) - let mut next_song: Option<(usize, &Song)> = if let Some((idx, song)) = songs.get(0).copied() - { - tracing::debug!( - "Sending TrackBoundary for first song (idx={}, elapsed={}ms) at timestamp 0", - idx, - song.elapsed - ); - let metadata = song_to_metadata(song, block).await; - let track_boundary = AudioSegment::new_track_boundary( - *order, 0.0, // timestamp = 0 au début du stream - metadata, - ); - self.send_to_children(output, track_boundary).await?; - song_index = 1; - // Le prochain TrackBoundary sera pour la deuxième song quand elapsed_ms >= song.elapsed - songs.get(1).copied() - } else { - None - }; - tracing::debug!("Starting audio chunk loop"); - - // Buffer pour lecture - let bytes_per_sample = (bits_per_sample / 8) as usize; - let frame_bytes = bytes_per_sample * 2; // stereo - let chunk_frames = self.chunk_frames; - let chunk_byte_len = chunk_frames * frame_bytes; - let mut read_buf = vec![0u8; chunk_byte_len * 2]; - let mut pending: Vec = Vec::with_capacity(chunk_byte_len * 2); - - // Traiter les chunks audio - let mut chunk_count = 0; - let mut total_bytes_decoded = 0u64; - let expected_duration_sec = block.length as f64 / 1000.0; - let mut stats_last_log = Instant::now(); - - loop { - // Vérifier stop_token - if stop_token.is_cancelled() { - // Retourner le timestamp actuel et start_instant si on est interrompu - let current_timestamp = total_samples as f64 / sample_rate as f64; - tracing::warn!( - "Block decode CANCELLED: sent {} chunks, {:.2}s duration ({:.1}% of expected {:.2}s), decoded {} bytes", - chunk_count, current_timestamp, - (current_timestamp / expected_duration_sec) * 100.0, - expected_duration_sec, total_bytes_decoded - ); - return Ok((current_timestamp, start_instant)); - } - - // Remplir le buffer - if pending.len() < chunk_byte_len { - let read = decoder - .read(&mut read_buf) - .await - .map_err(|e| AudioError::ProcessingError(format!("Read error: {}", e)))?; - - if read == 0 { - let actual_duration = total_samples as f64 / sample_rate as f64; - let percentage = (actual_duration / expected_duration_sec) * 100.0; - - if percentage < 95.0 { - tracing::error!( - "FLAC decode EOF PREMATURE: sent {} chunks, {:.2}s actual vs {:.2}s expected ({:.1}%), decoded {} bytes", - chunk_count, actual_duration, expected_duration_sec, percentage, total_bytes_decoded - ); - } else { - tracing::info!( - "FLAC decode EOF reached: sent {} chunks, {:.2}s duration ({:.1}% of expected), decoded {} bytes", - chunk_count, actual_duration, percentage, total_bytes_decoded - ); - } - break; // EOF - } - total_bytes_decoded += read as u64; - pending.extend_from_slice(&read_buf[..read]); - } - - if pending.is_empty() { - break; - } - - // Extraire un chunk - let frames_in_pending = pending.len() / frame_bytes; - let frames_to_emit = frames_in_pending.min(chunk_frames); - let take_bytes = frames_to_emit * frame_bytes; - let pcm_data = pending.drain(..take_bytes).collect::>(); - - // Calculer le nombre de frames (samples par canal) - let bytes_per_sample = (bits_per_sample / 8) as usize; - let chunk_len = (pcm_data.len() / (bytes_per_sample * 2)) as u64; // 2 = stereo - - // Vérifier si on doit insérer un TrackBoundary avant ce chunk - if let Some((idx, song)) = next_song { - let elapsed_ms = (total_samples * 1000) / sample_rate as u64; - - if elapsed_ms >= song.elapsed { - // Envoyer TrackBoundary AVANT le chunk (avec le même order) - tracing::debug!( - "Sending TrackBoundary for song {} at elapsed_ms={} (song.elapsed={}, timestamp_sec={:.2})", - idx, elapsed_ms, song.elapsed, (total_samples as f64 / sample_rate as f64) - ); - let metadata = song_to_metadata(song, block).await; - let timestamp_sec = total_samples as f64 / sample_rate as f64; - let track_boundary = - AudioSegment::new_track_boundary(*order, timestamp_sec, metadata); - self.send_to_children(output, track_boundary).await?; - - // Passer à la song suivante - song_index += 1; - next_song = songs.get(song_index).copied(); - tracing::debug!( - "Moved to next song, song_index={}, next_song present={}", - song_index, - next_song.is_some() - ); - } - } - - // Envoyer le chunk audio - let timestamp_sec = total_samples as f64 / sample_rate as f64; - if stats_last_log.elapsed() >= Duration::from_secs(1) { - let real_elapsed = start_instant.elapsed().as_secs_f64(); - tracing::debug!( - "RP timing: chunk={} ts={:.3}s real_elapsed={:.3}s delta={:.3}s chunk_len={} frames", - chunk_count, - timestamp_sec, - real_elapsed, - timestamp_sec - real_elapsed, - chunk_len - ); - stats_last_log = Instant::now(); - } - let audio_segment = pcm_to_audio_segment( - &pcm_data, - *order, - timestamp_sec, - sample_rate, - bits_per_sample, - )?; - self.send_to_children(output, audio_segment).await?; - - *order += 1; - total_samples += chunk_len; - chunk_count += 1; - } - - // Retourner le timestamp du dernier chunk (durée totale du bloc) et l'instant de début - let final_timestamp = total_samples as f64 / sample_rate as f64; - tracing::debug!( - "Block decode complete: {} samples, {:.2}s duration", - total_samples, - final_timestamp - ); - - Ok((final_timestamp, start_instant)) - } - - /// Envoie un segment à tous les enfants - async fn send_to_children( - &self, - output: &[mpsc::Sender>], - segment: Arc, - ) -> Result<(), AudioError> { - let segment_ts = segment.timestamp_sec; - self.stats.record_segment_received(segment_ts); - - let segment_bytes = match &segment.segment { - pmoaudio::_AudioSegment::Chunk(chunk) => chunk.len() * 2 * 4, - _ => 0, - }; - - send_to_children_with_timing( - std::any::type_name::(), - output, - segment, - |i, send_duration, capacity_before| { - tracing::trace!( - "send_to_children: Sending to child {} (channel capacity={}, timestamp={:.3}s)", - i, - capacity_before, - segment_ts - ); - - if send_duration.as_millis() > 10 { - let duration_ms = send_duration.as_millis() as u64; - self.stats.record_backpressure(duration_ms); - tracing::trace!( - "send_to_children: Send to child {} BLOCKED for {:.3}s (channel capacity before send={}, timestamp={:.3}s)", - i, - send_duration.as_secs_f64(), - capacity_before, - segment_ts - ); - } - - self.stats.record_segment_sent(segment_bytes); - }, - ) - .await?; - Ok(()) - } -} - -/// Convertit PCM bytes en AudioSegment -fn pcm_to_audio_segment( - pcm_data: &[u8], - order: u64, - timestamp_sec: f64, - sample_rate: u32, - bits_per_sample: u8, -) -> Result, AudioError> { - use pmoaudio::{AudioChunk, AudioChunkData, _AudioSegment}; - - let bytes_per_sample = (bits_per_sample / 8) as usize; - let channels = 2; // Stereo - let frame_bytes = bytes_per_sample * channels; - let frames = pcm_data.len() / frame_bytes; - - // Valider que la taille des données est correcte - if pcm_data.len() % frame_bytes != 0 { - return Err(AudioError::ProcessingError(format!( - "Invalid PCM data size: {} bytes is not a multiple of frame size {} ({}bit, {} channels)", - pcm_data.len(), - frame_bytes, - bits_per_sample, - channels - ))); - } - - let chunk = match bits_per_sample { - 16 => { - // Type I16 - let mut stereo = Vec::with_capacity(frames); - for frame_idx in 0..frames { - let base = frame_idx * frame_bytes; - let left = i16::from_le_bytes([pcm_data[base], pcm_data[base + 1]]); - let right = i16::from_le_bytes([pcm_data[base + 2], pcm_data[base + 3]]); - stereo.push([left, right]); - } - let chunk_data = AudioChunkData::new(stereo, sample_rate, 0.0); - AudioChunk::I16(chunk_data) - } - 24 => { - // Type I24 avec sign extension correcte - let mut stereo = Vec::with_capacity(frames); - for frame_idx in 0..frames { - let base = frame_idx * frame_bytes; - - // Left channel (bytes 0,1,2) avec sign extension - let left_i32 = { - let mut buf = [0u8; 4]; - buf[..3].copy_from_slice(&pcm_data[base..base + 3]); - // Sign extend si négatif - if pcm_data[base + 2] & 0x80 != 0 { - buf[3] = 0xFF; - } - i32::from_le_bytes(buf) - }; - let left = I24::new(left_i32).ok_or_else(|| { - AudioError::ProcessingError(format!("Invalid I24 value: {}", left_i32)) - })?; - - // Right channel (bytes 3,4,5) avec sign extension - let right_i32 = { - let mut buf = [0u8; 4]; - buf[..3].copy_from_slice(&pcm_data[base + 3..base + 6]); - // Sign extend si négatif - if pcm_data[base + 5] & 0x80 != 0 { - buf[3] = 0xFF; - } - i32::from_le_bytes(buf) - }; - let right = I24::new(right_i32).ok_or_else(|| { - AudioError::ProcessingError(format!("Invalid I24 value: {}", right_i32)) - })?; - - stereo.push([left, right]); - } - let chunk_data = AudioChunkData::new(stereo, sample_rate, 0.0); - AudioChunk::I24(chunk_data) - } - 32 => { - // Type I32 - let mut stereo = Vec::with_capacity(frames); - for frame_idx in 0..frames { - let base = frame_idx * frame_bytes; - let left = i32::from_le_bytes([ - pcm_data[base], - pcm_data[base + 1], - pcm_data[base + 2], - pcm_data[base + 3], - ]); - let right = i32::from_le_bytes([ - pcm_data[base + 4], - pcm_data[base + 5], - pcm_data[base + 6], - pcm_data[base + 7], - ]); - stereo.push([left, right]); - } - let chunk_data = AudioChunkData::new(stereo, sample_rate, 0.0); - AudioChunk::I32(chunk_data) - } - _ => { - return Err(AudioError::ProcessingError(format!( - "Unsupported bit depth: {}", - bits_per_sample - ))) - } - }; - - Ok(Arc::new(AudioSegment { - order, - timestamp_sec, - segment: _AudioSegment::Chunk(Arc::new(chunk)), - })) -} - -/// Convertit Song en TrackMetadata -/// -/// Configure toutes les métadonnées de manière asynchrone et attend que la configuration -/// soit terminée avant de retourner, garantissant que les métadonnées (y compris cover_url) -/// sont disponibles immédiatement pour les nodes suivants -async fn song_to_metadata(song: &Song, block: &Block) -> Arc> { - let metadata = MemoryTrackMetadata::new(); - let metadata_arc = Arc::new(RwLock::new(metadata)) as Arc>; - - // Cloner les données - let title = song.title.clone(); - let artist = song.artist.clone(); - let album = song.album.clone(); - let year = song.year; - let cover_url = song.cover.as_ref().and_then(|cover| block.cover_url(cover)); - - // Configurer les métadonnées de manière synchrone (mais async await) - { - let mut meta = metadata_arc.write().await; - - // Ces méthodes peuvent échouer (retournent Result), donc on log les erreurs - if let Err(e) = meta.set_title(Some(title)).await { - tracing::warn!("Failed to set title: {}", e); - } - if let Err(e) = meta.set_artist(Some(artist)).await { - tracing::warn!("Failed to set artist: {}", e); - } - if let Some(album) = album { - if let Err(e) = meta.set_album(Some(album)).await { - tracing::warn!("Failed to set album: {}", e); - } - } - if let Some(year) = year { - if let Err(e) = meta.set_year(Some(year)).await { - tracing::warn!("Failed to set year: {}", e); - } - } - if let Some(ref url) = cover_url { - tracing::debug!("RadioParadiseStreamSource: Setting cover_url to: {}", url); - if let Err(e) = meta.set_cover_url(Some(url.clone())).await { - tracing::warn!("Failed to set cover_url: {}", e); - } else { - tracing::debug!("RadioParadiseStreamSource: Successfully set cover_url"); - } - } else { - tracing::debug!("RadioParadiseStreamSource: No cover URL available for song"); - } - } - - metadata_arc -} - -#[async_trait::async_trait] -impl NodeLogic for RadioParadiseStreamSourceLogic { - async fn process( - &mut self, - _input: Option>>, - output: Vec>>, - stop_token: CancellationToken, - ) -> Result<(), AudioError> { - tracing::debug!( - "RadioParadiseStreamSource::process() started, block_queue has {} items", - self.block_queue.len() - ); - for (i, event_id) in self.block_queue.snapshot().iter().enumerate() { - tracing::debug!(" block_queue[{}] = {}", i, event_id); - } - - let mut order = 0u64; - let mut last_timestamp = 0.0; - let mut last_start_instant: Option = None; - - loop { - // Attendre un block ID depuis la queue (pas de timeout - mode idle) - tracing::debug!("Waiting for block_id from queue (idle mode, no timeout)..."); - let event_id = loop { - // Vérifier d'abord le stop_token - if stop_token.is_cancelled() { - tracing::info!("Stop token cancelled while waiting for block_id"); - break None; - } - - // Essayer de pop un event_id - if let Some(id) = self.block_queue.pop() { - tracing::debug!("Got event_id {} from queue", id); - - // Vérifier si c'est le signal de fin - if id == END_OF_BLOCKS_SIGNAL { - tracing::info!( - "Received END_OF_BLOCKS_SIGNAL, finishing after current block" - ); - break None; - } - - break Some(id); - } - - tracing::trace!("block_queue is empty, waiting for new events..."); - tokio::select! { - _ = stop_token.cancelled() => break None, - _ = self.block_queue.notify.notified() => {}, - _ = tokio::time::sleep(Duration::from_millis(100)) => {} - }; - }; - - // Si on n'a pas d'event_id, on termine - let event_id = match event_id { - Some(id) => id, - None => { - tracing::info!("No more blocks to process, exiting loop"); - break; - } - }; - - // Vérifier si déjà téléchargé récemment - if self.is_recent_block(event_id) { - tracing::debug!("Block {} was recently downloaded, skipping", event_id); - continue; - } - - // Récupérer les métadonnées du bloc - tracing::debug!("Fetching block metadata for event_id {}...", event_id); - let block = - self.client.get_block(Some(event_id)).await.map_err(|e| { - AudioError::ProcessingError(format!("Failed to get block: {}", e)) - })?; - tracing::debug!("Block metadata received: url={}", block.url); - - // Marquer comme téléchargé - self.mark_block_downloaded(event_id); - - // Télécharger et décoder le bloc - tracing::info!("Starting download and decode for block {}...", event_id); - let (block_duration, start_instant) = self - .download_and_decode_block(&block, &output, &stop_token, &mut order) - .await?; - last_timestamp = block_duration; - last_start_instant = Some(start_instant); - tracing::info!( - "Finished download and decode for block {} (duration: {:.2}s)", - event_id, - block_duration - ); - } - - // Envoyer EndOfStream avec le timestamp du dernier chunk - tracing::info!( - "Sending EndOfStream with timestamp {:.2}s to {} outputs", - last_timestamp, - output.len() - ); - let eos = AudioSegment::new_end_of_stream(order, last_timestamp); - send_to_children(std::any::type_name::(), &output, eos).await?; - - // IMPORTANT: Attendre que tous les channels soient fermés par les enfants - // Cela garantit que tous les chunks (y compris ceux en attente dans les buffers MPSC) - // ont été traités avant que nous ne fermions notre bout - tracing::info!("Waiting for all child nodes to close their channels..."); - for (i, tx) in output.iter().enumerate() { - tracing::debug!("Waiting for child {} to close channel...", i); - tx.closed().await; - tracing::debug!("Child {} channel closed", i); - } - tracing::info!("All child channels closed, pipeline complete"); - - if let Some(start_instant) = last_start_instant { - let total_elapsed = start_instant.elapsed().as_secs_f64(); - tracing::info!( - "Block processing complete: duration={:.2}s, total_elapsed={:.2}s ({:.1}% of real-time)", - last_timestamp, total_elapsed, (total_elapsed / last_timestamp) * 100.0 - ); - } - - // Log des statistiques finales - tracing::info!("\n{}", self.stats.report()); - - Ok(()) - } -} - -// ═══════════════════════════════════════════════════════════════════════════ -// RadioParadiseStreamSource - Wrapper utilisant Node -// ═══════════════════════════════════════════════════════════════════════════ - -pub struct RadioParadiseStreamSource { - inner: Node, - block_handle: BlockQueueHandle, -} - -impl RadioParadiseStreamSource { - /// Crée une nouvelle source Radio Paradise avec durée de chunk par défaut - pub fn new(client: RadioParadiseClient) -> Self { - Self::with_chunk_duration(client, DEFAULT_CHUNK_DURATION_MS as u32) - } - - /// Crée une nouvelle source avec durée de chunk personnalisée - pub fn with_chunk_duration(client: RadioParadiseClient, chunk_duration_ms: u32) -> Self { - let handle = BlockQueueHandle::new(); - let logic = - RadioParadiseStreamSourceLogic::with_queue(client, chunk_duration_ms, handle.clone()); - Self { - inner: Node::new_source(logic), - block_handle: handle, - } - } - - /// Ajoute un block ID à la file d'attente de téléchargement - pub fn push_block_id(&self, event_id: EventId) { - self.block_handle.enqueue(event_id); - } - - /// Retourne un handle permettant d'enfiler des blocks dynamiquement. - pub fn block_handle(&self) -> BlockQueueHandle { - self.block_handle.clone() - } -} - -#[async_trait::async_trait] -impl AudioPipelineNode for RadioParadiseStreamSource { - fn get_tx(&self) -> Option>> { - self.inner.get_tx() - } - - fn register(&mut self, child: Box) { - self.inner.register(child); - } - - async fn run(self: Box, stop_token: CancellationToken) -> Result<(), AudioError> { - Box::new(self.inner).run(stop_token).await - } -} - -impl TypedAudioNode for RadioParadiseStreamSource { - fn input_type(&self) -> Option { - None // Source node - } - - fn output_type(&self) -> Option { - // Radio Paradise FLAC peut être 16-bit, 24-bit, ou 32-bit - // La profondeur est détectée automatiquement depuis le header FLAC - Some(TypeRequirement::any_integer()) - } -} - -#[cfg(test)] -mod tests { - use super::*; - - fn create_test_client() -> RadioParadiseClient { - RadioParadiseClient::with_client(reqwest::Client::new()) - } - - #[test] - fn test_cache_fifo_basic() { - let client = create_test_client(); - let mut logic = - RadioParadiseStreamSourceLogic::new(client, DEFAULT_CHUNK_DURATION_MS as u32); - - // Ajouter 5 blocs - for i in 1..=5 { - logic.mark_block_downloaded(i); - } - - // Vérifier que tous sont dans le cache - for i in 1..=5 { - assert!(logic.is_recent_block(i), "Block {} should be in cache", i); - } - assert_eq!(logic.recent_blocks.len(), 5); - } - - #[test] - fn test_cache_fifo_exactly_10_elements() { - let client = create_test_client(); - let mut logic = - RadioParadiseStreamSourceLogic::new(client, DEFAULT_CHUNK_DURATION_MS as u32); - - // Ajouter exactement 10 blocs - for i in 1..=10 { - logic.mark_block_downloaded(i); - } - - // Vérifier qu'on a exactement 10 éléments - assert_eq!( - logic.recent_blocks.len(), - 10, - "Cache should have exactly 10 elements" - ); - - // Tous devraient être dans le cache - for i in 1..=10 { - assert!(logic.is_recent_block(i), "Block {} should be in cache", i); - } - } - - #[test] - fn test_cache_fifo_eviction_oldest() { - let client = create_test_client(); - let mut logic = - RadioParadiseStreamSourceLogic::new(client, DEFAULT_CHUNK_DURATION_MS as u32); - - // Remplir le cache avec 10 éléments (1..=10) - for i in 1..=10 { - logic.mark_block_downloaded(i); - } - - // Ajouter un 11ème élément - logic.mark_block_downloaded(11); - - // Le cache doit toujours avoir 10 éléments - assert_eq!( - logic.recent_blocks.len(), - 10, - "Cache should still have 10 elements" - ); - - // Le premier (plus ancien) doit avoir été évincé - assert!( - !logic.is_recent_block(1), - "Oldest block (1) should be evicted" - ); - - // Les éléments 2..=11 doivent être présents - for i in 2..=11 { - assert!(logic.is_recent_block(i), "Block {} should be in cache", i); - } - } - - #[test] - fn test_cache_fifo_multiple_evictions() { - let client = create_test_client(); - let mut logic = - RadioParadiseStreamSourceLogic::new(client, DEFAULT_CHUNK_DURATION_MS as u32); - - // Remplir avec 10 éléments - for i in 1..=10 { - logic.mark_block_downloaded(i); - } - - // Ajouter 5 éléments supplémentaires - for i in 11..=15 { - logic.mark_block_downloaded(i); - } - - // Toujours 10 éléments - assert_eq!( - logic.recent_blocks.len(), - 10, - "Cache should have 10 elements" - ); - - // Les 5 premiers doivent avoir été évincés - for i in 1..=5 { - assert!(!logic.is_recent_block(i), "Block {} should be evicted", i); - } - - // Les éléments 6..=15 doivent être présents - for i in 6..=15 { - assert!(logic.is_recent_block(i), "Block {} should be in cache", i); - } - } - - #[test] - fn test_cache_never_exceeds_capacity() { - let client = create_test_client(); - let mut logic = - RadioParadiseStreamSourceLogic::new(client, DEFAULT_CHUNK_DURATION_MS as u32); - - // Vérifier la capacité pré-allouée - assert_eq!(logic.recent_blocks.capacity(), RECENT_BLOCKS_CACHE_SIZE); - - // Ajouter beaucoup d'éléments - for i in 1..=100 { - logic.mark_block_downloaded(i); - - // À chaque itération, vérifier qu'on ne dépasse jamais 10 - assert!( - logic.recent_blocks.len() <= RECENT_BLOCKS_CACHE_SIZE, - "Cache size {} exceeded max {}", - logic.recent_blocks.len(), - RECENT_BLOCKS_CACHE_SIZE - ); - } - - // Finalement, on doit avoir exactement 10 éléments - assert_eq!(logic.recent_blocks.len(), 10); - - // Ce doivent être les 10 derniers (91..=100) - for i in 91..=100 { - assert!(logic.is_recent_block(i), "Block {} should be in cache", i); - } - } - - #[test] - fn test_cache_fifo_order_preserved() { - let client = create_test_client(); - let mut logic = - RadioParadiseStreamSourceLogic::new(client, DEFAULT_CHUNK_DURATION_MS as u32); - - // Ajouter 10 éléments - for i in 1..=10 { - logic.mark_block_downloaded(i); - } - - // Vérifier l'ordre dans la VecDeque (le front devrait être le plus ancien) - let front = logic.recent_blocks.front().copied(); - assert_eq!(front, Some(1), "Front should be the oldest element"); - - let back = logic.recent_blocks.back().copied(); - assert_eq!(back, Some(10), "Back should be the newest element"); - } - - #[test] - fn test_block_queue_push() { - let client = create_test_client(); - let mut logic = - RadioParadiseStreamSourceLogic::new(client, DEFAULT_CHUNK_DURATION_MS as u32); - - // Tester push_block_id - logic.push_block_id(100); - logic.push_block_id(200); - logic.push_block_id(300); - - assert_eq!(logic.block_queue.len(), 3); - assert_eq!(logic.block_queue.front(), Some(100)); - assert_eq!(logic.block_queue.back(), Some(300)); - } -} --------End of pmoparadise/src/radio_paradise_stream_source.rs --------- - ------------- pmoparadise/src/source.rs ---------- -//! RadioParadiseSource - Implementation of MusicSource for Radio Paradise -//! -//! This module provides a UPnP ContentDirectory source for Radio Paradise, -//! exposing live streams and historical playlists for all 4 channels. - -use crate::channels::{ChannelDescriptor, ALL_CHANNELS}; -use pmosource::pmodidl::{Container, Item, Resource}; -use pmosource::{ - async_trait, AudioFormat, BrowseResult, MusicSource, MusicSourceError, Result, - SourceCapabilities, -}; -use std::fmt; -use std::sync::Arc; -use std::time::{Duration, Instant, SystemTime}; -use tokio::sync::RwLock; - -/// Default Radio Paradise image (embedded in binary) -const DEFAULT_IMAGE: &[u8] = include_bytes!("../assets/default.webp"); - -#[cfg(feature = "playlist")] -const LIVE_PLAYLIST_MIN_READY_ITEMS: usize = 5; -#[cfg(feature = "playlist")] -const LIVE_PLAYLIST_READY_TIMEOUT: Duration = Duration::from_secs(10); -#[cfg(feature = "playlist")] -const LIVE_PLAYLIST_READY_POLL: Duration = Duration::from_millis(200); - -/// RadioParadiseSource - UPnP ContentDirectory source for Radio Paradise -/// -/// Provides access to: -/// - Live FLAC streams for all 4 channels (Main, Mellow, Rock, Eclectic) -/// - Historical playlists (FIFO) for each channel -/// -/// # Object ID Schema -/// -/// - Root: `radio-paradise` -/// - Channel container: `radio-paradise:channel:{slug}` -/// - Live stream item: `radio-paradise:channel:{slug}:live` -/// - Live playlist container: `radio-paradise:channel:{slug}:liveplaylist` -/// - Live playlist track: `radio-paradise:channel:{slug}:liveplaylist:track:{pk}` -/// - History container: `radio-paradise:channel:{slug}:history` -/// - History track: `radio-paradise:channel:{slug}:history:track:{pk}` -#[derive(Clone)] -pub struct RadioParadiseSource { - /// Base URL for streaming server (e.g., "http://localhost:8080") - base_url: String, - /// Update counter for change notifications - update_counter: Arc>, - /// Last change timestamp - last_change: Arc>, - /// Tokens des callbacks enregistrés auprès du PlaylistManager - callback_tokens: Arc>>, - /// Notifier optionnel pour signaler les mises à jour de conteneurs au ContentDirectory - container_notifier: Option>, -} - -impl fmt::Debug for RadioParadiseSource { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - f.debug_struct("RadioParadiseSource") - .field("base_url", &self.base_url) - .finish_non_exhaustive() - } -} - -impl RadioParadiseSource { - /// Create a new RadioParadiseSource - /// - /// # Arguments - /// - /// * `base_url` - Base URL for streaming server (e.g., "http://localhost:8080") - /// - /// # Note - /// - /// With the "playlist" feature enabled, this source will use the global PlaylistManager - /// singleton to access history playlists. - pub fn new(base_url: impl Into) -> Self { - Self { - base_url: base_url.into(), - update_counter: Arc::new(RwLock::new(0)), - last_change: Arc::new(RwLock::new(SystemTime::now())), - callback_tokens: Arc::new(std::sync::Mutex::new(Vec::new())), - container_notifier: None, - } - } - - /// Injecte un notifier pour propager les changements de playlists vers le ContentDirectory - pub fn with_container_notifier( - mut self, - notifier: Arc, - ) -> Self { - self.container_notifier = Some(notifier); - self - } - - /// Build a live stream URL for a channel - fn build_live_url(&self, slug: &str) -> String { - format!("{}/radioparadise/stream/{}/flac", self.base_url, slug) - } - - /// Build an OGG-FLAC live stream URL for clients that support it - fn build_live_ogg_url(&self, slug: &str) -> String { - format!("{}/radioparadise/stream/{}/ogg", self.base_url, slug) - } - - /// Incrémente l'update_counter et met à jour last_change - async fn bump_update_counter(&self) { - { - let mut c = self.update_counter.write().await; - *c = c.wrapping_add(1).max(1); - } - let mut lc = self.last_change.write().await; - *lc = SystemTime::now(); - } - - /// Enregistre des callbacks sur les playlists live/historique pour notifier les changements - pub fn attach_playlist_callbacks(self: &Arc) { - use pmoplaylist::PlaylistManager; - - // Préparer les IDs de playlists à surveiller (live + history pour chaque canal) - let ids: Vec = ALL_CHANNELS - .iter() - .flat_map(|ch| { - vec![ - Self::live_playlist_id(ch.slug), - Self::history_playlist_id(ch.slug), - ] - }) - .collect(); - - let mgr = PlaylistManager(); - let mut tokens = self.callback_tokens.lock().unwrap(); - - for pid in ids { - let weak = Arc::downgrade(self); - let pid_clone = pid.clone(); - let token = mgr.register_callback(move |event| { - let pid = pid_clone.clone(); - if event.playlist_id == pid { - // On ne réagit qu'aux mises à jour structurelles (ajout/suppression) - if !matches!(event.kind, pmoplaylist::PlaylistEventKind::Updated) { - return; - } - if let Some(strong) = weak.upgrade() { - tokio::spawn(async move { - strong.bump_update_counter().await; - // Notifier ContentDirectory des conteneurs concernés - let containers: Vec = if pid.contains("history") { - // history playlist -> container history - ALL_CHANNELS - .iter() - .find(|ch| pid.ends_with(ch.slug)) - .map(|ch| { - vec![format!("radio-paradise:channel:{}:history", ch.slug)] - }) - .unwrap_or_default() - } else { - // live playlist -> container liveplaylist - ALL_CHANNELS - .iter() - .find(|ch| pid.ends_with(ch.slug)) - .map(|ch| { - vec![format!( - "radio-paradise:channel:{}:liveplaylist", - ch.slug - )] - }) - .unwrap_or_default() - }; - - if !containers.is_empty() { - if let Some(notifier) = strong.container_notifier.as_ref() { - notifier(&containers); - } - } - }); - } - } - }); - tokens.push(token); - } - } - - /// URL de fallback pour l'image par défaut de la source - fn default_cover_url(&self) -> String { - format!("{}/api/sources/{}/image", self.base_url, self.id()) - } - - /// Fetch current metadata from the live stream - async fn fetch_live_metadata(&self, slug: &str) -> Result> { - let metadata_url = format!("{}/radioparadise/metadata/{}", self.base_url, slug); - - // Try to fetch metadata via HTTP - match reqwest::get(&metadata_url).await { - Ok(response) if response.status().is_success() => { - match response.json::().await { - Ok(json) => { - // Parse metadata from JSON and create an Item - let title = json["title"] - .as_str() - .unwrap_or("Unknown Title") - .to_string(); - let artist = json["artist"].as_str().map(|s| s.to_string()); - let album = json["album"].as_str().map(|s| s.to_string()); - let year = json["year"].as_u64().map(|y| y as u32); - // Préférer l'URL de cache si cover_pk est fourni par le pipeline - let cover_pk = json["cover_pk"].as_str().map(|s| s.to_string()); - let cover_url = cover_pk - .as_ref() - .map(|pk| format!("{}/covers/jpeg/{}", self.base_url, pk)) - .or_else(|| json["cover_url"].as_str().map(|s| s.to_string())) - .or_else(|| Some(self.default_cover_url())); - - // Parse duration from JSON (in seconds as a float) - let duration = json["duration"] - .as_object() - .and_then(|d| d.get("secs")) - .and_then(|s| s.as_f64()) - .or_else(|| json["duration"].as_f64()) - .map(|secs| { - let total_secs = secs as u64; - format!( - "{}:{:02}:{:02}", - total_secs / 3600, - (total_secs % 3600) / 60, - total_secs % 60 - ) - }); - - // Create the item with current metadata - let item = Item { - id: format!("radio-paradise:channel:{}:live", slug), - parent_id: format!("radio-paradise:channel:{}", slug), - restricted: Some("1".to_string()), - title, - creator: artist.clone(), - class: "object.item.audioItem.audioBroadcast".to_string(), - artist, - album, - genre: Some("Radio".to_string()), - album_art: cover_url, - album_art_pk: cover_pk, - date: year.map(|y| y.to_string()), - original_track_number: None, - resources: vec![Resource { - protocol_info: "http-get:*:audio/flac:*".to_string(), - bits_per_sample: None, - sample_frequency: None, - nr_audio_channels: Some("2".to_string()), - duration, - url: self.build_live_url(slug), - }], - descriptions: vec![], - }; - - Ok(Some(item)) - } - Err(_) => Ok(None), - } - } - _ => Ok(None), - } - } - - /// Get the playlist ID for a channel's history - #[cfg(feature = "playlist")] - fn history_playlist_id(slug: &str) -> String { - // Must match the prefix used in ParadiseHistoryBuilder - format!("radio-paradise-history-{}", slug) - } - - /// Live playlist id for a channel - fn live_playlist_id(slug: &str) -> String { - format!("radio-paradise-live-{}", slug) - } - - #[cfg(feature = "playlist")] - async fn wait_for_live_playlist_ready(&self, slug: &str) -> Result<()> { - let playlist_id = Self::live_playlist_id(slug); - let manager = pmoplaylist::PlaylistManager(); - let reader = manager.get_read_handle(&playlist_id).await.map_err(|e| { - MusicSourceError::BrowseError(format!( - "Failed to get live playlist {}: {}", - playlist_id, e - )) - })?; - let start = Instant::now(); - loop { - match reader.remaining().await { - Ok(count) if count >= LIVE_PLAYLIST_MIN_READY_ITEMS => return Ok(()), - Ok(_) => {} - Err(e) => { - return Err(MusicSourceError::BrowseError(format!( - "Failed to inspect live playlist {}: {}", - playlist_id, e - ))); - } - } - - if start.elapsed() >= LIVE_PLAYLIST_READY_TIMEOUT { - tracing::warn!( - "Timeout waiting for live playlist {} to reach {} items", - playlist_id, - LIVE_PLAYLIST_MIN_READY_ITEMS - ); - return Ok(()); - } - - tokio::time::sleep(LIVE_PLAYLIST_READY_POLL).await; - } - } - - /// Get channel descriptor by slug - fn get_channel_by_slug(slug: &str) -> Option<&'static ChannelDescriptor> { - ALL_CHANNELS.iter().find(|ch| ch.slug == slug) - } - - /// Parse an object ID into its components - fn parse_object_id(id: &str) -> ObjectIdType { - let parts: Vec<&str> = id.split(':').collect(); - match parts.as_slice() { - ["radio-paradise"] => ObjectIdType::Root, - ["radio-paradise", "channel", slug] => ObjectIdType::Channel { - slug: (*slug).to_string(), - }, - ["radio-paradise", "channel", slug, "live"] => ObjectIdType::LiveStream { - slug: (*slug).to_string(), - }, - ["radio-paradise", "channel", slug, "liveplaylist"] => ObjectIdType::LivePlaylist { - slug: (*slug).to_string(), - }, - ["radio-paradise", "channel", slug, "liveplaylist", "track", pk] => { - ObjectIdType::LivePlaylistTrack { - slug: (*slug).to_string(), - pk: (*pk).to_string(), - } - } - ["radio-paradise", "channel", slug, "history"] => ObjectIdType::History { - slug: (*slug).to_string(), - }, - ["radio-paradise", "channel", slug, "history", "track", pk] => { - ObjectIdType::HistoryTrack { - slug: (*slug).to_string(), - pk: (*pk).to_string(), - } - } - _ => ObjectIdType::Unknown, - } - } - - /// Build a channel container - fn build_channel_container(&self, descriptor: &ChannelDescriptor) -> Container { - Container { - id: format!("radio-paradise:channel:{}", descriptor.slug), - parent_id: "radio-paradise".to_string(), - restricted: Some("1".to_string()), - child_count: None, - searchable: Some("1".to_string()), - title: descriptor.display_name.to_string(), - class: "object.container".to_string(), - containers: vec![], - items: vec![], - } - } - - /// Build the live playlist container for a channel - fn build_live_playlist_container(&self, descriptor: &ChannelDescriptor) -> Container { - Container { - id: format!("radio-paradise:channel:{}:liveplaylist", descriptor.slug), - parent_id: format!("radio-paradise:channel:{}", descriptor.slug), - restricted: Some("1".to_string()), - child_count: None, - searchable: Some("0".to_string()), - title: format!("{} - Live Playlist", descriptor.display_name), - class: "object.container.playlistContainer".to_string(), - containers: vec![], - items: vec![], - } - } - - /// Build a live stream item for a channel - fn build_live_stream_item(&self, descriptor: &ChannelDescriptor) -> Item { - let stream_url = self.build_live_url(descriptor.slug); - - Item { - id: format!("radio-paradise:channel:{}:live", descriptor.slug), - parent_id: format!("radio-paradise:channel:{}", descriptor.slug), - restricted: Some("1".to_string()), - title: format!("{} - Live Stream", descriptor.display_name), - creator: Some("Radio Paradise".to_string()), - class: "object.item.audioItem.audioBroadcast".to_string(), - artist: Some("Radio Paradise".to_string()), - album: Some(descriptor.display_name.to_string()), - genre: Some("Radio".to_string()), - album_art: Some(self.default_cover_url()), - album_art_pk: None, - date: None, - original_track_number: None, - resources: vec![ - Resource { - protocol_info: "http-get:*:audio/flac:*".to_string(), - bits_per_sample: Some("16".to_string()), - sample_frequency: Some("44100".to_string()), - nr_audio_channels: Some("2".to_string()), - duration: None, - url: stream_url.clone(), - }, - Resource { - protocol_info: "http-get:*:audio/ogg:*".to_string(), - bits_per_sample: Some("16".to_string()), - sample_frequency: Some("44100".to_string()), - nr_audio_channels: Some("2".to_string()), - duration: None, - url: self.build_live_ogg_url(descriptor.slug), - }, - ], - descriptions: vec![], - } - } - - /// Build a history container for a channel - fn build_history_container(&self, descriptor: &ChannelDescriptor) -> Container { - Container { - id: format!("radio-paradise:channel:{}:history", descriptor.slug), - parent_id: format!("radio-paradise:channel:{}", descriptor.slug), - restricted: Some("1".to_string()), - child_count: None, - searchable: Some("1".to_string()), - title: format!("{} - History", descriptor.display_name), - // Expose l'historique comme une playlist jouable - class: "object.container.playlistContainer".to_string(), - containers: vec![], - items: vec![], - } - } - - /// Build a history container with accurate child count from playlist - #[cfg(feature = "playlist")] - async fn build_history_container_with_count( - &self, - descriptor: &ChannelDescriptor, - ) -> Container { - let mut container = self.build_history_container(descriptor); - - // Try to get actual count from playlist - let playlist_id = Self::history_playlist_id(descriptor.slug); - let manager = pmoplaylist::PlaylistManager(); - - if let Ok(reader) = manager.get_read_handle(&playlist_id).await { - if let Ok(count) = reader.remaining().await { - container.child_count = Some(count.to_string()); - } - } - - container - } - - /// Get items from history playlist - #[cfg(feature = "playlist")] - async fn get_history_items( - &self, - slug: &str, - _offset: usize, - count: usize, - ) -> Result> { - let playlist_id = Self::history_playlist_id(slug); - - // Get read handle for the playlist from the singleton - let manager = pmoplaylist::PlaylistManager(); - let reader = manager.get_read_handle(&playlist_id).await.map_err(|e| { - MusicSourceError::BrowseError(format!("Failed to get playlist {}: {}", playlist_id, e)) - })?; - - // Get items from playlist (to_items starts from cursor position) - let mut items = reader.to_items(count).await.map_err(|e| { - MusicSourceError::BrowseError(format!("Failed to read playlist entries: {}", e)) - })?; - - // Transform item IDs, parent_ids, and resource URLs to match Radio Paradise schema - // Expected: radio-paradise:channel:{slug}:history:track:{pk} - // Parent: radio-paradise:channel:{slug}:history - for item in items.iter_mut() { - // Extract cache_pk from the resource URL (last segment) - if let Some(resource) = item.resources.first_mut() { - if let Some(pk) = resource.url.split('/').last() { - // Update item ID and parent ID - item.id = format!("radio-paradise:channel:{}:history:track:{}", slug, pk); - item.parent_id = format!("radio-paradise:channel:{}:history", slug); - - // Convert relative URL to absolute URL - // From: /audio/flac/pk - // To: http://base_url/audio/flac/pk - if resource.url.starts_with('/') { - resource.url = format!("{}{}", self.base_url, resource.url); - } - } - } - - // Fix: Ajouter un genre par défaut si absent - // Certains clients UPnP (comme gupnp-av-cp) requièrent le champ - // pour parser correctement les items de classe musicTrack, même si ce champ - // est optionnel selon la spec UPnP ContentDirectory. - if item.genre.is_none() { - item.genre = Some("Radio Paradise".to_string()); - } - - // Normaliser l'albumArtURI : rendre absolu si chemin relatif, sinon fallback par défaut - if let Some(art) = item.album_art.as_mut() { - if art.starts_with('/') { - *art = format!("{}{}", self.base_url, art); - } - } else { - item.album_art = Some(self.default_cover_url()); - } - } - - Ok(items) - } - - /// Get items from live playlist (current stream queue) - #[cfg(feature = "playlist")] - async fn get_live_playlist_items( - &self, - slug: &str, - _offset: usize, - count: usize, - ) -> Result> { - #[cfg(all(feature = "playlist", feature = "pmoaudio"))] - if let Some(descriptor) = Self::get_channel_by_slug(slug) { - if let Some(manager) = crate::stream_channel::get_global_channel_manager() { - if let Err(e) = manager.prefetch_until_horizon(descriptor.id).await { - tracing::warn!( - "Failed to prefetch live playlist for {}: {}", - descriptor.slug, - e - ); - } - } - } - - #[cfg(feature = "playlist")] - if let Err(e) = self.wait_for_live_playlist_ready(slug).await { - tracing::warn!( - "Failed to wait for live playlist readiness on {}: {}", - slug, - e - ); - } - - let playlist_id = Self::live_playlist_id(slug); - - let manager = pmoplaylist::PlaylistManager(); - let reader = manager.get_read_handle(&playlist_id).await.map_err(|e| { - MusicSourceError::BrowseError(format!( - "Failed to get live playlist {}: {}", - playlist_id, e - )) - })?; - - let mut items = reader.to_items(count).await.map_err(|e| { - MusicSourceError::BrowseError(format!("Failed to read live playlist entries: {}", e)) - })?; - - for item in items.iter_mut() { - // Ajuster id/parent/url pour coller au schéma Radio Paradise - if let Some(resource) = item.resources.first_mut() { - if let Some(pk) = resource.url.split('/').last() { - item.id = format!("radio-paradise:channel:{}:liveplaylist:track:{}", slug, pk); - item.parent_id = format!("radio-paradise:channel:{}:liveplaylist", slug); - - if resource.url.starts_with('/') { - resource.url = format!("{}{}", self.base_url, resource.url); - } - } - } - - if item.genre.is_none() { - item.genre = Some("Radio Paradise".to_string()); - } - - if let Some(art) = item.album_art.as_mut() { - if art.starts_with('/') { - *art = format!("{}{}", self.base_url, art); - } - } else { - item.album_art = Some(self.default_cover_url()); - } - } - - Ok(items) - } - - /// Get a single item from the live playlist by pk - #[cfg(feature = "playlist")] - async fn get_live_playlist_item(&self, slug: &str, pk: &str) -> Result { - let items = self.get_live_playlist_items(slug, 0, 1000).await?; - let expected_id = format!("radio-paradise:channel:{}:liveplaylist:track:{}", slug, pk); - for item in items { - if item.id == expected_id { - return Ok(item); - } - } - Err(MusicSourceError::ObjectNotFound(format!( - "Track with pk {} not found in live playlist", - pk - ))) - } -} - -/// Types of object IDs in the Radio Paradise source -#[derive(Debug, Clone, PartialEq)] -enum ObjectIdType { - Root, - Channel { slug: String }, - LiveStream { slug: String }, - LivePlaylist { slug: String }, - LivePlaylistTrack { slug: String, pk: String }, - History { slug: String }, - HistoryTrack { slug: String, pk: String }, - Unknown, -} - -#[async_trait] -impl MusicSource for RadioParadiseSource { - fn name(&self) -> &str { - "Radio Paradise" - } - - fn id(&self) -> &str { - "radio-paradise" - } - - fn default_image(&self) -> &[u8] { - DEFAULT_IMAGE - } - - async fn root_container(&self) -> Result { - Ok(Container { - id: "radio-paradise".to_string(), - parent_id: "0".to_string(), - restricted: Some("1".to_string()), - // childCount retiré pour éviter les soucis de compatibilité côté CP - child_count: None, - searchable: Some("1".to_string()), - title: "Radio Paradise".to_string(), - class: "object.container".to_string(), - containers: vec![], - items: vec![], - }) - } - - async fn browse(&self, object_id: &str) -> Result { - match Self::parse_object_id(object_id) { - ObjectIdType::Root => { - // Return the 4 channel containers - let containers: Vec = ALL_CHANNELS - .iter() - .map(|ch| self.build_channel_container(ch)) - .collect(); - - Ok(BrowseResult::Containers(containers)) - } - - ObjectIdType::Channel { slug } => { - // Return live stream item + history container - let descriptor = Self::get_channel_by_slug(&slug).ok_or_else(|| { - MusicSourceError::ObjectNotFound(format!("Unknown channel: {}", slug)) - })?; - - let live_item = self.build_live_stream_item(descriptor); - let live_playlist_container = self.build_live_playlist_container(descriptor); - - #[cfg(feature = "playlist")] - let history_container = self.build_history_container_with_count(descriptor).await; - #[cfg(not(feature = "playlist"))] - let history_container = self.build_history_container(descriptor); - - Ok(BrowseResult::Mixed { - containers: vec![live_playlist_container, history_container], - items: vec![live_item], - }) - } - - ObjectIdType::History { slug } => { - // Return history container (for BrowseMetadata) and items (for BrowseDirectChildren) - // The content_handler will filter out the container when browsing direct children - let descriptor = Self::get_channel_by_slug(&slug).ok_or_else(|| { - MusicSourceError::ObjectNotFound(format!("Unknown channel: {}", slug)) - })?; - - #[cfg(feature = "playlist")] - { - let history_container = - self.build_history_container_with_count(descriptor).await; - let items = self.get_history_items(&slug, 0, 100).await?; - Ok(BrowseResult::Mixed { - containers: vec![history_container], - items, - }) - } - - #[cfg(not(feature = "playlist"))] - { - // If playlist feature is disabled, return just the container - let history_container = self.build_history_container(descriptor); - Ok(BrowseResult::Containers(vec![history_container])) - } - } - - ObjectIdType::LiveStream { slug } => { - // Return metadata for the live stream item - let descriptor = Self::get_channel_by_slug(&slug).ok_or_else(|| { - MusicSourceError::ObjectNotFound(format!("Unknown channel: {}", slug)) - })?; - let item = self.build_live_stream_item(descriptor); - Ok(BrowseResult::Items(vec![item])) - } - - ObjectIdType::LivePlaylist { slug } => { - // Playlist du live : container + items - let descriptor = Self::get_channel_by_slug(&slug).ok_or_else(|| { - MusicSourceError::ObjectNotFound(format!("Unknown channel: {}", slug)) - })?; - - #[cfg(feature = "playlist")] - { - let container = self.build_live_playlist_container(descriptor); - let items = self.get_live_playlist_items(&slug, 0, 100).await?; - Ok(BrowseResult::Mixed { - containers: vec![container], - items, - }) - } - - #[cfg(not(feature = "playlist"))] - { - let container = self.build_live_playlist_container(descriptor); - Ok(BrowseResult::Containers(vec![container])) - } - } - - ObjectIdType::HistoryTrack { slug: _, pk: _ } => { - // Return metadata for the history track item - let item = self.get_item(object_id).await?; - Ok(BrowseResult::Items(vec![item])) - } - - ObjectIdType::LivePlaylistTrack { slug, pk } => { - // Détails d'un titre du live (playlist live) - #[cfg(feature = "playlist")] - { - let item = self.get_live_playlist_item(&slug, &pk).await?; - Ok(BrowseResult::Items(vec![item])) - } - - #[cfg(not(feature = "playlist"))] - { - let _ = (slug, pk); - Err(MusicSourceError::NotSupported( - "Playlist feature not enabled".to_string(), - )) - } - } - - ObjectIdType::Unknown => Err(MusicSourceError::ObjectNotFound(format!( - "Unknown object ID: {}", - object_id - ))), - } - } - - async fn resolve_uri(&self, object_id: &str) -> Result { - match Self::parse_object_id(object_id) { - ObjectIdType::LiveStream { slug } => { - // Return live stream URL - Ok(self.build_live_url(&slug)) - } - - ObjectIdType::HistoryTrack { pk, .. } => { - // Return cached audio URL - Ok(format!("{}/cache/audio/{}", self.base_url, pk)) - } - - ObjectIdType::LivePlaylistTrack { pk, .. } => { - // Return cached audio URL - Ok(format!("{}/cache/audio/{}", self.base_url, pk)) - } - - _ => Err(MusicSourceError::ObjectNotFound(format!( - "Cannot resolve URI for object: {}", - object_id - ))), - } - } - - fn capabilities(&self) -> SourceCapabilities { - SourceCapabilities { - supports_fifo: self.supports_fifo(), - supports_search: false, - supports_favorites: false, - supports_playlists: false, - supports_user_content: false, - supports_high_res_audio: true, - max_sample_rate: Some(44100), - supports_multiple_formats: true, - supports_advanced_search: false, - supports_pagination: false, - } - } - - async fn get_available_formats(&self, object_id: &str) -> Result> { - match Self::parse_object_id(object_id) { - ObjectIdType::LiveStream { .. } => Ok(vec![ - AudioFormat { - format_id: "flac".to_string(), - mime_type: "audio/flac".to_string(), - sample_rate: Some(44100), - bit_depth: Some(16), - bitrate: None, - channels: Some(2), - }, - AudioFormat { - format_id: "ogg-flac".to_string(), - mime_type: "audio/ogg".to_string(), - sample_rate: Some(44100), - bit_depth: Some(16), - bitrate: None, - channels: Some(2), - }, - ]), - ObjectIdType::HistoryTrack { .. } => Ok(vec![AudioFormat { - format_id: "flac".to_string(), - mime_type: "audio/flac".to_string(), - sample_rate: Some(44100), - bit_depth: Some(16), - bitrate: None, - channels: Some(2), - }]), - ObjectIdType::LivePlaylistTrack { .. } => Ok(vec![AudioFormat { - format_id: "flac".to_string(), - mime_type: "audio/flac".to_string(), - sample_rate: Some(44100), - bit_depth: Some(16), - bitrate: None, - channels: Some(2), - }]), - _ => Err(MusicSourceError::ObjectNotFound(format!( - "Cannot list formats for object: {}", - object_id - ))), - } - } - - async fn get_item(&self, object_id: &str) -> Result { - match Self::parse_object_id(object_id) { - ObjectIdType::LiveStream { slug } => { - // Try to fetch current metadata from live stream - if let Ok(Some(item)) = self.fetch_live_metadata(&slug).await { - return Ok(item); - } - - // Fallback to static item if metadata fetch fails - let descriptor = Self::get_channel_by_slug(&slug).ok_or_else(|| { - MusicSourceError::ObjectNotFound(format!("Unknown channel: {}", slug)) - })?; - Ok(self.build_live_stream_item(descriptor)) - } - - ObjectIdType::HistoryTrack { slug, pk } => { - // Get from history playlist - #[cfg(feature = "playlist")] - { - let playlist_id = Self::history_playlist_id(&slug); - let manager = pmoplaylist::PlaylistManager(); - let reader = manager.get_read_handle(&playlist_id).await.map_err(|e| { - MusicSourceError::BrowseError(format!( - "Failed to get playlist {}: {}", - playlist_id, e - )) - })?; - - // Try to find the item with this pk - let items = reader.to_items(1000).await.map_err(|e| { - MusicSourceError::BrowseError(format!( - "Failed to read playlist entries: {}", - e - )) - })?; - - // Ajuster les IDs/parent_id/URL pour coller au schéma Radio Paradise, - // comme dans get_history_items. - let mut adjusted = Vec::new(); - for mut item in items { - if let Some(resource) = item.resources.first_mut() { - if let Some(pk2) = resource.url.split('/').last() { - item.id = format!( - "radio-paradise:channel:{}:history:track:{}", - slug, pk2 - ); - item.parent_id = format!("radio-paradise:channel:{}:history", slug); - - if resource.url.starts_with('/') { - resource.url = format!("{}{}", self.base_url, resource.url); - } - } - } - if item.genre.is_none() { - item.genre = Some("Radio Paradise".to_string()); - } - adjusted.push(item); - } - - // Find the item matching this pk in the item ID - let expected_id = - format!("radio-paradise:channel:{}:history:track:{}", slug, pk); - for item in adjusted { - if item.id == expected_id { - return Ok(item); - } - } - - Err(MusicSourceError::ObjectNotFound(format!( - "Track with pk {} not found in history", - pk - ))) - } - - #[cfg(not(feature = "playlist"))] - { - let _ = (slug, pk); - Err(MusicSourceError::NotSupported( - "Playlist feature not enabled".to_string(), - )) - } - } - - ObjectIdType::LivePlaylistTrack { slug, pk } => { - #[cfg(feature = "playlist")] - { - let playlist_id = Self::live_playlist_id(&slug); - let manager = pmoplaylist::PlaylistManager(); - let reader = manager.get_read_handle(&playlist_id).await.map_err(|e| { - MusicSourceError::BrowseError(format!( - "Failed to get live playlist {}: {}", - playlist_id, e - )) - })?; - - let items = reader.to_items(1000).await.map_err(|e| { - MusicSourceError::BrowseError(format!( - "Failed to read live playlist entries: {}", - e - )) - })?; - - for mut item in items { - if let Some(resource) = item.resources.first_mut() { - if let Some(pk2) = resource.url.split('/').last() { - item.id = format!( - "radio-paradise:channel:{}:liveplaylist:track:{}", - slug, pk2 - ); - item.parent_id = - format!("radio-paradise:channel:{}:liveplaylist", slug); - - if resource.url.starts_with('/') { - resource.url = format!("{}{}", self.base_url, resource.url); - } - } - } - - if item.genre.is_none() { - item.genre = Some("Radio Paradise".to_string()); - } - - if let Some(art) = item.album_art.as_mut() { - if art.starts_with('/') { - *art = format!("{}{}", self.base_url, art); - } - } else { - item.album_art = Some(self.default_cover_url()); - } - - let expected_id = - format!("radio-paradise:channel:{}:liveplaylist:track:{}", slug, pk); - if item.id == expected_id { - return Ok(item); - } - } - - Err(MusicSourceError::ObjectNotFound(format!( - "Track with pk {} not found in live playlist", - pk - ))) - } - - #[cfg(not(feature = "playlist"))] - { - let _ = (slug, pk); - Err(MusicSourceError::NotSupported( - "Playlist feature not enabled".to_string(), - )) - } - } - - _ => Err(MusicSourceError::ObjectNotFound(format!( - "Cannot get item for object: {}", - object_id - ))), - } - } - - fn supports_fifo(&self) -> bool { - // History playlists are FIFO - cfg!(feature = "playlist") - } - - async fn append_track(&self, _track: Item) -> Result<()> { - // Tracks are added automatically by FlacCacheSink - Err(MusicSourceError::NotSupported( - "Tracks are automatically added to history by the streaming system".to_string(), - )) - } - - async fn remove_oldest(&self) -> Result> { - // Managed automatically by playlist FIFO - Ok(None) - } - - async fn update_id(&self) -> u32 { - *self.update_counter.read().await - } - - async fn last_change(&self) -> Option { - Some(*self.last_change.read().await) - } - - async fn get_items(&self, offset: usize, count: usize) -> Result> { - // For Radio Paradise, we don't have a global FIFO - // Each channel has its own history - // Return empty for now - clients should browse specific channel histories - let _ = (offset, count); - Ok(vec![]) - } -} --------End of pmoparadise/src/source.rs --------- - ------------- pmoparadise/src/stream_channel_old.rs ---------- -use std::{ - collections::HashMap, - pin::Pin, - sync::{ - atomic::{AtomicUsize, Ordering}, - Arc, - }, - task::{Context, Poll}, - time::Duration, -}; - -use crate::{ - channels::{ChannelDescriptor, ParadiseChannelKind, ALL_CHANNELS}, - client::RadioParadiseClient, - radio_paradise_stream_source::RadioParadiseStreamSource, -}; -use anyhow::{anyhow, Result}; -use pmoaudio::{nodes::DEFAULT_CHANNEL_SIZE, AudioPipelineNode}; -use pmoaudio_ext::{ - FlacCacheSink, FlacClientStream, IcyClientStream, MetadataSnapshot, OggFlacClientStream, - OggFlacStreamHandle, PlaylistSource, StreamHandle, StreamingFlacSink, StreamingOggFlacSink, - TrackBoundaryCoverNode, StreamingSinkOptions, -}; -use pmoaudiocache::Cache as AudioCache; -use pmocovers::Cache as CoverCache; -use pmoflac::EncoderOptions; -use pmoplaylist::WriteHandle; -use thiserror::Error; -use tokio::io::{AsyncRead, ReadBuf}; -use tokio::sync::Notify; -use tokio::task::JoinHandle; -use tokio_util::sync::CancellationToken; -use tracing::{error, info, warn}; - -/// Configuration pour un canal Radio Paradise. -#[derive(Clone, Debug)] -pub struct ParadiseStreamChannelConfig { - /// Durée maximale (en secondes) d'avance acceptée par le broadcast. - pub max_lead_seconds: f64, - pub flac_options: StreamingSinkOptions, - pub ogg_options: StreamingSinkOptions, - pub server_base_url: Option, -} - -impl Default for ParadiseStreamChannelConfig { - fn default() -> Self { - Self { - max_lead_seconds: 1.0, - flac_options: StreamingSinkOptions::flac_defaults(), - ogg_options: StreamingSinkOptions::ogg_defaults(), - server_base_url: None, - } - } -} - -/// Options pour activer l'archivage/historique d'un canal. -pub struct ParadiseHistoryOptions { - pub audio_cache: Arc, - pub cover_cache: Arc, - pub playlist_id: String, - pub playlist_writer: WriteHandle, - pub collection: Option, - pub replay_max_lead_seconds: f64, -} - -/// Builder pratique pour configurer automatiquement les playlists historiques. -#[derive(Clone)] -pub struct ParadiseHistoryBuilder { - pub audio_cache: Arc, - pub cover_cache: Arc, - pub playlist_prefix: String, - pub playlist_title_prefix: Option, - pub max_history_tracks: Option, - pub collection_prefix: Option, - pub replay_max_lead_seconds: f64, -} - -impl ParadiseHistoryBuilder { - pub fn new(audio_cache: Arc, cover_cache: Arc) -> Self { - Self { - audio_cache, - cover_cache, - playlist_prefix: "radio-paradise-history".into(), - playlist_title_prefix: Some("Radio Paradise History".into()), - max_history_tracks: Some(500), - collection_prefix: Some("radio-paradise".into()), - replay_max_lead_seconds: 1.0, - } - } - - pub async fn build_for_channel( - &self, - descriptor: &ChannelDescriptor, - ) -> Result { - let playlist_id = format!("{}-{}", self.playlist_prefix, descriptor.slug); - let manager = pmoplaylist::PlaylistManager(); - let writer = manager - .get_persistent_write_handle(playlist_id.clone()) - .await?; - - if let Some(prefix) = &self.playlist_title_prefix { - let title = format!("{} - {}", prefix, descriptor.display_name); - writer.set_title(title).await?; - } - - if let Some(capacity) = self.max_history_tracks { - writer.set_capacity(Some(capacity)).await?; - } - - let collection = self - .collection_prefix - .as_ref() - .map(|prefix| format!("{}-{}", prefix, descriptor.slug)); - - Ok(ParadiseHistoryOptions { - audio_cache: self.audio_cache.clone(), - cover_cache: self.cover_cache.clone(), - playlist_id, - playlist_writer: writer, - collection, - replay_max_lead_seconds: self.replay_max_lead_seconds, - }) - } -} - -struct HistoryState { - playlist_id: String, - audio_cache: Arc, - replay_max_lead_seconds: f64, -} - -#[cfg(feature = "pmoconfig")] -impl ParadiseStreamChannelConfig { - pub fn from_config(cfg: &pmoconfig::Config, channel: ParadiseChannelKind) -> Self { - use serde_yaml::Value; - let path = [ - "sources", - "radio_paradise", - "channels", - channel.slug(), - "max_lead_seconds", - ]; - match cfg.get_value(&path) { - Ok(Value::Number(num)) => { - if let Some(v) = num.as_f64() { - Self { - max_lead_seconds: v.max(0.1), - flac_options: StreamingSinkOptions::flac_defaults(), - ogg_options: StreamingSinkOptions::ogg_defaults(), - server_base_url: None, - } - } else { - let default = Self::default(); - let _ = - cfg.set_value(&path, Value::String(default.max_lead_seconds.to_string())); - default - } - } - Ok(Value::String(s)) => { - if let Ok(v) = s.parse::() { - Self { - max_lead_seconds: v.max(0.1), - flac_options: StreamingSinkOptions::flac_defaults(), - ogg_options: StreamingSinkOptions::ogg_defaults(), - server_base_url: None, - } - } else { - let default = Self::default(); - let _ = - cfg.set_value(&path, Value::String(default.max_lead_seconds.to_string())); - default - } - } - _ => { - let default = Self::default(); - let _ = cfg.set_value(&path, Value::String(default.max_lead_seconds.to_string())); - default - } - } - } -} - -/// Stream complet (FLAC pur + OGG-FLAC) pour un canal Radio Paradise. -pub struct ParadiseStreamChannel { - descriptor: ChannelDescriptor, - state: Arc, - pipeline_handle: JoinHandle<()>, - feeder_handle: JoinHandle<()>, - history: Option, -} - -impl ParadiseStreamChannel { - /// Crée un canal avec client déjà configuré. - pub fn with_client( - descriptor: ChannelDescriptor, - client: RadioParadiseClient, - config: ParadiseStreamChannelConfig, - cover_cache: Option>, - history: Option, - ) -> Self { - let mut source = RadioParadiseStreamSource::new(client.clone()); - let block_handle = source.block_handle(); - - let (flac_sink, stream_handle) = StreamingFlacSink::with_options( - EncoderOptions::default(), - 16, - config.max_lead_seconds, - config.flac_options.clone(), - ); - let (ogg_sink, ogg_handle) = StreamingOggFlacSink::with_options( - EncoderOptions::default(), - 16, - config.max_lead_seconds, - config.ogg_options.clone(), - ); - - let mut downstream_children: Vec> = Vec::new(); - downstream_children.push(Box::new(flac_sink)); - downstream_children.push(Box::new(ogg_sink)); - - let mut history_state = None; - - if let Some(history_opts) = history { - let ParadiseHistoryOptions { - audio_cache, - cover_cache, - playlist_id, - playlist_writer, - collection, - replay_max_lead_seconds, - } = history_opts; - let mut cache_sink = FlacCacheSink::with_config( - audio_cache.clone(), - cover_cache, - DEFAULT_CHANNEL_SIZE, - EncoderOptions::default(), - collection, - ); - cache_sink.register_playlist(playlist_writer); - downstream_children.push(Box::new(cache_sink)); - history_state = Some(HistoryState { - playlist_id, - audio_cache, - replay_max_lead_seconds, - }); - } - - if let Some(cache) = cover_cache { - let mut cover_node = TrackBoundaryCoverNode::new(cache); - for child in downstream_children { - cover_node.register(child); - } - source.register(Box::new(cover_node)); - } else { - for child in downstream_children { - source.register(child); - } - } - stream_handle.set_auto_stop(false); - ogg_handle.set_auto_stop(false); - - let stop_token = CancellationToken::new(); - let pipeline_stop = stop_token.clone(); - let pipeline_handle = tokio::spawn(async move { - info!( - "RadioParadise stream pipeline started for channel {}", - descriptor.display_name - ); - if let Err(e) = Box::new(source).run(pipeline_stop).await { - error!( - "Pipeline error for channel {}: {}", - descriptor.display_name, e - ); - } - }); - - let state = Arc::new(ChannelState { - descriptor, - config, - client, - block_handle, - stream_handle, - ogg_handle, - active_clients: AtomicUsize::new(0), - activity_notify: Notify::new(), - stop_token, - }); - - let feeder_state = state.clone(); - let feeder_handle = tokio::spawn(async move { - feeder_state.run_scheduler().await; - }); - - Self { - descriptor, - state, - pipeline_handle, - feeder_handle, - history: history_state, - } - } - - /// Crée un canal en construisant automatiquement le client pour ce descriptor. - pub async fn new( - descriptor: ChannelDescriptor, - config: ParadiseStreamChannelConfig, - cover_cache: Option>, - history: Option, - ) -> Result { - let client = RadioParadiseClient::builder() - .channel(descriptor.id) - .build() - .await?; - Ok(Self::with_client( - descriptor, - client, - config, - cover_cache, - history, - )) - } - - /// S'abonne au flux FLAC pur. - pub fn subscribe_flac(&self) -> ChannelFlacStream { - self.state.on_client_added(); - let inner = self.state.stream_handle.subscribe_flac(); - ChannelFlacStream::new(inner, self.state.clone()) - } - - /// S'abonne au flux FLAC + ICY metadata. - pub fn subscribe_icy(&self) -> ChannelIcyStream { - self.state.on_client_added(); - let inner = self.state.stream_handle.subscribe_icy(); - ChannelIcyStream::new(inner, self.state.clone()) - } - - /// S'abonne au flux OGG-FLAC. - pub fn subscribe_ogg(&self) -> ChannelOggStream { - self.state.on_client_added(); - let inner = self.state.ogg_handle.subscribe(); - ChannelOggStream::new(inner, self.state.clone()) - } - - /// Snapshot des métadonnées actuelles. - pub async fn metadata(&self) -> MetadataSnapshot { - self.state.stream_handle.get_metadata().await - } - - /// Nombre de clients actifs. - pub fn active_clients(&self) -> usize { - self.state.active_clients.load(Ordering::SeqCst) - } - - pub fn descriptor(&self) -> ChannelDescriptor { - self.descriptor - } - - /// Lance un pipeline dédié pour rejouer l'historique (FLAC pur) pour un client. - pub async fn stream_history_flac( - &self, - client_id: &str, - ) -> Result { - let history = self - .history - .as_ref() - .ok_or(HistoryStreamError::HistoryDisabled)?; - tracing::info!( - "Starting historical FLAC replay for channel {} (client_id={})", - self.descriptor.display_name, - client_id - ); - - let reader = pmoplaylist::PlaylistManager() - .get_read_handle(&history.playlist_id) - .await - .map_err(|e| HistoryStreamError::Playlist(e.to_string()))?; - let mut source = PlaylistSource::new(reader, history.audio_cache.clone()); - let (flac_sink, handle) = StreamingFlacSink::with_options( - EncoderOptions::default(), - 16, - history.replay_max_lead_seconds, - self.state.config.flac_options.clone(), - ); - source.register(Box::new(flac_sink)); - let stop_token = CancellationToken::new(); - let mut pipeline_source = source; - let stop_clone = stop_token.clone(); - let pipeline = tokio::spawn(async move { - let _ = Box::new(pipeline_source).run(stop_clone).await; - }); - let stream = handle.subscribe_flac(); - Ok(HistoryFlacStream::new(stream, stop_token, pipeline)) - } - - /// Lance un pipeline dédié pour rejouer l'historique (OGG-FLAC) pour un client. - pub async fn stream_history_ogg( - &self, - client_id: &str, - ) -> Result { - let history = self - .history - .as_ref() - .ok_or(HistoryStreamError::HistoryDisabled)?; - tracing::info!( - "Starting historical OGG replay for channel {} (client_id={})", - self.descriptor.display_name, - client_id - ); - - let reader = pmoplaylist::PlaylistManager() - .get_read_handle(&history.playlist_id) - .await - .map_err(|e| HistoryStreamError::Playlist(e.to_string()))?; - let mut source = PlaylistSource::new(reader, history.audio_cache.clone()); - let (ogg_sink, handle) = StreamingOggFlacSink::with_options( - EncoderOptions::default(), - 16, - history.replay_max_lead_seconds, - self.state.config.ogg_options.clone(), - ); - source.register(Box::new(ogg_sink)); - let stop_token = CancellationToken::new(); - let mut pipeline_source = source; - let stop_clone = stop_token.clone(); - let pipeline = tokio::spawn(async move { - let _ = Box::new(pipeline_source).run(stop_clone).await; - }); - let stream = handle.subscribe(); - Ok(HistoryOggStream::new(stream, stop_token, pipeline)) - } -} - -impl Drop for ParadiseStreamChannel { - fn drop(&mut self) { - self.state.stop_token.cancel(); - self.pipeline_handle.abort(); - self.feeder_handle.abort(); - } -} - -struct ChannelState { - descriptor: ChannelDescriptor, - config: ParadiseStreamChannelConfig, - client: RadioParadiseClient, - block_handle: crate::radio_paradise_stream_source::BlockQueueHandle, - stream_handle: StreamHandle, - ogg_handle: OggFlacStreamHandle, - active_clients: AtomicUsize, - activity_notify: Notify, - stop_token: CancellationToken, -} - -impl ChannelState { - fn on_client_added(&self) { - if self.active_clients.fetch_add(1, Ordering::SeqCst) == 0 { - self.activity_notify.notify_one(); - } - } - - fn on_client_removed(&self) { - self.active_clients.fetch_sub(1, Ordering::SeqCst); - } - - async fn wait_for_clients(&self) -> bool { - while self.active_clients.load(Ordering::SeqCst) == 0 { - tokio::select! { - _ = self.stop_token.cancelled() => return false, - _ = self.activity_notify.notified() => {}, - } - } - true - } - - async fn run_scheduler(self: Arc) { - let mut backoff = Duration::from_secs(5); - loop { - if self.stop_token.is_cancelled() { - break; - } - - if !self.wait_for_clients().await { - break; - } - - match self.client.get_block(None).await { - Ok(block) => { - info!( - "Channel {} streaming block {}", - self.descriptor.display_name, block.event - ); - self.block_handle.enqueue(block.event); - let mut next_event = block.end_event; - - loop { - if self.stop_token.is_cancelled() { - return; - } - - if self.active_clients.load(Ordering::SeqCst) == 0 { - break; - } - - match self.client.get_block(Some(next_event)).await { - Ok(next_block) => { - self.block_handle.enqueue(next_block.event); - next_event = next_block.end_event; - backoff = Duration::from_secs(5); - } - Err(e) => { - warn!( - "Failed to fetch next block for channel {}: {}", - self.descriptor.display_name, e - ); - tokio::select! { - _ = self.stop_token.cancelled() => return, - _ = tokio::time::sleep(backoff) => {}, - } - backoff = (backoff * 2).min(Duration::from_secs(60)); - } - } - } - } - Err(e) => { - warn!( - "Failed to fetch current block for channel {}: {}", - self.descriptor.display_name, e - ); - tokio::select! { - _ = self.stop_token.cancelled() => break, - _ = tokio::time::sleep(backoff) => {}, - } - backoff = (backoff * 2).min(Duration::from_secs(60)); - } - } - } - } -} - -macro_rules! wrap_stream { - ($name:ident, $inner:ty) => { - pub struct $name { - inner: $inner, - state: Arc, - } - - impl $name { - fn new(inner: $inner, state: Arc) -> Self { - Self { inner, state } - } - } - - impl AsyncRead for $name { - fn poll_read( - mut self: Pin<&mut Self>, - cx: &mut Context<'_>, - buf: &mut ReadBuf<'_>, - ) -> Poll> { - Pin::new(&mut self.inner).poll_read(cx, buf) - } - } - - impl Drop for $name { - fn drop(&mut self) { - self.state.on_client_removed(); - } - } - }; -} - -wrap_stream!(ChannelFlacStream, FlacClientStream); -wrap_stream!(ChannelIcyStream, IcyClientStream); -wrap_stream!(ChannelOggStream, OggFlacClientStream); - -#[derive(Debug, Error)] -pub enum HistoryStreamError { - #[error("history replay not enabled for this channel")] - HistoryDisabled, - #[error("playlist error: {0}")] - Playlist(String), -} - -pub struct HistoryFlacStream { - inner: FlacClientStream, - stop_token: CancellationToken, - pipeline: Option>, -} - -impl HistoryFlacStream { - fn new( - inner: FlacClientStream, - stop_token: CancellationToken, - pipeline: JoinHandle<()>, - ) -> Self { - Self { - inner, - stop_token, - pipeline: Some(pipeline), - } - } -} - -impl AsyncRead for HistoryFlacStream { - fn poll_read( - mut self: Pin<&mut Self>, - cx: &mut Context<'_>, - buf: &mut ReadBuf<'_>, - ) -> Poll> { - Pin::new(&mut self.inner).poll_read(cx, buf) - } -} - -impl Unpin for HistoryFlacStream {} - -impl Drop for HistoryFlacStream { - fn drop(&mut self) { - self.stop_token.cancel(); - if let Some(handle) = self.pipeline.take() { - handle.abort(); - } - } -} - -pub struct HistoryOggStream { - inner: OggFlacClientStream, - stop_token: CancellationToken, - pipeline: Option>, -} - -impl HistoryOggStream { - fn new( - inner: OggFlacClientStream, - stop_token: CancellationToken, - pipeline: JoinHandle<()>, - ) -> Self { - Self { - inner, - stop_token, - pipeline: Some(pipeline), - } - } -} - -impl AsyncRead for HistoryOggStream { - fn poll_read( - mut self: Pin<&mut Self>, - cx: &mut Context<'_>, - buf: &mut ReadBuf<'_>, - ) -> Poll> { - Pin::new(&mut self.inner).poll_read(cx, buf) - } -} - -impl Unpin for HistoryOggStream {} - -impl Drop for HistoryOggStream { - fn drop(&mut self) { - self.stop_token.cancel(); - if let Some(handle) = self.pipeline.take() { - handle.abort(); - } - } -} - -/// Gestionnaire multi-canaux. -pub struct ParadiseChannelManager { - channels: HashMap>, -} - -impl ParadiseChannelManager { - pub fn new(channels: HashMap>) -> Self { - Self { channels } - } - - pub async fn with_defaults_with_cover_cache( - cover_cache: Option>, - history_builder: Option, - server_base_url: Option, - ) -> Result { - let mut map = HashMap::new(); - for descriptor in ALL_CHANNELS.iter().copied() { - let mut config = ParadiseStreamChannelConfig::default(); - config.server_base_url = server_base_url.clone(); - - let history_opts = if let Some(builder) = &history_builder { - Some( - builder - .build_for_channel(&descriptor) - .await - .map_err(|e| anyhow!("Failed to init history playlist: {}", e))?, - ) - } else { - None - }; - let channel = ParadiseStreamChannel::new( - descriptor, - config, - cover_cache.clone(), - history_opts, - ) - .await?; - map.insert(descriptor.id, Arc::new(channel)); - } - Ok(Self { channels: map }) - } - - pub async fn with_defaults() -> Result { - Self::with_defaults_with_cover_cache(None, None, None).await - } - - pub fn get(&self, id: u8) -> Option> { - self.channels.get(&id).cloned() - } - - pub fn iter(&self) -> impl Iterator> { - self.channels.values() - } -} --------End of pmoparadise/src/stream_channel_old.rs --------- - ------------- pmoparadise/src/stream_channel.rs ---------- -//! Version simplifiée de stream_channel.rs utilisant RadioParadisePlaylistFeeder + PlaylistSource -//! -//! Cette version remplace l'architecture complexe RadioParadiseStreamSource par : -//! - RadioParadisePlaylistFeeder : télécharge les URLs gapless et alimente une playlist -//! - PlaylistSource::with_history() : lit la playlist et gère l'historique automatiquement - -use std::{ - collections::HashMap, - pin::Pin, - sync::{ - atomic::{AtomicUsize, Ordering}, - Arc, - }, - task::{Context, Poll}, - time::{Duration, Instant, SystemTime, UNIX_EPOCH}, -}; - -use crate::{ - channels::{ChannelDescriptor, ParadiseChannelKind, ALL_CHANNELS}, - client::RadioParadiseClient, - models::{Block, EventId}, - playlist_feeder::RadioParadisePlaylistFeeder, -}; -use anyhow::{anyhow, Context as AnyhowContext, Result}; -use once_cell::sync::OnceCell; -use pmoaudio::{AudioError, AudioPipelineNode}; -use pmoaudio_ext::{ - FlacClientStream, IcyClientStream, MetadataSnapshot, OggFlacClientStream, OggFlacStreamHandle, - PlaylistSource, StreamHandle, StreamingFlacSink, StreamingOggFlacSink, StreamingSinkOptions, - TrackBoundaryCoverNode, -}; -use pmoaudiocache::{get_audio_cache, Cache as AudioCache}; -use pmocovers::{get_cover_cache, Cache as CoverCache}; -use pmoflac::EncoderOptions; -use pmoplaylist::PlaylistManager; -use thiserror::Error; -use tokio::io::{AsyncRead, ReadBuf}; -use tokio::sync::{Mutex, Notify}; -use tokio::task::JoinHandle; -use tokio_util::sync::CancellationToken; -use tracing::{error, info, warn}; - -/// Configuration pour un canal Radio Paradise. -#[derive(Clone, Debug)] -pub struct ParadiseStreamChannelConfig { - /// Durée maximale (en secondes) d'avance acceptée par le broadcast. - pub max_lead_seconds: f64, - /// Options pour le flux FLAC pur. - pub flac_options: StreamingSinkOptions, - /// Options pour le flux OGG-FLAC. - pub ogg_options: StreamingSinkOptions, - /// URL de base du serveur (pour les métadonnées, covers...) - pub server_base_url: Option, -} - -impl Default for ParadiseStreamChannelConfig { - fn default() -> Self { - Self { - max_lead_seconds: 3.0, // Compromis live/fluidité : assez pour absorber les transitions - flac_options: StreamingSinkOptions::flac_defaults(), - ogg_options: StreamingSinkOptions::ogg_defaults(), - server_base_url: None, - } - } -} - -/// Options pour activer l'archivage/historique d'un canal. -pub struct ParadiseHistoryOptions { - pub audio_cache: Arc, - pub cover_cache: Arc, - pub playlist_id: String, - pub collection: Option, - pub replay_max_lead_seconds: f64, - pub max_history_tracks: Option, -} - -/// Builder pratique pour configurer automatiquement les playlists historiques. -#[derive(Clone)] -pub struct ParadiseHistoryBuilder { - pub audio_cache: Arc, - pub cover_cache: Arc, - pub playlist_prefix: String, - pub playlist_title_prefix: Option, - pub max_history_tracks: Option, - pub collection_prefix: Option, - pub replay_max_lead_seconds: f64, -} - -impl ParadiseHistoryBuilder { - pub fn new(audio_cache: Arc, cover_cache: Arc) -> Self { - Self { - audio_cache, - cover_cache, - playlist_prefix: "radio-paradise-history".into(), - playlist_title_prefix: Some("Radio Paradise History".into()), - max_history_tracks: Some(500), - collection_prefix: Some("radio-paradise".into()), - replay_max_lead_seconds: 3.0, // Aligné avec le live - } - } - - pub async fn build_for_channel( - &self, - descriptor: &ChannelDescriptor, - ) -> Result { - let playlist_id = format!("{}-{}", self.playlist_prefix, descriptor.slug); - - let collection = self - .collection_prefix - .as_ref() - .map(|prefix| format!("{}-{}", prefix, descriptor.slug)); - - Ok(ParadiseHistoryOptions { - audio_cache: self.audio_cache.clone(), - cover_cache: self.cover_cache.clone(), - playlist_id, - collection, - replay_max_lead_seconds: self.replay_max_lead_seconds, - max_history_tracks: self.max_history_tracks, - }) - } -} - -impl Default for ParadiseHistoryBuilder { - fn default() -> Self { - let audio_cache = get_audio_cache() - .expect("pmoaudiocache::register_audio_cache must be called before using ParadiseHistoryBuilder::default()"); - let cover_cache = get_cover_cache() - .expect("pmocovers::register_cover_cache must be called before using ParadiseHistoryBuilder::default()"); - Self::new(audio_cache, cover_cache) - } -} - -#[cfg(feature = "pmoconfig")] -impl ParadiseStreamChannelConfig { - pub fn from_config(cfg: &pmoconfig::Config, channel: ParadiseChannelKind) -> Self { - use serde_yaml::Value; - let path = [ - "sources", - "radio_paradise", - "channels", - channel.slug(), - "max_lead_seconds", - ]; - match cfg.get_value(&path) { - Ok(Value::Number(num)) => { - if let Some(v) = num.as_f64() { - Self { - max_lead_seconds: v.max(0.1), - flac_options: StreamingSinkOptions::flac_defaults(), - ogg_options: StreamingSinkOptions::ogg_defaults(), - server_base_url: None, - } - } else { - let default = Self::default(); - let _ = - cfg.set_value(&path, Value::String(default.max_lead_seconds.to_string())); - default - } - } - Ok(Value::String(s)) => { - if let Ok(v) = s.parse::() { - Self { - max_lead_seconds: v.max(0.1), - flac_options: StreamingSinkOptions::flac_defaults(), - ogg_options: StreamingSinkOptions::ogg_defaults(), - server_base_url: None, - } - } else { - let default = Self::default(); - let _ = - cfg.set_value(&path, Value::String(default.max_lead_seconds.to_string())); - default - } - } - _ => { - let default = Self::default(); - let _ = cfg.set_value(&path, Value::String(default.max_lead_seconds.to_string())); - default - } - } - } -} - -/// Stream complet (FLAC pur + OGG-FLAC) pour un canal Radio Paradise. -/// -/// Version simplifiée utilisant RadioParadisePlaylistFeeder + PlaylistSource -pub struct ParadiseStreamChannel { - descriptor: ChannelDescriptor, - state: Arc, - pipeline_handle: JoinHandle<()>, - feeder_handle: JoinHandle<()>, -} - -impl ParadiseStreamChannel { - /// Crée un canal avec client déjà configuré. - pub async fn with_client( - descriptor: ChannelDescriptor, - client: RadioParadiseClient, - config: ParadiseStreamChannelConfig, - cover_cache: Option>, - history: Option, - ) -> Result { - // Propager server_base_url dans les options pour que les encoders injectent les covers du cache - let mut config = config; - if let Some(ref base) = config.server_base_url { - config.flac_options = config - .flac_options - .clone() - .with_server_base_url(Some(base.clone())); - config.ogg_options = config - .ogg_options - .clone() - .with_server_base_url(Some(base.clone())); - } - let cover_cache = cover_cache - .or_else(|| history.as_ref().map(|opts| opts.cover_cache.clone())) - .or_else(|| get_cover_cache()); - let manager = PlaylistManager::get(); - - // 1. Créer la playlist live pour ce canal - let live_playlist_id = format!("radio-paradise-live-{}", descriptor.slug); - let (feeder, live_read) = if let Some(ref history_opts) = history { - RadioParadisePlaylistFeeder::new( - client.clone(), - history_opts.audio_cache.clone(), - history_opts.cover_cache.clone(), - live_playlist_id.clone(), - history_opts.collection.clone(), - ) - .await? - } else { - // Pas d'historique, on a besoin quand même d'un cache audio basique - return Err(anyhow!( - "History options required for now (audio cache needed)" - )); - }; - - let feeder = Arc::new(feeder); - - // 2. Créer/récupérer la playlist historique si activée - let history_write = if let Some(ref history_opts) = history { - let write = manager - .get_persistent_write_handle(history_opts.playlist_id.clone()) - .await?; - - // Configurer la capacité - if let Some(capacity) = history_opts.max_history_tracks { - write.set_capacity(Some(capacity)).await?; - } - - // Configurer le titre - let title = format!("Radio Paradise History - {}", descriptor.display_name); - write.set_title(title).await?; - - Some(Arc::new(write)) - } else { - None - }; - - // 3. Créer la source playlist avec historique - let audio_cache = history.as_ref().unwrap().audio_cache.clone(); - let mut source = if let Some(history_write) = history_write.clone() { - PlaylistSource::with_history(live_read, audio_cache.clone(), history_write) - } else { - PlaylistSource::new(live_read, audio_cache.clone()) - }; - - // 4. Créer les sinks de broadcast (FLAC + OGG) - let (flac_sink, stream_handle) = StreamingFlacSink::with_options( - EncoderOptions::default(), - 16, - config.max_lead_seconds, - config.flac_options.clone(), - ); - let (ogg_sink, ogg_handle) = StreamingOggFlacSink::with_options( - EncoderOptions::default(), - 16, - config.max_lead_seconds, - config.ogg_options.clone(), - ); - - let mut downstream_children: Vec> = Vec::new(); - downstream_children.push(Box::new(flac_sink)); - downstream_children.push(Box::new(ogg_sink)); - - // 5. Optionnel : ajouter le nœud de cache de covers - if let Some(cache) = cover_cache { - let mut cover_node = TrackBoundaryCoverNode::new(cache); - for child in downstream_children { - cover_node.register(child); - } - source.register(Box::new(cover_node)); - } else { - for child in downstream_children { - source.register(child); - } - } - - stream_handle.set_auto_stop(false); - ogg_handle.set_auto_stop(false); - - // 6. Lancer le pipeline audio - let stop_token = CancellationToken::new(); - let pipeline_stop = stop_token.clone(); - let channel_display_name = descriptor.display_name; - - let state = Arc::new(ChannelState { - descriptor, - config, - client, - feeder: feeder.clone(), - stream_handle, - ogg_handle, - history_playlist_id: history.map(|h| h.playlist_id), - history_audio_cache: history_write.map(|_| audio_cache), - active_clients: AtomicUsize::new(0), - activity_notify: Notify::new(), - stop_token, - current_block: Mutex::new(None), - prefetch_lock: Mutex::new(()), - }); - - let pipeline_state = state.clone(); - let pipeline_handle = tokio::spawn(async move { - info!( - "RadioParadise stream pipeline started for channel {}", - channel_display_name - ); - if let Err(e) = Box::new(source).run(pipeline_stop).await { - error!("Pipeline error for channel {}: {}", channel_display_name, e); - pipeline_state.handle_pipeline_error(&e).await; - } - }); - - // 7. Lancer le feeder qui traite les blocs - let feeder_runner = feeder.clone(); - tokio::spawn(async move { - if let Err(e) = feeder_runner.run().await { - error!("RadioParadisePlaylistFeeder error: {}", e); - } - }); - - // 8. Lancer le scheduler qui enqueue les blocs - let feeder_state = state.clone(); - let feeder_handle = tokio::spawn(async move { - feeder_state.run_scheduler().await; - }); - - Ok(Self { - descriptor, - state, - pipeline_handle, - feeder_handle, - }) - } - - /// Crée un canal en construisant automatiquement le client pour ce descriptor. - pub async fn new( - descriptor: ChannelDescriptor, - config: ParadiseStreamChannelConfig, - cover_cache: Option>, - history: Option, - ) -> Result { - let client = RadioParadiseClient::builder() - .channel(descriptor.id) - .build() - .await?; - Self::with_client(descriptor, client, config, cover_cache, history).await - } - - /// S'abonne au flux FLAC pur. - pub fn subscribe_flac(&self) -> ChannelFlacStream { - self.state.on_client_added(); - let inner = self.state.stream_handle.subscribe_flac(); - ChannelFlacStream::new(inner, self.state.clone()) - } - - /// S'abonne au flux FLAC + ICY metadata. - pub fn subscribe_icy(&self) -> ChannelIcyStream { - self.state.on_client_added(); - let inner = self.state.stream_handle.subscribe_icy(); - ChannelIcyStream::new(inner, self.state.clone()) - } - - /// S'abonne au flux OGG-FLAC. - pub fn subscribe_ogg(&self) -> ChannelOggStream { - self.state.on_client_added(); - let inner = self.state.ogg_handle.subscribe(); - ChannelOggStream::new(inner, self.state.clone()) - } - - /// Snapshot des métadonnées actuelles. - pub async fn metadata(&self) -> MetadataSnapshot { - self.state.stream_handle.get_metadata().await - } - - /// Nombre de clients actifs. - pub fn active_clients(&self) -> usize { - self.state.active_clients.load(Ordering::SeqCst) - } - - pub fn descriptor(&self) -> ChannelDescriptor { - self.descriptor - } - - /// Lance un pipeline dédié pour rejouer l'historique (FLAC pur) pour un client. - pub async fn stream_history_flac( - &self, - client_id: &str, - ) -> Result { - let history_id = self - .state - .history_playlist_id - .as_ref() - .ok_or(HistoryStreamError::HistoryDisabled)?; - - let audio_cache = self - .state - .history_audio_cache - .as_ref() - .ok_or(HistoryStreamError::HistoryDisabled)?; - - tracing::info!( - "Starting historical FLAC replay for channel {} (client_id={})", - self.descriptor.display_name, - client_id - ); - - let reader = pmoplaylist::PlaylistManager::get() - .get_read_handle(history_id) - .await - .map_err(|e| HistoryStreamError::Playlist(e.to_string()))?; - - let mut source = PlaylistSource::new(reader, audio_cache.clone()); - let (flac_sink, handle) = StreamingFlacSink::with_max_broadcast_lead( - EncoderOptions::default(), - 16, - self.state.config.max_lead_seconds, - ); - source.register(Box::new(flac_sink)); - let stop_token = CancellationToken::new(); - let stop_clone = stop_token.clone(); - let pipeline = tokio::spawn(async move { - let _ = Box::new(source).run(stop_clone).await; - }); - let stream = handle.subscribe_flac(); - Ok(HistoryFlacStream::new(stream, stop_token, pipeline)) - } - - /// Lance un pipeline dédié pour rejouer l'historique (OGG-FLAC) pour un client. - pub async fn stream_history_ogg( - &self, - client_id: &str, - ) -> Result { - let history_id = self - .state - .history_playlist_id - .as_ref() - .ok_or(HistoryStreamError::HistoryDisabled)?; - - let audio_cache = self - .state - .history_audio_cache - .as_ref() - .ok_or(HistoryStreamError::HistoryDisabled)?; - - tracing::info!( - "Starting historical OGG replay for channel {} (client_id={})", - self.descriptor.display_name, - client_id - ); - - let reader = pmoplaylist::PlaylistManager::get() - .get_read_handle(history_id) - .await - .map_err(|e| HistoryStreamError::Playlist(e.to_string()))?; - - let mut source = PlaylistSource::new(reader, audio_cache.clone()); - let (ogg_sink, handle) = StreamingOggFlacSink::with_max_broadcast_lead( - EncoderOptions::default(), - 16, - self.state.config.max_lead_seconds, - ); - source.register(Box::new(ogg_sink)); - let stop_token = CancellationToken::new(); - let stop_clone = stop_token.clone(); - let pipeline = tokio::spawn(async move { - let _ = Box::new(source).run(stop_clone).await; - }); - let stream = handle.subscribe(); - Ok(HistoryOggStream::new(stream, stop_token, pipeline)) - } -} - -impl Drop for ParadiseStreamChannel { - fn drop(&mut self) { - self.state.stop_token.cancel(); - self.pipeline_handle.abort(); - self.feeder_handle.abort(); - } -} - -const MAX_BLOCK_LEAD: Duration = Duration::from_secs(3600); -const BLOCK_LEAD_CHECK_CHUNK: Duration = Duration::from_secs(300); -const LIVE_PREFETCH_MIN_TRACKS: usize = 5; -const LIVE_PREFETCH_TIMEOUT: Duration = Duration::from_secs(10); -const LIVE_PREFETCH_POLL_INTERVAL: Duration = Duration::from_millis(200); -const LIVE_PREFETCH_MAX_BLOCKS: usize = 4; - -static GLOBAL_CHANNEL_MANAGER: OnceCell> = OnceCell::new(); - -struct ChannelState { - descriptor: ChannelDescriptor, - config: ParadiseStreamChannelConfig, - client: RadioParadiseClient, - feeder: Arc, - stream_handle: StreamHandle, - ogg_handle: OggFlacStreamHandle, - history_playlist_id: Option, - history_audio_cache: Option>, - active_clients: AtomicUsize, - activity_notify: Notify, - stop_token: CancellationToken, - current_block: Mutex>, - prefetch_lock: Mutex<()>, -} - -impl ChannelState { - fn current_unix_millis() -> u64 { - SystemTime::now() - .duration_since(UNIX_EPOCH) - .map(|d| d.as_millis() as u64) - .unwrap_or(0) - } - - fn block_lead_delay(&self, block: &Block) -> Option { - let start = block.start_time_millis()?; - let now = Self::current_unix_millis(); - let max_lead_ms = MAX_BLOCK_LEAD.as_millis() as u64; - if start <= now + max_lead_ms { - None - } else { - Some(Duration::from_millis(start - now - max_lead_ms)) - } - } - - fn on_client_added(&self) { - if self.active_clients.fetch_add(1, Ordering::SeqCst) == 0 { - self.activity_notify.notify_one(); - } - } - - fn on_client_removed(&self) { - self.active_clients.fetch_sub(1, Ordering::SeqCst); - } - - async fn wait_for_clients(&self) -> bool { - while self.active_clients.load(Ordering::SeqCst) == 0 { - tokio::select! { - _ = self.stop_token.cancelled() => return false, - _ = self.activity_notify.notified() => {}, - } - } - true - } - - async fn wait_until_block_ready(&self, block: &Block) -> BlockReadiness { - loop { - if self.stop_token.is_cancelled() { - return BlockReadiness::Stopped; - } - if self.active_clients.load(Ordering::SeqCst) == 0 { - return BlockReadiness::NoClients; - } - - if let Some(delay) = self.block_lead_delay(block) { - let sleep_for = delay.min(BLOCK_LEAD_CHECK_CHUNK); - let lead_secs = delay.as_secs_f64(); - info!( - "Block {} scheduled too far in the future ({:.1} min). Sleeping {:?} before retrying.", - block.event, - lead_secs / 60.0, - sleep_for - ); - tokio::select! { - _ = self.stop_token.cancelled() => return BlockReadiness::Stopped, - _ = tokio::time::sleep(sleep_for) => {}, - } - continue; - } - - return BlockReadiness::Ready; - } - } - - fn live_playlist_id(&self) -> String { - format!("radio-paradise-live-{}", self.descriptor.slug) - } - - async fn prefetch_until_horizon(&self) -> Result<()> { - let _guard = self.prefetch_lock.lock().await; - let playlist_id = self.live_playlist_id(); - let manager = PlaylistManager::get(); - let reader = manager - .get_read_handle(&playlist_id) - .await - .with_context(|| format!("Failed to get live playlist {}", playlist_id))?; - let start = Instant::now(); - let mut next_event: Option = None; - let mut attempts = 0usize; - - loop { - let available = reader - .remaining() - .await - .with_context(|| format!("Failed to inspect playlist {}", playlist_id))?; - if available >= LIVE_PREFETCH_MIN_TRACKS { - return Ok(()); - } - - if start.elapsed() >= LIVE_PREFETCH_TIMEOUT { - warn!( - "Prefetch timeout for channel {} ({} tracks available)", - self.descriptor.display_name, available - ); - return Ok(()); - } - - if attempts >= LIVE_PREFETCH_MAX_BLOCKS { - warn!( - "Prefetch block limit reached for channel {} ({} tracks available)", - self.descriptor.display_name, available - ); - return Ok(()); - } - - match self.client.get_block(next_event).await { - Ok(block) => { - attempts += 1; - next_event = Some(block.end_event); - self.feeder.push_block_id(block.event).await; - } - Err(e) => { - warn!( - "Failed to fetch block during prefetch for channel {}: {}", - self.descriptor.display_name, e - ); - return Ok(()); - } - } - - tokio::time::sleep(LIVE_PREFETCH_POLL_INTERVAL).await; - } - } - - async fn set_current_block(&self, event_id: EventId) { - let mut guard = self.current_block.lock().await; - *guard = Some(event_id); - } - - async fn take_current_block(&self) -> Option { - self.current_block.lock().await.take() - } - - async fn handle_pipeline_error(&self, err: &AudioError) { - if let Some(event_id) = self.take_current_block().await { - warn!( - "Pipeline error while streaming block {} on channel {}: {}. Rescheduling block.", - event_id, self.descriptor.display_name, err - ); - self.feeder.retry_block(event_id).await; - } else { - warn!( - "Pipeline error for channel {} but no tracked block: {}", - self.descriptor.display_name, err - ); - } - } - - async fn run_scheduler(self: Arc) { - let mut backoff = Duration::from_secs(5); - 'scheduler: loop { - if self.stop_token.is_cancelled() { - break; - } - - if !self.wait_for_clients().await { - break; - } - - match self.client.get_block(None).await { - Ok(block) => { - match self.wait_until_block_ready(&block).await { - BlockReadiness::Ready => {} - BlockReadiness::NoClients => continue, - BlockReadiness::Stopped => break, - } - info!( - "Channel {} streaming block {}", - self.descriptor.display_name, block.event - ); - self.set_current_block(block.event).await; - self.feeder.push_block_id(block.event).await; - let mut next_event = block.end_event; - - loop { - if self.stop_token.is_cancelled() { - return; - } - - if self.active_clients.load(Ordering::SeqCst) == 0 { - break; - } - - match self.client.get_block(Some(next_event)).await { - Ok(next_block) => { - match self.wait_until_block_ready(&next_block).await { - BlockReadiness::Ready => {} - BlockReadiness::NoClients => break, - BlockReadiness::Stopped => break 'scheduler, - } - self.set_current_block(next_block.event).await; - self.feeder.push_block_id(next_block.event).await; - next_event = next_block.end_event; - backoff = Duration::from_secs(5); - } - Err(e) => { - warn!( - "Failed to fetch next block for channel {}: {}", - self.descriptor.display_name, e - ); - tokio::select! { - _ = self.stop_token.cancelled() => return, - _ = tokio::time::sleep(backoff) => {}, - } - backoff = (backoff * 2).min(Duration::from_secs(60)); - } - } - } - } - Err(e) => { - warn!( - "Failed to fetch current block for channel {}: {}", - self.descriptor.display_name, e - ); - tokio::select! { - _ = self.stop_token.cancelled() => break, - _ = tokio::time::sleep(backoff) => {}, - } - backoff = (backoff * 2).min(Duration::from_secs(60)); - } - } - } - } -} - -enum BlockReadiness { - Ready, - NoClients, - Stopped, -} - -macro_rules! wrap_stream { - ($name:ident, $inner:ty) => { - pub struct $name { - inner: $inner, - state: Arc, - } - - impl $name { - fn new(inner: $inner, state: Arc) -> Self { - Self { inner, state } - } - } - - impl AsyncRead for $name { - fn poll_read( - mut self: Pin<&mut Self>, - cx: &mut Context<'_>, - buf: &mut ReadBuf<'_>, - ) -> Poll> { - Pin::new(&mut self.inner).poll_read(cx, buf) - } - } - - impl Drop for $name { - fn drop(&mut self) { - self.state.on_client_removed(); - } - } - }; -} - -wrap_stream!(ChannelFlacStream, FlacClientStream); -wrap_stream!(ChannelIcyStream, IcyClientStream); -wrap_stream!(ChannelOggStream, OggFlacClientStream); - -#[derive(Debug, Error)] -pub enum HistoryStreamError { - #[error("history replay not enabled for this channel")] - HistoryDisabled, - #[error("playlist error: {0}")] - Playlist(String), -} - -pub struct HistoryFlacStream { - inner: FlacClientStream, - stop_token: CancellationToken, - pipeline: Option>, -} - -impl HistoryFlacStream { - fn new( - inner: FlacClientStream, - stop_token: CancellationToken, - pipeline: JoinHandle<()>, - ) -> Self { - Self { - inner, - stop_token, - pipeline: Some(pipeline), - } - } -} - -impl AsyncRead for HistoryFlacStream { - fn poll_read( - mut self: Pin<&mut Self>, - cx: &mut Context<'_>, - buf: &mut ReadBuf<'_>, - ) -> Poll> { - Pin::new(&mut self.inner).poll_read(cx, buf) - } -} - -impl Unpin for HistoryFlacStream {} - -impl Drop for HistoryFlacStream { - fn drop(&mut self) { - self.stop_token.cancel(); - if let Some(handle) = self.pipeline.take() { - handle.abort(); - } - } -} - -pub struct HistoryOggStream { - inner: OggFlacClientStream, - stop_token: CancellationToken, - pipeline: Option>, -} - -impl HistoryOggStream { - fn new( - inner: OggFlacClientStream, - stop_token: CancellationToken, - pipeline: JoinHandle<()>, - ) -> Self { - Self { - inner, - stop_token, - pipeline: Some(pipeline), - } - } -} - -impl AsyncRead for HistoryOggStream { - fn poll_read( - mut self: Pin<&mut Self>, - cx: &mut Context<'_>, - buf: &mut ReadBuf<'_>, - ) -> Poll> { - Pin::new(&mut self.inner).poll_read(cx, buf) - } -} - -impl Unpin for HistoryOggStream {} - -impl Drop for HistoryOggStream { - fn drop(&mut self) { - self.stop_token.cancel(); - if let Some(handle) = self.pipeline.take() { - handle.abort(); - } - } -} - -/// Gestionnaire multi-canaux. -pub struct ParadiseChannelManager { - channels: HashMap>, -} - -impl ParadiseChannelManager { - pub fn new(channels: HashMap>) -> Self { - Self { channels } - } - - pub async fn with_defaults_with_cover_cache( - cover_cache: Option>, - history_builder: Option, - server_base_url: Option, - ) -> Result { - tracing::warn!( - "➡️ Entering with_defaults_with_cover_cache ({} channels, base_url={:?})", - ALL_CHANNELS.len(), - server_base_url - ); - let mut map = HashMap::new(); - for descriptor in ALL_CHANNELS.iter().copied() { - let mut config = ParadiseStreamChannelConfig::default(); - config.server_base_url = server_base_url.clone(); - - let start = Instant::now(); - tracing::warn!( - "⏳ Initializing Radio Paradise channel {} ({})...", - descriptor.display_name, - descriptor.slug - ); - - let history_opts = if let Some(builder) = &history_builder { - tracing::warn!( - " ⏳ Building history options for channel {} ({})", - descriptor.display_name, - descriptor.slug - ); - Some( - builder - .build_for_channel(&descriptor) - .await - .map_err(|e| anyhow!("Failed to init history playlist: {}", e))?, - ) - } else { - None - }; - tracing::warn!( - " ⏩ History options ready for channel {} ({})", - descriptor.display_name, - descriptor.slug - ); - let channel = match tokio::time::timeout( - Duration::from_secs(20), - ParadiseStreamChannel::new(descriptor, config, cover_cache.clone(), history_opts), - ) - .await - { - Ok(Ok(ch)) => { - tracing::warn!( - "✅ Channel {} ({}) initialized in {:?}", - descriptor.display_name, - descriptor.slug, - start.elapsed() - ); - ch - } - Ok(Err(e)) => { - tracing::error!( - "⚠️ Failed to initialize channel {} ({}): {}", - descriptor.display_name, - descriptor.slug, - e - ); - continue; - } - Err(_) => { - tracing::error!( - "⚠️ Timeout initializing channel {} ({}) after 20s, skipping", - descriptor.display_name, - descriptor.slug - ); - continue; - } - }; - map.insert(descriptor.id, Arc::new(channel)); - } - Ok(Self { channels: map }) - } - - pub async fn with_defaults() -> Result { - Self::with_defaults_with_cover_cache(None, None, None).await - } - - pub fn get(&self, id: u8) -> Option> { - self.channels.get(&id).cloned() - } - - pub fn iter(&self) -> impl Iterator> { - self.channels.values() - } - - pub async fn prefetch_until_horizon(&self, channel_id: u8) -> Result<()> { - let channel = self - .get(channel_id) - .ok_or_else(|| anyhow!("Unknown channel id {}", channel_id))?; - channel.prefetch_until_horizon().await - } -} - -pub fn register_global_channel_manager(manager: Arc) { - let _ = GLOBAL_CHANNEL_MANAGER.set(Arc::downgrade(&manager)); -} - -pub fn get_global_channel_manager() -> Option> { - GLOBAL_CHANNEL_MANAGER.get().and_then(|weak| weak.upgrade()) -} - -impl ParadiseStreamChannel { - pub async fn prefetch_until_horizon(&self) -> Result<()> { - self.state.prefetch_until_horizon().await - } -} --------End of pmoparadise/src/stream_channel.rs --------- - ------------- pmoparadise/examples/download_block.rs ---------- -//! Télécharge un bloc complet de Radio Paradise et sauvegarde toutes les pistes en FLAC -//! -//! Ce programme démontre l'utilisation de la chaîne : -//! 1. RadioParadiseStreamSource - Télécharge et décode un bloc FLAC de Radio Paradise -//! 2. FlacFileSink - Sauvegarde automatiquement chaque piste dans un fichier FLAC séparé -//! -//! La nouvelle architecture AudioPipelineNode permet de : -//! - Télécharger et décoder automatiquement les blocs FLAC de Radio Paradise -//! - Détecter les limites de pistes (TrackBoundary) -//! - Sauvegarder automatiquement chaque piste dans un fichier séparé -//! - Gérer proprement l'arrêt du pipeline avec un CancellationToken -//! -//! Usage: -//! cargo run --example download_block -- -//! -//! Exemple: -//! cargo run --example download_block -- 0 # Main Mix -//! cargo run --example download_block -- 1 # Mellow Mix -//! cargo run --example download_block -- 2 # Rock Mix -//! cargo run --example download_block -- 3 # World/Etc Mix - -use pmoaudio::{AudioPipelineNode, FlacFileSink}; -use pmoparadise::{RadioParadiseClient, RadioParadiseStreamSource}; -use std::env; -use tokio_util::sync::CancellationToken; - -#[tokio::main] -async fn main() -> Result<(), Box> { - // Initialiser tracing pour le debug - tracing_subscriber::fmt() - .with_env_filter( - tracing_subscriber::EnvFilter::from_default_env() - .add_directive(tracing::Level::INFO.into()), - ) - .init(); - - // Récupérer les arguments - let args: Vec = env::args().collect(); - if args.len() != 2 { - eprintln!("Usage: {} ", args[0]); - eprintln!(); - eprintln!("Downloads a complete Radio Paradise block and saves all tracks as FLAC files."); - eprintln!(); - eprintln!("Channel IDs:"); - eprintln!(" 0 - Main Mix (eclectic, diverse mix)"); - eprintln!(" 1 - Mellow Mix (smooth, chilled music)"); - eprintln!(" 2 - Rock Mix (classic & modern rock)"); - eprintln!(" 3 - World/Etc Mix (global sounds)"); - eprintln!(); - eprintln!("Example:"); - eprintln!(" {} 0 # Download Main Mix", args[0]); - eprintln!(" {} 2 # Download Rock Mix", args[0]); - std::process::exit(1); - } - - let channel_id: u8 = match args[1].parse() { - Ok(id) => id, - Err(_) => { - eprintln!("Error: channel_id must be a number between 0 and 3"); - std::process::exit(1); - } - }; - - if channel_id > 3 { - eprintln!("Error: channel_id must be between 0 and 3"); - std::process::exit(1); - } - - println!("=== Radio Paradise Block Downloader ==="); - println!(); - println!("Channel ID: {}", channel_id); - println!(); - - // Créer le client Radio Paradise pour le channel spécifié - println!("Fetching current block metadata..."); - let client = RadioParadiseClient::builder() - .channel(channel_id) - .build() - .await?; - - // Récupérer le bloc actuel - let block = client.get_block(None).await?; - - println!("Block Information:"); - println!(" Event ID: {}", block.event); - println!(" Songs: {}", block.song_count()); - println!(" Duration: {:.1} minutes", block.length as f64 / 60000.0); - println!(); - - // Afficher la liste des pistes - println!("Tracklist:"); - for (index, song) in block.songs_ordered() { - println!( - " {:2}. {} - {} ({})", - index + 1, - song.artist, - song.title, - song.album.as_deref().unwrap_or("Unknown Album") - ); - } - println!(); - - // Créer le répertoire de sortie - let output_dir = format!("./rp_channel_{}block{}", channel_id, block.event); - std::fs::create_dir_all(&output_dir)?; - println!("Output directory: {}", output_dir); - println!(); - - // Créer le pipeline: RadioParadiseStreamSource → FlacFileSink - let mut source = RadioParadiseStreamSource::new(client); - - // Ajouter le bloc à télécharger - source.push_block_id(block.event); - - // Créer le sink qui sauvegarde chaque piste dans un fichier séparé - let base_path = format!("{}/track.flac", output_dir); - let sink = FlacFileSink::new(&base_path); - - // Construire la chaîne: source → sink - source.register(Box::new(sink)); - - // Créer un token d'arrêt - let stop_token = CancellationToken::new(); - - // Gérer Ctrl+C pour arrêt propre - let stop_token_clone = stop_token.clone(); - tokio::spawn(async move { - tokio::signal::ctrl_c().await.ok(); - println!("\n\nReceived Ctrl+C, stopping..."); - stop_token_clone.cancel(); - }); - - // Lancer tout le pipeline - println!("Downloading and processing block..."); - println!("Press Ctrl+C to stop."); - println!(); - let start = std::time::Instant::now(); - - let result = Box::new(source).run(stop_token).await; - - let elapsed = start.elapsed(); - - // Vérifier le résultat - match result { - Ok(()) => { - println!(); - println!( - "✓ Download completed successfully in {:.2}s", - elapsed.as_secs_f64() - ); - println!(" Output directory: {}", output_dir); - println!(); - - // Afficher les fichiers créés - let entries = std::fs::read_dir(&output_dir)?; - let mut files: Vec<_> = entries - .filter_map(|e| e.ok()) - .filter(|e| { - e.path() - .extension() - .and_then(|s| s.to_str()) - .map(|s| s == "flac") - .unwrap_or(false) - }) - .collect(); - files.sort_by_key(|e| e.path()); - - println!("Files created:"); - for (i, entry) in files.iter().enumerate() { - let path = entry.path(); - let metadata = std::fs::metadata(&path)?; - let size_mb = metadata.len() as f64 / (1024.0 * 1024.0); - println!( - " {:2}. {} ({:.2} MB)", - i + 1, - path.file_name().unwrap().to_string_lossy(), - size_mb - ); - } - println!(); - - // Calculer la taille totale - let total_size: u64 = files - .iter() - .filter_map(|e| std::fs::metadata(e.path()).ok()) - .map(|m| m.len()) - .sum(); - println!( - "Total size: {:.2} MB", - total_size as f64 / (1024.0 * 1024.0) - ); - } - Err(e) => { - eprintln!(); - eprintln!("✗ Download error: {}", e); - eprintln!(); - return Err(e.into()); - } - } - - Ok(()) -} --------End of pmoparadise/examples/download_block.rs --------- - ------------- pmoparadise/examples/now_playing.rs ---------- -//! Example: Display currently playing song and block information -//! -//! This example demonstrates: -//! - Creating a Radio Paradise client -//! - Fetching the current block -//! - Displaying song metadata -//! - Generating cover image URLs -//! -//! Run with: cargo run --example now_playing - -use pmoparadise::{RadioParadiseClient, Result}; - -#[tokio::main] -async fn main() -> Result<()> { - // Initialize logging (optional) - #[cfg(feature = "logging")] - tracing_subscriber::fmt::init(); - - println!("Radio Paradise - Now Playing"); - println!("=============================\n"); - - // Create client with default settings (FLAC quality, channel 0) - let client = RadioParadiseClient::new().await?; - - // Get what's currently playing - let now_playing = client.now_playing().await?; - let block = &now_playing.block; - - // Display block information - println!("Block Information:"); - println!(" Event ID: {}", block.event); - println!(" Next Event: {}", block.end_event); - println!(" Duration: {:.1} minutes", block.length as f64 / 60000.0); - println!(" Songs in block: {}", block.song_count()); - println!(" Stream URL: {}\n", block.url); - - // Display current song (if available) - if let Some(song) = &now_playing.current_song { - println!("Now Playing:"); - println!(" Title: {}", song.title); - println!(" Artist: {}", song.artist); - if let Some(ref album) = song.album { - println!(" Album: {}", album); - } - if let Some(year) = song.year { - println!(" Year: {}", year); - } - if let Some(rating) = song.rating { - println!(" Rating: {:.1}/10", rating); - } - println!( - " Duration: {}:{:02}", - song.duration / 60000, - (song.duration % 60000) / 1000 - ); - - // Display cover URL - if let Some(cover) = &song.cover { - if let Some(cover_url) = block.cover_url(cover) { - println!(" Cover: {}", cover_url); - } - } - println!(); - } - - // Display all songs in the block - println!("All Songs in This Block:"); - println!("------------------------"); - - for (index, song) in block.songs_ordered() { - let start_sec = song.elapsed / 1000; - let duration_sec = song.duration / 1000; - - println!( - "{}. [{:02}:{:02}] {} - {} ({:02}:{:02})", - index + 1, - start_sec / 60, - start_sec % 60, - song.artist, - song.title, - duration_sec / 60, - duration_sec % 60 - ); - if let Some(ref album) = song.album { - println!(" Album: {}", album); - } - - if let Some(year) = song.year { - print!(" Year: {}", year); - } - if let Some(rating) = song.rating { - print!(" Rating: {:.1}/10", rating); - } - println!("\n"); - } - - // Show how to get the next block - println!("Fetching Next Block..."); - let next_block = client.get_block(Some(block.end_event)).await?; - println!(" Next block event: {}", next_block.event); - println!(" Songs in next block: {}", next_block.song_count()); - - if let Some((_, first_song)) = next_block.songs_ordered().first() { - println!(" First song: {} - {}", first_song.artist, first_song.title); - } - - Ok(()) -} --------End of pmoparadise/examples/now_playing.rs --------- - ------------- pmoparadise/examples/play_and_cache.rs ---------- -//! Télécharge un bloc Radio Paradise, le cache, et le joue en même temps -//! -//! Ce programme démontre l'utilisation complète de la chaîne : -//! 1. RadioParadiseStreamSource - Télécharge et décode un bloc FLAC -//! 2. FlacCacheSink - Cache chaque piste en FLAC et alimente une playlist -//! 3. PlaylistSource - Lit la playlist pendant le téléchargement -//! 4. TimerNode - Régule le débit pour éviter EOF prématurés (progressive cache) -//! 5. AudioSink - Joue l'audio sur la sortie standard -//! -//! Architecture : -//! ```text -//! Pipeline 1 (Download & Cache): -//! RadioParadiseStreamSource → FlacCacheSink (avec playlist abonnée) -//! -//! Pipeline 2 (Playback): -//! PlaylistSource → TimerNode (rate limiting) → AudioSink -//! ↓ -//! Prévention EOF -//! (3s max lead) -//! ``` -//! -//! Usage: -//! cargo run --example play_and_cache --features full -- -//! -//! Exemple: -//! cargo run --example play_and_cache --features full -- 0 # Main Mix -//! cargo run --example play_and_cache --features full -- 2 # Rock Mix - -use pmoaudio::{AudioPipelineNode, AudioSink, TimerNode}; -use pmoaudio_ext::{FlacCacheSink, PlaylistSource}; -use pmoaudiocache::{ - new_cache_with_consolidation as new_audio_cache, - register_audio_cache as register_global_audio_cache, -}; -use pmocovers::{new_cache_with_consolidation as new_cover_cache, register_cover_cache}; -use pmoparadise::{RadioParadiseClient, RadioParadiseStreamSource}; -use pmoplaylist::register_audio_cache as register_playlist_audio_cache; -use std::env; -use std::sync::Arc; -use tokio_util::sync::CancellationToken; - -#[tokio::main] -async fn main() -> Result<(), Box> { - // Initialiser tracing avec beaucoup de logs - tracing_subscriber::fmt() - .with_env_filter( - tracing_subscriber::EnvFilter::from_default_env() - .add_directive(tracing::Level::DEBUG.into()) - .add_directive("pmoaudio=debug".parse()?) - .add_directive("pmoaudio_ext=debug".parse()?) - .add_directive("pmoplaylist=debug".parse()?) - .add_directive("pmoparadise=debug".parse()?) - .add_directive("pmoaudiocache=debug".parse()?), - ) - .init(); - - tracing::info!("=== Radio Paradise Play & Cache ==="); - - // Récupérer les arguments - let args: Vec = env::args().collect(); - if args.len() < 2 { - eprintln!("Usage: {} [--null-audio]", args[0]); - eprintln!(); - eprintln!("Downloads a Radio Paradise block, caches it, and plays it simultaneously."); - eprintln!(); - eprintln!("Channel IDs:"); - eprintln!(" 0 - Main Mix (eclectic, diverse mix)"); - eprintln!(" 1 - Mellow Mix (smooth, chilled music)"); - eprintln!(" 2 - Rock Mix (classic & modern rock)"); - eprintln!(" 3 - World/Etc Mix (global sounds)"); - eprintln!(); - eprintln!("Options:"); - eprintln!(" --null-audio Don't play audio (for testing without audio device)"); - std::process::exit(1); - } - - let channel_id: u8 = match args[1].parse() { - Ok(id) if id <= 3 => id, - _ => { - eprintln!("Error: channel_id must be a number between 0 and 3"); - std::process::exit(1); - } - }; - - let use_null_audio = args.len() > 2 && args[2] == "--null-audio"; - - tracing::info!("Channel ID: {}", channel_id); - if use_null_audio { - tracing::info!("Using null audio output (no playback)"); - } - - // ═══════════════════════════════════════════════════════════════════════════ - // Initialiser les caches et le gestionnaire de playlist - // ═══════════════════════════════════════════════════════════════════════════ - - let base_dir = - std::env::var("PMO_CONFIG_DIR").unwrap_or_else(|_| "/tmp/pmomusic_test".to_string()); - std::fs::create_dir_all(&base_dir)?; - - tracing::info!("Initializing caches in: {}", base_dir); - - // Créer le cache audio - let audio_cache_dir = format!("{}/audio_cache", base_dir); - std::fs::create_dir_all(&audio_cache_dir)?; - let audio_cache = new_audio_cache(&audio_cache_dir, 1000).await?; - tracing::debug!("Audio cache initialized at: {}", audio_cache_dir); - - // Créer le cache de covers - let cover_cache_dir = format!("{}/cover_cache", base_dir); - std::fs::create_dir_all(&cover_cache_dir)?; - let cover_cache = new_cover_cache(&cover_cache_dir, 100).await?; - tracing::debug!("Cover cache initialized at: {}", cover_cache_dir); - - // Enregistrer le cache audio dans pmoplaylist - // (requis par pmoplaylist pour valider les pks) - register_global_audio_cache(audio_cache.clone()); - register_playlist_audio_cache(audio_cache.clone()); - register_cover_cache(cover_cache.clone()); - tracing::debug!("Audio cache registered in pmoplaylist"); - - // Utiliser le gestionnaire de playlist singleton - tracing::info!("Getting playlist manager..."); - let playlist_manager = pmoplaylist::PlaylistManager(); - tracing::debug!("Playlist manager obtained"); - - // ═══════════════════════════════════════════════════════════════════════════ - // Créer la playlist pour ce channel - // ═══════════════════════════════════════════════════════════════════════════ - - let playlist_id = format!("radio-paradise-ch{}", channel_id); - tracing::info!("Creating playlist: {}", playlist_id); - - // Créer une playlist éphémère (non persistante) pour cet exemple - let writer = playlist_manager - .get_write_handle(playlist_id.clone()) - .await?; - writer - .set_title(format!("Radio Paradise - Channel {}", channel_id)) - .await?; - writer.flush().await?; // Vider la playlist si elle existait - tracing::debug!("Playlist created and flushed"); - - // Créer le reader pour la lecture - let reader = playlist_manager.get_read_handle(&playlist_id).await?; - tracing::debug!("Read handle created"); - - // ═══════════════════════════════════════════════════════════════════════════ - // Récupérer les infos du bloc à télécharger - // ═══════════════════════════════════════════════════════════════════════════ - - tracing::info!("Fetching current block metadata..."); - let client = RadioParadiseClient::builder() - .channel(channel_id) - .build() - .await?; - - let block = client.get_block(None).await?; - - tracing::info!("Block Information:"); - tracing::info!(" Event ID: {}", block.event); - tracing::info!(" Songs: {}", block.song_count()); - tracing::info!(" Duration: {:.1} minutes", block.length as f64 / 60000.0); - tracing::info!(""); - - tracing::info!("Tracklist:"); - for (index, song) in block.songs_ordered() { - tracing::info!( - " {:2}. {} - {} ({})", - index + 1, - song.artist, - song.title, - song.album.as_deref().unwrap_or("Unknown Album") - ); - } - tracing::info!(""); - - // ═══════════════════════════════════════════════════════════════════════════ - // Pipeline 1: Téléchargement et cache - // ═══════════════════════════════════════════════════════════════════════════ - - tracing::info!("Creating download pipeline..."); - - // Créer la source Radio Paradise - let mut download_source = RadioParadiseStreamSource::new(client); - download_source.push_block_id(block.event); - tracing::debug!( - "RadioParadiseStreamSource created with block {}", - block.event - ); - - // Créer le sink de cache FLAC - let mut cache_sink = FlacCacheSink::new(audio_cache.clone(), cover_cache.clone()); - cache_sink.register_playlist(writer); - tracing::debug!("FlacCacheSink created and registered with playlist"); - - // Connecter source → sink - download_source.register(Box::new(cache_sink)); - tracing::info!("Download pipeline connected: RadioParadiseStreamSource → FlacCacheSink"); - - // ═══════════════════════════════════════════════════════════════════════════ - // Pipeline 2: Lecture depuis la playlist - // ═══════════════════════════════════════════════════════════════════════════ - - tracing::info!("Creating playback pipeline..."); - - // Créer la source playlist - let mut playlist_source = PlaylistSource::new(reader, audio_cache.clone()); - tracing::debug!("PlaylistSource created"); - - // Créer le timer node pour réguler le débit (empêche EOF prématurés) - // Tolère 3 secondes d'avance max pour permettre le buffering - let mut timer = TimerNode::new(3.0); - tracing::debug!("TimerNode created (max_lead_time=3.0s)"); - - // Créer le sink audio - let audio_sink = if use_null_audio { - AudioSink::with_null_output() - } else { - AudioSink::new() - }; - tracing::debug!("AudioSink created"); - - // Connecter timer → audio (AVANT de mettre timer dans une Box) - timer.register(Box::new(audio_sink)); - - // Connecter playlist → timer - playlist_source.register(Box::new(timer)); - tracing::info!("Playback pipeline connected: PlaylistSource → TimerNode → AudioSink"); - - // ═══════════════════════════════════════════════════════════════════════════ - // Lancer les deux pipelines en parallèle - // ═══════════════════════════════════════════════════════════════════════════ - - tracing::info!(""); - tracing::info!("========================================"); - tracing::info!("Starting both pipelines..."); - tracing::info!("Pipeline 1: Downloading and caching"); - tracing::info!("Pipeline 2: Playing from playlist"); - tracing::info!("========================================"); - tracing::info!(""); - - let stop_token = CancellationToken::new(); - let stop_token_download = stop_token.clone(); - let stop_token_playback = stop_token.clone(); - - // Gérer Ctrl+C - let stop_token_ctrl_c = stop_token.clone(); - tokio::spawn(async move { - tokio::signal::ctrl_c().await.ok(); - tracing::warn!("Received Ctrl+C, stopping..."); - stop_token_ctrl_c.cancel(); - }); - - let start = std::time::Instant::now(); - - // Lancer les deux pipelines en parallèle - let download_handle = tokio::spawn(async move { - tracing::info!("[DOWNLOAD] Pipeline starting..."); - let result = Box::new(download_source).run(stop_token_download).await; - match &result { - Ok(()) => tracing::info!("[DOWNLOAD] Pipeline completed successfully"), - Err(e) => tracing::error!("[DOWNLOAD] Pipeline error: {}", e), - } - result - }); - - let playback_handle = tokio::spawn(async move { - // Pas de sleep - le cache progressif permet de démarrer immédiatement - // dès que le prebuffer (512 KB) est atteint - tracing::info!("[PLAYBACK] Pipeline starting (will wait for prebuffer)..."); - let result = Box::new(playlist_source).run(stop_token_playback).await; - match &result { - Ok(()) => tracing::info!("[PLAYBACK] Pipeline completed successfully"), - Err(e) => tracing::error!("[PLAYBACK] Pipeline error: {}", e), - } - result - }); - - // Attendre les deux pipelines - let (download_result, playback_result) = tokio::join!(download_handle, playback_handle); - - let elapsed = start.elapsed(); - - // Vérifier les résultats - match (download_result, playback_result) { - (Ok(Ok(())), Ok(Ok(()))) => { - tracing::info!(""); - tracing::info!("========================================"); - tracing::info!("✓ Both pipelines completed successfully"); - tracing::info!(" Total time: {:.2}s", elapsed.as_secs_f64()); - tracing::info!("========================================"); - } - (download_res, playback_res) => { - tracing::error!(""); - tracing::error!("========================================"); - if let Err(e) = download_res { - tracing::error!("✗ Download pipeline error: {:?}", e); - } else if let Ok(Err(e)) = download_res { - tracing::error!("✗ Download pipeline error: {}", e); - } - if let Err(e) = playback_res { - tracing::error!("✗ Playback pipeline error: {:?}", e); - } else if let Ok(Err(e)) = playback_res { - tracing::error!("✗ Playback pipeline error: {}", e); - } - tracing::error!("========================================"); - return Err("Pipeline error".into()); - } - } - - Ok(()) -} --------End of pmoparadise/examples/play_and_cache.rs --------- - ------------- pmoparadise/examples/serve_channels.rs ---------- -//! Minimal HTTP server exposing all four Radio Paradise channels. -//! -//! Routes: -//! - `/radioparadise/stream//flac` -//! - `/radioparadise/stream//ogg` -//! - `/radioparadise/stream//icy` -//! - `/radioparadise/stream//historic//flac` -//! - `/radioparadise/stream//historic//ogg` -//! - `/radioparadise/metadata/` - -use std::{fs, sync::Arc}; - -use axum::{ - body::Body, - extract::{Path, State}, - http::{ - header::{ACCEPT_RANGES, CACHE_CONTROL, CONNECTION, CONTENT_TYPE}, - StatusCode, - }, - response::{IntoResponse, Response}, - routing::get, - Json, Router, -}; -use pmoaudiocache::{ - new_cache_with_consolidation as new_audio_cache, - register_audio_cache as register_global_audio_cache, -}; -use pmocovers::{new_cache_with_consolidation as new_cover_cache, register_cover_cache}; -use pmoparadise::{channels::ALL_CHANNELS, ParadiseChannelManager, ParadiseHistoryBuilder}; -use pmoplaylist::register_audio_cache as register_playlist_audio_cache; -use pmoserver::{init_logging, ServerBuilder}; -use tokio_util::io::ReaderStream; -use tracing::{error, info}; - -#[derive(Clone)] -struct AppState { - manager: Arc, -} - -#[tokio::main] -async fn main() -> anyhow::Result<()> { - let _ = init_logging(); - - // Préparer les caches partagés - let cover_cache_dir = "./cache/rp_covers"; - let audio_cache_dir = "./cache/rp_audio"; - fs::create_dir_all(cover_cache_dir)?; - fs::create_dir_all(audio_cache_dir)?; - - let cover_cache = new_cover_cache(cover_cache_dir, 500).await?; - let audio_cache = new_audio_cache(audio_cache_dir, 1000).await?; - register_global_audio_cache(audio_cache.clone()); - register_playlist_audio_cache(audio_cache.clone()); - register_cover_cache(cover_cache.clone()); - let _playlist_manager = pmoplaylist::PlaylistManager(); - - let history_builder = ParadiseHistoryBuilder { - audio_cache: audio_cache.clone(), - cover_cache: cover_cache.clone(), - playlist_prefix: "radio-paradise-history".into(), - playlist_title_prefix: Some("Radio Paradise History".into()), - max_history_tracks: Some(500), - collection_prefix: Some("radioparadise".into()), - replay_max_lead_seconds: 1.0, - }; - - info!("Initializing Radio Paradise channels..."); - let server_base_url = format!("http://localhost:{}", 8080); - let manager = Arc::new( - ParadiseChannelManager::with_defaults_with_cover_cache( - Some(cover_cache), - Some(history_builder), - Some(server_base_url), - ) - .await?, - ); - let app_state = Arc::new(AppState { - manager: manager.clone(), - }); - - let mut server = ServerBuilder::new("RadioParadiseChannels", "http://localhost", 8080).build(); - - for descriptor in ALL_CHANNELS.iter() { - let slug = descriptor.slug; - let flac_path = format!("/radioparadise/stream/{}/flac", slug); - let ogg_path = format!("/radioparadise/stream/{}/ogg", slug); - let icy_path = format!("/radioparadise/stream/{}/icy", slug); - let history_path = format!("/radioparadise/stream/{}/historic", slug); - let meta_path = format!("/radioparadise/metadata/{}", slug); - let channel_id = descriptor.id; - - server - .add_handler_with_state( - &flac_path, - move |State(state): State>| { - let manager = state.manager.clone(); - async move { stream_flac(manager, channel_id).await } - }, - app_state.clone(), - ) - .await; - - server - .add_handler_with_state( - &ogg_path, - move |State(state): State>| { - let manager = state.manager.clone(); - async move { stream_ogg(manager, channel_id).await } - }, - app_state.clone(), - ) - .await; - - server - .add_handler_with_state( - &icy_path, - move |State(state): State>| { - let manager = state.manager.clone(); - async move { stream_icy(manager, channel_id).await } - }, - app_state.clone(), - ) - .await; - - let history_router = Router::new() - .route( - "/{client_id}/flac", - get({ - let manager = manager.clone(); - move |Path(client_id): Path| { - let manager = manager.clone(); - async move { stream_history_flac(manager, channel_id, client_id).await } - } - }), - ) - .route( - "/{client_id}/ogg", - get({ - let manager = manager.clone(); - move |Path(client_id): Path| { - let manager = manager.clone(); - async move { stream_history_ogg(manager, channel_id, client_id).await } - } - }), - ); - - server.add_router(&history_path, history_router).await; - - server - .add_handler_with_state( - &meta_path, - move |State(state): State>| { - let manager = state.manager.clone(); - async move { get_metadata(manager, channel_id).await } - }, - app_state.clone(), - ) - .await; - } - - info!("========================================"); - info!("Radio Paradise streaming server running on http://localhost:8080"); - info!("Available channels:"); - for descriptor in ALL_CHANNELS.iter() { - info!( - " {}: /radioparadise/stream/{}/flac (also /ogg, /icy, metadata, /historic//(flac|ogg))", - descriptor.display_name, descriptor.slug - ); - } - info!("Press Ctrl+C to stop."); - info!("========================================"); - - server.start().await; - server.wait().await; - Ok(()) -} - -async fn stream_flac( - manager: Arc, - channel_id: u8, -) -> Result { - let channel = manager.get(channel_id).ok_or(StatusCode::NOT_FOUND)?; - let stream = channel.subscribe_flac(); - Ok(Response::builder() - .status(StatusCode::OK) - .header(CONTENT_TYPE, "audio/flac") - .header(CACHE_CONTROL, "no-store, no-transform") - .header(CONNECTION, "keep-alive") - .header(ACCEPT_RANGES, "none") - .body(Body::from_stream(ReaderStream::new(stream))) - .unwrap()) -} - -async fn stream_ogg( - manager: Arc, - channel_id: u8, -) -> Result { - let channel = manager.get(channel_id).ok_or(StatusCode::NOT_FOUND)?; - let stream = channel.subscribe_ogg(); - Ok(Response::builder() - .status(StatusCode::OK) - .header(CONTENT_TYPE, "application/ogg") - .header(CACHE_CONTROL, "no-store, no-transform") - .header(CONNECTION, "keep-alive") - .header(ACCEPT_RANGES, "none") - .body(Body::from_stream(ReaderStream::new(stream))) - .unwrap()) -} - -async fn stream_icy( - manager: Arc, - channel_id: u8, -) -> Result { - let channel = manager.get(channel_id).ok_or(StatusCode::NOT_FOUND)?; - let stream = channel.subscribe_icy(); - Ok(Response::builder() - .status(StatusCode::OK) - .header(CONTENT_TYPE, "audio/flac") - .header(CACHE_CONTROL, "no-store, no-transform") - .header(CONNECTION, "keep-alive") - .header(ACCEPT_RANGES, "none") - .header("icy-metaint", "16000") - .body(Body::from_stream(ReaderStream::new(stream))) - .unwrap()) -} - -async fn get_metadata( - manager: Arc, - channel_id: u8, -) -> Result { - let channel = manager.get(channel_id).ok_or(StatusCode::NOT_FOUND)?; - let metadata = channel.metadata().await; - Ok(Json(metadata)) -} - -async fn stream_history_flac( - manager: Arc, - channel_id: u8, - client_id: String, -) -> Result { - let channel = manager.get(channel_id).ok_or(StatusCode::NOT_FOUND)?; - let stream = channel.stream_history_flac(&client_id).await.map_err(|e| { - error!( - "Failed to start historical FLAC stream for channel {} (client_id={}): {}", - channel_id, client_id, e - ); - StatusCode::INTERNAL_SERVER_ERROR - })?; - Ok(Response::builder() - .status(StatusCode::OK) - .header(CONTENT_TYPE, "audio/flac") - .header(CACHE_CONTROL, "no-store, no-transform") - .header(CONNECTION, "keep-alive") - .header(ACCEPT_RANGES, "none") - .body(Body::from_stream(ReaderStream::new(stream))) - .unwrap()) -} - -async fn stream_history_ogg( - manager: Arc, - channel_id: u8, - client_id: String, -) -> Result { - let channel = manager.get(channel_id).ok_or(StatusCode::NOT_FOUND)?; - let stream = channel.stream_history_ogg(&client_id).await.map_err(|e| { - error!( - "Failed to start historical OGG stream for channel {} (client_id={}): {}", - channel_id, client_id, e - ); - StatusCode::INTERNAL_SERVER_ERROR - })?; - Ok(Response::builder() - .status(StatusCode::OK) - .header(CONTENT_TYPE, "application/ogg") - .header(CACHE_CONTROL, "no-store, no-transform") - .header(CONNECTION, "keep-alive") - .header(ACCEPT_RANGES, "none") - .body(Body::from_stream(ReaderStream::new(stream))) - .unwrap()) -} --------End of pmoparadise/examples/serve_channels.rs --------- - ------------- pmoparadise/examples/single_channel_server.rs ---------- -//! Simple web server that exposes one Radio Paradise channel over HTTP. -//! -//! Usage: -//! ```bash -//! cargo run --example single_channel_server --features full -- main -//! ``` -//! Valid arguments are either the slug (`main`, `mellow`, `rock`, `eclectic`) or -//! the numeric channel id (`0`..`3`). When no argument is provided, the example -//! defaults to the “main” mix. - -use axum::{ - body::Body, - extract::{Path, Request, State}, - http::StatusCode, - response::{IntoResponse, Response}, - routing::get, - Json, Router, -}; -use pmoaudio_ext::StreamingSinkOptions; -use pmoaudiocache::{ - new_cache_with_consolidation as new_audio_cache, - register_audio_cache as register_global_audio_cache, -}; -use pmocovers::{ - new_cache_with_consolidation as new_cover_cache, register_cover_cache, Cache as CoverCache, -}; -use pmoparadise::{ - channels::{ChannelDescriptor, ALL_CHANNELS}, - ParadiseHistoryBuilder, ParadiseStreamChannel, ParadiseStreamChannelConfig, -}; -use pmoplaylist::register_audio_cache as register_playlist_audio_cache; -use std::{fs, net::SocketAddr, sync::Arc}; -use tokio::net::TcpListener; -use tokio_util::io::ReaderStream; -use tracing::info; - -#[derive(Clone)] -struct AppState { - channel: Arc, - descriptor: ChannelDescriptor, - cover_cache: Arc, -} - -#[tokio::main] -async fn main() -> anyhow::Result<()> { - let env_filter = tracing_subscriber::EnvFilter::try_from_default_env() - .unwrap_or_else(|_| tracing_subscriber::EnvFilter::new("info")); - - tracing_subscriber::fmt().with_env_filter(env_filter).init(); - - let descriptor = pick_descriptor(std::env::args().nth(1))?; - info!( - "Selected Radio Paradise channel: {} ({})", - descriptor.display_name, descriptor.slug - ); - - // Prepare caches under ./cache/single-channel - let cache_root = "./cache/single-channel"; - let audio_cache_dir = format!("{}/audio", cache_root); - let cover_cache_dir = format!("{}/covers", cache_root); - fs::create_dir_all(&audio_cache_dir)?; - fs::create_dir_all(&cover_cache_dir)?; - - let audio_cache = new_audio_cache(&audio_cache_dir, 1000).await?; - let cover_cache = new_cover_cache(&cover_cache_dir, 200).await?; - register_global_audio_cache(audio_cache.clone()); - register_playlist_audio_cache(audio_cache.clone()); - register_cover_cache(cover_cache.clone()); - - let mut history_builder = ParadiseHistoryBuilder::new(audio_cache.clone(), cover_cache.clone()); - history_builder.playlist_prefix = format!("single-channel-history-{}", descriptor.slug); - history_builder.collection_prefix = Some(format!("single-channel-{}", descriptor.slug)); - let history_opts = history_builder.build_for_channel(&descriptor).await?; - - let mut channel_config = ParadiseStreamChannelConfig::default(); - // Base URL for cover images in stream metadata - let server_base_url = "http://localhost:8080".to_string(); - - // Configuration commune pour FLAC et OGG - let common_options = StreamingSinkOptions::flac_defaults() - .with_default_artist(Some("Radio Paradise".to_string())) - .with_default_title(descriptor.display_name.to_string()) - .with_server_base_url(Some(server_base_url.clone())); - - channel_config.flac_options = common_options.clone(); - channel_config.ogg_options = StreamingSinkOptions::ogg_defaults() - .with_default_artist(Some("Radio Paradise".to_string())) - .with_default_title(descriptor.display_name.to_string()) - .with_server_base_url(Some(server_base_url)); - - let channel = Arc::new( - ParadiseStreamChannel::new( - descriptor, - channel_config, - Some(cover_cache.clone()), - Some(history_opts), - ) - .await?, - ); - - let state = AppState { - channel, - descriptor, - cover_cache, - }; - - let app = Router::new() - .route("/stream/flac", get(stream_flac)) - .route("/stream/ogg", get(stream_ogg)) - .route("/metadata", get(get_metadata)) - .route("/covers/image/{pk}", get(get_cover)) - .with_state(state); - - let addr: SocketAddr = ([0, 0, 0, 0], 8080).into(); - info!("========================================"); - info!("HTTP server listening on http://{addr}"); - info!("Available endpoints:"); - info!(" - /stream/flac : FLAC audio stream"); - info!(" - /stream/ogg : OGG-FLAC audio stream"); - info!(" - /metadata : Current track metadata (JSON)"); - info!(" - /covers/image/{{pk}} : Album cover images (WebP)"); - info!("========================================"); - info!("Connect with a FLAC player: ffplay http://localhost:8080/stream/flac"); - info!("Connect with an OGG-FLAC player: ffplay http://localhost:8080/stream/ogg"); - - let listener = TcpListener::bind(addr).await?; - axum::serve(listener, app.into_make_service()).await?; - - Ok(()) -} - -async fn stream_flac(State(state): State) -> Result { - let stream = state.channel.subscribe_flac(); - let body = Body::from_stream(ReaderStream::new(stream)); - Response::builder() - .status(StatusCode::OK) - .header("Content-Type", "audio/flac") - .header( - "X-PMO-Channel", - format!( - "{} ({})", - state.descriptor.display_name, state.descriptor.slug - ), - ) - .body(body) - .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR) -} - -async fn stream_ogg(State(state): State) -> Result { - let stream = state.channel.subscribe_ogg(); - let body = Body::from_stream(ReaderStream::new(stream)); - Response::builder() - .status(StatusCode::OK) - .header("Content-Type", "audio/ogg") - .header( - "X-PMO-Channel", - format!( - "{} ({})", - state.descriptor.display_name, state.descriptor.slug - ), - ) - .body(body) - .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR) -} - -async fn get_metadata( - State(state): State, - request: Request, -) -> Result { - let mut metadata = state.channel.metadata().await; - - // Si cover_pk est disponible, construire l'URL complète depuis les headers - // Format: /covers/image/{pk} (correspond à la structure du cache pmocovers) - if let Some(ref pk) = metadata.cover_pk { - let base_url = extract_base_url(&request); - metadata.cover_url = Some(format!("{}/covers/image/{}", base_url, pk)); - } - - Ok(Json(metadata)) -} - -/// Extrait l'URL de base depuis les headers HTTP de la requête -/// Supporte les proxies avec X-Forwarded-Host et X-Forwarded-Proto -fn extract_base_url(request: &Request) -> String { - let headers = request.headers(); - - // Déterminer le schéma (http ou https) - let scheme = headers - .get("x-forwarded-proto") - .and_then(|h| h.to_str().ok()) - .unwrap_or("http"); - - // Déterminer le host - let host = headers - .get("x-forwarded-host") - .or_else(|| headers.get("host")) - .and_then(|h| h.to_str().ok()) - .unwrap_or("localhost:8080"); - - format!("{}://{}", scheme, host) -} - -async fn get_cover( - State(state): State, - Path(pk): Path, -) -> Result { - // Récupérer le chemin de la cover depuis le cache - // Le cache retourne un PathBuf pointant vers le fichier .webp - let cover_path = state.cover_cache.get(&pk).await.map_err(|e| { - tracing::error!("Failed to get cover path for {}: {}", pk, e); - StatusCode::NOT_FOUND - })?; - - // Lire le fichier - let cover_data = tokio::fs::read(&cover_path).await.map_err(|e| { - tracing::error!("Failed to read cover file {:?}: {}", cover_path, e); - StatusCode::NOT_FOUND - })?; - - Response::builder() - .status(StatusCode::OK) - .header("Content-Type", "image/webp") - .header("Cache-Control", "public, max-age=86400") - .body(Body::from(cover_data)) - .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR) -} - -fn pick_descriptor(arg: Option) -> anyhow::Result { - if let Some(token) = arg { - if let Some(desc) = ALL_CHANNELS.iter().find(|c| c.slug == token) { - return Ok(*desc); - } - if let Ok(id) = token.parse::() { - if let Some(desc) = ALL_CHANNELS.iter().find(|c| c.id == id) { - return Ok(*desc); - } - } - anyhow::bail!("Unknown channel identifier: {token}"); - } - Ok(ALL_CHANNELS[0]) -} --------End of pmoparadise/examples/single_channel_server.rs --------- - ------------- pmoparadise/examples/stream_block.rs ---------- -//! Streams a Radio Paradise block via HTTP using pmoserver -//! -//! This example demonstrates streaming a single Radio Paradise block -//! using the StreamingFlacSink over HTTP via pmoserver. Perfect for -//! testing with VLC or other media players that support HTTP streaming. -//! -//! The example streams ONE block then terminates cleanly using END_OF_BLOCKS_SIGNAL. -//! For continuous streaming, push multiple block_ids without the END signal. -//! -//! Architecture: -//! ```text -//! RadioParadiseStreamSource → TimerBufferNode → StreamingFlacSink -//! ↓ -//! StreamHandle -//! ↓ -//! pmoserver (Axum) -//! ↓ -//! VLC / Media Player Client -//! ``` -//! -//! Usage: -//! cargo run --example stream_block --features full -- -//! -//! Example: -//! cargo run --example stream_block --features full -- 0 # Main Mix -//! -//! Then open in VLC: -//! vlc http://localhost:8080/test/stream (pure FLAC) -//! vlc http://localhost:8080/test/stream-ogg (OGG-FLAC streaming container) -//! vlc http://localhost:8080/test/stream-icy (FLAC + ICY metadata) -//! -//! To check current metadata: -//! curl http://localhost:8080/test/metadata - -use axum::{ - body::Body, - extract::State, - http::{HeaderMap, StatusCode}, - response::{IntoResponse, Response}, -}; -use pmoaudio::{AudioPipelineNode, TimerBufferNode}; -use pmoaudio_ext::{StreamingFlacSink, StreamingOggFlacSink}; -use pmoflac::EncoderOptions; -use pmoparadise::{RadioParadiseClient, RadioParadiseStreamSource, END_OF_BLOCKS_SIGNAL}; -use pmoserver::{init_logging, ServerBuilder}; -use std::env; -use std::sync::Arc; -use tokio_util::io::ReaderStream; -use tokio_util::sync::CancellationToken; - -/// Shared application state -struct AppState { - stream_handle: pmoaudio_ext::StreamHandle, - ogg_handle: pmoaudio_ext::OggFlacStreamHandle, -} - -/// Main HTTP handler for streaming (pure FLAC, no ICY metadata) -async fn stream_handler( - State(state): State>, - _headers: HeaderMap, -) -> Result { - tracing::info!("New client connected (pure FLAC mode)"); - - // Pure FLAC stream without ICY metadata - let flac_stream = state.stream_handle.subscribe_flac(); - - Ok(Response::builder() - .status(StatusCode::OK) - .header("Content-Type", "audio/flac") - .header("Cache-Control", "no-cache, no-store") - .body(Body::from_stream(ReaderStream::new(flac_stream))) - .unwrap()) -} - -/// ICY streaming handler (FLAC with embedded metadata) -async fn stream_icy_handler( - State(state): State>, - _headers: HeaderMap, -) -> Result { - tracing::info!("New client connected (ICY mode)"); - - // FLAC stream with ICY metadata - let icy_stream = state.stream_handle.subscribe_icy(); - - Ok(Response::builder() - .status(StatusCode::OK) - .header("Content-Type", "audio/flac") - .header("icy-metaint", "16000") - .header("icy-name", "Radio Paradise Stream Test") - .header("icy-genre", "Eclectic") - .header("icy-pub", "1") - .header("Cache-Control", "no-cache, no-store") - .body(Body::from_stream(ReaderStream::new(icy_stream))) - .unwrap()) -} - -/// OGG-FLAC streaming handler -async fn stream_ogg_handler( - State(state): State>, - _headers: HeaderMap, -) -> Result { - tracing::info!("New client connected (OGG-FLAC mode)"); - - // OGG-FLAC stream - let ogg_stream = state.ogg_handle.subscribe(); - - Ok(Response::builder() - .status(StatusCode::OK) - .header("Content-Type", "audio/ogg") - .header("Cache-Control", "no-cache, no-store") - .body(Body::from_stream(ReaderStream::new(ogg_stream))) - .unwrap()) -} - -/// Metadata endpoint (JSON) -async fn metadata_handler(State(state): State>) -> impl IntoResponse { - let metadata = state.stream_handle.get_metadata().await; - axum::Json(metadata) -} - -/// Health check endpoint -async fn health_handler() -> &'static str { - "OK" -} - -#[tokio::main] -async fn main() -> Result<(), Box> { - // Initialize logging via pmoserver - let _log_state = init_logging(); - - tracing::info!("=== Radio Paradise HTTP Streaming Test ==="); - - // Parse arguments - let args: Vec = env::args().collect(); - if args.len() < 2 { - eprintln!("Usage: {} ", args[0]); - eprintln!(); - eprintln!("Streams a Radio Paradise block via HTTP for testing."); - eprintln!(); - eprintln!("Channel IDs:"); - eprintln!(" 0 - Main Mix (eclectic, diverse mix)"); - eprintln!(" 1 - Mellow Mix (smooth, chilled music)"); - eprintln!(" 2 - Rock Mix (classic & modern rock)"); - eprintln!(" 3 - World/Etc Mix (global sounds)"); - eprintln!(); - eprintln!("After starting, open in VLC:"); - eprintln!(" vlc http://localhost:8080/test/stream (pure FLAC)"); - eprintln!(" vlc http://localhost:8080/test/stream-ogg (OGG-FLAC container)"); - eprintln!(" vlc http://localhost:8080/test/stream-icy (FLAC + ICY metadata)"); - std::process::exit(1); - } - - let channel_id: u8 = match args[1].parse() { - Ok(id) if id <= 3 => id, - _ => { - eprintln!("Error: channel_id must be a number between 0 and 3"); - std::process::exit(1); - } - }; - - tracing::info!("Channel ID: {}", channel_id); - - // ═══════════════════════════════════════════════════════════════════════════ - // Fetch block metadata - // ═══════════════════════════════════════════════════════════════════════════ - - tracing::info!("Fetching current block metadata..."); - let client = RadioParadiseClient::builder() - .channel(channel_id) - .build() - .await?; - - let block = client.get_block(None).await?; - - tracing::info!("Block Information:"); - tracing::info!(" Event ID: {}", block.event); - tracing::info!(" Songs: {}", block.song_count()); - tracing::info!(" Duration: {:.1} minutes", block.length as f64 / 60000.0); - tracing::info!(""); - - tracing::info!("Tracklist:"); - for (index, song) in block.songs_ordered() { - tracing::info!( - " {:2}. {} - {} ({})", - index + 1, - song.artist, - song.title, - song.album.as_deref().unwrap_or("Unknown Album") - ); - } - tracing::info!(""); - - // ═══════════════════════════════════════════════════════════════════════════ - // Create streaming pipelines (FLAC and OGG-FLAC) - // ═══════════════════════════════════════════════════════════════════════════ - - tracing::info!("Creating streaming pipelines..."); - - // Encoder options (shared) - let encoder_options = EncoderOptions { - compression_level: 5, - verify: false, - ..Default::default() - }; - - // ───────────────────────────────────────────────────────────────────────── - // Unique pipeline feeding both FLAC and OGG sinks - // ───────────────────────────────────────────────────────────────────────── - - let mut source = RadioParadiseStreamSource::new(client); - source.push_block_id(block.event); - source.push_block_id(END_OF_BLOCKS_SIGNAL); // Signal: no more blocks after this one - tracing::debug!( - "RadioParadiseStreamSource created with block {} + END signal", - block.event - ); - - // Use SMALL channel size to make backpressure plus fan-out manageable. - let buffer_sec = 0.1; - let max_lead_time = buffer_sec; - let channel_size = 512; - tracing::debug!( - "Using channel size: {} chunks ({:.1}s buffer à 50ms/chunk)", - channel_size, - channel_size as f64 * 0.05 - ); - - let mut timer_node = TimerBufferNode::with_channel_size(buffer_sec, channel_size); - tracing::debug!( - "TimerBufferNode created with {:.1}s buffer, {} chunk queue", - buffer_sec, - channel_size - ); - - // Streaming sinks - let (streaming_sink, stream_handle) = - StreamingFlacSink::with_max_broadcast_lead(encoder_options.clone(), 16, max_lead_time); - tracing::debug!("StreamingFlacSink created"); - - let (ogg_sink, ogg_handle) = - StreamingOggFlacSink::with_max_broadcast_lead(encoder_options, 16, max_lead_time); - tracing::debug!("StreamingOggFlacSink created"); - - // timer_node.register(Box::new(streaming_sink)); - // timer_node.register(Box::new(ogg_sink)); - // source.register(Box::new(timer_node)); - - source.register(Box::new(streaming_sink)); - source.register(Box::new(ogg_sink)); - - tracing::info!("Pipeline connected: StreamSource → TimerBufferNode → {{FLAC, OGG}} sinks"); - - // ═══════════════════════════════════════════════════════════════════════════ - // Setup pmoserver with streaming routes - // ═══════════════════════════════════════════════════════════════════════════ - - tracing::info!("Setting up pmoserver..."); - - let mut server = - ServerBuilder::new("RadioParadiseStreamTest", "http://localhost", 8080).build(); - - let app_state = Arc::new(AppState { - stream_handle, - ogg_handle, - }); - - // Add streaming routes - let base = "/radioparadise/test"; - server - .add_handler_with_state( - &format!("{}/stream", base), - stream_handler, - app_state.clone(), - ) - .await; - server - .add_handler_with_state( - &format!("{}/stream-icy", base), - stream_icy_handler, - app_state.clone(), - ) - .await; - server - .add_handler_with_state( - &format!("{}/stream-ogg", base), - stream_ogg_handler, - app_state.clone(), - ) - .await; - - // Add metadata route - server - .add_handler_with_state( - &format!("{}/metadata", base), - metadata_handler, - app_state.clone(), - ) - .await; - - // Add health check - server.add_handler("/test/health", health_handler).await; - - tracing::info!(""); - tracing::info!("========================================"); - tracing::info!("Ready to stream!"); - tracing::info!(""); - tracing::info!("Pure FLAC stream (for VLC, standard players):"); - tracing::info!(" vlc http://localhost:8080{}/stream", base); - tracing::info!(""); - tracing::info!("OGG-FLAC stream (streaming container with metadata support):"); - tracing::info!(" vlc http://localhost:8080{}/stream-ogg", base); - tracing::info!(""); - tracing::info!("FLAC + ICY metadata stream (for ICY-aware clients):"); - tracing::info!(" http://localhost:8080{}/stream-icy", base); - tracing::info!(""); - tracing::info!("Metadata endpoint (JSON):"); - tracing::info!(" curl http://localhost:8080{}/metadata", base); - tracing::info!("========================================"); - tracing::info!(""); - - // ═══════════════════════════════════════════════════════════════════════════ - // Start pipelines and server - // ═══════════════════════════════════════════════════════════════════════════ - - let stop_token = CancellationToken::new(); - let pipeline_stop = stop_token.clone(); - - // Start shared pipeline in background - let pipeline_handle = tokio::spawn(async move { - tracing::info!("[PIPELINE] Starting..."); - let result = Box::new(source).run(pipeline_stop).await; - match &result { - Ok(()) => tracing::info!("[PIPELINE] Completed successfully"), - Err(e) => tracing::error!("[PIPELINE] Error: {}", e), - } - result - }); - - // Start pmoserver (blocks until Ctrl+C) - tracing::info!("[SERVER] Starting pmoserver..."); - server.start().await; - server.wait().await; - - // Server stopped, cancel pipelines - tracing::info!("Server stopped, canceling pipelines..."); - stop_token.cancel(); - - // Wait for pipeline to finish - match pipeline_handle.await { - Ok(Ok(())) => tracing::info!("Pipeline completed successfully"), - Ok(Err(e)) => tracing::error!("Pipeline error: {}", e), - Err(e) => tracing::error!("Pipeline task error: {}", e), - } - - tracing::info!("Shutdown complete"); - Ok(()) -} --------End of pmoparadise/examples/stream_block.rs --------- - diff --git a/pmoplaylist/src/handle/write.rs b/pmoplaylist/src/handle/write.rs index b00c7b90..5c35feb4 100644 --- a/pmoplaylist/src/handle/write.rs +++ b/pmoplaylist/src/handle/write.rs @@ -357,7 +357,9 @@ impl WriteHandle { } let manager = crate::manager::PlaylistManager(); - manager.rebuild_track_index(&self.playlist.id, &snapshot).await; + manager + .rebuild_track_index(&self.playlist.id, &snapshot) + .await; manager.notify_playlist_changed(&self.playlist.id); Ok(()) @@ -390,7 +392,9 @@ impl WriteHandle { } let manager = crate::manager::PlaylistManager(); - manager.rebuild_track_index(&self.playlist.id, &snapshot).await; + manager + .rebuild_track_index(&self.playlist.id, &snapshot) + .await; manager.notify_playlist_changed(&self.playlist.id); Ok(()) @@ -452,7 +456,9 @@ impl WriteHandle { } let manager = crate::manager::PlaylistManager(); - manager.rebuild_track_index(&self.playlist.id, &snapshot).await; + manager + .rebuild_track_index(&self.playlist.id, &snapshot) + .await; manager.notify_playlist_changed(&self.playlist.id); } diff --git a/pmoplaylist/src/manager.rs b/pmoplaylist/src/manager.rs index 26b7f7bc..0db151d5 100644 --- a/pmoplaylist/src/manager.rs +++ b/pmoplaylist/src/manager.rs @@ -568,7 +568,11 @@ impl PlaylistManager { let manager = self.clone(); tokio::spawn(async move { - tracing::info!("Lazy mode enabled for playlist {} (lookahead: {})", playlist_id, lookahead); + tracing::info!( + "Lazy mode enabled for playlist {} (lookahead: {})", + playlist_id, + lookahead + ); while let Ok(event) = rx.recv().await { match event { @@ -579,7 +583,9 @@ impl PlaylistManager { if let Ok(writer) = manager.get_write_handle(playlist_id.clone()).await { tracing::info!( "Switching PK in playlist {}: {} -> {}", - playlist_id, lazy_pk, real_pk + playlist_id, + lazy_pk, + real_pk ); if let Err(e) = writer.update_cache_pk(&lazy_pk, &real_pk).await { tracing::error!("Failed to update PK in playlist: {}", e); @@ -587,7 +593,9 @@ impl PlaylistManager { } // 2. Prefetch les tracks suivants - manager.prefetch_next_tracks(&playlist_id, &real_pk, lookahead).await; + manager + .prefetch_next_tracks(&playlist_id, &real_pk, lookahead) + .await; } _ => {} } diff --git a/pmoplaylist/src/playlist/record.rs b/pmoplaylist/src/playlist/record.rs index 521e605d..13626088 100644 --- a/pmoplaylist/src/playlist/record.rs +++ b/pmoplaylist/src/playlist/record.rs @@ -1,6 +1,9 @@ //! Record : entrée dans la playlist pointant vers le cache audio -use std::time::{Duration, SystemTime}; +use std::sync::atomic::{AtomicI64, Ordering}; +use std::time::{Duration, SystemTime, UNIX_EPOCH}; + +static LAST_ADDED_AT: AtomicI64 = AtomicI64::new(0); /// Un enregistrement dans la playlist /// @@ -23,7 +26,7 @@ impl Record { pub fn new(cache_pk: String) -> Self { Self { cache_pk, - added_at: SystemTime::now(), + added_at: next_timestamp(), ttl: None, } } @@ -32,7 +35,7 @@ impl Record { pub fn with_ttl(cache_pk: String, ttl: Duration) -> Self { Self { cache_pk, - added_at: SystemTime::now(), + added_at: next_timestamp(), ttl: Some(ttl), } } @@ -59,3 +62,34 @@ impl Record { .as_nanos() as i64 } } + +fn next_timestamp() -> SystemTime { + let now_nanos = SystemTime::now() + .duration_since(UNIX_EPOCH) + .unwrap_or_default() + .as_nanos() as i64; + + let mut last = LAST_ADDED_AT.load(Ordering::Relaxed); + loop { + let candidate = if now_nanos > last { + now_nanos + } else { + last.saturating_add(1) + }; + + match LAST_ADDED_AT.compare_exchange( + last, + candidate, + Ordering::SeqCst, + Ordering::SeqCst, + ) { + Ok(_) => { + let nanos = candidate as u64; + return UNIX_EPOCH + Duration::from_nanos(nanos); + } + Err(updated) => { + last = updated; + } + } + } +} diff --git a/pmoqobuz/examples/test_getfileurl.rs b/pmoqobuz/examples/test_getfileurl.rs index 2a30860e..66671a9e 100644 --- a/pmoqobuz/examples/test_getfileurl.rs +++ b/pmoqobuz/examples/test_getfileurl.rs @@ -50,7 +50,10 @@ async fn main() -> Result<()> { match api.get_file_url(track_id).await { Ok(stream_info) => { println!(" ✓ Success!"); - println!(" URL: {}...", &stream_info.url[..80.min(stream_info.url.len())]); + println!( + " URL: {}...", + &stream_info.url[..80.min(stream_info.url.len())] + ); println!(" MIME type: {}", stream_info.mime_type); } Err(e) => { diff --git a/pmoqobuz/examples/test_signature.rs b/pmoqobuz/examples/test_signature.rs index d043c011..8c8f13c1 100644 --- a/pmoqobuz/examples/test_signature.rs +++ b/pmoqobuz/examples/test_signature.rs @@ -29,7 +29,10 @@ async fn main() -> Result<()> { println!(" format_id: {}", format_id); println!(" intent: {}", intent); println!(" timestamp: {}", timestamp); - println!(" secret: {}... (first 10 chars)", &app_secret[..10.min(app_secret.len())]); + println!( + " secret: {}... (first 10 chars)", + &app_secret[..10.min(app_secret.len())] + ); // Calculer la signature let signature = signing::sign_track_get_file_url( diff --git a/pmoqobuz/src/api/mod.rs b/pmoqobuz/src/api/mod.rs index 07b8738a..70bcb0d1 100644 --- a/pmoqobuz/src/api/mod.rs +++ b/pmoqobuz/src/api/mod.rs @@ -252,8 +252,14 @@ impl QobuzApi { } // Headers additionnels pour compatibilité avec qobuz-player-client - request = request.header("Accept-Language", "en,en-US;q=0.8,ko;q=0.6,zh;q=0.4,zh-CN;q=0.2"); - request = request.header("Access-Control-Request-Headers", "x-user-auth-token,x-app-id"); + request = request.header( + "Accept-Language", + "en,en-US;q=0.8,ko;q=0.6,zh;q=0.4,zh-CN;q=0.2", + ); + request = request.header( + "Access-Control-Request-Headers", + "x-user-auth-token,x-app-id", + ); // Ajouter les paramètres if method == "GET" { @@ -268,7 +274,11 @@ impl QobuzApi { } /// Traite la réponse HTTP - async fn handle_response(&self, response: Response, endpoint: &str) -> Result { + async fn handle_response( + &self, + response: Response, + endpoint: &str, + ) -> Result { let status = response.status(); let status_code = status.as_u16(); @@ -276,7 +286,10 @@ impl QobuzApi { if !status.is_success() { let error_text = response.text().await.unwrap_or_default(); - debug!("API error ({}) on {}: {}", status_code, endpoint, error_text); + debug!( + "API error ({}) on {}: {}", + status_code, endpoint, error_text + ); return Err(QobuzError::from_status_code(status_code, error_text)); } diff --git a/pmoqobuz/src/client.rs b/pmoqobuz/src/client.rs index 3996a480..ebc4ff30 100644 --- a/pmoqobuz/src/client.rs +++ b/pmoqobuz/src/client.rs @@ -134,10 +134,7 @@ impl QobuzClient { let mut api = match (config_appid.clone(), config_spoofer_secret, config_secret) { // Priority 1: Try memorized Spoofer secret (raw, no XOR) (Some(app_id), Some(spoofer_secret), _) => { - info!( - "Trying memorized Spoofer secret with App ID: {}", - app_id - ); + info!("Trying memorized Spoofer secret with App ID: {}", app_id); match QobuzApi::with_raw_secret(&app_id, &spoofer_secret) { Ok(api) => { used_config_credentials = true; @@ -174,9 +171,7 @@ impl QobuzClient { } // Priority 3: Fallback to Spoofer _ => { - info!( - "AppID or secret not configured, using Spoofer..." - ); + info!("AppID or secret not configured, using Spoofer..."); Self::try_spoofer_fallback(config).await? } }; @@ -266,13 +261,19 @@ impl QobuzClient { // Optimization: Login once with first secret to get auth token // Then test all secrets using the same token if let Some((first_timezone, first_secret)) = secrets.first() { - if let Ok(temp_api) = QobuzApi::with_raw_secret(&app_id, first_secret) { - if let Ok(_auth_info) = temp_api.login(&username, &password).await { + if let Ok(temp_api) = + QobuzApi::with_raw_secret(&app_id, first_secret) + { + if let Ok(_auth_info) = + temp_api.login(&username, &password).await + { // Now test each secret with the authenticated token for (timezone, secret) in secrets.iter() { debug!("Testing timezone secret: {}", timezone); - if let Ok(test_api) = QobuzApi::with_raw_secret(&app_id, secret) { + if let Ok(test_api) = + QobuzApi::with_raw_secret(&app_id, secret) + { // Set the auth token from our initial login test_api.set_auth_token( temp_api.auth_token().unwrap(), @@ -282,17 +283,29 @@ impl QobuzClient { // Test the secret using track/getFileUrl (like qobuz-player-client) // Use the same hardcoded track_id (64868955) as qobuz-player-client if test_api.get_file_url("64868955").await.is_ok() { - info!("✓ Secret from timezone '{}' works!", timezone); + info!( + "✓ Secret from timezone '{}' works!", + timezone + ); // Save both appid and the working secret - if let Err(e) = config.set_qobuz_appid(&app_id) { + if let Err(e) = config.set_qobuz_appid(&app_id) + { debug!("Could not save appid: {}", e); } - if let Err(e) = config.set_qobuz_spoofer_secret(secret) { - debug!("Could not save spoofer secret: {}", e); + if let Err(e) = + config.set_qobuz_spoofer_secret(secret) + { + debug!( + "Could not save spoofer secret: {}", + e + ); } - return Ok(Some((app_id.clone(), secret.clone()))); + return Ok(Some(( + app_id.clone(), + secret.clone(), + ))); } else { debug!("✗ Secret from timezone '{}' failed track/getFileUrl test", timezone); } @@ -310,7 +323,7 @@ impl QobuzClient { Ok(None) } } - }, + } Err(e) => { info!( "Spoofer failed to extract app_id: {}, falling back to DEFAULT_APP_ID", diff --git a/pmoqobuz/src/source.rs b/pmoqobuz/src/source.rs index d4642f3a..7e157129 100644 --- a/pmoqobuz/src/source.rs +++ b/pmoqobuz/src/source.rs @@ -230,8 +230,9 @@ impl QobuzSource { /// /// # Returns /// - /// The track ID (e.g., "qobuz://track/12345") - pub async fn add_track_lazy(&self, track: &Track) -> Result { + /// `(track_id, lazy_pk)` where `track_id` is the logical Qobuz URI and + /// `lazy_pk` the cache identifier stored in pmocache. + pub async fn add_track_lazy(&self, track: &Track) -> Result<(String, String)> { let track_id = format!("qobuz://track/{}", track.id); // Get streaming URL @@ -287,7 +288,12 @@ impl QobuzSource { .cache_manager .cache_audio_lazy(&stream_url, Some(metadata)) .await - .ok(); + .map_err(|e| { + MusicSourceError::CacheError(format!( + "Failed to cache lazy track {}: {}", + track.title, e + )) + })?; // 4. Store metadata self.inner @@ -296,13 +302,13 @@ impl QobuzSource { track_id.clone(), pmosource::TrackMetadata { original_uri: stream_url, - cached_audio_pk, + cached_audio_pk: Some(cached_audio_pk.clone()), cached_cover_pk, }, ) .await; - Ok(track_id) + Ok((track_id, cached_audio_pk)) } /// Load full album into pmoplaylist with lazy audio @@ -345,15 +351,15 @@ impl QobuzSource { for (i, track) in tracks.iter().enumerate() { match self.add_track_lazy(track).await { - Ok(track_id) => { - debug!("Track {}/{}: {} (lazy)", i + 1, tracks.len(), track.title); - - // Extract lazy PK from cache manager - if let Some(metadata) = self.inner.cache_manager.get_metadata(&track_id).await { - if let Some(audio_pk) = metadata.cached_audio_pk { - lazy_pks.push(audio_pk); - } - } + Ok((_track_id, lazy_pk)) => { + debug!( + "Track {}/{}: {} (lazy pk {})", + i + 1, + tracks.len(), + track.title, + &lazy_pk + ); + lazy_pks.push(lazy_pk); } Err(e) => { warn!("Failed to add track {} ({}): {}", i + 1, track.title, e); @@ -431,15 +437,15 @@ impl QobuzSource { for (i, track) in tracks.iter().enumerate() { match self.add_track_lazy(track).await { - Ok(track_id) => { - debug!("Track {}/{}: {} (lazy)", i + 1, tracks.len(), track.title); - - // Extract lazy PK from cache manager - if let Some(metadata) = self.inner.cache_manager.get_metadata(&track_id).await { - if let Some(audio_pk) = metadata.cached_audio_pk { - lazy_pks.push(audio_pk); - } - } + Ok((_track_id, lazy_pk)) => { + debug!( + "Track {}/{}: {} (lazy pk {})", + i + 1, + tracks.len(), + track.title, + &lazy_pk + ); + lazy_pks.push(lazy_pk); } Err(e) => { warn!("Failed to add track {} ({}): {}", i + 1, track.title, e); diff --git a/pmoqobuz_026.txt b/pmoqobuz_026.txt deleted file mode 100644 index ac463fb9..00000000 --- a/pmoqobuz_026.txt +++ /dev/null @@ -1,4889 +0,0 @@ -=============== pmoqobuz/Cargo.toml ============ -[package] -name = "pmoqobuz" -version = "0.1.0" -edition = "2021" - -[dependencies] -# HTTP client pour les requêtes à l'API Qobuz -reqwest = { version = "0.12", features = ["json", "cookies"] } - -# Gestion asynchrone -tokio = { version = "1", features = ["full"] } - -# Sérialisation/Désérialisation JSON -serde = { version = "1.0", features = ["derive"] } -serde_json = "1.0" - -# Gestion des erreurs -anyhow = "1.0" -thiserror = "1.0" - -# Hashing pour les clés de cache -sha1 = "0.10" -hex = "0.4" - -# Cache en mémoire avec TTL -moka = { version = "0.12", features = ["future"] } - -# Logging -tracing = "0.1" - -# Gestion du temps -chrono = { version = "0.4", features = ["serde"] } - -# Configuration -pmoconfig = { path = "../pmoconfig" } - -# Intégration avec pmocovers pour le cache d'images (OBLIGATOIRE) -pmocovers = { path = "../pmocovers" } - -# Intégration avec pmoaudiocache pour le cache audio (OBLIGATOIRE) -pmoaudiocache = { path = "../pmoaudiocache" } - -# Intégration avec pmodidl pour l'export DIDL -pmodidl = { path = "../pmodidl" } - -# Intégration avec pmoserver pour l'API HTTP -pmoserver = { path = "../pmoserver", optional = true } -axum = { version = "0.8", optional = true } - -# Documentation OpenAPI -utoipa = { version = "5.3", optional = true } - -# Common music source traits -pmosource = { path = "../pmosource" } - -[features] -default = [] -# Feature pour activer les extensions pmoserver -pmoserver = ["dep:pmoserver", "dep:axum", "dep:utoipa"] -# Feature pour activer le support serveur (cache registry) -server = ["pmosource/server"] -# Feature cache (deprecated - toujours actif maintenant) -cache = [] - -[dev-dependencies] -# Tests -tokio-test = "0.4" -mockito = "1.0" -# Pour les exemples -tracing-subscriber = "0.3" - -# Specify that the with_cache example requires the cache feature -[[example]] -name = "with_cache" -required-features = ["cache"] -========= End of pmoqobuz/Cargo.toml =========== - -=============== pmoqobuz/README.md ============ -# pmoqobuz - Client Qobuz pour PMOMusic - -Client Rust pour l'API Qobuz avec cache en mémoire, inspiré de l'implémentation Python d'upmpdcli. - -## Fonctionnalités - -- ✅ **Authentification** : Login avec username/password depuis la configuration -- ✅ **Catalogue** : Accès complet au catalogue Qobuz (albums, tracks, artistes, playlists) -- ✅ **Recherche** : Recherche dans le catalogue avec filtres -- ✅ **Favoris** : Accès aux albums, artistes, tracks et playlists favoris -- ✅ **Cache en mémoire** : Minimisation des requêtes API avec TTL configurable -- ✅ **Export DIDL** : Conversion automatique en format DIDL-Lite (UPnP/DLNA) -- ✅ **Integration pmocovers** : Cache automatique des images (feature `covers`) -- ✅ **Integration pmoaudiocache** : Cache audio haute résolution avec métadonnées (feature `cache`) -- ✅ **API HTTP** : Endpoints REST via pmoserver (feature `pmoserver`) - -## Installation - -Ajoutez la dépendance dans votre `Cargo.toml` : - -```toml -[dependencies] -pmoqobuz = { path = "../pmoqobuz" } -``` - -## Configuration - -Les credentials Qobuz doivent être configurés dans `.pmomusic.yml` : - -```yaml -accounts: - qobuz: - username: "votre@email.com" - password: "votre_mot_de_passe" -``` - -## Utilisation - -### Exemple basique - -```rust -use pmoqobuz::QobuzClient; - -#[tokio::main] -async fn main() -> anyhow::Result<()> { - // Connexion depuis la configuration - let client = QobuzClient::from_config().await?; - - // Rechercher des albums - let albums = client.search_albums("Miles Davis").await?; - - for album in albums.iter().take(5) { - println!("{} - {}", album.artist.name, album.title); - } - - Ok(()) -} -``` - -### Export DIDL - -```rust -use pmoqobuz::{QobuzClient, ToDIDL}; - -#[tokio::main] -async fn main() -> anyhow::Result<()> { - let client = QobuzClient::from_config().await?; - - let album = client.get_album("album_id").await?; - let didl_container = album.to_didl_container("parent_id")?; - - let tracks = client.get_album_tracks(&album.id).await?; - for track in tracks { - let didl_item = track.to_didl_item(&didl_container.id)?; - println!("{}", didl_item.title); - } - - Ok(()) -} -``` - -### Favoris - -```rust -use pmoqobuz::QobuzClient; - -#[tokio::main] -async fn main() -> anyhow::Result<()> { - let client = QobuzClient::from_config().await?; - - // Albums favoris - let albums = client.get_favorite_albums().await?; - println!("{} albums favoris", albums.len()); - - // Artistes favoris - let artists = client.get_favorite_artists().await?; - - // Tracks favorites - let tracks = client.get_favorite_tracks().await?; - - // Playlists de l'utilisateur - let playlists = client.get_user_playlists().await?; - - Ok(()) -} -``` - -## Formats audio - -Qobuz propose plusieurs formats : - -| Format | Description | Format ID | -|--------|-------------|-----------| -| `Mp3_320` | MP3 320 kbps | 5 | -| `Flac_Lossless` | FLAC 16 bit / 44.1 kHz | 6 (défaut) | -| `Flac_HiRes_96` | FLAC 24 bit / jusqu'à 96 kHz | 7 | -| `Flac_HiRes_192` | FLAC 24 bit / jusqu'à 192 kHz | 27 | - -```rust -use pmoqobuz::{QobuzClient, AudioFormat}; - -let mut client = QobuzClient::from_config().await?; -client.set_format(AudioFormat::Flac_HiRes_96); -``` - -## Cache - -Le cache en mémoire utilise `moka` avec TTL : - -- **Albums** : 1 heure -- **Tracks** : 1 heure -- **Artistes** : 1 heure -- **Playlists** : 30 minutes -- **Recherches** : 15 minutes -- **URLs de streaming** : 5 minutes - -```rust -// Statistiques du cache -let stats = client.cache().stats().await; -println!("Albums: {}", stats.albums_count); -println!("Total: {}", stats.total_count()); - -// Vider le cache -client.cache().clear_all().await; -``` - -## Cache avancé (feature `cache`) - -La feature `cache` active le support complet de pmocovers et pmoaudiocache pour télécharger et cacher localement les images et l'audio haute résolution : - -```rust -use pmoqobuz::{QobuzSource, QobuzClient}; -use pmocovers::Cache as CoverCache; -use pmoaudiocache::AudioCache; -use std::sync::Arc; - -#[tokio::main] -async fn main() -> anyhow::Result<()> { - // Initialize caches - let cover_cache = Arc::new(CoverCache::new("./cache/covers", 500)?); - let audio_cache = Arc::new(AudioCache::new("./cache/audio", 100)?); - - // Create source with caching - let client = QobuzClient::from_config().await?; - let source = QobuzSource::new_with_cache( - client, - "http://localhost:8080", - Some(cover_cache), - Some(audio_cache), - ); - - // Add tracks with automatic caching - let tracks = source.client().get_favorite_tracks().await?; - for track in tracks.iter().take(5) { - let track_id = source.add_track(track).await?; - // Audio and cover are now cached locally - let uri = source.resolve_uri(&track_id).await?; - println!("Cached: {}", uri); - } - - Ok(()) -} -``` - -**Métadonnées enrichies préservées** : -- Titre, artiste, album -- Numéro de piste et de disque -- Année de sortie -- Genre(s) et label -- Qualité audio (sample rate, bit depth, channels) -- Durée - -## Exemples - -Exécutez les exemples : - -```bash -# Exemple basique -cargo run --example basic_usage - -# Exemple avec cache (nécessite la feature cache) -cargo run --example with_cache --features cache -``` - -## Architecture - -``` -pmoqobuz/ -├── src/ -│ ├── lib.rs # Module principal -│ ├── client.rs # Client haut-niveau -│ ├── models.rs # Structures de données -│ ├── api/ -│ │ ├── mod.rs # API client bas-niveau -│ │ ├── auth.rs # Authentification -│ │ ├── catalog.rs # Accès catalogue -│ │ └── user.rs # API utilisateur -│ ├── cache.rs # Cache en mémoire -│ ├── didl.rs # Export DIDL-Lite -│ └── error.rs # Gestion des erreurs -└── examples/ - └── basic_usage.rs # Exemple d'utilisation -``` - -## Tests - -```bash -cargo test -p pmoqobuz -``` - -## Documentation - -Générez la documentation : - -```bash -cargo doc -p pmoqobuz --open -``` - -## Features - -- `covers` : Active pmocovers pour le cache d'images -- `cache` : Active pmocovers + pmoaudiocache pour le cache complet (images + audio) -- `pmoserver` : Active les endpoints REST via pmoserver - -## Dépendances principales - -- `reqwest` : Client HTTP -- `tokio` : Runtime asynchrone -- `serde` / `serde_json` : Sérialisation JSON -- `moka` : Cache en mémoire avec TTL -- `pmodidl` : Export DIDL-Lite -- `pmoconfig` : Configuration -- `pmocovers` : Cache d'images (optionnel) -- `pmoaudiocache` : Cache audio (optionnel) - -## Licence - -Ce code fait partie du projet PMOMusic. - -## Références - -- [API Qobuz Documentation](https://github.com/Qobuz/api-documentation) -- [upmpdcli Qobuz Plugin](https://www.lesbonscomptes.com/upmpdcli/) -========= End of pmoqobuz/README.md =========== - -=============== pmoqobuz/examples/server_with_covers.rs ============ -//! Exemple d'utilisation de pmoqobuz avec pmoserver et pmocovers -//! -//! Cet exemple montre comment : -//! - Créer un serveur HTTP avec pmoserver -//! - Initialiser le cache d'images avec pmocovers -//! - Initialiser le client Qobuz avec intégration pmocovers -//! - Les images d'albums sont automatiquement mises en cache -//! -//! Pour tester : -//! ```bash -//! cargo run --example server_with_covers --features "pmoserver,covers" -//! ``` -//! -//! Endpoints disponibles : -//! - GET /qobuz/search?q=query&type=albums - Recherche d'albums (images auto-cachées) -//! - GET /qobuz/albums/{id} - Détails d'un album (image auto-cachée) -//! - GET /qobuz/favorites/albums - Albums favoris (images auto-cachées) -//! - GET /covers/images/{pk} - Image originale mise en cache -//! - GET /covers/images/{pk}/{size} - Variante redimensionnée -//! - GET /api/covers - API REST du cache d'images -//! - GET /swagger-ui - Documentation interactive - -#[cfg(all(feature = "pmoserver", feature = "covers"))] -use pmocovers::CoverCacheExt; - -#[cfg(all(feature = "pmoserver", feature = "covers"))] -use pmoqobuz::QobuzServerExt; - -#[cfg(all(feature = "pmoserver", feature = "covers"))] -use pmoserver::ServerBuilder; - -#[cfg(all(feature = "pmoserver", feature = "covers"))] -#[tokio::main] -async fn main() -> anyhow::Result<()> { - // Initialiser le logging - tracing_subscriber::fmt() - .with_max_level(tracing::Level::INFO) - .init(); - - println!("=== PMOQobuz + PMOCovers - Serveur HTTP avec cache d'images ===\n"); - - // Créer le serveur depuis la configuration - let mut server = ServerBuilder::new_configured().build(); - - println!("1. Initialisation du cache d'images (pmocovers)..."); - // Initialiser le cache d'images avec la configuration - let cache = server.init_cover_cache_configured().await?; - println!(" ✓ Cache d'images initialisé: {}", cache.cache_dir()); - - println!("\n2. Initialisation du client Qobuz avec intégration pmocovers..."); - // Initialiser le client Qobuz avec intégration pmocovers - // Les images d'albums seront automatiquement ajoutées au cache - let client = server - .init_qobuz_client_configured_with_covers(cache.clone()) - .await?; - - if let Some(auth_info) = client.auth_info() { - println!(" ✓ Client Qobuz connecté !"); - println!(" User ID: {}", auth_info.user_id); - if let Some(label) = &auth_info.subscription_label { - println!(" Abonnement: {}", label); - } - } - - println!("\n3. Démarrage du serveur HTTP..."); - server.start().await; - - println!("\n✓ Serveur démarré avec succès !\n"); - println!("Endpoints disponibles :"); - println!(" • Qobuz API:"); - println!(" - GET /qobuz/search?q=query&type=albums"); - println!(" - GET /qobuz/albums/{{id}}"); - println!(" - GET /qobuz/albums/{{id}}/tracks"); - println!(" - GET /qobuz/favorites/albums"); - println!(" - GET /qobuz/favorites/artists"); - println!(" - GET /qobuz/cache/stats"); - println!(" • Images (auto-cachées depuis Qobuz):"); - println!(" - GET /covers/images/{{pk}}"); - println!(" - GET /covers/images/{{pk}}/{{size}}"); - println!(" • API REST du cache:"); - println!(" - GET /api/covers"); - println!(" - POST /api/covers"); - println!(" - DELETE /api/covers/{{pk}}"); - println!(" • Documentation:"); - println!(" - GET /swagger-ui"); - println!("\nExemple de requête :"); - println!(" curl 'http://localhost:3000/qobuz/search?q=Miles%20Davis&type=albums' | jq '.[0].image_cached'"); - println!(" # Retourne: \"/covers/images/{{pk}}\""); - println!("\nAppuyez sur Ctrl+C pour arrêter le serveur...\n"); - - // Attendre indéfiniment - server.wait().await; - - Ok(()) -} - -#[cfg(not(all(feature = "pmoserver", feature = "covers")))] -fn main() { - eprintln!("Cet exemple nécessite les features 'pmoserver' et 'covers'"); - eprintln!("Exécutez: cargo run --example server_with_covers --features \"pmoserver,covers\""); - std::process::exit(1); -} -========= End of pmoqobuz/examples/server_with_covers.rs =========== - -=============== pmoqobuz/examples/basic_usage.rs ============ -//! Exemple d'utilisation basique de pmoqobuz -//! -//! Cet exemple montre comment : -//! - Se connecter à Qobuz avec les credentials de la configuration -//! - Rechercher des albums -//! - Récupérer les détails d'un album -//! - Exporter un album en format DIDL-Lite - -use pmoqobuz::{QobuzClient, ToDIDL}; - -#[tokio::main] -async fn main() -> anyhow::Result<()> { - // Initialiser le logging - tracing_subscriber::fmt::init(); - - println!("=== PMOQobuz - Exemple d'utilisation basique ===\n"); - - // Créer un client depuis la configuration - println!("Connexion à Qobuz..."); - let client = QobuzClient::from_config().await?; - - if let Some(auth_info) = client.auth_info() { - println!("✓ Connecté avec succès !"); - println!(" User ID: {}", auth_info.user_id); - if let Some(label) = &auth_info.subscription_label { - println!(" Abonnement: {}", label); - } - } - - println!("\n--- Recherche d'albums ---"); - let query = "Miles Davis"; - println!("Recherche: '{}'...", query); - - let albums = client.search_albums(query).await?; - println!("✓ {} album(s) trouvé(s)\n", albums.len()); - - // Afficher les 5 premiers albums - for (i, album) in albums.iter().take(5).enumerate() { - println!(" {}. {} - {}", i + 1, album.artist.name, album.title); - if let Some(date) = &album.release_date { - println!(" Date: {}", date); - } - if let Some(count) = album.tracks_count { - println!(" Pistes: {}", count); - } - } - - // Récupérer les détails du premier album - if let Some(first_album) = albums.first() { - println!("\n--- Détails de l'album ---"); - println!("Album: {} - {}", first_album.artist.name, first_album.title); - - // Récupérer les tracks - let tracks = client.get_album_tracks(&first_album.id).await?; - println!("Tracks ({}):", tracks.len()); - - for track in tracks.iter().take(3) { - println!( - " {}. {} - {} ({}:{})", - track.track_number, - track - .display_artist() - .map(|a| a.name.as_str()) - .unwrap_or("Unknown"), - track.title, - track.duration / 60, - track.duration % 60 - ); - } - - if tracks.len() > 3 { - println!(" ... et {} autres pistes", tracks.len() - 3); - } - - // Export DIDL - println!("\n--- Export DIDL-Lite ---"); - let didl_container = first_album.to_didl_container("0")?; - println!("Container ID: {}", didl_container.id); - println!("Title: {}", didl_container.title); - println!("Class: {}", didl_container.class); - - if let Some(first_track) = tracks.first() { - let didl_item = first_track.to_didl_item(&didl_container.id)?; - println!("\nPremière track en DIDL:"); - println!(" Item ID: {}", didl_item.id); - println!(" Title: {}", didl_item.title); - if let Some(artist) = &didl_item.artist { - println!(" Artist: {}", artist); - } - } - } - - // Afficher les statistiques du cache - println!("\n--- Statistiques du cache ---"); - let stats = client.cache().stats().await; - println!("Albums en cache: {}", stats.albums_count); - println!("Tracks en cache: {}", stats.tracks_count); - println!("Artistes en cache: {}", stats.artists_count); - println!("Total: {} entrées", stats.total_count()); - - // Favoris - println!("\n--- Albums favoris ---"); - match client.get_favorite_albums().await { - Ok(favorites) => { - println!("✓ {} album(s) favori(s)", favorites.len()); - for (i, album) in favorites.iter().take(5).enumerate() { - println!(" {}. {} - {}", i + 1, album.artist.name, album.title); - } - if favorites.len() > 5 { - println!(" ... et {} autres", favorites.len() - 5); - } - } - Err(e) => { - println!("⚠ Impossible de récupérer les favoris: {}", e); - } - } - - println!("\n✓ Exemple terminé avec succès !"); - - Ok(()) -} -========= End of pmoqobuz/examples/basic_usage.rs =========== - -=============== pmoqobuz/examples/with_cache.rs ============ -//! Example demonstrating Qobuz with cache support -//! -//! This example shows how to use the QobuzSource with pmocovers -//! and pmoaudiocache to cache both cover images and audio tracks. -//! -//! Run with: -//! ```bash -//! cargo run --example with_cache --features cache -//! ``` - -use pmoaudiocache::AudioCache; -use pmocovers::Cache as CoverCache; -use pmoqobuz::{QobuzClient, QobuzSource}; -use pmosource::MusicSource; -use std::sync::Arc; - -#[tokio::main] -async fn main() -> Result<(), Box> { - // Initialize tracing - tracing_subscriber::fmt::init(); - - println!("🎵 Qobuz with Cache Support"); - println!("============================\n"); - - // Create the Qobuz client using configuration - println!("📡 Connecting to Qobuz..."); - let client = QobuzClient::from_config().await?; - println!("✅ Connected!\n"); - - // Initialize caches - println!("💾 Initializing caches..."); - let cover_cache = Arc::new(CoverCache::new("./cache/qobuz-covers", 500)?); - let audio_cache = Arc::new(AudioCache::new("./cache/qobuz-audio", 100)?); - println!("✅ Caches initialized!\n"); - - // Create the source with caching enabled - let source = QobuzSource::new_with_cache( - client, - "http://localhost:8080", - Some(cover_cache.clone()), - Some(audio_cache.clone()), - ); - - println!("📻 Source: {}", source.name()); - println!("🆔 ID: {}", source.id()); - println!("📝 Supports FIFO: {}\n", source.supports_fifo()); - - // Get user's favorite tracks - println!("🎧 Fetching your favorite tracks..."); - let favorite_tracks = source.client().get_favorite_tracks().await?; - - if favorite_tracks.is_empty() { - println!("⚠️ No favorite tracks found. Add some favorites on Qobuz first!"); - println!("\n💡 Tip: You can also search for tracks:"); - - // Example: Search for tracks - println!("\n🔍 Searching for 'Miles Davis'..."); - let search_results = source.client().search("Miles Davis", None).await?; - - if !search_results.tracks.is_empty() { - println!("\n📋 Found {} tracks:", search_results.tracks.len()); - for (i, track) in search_results.tracks.iter().enumerate().take(3) { - println!( - " {}. {} - {}", - i + 1, - track - .performer - .as_ref() - .map(|p| p.name.as_str()) - .unwrap_or("Unknown"), - track.title - ); - - // Demonstrate adding a track with caching - if i == 0 { - println!("\n➕ Adding first track to cache..."); - let track_id = source.add_track(track).await?; - println!("✅ Track added with ID: {}", track_id); - println!(" - Cover image caching started"); - println!(" - Audio caching started (high-quality FLAC)"); - - // Show resolved URI (will use cached version if available) - if let Ok(uri) = source.resolve_uri(&track_id).await { - println!(" - Stream URI: {}", uri); - } - } - } - } - } else { - println!("✅ Found {} favorite tracks!\n", favorite_tracks.len()); - - // Add first 3 favorite tracks with caching - for (i, track) in favorite_tracks.iter().enumerate().take(3) { - println!( - "{}. {} - {}", - i + 1, - track - .performer - .as_ref() - .map(|p| p.name.as_str()) - .unwrap_or("Unknown"), - track.title - ); - - if let Some(album) = &track.album { - println!(" Album: {}", album.title); - if let Some(label) = &album.label { - println!(" Label: {}", label); - } - if let Some(sample_rate) = album.maximum_sampling_rate { - println!(" Max Sample Rate: {} kHz", sample_rate / 1000.0); - } - if let Some(bit_depth) = album.maximum_bit_depth { - println!(" Max Bit Depth: {} bit", bit_depth); - } - } - - println!("\n ➕ Adding to cache..."); - match source.add_track(track).await { - Ok(track_id) => { - println!(" ✅ Track cached successfully!"); - - // Show resolved URI - if let Ok(uri) = source.resolve_uri(&track_id).await { - println!(" 📍 Stream URI: {}", uri); - } - } - Err(e) => { - println!(" ⚠️ Failed to cache track: {}", e); - } - } - println!(); - } - } - - // Browse favorite albums - println!("\n📚 Browsing your favorite albums..."); - let favorite_albums = source.client().get_favorite_albums().await?; - - if !favorite_albums.is_empty() { - println!("✅ Found {} favorite albums!\n", favorite_albums.len()); - - for (i, album) in favorite_albums.iter().enumerate().take(3) { - println!("{}. {} - {}", i + 1, album.artist.name, album.title); - if let Some(release_date) = &album.release_date { - println!(" Released: {}", release_date); - } - if let Some(tracks_count) = album.tracks_count { - println!(" Tracks: {}", tracks_count); - } - if !album.genres.is_empty() { - println!(" Genres: {}", album.genres.join(", ")); - } - } - } else { - println!("⚠️ No favorite albums found."); - } - - println!("\n✨ Example complete!"); - println!("\n💡 Tips:"); - println!(" - Run the example again to see faster loading from cache"); - println!(" - Check ./cache/qobuz-covers/ for cached cover images (WebP)"); - println!(" - Check ./cache/qobuz-audio/ for cached Hi-Res FLAC files"); - println!(" - Qobuz provides rich metadata (label, ISRC, sample rate, bit depth)"); - println!(" - Cached audio retains original quality (up to 24bit/192kHz)"); - - Ok(()) -} -========= End of pmoqobuz/examples/with_cache.rs =========== - -=============== pmoqobuz/examples/show_source_image.rs ============ -//! Example showing how to access and save the Qobuz source image -//! -//! This example demonstrates: -//! - Getting source information via the MusicSource trait -//! - Accessing the embedded WebP image -//! - Optionally saving it to a file - -use pmoqobuz::{QobuzClient, QobuzSource}; -use pmosource::MusicSource; -use std::fs; -use std::io::Write; - -#[tokio::main] -async fn main() -> Result<(), Box> { - // Create the client and source - let client = QobuzClient::from_config().await?; - let source = QobuzSource::new(client, "http://localhost:8080"); - - // Display source information - println!("Music Source Information"); - println!("========================"); - println!("Name: {}", source.name()); - println!("ID: {}", source.id()); - println!("Image MIME type: {}", source.default_image_mime_type()); - - // Get the embedded image - let image_data = source.default_image(); - println!("Embedded image size: {} bytes", image_data.len()); - - // Verify WebP format - if image_data.len() >= 12 { - let is_webp = &image_data[0..4] == b"RIFF" && &image_data[8..12] == b"WEBP"; - println!("Valid WebP format: {}", is_webp); - } - - // Optional: save to file - if std::env::args().any(|arg| arg == "--save") { - let filename = format!("{}_default.webp", source.id()); - let mut file = fs::File::create(&filename)?; - file.write_all(image_data)?; - println!("\nImage saved to: {}", filename); - println!("You can view it with: open {}", filename); - } else { - println!("\nTo save the image to disk, run with: --save"); - } - - Ok(()) -} -========= End of pmoqobuz/examples/show_source_image.rs =========== - -=============== pmoqobuz/src/cache.rs ============ -//! Système de cache en mémoire pour les données Qobuz -//! -//! Ce module fournit un cache en mémoire avec TTL pour minimiser les requêtes à l'API Qobuz. - -use crate::models::{Album, Artist, Playlist, SearchResult, StreamInfo, Track}; -use moka::future::Cache as MokaCache; -use std::sync::Arc; -use std::time::Duration; - -/// Cache principal pour les données Qobuz -#[derive(Clone)] -pub struct QobuzCache { - /// Cache des albums (TTL: 1 heure) - albums: Arc>, - /// Cache des tracks (TTL: 1 heure) - tracks: Arc>, - /// Cache des artistes (TTL: 1 heure) - artists: Arc>, - /// Cache des playlists (TTL: 30 minutes) - playlists: Arc>, - /// Cache des résultats de recherche (TTL: 15 minutes) - searches: Arc>, - /// Cache des URLs de streaming (TTL: 5 minutes) - stream_urls: Arc>, -} - -impl QobuzCache { - /// Crée un nouveau cache avec les paramètres par défaut - pub fn new() -> Self { - Self::with_capacity(1000) - } - - /// Crée un nouveau cache avec une capacité spécifique - pub fn with_capacity(max_capacity: u64) -> Self { - Self { - albums: Arc::new( - MokaCache::builder() - .max_capacity(max_capacity) - .time_to_live(Duration::from_secs(3600)) // 1 heure - .build(), - ), - tracks: Arc::new( - MokaCache::builder() - .max_capacity(max_capacity * 2) - .time_to_live(Duration::from_secs(3600)) // 1 heure - .build(), - ), - artists: Arc::new( - MokaCache::builder() - .max_capacity(max_capacity / 2) - .time_to_live(Duration::from_secs(3600)) // 1 heure - .build(), - ), - playlists: Arc::new( - MokaCache::builder() - .max_capacity(max_capacity / 4) - .time_to_live(Duration::from_secs(1800)) // 30 minutes - .build(), - ), - searches: Arc::new( - MokaCache::builder() - .max_capacity(max_capacity / 2) - .time_to_live(Duration::from_secs(900)) // 15 minutes - .build(), - ), - stream_urls: Arc::new( - MokaCache::builder() - .max_capacity(max_capacity / 4) - .time_to_live(Duration::from_secs(300)) // 5 minutes - .build(), - ), - } - } - - // ============ Albums ============ - - /// Récupère un album depuis le cache - pub async fn get_album(&self, id: &str) -> Option { - self.albums.get(id).await - } - - /// Ajoute un album au cache - pub async fn put_album(&self, id: String, album: Album) { - self.albums.insert(id, album).await; - } - - /// Invalide un album du cache - pub async fn invalidate_album(&self, id: &str) { - self.albums.invalidate(id).await; - } - - // ============ Tracks ============ - - /// Récupère une track depuis le cache - pub async fn get_track(&self, id: &str) -> Option { - self.tracks.get(id).await - } - - /// Ajoute une track au cache - pub async fn put_track(&self, id: String, track: Track) { - self.tracks.insert(id, track).await; - } - - /// Invalide une track du cache - pub async fn invalidate_track(&self, id: &str) { - self.tracks.invalidate(id).await; - } - - // ============ Artists ============ - - /// Récupère un artiste depuis le cache - pub async fn get_artist(&self, id: &str) -> Option { - self.artists.get(id).await - } - - /// Ajoute un artiste au cache - pub async fn put_artist(&self, id: String, artist: Artist) { - self.artists.insert(id, artist).await; - } - - /// Invalide un artiste du cache - pub async fn invalidate_artist(&self, id: &str) { - self.artists.invalidate(id).await; - } - - // ============ Playlists ============ - - /// Récupère une playlist depuis le cache - pub async fn get_playlist(&self, id: &str) -> Option { - self.playlists.get(id).await - } - - /// Ajoute une playlist au cache - pub async fn put_playlist(&self, id: String, playlist: Playlist) { - self.playlists.insert(id, playlist).await; - } - - /// Invalide une playlist du cache - pub async fn invalidate_playlist(&self, id: &str) { - self.playlists.invalidate(id).await; - } - - // ============ Recherches ============ - - /// Récupère un résultat de recherche depuis le cache - pub async fn get_search(&self, query: &str) -> Option { - self.searches.get(query).await - } - - /// Ajoute un résultat de recherche au cache - pub async fn put_search(&self, query: String, result: SearchResult) { - self.searches.insert(query, result).await; - } - - /// Invalide un résultat de recherche du cache - pub async fn invalidate_search(&self, query: &str) { - self.searches.invalidate(query).await; - } - - // ============ URLs de streaming ============ - - /// Récupère une URL de streaming depuis le cache - pub async fn get_stream_url(&self, track_id: &str) -> Option { - self.stream_urls.get(track_id).await - } - - /// Ajoute une URL de streaming au cache - pub async fn put_stream_url(&self, track_id: String, info: StreamInfo) { - self.stream_urls.insert(track_id, info).await; - } - - /// Invalide une URL de streaming du cache - pub async fn invalidate_stream_url(&self, track_id: &str) { - self.stream_urls.invalidate(track_id).await; - } - - // ============ Maintenance ============ - - /// Vide tous les caches - pub async fn clear_all(&self) { - self.albums.invalidate_all(); - self.tracks.invalidate_all(); - self.artists.invalidate_all(); - self.playlists.invalidate_all(); - self.searches.invalidate_all(); - self.stream_urls.invalidate_all(); - } - - /// Retourne des statistiques sur le cache - pub async fn stats(&self) -> CacheStats { - CacheStats { - albums_count: self.albums.entry_count(), - tracks_count: self.tracks.entry_count(), - artists_count: self.artists.entry_count(), - playlists_count: self.playlists.entry_count(), - searches_count: self.searches.entry_count(), - stream_urls_count: self.stream_urls.entry_count(), - } - } -} - -impl Default for QobuzCache { - fn default() -> Self { - Self::new() - } -} - -/// Statistiques du cache -#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] -pub struct CacheStats { - /// Nombre d'albums en cache - pub albums_count: u64, - /// Nombre de tracks en cache - pub tracks_count: u64, - /// Nombre d'artistes en cache - pub artists_count: u64, - /// Nombre de playlists en cache - pub playlists_count: u64, - /// Nombre de recherches en cache - pub searches_count: u64, - /// Nombre d'URLs de streaming en cache - pub stream_urls_count: u64, -} - -impl CacheStats { - /// Retourne le nombre total d'entrées en cache - pub fn total_count(&self) -> u64 { - self.albums_count - + self.tracks_count - + self.artists_count - + self.playlists_count - + self.searches_count - + self.stream_urls_count - } -} - -#[cfg(test)] -mod tests { - use super::*; - use crate::models::Artist; - - #[tokio::test] - async fn test_cache_basic_operations() { - let cache = QobuzCache::new(); - - let artist = Artist::new("123", "Test Artist"); - - // Test insertion - cache.put_artist("123".to_string(), artist.clone()).await; - - // Test récupération - let retrieved = cache.get_artist("123").await; - assert!(retrieved.is_some()); - assert_eq!(retrieved.unwrap().name, "Test Artist"); - - // Test invalidation - cache.invalidate_artist("123").await; - let after_invalidation = cache.get_artist("123").await; - assert!(after_invalidation.is_none()); - } - - #[tokio::test] - async fn test_cache_stats() { - let cache = QobuzCache::new(); - - let artist = Artist::new("123", "Test Artist"); - cache.put_artist("123".to_string(), artist).await; - - let stats = cache.stats().await; - assert_eq!(stats.artists_count, 1); - assert_eq!(stats.albums_count, 0); - } - - #[tokio::test] - async fn test_cache_clear_all() { - let cache = QobuzCache::new(); - - let artist = Artist::new("123", "Test Artist"); - cache.put_artist("123".to_string(), artist).await; - - cache.clear_all().await; - - let stats = cache.stats().await; - assert_eq!(stats.total_count(), 0); - } -} -========= End of pmoqobuz/src/cache.rs =========== - -=============== pmoqobuz/src/client.rs ============ -//! Client principal pour interagir avec l'API Qobuz -//! -//! Ce module fournit un client haut-niveau avec authentification et cache intégré. - -use crate::api::auth::AuthInfo; -use crate::api::QobuzApi; -use crate::cache::QobuzCache; -use crate::error::{QobuzError, Result}; -use crate::models::*; -use pmoconfig::Config; -use std::sync::Arc; -use tracing::{debug, info}; - -/// App ID Qobuz par défaut (peut être overridé) -const DEFAULT_APP_ID: &str = "1401488693436528"; - -/// Client Qobuz haut-niveau avec cache -pub struct QobuzClient { - /// API bas-niveau - api: QobuzApi, - /// Cache en mémoire - cache: Arc, - /// Informations d'authentification - auth_info: Option, -} - -impl QobuzClient { - /// Crée un nouveau client et authentifie avec les credentials fournis - /// - /// # Arguments - /// - /// * `username` - Email ou nom d'utilisateur Qobuz - /// * `password` - Mot de passe - /// - /// # Exemple - /// - /// ```rust,no_run - /// use pmoqobuz::QobuzClient; - /// - /// #[tokio::main] - /// async fn main() -> anyhow::Result<()> { - /// let client = QobuzClient::new("user@example.com", "password").await?; - /// Ok(()) - /// } - /// ``` - pub async fn new(username: &str, password: &str) -> Result { - Self::with_app_id(DEFAULT_APP_ID, username, password).await - } - - /// Crée un nouveau client avec un App ID personnalisé - pub async fn with_app_id(app_id: &str, username: &str, password: &str) -> Result { - info!("Creating Qobuz client with app ID: {}", app_id); - - let mut api = QobuzApi::new(app_id)?; - let auth_info = api.login(username, password).await?; - - Ok(Self { - api, - cache: Arc::new(QobuzCache::new()), - auth_info: Some(auth_info), - }) - } - - /// Crée un client en utilisant la configuration de pmoconfig - /// - /// # Exemple - /// - /// ```rust,no_run - /// use pmoqobuz::QobuzClient; - /// - /// #[tokio::main] - /// async fn main() -> anyhow::Result<()> { - /// let client = QobuzClient::from_config().await?; - /// Ok(()) - /// } - /// ``` - pub async fn from_config() -> Result { - let config = pmoconfig::get_config(); - Self::from_config_obj(config.as_ref()).await - } - - /// Crée un client depuis un objet Config spécifique - pub async fn from_config_obj(config: &Config) -> Result { - let (username, password) = config.get_qobuz_credentials()?; - Self::new(&username, &password).await - } - - /// Définit le format audio par défaut - pub fn set_format(&mut self, format: AudioFormat) { - self.api.set_format(format); - } - - /// Retourne le format audio configuré - pub fn format(&self) -> AudioFormat { - self.api.format() - } - - /// Retourne les informations d'authentification - pub fn auth_info(&self) -> Option<&AuthInfo> { - self.auth_info.as_ref() - } - - /// Retourne une référence au cache - pub fn cache(&self) -> Arc { - self.cache.clone() - } - - // ============ Albums ============ - - /// Récupère un album par son ID - pub async fn get_album(&self, album_id: &str) -> Result { - // Vérifier le cache d'abord - if let Some(album) = self.cache.get_album(album_id).await { - debug!("Album {} found in cache", album_id); - return Ok(album); - } - - // Sinon, récupérer depuis l'API - let album = self.api.get_album(album_id).await?; - - // Mettre en cache - self.cache - .put_album(album_id.to_string(), album.clone()) - .await; - - Ok(album) - } - - /// Récupère les tracks d'un album - pub async fn get_album_tracks(&self, album_id: &str) -> Result> { - let tracks = self.api.get_album_tracks(album_id).await?; - - // Mettre les tracks en cache - for track in &tracks { - self.cache.put_track(track.id.clone(), track.clone()).await; - } - - Ok(tracks) - } - - // ============ Tracks ============ - - /// Récupère une track par son ID - pub async fn get_track(&self, track_id: &str) -> Result { - if let Some(track) = self.cache.get_track(track_id).await { - debug!("Track {} found in cache", track_id); - return Ok(track); - } - - let track = self.api.get_track(track_id).await?; - self.cache - .put_track(track_id.to_string(), track.clone()) - .await; - - Ok(track) - } - - /// Récupère l'URL de streaming d'une track - pub async fn get_stream_url(&self, track_id: &str) -> Result { - // Vérifier le cache d'abord - if let Some(info) = self.cache.get_stream_url(track_id).await { - if info.expires_at > chrono::Utc::now() { - debug!("Stream URL for track {} found in cache", track_id); - return Ok(info.url); - } - } - - // Sinon, récupérer depuis l'API - let info = self.api.get_file_url(track_id).await?; - let url = info.url.clone(); - - // Mettre en cache - self.cache.put_stream_url(track_id.to_string(), info).await; - - Ok(url) - } - - // ============ Artists ============ - - /// Récupère un artiste par son ID - pub async fn get_artist(&self, artist_id: &str) -> Result { - if let Some(artist) = self.cache.get_artist(artist_id).await { - debug!("Artist {} found in cache", artist_id); - return Ok(artist); - } - - // Pour récupérer un artiste, on doit passer par get_artist_albums - let albums = self.api.get_artist_albums(artist_id).await?; - - if let Some(first_album) = albums.first() { - let artist = first_album.artist.clone(); - self.cache - .put_artist(artist_id.to_string(), artist.clone()) - .await; - Ok(artist) - } else { - Err(QobuzError::NotFound(format!( - "Artist {} not found", - artist_id - ))) - } - } - - /// Récupère les albums d'un artiste - pub async fn get_artist_albums(&self, artist_id: &str) -> Result> { - self.api.get_artist_albums(artist_id).await - } - - /// Récupère les artistes similaires - pub async fn get_similar_artists(&self, artist_id: &str) -> Result> { - self.api.get_similar_artists(artist_id).await - } - - // ============ Playlists ============ - - /// Récupère une playlist par son ID - pub async fn get_playlist(&self, playlist_id: &str) -> Result { - if let Some(playlist) = self.cache.get_playlist(playlist_id).await { - debug!("Playlist {} found in cache", playlist_id); - return Ok(playlist); - } - - let playlist = self.api.get_playlist(playlist_id).await?; - self.cache - .put_playlist(playlist_id.to_string(), playlist.clone()) - .await; - - Ok(playlist) - } - - /// Récupère les tracks d'une playlist - pub async fn get_playlist_tracks(&self, playlist_id: &str) -> Result> { - self.api.get_playlist_tracks(playlist_id).await - } - - // ============ Catalogue ============ - - /// Récupère la liste des genres - pub async fn get_genres(&self) -> Result> { - self.api.get_genres().await - } - - /// Récupère les albums featured (nouveautés, éditeur, etc.) - pub async fn get_featured_albums( - &self, - genre_id: Option<&str>, - type_: &str, - ) -> Result> { - self.api.get_featured_albums(genre_id, type_).await - } - - /// Récupère les playlists featured - pub async fn get_featured_playlists( - &self, - genre_id: Option<&str>, - tags: Option<&str>, - ) -> Result> { - self.api.get_featured_playlists(genre_id, tags).await - } - - // ============ Recherche ============ - - /// Recherche dans le catalogue Qobuz - /// - /// # Arguments - /// - /// * `query` - Termes de recherche - /// * `type_` - Type de recherche : None (tous), Some("albums"), Some("artists"), Some("tracks"), Some("playlists") - pub async fn search(&self, query: &str, type_: Option<&str>) -> Result { - // Créer une clé de cache - let cache_key = format!("{}:{}", query, type_.unwrap_or("all")); - - // Vérifier le cache - if let Some(result) = self.cache.get_search(&cache_key).await { - debug!("Search results for '{}' found in cache", query); - return Ok(result); - } - - // Sinon, rechercher via l'API - let result = self.api.search(query, type_).await?; - - // Mettre en cache - self.cache.put_search(cache_key, result.clone()).await; - - Ok(result) - } - - /// Recherche des albums - pub async fn search_albums(&self, query: &str) -> Result> { - let result = self.search(query, Some("albums")).await?; - Ok(result.albums) - } - - /// Recherche des artistes - pub async fn search_artists(&self, query: &str) -> Result> { - let result = self.search(query, Some("artists")).await?; - Ok(result.artists) - } - - /// Recherche des tracks - pub async fn search_tracks(&self, query: &str) -> Result> { - let result = self.search(query, Some("tracks")).await?; - Ok(result.tracks) - } - - /// Recherche des playlists - pub async fn search_playlists(&self, query: &str) -> Result> { - let result = self.search(query, Some("playlists")).await?; - Ok(result.playlists) - } - - // ============ Favoris ============ - - /// Récupère les albums favoris de l'utilisateur - pub async fn get_favorite_albums(&self) -> Result> { - self.api.get_favorite_albums().await - } - - /// Récupère les artistes favoris de l'utilisateur - pub async fn get_favorite_artists(&self) -> Result> { - self.api.get_favorite_artists().await - } - - /// Récupère les tracks favorites de l'utilisateur - pub async fn get_favorite_tracks(&self) -> Result> { - self.api.get_favorite_tracks().await - } - - /// Récupère les playlists de l'utilisateur - pub async fn get_user_playlists(&self) -> Result> { - self.api.get_user_playlists().await - } - - /// Ajoute un album aux favoris - pub async fn add_favorite_album(&self, album_id: &str) -> Result<()> { - self.api.add_favorite_album(album_id).await - } - - /// Supprime un album des favoris - pub async fn remove_favorite_album(&self, album_id: &str) -> Result<()> { - self.api.remove_favorite_album(album_id).await - } - - /// Ajoute un track aux favoris - pub async fn add_favorite_track(&self, track_id: &str) -> Result<()> { - self.api.add_favorite_track(track_id).await - } - - /// Supprime un track des favoris - pub async fn remove_favorite_track(&self, track_id: &str) -> Result<()> { - self.api.remove_favorite_track(track_id).await - } - - /// Ajoute un track à une playlist - pub async fn add_to_playlist(&self, playlist_id: &str, track_id: &str) -> Result<()> { - self.api.add_to_playlist(playlist_id, track_id).await - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_default_app_id() { - assert!(!DEFAULT_APP_ID.is_empty()); - } - - #[test] - fn test_audio_format() { - assert_eq!(AudioFormat::default(), AudioFormat::Flac_Lossless); - } -} -========= End of pmoqobuz/src/client.rs =========== - -=============== pmoqobuz/src/error.rs ============ -//! Gestion des erreurs pour le client Qobuz - -use thiserror::Error; - -/// Type Result personnalisé pour pmoqobuz -pub type Result = std::result::Result; - -/// Erreurs possibles lors de l'utilisation du client Qobuz -#[derive(Error, Debug)] -pub enum QobuzError { - /// Erreur d'authentification (credentials invalides) - #[error("Authentication failed: {0}")] - Unauthorized(String), - - /// Ressource non trouvée (album, track, etc.) - #[error("Resource not found: {0}")] - NotFound(String), - - /// Erreur HTTP - #[error("HTTP error: {0}")] - Http(#[from] reqwest::Error), - - /// Erreur de parsing JSON - #[error("JSON parsing error: {0}")] - JsonParse(#[from] serde_json::Error), - - /// Erreur de configuration - #[error("Configuration error: {0}")] - Config(#[from] anyhow::Error), - - /// Erreur de l'API Qobuz - #[error("Qobuz API error (code {code}): {message}")] - ApiError { code: u16, message: String }, - - /// Quota dépassé (rate limiting) - #[error("Rate limit exceeded, please try again later")] - RateLimitExceeded, - - /// Contenu non disponible dans la région de l'utilisateur - #[error("Content not available in your region")] - NotAvailable, - - /// Abonnement insuffisant pour accéder au contenu - #[error("Subscription level insufficient: {0}")] - SubscriptionRequired(String), - - /// Erreur de cache - #[error("Cache error: {0}")] - Cache(String), - - /// Erreur d'export DIDL - #[error("DIDL export error: {0}")] - DidlExport(String), - - /// Erreur générique - #[error("Qobuz error: {0}")] - Other(String), -} - -impl QobuzError { - /// Crée une erreur API depuis un code de statut HTTP et un message - pub fn from_status_code(code: u16, message: impl Into) -> Self { - match code { - 401 | 403 => Self::Unauthorized(message.into()), - 404 => Self::NotFound(message.into()), - 429 => Self::RateLimitExceeded, - _ => Self::ApiError { - code, - message: message.into(), - }, - } - } - - /// Vérifie si l'erreur est une erreur de credentials - pub fn is_auth_error(&self) -> bool { - matches!(self, QobuzError::Unauthorized(_)) - } - - /// Vérifie si l'erreur est une erreur de rate limiting - pub fn is_rate_limit(&self) -> bool { - matches!(self, QobuzError::RateLimitExceeded) - } -} -========= End of pmoqobuz/src/error.rs =========== - -=============== pmoqobuz/src/lib.rs ============ -//! # pmoqobuz - Client Qobuz pour PMOMusic -//! -//! Cette crate fournit un client Rust pour l'API Qobuz, inspiré de l'implémentation Python d'upmpdcli, -//! avec un système de cache en mémoire et une intégration avec les autres modules PMOMusic. -//! -//! ## Vue d'ensemble -//! -//! `pmoqobuz` permet d'accéder aux fonctionnalités de Qobuz : -//! - Authentification avec les credentials configurés -//! - Navigation dans le catalogue (albums, artistes, playlists, tracks) -//! - Recherche dans le catalogue -//! - Accès aux favoris de l'utilisateur -//! - Cache en mémoire pour minimiser les requêtes API -//! - Export des objets en format DIDL-Lite (via `pmodidl`) -//! - Cache des images d'albums (via `pmocovers`) -//! -//! ## Architecture -//! -//! La crate suit le pattern d'extension des autres crates PMO : -//! - `QobuzClient` : Client principal avec authentification et cache -//! - `models` : Structures de données (Album, Track, Artist, etc.) -//! - `api` : Couche d'accès à l'API REST Qobuz -//! - `cache` : Système de cache en mémoire avec TTL -//! - `didl` : Export des objets en format DIDL-Lite -//! -//! ## Structure des modules -//! -//! ```text -//! pmoqobuz/ -//! ├── src/ -//! │ ├── lib.rs # Module principal (ce fichier) -//! │ ├── client.rs # Client Qobuz principal -//! │ ├── models.rs # Structures de données -//! │ ├── api/ -//! │ │ ├── mod.rs # API client -//! │ │ ├── auth.rs # Authentification -//! │ │ ├── catalog.rs # Accès au catalogue -//! │ │ └── user.rs # API utilisateur (favoris) -//! │ ├── cache.rs # Cache en mémoire -//! │ ├── didl.rs # Export DIDL-Lite -//! │ └── error.rs # Gestion des erreurs -//! ``` -//! -//! ## Utilisation -//! -//! ### Exemple basique avec configuration automatique -//! -//! ```rust,no_run -//! use pmoqobuz::QobuzClient; -//! -//! #[tokio::main] -//! async fn main() -> anyhow::Result<()> { -//! // Utilise automatiquement la config depuis pmoconfig -//! let client = QobuzClient::from_config().await?; -//! -//! // Rechercher des albums -//! let results = client.search_albums("Miles Davis").await?; -//! for album in results { -//! println!("{} - {}", album.artist.name, album.title); -//! } -//! -//! Ok(()) -//! } -//! ``` -//! -//! ### Exemple avec credentials personnalisés -//! -//! ```rust,no_run -//! use pmoqobuz::QobuzClient; -//! -//! #[tokio::main] -//! async fn main() -> anyhow::Result<()> { -//! let client = QobuzClient::new("user@example.com", "password").await?; -//! -//! // Obtenir les albums favoris -//! let favorites = client.get_favorite_albums().await?; -//! -//! Ok(()) -//! } -//! ``` -//! -//! ### Export DIDL-Lite -//! -//! ```rust,no_run -//! use pmoqobuz::QobuzClient; -//! -//! #[tokio::main] -//! async fn main() -> anyhow::Result<()> { -//! let client = QobuzClient::from_config().await?; -//! -//! let album = client.get_album("12345").await?; -//! let didl_container = album.to_didl_container("parent_id")?; -//! -//! Ok(()) -//! } -//! ``` -//! -//! ## Cache -//! -//! Le client utilise un cache en mémoire avec TTL pour minimiser les requêtes à l'API Qobuz : -//! - Albums : 1 heure -//! - Tracks : 1 heure -//! - Artistes : 1 heure -//! - Playlists : 30 minutes -//! - Résultats de recherche : 15 minutes -//! - URLs de streaming : 5 minutes -//! -//! ## Intégration pmocovers et pmoaudiocache -//! -//! La feature `cache` active le support complet du cache pour les images et l'audio. -//! -//! ### Cache d'images (pmocovers) -//! -//! Les images de couverture sont automatiquement téléchargées et converties en WebP : -//! -//! ```rust,no_run -//! use pmoqobuz::{QobuzSource, QobuzClient}; -//! use pmocovers::Cache as CoverCache; -//! use std::sync::Arc; -//! -//! # async fn example() -> Result<(), Box> { -//! let client = QobuzClient::from_config().await?; -//! let cover_cache = Arc::new(CoverCache::new("./cache/covers", 500)?); -//! -//! let source = QobuzSource::new_with_cache( -//! client, -//! "http://localhost:8080", -//! Some(cover_cache), -//! None, -//! ); -//! # Ok(()) -//! # } -//! ``` -//! -//! ### Cache audio (pmoaudiocache) -//! -//! L'audio haute résolution est téléchargé et caché localement avec métadonnées enrichies : -//! -//! ```rust,no_run -//! use pmoqobuz::{QobuzSource, QobuzClient}; -//! use pmocovers::Cache as CoverCache; -//! use pmoaudiocache::AudioCache; -//! use std::sync::Arc; -//! -//! # async fn example() -> Result<(), Box> { -//! let client = QobuzClient::from_config().await?; -//! let cover_cache = Arc::new(CoverCache::new("./cache/covers", 500)?); -//! let audio_cache = Arc::new(AudioCache::new("./cache/audio", 100)?); -//! -//! let source = QobuzSource::new_with_cache( -//! client.clone(), -//! "http://localhost:8080", -//! Some(cover_cache), -//! Some(audio_cache), -//! ); -//! -//! // Add a track with caching -//! let tracks = client.get_favorite_tracks().await?; -//! if let Some(track) = tracks.first() { -//! let track_id = source.add_track(track).await?; -//! // Audio and cover are now cached with rich metadata -//! -//! // Resolve URI (returns cached version if available) -//! let uri = source.resolve_uri(&track_id).await?; -//! } -//! # Ok(()) -//! # } -//! ``` -//! -//! ### Métadonnées enrichies -//! -//! Qobuz fournit des métadonnées détaillées qui sont préservées dans le cache : -//! - Titre, artiste, album -//! - Numéro de piste et de disque -//! - Année de sortie -//! - Genre(s) -//! - Label -//! - Qualité audio (sample rate, bit depth, channels) -//! - Durée -//! -//! ### Exemple complet -//! -//! Voir `examples/with_cache.rs` pour un exemple complet d'utilisation avec cache. -//! -//! ## Formats audio supportés -//! -//! Qobuz propose plusieurs formats : -//! - Format 5 : MP3 320 kbps -//! - Format 6 : FLAC 16 bit / 44.1 kHz (CD Quality) -//! - Format 7 : FLAC 24 bit / jusqu'à 96 kHz (Hi-Res) -//! - Format 27 : FLAC 24 bit / jusqu'à 192 kHz (Hi-Res+) -//! -//! ## Gestion des erreurs -//! -//! La crate utilise `thiserror` pour définir des erreurs typées : -//! -//! ```rust,ignore -//! use pmoqobuz::{QobuzClient, QobuzError}; -//! -//! match client.get_album("invalid").await { -//! Ok(album) => println!("Album: {}", album.title), -//! Err(QobuzError::NotFound) => println!("Album not found"), -//! Err(QobuzError::Unauthorized) => println!("Authentication failed"), -//! Err(e) => println!("Error: {}", e), -//! } -//! ``` -//! -//! ## Voir aussi -//! -//! - [`pmodidl`] : Format DIDL-Lite -//! - [`pmocovers`] : Cache d'images -//! - [`pmoaudiocache`] : Cache audio -//! - [`pmoconfig`] : Configuration -//! - [`pmoserver`] : Serveur HTTP - -pub mod api; -pub mod cache; -pub mod client; -pub mod didl; -pub mod error; -pub mod models; -pub mod source; - -// Extension pmoserver (feature-gated) -#[cfg(feature = "pmoserver")] -pub mod api_rest; - -#[cfg(feature = "pmoserver")] -pub mod pmoserver_ext; - -#[cfg(feature = "pmoserver")] -mod pmoserver_impl; - -pub use client::QobuzClient; -pub use error::{QobuzError, Result}; -pub use models::{Album, Artist, AudioFormat, Genre, Playlist, SearchResult, Track}; -pub use source::QobuzSource; - -/// Ré-exporte les types DIDL pour faciliter l'utilisation -pub use didl::ToDIDL; - -/// Ré-exporte le trait d'extension pmoserver -#[cfg(feature = "pmoserver")] -pub use pmoserver_ext::QobuzServerExt; -========= End of pmoqobuz/src/lib.rs =========== - -=============== pmoqobuz/src/models.rs ============ -//! Structures de données pour représenter les objets Qobuz - -use chrono::{DateTime, Utc}; -use serde::{Deserialize, Serialize}; - -/// Représente un artiste Qobuz -#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)] -pub struct Artist { - /// Identifiant unique de l'artiste - pub id: String, - /// Nom de l'artiste - pub name: String, - /// URL de l'image de l'artiste (optionnelle) - #[serde(default)] - pub image: Option, - /// URL de l'image cachée localement (via pmocovers) - #[serde(skip)] - pub image_cached: Option, -} - -/// Représente un album Qobuz -#[derive(Debug, Clone, Serialize, Deserialize)] -pub struct Album { - /// Identifiant unique de l'album - pub id: String, - /// Titre de l'album - pub title: String, - /// Artiste principal de l'album - pub artist: Artist, - /// Nombre de pistes - #[serde(default)] - pub tracks_count: Option, - /// Durée totale en secondes - #[serde(default)] - pub duration: Option, - /// Date de sortie (format ISO 8601) - #[serde(default)] - pub release_date: Option, - /// URL de l'image de couverture - #[serde(default)] - pub image: Option, - /// URL de l'image cachée localement (via pmocovers) - #[serde(skip)] - pub image_cached: Option, - /// Indique si l'album est disponible pour le streaming - #[serde(default = "default_true")] - pub streamable: bool, - /// Description de l'album - #[serde(default)] - pub description: Option, - /// Taux d'échantillonnage maximum (Hz) - #[serde(default)] - pub maximum_sampling_rate: Option, - /// Profondeur de bits maximale - #[serde(default)] - pub maximum_bit_depth: Option, - /// Genre(s) de l'album - #[serde(default)] - pub genres: Vec, - /// Label de l'album - #[serde(default)] - pub label: Option, -} - -/// Représente une piste (track) Qobuz -#[derive(Debug, Clone, Serialize, Deserialize)] -pub struct Track { - /// Identifiant unique de la piste - pub id: String, - /// Titre de la piste - pub title: String, - /// Artiste de la piste (peut différer de l'artiste de l'album) - pub performer: Option, - /// Album contenant la piste - pub album: Option, - /// Durée en secondes - pub duration: u32, - /// Numéro de piste - pub track_number: u32, - /// Numéro de disque (pour les albums multi-disques) - pub media_number: u32, - /// Indique si la piste est disponible pour le streaming - #[serde(default = "default_true")] - pub streamable: bool, - /// Type MIME du fichier audio (déterminé après obtention de l'URL) - #[serde(skip)] - pub mime_type: Option, - /// Fréquence d'échantillonnage (Hz) - #[serde(skip)] - pub sample_rate: Option, - /// Profondeur de bits - #[serde(skip)] - pub bit_depth: Option, - /// Nombre de canaux audio - #[serde(skip)] - pub channels: Option, -} - -/// Représente une playlist Qobuz -#[derive(Debug, Clone, Serialize, Deserialize)] -pub struct Playlist { - /// Identifiant unique de la playlist - pub id: String, - /// Nom de la playlist - pub name: String, - /// Description de la playlist - #[serde(default)] - pub description: Option, - /// Nombre de pistes - #[serde(default)] - pub tracks_count: Option, - /// Durée totale en secondes - #[serde(default)] - pub duration: Option, - /// URL de l'image de la playlist - #[serde(default)] - pub image: Option, - /// URL de l'image cachée localement - #[serde(skip)] - pub image_cached: Option, - /// Indique si c'est une playlist publique - #[serde(default)] - pub is_public: bool, - /// Propriétaire de la playlist - #[serde(default)] - pub owner: Option, -} - -/// Propriétaire d'une playlist -#[derive(Debug, Clone, Serialize, Deserialize)] -pub struct PlaylistOwner { - /// Identifiant de l'utilisateur - pub id: u64, - /// Nom de l'utilisateur - pub name: String, -} - -/// Représente un genre musical -#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)] -pub struct Genre { - /// Identifiant du genre (peut être None pour "All Genres") - pub id: Option, - /// Nom du genre - pub name: String, - /// Genres enfants - #[serde(default)] - pub children: Vec, -} - -/// Résultats de recherche -#[derive(Debug, Clone, Default, Serialize, Deserialize)] -pub struct SearchResult { - /// Albums trouvés - #[serde(default)] - pub albums: Vec, - /// Artistes trouvés - #[serde(default)] - pub artists: Vec, - /// Pistes trouvées - #[serde(default)] - pub tracks: Vec, - /// Playlists trouvées - #[serde(default)] - pub playlists: Vec, -} - -/// Informations sur un fichier de streaming -#[derive(Debug, Clone, Serialize, Deserialize)] -pub struct StreamInfo { - /// URL de streaming - pub url: String, - /// Type MIME - pub mime_type: String, - /// Fréquence d'échantillonnage (Hz) - pub sampling_rate: u32, - /// Profondeur de bits - pub bit_depth: u32, - /// Format ID Qobuz - pub format_id: u8, - /// Date d'expiration de l'URL - #[serde(skip)] - pub expires_at: DateTime, -} - -/// Format audio demandé pour le streaming -#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] -#[repr(u8)] -#[allow(non_camel_case_types)] -pub enum AudioFormat { - /// MP3 320 kbps - Mp3_320 = 5, - /// FLAC 16 bit / 44.1 kHz (CD Quality) - Flac_Lossless = 6, - /// FLAC 24 bit / jusqu'à 96 kHz (Hi-Res) - Flac_HiRes_96 = 7, - /// FLAC 24 bit / jusqu'à 192 kHz (Hi-Res+) - Flac_HiRes_192 = 27, -} - -impl AudioFormat { - /// Retourne l'ID du format pour l'API Qobuz - pub fn id(&self) -> u8 { - *self as u8 - } - - /// Retourne une description lisible du format - pub fn description(&self) -> &'static str { - match self { - AudioFormat::Mp3_320 => "MP3 320 kbps", - AudioFormat::Flac_Lossless => "FLAC 16 bit / 44.1 kHz", - AudioFormat::Flac_HiRes_96 => "FLAC 24 bit / up to 96 kHz", - AudioFormat::Flac_HiRes_192 => "FLAC 24 bit / up to 192 kHz", - } - } - - /// Retourne le type MIME associé - pub fn mime_type(&self) -> &'static str { - match self { - AudioFormat::Mp3_320 => "audio/mpeg", - _ => "audio/flac", - } - } -} - -impl Default for AudioFormat { - fn default() -> Self { - AudioFormat::Flac_Lossless - } -} - -// Helper functions -fn default_true() -> bool { - true -} - -impl Artist { - /// Crée un nouvel artiste avec un ID et un nom - pub fn new(id: impl Into, name: impl Into) -> Self { - Self { - id: id.into(), - name: name.into(), - image: None, - image_cached: None, - } - } -} - -impl Album { - /// Retourne un titre formaté avec les informations audio si disponibles - pub fn formatted_title(&self) -> String { - if let (Some(rate), Some(depth)) = (self.maximum_sampling_rate, self.maximum_bit_depth) { - format!("{} ({:.0}/{} bit)", self.title, rate / 1000.0, depth) - } else { - self.title.clone() - } - } - - /// Vérifie si l'album est disponible pour le streaming - pub fn is_available(&self) -> bool { - self.streamable - } -} - -impl Track { - /// Retourne l'artiste à afficher (performer ou artiste de l'album) - pub fn display_artist(&self) -> Option<&Artist> { - self.performer - .as_ref() - .or_else(|| self.album.as_ref().map(|a| &a.artist)) - } - - /// Retourne le nom de l'album si disponible - pub fn album_name(&self) -> Option<&str> { - self.album.as_ref().map(|a| a.title.as_str()) - } - - /// Vérifie si la piste est disponible pour le streaming - pub fn is_available(&self) -> bool { - self.streamable - } -} - -impl SearchResult { - /// Crée un résultat de recherche vide - pub fn new() -> Self { - Self::default() - } - - /// Retourne le nombre total de résultats - pub fn total_count(&self) -> usize { - self.albums.len() + self.artists.len() + self.tracks.len() + self.playlists.len() - } - - /// Vérifie si la recherche n'a retourné aucun résultat - pub fn is_empty(&self) -> bool { - self.total_count() == 0 - } -} -========= End of pmoqobuz/src/models.rs =========== - -=============== pmoqobuz/src/didl.rs ============ -//! Export des objets Qobuz en format DIDL-Lite -//! -//! Ce module permet de convertir les structures Qobuz (Album, Track, etc.) -//! en objets DIDL-Lite compatibles avec UPnP/DLNA. - -use crate::error::{QobuzError, Result}; -use crate::models::{Album, Playlist, Track}; -use pmodidl::{Container, Item, Resource}; - -/// Trait pour convertir un objet Qobuz en DIDL-Lite -pub trait ToDIDL { - /// Convertit l'objet en Container DIDL - fn to_didl_container(&self, parent_id: &str) -> Result; - - /// Convertit l'objet en Item DIDL - fn to_didl_item(&self, parent_id: &str) -> Result; -} - -impl ToDIDL for Album { - /// Convertit un album en Container DIDL - /// - /// # Arguments - /// - /// * `parent_id` - ID du container parent - /// - /// # Exemple - /// - /// ```rust,ignore - /// let album = client.get_album("12345").await?; - /// let container = album.to_didl_container("0$qobuz$albums")?; - /// ``` - fn to_didl_container(&self, parent_id: &str) -> Result { - let id = format!("0$qobuz$album${}", self.id); - - Ok(Container { - id, - parent_id: parent_id.to_string(), - restricted: Some("1".to_string()), - child_count: self.tracks_count.map(|c| c.to_string()), - searchable: Some("1".to_string()), - title: self.formatted_title(), - class: "object.container.album.musicAlbum".to_string(), - containers: Vec::new(), - items: Vec::new(), - }) - } - - /// Un album ne peut pas être converti directement en Item - fn to_didl_item(&self, _parent_id: &str) -> Result { - Err(QobuzError::DidlExport( - "Album cannot be converted to Item, use to_didl_container instead".to_string(), - )) - } -} - -impl ToDIDL for Track { - /// Une track ne peut pas être convertie en Container - fn to_didl_container(&self, _parent_id: &str) -> Result { - Err(QobuzError::DidlExport( - "Track cannot be converted to Container, use to_didl_item instead".to_string(), - )) - } - - /// Convertit une track en Item DIDL - /// - /// # Arguments - /// - /// * `parent_id` - ID du container parent - /// - /// # Exemple - /// - /// ```rust,ignore - /// let track = client.get_track("98765").await?; - /// let item = track.to_didl_item("0$qobuz$album$12345")?; - /// ``` - fn to_didl_item(&self, parent_id: &str) -> Result { - let id = format!("0$qobuz$track${}", self.id); - - // Déterminer l'artiste à afficher - let artist_name = self - .display_artist() - .map(|a| a.name.clone()) - .or_else(|| self.album.as_ref().map(|a| a.artist.name.clone())); - - // Déterminer l'album - let album_name = self.album_name().map(|s| s.to_string()); - - // Déterminer l'image de couverture - let album_art = self - .album - .as_ref() - .and_then(|a| a.image_cached.clone().or_else(|| a.image.clone())); - - // Créer la ressource (URL de streaming) - // Note: L'URL sera remplie plus tard via get_stream_url - let resource = Resource { - protocol_info: format!( - "http-get:*:{}:*", - self.mime_type.as_deref().unwrap_or("audio/flac") - ), - bits_per_sample: self.bit_depth.map(|b| b.to_string()), - sample_frequency: self.sample_rate.map(|r| r.to_string()), - nr_audio_channels: self.channels.map(|c| c.to_string()), - duration: Some(format_duration(self.duration)), - url: format!("qobuz://track/{}", self.id), // URL symbolique - }; - - Ok(Item { - id, - parent_id: parent_id.to_string(), - restricted: Some("1".to_string()), - title: self.title.clone(), - creator: artist_name.clone(), - class: "object.item.audioItem.musicTrack".to_string(), - artist: artist_name, - album: album_name, - genre: None, // Qobuz ne fournit pas le genre au niveau track - album_art, - album_art_pk: None, - date: self.album.as_ref().and_then(|a| a.release_date.clone()), - original_track_number: Some(self.track_number.to_string()), - resources: vec![resource], - descriptions: Vec::new(), - }) - } -} - -impl ToDIDL for Playlist { - /// Convertit une playlist en Container DIDL - fn to_didl_container(&self, parent_id: &str) -> Result { - let id = format!("0$qobuz$playlist${}", self.id); - - Ok(Container { - id, - parent_id: parent_id.to_string(), - restricted: Some("1".to_string()), - child_count: self.tracks_count.map(|c| c.to_string()), - searchable: Some("1".to_string()), - title: self.name.clone(), - class: "object.container.playlistContainer".to_string(), - containers: Vec::new(), - items: Vec::new(), - }) - } - - /// Une playlist ne peut pas être convertie en Item - fn to_didl_item(&self, _parent_id: &str) -> Result { - Err(QobuzError::DidlExport( - "Playlist cannot be converted to Item, use to_didl_container instead".to_string(), - )) - } -} - -/// Formate une durée en secondes au format HH:MM:SS -fn format_duration(seconds: u32) -> String { - let hours = seconds / 3600; - let minutes = (seconds % 3600) / 60; - let secs = seconds % 60; - format!("{:02}:{:02}:{:02}", hours, minutes, secs) -} - -/// Convertit une liste de tracks en items DIDL -pub fn tracks_to_didl_items(tracks: &[Track], parent_id: &str) -> Result> { - tracks - .iter() - .map(|track| track.to_didl_item(parent_id)) - .collect() -} - -/// Convertit une liste d'albums en containers DIDL -pub fn albums_to_didl_containers(albums: &[Album], parent_id: &str) -> Result> { - albums - .iter() - .map(|album| album.to_didl_container(parent_id)) - .collect() -} - -/// Convertit une liste de playlists en containers DIDL -pub fn playlists_to_didl_containers( - playlists: &[Playlist], - parent_id: &str, -) -> Result> { - playlists - .iter() - .map(|playlist| playlist.to_didl_container(parent_id)) - .collect() -} - -#[cfg(test)] -mod tests { - use super::*; - use crate::models::{Album, Artist, Track}; - - #[test] - fn test_album_to_didl_container() { - let album = Album { - id: "123".to_string(), - title: "Test Album".to_string(), - artist: Artist::new("456", "Test Artist"), - tracks_count: Some(10), - duration: Some(3000), - release_date: Some("2024-01-01".to_string()), - image: None, - image_cached: None, - streamable: true, - description: None, - maximum_sampling_rate: Some(96000.0), - maximum_bit_depth: Some(24), - genres: vec![], - label: None, - }; - - let container = album.to_didl_container("parent").unwrap(); - assert_eq!(container.id, "0$qobuz$album$123"); - assert_eq!(container.parent_id, "parent"); - assert!(container.title.contains("Test Album")); - } - - #[test] - fn test_track_to_didl_item() { - let track = Track { - id: "789".to_string(), - title: "Test Track".to_string(), - performer: Some(Artist::new("456", "Test Artist")), - album: None, - duration: 180, - track_number: 1, - media_number: 1, - streamable: true, - mime_type: Some("audio/flac".to_string()), - sample_rate: Some(44100), - bit_depth: Some(16), - channels: Some(2), - }; - - let item = track.to_didl_item("parent").unwrap(); - assert_eq!(item.id, "0$qobuz$track$789"); - assert_eq!(item.parent_id, "parent"); - assert_eq!(item.title, "Test Track"); - } - - #[test] - fn test_format_duration() { - assert_eq!(format_duration(0), "00:00:00"); - assert_eq!(format_duration(90), "00:01:30"); - assert_eq!(format_duration(3665), "01:01:05"); - } -} -========= End of pmoqobuz/src/didl.rs =========== - -=============== pmoqobuz/src/source.rs ============ -//! Music source implementation for Qobuz -//! -//! This module implements the [`pmosource::MusicSource`] trait for Qobuz, -//! providing a complete music catalog browsing and searching experience. - -use crate::client::QobuzClient; -use crate::didl::ToDIDL; -use crate::models::Track; -use pmoaudiocache::{AudioMetadata, Cache as AudioCache}; -use pmocovers::Cache as CoverCache; -use pmodidl::{Container, Item}; -use pmosource::SourceCacheManager; -use pmosource::{async_trait, BrowseResult, MusicSource, MusicSourceError, Result}; -use std::sync::Arc; -use std::time::SystemTime; - -/// Default image for Qobuz (300x300 WebP, embedded in binary) -const DEFAULT_IMAGE: &[u8] = include_bytes!("../assets/default.webp"); - -/// Qobuz music source with full MusicSource trait implementation -/// -/// This struct combines a [`QobuzClient`] for API access with browsing and -/// navigation capabilities, implementing the complete [`MusicSource`] trait. -/// -/// # Features -/// -/// - **Catalog Navigation**: Browse albums, artists, playlists, favorites -/// - **Search**: Full-text search across the Qobuz catalog -/// - **URI Resolution**: Resolves track streaming URIs with authentication -/// - **DIDL-Lite Export**: Converts albums, tracks, and playlists to UPnP formats -/// - **Caching**: Integrated with QobuzClient's cache for performance -/// -/// # Architecture -/// -/// Unlike streaming sources like Radio Paradise, Qobuz is a catalog-based source: -/// - Root container has multiple sub-containers (Albums, Artists, Favorites, etc.) -/// - No FIFO support (it's a static catalog, not a dynamic stream) -/// - Hierarchical browsing: Root → Category → Albums → Tracks -/// -/// # Examples -/// -/// ```no_run -/// use pmoqobuz::{QobuzSource, QobuzClient}; -/// use pmosource::MusicSource; -/// -/// #[tokio::main] -/// async fn main() -> Result<(), Box> { -/// let client = QobuzClient::from_config().await?; -/// let source = QobuzSource::new(client); -/// -/// println!("Source: {}", source.name()); -/// println!("Supports FIFO: {}", source.supports_fifo()); -/// -/// // Browse root container -/// let root = source.root_container().await?; -/// println!("Root: {} with {} children", root.title, root.child_count.unwrap_or_default()); -/// -/// Ok(()) -/// } -/// ``` -#[derive(Clone)] -pub struct QobuzSource { - inner: Arc, -} - -struct QobuzSourceInner { - /// Qobuz API client - client: QobuzClient, - - /// Cache manager (centralisé) - cache_manager: SourceCacheManager, - - /// Update tracking - update_counter: tokio::sync::RwLock, - last_change: tokio::sync::RwLock, -} - -impl std::fmt::Debug for QobuzSource { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - f.debug_struct("QobuzSource").finish() - } -} - -impl QobuzSource { - /// Create a new Qobuz source from the cache registry - /// - /// This is the recommended way to create a source when using the UPnP server. - /// The caches are automatically retrieved from the global registry. - /// - /// # Arguments - /// - /// * `client` - Authenticated Qobuz API client - /// - /// # Errors - /// - /// Returns an error if the caches are not initialized in the registry - #[cfg(feature = "server")] - pub fn from_registry(client: QobuzClient) -> Result { - let cache_manager = SourceCacheManager::from_registry("qobuz".to_string())?; - - Ok(Self { - inner: Arc::new(QobuzSourceInner { - client, - cache_manager, - update_counter: tokio::sync::RwLock::new(0), - last_change: tokio::sync::RwLock::new(SystemTime::now()), - }), - }) - } - - /// Create a new Qobuz source with explicit caches (for tests) - /// - /// # Arguments - /// - /// * `client` - Authenticated Qobuz API client - /// * `cover_cache` - Cover image cache (required) - /// * `audio_cache` - Audio cache (required) - pub fn new( - client: QobuzClient, - cover_cache: Arc, - audio_cache: Arc, - ) -> Self { - let cache_manager = SourceCacheManager::new("qobuz".to_string(), cover_cache, audio_cache); - - Self { - inner: Arc::new(QobuzSourceInner { - client, - cache_manager, - update_counter: tokio::sync::RwLock::new(0), - last_change: tokio::sync::RwLock::new(SystemTime::now()), - }), - } - } - - /// Get the Qobuz client - pub fn client(&self) -> &QobuzClient { - &self.inner.client - } - - /// Add a track from Qobuz with caching - /// - /// This method downloads and caches both cover art and audio data. - pub async fn add_track(&self, track: &Track) -> Result { - let track_id = format!("qobuz://track/{}", track.id); - - // Get streaming URL - let stream_url = self - .inner - .client - .get_stream_url(&track.id) - .await - .map_err(|e| MusicSourceError::UriResolutionError(e.to_string()))?; - - // 1. Cache cover via manager - let cached_cover_pk = if let Some(ref album) = track.album { - if let Some(ref image_url) = album.image { - self.inner.cache_manager.cache_cover(image_url).await.ok() - } else { - None - } - } else { - None - }; - - // 2. Prepare rich metadata from Qobuz track - let metadata = AudioMetadata { - title: Some(track.title.clone()), - artist: track.performer.as_ref().map(|p| p.name.clone()), - album: track.album.as_ref().map(|a| a.title.clone()), - duration_secs: Some(track.duration as u64), - year: track.album.as_ref().and_then(|a| { - a.release_date - .as_ref() - .and_then(|d| d.split('-').next()?.parse().ok()) - }), - track_number: Some(track.track_number), - track_total: track.album.as_ref().and_then(|a| a.tracks_count), - disc_number: Some(track.media_number), - disc_total: None, - genre: track.album.as_ref().and_then(|a| { - if !a.genres.is_empty() { - Some(a.genres.join(", ")) - } else { - None - } - }), - sample_rate: track.sample_rate, - channels: track.channels, - bitrate: None, - conversion: None, - }; - - // 3. Cache audio via manager - let cached_audio_pk = self - .inner - .cache_manager - .cache_audio(&stream_url, Some(metadata)) - .await - .ok(); - - // 4. Store metadata - self.inner - .cache_manager - .update_metadata( - track_id.clone(), - pmosource::TrackMetadata { - original_uri: stream_url, - cached_audio_pk, - cached_cover_pk, - }, - ) - .await; - - Ok(track_id) - } - - /// Increment update counter (called on catalog changes) - async fn increment_update_id(&self) { - let mut counter = self.inner.update_counter.write().await; - *counter = counter.wrapping_add(1); - let mut last = self.inner.last_change.write().await; - *last = SystemTime::now(); - } - - /// Parse object_id to determine what to browse - /// - /// Object IDs follow these patterns: - /// - "qobuz" or "0" → Root container - /// - "qobuz:favorites" → User's favorite albums - /// - "qobuz:album:{id}" → Tracks in album - /// - "qobuz:playlist:{id}" → Tracks in playlist - fn parse_object_id(&self, object_id: &str) -> ObjectIdType { - if object_id == "qobuz" || object_id == "0" { - return ObjectIdType::Root; - } - - let parts: Vec<&str> = object_id.split(':').collect(); - match parts.as_slice() { - ["qobuz", "favorites"] => ObjectIdType::Favorites, - ["qobuz", "album", id] => ObjectIdType::Album(id.to_string()), - ["qobuz", "playlist", id] => ObjectIdType::Playlist(id.to_string()), - ["qobuz", "artist", id] => ObjectIdType::Artist(id.to_string()), - _ => ObjectIdType::Unknown, - } - } -} - -#[derive(Debug)] -enum ObjectIdType { - Root, - Favorites, - Album(String), - Playlist(String), - Artist(String), - Unknown, -} - -#[async_trait] -impl MusicSource for QobuzSource { - fn name(&self) -> &str { - "Qobuz" - } - - fn id(&self) -> &str { - "qobuz" - } - - fn default_image(&self) -> &[u8] { - DEFAULT_IMAGE - } - - async fn root_container(&self) -> Result { - // Create the root container with sub-containers for different categories - Ok(Container { - id: "qobuz".to_string(), - parent_id: "0".to_string(), - restricted: Some("1".to_string()), - child_count: Some("2".to_string()), // Favorites + Search (simplified) - searchable: Some("1".to_string()), - title: "Qobuz".to_string(), - class: "object.container".to_string(), - containers: vec![ - // Favorites container - Container { - id: "qobuz:favorites".to_string(), - parent_id: "qobuz".to_string(), - restricted: Some("1".to_string()), - child_count: None, // Will be determined when browsed - searchable: Some("1".to_string()), - title: "My Favorites".to_string(), - class: "object.container".to_string(), - containers: vec![], - items: vec![], - }, - ], - items: vec![], - }) - } - - async fn browse(&self, object_id: &str) -> Result { - match self.parse_object_id(object_id) { - ObjectIdType::Root => { - // Return the root container's children - let root = self.root_container().await?; - Ok(BrowseResult::Containers(root.containers)) - } - - ObjectIdType::Favorites => { - // Get user's favorite albums - let albums = self - .inner - .client - .get_favorite_albums() - .await - .map_err(|e| MusicSourceError::BrowseError(e.to_string()))?; - - let containers: Vec = albums - .into_iter() - .filter_map(|album| album.to_didl_container("qobuz:favorites").ok()) - .collect(); - - Ok(BrowseResult::Containers(containers)) - } - - ObjectIdType::Album(album_id) => { - // Get tracks in album - let tracks = self - .inner - .client - .get_album_tracks(&album_id) - .await - .map_err(|e| MusicSourceError::BrowseError(e.to_string()))?; - - let items: Vec = tracks - .into_iter() - .filter_map(|track| { - track - .to_didl_item(&format!("qobuz:album:{}", album_id)) - .ok() - }) - .collect(); - - Ok(BrowseResult::Items(items)) - } - - ObjectIdType::Playlist(playlist_id) => { - // Get tracks in playlist - let tracks = self - .inner - .client - .get_playlist_tracks(&playlist_id) - .await - .map_err(|e| MusicSourceError::BrowseError(e.to_string()))?; - - let items: Vec = tracks - .into_iter() - .filter_map(|track| { - track - .to_didl_item(&format!("qobuz:playlist:{}", playlist_id)) - .ok() - }) - .collect(); - - Ok(BrowseResult::Items(items)) - } - - ObjectIdType::Artist(artist_id) => { - // Get albums by artist - let albums = self - .inner - .client - .get_artist_albums(&artist_id) - .await - .map_err(|e| MusicSourceError::BrowseError(e.to_string()))?; - - let containers: Vec = albums - .into_iter() - .filter_map(|album| { - album - .to_didl_container(&format!("qobuz:artist:{}", artist_id)) - .ok() - }) - .collect(); - - Ok(BrowseResult::Containers(containers)) - } - - ObjectIdType::Unknown => Err(MusicSourceError::ObjectNotFound(object_id.to_string())), - } - } - - async fn resolve_uri(&self, object_id: &str) -> Result { - // Try cache manager first - if let Ok(uri) = self.inner.cache_manager.resolve_uri(object_id).await { - return Ok(uri); - } - - // If not cached, extract track ID and get streaming URL from Qobuz - let track_id = object_id - .strip_prefix("qobuz://track/") - .unwrap_or(object_id); - - self.inner - .client - .get_stream_url(track_id) - .await - .map_err(|e| MusicSourceError::UriResolutionError(e.to_string())) - } - - fn supports_fifo(&self) -> bool { - // Qobuz is a catalog, not a dynamic stream - false - } - - async fn append_track(&self, _track: Item) -> Result<()> { - Err(MusicSourceError::FifoNotSupported) - } - - async fn remove_oldest(&self) -> Result> { - Err(MusicSourceError::FifoNotSupported) - } - - async fn update_id(&self) -> u32 { - *self.inner.update_counter.read().await - } - - async fn last_change(&self) -> Option { - Some(*self.inner.last_change.read().await) - } - - async fn get_items(&self, offset: usize, count: usize) -> Result> { - // For Qobuz, "get_items" returns favorite tracks with pagination - let all_tracks = self - .inner - .client - .get_favorite_tracks() - .await - .map_err(|e| MusicSourceError::BrowseError(e.to_string()))?; - - let items: Vec = all_tracks - .into_iter() - .skip(offset) - .take(count) - .filter_map(|track| track.to_didl_item("qobuz:favorites").ok()) - .collect(); - - Ok(items) - } - - async fn search(&self, query: &str) -> Result { - // Search across Qobuz catalog - let results = self - .inner - .client - .search(query, None) - .await - .map_err(|e| MusicSourceError::BrowseError(e.to_string()))?; - - // Convert albums to containers and tracks to items - let containers: Vec = results - .albums - .into_iter() - .filter_map(|album| album.to_didl_container("qobuz").ok()) - .collect(); - - let items: Vec = results - .tracks - .into_iter() - .filter_map(|track| track.to_didl_item("qobuz").ok()) - .collect(); - - if !containers.is_empty() || !items.is_empty() { - Ok(BrowseResult::Mixed { containers, items }) - } else { - Ok(BrowseResult::Items(vec![])) - } - } - - // ============= Extended Features Implementation ============= - - fn capabilities(&self) -> pmosource::SourceCapabilities { - pmosource::SourceCapabilities { - supports_fifo: false, - supports_search: true, - supports_favorites: true, - supports_playlists: true, - supports_user_content: false, - supports_high_res_audio: true, - max_sample_rate: Some(192_000), // Qobuz supports up to 192kHz - supports_multiple_formats: true, - supports_advanced_search: false, // TODO: Qobuz API supports it, not yet implemented - supports_pagination: true, - } - } - - async fn get_available_formats(&self, object_id: &str) -> Result> { - use pmosource::AudioFormat; - - // Extract track ID from object_id - let track_id = if let Some(id) = object_id.strip_prefix("qobuz://track/") { - id - } else { - object_id - }; - - // Get track details from Qobuz - let track = self - .inner - .client - .get_track(track_id) - .await - .map_err(|e| MusicSourceError::BrowseError(e.to_string()))?; - - // Qobuz provides multiple formats based on subscription - let mut formats = vec![]; - - // MP3 320 (format_id 5) - available to all - formats.push(AudioFormat { - format_id: "mp3-320".to_string(), - mime_type: "audio/mpeg".to_string(), - sample_rate: Some(44100), - bit_depth: None, - bitrate: Some(320), - channels: Some(2), - }); - - // FLAC 16/44.1 (format_id 6) - CD quality - formats.push(AudioFormat { - format_id: "flac-16-44".to_string(), - mime_type: "audio/flac".to_string(), - sample_rate: Some(44100), - bit_depth: Some(16), - bitrate: None, - channels: Some(2), - }); - - // Hi-Res formats (if available for this track) - if let Some(sample_rate) = track.sample_rate { - if sample_rate > 44100 { - // FLAC 24-bit Hi-Res - let bit_depth = track.bit_depth.map(|d| d as u8).or(Some(24)); - - formats.push(AudioFormat { - format_id: format!("flac-{}-{}", bit_depth.unwrap_or(24), sample_rate / 1000), - mime_type: "audio/flac".to_string(), - sample_rate: Some(sample_rate), - bit_depth, - bitrate: None, - channels: track.channels, - }); - } - } - - Ok(formats) - } - - async fn get_cache_status(&self, object_id: &str) -> Result { - self.inner.cache_manager.get_cache_status(object_id).await - } - - async fn cache_item(&self, object_id: &str) -> Result { - // Extract track ID - let track_id = object_id - .strip_prefix("qobuz://track/") - .unwrap_or(object_id); - - // Get track details from Qobuz - let track = self - .inner - .client - .get_track(track_id) - .await - .map_err(|e| MusicSourceError::BrowseError(e.to_string()))?; - - // Add track to cache (via manager) - let cached_id = self.add_track(&track).await?; - - // Return the cache status - self.get_cache_status(&cached_id).await - } - - async fn add_favorite(&self, object_id: &str) -> Result<()> { - // Parse object_id to determine type - let parts: Vec<&str> = object_id.split(':').collect(); - - match parts.as_slice() { - ["qobuz", "album", id] | ["qobuz://album", id] => { - self.inner - .client - .add_favorite_album(id) - .await - .map_err(|e| MusicSourceError::FavoritesError(e.to_string()))?; - } - ["qobuz", "track", id] | ["qobuz://track", id] => { - self.inner - .client - .add_favorite_track(id) - .await - .map_err(|e| MusicSourceError::FavoritesError(e.to_string()))?; - } - _ => { - return Err(MusicSourceError::NotSupported( - "Favorites only supported for albums and tracks".to_string(), - )); - } - } - - self.increment_update_id().await; - Ok(()) - } - - async fn remove_favorite(&self, object_id: &str) -> Result<()> { - // Parse object_id to determine type - let parts: Vec<&str> = object_id.split(':').collect(); - - match parts.as_slice() { - ["qobuz", "album", id] | ["qobuz://album", id] => { - self.inner - .client - .remove_favorite_album(id) - .await - .map_err(|e| MusicSourceError::FavoritesError(e.to_string()))?; - } - ["qobuz", "track", id] | ["qobuz://track", id] => { - self.inner - .client - .remove_favorite_track(id) - .await - .map_err(|e| MusicSourceError::FavoritesError(e.to_string()))?; - } - _ => { - return Err(MusicSourceError::NotSupported( - "Favorites only supported for albums and tracks".to_string(), - )); - } - } - - self.increment_update_id().await; - Ok(()) - } - - async fn is_favorite(&self, object_id: &str) -> Result { - // Parse object_id to determine type - let parts: Vec<&str> = object_id.split(':').collect(); - - match parts.as_slice() { - ["qobuz", "album", id] | ["qobuz://album", id] => { - let favorites = self - .inner - .client - .get_favorite_albums() - .await - .map_err(|e| MusicSourceError::FavoritesError(e.to_string()))?; - - Ok(favorites.iter().any(|album| album.id == *id)) - } - ["qobuz", "track", id] | ["qobuz://track", id] => { - let favorites = self - .inner - .client - .get_favorite_tracks() - .await - .map_err(|e| MusicSourceError::FavoritesError(e.to_string()))?; - - Ok(favorites.iter().any(|track| track.id == *id)) - } - _ => Err(MusicSourceError::NotSupported( - "Favorites only supported for albums and tracks".to_string(), - )), - } - } - - async fn get_user_playlists(&self) -> Result> { - let playlists = self - .inner - .client - .get_user_playlists() - .await - .map_err(|e| MusicSourceError::PlaylistError(e.to_string()))?; - - let containers: Vec = playlists - .into_iter() - .filter_map(|playlist| playlist.to_didl_container("qobuz").ok()) - .collect(); - - Ok(containers) - } - - async fn add_to_playlist(&self, playlist_id: &str, item_id: &str) -> Result<()> { - // Extract track ID from item_id - let track_id = if let Some(id) = item_id.strip_prefix("qobuz://track/") { - id - } else if let Some(id) = item_id.strip_prefix("qobuz:track:") { - id - } else { - item_id - }; - - self.inner - .client - .add_to_playlist(playlist_id, track_id) - .await - .map_err(|e| MusicSourceError::PlaylistError(e.to_string()))?; - - self.increment_update_id().await; - Ok(()) - } - - async fn get_item_count(&self, object_id: &str) -> Result { - match self.parse_object_id(object_id) { - ObjectIdType::Album(album_id) => { - let album = self - .inner - .client - .get_album(&album_id) - .await - .map_err(|e| MusicSourceError::BrowseError(e.to_string()))?; - - Ok(album.tracks_count.unwrap_or(0) as usize) - } - ObjectIdType::Playlist(playlist_id) => { - let playlist = self - .inner - .client - .get_playlist(&playlist_id) - .await - .map_err(|e| MusicSourceError::BrowseError(e.to_string()))?; - - Ok(playlist.tracks_count.unwrap_or(0) as usize) - } - _ => { - // Fall back to default implementation - let result = self.browse(object_id).await?; - Ok(result.count()) - } - } - } - - async fn browse_paginated( - &self, - object_id: &str, - offset: usize, - limit: usize, - ) -> Result { - match self.parse_object_id(object_id) { - ObjectIdType::Album(album_id) => { - // Qobuz returns all tracks, so we slice them - let tracks = self - .inner - .client - .get_album_tracks(&album_id) - .await - .map_err(|e| MusicSourceError::BrowseError(e.to_string()))?; - - let items: Vec = tracks - .into_iter() - .skip(offset) - .take(limit) - .filter_map(|track| { - track - .to_didl_item(&format!("qobuz:album:{}", album_id)) - .ok() - }) - .collect(); - - Ok(BrowseResult::Items(items)) - } - ObjectIdType::Favorites => { - let albums = self - .inner - .client - .get_favorite_albums() - .await - .map_err(|e| MusicSourceError::BrowseError(e.to_string()))?; - - let containers: Vec = albums - .into_iter() - .skip(offset) - .take(limit) - .filter_map(|album| album.to_didl_container("qobuz:favorites").ok()) - .collect(); - - Ok(BrowseResult::Containers(containers)) - } - _ => { - // Fall back to default implementation - self.browse(object_id).await - } - } - } - - async fn statistics(&self) -> Result { - let mut stats = pmosource::SourceStatistics::default(); - - // Try to get favorite counts - if let Ok(albums) = self.inner.client.get_favorite_albums().await { - stats.total_containers = Some(albums.len()); - } - - if let Ok(tracks) = self.inner.client.get_favorite_tracks().await { - stats.total_items = Some(tracks.len()); - } - - // Get cache statistics from manager - let cache_stats = self.inner.cache_manager.statistics().await; - stats.cached_items = Some(cache_stats.cached_tracks); - - Ok(stats) - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_default_image_present() { - assert!(DEFAULT_IMAGE.len() > 0, "Default image should not be empty"); - - // Check WebP magic bytes (RIFF...WEBP) - assert!( - DEFAULT_IMAGE.len() >= 12, - "Image too small to be valid WebP" - ); - assert_eq!(&DEFAULT_IMAGE[0..4], b"RIFF", "Missing RIFF header"); - assert_eq!(&DEFAULT_IMAGE[8..12], b"WEBP", "Missing WEBP signature"); - } - - // Note: We can't easily test parse_object_id without creating a real client - // which requires authentication. The parsing logic is simple enough that - // it's covered by integration tests. -} -========= End of pmoqobuz/src/source.rs =========== - -=============== pmoqobuz/src/api_rest.rs ============ -//! Endpoints API REST pour Qobuz -//! -//! Ce module définit les handlers HTTP pour accéder aux fonctionnalités Qobuz. - -#[cfg(feature = "pmoserver")] -use axum::{ - extract::{Path, Query, State}, - http::StatusCode, - response::{IntoResponse, Response}, - Json, Router, -}; - -#[cfg(feature = "pmoserver")] -use serde::{Deserialize, Serialize}; - -#[cfg(feature = "pmoserver")] -use std::sync::Arc; - -#[cfg(feature = "pmoserver")] -use crate::{client::QobuzClient, error::QobuzError, models::*}; - -/// État partagé de l'application -#[cfg(feature = "pmoserver")] -#[derive(Clone)] -pub struct QobuzState { - pub client: Arc, - #[cfg(feature = "covers")] - pub cover_cache: Option>, -} - -/// Paramètres de recherche -#[cfg(feature = "pmoserver")] -#[derive(Debug, Deserialize)] -pub struct SearchParams { - /// Requête de recherche - pub q: String, - /// Type de recherche (albums, artists, tracks, playlists) - #[serde(rename = "type")] - pub search_type: Option, -} - -/// Paramètres pour featured albums -#[cfg(feature = "pmoserver")] -#[derive(Debug, Deserialize)] -pub struct FeaturedAlbumsParams { - /// ID du genre (optionnel) - pub genre_id: Option, - /// Type (new-releases, ideal-discography, etc.) - #[serde(rename = "type", default = "default_featured_type")] - pub type_: String, -} - -#[cfg(feature = "pmoserver")] -fn default_featured_type() -> String { - "new-releases".to_string() -} - -/// Paramètres pour featured playlists -#[cfg(feature = "pmoserver")] -#[derive(Debug, Deserialize)] -pub struct FeaturedPlaylistsParams { - /// ID du genre (optionnel) - pub genre_id: Option, - /// Tags (optionnel) - pub tags: Option, -} - -/// Crée le router Axum avec tous les endpoints Qobuz -#[cfg(feature = "pmoserver")] -pub fn create_router(state: QobuzState) -> Router { - Router::new() - // Albums - .route("/albums/:id", axum::routing::get(get_album)) - .route("/albums/:id/tracks", axum::routing::get(get_album_tracks)) - // Tracks - .route("/tracks/:id", axum::routing::get(get_track)) - .route("/tracks/:id/stream", axum::routing::get(get_stream_url)) - // Artists - .route("/artists/:id/albums", axum::routing::get(get_artist_albums)) - .route( - "/artists/:id/similar", - axum::routing::get(get_similar_artists), - ) - // Playlists - .route("/playlists/:id", axum::routing::get(get_playlist)) - .route( - "/playlists/:id/tracks", - axum::routing::get(get_playlist_tracks), - ) - // Recherche - .route("/search", axum::routing::get(search)) - // Favoris - .route("/favorites/albums", axum::routing::get(get_favorite_albums)) - .route( - "/favorites/artists", - axum::routing::get(get_favorite_artists), - ) - .route("/favorites/tracks", axum::routing::get(get_favorite_tracks)) - .route( - "/favorites/playlists", - axum::routing::get(get_user_playlists), - ) - // Catalogue - .route("/genres", axum::routing::get(get_genres)) - .route("/featured/albums", axum::routing::get(get_featured_albums)) - .route( - "/featured/playlists", - axum::routing::get(get_featured_playlists), - ) - // Cache - .route("/cache/stats", axum::routing::get(get_cache_stats)) - .with_state(state) -} - -// ============ Handlers ============ - -#[cfg(feature = "pmoserver")] -async fn get_album( - State(state): State, - Path(id): Path, -) -> Result, AppError> { - let mut album = state.client.get_album(&id).await?; - - #[cfg(feature = "covers")] - if let Some(ref cover_cache) = state.cover_cache { - album = cache_album_image(album, cover_cache).await; - } - - Ok(Json(album)) -} - -#[cfg(feature = "pmoserver")] -async fn get_album_tracks( - State(state): State, - Path(id): Path, -) -> Result>, AppError> { - let tracks = state.client.get_album_tracks(&id).await?; - Ok(Json(tracks)) -} - -#[cfg(feature = "pmoserver")] -async fn get_track( - State(state): State, - Path(id): Path, -) -> Result, AppError> { - let track = state.client.get_track(&id).await?; - Ok(Json(track)) -} - -#[cfg(feature = "pmoserver")] -async fn get_stream_url( - State(state): State, - Path(id): Path, -) -> Result, AppError> { - let url = state.client.get_stream_url(&id).await?; - Ok(Json(serde_json::json!({ "url": url }))) -} - -#[cfg(feature = "pmoserver")] -async fn get_artist_albums( - State(state): State, - Path(id): Path, -) -> Result>, AppError> { - let mut albums = state.client.get_artist_albums(&id).await?; - - #[cfg(feature = "covers")] - if let Some(ref cover_cache) = state.cover_cache { - albums = cache_albums_images(albums, cover_cache).await; - } - - Ok(Json(albums)) -} - -#[cfg(feature = "pmoserver")] -async fn get_similar_artists( - State(state): State, - Path(id): Path, -) -> Result>, AppError> { - let artists = state.client.get_similar_artists(&id).await?; - Ok(Json(artists)) -} - -#[cfg(feature = "pmoserver")] -async fn get_playlist( - State(state): State, - Path(id): Path, -) -> Result, AppError> { - let playlist = state.client.get_playlist(&id).await?; - Ok(Json(playlist)) -} - -#[cfg(feature = "pmoserver")] -async fn get_playlist_tracks( - State(state): State, - Path(id): Path, -) -> Result>, AppError> { - let tracks = state.client.get_playlist_tracks(&id).await?; - Ok(Json(tracks)) -} - -#[cfg(feature = "pmoserver")] -async fn search( - State(state): State, - Query(params): Query, -) -> Result, AppError> { - let mut result = state - .client - .search(¶ms.q, params.search_type.as_deref()) - .await?; - - #[cfg(feature = "covers")] - if let Some(ref cover_cache) = state.cover_cache { - result.albums = cache_albums_images(result.albums, cover_cache).await; - } - - Ok(Json(result)) -} - -#[cfg(feature = "pmoserver")] -async fn get_favorite_albums( - State(state): State, -) -> Result>, AppError> { - let mut albums = state.client.get_favorite_albums().await?; - - #[cfg(feature = "covers")] - if let Some(ref cover_cache) = state.cover_cache { - albums = cache_albums_images(albums, cover_cache).await; - } - - Ok(Json(albums)) -} - -#[cfg(feature = "pmoserver")] -async fn get_favorite_artists( - State(state): State, -) -> Result>, AppError> { - let artists = state.client.get_favorite_artists().await?; - Ok(Json(artists)) -} - -#[cfg(feature = "pmoserver")] -async fn get_favorite_tracks( - State(state): State, -) -> Result>, AppError> { - let tracks = state.client.get_favorite_tracks().await?; - Ok(Json(tracks)) -} - -#[cfg(feature = "pmoserver")] -async fn get_user_playlists( - State(state): State, -) -> Result>, AppError> { - let playlists = state.client.get_user_playlists().await?; - Ok(Json(playlists)) -} - -#[cfg(feature = "pmoserver")] -async fn get_genres(State(state): State) -> Result>, AppError> { - let genres = state.client.get_genres().await?; - Ok(Json(genres)) -} - -#[cfg(feature = "pmoserver")] -async fn get_featured_albums( - State(state): State, - Query(params): Query, -) -> Result>, AppError> { - let mut albums = state - .client - .get_featured_albums(params.genre_id.as_deref(), ¶ms.type_) - .await?; - - #[cfg(feature = "covers")] - if let Some(ref cover_cache) = state.cover_cache { - albums = cache_albums_images(albums, cover_cache).await; - } - - Ok(Json(albums)) -} - -#[cfg(feature = "pmoserver")] -async fn get_featured_playlists( - State(state): State, - Query(params): Query, -) -> Result>, AppError> { - let playlists = state - .client - .get_featured_playlists(params.genre_id.as_deref(), params.tags.as_deref()) - .await?; - Ok(Json(playlists)) -} - -#[cfg(feature = "pmoserver")] -async fn get_cache_stats( - State(state): State, -) -> Result, AppError> { - let stats = state.client.cache().stats().await; - Ok(Json(stats)) -} - -// ============ Helpers pour le cache d'images ============ - -#[cfg(all(feature = "pmoserver", feature = "covers"))] -async fn cache_album_image(mut album: Album, cover_cache: &Arc) -> Album { - if let Some(ref image_url) = album.image { - match cover_cache.add_from_url(image_url, None).await { - Ok(pk) => { - album.image_cached = Some(format!("/covers/images/{}", pk)); - } - Err(e) => { - tracing::warn!("Failed to cache album image: {}", e); - } - } - } - album -} - -#[cfg(all(feature = "pmoserver", feature = "covers"))] -async fn cache_albums_images( - albums: Vec, - cover_cache: &Arc, -) -> Vec { - let mut cached_albums = Vec::with_capacity(albums.len()); - for album in albums { - cached_albums.push(cache_album_image(album, cover_cache).await); - } - cached_albums -} - -// ============ Gestion des erreurs ============ - -#[cfg(feature = "pmoserver")] -struct AppError(QobuzError); - -#[cfg(feature = "pmoserver")] -impl IntoResponse for AppError { - fn into_response(self) -> Response { - let (status, message) = match self.0 { - QobuzError::Unauthorized(_) => (StatusCode::UNAUTHORIZED, self.0.to_string()), - QobuzError::NotFound(_) => (StatusCode::NOT_FOUND, self.0.to_string()), - QobuzError::RateLimitExceeded => (StatusCode::TOO_MANY_REQUESTS, self.0.to_string()), - _ => (StatusCode::INTERNAL_SERVER_ERROR, self.0.to_string()), - }; - - let body = Json(serde_json::json!({ - "error": message - })); - - (status, body).into_response() - } -} - -#[cfg(feature = "pmoserver")] -impl From for AppError -where - E: Into, -{ - fn from(err: E) -> Self { - Self(err.into()) - } -} -========= End of pmoqobuz/src/api_rest.rs =========== - -=============== pmoqobuz/src/pmoserver_impl.rs ============ -//! Implémentation du trait QobuzServerExt pour pmoserver::Server -//! -//! Ce module enrichit `pmoserver::Server` avec les fonctionnalités du client Qobuz en -//! implémentant le trait [`QobuzServerExt`](crate::QobuzServerExt). Cette implémentation -//! permet d'initialiser facilement le client Qobuz et d'enregistrer les routes HTTP. -//! -//! ## Architecture -//! -//! `pmoqobuz` étend `pmoserver::Server` sans que `pmoserver` connaisse `pmoqobuz`. -//! C'est le pattern d'extension : `pmoqobuz` ajoute des fonctionnalités à un type -//! externe via un trait, similaire au pattern utilisé par `pmocovers` pour `CoverCacheExt`. -//! -//! ## Exemple d'utilisation -//! -//! ```rust,no_run -//! use pmoqobuz::QobuzServerExt; -//! use pmoserver::ServerBuilder; -//! -//! # async fn example() -> anyhow::Result<()> { -//! let mut server = ServerBuilder::new_configured().build(); -//! -//! // Le trait QobuzServerExt est automatiquement disponible -//! let client = server.init_qobuz_client_configured().await?; -//! -//! server.start().await; -//! # Ok(()) -//! # } -//! ``` - -use crate::api_rest::{create_router, QobuzState}; -use crate::client::QobuzClient; -use crate::pmoserver_ext::QobuzServerExt; -use anyhow::Result; -use pmoconfig::Config; -use pmoserver::Server; -use std::sync::Arc; -use tracing::info; - -impl QobuzServerExt for Server { - async fn init_qobuz_client( - &mut self, - username: &str, - password: &str, - ) -> Result> { - info!("Initializing Qobuz client for user: {}", username); - - // Créer le client Qobuz - let client = QobuzClient::new(username, password).await?; - let client = Arc::new(client); - - // Créer l'état de l'API sans cache d'images - let state = QobuzState { - client: client.clone(), - #[cfg(feature = "covers")] - cover_cache: None, - }; - - // Créer le router et l'enregistrer - let router = create_router(state); - self.add_router("/qobuz", router).await; - - info!("Qobuz client initialized successfully"); - info!("API endpoints available at /qobuz/*"); - - Ok(client) - } - - async fn init_qobuz_client_configured(&mut self) -> Result> { - info!("Initializing Qobuz client from configuration"); - - // Récupérer les credentials depuis la config - let config = pmoconfig::get_config(); - let (username, password) = config.get_qobuz_credentials()?; - - self.init_qobuz_client(&username, &password).await - } - - #[cfg(feature = "covers")] - async fn init_qobuz_client_with_covers( - &mut self, - username: &str, - password: &str, - cover_cache: Arc, - ) -> Result> { - info!("Initializing Qobuz client with pmocovers integration"); - - // Créer le client Qobuz - let client = QobuzClient::new(username, password).await?; - let client = Arc::new(client); - - info!("pmocovers integration enabled - album images will be cached automatically"); - - // Créer l'état de l'API avec le cache - let state = QobuzState { - client: client.clone(), - cover_cache: Some(cover_cache), - }; - - // Créer le router et l'enregistrer - let router = create_router(state); - self.add_router("/qobuz", router).await; - - info!("Qobuz client initialized successfully with covers"); - info!("API endpoints available at /qobuz/*"); - - Ok(client) - } - - #[cfg(feature = "covers")] - async fn init_qobuz_client_configured_with_covers( - &mut self, - cover_cache: Arc, - ) -> Result> { - info!("Initializing Qobuz client from configuration with pmocovers"); - - // Récupérer les credentials depuis la config - let config = pmoconfig::get_config(); - let (username, password) = config.get_qobuz_credentials()?; - - self.init_qobuz_client_with_covers(&username, &password, cover_cache) - .await - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_trait_implemented() { - // Ce test vérifie simplement que le trait est bien implémenté - // Les tests fonctionnels nécessiteraient un serveur et des credentials réels - } -} -========= End of pmoqobuz/src/pmoserver_impl.rs =========== - -=============== pmoqobuz/src/api/auth.rs ============ -//! Module d'authentification pour l'API Qobuz - -use super::QobuzApi; -use crate::error::{QobuzError, Result}; -use serde::{Deserialize, Serialize}; -use tracing::{debug, info}; - -/// Réponse de l'endpoint /user/login -#[derive(Debug, Deserialize)] -struct LoginResponse { - user: UserInfo, - user_auth_token: String, -} - -/// Informations utilisateur retournées par l'API -#[derive(Debug, Deserialize)] -struct UserInfo { - id: u64, - #[serde(default)] - email: Option, - #[serde(default)] - firstname: Option, - #[serde(default)] - lastname: Option, - credential: CredentialInfo, -} - -/// Informations sur les credentials de l'utilisateur -#[derive(Debug, Deserialize)] -struct CredentialInfo { - #[serde(default)] - parameters: Option, -} - -/// Paramètres du niveau d'abonnement -#[derive(Debug, Deserialize)] -struct CredentialParameters { - #[serde(default)] - short_label: Option, -} - -/// Informations d'authentification -#[derive(Debug, Clone, Serialize, Deserialize)] -pub struct AuthInfo { - /// Token d'authentification - pub token: String, - /// ID utilisateur - pub user_id: String, - /// Label de l'abonnement (ex: "Studio", "Hi-Fi", etc.) - pub subscription_label: Option, -} - -impl QobuzApi { - /// Authentifie l'utilisateur avec username et password - /// - /// # Arguments - /// - /// * `username` - Email ou nom d'utilisateur Qobuz - /// * `password` - Mot de passe - /// - /// # Returns - /// - /// Retourne les informations d'authentification si le login est réussi - /// - /// # Errors - /// - /// * `QobuzError::Unauthorized` - Credentials invalides - /// * `QobuzError::SubscriptionRequired` - Compte gratuit (non éligible) - pub async fn login(&mut self, username: &str, password: &str) -> Result { - info!("Attempting to login to Qobuz as {}", username); - - let params = [("username", username), ("password", password)]; - - let response: LoginResponse = self.post("/user/login", ¶ms).await?; - - // Vérifier que l'utilisateur a un abonnement valide - if response.user.credential.parameters.is_none() { - return Err(QobuzError::SubscriptionRequired( - "Free accounts are not eligible for streaming".to_string(), - )); - } - - let user_id = response.user.id.to_string(); - let subscription_label = response - .user - .credential - .parameters - .and_then(|p| p.short_label); - - debug!( - "Login successful - User ID: {}, Subscription: {:?}", - user_id, subscription_label - ); - - // Stocker les informations d'authentification - self.set_auth_token(response.user_auth_token.clone(), user_id.clone()); - - Ok(AuthInfo { - token: response.user_auth_token, - user_id, - subscription_label, - }) - } - - /// Vérifie si le client est authentifié - pub fn is_authenticated(&self) -> bool { - self.user_auth_token.is_some() && self.user_id.is_some() - } - - /// Déconnecte l'utilisateur - pub fn logout(&mut self) { - debug!("Logging out"); - self.user_auth_token = None; - self.user_id = None; - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_is_authenticated() { - let mut api = QobuzApi::new("test_app_id").unwrap(); - assert!(!api.is_authenticated()); - - api.set_auth_token("token".to_string(), "user123".to_string()); - assert!(api.is_authenticated()); - - api.logout(); - assert!(!api.is_authenticated()); - } -} -========= End of pmoqobuz/src/api/auth.rs =========== - -=============== pmoqobuz/src/api/catalog.rs ============ -//! Module d'accès au catalogue Qobuz (albums, tracks, artistes, playlists) - -use super::QobuzApi; -use crate::error::Result; -use crate::models::*; -use serde::Deserialize; -use tracing::debug; - -/// Réponse paginée de l'API -#[derive(Debug, Deserialize)] -struct PaginatedResponse { - items: Vec, - #[serde(default)] - total: Option, - #[serde(default)] - limit: Option, - #[serde(default)] - offset: Option, -} - -/// Réponse de l'endpoint /album/get -#[derive(Debug, Deserialize)] -pub(crate) struct AlbumResponse { - id: String, - title: String, - artist: ArtistResponse, - #[serde(default)] - tracks_count: Option, - #[serde(default)] - duration: Option, - #[serde(default)] - release_date_original: Option, - #[serde(default)] - image: Option, - #[serde(default = "default_streamable")] - streamable: bool, - #[serde(default)] - description: Option, - #[serde(default)] - maximum_sampling_rate: Option, - #[serde(default)] - maximum_bit_depth: Option, - #[serde(default)] - genre: Option, - #[serde(default)] - label: Option, - #[serde(default)] - tracks: Option>, -} - -/// Réponse de l'endpoint /track/get -#[derive(Debug, Deserialize)] -pub(crate) struct TrackResponse { - id: String, - title: String, - #[serde(default)] - performer: Option, - #[serde(default)] - artist: Option, - #[serde(default)] - album: Option, - duration: u32, - track_number: u32, - media_number: u32, - #[serde(default = "default_streamable")] - streamable: bool, -} - -/// Réponse artiste -#[derive(Debug, Deserialize)] -pub(crate) struct ArtistResponse { - id: u64, - name: String, - #[serde(default)] - image: Option, - #[serde(default)] - albums: Option>, -} - -/// Réponse image -#[derive(Debug, Deserialize)] -struct ImageResponse { - #[serde(default)] - large: Option, -} - -/// Réponse genre -#[derive(Debug, Deserialize)] -struct GenreResponse { - #[serde(default)] - id: Option, - name: String, -} - -/// Réponse label -#[derive(Debug, Deserialize)] -struct LabelResponse { - name: String, -} - -/// Réponse playlist -#[derive(Debug, Deserialize)] -pub(crate) struct PlaylistResponse { - id: u64, - name: String, - #[serde(default)] - description: Option, - #[serde(default)] - tracks_count: Option, - #[serde(default)] - duration: Option, - #[serde(default)] - images300: Option>, - #[serde(default)] - is_public: bool, - #[serde(default)] - owner: Option, - #[serde(default)] - tracks: Option>, -} - -/// Réponse propriétaire -#[derive(Debug, Deserialize)] -struct OwnerResponse { - id: u64, - name: String, -} - -/// Réponse genres list -#[derive(Debug, Deserialize)] -struct GenresResponse { - genres: PaginatedResponse, -} - -/// Réponse albums featured -#[derive(Debug, Deserialize)] -struct FeaturedAlbumsResponse { - albums: PaginatedResponse, -} - -/// Réponse playlists featured -#[derive(Debug, Deserialize)] -struct FeaturedPlaylistsResponse { - playlists: PaginatedResponse, -} - -/// Réponse search -#[derive(Debug, Deserialize)] -struct SearchResponse { - #[serde(default)] - albums: Option>, - #[serde(default)] - artists: Option>, - #[serde(default)] - tracks: Option>, - #[serde(default)] - playlists: Option>, -} - -/// Réponse track file URL -#[derive(Debug, Deserialize)] -struct FileUrlResponse { - url: String, - mime_type: String, - sampling_rate: u32, - bit_depth: u32, - format_id: u8, -} - -fn default_streamable() -> bool { - true -} - -impl QobuzApi { - /// Récupère les détails d'un album - pub async fn get_album(&self, album_id: &str) -> Result { - debug!("Fetching album {}", album_id); - let params = [("album_id", album_id)]; - let response: AlbumResponse = self.get("/album/get", ¶ms).await?; - Ok(Self::parse_album(response)) - } - - /// Récupère les tracks d'un album - pub async fn get_album_tracks(&self, album_id: &str) -> Result> { - debug!("Fetching tracks for album {}", album_id); - let params = [("album_id", album_id)]; - let mut response: AlbumResponse = self.get("/album/get", ¶ms).await?; - - if let Some(tracks) = response.tracks.take() { - let album = Self::parse_album(response); - Ok(tracks - .items - .into_iter() - .map(|t| Self::parse_track(t, Some(album.clone()))) - .collect()) - } else { - Ok(Vec::new()) - } - } - - /// Récupère les détails d'une track - pub async fn get_track(&self, track_id: &str) -> Result { - debug!("Fetching track {}", track_id); - let params = [("track_id", track_id)]; - let response: TrackResponse = self.get("/track/get", ¶ms).await?; - Ok(Self::parse_track(response, None)) - } - - /// Récupère l'URL de streaming d'une track - pub async fn get_file_url(&self, track_id: &str) -> Result { - debug!("Fetching file URL for track {}", track_id); - let format_id = self.format_id.id().to_string(); - let params = [ - ("track_id", track_id), - ("format_id", &format_id), - ("intent", "stream"), - ]; - let response: FileUrlResponse = self.get("/track/getFileUrl", ¶ms).await?; - - Ok(StreamInfo { - url: response.url, - mime_type: response.mime_type, - sampling_rate: response.sampling_rate, - bit_depth: response.bit_depth, - format_id: response.format_id, - expires_at: chrono::Utc::now() + chrono::Duration::minutes(5), - }) - } - - /// Récupère les albums d'un artiste - pub async fn get_artist_albums(&self, artist_id: &str) -> Result> { - debug!("Fetching albums for artist {}", artist_id); - let params = [("artist_id", artist_id), ("extra", "albums")]; - let response: ArtistResponse = self.get("/artist/get", ¶ms).await?; - - if let Some(albums) = response.albums { - Ok(albums - .items - .into_iter() - .map(Self::parse_album) - .filter(|a| a.streamable) - .collect()) - } else { - Ok(Vec::new()) - } - } - - /// Récupère les artistes similaires - pub async fn get_similar_artists(&self, artist_id: &str) -> Result> { - debug!("Fetching similar artists for {}", artist_id); - let params = [("artist_id", artist_id)]; - - #[derive(Debug, Deserialize)] - struct SimilarArtistsResponse { - artists: PaginatedResponse, - } - - let response: SimilarArtistsResponse = - self.get("/artist/getSimilarArtists", ¶ms).await?; - Ok(response - .artists - .items - .into_iter() - .map(Self::parse_artist) - .collect()) - } - - /// Récupère les détails d'une playlist - pub async fn get_playlist(&self, playlist_id: &str) -> Result { - debug!("Fetching playlist {}", playlist_id); - let params = [("playlist_id", playlist_id)]; - let response: PlaylistResponse = self.get("/playlist/get", ¶ms).await?; - Ok(Self::parse_playlist(response)) - } - - /// Récupère les tracks d'une playlist - pub async fn get_playlist_tracks(&self, playlist_id: &str) -> Result> { - debug!("Fetching tracks for playlist {}", playlist_id); - let params = [("playlist_id", playlist_id), ("extra", "tracks")]; - let response: PlaylistResponse = self.get("/playlist/get", ¶ms).await?; - - if let Some(tracks) = response.tracks { - Ok(tracks - .items - .into_iter() - .map(|t| Self::parse_track(t, None)) - .collect()) - } else { - Ok(Vec::new()) - } - } - - /// Récupère la liste des genres - pub async fn get_genres(&self) -> Result> { - debug!("Fetching genres"); - let response: GenresResponse = self.get("/genre/list", &[]).await?; - Ok(response - .genres - .items - .into_iter() - .map(Self::parse_genre) - .collect()) - } - - /// Récupère les albums featured (nouveautés, éditeur, etc.) - pub async fn get_featured_albums( - &self, - genre_id: Option<&str>, - type_: &str, - ) -> Result> { - debug!("Fetching featured albums (type: {})", type_); - let mut params = vec![("type", type_), ("limit", "100")]; - - if let Some(gid) = genre_id { - params.push(("genre_ids", gid)); - } - - let response: FeaturedAlbumsResponse = self.get("/album/getFeatured", ¶ms).await?; - Ok(response - .albums - .items - .into_iter() - .map(Self::parse_album) - .filter(|a| a.streamable) - .collect()) - } - - /// Récupère les playlists featured - pub async fn get_featured_playlists( - &self, - genre_id: Option<&str>, - tags: Option<&str>, - ) -> Result> { - debug!("Fetching featured playlists"); - let mut params = vec![("type", "editor-picks"), ("limit", "100")]; - - if let Some(gid) = genre_id { - params.push(("genre_ids", gid)); - } - if let Some(t) = tags { - params.push(("tags", t)); - } - - let response: FeaturedPlaylistsResponse = - self.get("/playlist/getFeatured", ¶ms).await?; - Ok(response - .playlists - .items - .into_iter() - .map(Self::parse_playlist) - .collect()) - } - - /// Recherche dans le catalogue - pub async fn search(&self, query: &str, type_: Option<&str>) -> Result { - debug!("Searching for '{}' (type: {:?})", query, type_); - let mut params = vec![("query", query), ("limit", "200")]; - - if let Some(t) = type_ { - params.push(("type", t)); - } - - let response: SearchResponse = self.get("/catalog/search", ¶ms).await?; - - Ok(SearchResult { - albums: response - .albums - .map(|a| { - a.items - .into_iter() - .map(Self::parse_album) - .filter(|album| album.streamable) - .collect() - }) - .unwrap_or_default(), - artists: response - .artists - .map(|a| a.items.into_iter().map(Self::parse_artist).collect()) - .unwrap_or_default(), - tracks: response - .tracks - .map(|t| { - t.items - .into_iter() - .map(|track| Self::parse_track(track, None)) - .filter(|track| track.streamable) - .collect() - }) - .unwrap_or_default(), - playlists: response - .playlists - .map(|p| p.items.into_iter().map(Self::parse_playlist).collect()) - .unwrap_or_default(), - }) - } - - // Fonctions de parsing publiques (utilisées aussi par le module user) - - pub(crate) fn parse_album(response: AlbumResponse) -> Album { - Album { - id: response.id, - title: response.title, - artist: Self::parse_artist(response.artist), - tracks_count: response.tracks_count, - duration: response.duration, - release_date: response.release_date_original, - image: response.image.and_then(|i| i.large), - image_cached: None, - streamable: response.streamable, - description: response.description, - maximum_sampling_rate: response.maximum_sampling_rate, - maximum_bit_depth: response.maximum_bit_depth, - genres: response.genre.map(|g| vec![g.name]).unwrap_or_default(), - label: response.label.map(|l| l.name), - } - } - - pub(crate) fn parse_track(response: TrackResponse, album: Option) -> Track { - let performer = response - .performer - .or(response.artist) - .map(Self::parse_artist); - - let album = album.or_else(|| response.album.map(Self::parse_album)); - - Track { - id: response.id, - title: response.title, - performer, - album, - duration: response.duration, - track_number: response.track_number, - media_number: response.media_number, - streamable: response.streamable, - mime_type: None, - sample_rate: None, - bit_depth: None, - channels: None, - } - } - - pub(crate) fn parse_artist(response: ArtistResponse) -> Artist { - Artist { - id: response.id.to_string(), - name: response.name, - image: response.image.and_then(|i| i.large), - image_cached: None, - } - } - - pub(crate) fn parse_playlist(response: PlaylistResponse) -> Playlist { - Playlist { - id: response.id.to_string(), - name: response.name, - description: response.description, - tracks_count: response.tracks_count, - duration: response.duration, - image: response.images300.and_then(|imgs| imgs.first().cloned()), - image_cached: None, - is_public: response.is_public, - owner: response.owner.map(|o| PlaylistOwner { - id: o.id, - name: o.name, - }), - } - } - - pub(crate) fn parse_genre(response: GenreResponse) -> Genre { - Genre { - id: response.id, - name: response.name, - children: Vec::new(), - } - } -} -========= End of pmoqobuz/src/api/catalog.rs =========== - -=============== pmoqobuz/src/api/user.rs ============ -//! Module d'accès aux données utilisateur (favoris) - -use super::catalog::{AlbumResponse, ArtistResponse, PlaylistResponse, TrackResponse}; -use super::QobuzApi; -use crate::error::{QobuzError, Result}; -use crate::models::*; -use serde::Deserialize; -use tracing::debug; - -/// Réponse paginée -#[derive(Debug, Deserialize)] -struct PaginatedResponse { - items: Vec, -} - -/// Réponse de l'endpoint /favorite/getUserFavorites -#[derive(Debug, Deserialize)] -struct FavoritesResponse { - #[serde(default)] - albums: Option>, - #[serde(default)] - artists: Option>, - #[serde(default)] - tracks: Option>, -} - -/// Réponse de l'endpoint /playlist/getUserPlaylists -#[derive(Debug, Deserialize)] -struct UserPlaylistsResponse { - playlists: PaginatedResponse, -} - -impl QobuzApi { - /// Vérifie que l'utilisateur est authentifié - fn ensure_authenticated(&self) -> Result<&str> { - self.user_id - .as_deref() - .ok_or_else(|| QobuzError::Unauthorized("Not authenticated".to_string())) - } - - /// Récupère les albums favoris de l'utilisateur - pub async fn get_favorite_albums(&self) -> Result> { - let user_id = self.ensure_authenticated()?; - debug!("Fetching favorite albums for user {}", user_id); - - let params = [("user_id", user_id), ("type", "albums"), ("limit", "1000")]; - - let response: FavoritesResponse = self.get("/favorite/getUserFavorites", ¶ms).await?; - - if let Some(albums) = response.albums { - Ok(albums - .items - .into_iter() - .map(QobuzApi::parse_album) - .filter(|a| a.streamable) - .collect()) - } else { - Ok(Vec::new()) - } - } - - /// Récupère les artistes favoris de l'utilisateur - pub async fn get_favorite_artists(&self) -> Result> { - let user_id = self.ensure_authenticated()?; - debug!("Fetching favorite artists for user {}", user_id); - - let params = [("user_id", user_id), ("type", "artists"), ("limit", "1000")]; - - let response: FavoritesResponse = self.get("/favorite/getUserFavorites", ¶ms).await?; - - if let Some(artists) = response.artists { - Ok(artists - .items - .into_iter() - .map(QobuzApi::parse_artist) - .collect()) - } else { - Ok(Vec::new()) - } - } - - /// Récupère les tracks favorites de l'utilisateur - pub async fn get_favorite_tracks(&self) -> Result> { - let user_id = self.ensure_authenticated()?; - debug!("Fetching favorite tracks for user {}", user_id); - - let params = [("user_id", user_id), ("type", "tracks"), ("limit", "1000")]; - - let response: FavoritesResponse = self.get("/favorite/getUserFavorites", ¶ms).await?; - - if let Some(tracks) = response.tracks { - Ok(tracks - .items - .into_iter() - .map(|t| QobuzApi::parse_track(t, None)) - .filter(|t| t.streamable) - .collect()) - } else { - Ok(Vec::new()) - } - } - - /// Récupère les playlists de l'utilisateur - pub async fn get_user_playlists(&self) -> Result> { - let user_id = self.ensure_authenticated()?; - debug!("Fetching playlists for user {}", user_id); - - let params = [("user_id", user_id), ("limit", "1000")]; - - let response: UserPlaylistsResponse = - self.get("/playlist/getUserPlaylists", ¶ms).await?; - - Ok(response - .playlists - .items - .into_iter() - .map(QobuzApi::parse_playlist) - .collect()) - } - - /// Ajoute un album aux favoris - pub async fn add_favorite_album(&self, album_id: &str) -> Result<()> { - let user_id = self.ensure_authenticated()?; - debug!( - "Adding album {} to favorites for user {}", - album_id, user_id - ); - - let params = [("album_id", album_id), ("user_id", user_id)]; - - self.get::("/favorite/create", ¶ms) - .await?; - Ok(()) - } - - /// Supprime un album des favoris - pub async fn remove_favorite_album(&self, album_id: &str) -> Result<()> { - let user_id = self.ensure_authenticated()?; - debug!( - "Removing album {} from favorites for user {}", - album_id, user_id - ); - - let params = [("album_ids", album_id), ("user_id", user_id)]; - - self.get::("/favorite/delete", ¶ms) - .await?; - Ok(()) - } - - /// Ajoute un track aux favoris - pub async fn add_favorite_track(&self, track_id: &str) -> Result<()> { - let user_id = self.ensure_authenticated()?; - debug!( - "Adding track {} to favorites for user {}", - track_id, user_id - ); - - let params = [("track_id", track_id), ("user_id", user_id)]; - - self.get::("/favorite/create", ¶ms) - .await?; - Ok(()) - } - - /// Supprime un track des favoris - pub async fn remove_favorite_track(&self, track_id: &str) -> Result<()> { - let user_id = self.ensure_authenticated()?; - debug!( - "Removing track {} from favorites for user {}", - track_id, user_id - ); - - let params = [("track_ids", track_id), ("user_id", user_id)]; - - self.get::("/favorite/delete", ¶ms) - .await?; - Ok(()) - } - - /// Ajoute un track à une playlist - pub async fn add_to_playlist(&self, playlist_id: &str, track_id: &str) -> Result<()> { - let user_id = self.ensure_authenticated()?; - debug!( - "Adding track {} to playlist {} for user {}", - track_id, playlist_id, user_id - ); - - let params = [("playlist_id", playlist_id), ("track_ids", track_id)]; - - self.get::("/playlist/addTracks", ¶ms) - .await?; - Ok(()) - } -} -========= End of pmoqobuz/src/api/user.rs =========== - -=============== pmoqobuz/src/api/mod.rs ============ -//! Couche d'accès à l'API REST Qobuz -//! -//! Ce module fournit une interface bas-niveau pour communiquer avec l'API Qobuz. - -pub mod auth; -pub mod catalog; -pub mod user; - -use crate::error::{QobuzError, Result}; -use crate::models::AudioFormat; -use reqwest::{Client, Response}; -use serde::de::DeserializeOwned; -use serde_json::Value; -use std::time::Duration; -use tracing::{debug, warn}; - -/// URL de base de l'API Qobuz -const API_BASE_URL: &str = "https://www.qobuz.com/api.json/0.2"; - -/// Client API bas-niveau pour communiquer avec Qobuz -pub struct QobuzApi { - /// Client HTTP - client: Client, - /// App ID pour l'authentification - app_id: String, - /// Token d'authentification utilisateur - user_auth_token: Option, - /// ID utilisateur - user_id: Option, - /// Format audio par défaut - format_id: AudioFormat, -} - -impl QobuzApi { - /// Crée une nouvelle instance de l'API - pub fn new(app_id: impl Into) -> Result { - let client = Client::builder() - .timeout(Duration::from_secs(30)) - .user_agent( - "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:67.0) Gecko/20100101 Firefox/67.0", - ) - .build()?; - - Ok(Self { - client, - app_id: app_id.into(), - user_auth_token: None, - user_id: None, - format_id: AudioFormat::default(), - }) - } - - /// Définit le token d'authentification - pub fn set_auth_token(&mut self, token: String, user_id: String) { - self.user_auth_token = Some(token); - self.user_id = Some(user_id); - } - - /// Définit le format audio par défaut - pub fn set_format(&mut self, format: AudioFormat) { - self.format_id = format; - } - - /// Retourne le format audio configuré - pub fn format(&self) -> AudioFormat { - self.format_id - } - - /// Retourne l'App ID - pub fn app_id(&self) -> &str { - &self.app_id - } - - /// Retourne le token d'authentification si disponible - pub fn auth_token(&self) -> Option<&str> { - self.user_auth_token.as_deref() - } - - /// Retourne l'ID utilisateur si disponible - pub fn user_id(&self) -> Option<&str> { - self.user_id.as_deref() - } - - /// Effectue une requête GET à l'API - pub(crate) async fn get( - &self, - endpoint: &str, - params: &[(&str, &str)], - ) -> Result { - self.request("GET", endpoint, params).await - } - - /// Effectue une requête POST à l'API - pub(crate) async fn post( - &self, - endpoint: &str, - params: &[(&str, &str)], - ) -> Result { - self.request("POST", endpoint, params).await - } - - /// Effectue une requête à l'API (générique) - async fn request( - &self, - method: &str, - endpoint: &str, - params: &[(&str, &str)], - ) -> Result { - let url = format!("{}{}", API_BASE_URL, endpoint); - - debug!("{} {} with {} params", method, url, params.len()); - - let mut request = if method == "GET" { - self.client.get(&url) - } else { - self.client.post(&url) - }; - - // Ajouter les headers - request = request.header("X-App-Id", &self.app_id); - - if let Some(ref token) = self.user_auth_token { - request = request.header("X-User-Auth-Token", token); - } - - // Ajouter les paramètres - if method == "GET" { - request = request.query(params); - } else { - request = request.form(params); - } - - // Envoyer la requête - let response = request.send().await?; - self.handle_response(response).await - } - - /// Traite la réponse HTTP - async fn handle_response(&self, response: Response) -> Result { - let status = response.status(); - let status_code = status.as_u16(); - - debug!("Response status: {}", status); - - if !status.is_success() { - let error_text = response.text().await.unwrap_or_default(); - warn!("API error ({}): {}", status_code, error_text); - return Err(QobuzError::from_status_code(status_code, error_text)); - } - - let text = response.text().await?; - - // Vérifier si la réponse contient une erreur Qobuz - if let Ok(json) = serde_json::from_str::(&text) { - if let Some(status_obj) = json.get("status") { - if status_obj == "error" { - let message = json - .get("message") - .and_then(|m| m.as_str()) - .unwrap_or("Unknown error"); - warn!("Qobuz API error: {}", message); - return Err(QobuzError::ApiError { - code: status_code, - message: message.to_string(), - }); - } - } - } - - // Parser la réponse - serde_json::from_str(&text).map_err(|e| { - warn!("Failed to parse response: {}", e); - QobuzError::JsonParse(e) - }) - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_api_creation() { - let api = QobuzApi::new("test_app_id").unwrap(); - assert_eq!(api.app_id(), "test_app_id"); - assert!(api.auth_token().is_none()); - } - - #[test] - fn test_set_auth_token() { - let mut api = QobuzApi::new("test_app_id").unwrap(); - api.set_auth_token("test_token".to_string(), "user123".to_string()); - assert_eq!(api.auth_token(), Some("test_token")); - assert_eq!(api.user_id(), Some("user123")); - } - - #[test] - fn test_set_format() { - let mut api = QobuzApi::new("test_app_id").unwrap(); - api.set_format(AudioFormat::Flac_HiRes_96); - assert_eq!(api.format(), AudioFormat::Flac_HiRes_96); - } -} -========= End of pmoqobuz/src/api/mod.rs =========== - -=============== pmoqobuz/src/pmoserver_ext.rs ============ -//! Extension de pmoserver::Server pour intégrer le client Qobuz -//! -//! Ce module fournit un trait d'extension permettant d'ajouter facilement -//! le client Qobuz et ses endpoints à un serveur pmoserver. - -use crate::client::QobuzClient; -use anyhow::Result; -use std::sync::Arc; - -/// Trait d'extension pour ajouter le support Qobuz à un serveur pmoserver -/// -/// Ce trait permet à `pmoqobuz` d'ajouter des méthodes d'extension sur -/// `pmoserver::Server` sans que pmoserver dépende de pmoqobuz. -/// -/// # Architecture -/// -/// Similaire au pattern utilisé par `pmocovers` avec `CoverCacheExt`, ce trait permet -/// une extension propre et découplée : -/// -/// - `pmoserver` définit un serveur HTTP générique -/// - `pmoqobuz` étend ce serveur avec des fonctionnalités Qobuz via ce trait -/// - Le serveur n'a pas besoin de connaître `pmoqobuz` -/// -/// # Exemple -/// -/// ```rust,no_run -/// use pmoqobuz::QobuzServerExt; -/// use pmoserver::ServerBuilder; -/// -/// #[tokio::main] -/// async fn main() -> anyhow::Result<()> { -/// let mut server = ServerBuilder::new_configured().build(); -/// -/// // Initialise le client Qobuz depuis la config -/// server.init_qobuz_client_configured().await?; -/// -/// server.start().await; -/// server.wait().await; -/// Ok(()) -/// } -/// ``` -pub trait QobuzServerExt { - /// Initialise le client Qobuz et enregistre les routes HTTP - /// - /// # Arguments - /// - /// * `username` - Email ou nom d'utilisateur Qobuz - /// * `password` - Mot de passe - /// - /// # Returns - /// - /// * `Arc` - Instance partagée du client - /// - /// # Routes enregistrées - /// - /// - `GET /qobuz/albums/{id}` - Détails d'un album - /// - `GET /qobuz/albums/{id}/tracks` - Tracks d'un album - /// - `GET /qobuz/tracks/{id}` - Détails d'une track - /// - `GET /qobuz/tracks/{id}/stream` - URL de streaming - /// - `GET /qobuz/artists/{id}` - Détails d'un artiste - /// - `GET /qobuz/artists/{id}/albums` - Albums d'un artiste - /// - `GET /qobuz/playlists/{id}` - Détails d'une playlist - /// - `GET /qobuz/playlists/{id}/tracks` - Tracks d'une playlist - /// - `GET /qobuz/search` - Recherche (query params: q, type) - /// - `GET /qobuz/favorites/albums` - Albums favoris - /// - `GET /qobuz/favorites/artists` - Artistes favoris - /// - `GET /qobuz/favorites/tracks` - Tracks favoris - /// - `GET /qobuz/favorites/playlists` - Playlists utilisateur - /// - `GET /qobuz/genres` - Liste des genres - /// - `GET /qobuz/featured/albums` - Albums featured - /// - `GET /qobuz/featured/playlists` - Playlists featured - /// - `GET /qobuz/cache/stats` - Statistiques du cache - /// - `GET /swagger-ui` - Documentation interactive - async fn init_qobuz_client( - &mut self, - username: &str, - password: &str, - ) -> Result>; - - /// Initialise le client Qobuz avec la configuration par défaut - /// - /// Utilise automatiquement les credentials de `pmoconfig::Config` : - /// - `accounts.qobuz.username` pour le nom d'utilisateur - /// - `accounts.qobuz.password` pour le mot de passe - /// - /// # Returns - /// - /// * `Arc` - Instance partagée du client - /// - /// # Exemple - /// - /// ```rust,no_run - /// use pmoqobuz::QobuzServerExt; - /// use pmoserver::ServerBuilder; - /// - /// #[tokio::main] - /// async fn main() -> anyhow::Result<()> { - /// let mut server = ServerBuilder::new_configured().build(); - /// - /// // Utilise automatiquement la config - /// server.init_qobuz_client_configured().await?; - /// - /// server.start().await; - /// Ok(()) - /// } - /// ``` - async fn init_qobuz_client_configured(&mut self) -> Result>; - - /// Initialise le client Qobuz avec intégration pmocovers - /// - /// Les images d'albums seront automatiquement ajoutées au cache pmocovers fourni. - /// - /// # Arguments - /// - /// * `username` - Email ou nom d'utilisateur Qobuz - /// * `password` - Mot de passe - /// * `cover_cache` - Instance du cache pmocovers à utiliser - /// - /// # Returns - /// - /// * `Arc` - Instance partagée du client avec cache d'images - /// - /// # Exemple - /// - /// ```rust,no_run - /// use pmoqobuz::QobuzServerExt; - /// use pmocovers::CoverCacheExt; - /// use pmoserver::ServerBuilder; - /// - /// #[tokio::main] - /// async fn main() -> anyhow::Result<()> { - /// let mut server = ServerBuilder::new_configured().build(); - /// - /// // D'abord initialiser le cache d'images - /// let cache = server.init_cover_cache_configured().await?; - /// - /// // Puis initialiser Qobuz avec le cache - /// server.init_qobuz_client_with_covers("user", "pass", cache).await?; - /// - /// server.start().await; - /// Ok(()) - /// } - /// ``` - #[cfg(feature = "covers")] - async fn init_qobuz_client_with_covers( - &mut self, - username: &str, - password: &str, - cover_cache: Arc, - ) -> Result>; - - /// Initialise le client Qobuz avec intégration pmocovers depuis la configuration - /// - /// # Arguments - /// - /// * `cover_cache` - Instance du cache pmocovers à utiliser - /// - /// # Exemple - /// - /// ```rust,no_run - /// use pmoqobuz::QobuzServerExt; - /// use pmocovers::CoverCacheExt; - /// use pmoserver::ServerBuilder; - /// - /// #[tokio::main] - /// async fn main() -> anyhow::Result<()> { - /// let mut server = ServerBuilder::new_configured().build(); - /// - /// // D'abord initialiser le cache - /// let cache = server.init_cover_cache_configured().await?; - /// - /// // Puis initialiser Qobuz avec le cache - /// server.init_qobuz_client_configured_with_covers(cache).await?; - /// - /// server.start().await; - /// Ok(()) - /// } - /// ``` - #[cfg(feature = "covers")] - async fn init_qobuz_client_configured_with_covers( - &mut self, - cover_cache: Arc, - ) -> Result>; -} - -// L'implémentation du trait sera dans un module séparé (pmoserver_impl.rs) -// pour éviter les dépendances circulaires -========= End of pmoqobuz/src/pmoserver_ext.rs =========== - diff --git a/pmoqobuz_027.txt b/pmoqobuz_027.txt deleted file mode 100644 index a29393e1..00000000 --- a/pmoqobuz_027.txt +++ /dev/null @@ -1,8488 +0,0 @@ -=============== pmoqobuz/Cargo.toml ============ -[package] -name = "pmoqobuz" -version = "0.1.0" -edition = "2021" - -[dependencies] -regex = "1.12" -base64 = "0.22" -indexmap = "2.0" - -# HTTP client pour les requêtes à l'API Qobuz -reqwest = { version = "0.12", features = ["json", "cookies"] } - -# Gestion asynchrone -tokio = { version = "1", features = ["full"] } - -# Sérialisation/Désérialisation JSON -serde = { version = "1.0", features = ["derive"] } -serde_json = "1.0" -serde_yaml = "0.9" - -# Gestion des erreurs -anyhow = "1.0" -thiserror = "1.0" - -# Hashing pour les clés de cache et signatures -sha1 = "0.10" -hex = "0.4" -md-5 = "0.10" - -# Cache en mémoire avec TTL -moka = { version = "0.12", features = ["future"] } - -# Logging -tracing = "0.1" - -# Gestion du temps -chrono = { version = "0.4", features = ["serde"] } - -# Configuration -pmoconfig = { path = "../pmoconfig" } - -# Intégration avec pmocovers pour le cache d'images (OBLIGATOIRE) -pmocovers = { path = "../pmocovers" } - -# Intégration avec pmoaudiocache pour le cache audio (OBLIGATOIRE) -pmoaudiocache = { path = "../pmoaudiocache" } - -# Intégration avec pmodidl pour l'export DIDL -pmodidl = { path = "../pmodidl" } - -# Intégration avec pmoserver pour l'API HTTP -pmoserver = { path = "../pmoserver", optional = true } -axum = { version = "0.8", optional = true } - -# Documentation OpenAPI -utoipa = { version = "5.3", optional = true } - -# Common music source traits -pmosource = { path = "../pmosource" } - -# Playlist management -pmoplaylist = { path = "../pmoplaylist" } - -[features] -default = [] -# Feature pour activer les extensions pmoserver -pmoserver = ["dep:pmoserver", "dep:axum", "dep:utoipa"] -# Feature pour activer le support serveur (cache registry) -server = ["pmosource/server"] -# Feature cache (deprecated - toujours actif maintenant) -cache = [] - -[dev-dependencies] -# Tests -tokio-test = "0.4" -mockito = "1.0" -tempfile = "3.0" -# Pour les exemples -tracing-subscriber = "0.3" -pmocache = { path = "../pmocache" } -# Pour l'exemple spoofer - -# Specify that the with_cache example requires the cache feature -[[example]] -name = "with_cache" -required-features = ["cache"] -========= End of pmoqobuz/Cargo.toml =========== - -=============== pmoqobuz/IMPLEMENTATION_STATUS.md ============ -# Statut d'implémentation de l'API Qobuz - -**Date** : 2025-12-10 -**Statut** : ✅ **PRODUCTION READY avec Spoofer intégré** - -## Résumé - -L'implémentation Rust de `pmoqobuz` suit maintenant fidèlement l'API de référence Python (`qobuz.api.raw`) pour toutes les fonctionnalités critiques. Le Spoofer est désormais intégré automatiquement dans le client pour obtenir dynamiquement des AppID et secrets valides. - -## ✅ Problèmes corrigés - -### 1. ✅ Gestion du secret `s4` - -**État** : **TERMINÉ** - -- **Fichier** : [pmoqobuz/src/api/mod.rs](src/api/mod.rs) -- **Ajouts** : - - Champ `secret: Option>` dans `QobuzApi` - - `with_secret()` - Crée une API avec appID + configvalue (base64) - - `set_secret()` - Définit le secret directement - - `set_secret_from_configvalue()` - Décodage base64 + XOR avec appID - - `secret()` - Getter pour le secret - -### 2. ✅ Signature MD5 des requêtes - -**État** : **TERMINÉ** - -- **Fichier** : [pmoqobuz/src/api/signing.rs](src/api/signing.rs) (nouveau) -- **Fonctions implémentées** : - - `get_timestamp()` - Génère timestamp Unix - - `sign_track_get_file_url()` - Signature pour `track/getFileUrl` - - `sign_userlib_get_albums()` - Signature pour `userLibrary/getAlbumsList` -- **Tests unitaires** : ✅ Tous passants - -### 3. ✅ Méthode `get_file_url` avec signature - -**État** : **TERMINÉ** - -- **Fichier** : [pmoqobuz/src/api/catalog.rs](src/api/catalog.rs:217-269) -- **Modifications** : - - Vérification du secret avant la requête - - Génération du timestamp - - Signature MD5 de la requête - - Ajout de `request_ts` et `request_sig` aux paramètres -- **Comportement** : Retourne `QobuzError::Configuration` si le secret n'est pas configuré - -### 4. ✅ Méthode `userlib_getAlbums` - -**État** : **TERMINÉ** - -- **Fichier** : [pmoqobuz/src/api/user.rs](src/api/user.rs:196-249) -- **Fonctionnalités** : - - Signature MD5 avec le secret - - Utilisée pour tester la validité des secrets - - Requête POST vers `/userLibrary/getAlbumsList` - -### 5. ✅ Configuration AppID et Secret - -**État** : **TERMINÉ** - -- **Fichier** : [pmoqobuz/src/config_ext.rs](src/config_ext.rs) -- **Méthodes ajoutées** : - - `get_qobuz_appid()` / `set_qobuz_appid()` - - `get_qobuz_secret()` / `set_qobuz_secret()` -- **Configuration YAML** : - ```yaml - accounts: - qobuz: - username: "user@example.com" - password: "password" - appid: "1401488693436528" # Optionnel - secret: "base64_encoded_secret" # Optionnel - ``` - -### 6. ✅ Intégration dans QobuzClient - -**État** : **TERMINÉ** - -- **Fichier** : [pmoqobuz/src/client.rs](src/client.rs:80-129) -- **Logique** : - 1. Si `appid` ET `secret` configurés → `QobuzApi::with_secret()` - 2. Sinon → `QobuzApi::new()` avec appid (ou DEFAULT_APP_ID) -- **Note** : Les requêtes signées échouent si le secret n'est pas configuré - -## 📦 Dépendances ajoutées - -```toml -md-5 = "0.10" # Pour les signatures MD5 -``` - -## 📁 Fichiers créés/modifiés - -### Nouveaux fichiers -- ✅ `src/api/signing.rs` - Module de signatures MD5 -- ✅ `src/config_ext.rs` - Trait d'extension pour la configuration -- ✅ `API_ANALYSIS.md` - Analyse des différences avec Python -- ✅ `IMPLEMENTATION_STATUS.md` - Ce fichier - -### Fichiers modifiés -- ✅ `src/api/mod.rs` - Ajout du support du secret s4 -- ✅ `src/api/catalog.rs` - Signature de `get_file_url` -- ✅ `src/api/user.rs` - Ajout de `userlib_get_albums` -- ✅ `src/client.rs` - Intégration du secret dans `from_config_obj` -- ✅ `src/error.rs` - Ajout de `QobuzError::Configuration` -- ✅ `src/lib.rs` - Export de `QobuzConfigExt` -- ✅ `Cargo.toml` - Ajout de `md-5` - -## 🧪 Tests - -### Compilation -```bash -cargo check -# ✅ warning: `pmoqobuz` (lib) generated 6 warnings -# ✅ Finished `dev` profile -``` - -### Exemples -```bash -cargo check --example basic_usage -# ✅ Finished `dev` profile -``` - -## 🚀 Utilisation - -### Option 1 : Sans secret (limité) - -**Configuration minimale** : -```yaml -accounts: - qobuz: - username: "user@example.com" - password: "password" -``` - -**Fonctionnalités disponibles** : -- ✅ Authentification -- ✅ Recherche (albums, artistes, tracks, playlists) -- ✅ Récupération des métadonnées (albums, tracks, etc.) -- ✅ Favoris -- ✅ Playlists -- ❌ Streaming (requiert signature) -- ❌ Bibliothèque utilisateur complète (requiert signature) - -### Option 2 : Avec secret (complet) - -**Configuration complète** : -```yaml -accounts: - qobuz: - username: "user@example.com" - password: "password" - appid: "1401488693436528" - secret: "Ym9vdHN0cmFw..." # Base64 encoded -``` - -**Fonctionnalités disponibles** : -- ✅ Toutes les fonctionnalités de l'Option 1 -- ✅ Streaming (avec `get_stream_url`) -- ✅ Bibliothèque utilisateur complète - -### Option 3 : Avec Spoofer (TODO) - -Le Spoofer permet d'obtenir automatiquement un AppID et des secrets valides. - -**Status** : 🚧 En cours (nécessite intégration dans `QobuzClient::from_config`) - -## ✅ Nouvelles fonctionnalités (2025-12-10) - -### 1. ✅ Désérialisation flexible des IDs - -**Problème résolu** : Les IDs Qobuz peuvent être des integers ou des strings dans les réponses JSON - -**Modifications** : -- Ajout de `deserialize_id()` dans [models.rs](src/models.rs:7-20) -- Application à toutes les structures (Artist, Album, Track, Playlist, etc.) -- Support automatique des deux formats - -### 2. ✅ Intégration automatique du Spoofer avec fallback intelligent - -**Fonctionnalité** : Le client gère automatiquement les credentials invalides/expirés - -**Logique d'initialisation** (client.rs:90-222) : -1. Si `appid` ET `secret` configurés → **test avec authentification** -2. Si l'authentification réussit → utilisation directe (pas de Spoofer) -3. Si l'authentification échoue (credentials invalides/expirés) → **fallback automatique vers Spoofer** -4. Si aucun `appid`/`secret` configuré → appel direct du Spoofer -5. Le Spoofer teste chaque secret et sauvegarde le premier valide -6. Fallback ultime vers DEFAULT_APP_ID si tout échoue - -**Avantages** : -- ✅ Aucune configuration manuelle requise -- ✅ **Gestion automatique de l'expiration des credentials** -- ✅ **Auto-réparation si les credentials deviennent invalides** -- ✅ Secrets toujours à jour -- ✅ Fonctionnement transparent pour l'utilisateur -- ✅ Configuration sauvegardée automatiquement - -## ⚠️ Limitations connues - -1. **Test des secrets** : La méthode `test_secret()` est incomplète (nécessite refactoring pour &mut self) - -## 📚 Documentation - -- [API_ANALYSIS.md](API_ANALYSIS.md) - Analyse détaillée des différences -- [examples/basic_usage.rs](examples/basic_usage.rs) - Exemple fonctionnel -- [examples/spoofer.rs](examples/spoofer.rs) - Exemple d'extraction AppID/secrets -- [examples/config_usage.rs](examples/config_usage.rs) - Exemple de configuration - -## ✅ Conclusion - -L'implémentation Rust reproduit fidèlement le comportement de l'API Python de référence pour toutes les opérations critiques. Le système de signatures MD5 fonctionne correctement, et le Spoofer intégré permet un fonctionnement automatique sans configuration manuelle. - -**Status global** : ✅ **PRODUCTION READY** - -### Avantages par rapport à la version Python : -- ✅ Intégration automatique du Spoofer (pas besoin de configuration manuelle) -- ✅ Désérialisation robuste (gère integers et strings pour les IDs) -- ✅ Sauvegarde automatique des credentials valides -- ✅ Performance supérieure (Rust) -- ✅ Type safety (compilation) -========= End of pmoqobuz/IMPLEMENTATION_STATUS.md =========== - -=============== pmoqobuz/CACHE_STRATEGY.md ============ -# Stratégie de cache pour pmoqobuz - -## Vue d'ensemble - -Ce document décrit la stratégie complète de mise en cache dans `pmoqobuz` pour **minimiser le nombre de requêtes API** et **limiter les logins**. - -## Objectifs - -1. **Limiter les login** - Éviter de se reconnecter à chaque démarrage -2. **Minimiser les requêtes API** - Réduire la charge sur les serveurs Qobuz -3. **Améliorer les performances** - Réponses instantanées pour les données déjà chargées -4. **Transparence** - Le cache doit être invisible pour l'utilisateur final - -## Architecture du cache - -### 1. Cache du token d'authentification ✅ IMPLÉMENTÉ - -**Localisation** : Fichier `config.yaml` dans la section `accounts.qobuz` - -**Données stockées** : -```yaml -accounts: - qobuz: - username: eric@coissac.eu - password: encrypted:yRyu/jNlJRSdVz0eE+JX56UC2Tk016TmESDoLT6npLBJB3ZuhJ0XTqNOQjiXkkcB - appid: '798273057' - secret: 806331c3b0b641da923b890aed01d04a - # Token d'authentification (ajouté automatiquement) - auth_token: "r7xPjQ5Kn8..." - user_id: "1217710" - token_expires_at: 1733953200 - subscription_label: "Studio" -``` - -**Stratégie** : -- Au **démarrage** : Réutiliser le token stocké SANS vérifier l'expiration -- Si une requête échoue avec **401/403** : Re-login automatique (TODO) -- Après un **login réussi** : Sauvegarder le token dans la config -- **TTL** : 24 heures (mais validation lazy) - -**Bénéfices** : -- ✅ **Zéro login inutile au démarrage** -- ✅ Démarrage instantané de l'application -- ✅ Token persisté entre les sessions - -**Implémentation** : [config_ext.rs:254-354](src/config_ext.rs#L254-354) - -```rust -// Au démarrage - aucun login ! -if let (Ok(Some(token)), Ok(Some(user_id))) = - (config.get_qobuz_auth_token(), config.get_qobuz_user_id()) -{ - api.set_auth_token(token, user_id); - info!("✓ Reusing authentication token (no login required)"); - // → Pas de requête réseau, démarrage instantané -} -``` - -### 2. Cache en mémoire (données API) ✅ IMPLÉMENTÉ - -**Localisation** : En mémoire (bibliothèque `moka`) - -**Implémentation** : [cache.rs](src/cache.rs) - -| Type de données | TTL | Capacité | Invalidation | -|----------------------|---------|-----------|--------------| -| Albums | 1h | 1000 | Manuelle | -| Tracks | 1h | 2000 | Manuelle | -| Artistes | 1h | 500 | Manuelle | -| Playlists | 30min | 250 | Manuelle | -| Résultats recherche | 15min | 500 | Manuelle | -| URLs streaming | 5min | 250 | Manuelle | - -**Stratégie** : -- **Vérifier le cache** avant chaque requête API -- Si donnée en cache ET non expirée → retour immédiat -- Sinon → requête API + mise en cache - -**Exemple** ([client.rs:247-263](src/client.rs#L247-263)) : -```rust -pub async fn get_album(&self, album_id: &str) -> Result { - // 1. Vérifier le cache d'abord - if let Some(album) = self.cache.get_album(album_id).await { - debug!("Album {} found in cache", album_id); - return Ok(album); // ← Aucune requête API ! - } - - // 2. Sinon, récupérer depuis l'API - let album = self.api.get_album(album_id).await?; - - // 3. Mettre en cache pour la prochaine fois - self.cache.put_album(album_id.to_string(), album.clone()).await; - - Ok(album) -} -``` - -**Bénéfices** : -- ✅ Réponses instantanées pour les données fréquemment accédées -- ✅ Réduction drastique des requêtes API -- ✅ Expiration automatique (TTL) -- ✅ Limite de mémoire (LRU éviction) - -### 3. Cache sur disque (favoris et bibliothèque) ❌ TODO - -**Problème actuel** : Les favoris et la bibliothèque ne sont PAS cachés - -```rust -pub async fn get_favorite_albums(&self) -> Result> { - // ❌ Requête API à CHAQUE appel - self.api.get_favorite_albums().await -} -``` - -**Impact** : -- 375 albums favoris → requête complète à chaque fois -- Playlists utilisateur → requête complète à chaque fois - -**Solution proposée** : Cache disque avec invalidation intelligente - -```rust -// Fichier: ~/.pmomusic/cache/favorites_{user_id}.json -pub async fn get_favorite_albums(&self) -> Result> { - let cache_file = format!("cache/favorites_{}.json", self.user_id); - - // Vérifier le cache sur disque - if let Ok(cached) = load_from_disk(&cache_file) { - if !is_expired(&cached, Duration::from_secs(3600)) { - return Ok(cached.albums); - } - } - - // Sinon, récupérer depuis l'API - let albums = self.api.get_favorite_albums().await?; - - // Sauvegarder pour la prochaine fois - save_to_disk(&cache_file, &albums)?; - - Ok(albums) -} -``` - -**Bénéfices potentiels** : -- ✅ Cache persistant entre les sessions -- ✅ Réduction majeure des requêtes pour les gros catalogues -- ✅ TTL configurable (ex: 1h pour favoris, 24h pour bibliothèque) - -## Statistiques et monitoring - -### Métriques disponibles - -```rust -let stats = client.cache().stats().await; -println!("Albums en cache: {}", stats.albums_count); -println!("Tracks en cache: {}", stats.tracks_count); -println!("Total: {} entrées", stats.total_count()); -``` - -### Logs de debug - -```bash -RUST_LOG=debug ./pmomusic -# → Voir les hits/miss du cache -# → Voir les requêtes API effectuées -``` - -## Impact mesuré - -### Avant optimisations -- **Login à chaque démarrage** : ~500ms -- **Recherche "Miles Davis"** (2ème fois) : ~300ms (nouvelle requête API) -- **get_album("123")** (2ème fois) : ~200ms (nouvelle requête API) - -### Après optimisations -- **Login au démarrage** : 0ms (token réutilisé) ✅ -- **Recherche "Miles Davis"** (2ème fois) : ~1ms (cache mémoire) ✅ -- **get_album("123")** (2ème fois) : ~0.5ms (cache mémoire) ✅ - -**Réduction** : **~99% du temps de réponse** pour les données déjà chargées - -## Recommandations - -### Court terme - -1. ✅ **Token d'authentification** - IMPLÉMENTÉ -2. ✅ **Cache mémoire** - IMPLÉMENTÉ -3. ❌ **Cache disque pour favoris** - TODO (priorité haute) - -### Moyen terme - -4. ❌ **Re-login automatique** sur erreur 401/403 - TODO -5. ❌ **Cache des playlists utilisateur** - TODO -6. ❌ **Invalidation intelligente** (ex: invalider cache favoris après ajout) - TODO - -### Long terme - -7. ❌ **Cache partagé entre instances** (Redis/SQLite) - TODO -8. ❌ **Préchargement** (favoris au démarrage en arrière-plan) - TODO -9. ❌ **Compression** du cache disque - TODO - -## Configuration - -### Configurer la taille du cache - -```rust -let cache = QobuzCache::with_capacity(2000); // 2000 albums max -let client = QobuzClient::new_with_cache(username, password, cache).await?; -``` - -### Désactiver le cache (debugging) - -```rust -let cache = QobuzCache::with_capacity(0); // Cache désactivé -``` - -### Invalider le cache - -```rust -// Invalider un album spécifique -client.cache().invalidate_album("123").await; - -// Tout effacer -client.cache().clear_all().await; -``` - -## Tests - -```bash -# Tests du module cache -cargo test -p pmoqobuz cache - -# Tests d'intégration avec Qobuz -cargo run --example basic_usage - -# Vérifier les logs de cache -RUST_LOG=debug,pmoqobuz::cache=trace cargo run --example basic_usage -``` - -## Conclusion - -La stratégie de cache actuelle offre déjà **d'excellentes performances** : -- ✅ Démarrage instantané (pas de login) -- ✅ Requêtes ultra-rapides (cache mémoire) -- ✅ Réduction de ~99% des requêtes répétées - -**Prochaine étape prioritaire** : Implémenter le cache disque pour les favoris et bibliothèque utilisateur. -========= End of pmoqobuz/CACHE_STRATEGY.md =========== - -=============== pmoqobuz/API_ANALYSIS.md ============ -# Analyse des différences entre l'API Rust et Python - -## Vue d'ensemble - -L'implémentation actuelle de `pmoqobuz` ne suit pas complètement l'API de référence Python (`qobuz.api.raw`). Voici les principales différences et ce qui doit être corrigé. - -## Problèmes identifiés - -### 1. ❌ Gestion du secret `s4` manquante - -**Python** : -- Accepte soit `appid` + `configvalue` (secret encodé en base64) -- Soit utilise le `Spoofer` pour obtenir l'appID et les secrets dynamiquement -- Le `configvalue` est décodé et XORé avec l'appID pour obtenir le secret `s4` -- Le secret `s4` est utilisé pour signer certaines requêtes critiques - -**Rust actuel** : -- ❌ Utilise un `DEFAULT_APP_ID` codé en dur -- ❌ Pas de gestion du secret `s4` -- ❌ Pas d'utilisation du Spoofer pour obtenir l'appID/secret -- ❌ Pas de méthode pour décoder et dériver le secret depuis un `configvalue` - -**Impact** : -- Les requêtes `track/getFileUrl` et `userLibrary/getAlbumsList` échoueront probablement car elles nécessitent une signature MD5 - -### 2. ❌ Signature MD5 des requêtes manquante - -**Python - track_getFileUrl** : -```python -ts = str(time.time()) -stringvalue = ("trackgetFileUrlformat_id" + fmt_id + - "intent" + intent + - "track_id" + track_id + ts).encode("ASCII") -stringvalue += self.s4 # Secret ajouté -rq_sig = str(hashlib.md5(stringvalue).hexdigest()) -params = { - "format_id": fmt_id, - "intent": intent, - "request_ts": ts, # ← Timestamp - "request_sig": rq_sig, # ← Signature MD5 - "track_id": track_id, -} -``` - -**Rust actuel (catalog.rs:210-218)** : -```rust -let params = [ - ("track_id", track_id), - ("format_id", &format_id), - ("intent", "stream"), - // ❌ MANQUE: request_ts - // ❌ MANQUE: request_sig -]; -``` - -**Impact** : -- Les requêtes de streaming peuvent échouer ou retourner des URLs invalides - -### 3. ❌ Méthode `userlib_getAlbums` manquante - -**Python** : -```python -def userlib_getAlbums(self, **ka): - ts = str(time.time()) - r_sig = "userLibrarygetAlbumsList" + str(ts) + str(ka["sec"]) - r_sig_hashed = hashlib.md5(r_sig.encode("utf-8")).hexdigest() - params = { - "app_id": self.appid, - "user_auth_token": self.user_auth_token, - "request_ts": ts, - "request_sig": r_sig_hashed, - } - return self._api_request(params, "/userLibrary/getAlbumsList") -``` - -**Rust actuel** : -- ❌ Méthode totalement absente - -**Impact** : -- Impossible de tester les secrets (méthode `setSec()`) -- Impossible de récupérer la bibliothèque d'albums de l'utilisateur - -### 4. ❌ Méthode `setSec()` manquante - -**Python** : -```python -def setSec(self): - # Teste tous les secrets du spoofer - for value in self.spoofer.getSecrets().values(): - self.s4 = value.encode("utf-8") - if self.userlib_getAlbums(sec=self.s4) is not None: - # Ce secret fonctionne ! - return -``` - -**Rust actuel** : -- ❌ Méthode totalement absente -- ❌ Pas de mécanisme pour tester et sélectionner le bon secret - -**Impact** : -- Si on utilise le Spoofer, impossible de trouver le bon secret parmi ceux retournés - -### 5. ⚠️ Configuration incomplète - -**Python** : -- Peut être initialisé avec `appid` + `configvalue` OU utiliser le Spoofer - -**Rust actuel** : -- ✅ Configuration du username/password via `QobuzConfigExt` -- ❌ Pas de configuration pour `appid` et `secret`/`configvalue` - -**Impact** : -- Impossible de configurer manuellement un appID et secret valides -- Dépendance à un appID codé en dur qui peut devenir obsolète - -## Plan de correction - -### Phase 1: Extension de la configuration - -**Fichier: `pmoqobuz/src/config_ext.rs`** - -Ajouter au trait `QobuzConfigExt` : -- `get_qobuz_appid()` / `set_qobuz_appid()` -- `get_qobuz_secret()` / `set_qobuz_secret()` (stocke la valeur base64) - -### Phase 2: Ajout du support du secret dans QobuzApi - -**Fichier: `pmoqobuz/src/api/mod.rs`** - -Modifications de `QobuzApi` : -```rust -pub struct QobuzApi { - client: Client, - app_id: String, - secret: Option>, // ← Nouveau : secret s4 décodé - user_auth_token: Option, - user_id: Option, - format_id: AudioFormat, -} -``` - -Nouvelles méthodes : -```rust -impl QobuzApi { - /// Crée une API avec appid + configvalue - pub fn with_secret(app_id: impl Into, configvalue: &str) -> Result; - - /// Crée une API en utilisant le Spoofer - pub async fn with_spoofer() -> Result; - - /// Définit le secret s4 - pub fn set_secret(&mut self, secret: Vec); - - /// Teste un secret en appelant userlib_getAlbums - async fn test_secret(&self, secret: &[u8]) -> bool; - - /// Teste et sélectionne le bon secret depuis le Spoofer - async fn set_secret_from_spoofer(&mut self, spoofer: &Spoofer) -> Result<()>; -} -``` - -### Phase 3: Implémentation des méthodes signées - -**Fichier: `pmoqobuz/src/api/signing.rs` (nouveau)** - -```rust -use md5::{Md5, Digest}; -use std::time::{SystemTime, UNIX_EPOCH}; - -/// Génère un timestamp Unix -pub fn get_timestamp() -> String { - SystemTime::now() - .duration_since(UNIX_EPOCH) - .unwrap() - .as_secs_f64() - .to_string() -} - -/// Signe une requête track/getFileUrl -pub fn sign_track_get_file_url( - format_id: &str, - intent: &str, - track_id: &str, - timestamp: &str, - secret: &[u8], -) -> String { - let mut hasher = Md5::new(); - hasher.update(b"trackgetFileUrlformat_id"); - hasher.update(format_id.as_bytes()); - hasher.update(b"intent"); - hasher.update(intent.as_bytes()); - hasher.update(b"track_id"); - hasher.update(track_id.as_bytes()); - hasher.update(timestamp.as_bytes()); - hasher.update(secret); - format!("{:x}", hasher.finalize()) -} - -/// Signe une requête userLibrary/getAlbumsList -pub fn sign_userlib_get_albums(timestamp: &str, secret: &[u8]) -> String { - let mut hasher = Md5::new(); - hasher.update(b"userLibrarygetAlbumsList"); - hasher.update(timestamp.as_bytes()); - hasher.update(secret); - format!("{:x}", hasher.finalize()) -} -``` - -**Fichier: `pmoqobuz/src/api/catalog.rs`** - -Modifier `get_file_url` : -```rust -pub async fn get_file_url(&self, track_id: &str) -> Result { - let format_id = self.format_id.id().to_string(); - let timestamp = signing::get_timestamp(); - - // Signature MD5 requise ! - let secret = self.secret.as_ref() - .ok_or_else(|| QobuzError::Configuration("Secret not configured".into()))?; - - let signature = signing::sign_track_get_file_url( - &format_id, - "stream", - track_id, - ×tamp, - secret, - ); - - let params = [ - ("track_id", track_id), - ("format_id", format_id.as_str()), - ("intent", "stream"), - ("request_ts", timestamp.as_str()), - ("request_sig", signature.as_str()), - ]; - - let response: FileUrlResponse = self.get("/track/getFileUrl", ¶ms).await?; - // ... -} -``` - -**Fichier: `pmoqobuz/src/api/user.rs`** - -Ajouter : -```rust -pub async fn get_user_albums(&self) -> Result { - let timestamp = signing::get_timestamp(); - - let secret = self.secret.as_ref() - .ok_or_else(|| QobuzError::Configuration("Secret not configured".into()))?; - - let signature = signing::sign_userlib_get_albums(×tamp, secret); - - let params = [ - ("app_id", self.app_id.as_str()), - ("user_auth_token", self.user_auth_token.as_ref() - .ok_or_else(|| QobuzError::Unauthorized("Not logged in".into()))? - .as_str()), - ("request_ts", timestamp.as_str()), - ("request_sig", signature.as_str()), - ]; - - self.post("/userLibrary/getAlbumsList", ¶ms).await -} -``` - -### Phase 4: Modification de QobuzClient - -**Fichier: `pmoqobuz/src/client.rs`** - -```rust -impl QobuzClient { - /// Crée un client avec appID et secret depuis la config - pub async fn from_config() -> Result { - let config = pmoconfig::get_config(); - - // Essayer d'obtenir appid et secret depuis la config - let api = if let (Ok(appid), Ok(secret)) = ( - config.get_qobuz_appid(), - config.get_qobuz_secret() - ) { - QobuzApi::with_secret(appid, &secret)? - } else { - // Sinon, utiliser le Spoofer - warn!("AppID/secret not configured, using Spoofer"); - QobuzApi::with_spoofer().await? - }; - - // Login... - let (username, password) = config.get_qobuz_credentials()?; - // ... - } -} -``` - -## Dépendances à ajouter - -**Cargo.toml** : -```toml -md5 = "0.7" -``` - -## Résumé des fichiers à modifier/créer - -### Modifications -- [x] `pmoqobuz/src/config_ext.rs` - Ajouter appid et secret -- [ ] `pmoqobuz/src/api/mod.rs` - Ajouter champ secret et nouvelles méthodes -- [ ] `pmoqobuz/src/api/auth.rs` - Appeler `set_secret_from_spoofer` après login -- [ ] `pmoqobuz/src/api/catalog.rs` - Ajouter signature à `get_file_url` -- [ ] `pmoqobuz/src/api/user.rs` - Ajouter `get_user_albums` avec signature -- [ ] `pmoqobuz/src/client.rs` - Utiliser Spoofer si pas de config -- [ ] `pmoqobuz/Cargo.toml` - Ajouter dépendance `md5` - -### Nouveaux fichiers -- [ ] `pmoqobuz/src/api/signing.rs` - Fonctions de signature MD5 - -## Tests nécessaires - -1. **Test avec Spoofer** : Vérifier que l'obtention automatique de l'appID fonctionne -2. **Test avec config manuelle** : Vérifier qu'on peut configurer un appID/secret -3. **Test de signature** : Vérifier que les signatures MD5 sont correctes -4. **Test de setSec** : Vérifier que le bon secret est sélectionné -5. **Test de streaming** : Vérifier qu'on obtient des URLs valides avec `get_file_url` -========= End of pmoqobuz/API_ANALYSIS.md =========== - -=============== pmoqobuz/README.md ============ -# pmoqobuz - Client Rust pour l'API Qobuz - -Client Rust pour l'API Qobuz avec intégration automatique du Spoofer pour obtenir des AppID et secrets valides. - -## 🎯 Fonctionnalités - -- ✅ **Authentification** automatique avec credentials -- ✅ **Spoofer intégré** - Obtention automatique d'AppID et secrets valides -- ✅ **Signatures MD5** pour les requêtes sensibles (streaming, bibliothèque) -- ✅ **Cache** en mémoire pour optimiser les performances -- ✅ **Support DIDL-Lite** pour l'export UPnP/DLNA -- ✅ **Recherche** dans le catalogue (albums, artistes, tracks, playlists) -- ✅ **Favoris** et playlists utilisateur -- ✅ **Désérialisation robuste** (gère integers et strings pour les IDs) - -## 🚀 Utilisation rapide - -### Configuration minimale - -```yaml -# ~/.pmomusic/config.yaml -accounts: - qobuz: - username: "your_email@example.com" - password: "your_password" - # AppID et secret seront automatiquement obtenus via le Spoofer -``` - -### Code d'exemple - -```rust -use pmoqobuz::QobuzClient; - -#[tokio::main] -async fn main() -> anyhow::Result<()> { - // Le Spoofer s'exécute automatiquement si nécessaire - let client = QobuzClient::from_config().await?; - - // Rechercher des albums - let albums = client.search_albums("Miles Davis").await?; - for album in albums.iter().take(5) { - println!("{} - {}", album.artist.name, album.title); - } - - Ok(()) -} -``` - -## 📖 Documentation - -- [IMPLEMENTATION_STATUS.md](IMPLEMENTATION_STATUS.md) - Statut d'implémentation complet -- [API_ANALYSIS.md](API_ANALYSIS.md) - Analyse des différences avec l'API Python -- [examples/basic_usage.rs](examples/basic_usage.rs) - Exemple complet -- [examples/spoofer.rs](examples/spoofer.rs) - Utilisation manuelle du Spoofer -========= End of pmoqobuz/README.md =========== - -=============== pmoqobuz/examples/config.yaml.example ============ -# Configuration exemple pour pmoqobuz -# -# Ce fichier montre comment configurer l'accès à Qobuz avec AppID et Secret. -# Pour utiliser cette configuration : -# -# 1. Copier ce fichier vers ~/.pmomusic/config.yaml (ou le répertoire de config approprié) -# 2. Remplacer les valeurs par vos propres credentials -# 3. Utiliser le Spoofer pour obtenir un AppID et Secret valides : -# cargo run --example spoofer - -host: - http_port: '8080' - cover_cache: - directory: cache_covers - size: 2000 - audio_cache: - directory: cache_audio - size: 500 - logger: - buffer_capacity: 200 - enable_console: true - min_level: INFO - -playlists: - directory: playlists - -devices: - mediarenderer: - pmo_mediarenderer: - udn: e4b68fbc-2bd5-4cea-98d8-be843fec0bd4 - mediaserver: - pmo_mediaserver: - udn: 17fe2ea6-8908-4e30-bc52-b28ea4cab3e4 - -accounts: - qobuz: - # Credentials utilisateur (REQUIS) - username: "your_email@example.com" - password: "your_password" - - # AppID et Secret (OPTIONNEL mais RECOMMANDÉ) - # Pour obtenir ces valeurs, exécutez : cargo run --example spoofer - # - # Exemple de valeurs récupérées le 2025-12-10 : - appid: "798273057" - secret: "f69a7734686cb9427629378a4b7ac381" # Secret pour timezone "london" - - # Autres secrets disponibles (testez si "london" ne fonctionne pas) : - # secret: "806331c3b0b641da923b890aed01d04a" # Secret pour timezone "abidjan" - # secret: "abb21364945c0583309667d13ca3d93a" # Secret pour timezone "berlin" - - # Note sur les secrets : - # - Les secrets sont des valeurs base64-encodées retournées par le Spoofer - # - Ils sont nécessaires pour les requêtes signées (streaming, bibliothèque) - # - Sans secret, seules les fonctionnalités de base sont disponibles - # - Les secrets peuvent expirer : réexécutez le Spoofer pour en obtenir de nouveaux -========= End of pmoqobuz/examples/config.yaml.example =========== - -=============== pmoqobuz/examples/spoofer.rs ============ -//! Exemple de Spoofer Qobuz - Extraction dynamique des AppID et secrets -//! -//! Cet exemple reproduit le comportement du spoofer Python : -//! 1. Récupère la page de login Qobuz -//! 2. Extrait l'URL du bundle.js -//! 3. Télécharge le bundle -//! 4. Extrait l'AppID et les secrets via regex -//! 5. Décode les secrets en base64 -//! -//! Usage: -//! ```bash -//! cargo run --example spoofer -//! ``` - -use anyhow::Result; -use base64::{engine::general_purpose::STANDARD, Engine}; -use indexmap::IndexMap; -use regex::Regex; -use reqwest::Client; - -struct Spoofer { - bundle: String, - seed_timezone_regex: Regex, - info_extras_regex_template: String, - app_id_regex: Regex, -} - -impl Spoofer { - /// Crée un nouveau Spoofer et télécharge le bundle.js - async fn new() -> Result { - // Expressions régulières (équivalent Python) - let seed_timezone_regex = Regex::new( - r#"[a-z]\.initialSeed\("(?P[\w=]+)",window\.utimezone\.(?P[a-z]+)\)"#, - )?; - - let info_extras_regex_template = - r#"name:"\w+/(?P{timezones})",info:"(?P[\w=]+)",extras:"(?P[\w=]+)""# - .to_string(); - - let app_id_regex = Regex::new( - r#"production:\{api:\{appId:"(?P\d{9})",appSecret:"(?P\w{32})"\},braze:.\(.\(\{\},.\),\{\},\{apiKey:"([-0-9a-fA-F]{36})"\}\),extra:.\}"#, - )?; - - // Créer un client HTTP - let client = Client::builder() - .user_agent("Mozilla/5.0 (compatible; PMOMusic/1.0)") - .build()?; - - println!("Récupération de la page de login..."); - let login_page = client - .get("https://play.qobuz.com/login") - .send() - .await? - .text() - .await?; - - // Extraire l'URL du bundle - let bundle_url_regex = - Regex::new(r#""#)?; - let bundle_url = bundle_url_regex - .captures(&login_page) - .and_then(|cap| cap.get(1)) - .ok_or_else(|| anyhow::anyhow!("Impossible de trouver l'URL du bundle"))? - .as_str(); - - println!("Téléchargement du bundle depuis: {}", bundle_url); - let bundle_full_url = format!("https://play.qobuz.com{}", bundle_url); - let bundle = client.get(&bundle_full_url).send().await?.text().await?; - - println!("Bundle téléchargé ({} bytes)", bundle.len()); - - Ok(Self { - bundle, - seed_timezone_regex, - info_extras_regex_template, - app_id_regex, - }) - } - - /// Extrait l'App ID depuis le bundle - fn get_app_id(&self) -> Result { - let captures = self - .app_id_regex - .captures(&self.bundle) - .ok_or_else(|| anyhow::anyhow!("AppID non trouvé dans le bundle"))?; - - Ok(captures - .name("app_id") - .ok_or_else(|| anyhow::anyhow!("Groupe app_id non trouvé"))? - .as_str() - .to_string()) - } - - /// Extrait les secrets depuis le bundle - fn get_secrets(&self) -> Result> { - // Étape 1: Extraire tous les seed/timezone pairs - let mut secrets: IndexMap> = IndexMap::new(); - - for captures in self.seed_timezone_regex.captures_iter(&self.bundle) { - let seed = captures - .name("seed") - .ok_or_else(|| anyhow::anyhow!("Groupe seed non trouvé"))? - .as_str(); - let timezone = captures - .name("timezone") - .ok_or_else(|| anyhow::anyhow!("Groupe timezone non trouvé"))? - .as_str(); - - secrets - .entry(timezone.to_string()) - .or_insert_with(Vec::new) - .push(seed.to_string()); - } - - println!("Timezones trouvées: {:?}", secrets.keys()); - - // Étape 2: Réordonner - on met la deuxième timezone en premier - // (comme le fait le code Python avec move_to_end) - if secrets.len() >= 2 { - let keys: Vec = secrets.keys().cloned().collect(); - let second_key = keys[1].clone(); - let second_value = secrets.get(&second_key).unwrap().clone(); - - // Retirer et réinsérer pour le mettre en premier - secrets.shift_remove(&second_key); - let mut new_secrets = IndexMap::new(); - new_secrets.insert(second_key, second_value); - for (k, v) in secrets { - new_secrets.insert(k, v); - } - secrets = new_secrets; - } - - // Étape 3: Construire la regex pour info/extras - let timezones_capitalized: Vec = secrets - .keys() - .map(|tz| { - let mut chars = tz.chars(); - match chars.next() { - None => String::new(), - Some(first) => first.to_uppercase().collect::() + chars.as_str(), - } - }) - .collect(); - - let info_extras_regex_str = self - .info_extras_regex_template - .replace("{timezones}", &timezones_capitalized.join("|")); - - let info_extras_regex = Regex::new(&info_extras_regex_str)?; - - // Étape 4: Extraire info et extras pour chaque timezone - for captures in info_extras_regex.captures_iter(&self.bundle) { - let timezone_cap = captures - .name("timezone") - .ok_or_else(|| anyhow::anyhow!("Groupe timezone non trouvé"))? - .as_str(); - let info = captures - .name("info") - .ok_or_else(|| anyhow::anyhow!("Groupe info non trouvé"))? - .as_str(); - let extras = captures - .name("extras") - .ok_or_else(|| anyhow::anyhow!("Groupe extras non trouvé"))? - .as_str(); - - let timezone_lower = timezone_cap.to_lowercase(); - if let Some(vec) = secrets.get_mut(&timezone_lower) { - vec.push(info.to_string()); - vec.push(extras.to_string()); - } - } - - // Étape 5: Décoder les secrets en base64 - let mut decoded_secrets = IndexMap::new(); - for (timezone, parts) in secrets { - let concatenated = parts.join(""); - - // Retirer les 44 derniers caractères (comme Python [:-44]) - if concatenated.len() > 44 { - let trimmed = &concatenated[..concatenated.len() - 44]; - - // Décoder en base64 - match STANDARD.decode(trimmed) { - Ok(decoded_bytes) => { - match String::from_utf8(decoded_bytes) { - Ok(decoded_str) => { - decoded_secrets.insert(timezone, decoded_str); - } - Err(e) => { - eprintln!( - "Erreur UTF-8 pour timezone {}: {}", - timezone, e - ); - } - } - } - Err(e) => { - eprintln!( - "Erreur de décodage base64 pour timezone {}: {}", - timezone, e - ); - } - } - } - } - - Ok(decoded_secrets) - } -} - -#[tokio::main] -async fn main() -> Result<()> { - // Initialiser le logging - tracing_subscriber::fmt::init(); - - println!("=== Spoofer Qobuz ===\n"); - - // Créer le spoofer - let spoofer = Spoofer::new().await?; - - // Extraire l'App ID - println!("\n--- App ID ---"); - match spoofer.get_app_id() { - Ok(app_id) => println!("App ID: {}", app_id), - Err(e) => eprintln!("Erreur lors de l'extraction de l'App ID: {}", e), - } - - // Extraire les secrets - println!("\n--- Secrets ---"); - match spoofer.get_secrets() { - Ok(secrets) => { - for (timezone, secret) in secrets { - println!("{}: {}", timezone, secret); - } - } - Err(e) => eprintln!("Erreur lors de l'extraction des secrets: {}", e), - } - - Ok(()) -} -========= End of pmoqobuz/examples/spoofer.rs =========== - -=============== pmoqobuz/examples/server_with_covers.rs ============ -//! Exemple d'utilisation de pmoqobuz avec pmoserver et pmocovers -//! -//! Cet exemple montre comment : -//! - Créer un serveur HTTP avec pmoserver -//! - Initialiser le cache d'images avec pmocovers -//! - Initialiser le client Qobuz avec intégration pmocovers -//! - Les images d'albums sont automatiquement mises en cache -//! -//! Pour tester : -//! ```bash -//! cargo run --example server_with_covers --features "pmoserver,covers" -//! ``` -//! -//! Endpoints disponibles : -//! - GET /qobuz/search?q=query&type=albums - Recherche d'albums (images auto-cachées) -//! - GET /qobuz/albums/{id} - Détails d'un album (image auto-cachée) -//! - GET /qobuz/favorites/albums - Albums favoris (images auto-cachées) -//! - GET /covers/images/{pk} - Image originale mise en cache -//! - GET /covers/images/{pk}/{size} - Variante redimensionnée -//! - GET /api/covers - API REST du cache d'images -//! - GET /swagger-ui - Documentation interactive - -#[cfg(all(feature = "pmoserver", feature = "covers"))] -use pmocovers::CoverCacheExt; - -#[cfg(all(feature = "pmoserver", feature = "covers"))] -use pmoqobuz::QobuzServerExt; - -#[cfg(all(feature = "pmoserver", feature = "covers"))] -use pmoserver::ServerBuilder; - -#[cfg(all(feature = "pmoserver", feature = "covers"))] -#[tokio::main] -async fn main() -> anyhow::Result<()> { - // Initialiser le logging - tracing_subscriber::fmt() - .with_max_level(tracing::Level::INFO) - .init(); - - println!("=== PMOQobuz + PMOCovers - Serveur HTTP avec cache d'images ===\n"); - - // Créer le serveur depuis la configuration - let mut server = ServerBuilder::new_configured().build(); - - println!("1. Initialisation du cache d'images (pmocovers)..."); - // Initialiser le cache d'images avec la configuration - let cache = server.init_cover_cache_configured().await?; - println!(" ✓ Cache d'images initialisé: {}", cache.cache_dir()); - - println!("\n2. Initialisation du client Qobuz avec intégration pmocovers..."); - // Initialiser le client Qobuz avec intégration pmocovers - // Les images d'albums seront automatiquement ajoutées au cache - let client = server - .init_qobuz_client_configured_with_covers(cache.clone()) - .await?; - - if let Some(auth_info) = client.auth_info() { - println!(" ✓ Client Qobuz connecté !"); - println!(" User ID: {}", auth_info.user_id); - if let Some(label) = &auth_info.subscription_label { - println!(" Abonnement: {}", label); - } - } - - println!("\n3. Démarrage du serveur HTTP..."); - server.start().await; - - println!("\n✓ Serveur démarré avec succès !\n"); - println!("Endpoints disponibles :"); - println!(" • Qobuz API:"); - println!(" - GET /qobuz/search?q=query&type=albums"); - println!(" - GET /qobuz/albums/{{id}}"); - println!(" - GET /qobuz/albums/{{id}}/tracks"); - println!(" - GET /qobuz/favorites/albums"); - println!(" - GET /qobuz/favorites/artists"); - println!(" - GET /qobuz/cache/stats"); - println!(" • Images (auto-cachées depuis Qobuz):"); - println!(" - GET /covers/images/{{pk}}"); - println!(" - GET /covers/images/{{pk}}/{{size}}"); - println!(" • API REST du cache:"); - println!(" - GET /api/covers"); - println!(" - POST /api/covers"); - println!(" - DELETE /api/covers/{{pk}}"); - println!(" • Documentation:"); - println!(" - GET /swagger-ui"); - println!("\nExemple de requête :"); - println!(" curl 'http://localhost:3000/qobuz/search?q=Miles%20Davis&type=albums' | jq '.[0].image_cached'"); - println!(" # Retourne: \"/covers/images/{{pk}}\""); - println!("\nAppuyez sur Ctrl+C pour arrêter le serveur...\n"); - - // Attendre indéfiniment - server.wait().await; - - Ok(()) -} - -#[cfg(not(all(feature = "pmoserver", feature = "covers")))] -fn main() { - eprintln!("Cet exemple nécessite les features 'pmoserver' et 'covers'"); - eprintln!("Exécutez: cargo run --example server_with_covers --features \"pmoserver,covers\""); - std::process::exit(1); -} -========= End of pmoqobuz/examples/server_with_covers.rs =========== - -=============== pmoqobuz/examples/README_SPOOFER.md ============ -# Exemple Spoofer Qobuz - -Cet exemple reproduit le comportement du spoofer Python original pour extraire dynamiquement l'AppID et les secrets de l'API Qobuz. - -## Vue d'ensemble - -Le spoofer effectue les opérations suivantes : - -1. **Récupère la page de login** : `https://play.qobuz.com/login` -2. **Extrait l'URL du bundle.js** : Via regex sur la page HTML -3. **Télécharge le bundle** : JavaScript obfusqué contenant les secrets -4. **Extrait l'AppID** : Via regex spécifique -5. **Extrait les secrets** : Via une série de regex et décodage base64 - -## Équivalences Python ↔ Rust - -| Python | Rust | Notes | -|--------|------|-------| -| `requests.get()` | `reqwest::Client::get()` | Client HTTP asynchrone | -| `re.search()` / `re.finditer()` | `regex::Regex::captures()` / `captures_iter()` | Expressions régulières | -| `OrderedDict` | `indexmap::IndexMap` | Maintient l'ordre d'insertion | -| `base64.standard_b64decode()` | `base64::STANDARD.decode()` | Décodage base64 | -| String slicing `[:-44]` | `&string[..len-44]` | Extraction de sous-chaînes | - -## Différences notables - -### 1. Gestion asynchrone -Le code Rust est entièrement asynchrone avec Tokio : -```rust -#[tokio::main] -async fn main() -> Result<()> { - let spoofer = Spoofer::new().await?; - // ... -} -``` - -### 2. Gestion d'erreurs explicite -Rust utilise `Result` pour la gestion d'erreurs : -```rust -fn get_app_id(&self) -> Result { - let captures = self.app_id_regex - .captures(&self.bundle) - .ok_or_else(|| anyhow::anyhow!("AppID non trouvé"))?; - // ... -} -``` - -### 3. Propriété et emprunt -Rust nécessite une gestion explicite de la propriété : -```rust -// Clone pour éviter les problèmes de borrowing -let second_key = keys[1].clone(); -let second_value = secrets.get(&second_key).unwrap().clone(); -``` - -### 4. Réorganisation de l'IndexMap -Le code Python utilise `move_to_end()` : -```python -secrets.move_to_end(keypairs[1][0], last=False) -``` - -En Rust, on reconstruit une nouvelle map : -```rust -secrets.shift_remove(&second_key); -let mut new_secrets = IndexMap::new(); -new_secrets.insert(second_key, second_value); -for (k, v) in secrets { - new_secrets.insert(k, v); -} -``` - -## Usage - -```bash -# Compiler et lancer l'exemple -cargo run --example spoofer - -# Ou compiler uniquement -cargo check --example spoofer -``` - -## Sortie attendue - -``` -=== Spoofer Qobuz === - -Récupération de la page de login... -Téléchargement du bundle depuis: /resources/x.x.x-xxxx/bundle.js -Bundle téléchargé (xxxxx bytes) -Timezones trouvées: ["america", "europe", "asia", ...] - ---- App ID --- -App ID: 123456789 - ---- Secrets --- -america: xxxxxxxxxxxxxxxxxxxxxxxxx -europe: yyyyyyyyyyyyyyyyyyyyyyyyy -... -``` - -## Dépendances - -Les dépendances suivantes sont nécessaires (ajoutées dans `[dev-dependencies]`) : - -```toml -regex = "1.10" -base64 = "0.22" -indexmap = "2.0" -``` - -## Avertissement - -⚠️ **Note importante** : Ce code est fourni à des fins éducatives et de reverse engineering. L'extraction de secrets depuis des applications web peut violer les conditions d'utilisation de certains services. Utilisez-le de manière responsable et conformément aux lois applicables. - -## Références - -- Code Python original : Basé sur le spoofer Qobuz de la communauté -- Documentation Qobuz API : https://github.com/Qobuz/api-documentation -========= End of pmoqobuz/examples/README_SPOOFER.md =========== - -=============== pmoqobuz/examples/basic_usage.rs ============ -//! Exemple d'utilisation basique de pmoqobuz -//! -//! Cet exemple montre comment : -//! - Se connecter à Qobuz avec les credentials de la configuration -//! - Rechercher des albums -//! - Récupérer les détails d'un album -//! - Exporter un album en format DIDL-Lite - -use pmoqobuz::{QobuzClient, ToDIDL}; - -#[tokio::main] -async fn main() -> anyhow::Result<()> { - // Initialiser le logging - tracing_subscriber::fmt::init(); - - println!("=== PMOQobuz - Exemple d'utilisation basique ===\n"); - - // Créer un client depuis la configuration - println!("Connexion à Qobuz..."); - let client = QobuzClient::from_config().await?; - - if let Some(auth_info) = client.auth_info() { - println!("✓ Connecté avec succès !"); - println!(" User ID: {}", auth_info.user_id); - if let Some(label) = &auth_info.subscription_label { - println!(" Abonnement: {}", label); - } - } - - println!("\n--- Recherche d'albums ---"); - let query = "Miles Davis"; - println!("Recherche: '{}'...", query); - - let albums = client.search_albums(query).await?; - println!("✓ {} album(s) trouvé(s)\n", albums.len()); - - // Afficher les 5 premiers albums - for (i, album) in albums.iter().take(5).enumerate() { - println!(" {}. {} - {}", i + 1, album.artist.name, album.title); - if let Some(date) = &album.release_date { - println!(" Date: {}", date); - } - if let Some(count) = album.tracks_count { - println!(" Pistes: {}", count); - } - } - - // Récupérer les détails du premier album - if let Some(first_album) = albums.first() { - println!("\n--- Détails de l'album ---"); - println!("Album: {} - {}", first_album.artist.name, first_album.title); - - // Récupérer les tracks - let tracks = client.get_album_tracks(&first_album.id).await?; - println!("Tracks ({}):", tracks.len()); - - for track in tracks.iter().take(3) { - println!( - " {}. {} - {} ({}:{})", - track.track_number, - track - .display_artist() - .map(|a| a.name.as_str()) - .unwrap_or("Unknown"), - track.title, - track.duration / 60, - track.duration % 60 - ); - } - - if tracks.len() > 3 { - println!(" ... et {} autres pistes", tracks.len() - 3); - } - - // Export DIDL - println!("\n--- Export DIDL-Lite ---"); - let didl_container = first_album.to_didl_container("0")?; - println!("Container ID: {}", didl_container.id); - println!("Title: {}", didl_container.title); - println!("Class: {}", didl_container.class); - - if let Some(first_track) = tracks.first() { - let didl_item = first_track.to_didl_item(&didl_container.id)?; - println!("\nPremière track en DIDL:"); - println!(" Item ID: {}", didl_item.id); - println!(" Title: {}", didl_item.title); - if let Some(artist) = &didl_item.artist { - println!(" Artist: {}", artist); - } - } - } - - // Afficher les statistiques du cache - println!("\n--- Statistiques du cache ---"); - let stats = client.cache().stats().await; - println!("Albums en cache: {}", stats.albums_count); - println!("Tracks en cache: {}", stats.tracks_count); - println!("Artistes en cache: {}", stats.artists_count); - println!("Total: {} entrées", stats.total_count()); - - // Favoris - println!("\n--- Albums favoris ---"); - match client.get_favorite_albums().await { - Ok(favorites) => { - println!("✓ {} album(s) favori(s)", favorites.len()); - for (i, album) in favorites.iter().take(5).enumerate() { - println!(" {}. {} - {}", i + 1, album.artist.name, album.title); - } - if favorites.len() > 5 { - println!(" ... et {} autres", favorites.len() - 5); - } - } - Err(e) => { - println!("⚠ Impossible de récupérer les favoris: {}", e); - } - } - - println!("\n✓ Exemple terminé avec succès !"); - - Ok(()) -} -========= End of pmoqobuz/examples/basic_usage.rs =========== - -=============== pmoqobuz/examples/with_cache.rs ============ -//! Example demonstrating Qobuz with cache support -//! -//! This example shows how to use the QobuzSource with pmocovers -//! and pmoaudiocache to cache both cover images and audio tracks. -//! -//! Run with: -//! ```bash -//! cargo run --example with_cache --features cache -//! ``` - -use pmoaudiocache::AudioCache; -use pmocovers::Cache as CoverCache; -use pmoqobuz::{QobuzClient, QobuzSource}; -use pmosource::MusicSource; -use std::sync::Arc; - -#[tokio::main] -async fn main() -> Result<(), Box> { - // Initialize tracing - tracing_subscriber::fmt::init(); - - println!("🎵 Qobuz with Cache Support"); - println!("============================\n"); - - // Create the Qobuz client using configuration - println!("📡 Connecting to Qobuz..."); - let client = QobuzClient::from_config().await?; - println!("✅ Connected!\n"); - - // Initialize caches - println!("💾 Initializing caches..."); - let cover_cache = Arc::new(CoverCache::new("./cache/qobuz-covers", 500)?); - let audio_cache = Arc::new(AudioCache::new("./cache/qobuz-audio", 100)?); - println!("✅ Caches initialized!\n"); - - // Create the source with caching enabled - let source = QobuzSource::new_with_cache( - client, - "http://localhost:8080", - Some(cover_cache.clone()), - Some(audio_cache.clone()), - ); - - println!("📻 Source: {}", source.name()); - println!("🆔 ID: {}", source.id()); - println!("📝 Supports FIFO: {}\n", source.supports_fifo()); - - // Get user's favorite tracks - println!("🎧 Fetching your favorite tracks..."); - let favorite_tracks = source.client().get_favorite_tracks().await?; - - if favorite_tracks.is_empty() { - println!("⚠️ No favorite tracks found. Add some favorites on Qobuz first!"); - println!("\n💡 Tip: You can also search for tracks:"); - - // Example: Search for tracks - println!("\n🔍 Searching for 'Miles Davis'..."); - let search_results = source.client().search("Miles Davis", None).await?; - - if !search_results.tracks.is_empty() { - println!("\n📋 Found {} tracks:", search_results.tracks.len()); - for (i, track) in search_results.tracks.iter().enumerate().take(3) { - println!( - " {}. {} - {}", - i + 1, - track - .performer - .as_ref() - .map(|p| p.name.as_str()) - .unwrap_or("Unknown"), - track.title - ); - - // Demonstrate adding a track with caching - if i == 0 { - println!("\n➕ Adding first track to cache..."); - let track_id = source.add_track(track).await?; - println!("✅ Track added with ID: {}", track_id); - println!(" - Cover image caching started"); - println!(" - Audio caching started (high-quality FLAC)"); - - // Show resolved URI (will use cached version if available) - if let Ok(uri) = source.resolve_uri(&track_id).await { - println!(" - Stream URI: {}", uri); - } - } - } - } - } else { - println!("✅ Found {} favorite tracks!\n", favorite_tracks.len()); - - // Add first 3 favorite tracks with caching - for (i, track) in favorite_tracks.iter().enumerate().take(3) { - println!( - "{}. {} - {}", - i + 1, - track - .performer - .as_ref() - .map(|p| p.name.as_str()) - .unwrap_or("Unknown"), - track.title - ); - - if let Some(album) = &track.album { - println!(" Album: {}", album.title); - if let Some(label) = &album.label { - println!(" Label: {}", label); - } - if let Some(sample_rate) = album.maximum_sampling_rate { - println!(" Max Sample Rate: {} kHz", sample_rate / 1000.0); - } - if let Some(bit_depth) = album.maximum_bit_depth { - println!(" Max Bit Depth: {} bit", bit_depth); - } - } - - println!("\n ➕ Adding to cache..."); - match source.add_track(track).await { - Ok(track_id) => { - println!(" ✅ Track cached successfully!"); - - // Show resolved URI - if let Ok(uri) = source.resolve_uri(&track_id).await { - println!(" 📍 Stream URI: {}", uri); - } - } - Err(e) => { - println!(" ⚠️ Failed to cache track: {}", e); - } - } - println!(); - } - } - - // Browse favorite albums - println!("\n📚 Browsing your favorite albums..."); - let favorite_albums = source.client().get_favorite_albums().await?; - - if !favorite_albums.is_empty() { - println!("✅ Found {} favorite albums!\n", favorite_albums.len()); - - for (i, album) in favorite_albums.iter().enumerate().take(3) { - println!("{}. {} - {}", i + 1, album.artist.name, album.title); - if let Some(release_date) = &album.release_date { - println!(" Released: {}", release_date); - } - if let Some(tracks_count) = album.tracks_count { - println!(" Tracks: {}", tracks_count); - } - if !album.genres.is_empty() { - println!(" Genres: {}", album.genres.join(", ")); - } - } - } else { - println!("⚠️ No favorite albums found."); - } - - println!("\n✨ Example complete!"); - println!("\n💡 Tips:"); - println!(" - Run the example again to see faster loading from cache"); - println!(" - Check ./cache/qobuz-covers/ for cached cover images (WebP)"); - println!(" - Check ./cache/qobuz-audio/ for cached Hi-Res FLAC files"); - println!(" - Qobuz provides rich metadata (label, ISRC, sample rate, bit depth)"); - println!(" - Cached audio retains original quality (up to 24bit/192kHz)"); - - Ok(()) -} -========= End of pmoqobuz/examples/with_cache.rs =========== - -=============== pmoqobuz/examples/lazy_loading.rs ============ -//! Example demonstrating Qobuz lazy loading with rate limiting -//! -//! This example shows how to use the new lazy loading feature to add albums -//! to playlists without downloading all audio files immediately. Only covers -//! are downloaded eagerly, audio is downloaded on-demand when played. -//! -//! Features demonstrated: -//! - Rate limiting (max 2 concurrent requests, 400ms delay) -//! - Lazy audio loading (saves ~99% initial bandwidth) -//! - Eager cover loading (UI responsiveness) -//! - Automatic PK switching when audio is downloaded -//! - Prefetch of next 2 tracks during playback -//! -//! Run with: -//! ```bash -//! cargo run -p pmoqobuz --example lazy_loading -//! ``` - -use pmoaudiocache::Cache as AudioCache; -use pmocovers::Cache as CoverCache; -use pmoplaylist::PlaylistManager; -use pmoqobuz::{QobuzClient, QobuzSource}; -use std::sync::Arc; -use std::time::Instant; - -#[tokio::main] -async fn main() -> Result<(), Box> { - // Initialize tracing with debug level to see rate limiting - tracing_subscriber::fmt() - .with_max_level(tracing::Level::INFO) - .with_target(false) - .init(); - - println!("🎵 Qobuz Lazy Loading Demo"); - println!("============================\n"); - - // Step 1: Connect to Qobuz with rate limiting enabled - println!("📡 Connecting to Qobuz (rate limiting enabled)..."); - let client = QobuzClient::from_config().await?; - println!("✅ Connected with rate limiting:"); - println!(" - Max 2 concurrent requests"); - println!(" - 400ms minimum delay between requests\n"); - - // Step 2: Initialize caches - println!("💾 Initializing caches..."); - let cover_cache = Arc::new(CoverCache::new("./cache/qobuz-covers", 500)?); - let audio_cache = Arc::new(AudioCache::new("./cache/qobuz-audio", 100)?); - println!("✅ Caches initialized\n"); - - // Step 3: Create QobuzSource with caches - let source = QobuzSource::new(client, cover_cache.clone(), audio_cache.clone()); - - // Step 4: Get user's favorite albums - println!("🎧 Fetching your favorite albums..."); - let favorite_albums = source.client().get_favorite_albums().await?; - - if favorite_albums.is_empty() { - println!("⚠️ No favorite albums found!"); - println!(" Please add some albums to your Qobuz favorites first.\n"); - return Ok(()); - } - - println!("✅ Found {} favorite albums\n", favorite_albums.len()); - - // Step 5: Select first album for testing - let album = &favorite_albums[0]; - println!("📀 Selected album: {} - {}", album.artist.name, album.title); - println!(" Tracks: {}", album.tracks_count.unwrap_or(0)); - println!(" Album ID: {}\n", album.id); - - // Step 6: Create a test playlist - println!("📝 Creating test playlist..."); - let playlist_manager = PlaylistManager(); - let playlist_id = { - let writer = playlist_manager - .create_persistent_playlist("lazy-test".to_string()) - .await?; - writer.id().to_string() - }; // Drop writer here to release the lock - println!("✅ Playlist created: {}\n", playlist_id); - - // Step 7: Add album with lazy loading (measure time and track downloads) - println!("⏱️ Adding album to playlist with LAZY loading..."); - println!(" This will:"); - println!(" - Download covers immediately (~400 KB each)"); - println!(" - Create lazy PKs for audio (NO download)"); - println!(" - Enable prefetch for next 2 tracks\n"); - - let start = Instant::now(); - let count = source - .add_album_to_playlist(&playlist_id, &album.id) - .await?; - let elapsed = start.elapsed(); - - println!("✅ Album added: {} tracks in {:.2}s", count, elapsed.as_secs_f64()); - println!(" Average: {:.0}ms per track\n", elapsed.as_millis() as f64 / count as f64); - - // Step 8: Verify lazy PKs - println!("🔍 Verifying lazy PKs..."); - let reader = playlist_manager.get_read_handle(&playlist_id).await?; - - // Read all tracks from playlist - let mut tracks = Vec::new(); - loop { - match reader.peek().await? { - Some(track) => { - tracks.push(track); - reader.pop().await?; - } - None => break, - } - } - - if tracks.is_empty() { - println!("⚠️ No tracks in playlist!"); - return Ok(()); - } - - let first_track_pk = tracks[0].cache_pk(); - let is_lazy = pmocache::is_lazy_pk(&first_track_pk); - - println!(" First track PK: {}", first_track_pk); - println!(" Is lazy: {}", if is_lazy { "✅ YES (starts with 'L:')" } else { "❌ NO" }); - - // Count lazy vs downloaded - let lazy_count = tracks.iter().filter(|t| pmocache::is_lazy_pk(t.cache_pk())).count(); - let downloaded_count = tracks.len() - lazy_count; - - println!("\n📊 Track status:"); - println!(" Lazy (not downloaded): {} tracks", lazy_count); - println!(" Downloaded: {} tracks", downloaded_count); - - // Step 9: Check cache sizes - println!("\n💾 Cache disk usage:"); - println!(" Covers: {:?}", get_dir_size("./cache/qobuz-covers")?); - println!(" Audio: {:?}", get_dir_size("./cache/qobuz-audio")?); - - // Step 10: Demonstrate on-demand download - if is_lazy { - println!("\n🎵 Simulating playback of first track..."); - println!(" This would trigger download via HTTP request to:"); - println!(" GET /cache/flac/{}", first_track_pk); - println!("\n The lazy PK will automatically:"); - println!(" 1. Download the audio file from Qobuz"); - println!(" 2. Convert to FLAC"); - println!(" 3. Calculate real PK from content"); - println!(" 4. Update playlist (lazy_pk → real_pk)"); - println!(" 5. Prefetch next 2 tracks in background"); - } - - // Step 11: Summary - println!("\n╭─────────────────────────────────────────╮"); - println!("│ 🎉 Lazy Loading Demo Complete! │"); - println!("╰─────────────────────────────────────────╯"); - println!("\n📈 Benefits demonstrated:"); - println!(" ✓ Fast album loading (~{}ms per track)", elapsed.as_millis() / count as u128); - println!(" ✓ Minimal initial download (covers only)"); - println!(" ✓ Audio downloaded on-demand"); - println!(" ✓ Rate limiting active (respectful to Qobuz)"); - println!(" ✓ Automatic prefetching during playback"); - - println!("\n💡 For 375 favorite albums (~3750 tracks):"); - println!(" Without lazy: ~15 GB download, ~75s (no rate limit)"); - println!(" With lazy: ~150 MB download, ~5 min (rate limited)"); - println!(" Savings: ~99% bandwidth, natural request pattern"); - - Ok(()) -} - -/// Calculate directory size recursively -fn get_dir_size(path: &str) -> Result> { - use std::fs; - - let mut total: u64 = 0; - - if let Ok(entries) = fs::read_dir(path) { - for entry in entries.flatten() { - if let Ok(metadata) = entry.metadata() { - if metadata.is_file() { - total += metadata.len(); - } else if metadata.is_dir() { - if let Ok(size_str) = get_dir_size(&entry.path().to_string_lossy()) { - // Parse size from string (hacky but works for this example) - if let Some(num) = size_str.split_whitespace().next() { - if let Ok(size) = num.parse::() { - total += (size * 1024.0 * 1024.0) as u64; - } - } - } - } - } - } - } - - Ok(format_size(total)) -} - -/// Format bytes to human-readable size -fn format_size(bytes: u64) -> String { - const KB: u64 = 1024; - const MB: u64 = KB * 1024; - const GB: u64 = MB * 1024; - - if bytes >= GB { - format!("{:.2} GB", bytes as f64 / GB as f64) - } else if bytes >= MB { - format!("{:.2} MB", bytes as f64 / MB as f64) - } else if bytes >= KB { - format!("{:.2} KB", bytes as f64 / KB as f64) - } else { - format!("{} B", bytes) - } -} -========= End of pmoqobuz/examples/lazy_loading.rs =========== - -=============== pmoqobuz/examples/show_source_image.rs ============ -//! Example showing how to access and save the Qobuz source image -//! -//! This example demonstrates: -//! - Getting source information via the MusicSource trait -//! - Accessing the embedded WebP image -//! - Optionally saving it to a file - -use pmoqobuz::{QobuzClient, QobuzSource}; -use pmosource::MusicSource; -use std::fs; -use std::io::Write; - -#[tokio::main] -async fn main() -> Result<(), Box> { - // Create the client and source - let client = QobuzClient::from_config().await?; - let source = QobuzSource::new(client, "http://localhost:8080"); - - // Display source information - println!("Music Source Information"); - println!("========================"); - println!("Name: {}", source.name()); - println!("ID: {}", source.id()); - println!("Image MIME type: {}", source.default_image_mime_type()); - - // Get the embedded image - let image_data = source.default_image(); - println!("Embedded image size: {} bytes", image_data.len()); - - // Verify WebP format - if image_data.len() >= 12 { - let is_webp = &image_data[0..4] == b"RIFF" && &image_data[8..12] == b"WEBP"; - println!("Valid WebP format: {}", is_webp); - } - - // Optional: save to file - if std::env::args().any(|arg| arg == "--save") { - let filename = format!("{}_default.webp", source.id()); - let mut file = fs::File::create(&filename)?; - file.write_all(image_data)?; - println!("\nImage saved to: {}", filename); - println!("You can view it with: open {}", filename); - } else { - println!("\nTo save the image to disk, run with: --save"); - } - - Ok(()) -} -========= End of pmoqobuz/examples/show_source_image.rs =========== - -=============== pmoqobuz/examples/config_usage.rs ============ -//! Exemple d'utilisation du trait QobuzConfigExt -//! -//! Cet exemple montre comment utiliser le trait d'extension pour gérer -//! les credentials Qobuz via pmoconfig. -//! -//! Usage: -//! ```bash -//! cargo run --example config_usage -//! ``` - -use pmoconfig::get_config; -use pmoqobuz::QobuzConfigExt; - -fn main() -> anyhow::Result<()> { - // Initialiser le logging - tracing_subscriber::fmt::init(); - - println!("=== QobuzConfigExt Example ===\n"); - - // Récupérer la configuration globale - let config = get_config(); - - // Exemple 1: Lire les credentials existants - println!("--- Lecture des credentials ---"); - match config.get_qobuz_credentials() { - Ok((username, password)) => { - println!("Username: {}", username); - println!("Password: {}", "*".repeat(password.len())); - } - Err(e) => { - println!("Credentials non configurés: {}", e); - } - } - - // Exemple 2: Lire username et password séparément - println!("\n--- Lecture séparée ---"); - match config.get_qobuz_username() { - Ok(username) => println!("Username: {}", username), - Err(e) => println!("Username non configuré: {}", e), - } - - match config.get_qobuz_password() { - Ok(password) => println!("Password: {}", "*".repeat(password.len())), - Err(e) => println!("Password non configuré: {}", e), - } - - // Exemple 3: Définir de nouveaux credentials (commenté pour ne pas modifier la config) - /* - println!("\n--- Définition de nouveaux credentials ---"); - config.set_qobuz_username("user@example.com")?; - config.set_qobuz_password("my_secure_password")?; - println!("Nouveaux credentials enregistrés !"); - */ - - // Exemple 4: Utilisation avec QobuzClient - println!("\n--- Utilisation avec QobuzClient ---"); - println!("Pour créer un client Qobuz à partir de la config:"); - println!(" let client = QobuzClient::from_config().await?;"); - println!("\nCette méthode utilise automatiquement QobuzConfigExt"); - println!("pour récupérer les credentials depuis pmoconfig."); - - Ok(()) -} -========= End of pmoqobuz/examples/config_usage.rs =========== - -=============== pmoqobuz/DISK_CACHE_USAGE.md ============ -# Utilisation du cache disque pour favoris/bibliothèque - -## Intégration dans QobuzClient - -### Étape 1 : Ajouter le cache disque au client - -```rust -// Dans src/client.rs - -use crate::disk_cache::DiskCache; - -pub struct QobuzClient { - api: QobuzApi, - cache: Arc, // Cache mémoire (existant) - disk_cache: Arc, // Cache disque (nouveau) - auth_info: Option, -} - -impl QobuzClient { - pub async fn from_config_obj(config: &Config) -> Result { - // ... code existant ... - - // Créer le cache disque (utilise le répertoire configuré) - let disk_cache_dir = config.get_qobuz_cache_dir()?; - let disk_cache = Arc::new(DiskCache::new(disk_cache_dir)?); - - Ok(Self { - api, - cache: Arc::new(QobuzCache::new()), - disk_cache, - auth_info: Some(auth_info), - }) - } -} -``` - -### Étape 2 : Utiliser le cache pour get_favorite_albums - -```rust -// Dans src/client.rs - -impl QobuzClient { - /// Récupère les albums favoris (avec cache disque) - pub async fn get_favorite_albums(&self) -> Result> { - let user_id = self.auth_info - .as_ref() - .map(|a| &a.user_id) - .ok_or_else(|| QobuzError::Unauthorized("Not authenticated".to_string()))?; - - let cache_key = format!("favorites_albums_{}", user_id); - - // 1. Essayer de charger depuis le cache disque (TTL: 1 heure) - if let Ok(Some(albums)) = self.disk_cache.load_with_ttl::>( - &cache_key, - Duration::from_secs(3600) - ) { - info!("✓ Loaded {} favorite albums from disk cache", albums.len()); - return Ok(albums); - } - - // 2. Sinon, requête API - info!("Fetching favorite albums from API..."); - let albums = self.api.get_favorite_albums().await?; - - // 3. Sauvegarder dans le cache disque - if let Err(e) = self.disk_cache.save(&cache_key, &albums) { - debug!("Failed to save favorites to disk cache: {}", e); - } else { - info!("✓ Saved {} favorite albums to disk cache", albums.len()); - } - - Ok(albums) - } - - /// Récupère les tracks favoris (avec cache disque) - pub async fn get_favorite_tracks(&self) -> Result> { - let user_id = self.auth_info - .as_ref() - .map(|a| &a.user_id) - .ok_or_else(|| QobuzError::Unauthorized("Not authenticated".to_string()))?; - - let cache_key = format!("favorites_tracks_{}", user_id); - - // 1. Cache disque (TTL: 1 heure) - if let Ok(Some(tracks)) = self.disk_cache.load_with_ttl::>( - &cache_key, - Duration::from_secs(3600) - ) { - info!("✓ Loaded {} favorite tracks from disk cache", tracks.len()); - return Ok(tracks); - } - - // 2. API - info!("Fetching favorite tracks from API..."); - let tracks = self.api.get_favorite_tracks().await?; - - // 3. Sauvegarder - if let Err(e) = self.disk_cache.save(&cache_key, &tracks) { - debug!("Failed to save favorites to disk cache: {}", e); - } else { - info!("✓ Saved {} favorite tracks to disk cache", tracks.len()); - } - - Ok(tracks) - } - - /// Récupère les playlists (avec cache disque) - pub async fn get_user_playlists(&self) -> Result> { - let user_id = self.auth_info - .as_ref() - .map(|a| &a.user_id) - .ok_or_else(|| QobuzError::Unauthorized("Not authenticated".to_string()))?; - - let cache_key = format!("playlists_{}", user_id); - - // 1. Cache disque (TTL: 30 minutes - les playlists changent plus souvent) - if let Ok(Some(playlists)) = self.disk_cache.load_with_ttl::>( - &cache_key, - Duration::from_secs(1800) - ) { - info!("✓ Loaded {} playlists from disk cache", playlists.len()); - return Ok(playlists); - } - - // 2. API - info!("Fetching playlists from API..."); - let playlists = self.api.get_user_playlists().await?; - - // 3. Sauvegarder - if let Err(e) = self.disk_cache.save(&cache_key, &playlists) { - debug!("Failed to save playlists to disk cache: {}", e); - } else { - info!("✓ Saved {} playlists to disk cache", playlists.len()); - } - - Ok(playlists) - } - - /// Invalide le cache des favoris (après ajout/suppression) - pub async fn invalidate_favorites_cache(&self) -> Result<()> { - let user_id = self.auth_info - .as_ref() - .map(|a| &a.user_id) - .ok_or_else(|| QobuzError::Unauthorized("Not authenticated".to_string()))?; - - self.disk_cache.invalidate(&format!("favorites_albums_{}", user_id))?; - self.disk_cache.invalidate(&format!("favorites_tracks_{}", user_id))?; - self.disk_cache.invalidate(&format!("playlists_{}", user_id))?; - - info!("✓ Invalidated favorites cache"); - Ok(()) - } -} -``` - -### Étape 3 : Méthodes utilitaires - -```rust -impl QobuzClient { - /// Retourne des statistiques sur le cache disque - pub fn disk_cache_stats(&self) -> Result<(usize, u64)> { - let count = self.disk_cache.count()?; - let size = self.disk_cache.size()?; - Ok((count, size)) - } - - /// Vide complètement le cache disque - pub fn clear_disk_cache(&self) -> Result<()> { - self.disk_cache.clear_all() - } -} -``` - -## Structure sur disque - -``` -.pmomusic/ -├── config.yaml -└── cache/ - └── qobuz/ - ├── favorites_albums_1217710.json # 375 albums (~200 KB) - ├── favorites_tracks_1217710.json # Tracks favoris - └── playlists_1217710.json # Playlists utilisateur -``` - -## Bénéfices - -### Sans cache disque (AVANT) -```bash -# Lancement 1 -INFO Fetching 375 favorite albums from API... (2.5s) - -# Lancement 2 (app redémarrée) -INFO Fetching 375 favorite albums from API... (2.5s) ← Requête inutile ! - -# Lancement 3 -INFO Fetching 375 favorite albums from API... (2.5s) ← Requête inutile ! -``` - -**Total** : 3 requêtes API × 2.5s = **7.5 secondes** - -### Avec cache disque (APRÈS) -```bash -# Lancement 1 (cache miss) -INFO Fetching 375 favorite albums from API... (2.5s) -INFO ✓ Saved 375 favorite albums to disk cache - -# Lancement 2 (cache hit!) -INFO ✓ Loaded 375 favorite albums from disk cache (5ms) ← Instantané ! - -# Lancement 3 (cache hit!) -INFO ✓ Loaded 375 favorite albums from disk cache (5ms) ← Instantané ! -``` - -**Total** : 1 requête API × 2.5s + 2 cache hits × 5ms = **2.51 secondes** - -**Amélioration** : **66% plus rapide** + réduction de **66% des requêtes API** - -## TTL recommandés - -| Donnée | TTL | Justification | -|--------|-----|---------------| -| Albums favoris | 1h | Changent rarement | -| Tracks favoris | 1h | Changent rarement | -| Playlists | 30min | Modifiées plus souvent | -| Bibliothèque complète | 24h | Très volumineuse, change peu | - -## Invalidation intelligente - -Invalider le cache après modifications : - -```rust -// Après ajout d'un favori -client.add_favorite_album("123").await?; -client.invalidate_favorites_cache().await?; - -// Après suppression -client.remove_favorite_album("123").await?; -client.invalidate_favorites_cache().await?; -``` - -## Tests - -```bash -# Test du cache disque -cargo test -p pmoqobuz disk_cache - -# Test d'intégration -cargo run --example basic_usage - -# Logs détaillés -RUST_LOG=info,pmoqobuz::disk_cache=debug cargo run --example basic_usage -``` - -## Migration - -Pour ajouter le cache disque au client existant : - -1. Ajouter le champ `disk_cache` à `QobuzClient` -2. Initialiser dans `from_config_obj()` -3. Modifier `get_favorite_albums()`, `get_favorite_tracks()`, etc. -4. Tester avec des gros catalogues (375+ albums) - -## Taille estimée du cache - -Pour un utilisateur avec : -- 375 albums favoris -- 100 tracks favoris -- 10 playlists - -**Taille totale** : ~300 KB (négligeable) - -## Comparaison : pmocache vs DiskCache - -| Critère | pmocache | DiskCache | -|---------|----------|-----------| -| **Complexité** | Élevée (SQLite, download, variants) | Faible (fichiers JSON simples) | -| **Taille overhead** | ~100 KB (SQLite + tables) | 0 (juste les JSON) | -| **Performance** | Excellent pour binaires | Excellent pour JSON | -| **Maintenance** | Complexe | Simple | -| **Adapté pour JSON** | ❌ Non | ✅ Oui | - -**Conclusion** : `DiskCache` est **parfaitement adapté** pour le cache de favoris/bibliothèque. -========= End of pmoqobuz/DISK_CACHE_USAGE.md =========== - -=============== pmoqobuz/src/cache.rs ============ -//! Système de cache en mémoire pour les données Qobuz -//! -//! Ce module fournit un cache en mémoire avec TTL pour minimiser les requêtes à l'API Qobuz. - -use crate::models::{Album, Artist, Playlist, SearchResult, StreamInfo, Track}; -use moka::future::Cache as MokaCache; -use std::sync::Arc; -use std::time::Duration; - -/// Cache principal pour les données Qobuz -#[derive(Clone)] -pub struct QobuzCache { - /// Cache des albums (TTL: 1 heure) - albums: Arc>, - /// Cache des tracks (TTL: 1 heure) - tracks: Arc>, - /// Cache des artistes (TTL: 1 heure) - artists: Arc>, - /// Cache des playlists (TTL: 30 minutes) - playlists: Arc>, - /// Cache des résultats de recherche (TTL: 15 minutes) - searches: Arc>, - /// Cache des URLs de streaming (TTL: 5 minutes) - stream_urls: Arc>, -} - -impl QobuzCache { - /// Crée un nouveau cache avec les paramètres par défaut - pub fn new() -> Self { - Self::with_capacity(1000) - } - - /// Crée un nouveau cache avec une capacité spécifique - pub fn with_capacity(max_capacity: u64) -> Self { - Self { - albums: Arc::new( - MokaCache::builder() - .max_capacity(max_capacity) - .time_to_live(Duration::from_secs(3600)) // 1 heure - .build(), - ), - tracks: Arc::new( - MokaCache::builder() - .max_capacity(max_capacity * 2) - .time_to_live(Duration::from_secs(3600)) // 1 heure - .build(), - ), - artists: Arc::new( - MokaCache::builder() - .max_capacity(max_capacity / 2) - .time_to_live(Duration::from_secs(3600)) // 1 heure - .build(), - ), - playlists: Arc::new( - MokaCache::builder() - .max_capacity(max_capacity / 4) - .time_to_live(Duration::from_secs(1800)) // 30 minutes - .build(), - ), - searches: Arc::new( - MokaCache::builder() - .max_capacity(max_capacity / 2) - .time_to_live(Duration::from_secs(900)) // 15 minutes - .build(), - ), - stream_urls: Arc::new( - MokaCache::builder() - .max_capacity(max_capacity / 4) - .time_to_live(Duration::from_secs(300)) // 5 minutes - .build(), - ), - } - } - - // ============ Albums ============ - - /// Récupère un album depuis le cache - pub async fn get_album(&self, id: &str) -> Option { - self.albums.get(id).await - } - - /// Ajoute un album au cache - pub async fn put_album(&self, id: String, album: Album) { - self.albums.insert(id, album).await; - } - - /// Invalide un album du cache - pub async fn invalidate_album(&self, id: &str) { - self.albums.invalidate(id).await; - } - - // ============ Tracks ============ - - /// Récupère une track depuis le cache - pub async fn get_track(&self, id: &str) -> Option { - self.tracks.get(id).await - } - - /// Ajoute une track au cache - pub async fn put_track(&self, id: String, track: Track) { - self.tracks.insert(id, track).await; - } - - /// Invalide une track du cache - pub async fn invalidate_track(&self, id: &str) { - self.tracks.invalidate(id).await; - } - - // ============ Artists ============ - - /// Récupère un artiste depuis le cache - pub async fn get_artist(&self, id: &str) -> Option { - self.artists.get(id).await - } - - /// Ajoute un artiste au cache - pub async fn put_artist(&self, id: String, artist: Artist) { - self.artists.insert(id, artist).await; - } - - /// Invalide un artiste du cache - pub async fn invalidate_artist(&self, id: &str) { - self.artists.invalidate(id).await; - } - - // ============ Playlists ============ - - /// Récupère une playlist depuis le cache - pub async fn get_playlist(&self, id: &str) -> Option { - self.playlists.get(id).await - } - - /// Ajoute une playlist au cache - pub async fn put_playlist(&self, id: String, playlist: Playlist) { - self.playlists.insert(id, playlist).await; - } - - /// Invalide une playlist du cache - pub async fn invalidate_playlist(&self, id: &str) { - self.playlists.invalidate(id).await; - } - - // ============ Recherches ============ - - /// Récupère un résultat de recherche depuis le cache - pub async fn get_search(&self, query: &str) -> Option { - self.searches.get(query).await - } - - /// Ajoute un résultat de recherche au cache - pub async fn put_search(&self, query: String, result: SearchResult) { - self.searches.insert(query, result).await; - } - - /// Invalide un résultat de recherche du cache - pub async fn invalidate_search(&self, query: &str) { - self.searches.invalidate(query).await; - } - - // ============ URLs de streaming ============ - - /// Récupère une URL de streaming depuis le cache - pub async fn get_stream_url(&self, track_id: &str) -> Option { - self.stream_urls.get(track_id).await - } - - /// Ajoute une URL de streaming au cache - pub async fn put_stream_url(&self, track_id: String, info: StreamInfo) { - self.stream_urls.insert(track_id, info).await; - } - - /// Invalide une URL de streaming du cache - pub async fn invalidate_stream_url(&self, track_id: &str) { - self.stream_urls.invalidate(track_id).await; - } - - // ============ Maintenance ============ - - /// Vide tous les caches - pub async fn clear_all(&self) { - self.albums.invalidate_all(); - self.tracks.invalidate_all(); - self.artists.invalidate_all(); - self.playlists.invalidate_all(); - self.searches.invalidate_all(); - self.stream_urls.invalidate_all(); - } - - /// Retourne des statistiques sur le cache - pub async fn stats(&self) -> CacheStats { - CacheStats { - albums_count: self.albums.entry_count(), - tracks_count: self.tracks.entry_count(), - artists_count: self.artists.entry_count(), - playlists_count: self.playlists.entry_count(), - searches_count: self.searches.entry_count(), - stream_urls_count: self.stream_urls.entry_count(), - } - } -} - -impl Default for QobuzCache { - fn default() -> Self { - Self::new() - } -} - -/// Statistiques du cache -#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] -pub struct CacheStats { - /// Nombre d'albums en cache - pub albums_count: u64, - /// Nombre de tracks en cache - pub tracks_count: u64, - /// Nombre d'artistes en cache - pub artists_count: u64, - /// Nombre de playlists en cache - pub playlists_count: u64, - /// Nombre de recherches en cache - pub searches_count: u64, - /// Nombre d'URLs de streaming en cache - pub stream_urls_count: u64, -} - -impl CacheStats { - /// Retourne le nombre total d'entrées en cache - pub fn total_count(&self) -> u64 { - self.albums_count - + self.tracks_count - + self.artists_count - + self.playlists_count - + self.searches_count - + self.stream_urls_count - } -} - -#[cfg(test)] -mod tests { - use super::*; - use crate::models::Artist; - - #[tokio::test] - async fn test_cache_basic_operations() { - let cache = QobuzCache::new(); - - let artist = Artist::new("123", "Test Artist"); - - // Test insertion - cache.put_artist("123".to_string(), artist.clone()).await; - - // Test récupération - let retrieved = cache.get_artist("123").await; - assert!(retrieved.is_some()); - assert_eq!(retrieved.unwrap().name, "Test Artist"); - - // Test invalidation - cache.invalidate_artist("123").await; - let after_invalidation = cache.get_artist("123").await; - assert!(after_invalidation.is_none()); - } - - #[tokio::test] - async fn test_cache_stats() { - let cache = QobuzCache::new(); - - let artist = Artist::new("123", "Test Artist"); - cache.put_artist("123".to_string(), artist).await; - - let stats = cache.stats().await; - assert_eq!(stats.artists_count, 1); - assert_eq!(stats.albums_count, 0); - } - - #[tokio::test] - async fn test_cache_clear_all() { - let cache = QobuzCache::new(); - - let artist = Artist::new("123", "Test Artist"); - cache.put_artist("123".to_string(), artist).await; - - cache.clear_all().await; - - let stats = cache.stats().await; - assert_eq!(stats.total_count(), 0); - } -} -========= End of pmoqobuz/src/cache.rs =========== - -=============== pmoqobuz/src/client.rs ============ -//! Client principal pour interagir avec l'API Qobuz -//! -//! Ce module fournit un client haut-niveau avec authentification et cache intégré. - -use crate::api::auth::AuthInfo; -use crate::api::{QobuzApi, DEFAULT_APP_ID}; -use crate::cache::QobuzCache; -use crate::config_ext::QobuzConfigExt; -use crate::error::{QobuzError, Result}; -use crate::models::*; -use pmoconfig::Config; -use std::sync::Arc; -use tracing::{debug, info}; - -/// Client Qobuz haut-niveau avec cache -pub struct QobuzClient { - /// API bas-niveau - api: QobuzApi, - /// Cache en mémoire - cache: Arc, - /// Informations d'authentification - auth_info: Option, -} - -impl QobuzClient { - /// Crée un nouveau client et authentifie avec les credentials fournis - /// - /// # Arguments - /// - /// * `username` - Email ou nom d'utilisateur Qobuz - /// * `password` - Mot de passe - /// - /// # Exemple - /// - /// ```rust,no_run - /// use pmoqobuz::QobuzClient; - /// - /// #[tokio::main] - /// async fn main() -> anyhow::Result<()> { - /// let client = QobuzClient::new("user@example.com", "password").await?; - /// Ok(()) - /// } - /// ``` - pub async fn new(username: &str, password: &str) -> Result { - Self::with_app_id(DEFAULT_APP_ID, username, password).await - } - - /// Crée un nouveau client avec un App ID personnalisé - pub async fn with_app_id(app_id: &str, username: &str, password: &str) -> Result { - info!("Creating Qobuz client with app ID: {}", app_id); - - let mut api = QobuzApi::new(app_id)?; - let auth_info = api.login(username, password).await?; - - Ok(Self { - api, - cache: Arc::new(QobuzCache::new()), - auth_info: Some(auth_info), - }) - } - - /// Crée un client en utilisant la configuration de pmoconfig - /// - /// # Exemple - /// - /// ```rust,no_run - /// use pmoqobuz::QobuzClient; - /// - /// #[tokio::main] - /// async fn main() -> anyhow::Result<()> { - /// let client = QobuzClient::from_config().await?; - /// Ok(()) - /// } - /// ``` - pub async fn from_config() -> Result { - let config = pmoconfig::get_config(); - Self::from_config_obj(config.as_ref()).await - } - - /// Configure le rate limiting sur une API depuis la configuration - /// - /// # Arguments - /// - /// * `api` - L'API Qobuz à configurer - /// * `config` - La configuration contenant les paramètres de rate limiting - fn configure_rate_limiting(api: &mut QobuzApi, config: &Config) { - let rate_limit_enabled = config.is_qobuz_rate_limiting_enabled(); - if rate_limit_enabled { - let max_concurrent = config.get_qobuz_rate_limit_max_concurrent() - .ok() - .flatten() - .unwrap_or(2); - let min_delay = config.get_qobuz_rate_limit_min_delay_ms() - .ok() - .flatten() - .unwrap_or(400); - - info!( - "Enabling Qobuz rate limiting: {} concurrent, {}ms delay", - max_concurrent, min_delay - ); - api.enable_rate_limiting(max_concurrent, min_delay); - } else { - debug!("Qobuz rate limiting disabled in configuration"); - } - } - - /// Crée un client depuis un objet Config spécifique - /// - /// Cette méthode récupère les credentials, l'App ID et optionnellement - /// le secret depuis la configuration. - /// - /// Ordre de priorité pour l'initialisation : - /// 0. **Vérifier le cache du token d'authentification** (évite un login si token valide) - /// 1. Si `appid` ET `secret` configurés → teste d'abord avec ces credentials - /// 2. Si échec d'authentification → utilise le Spoofer pour obtenir de nouveaux credentials - /// 3. Si aucun `appid`/`secret` configuré → utilise directement le Spoofer - /// 4. Fallback ultime → utilise DEFAULT_APP_ID sans secret (requêtes signées échoueront) - pub async fn from_config_obj(config: &Config) -> Result { - let (username, password) = config.get_qobuz_credentials()?; - - // Étape 0 : Essayer de réutiliser le token stocké dans la configuration - // DÉSACTIVÉ TEMPORAIREMENT : Le secret peut être obsolète même si le token est valide. - // Le login est nécessaire pour valider les credentials (app_id) et déclencher le - // Spoofer si besoin. Si le login échoue avec une erreur d'auth, le Spoofer sera - // automatiquement utilisé pour obtenir de nouveaux credentials. - // - // TODO: Implémenter un retry intelligent dans get_stream_url() qui détecte les - // erreurs de signature et rafraîchit automatiquement les credentials via Spoofer. - // Cela permettrait de réactiver la réutilisation du token sans risque. - /* - if let (Ok(Some(token)), Ok(Some(user_id))) = - (config.get_qobuz_auth_token(), config.get_qobuz_user_id()) - { - info!("✓ Found stored authentication token in configuration"); - - // Récupérer l'App ID et le secret depuis la config pour créer l'API - let config_appid = config.get_qobuz_appid()?; - let config_secret = config.get_qobuz_secret()?; - - match (config_appid, config_secret) { - (Some(app_id), Some(secret)) => match QobuzApi::with_secret(&app_id, &secret) { - Ok(mut api) => { - // Configure rate limiting - Self::configure_rate_limiting(&mut api, config); - - // Réutiliser le token de la configuration - api.set_auth_token(token.clone(), user_id.clone()); - - info!("✓ Reusing authentication token (no login required)"); - info!(" → Token will be validated on first API request"); - - let auth_info = AuthInfo { - token, - user_id, - subscription_label: config.get_qobuz_subscription_label().ok().flatten(), - }; - - return Ok(Self { - api, - cache: Arc::new(QobuzCache::new()), - auth_info: Some(auth_info), - }); - } - Err(e) => { - debug!("Failed to create API with stored credentials: {}", e); - info!("→ Credentials in config are invalid, will perform login"); - // Continuer vers le login normal - } - }, - _ => { - debug!("No appid/secret in config, cannot reuse token"); - info!("→ Missing AppID/secret, will perform login"); - // Continuer vers le login normal - } - } - } else { - debug!("No stored authentication token found in configuration, will perform login"); - } - */ - - info!("Performing login to validate credentials and obtain fresh token"); - - // Récupérer l'App ID et le secret depuis la config - let config_appid = config.get_qobuz_appid()?; - let config_secret = config.get_qobuz_secret()?; - - // Déterminer comment créer l'API - let mut api = match (config_appid, config_secret) { - // Cas 1: AppID ET secret configurés → test avec authentification - (Some(app_id), Some(secret)) => { - info!( - "Creating Qobuz API with configured App ID: {} and secret", - app_id - ); - - match QobuzApi::with_secret(&app_id, &secret) { - Ok(mut test_api) => { - // Configure rate limiting - Self::configure_rate_limiting(&mut test_api, config); - - // Tenter l'authentification pour valider les credentials - debug!("Testing configured credentials with login..."); - match test_api.login(&username, &password).await { - Ok(auth_info) => { - info!("✓ Configured credentials are valid"); - - // Sauvegarder le token dans la configuration - use std::time::{SystemTime, UNIX_EPOCH, Duration}; - let expires_at = SystemTime::now() - .duration_since(UNIX_EPOCH) - .unwrap() - .as_secs() - + Duration::from_secs(24 * 3600).as_secs(); // 24h - - if let Err(e) = config.set_qobuz_auth_info( - &auth_info.token, - &auth_info.user_id, - auth_info.subscription_label.as_deref(), - expires_at, - ) { - debug!("Failed to save authentication to config: {}", e); - } else { - info!("✓ Saved authentication token to configuration"); - } - - // Les credentials sont valides, retourner directement - return Ok(Self { - api: test_api, - cache: Arc::new(QobuzCache::new()), - auth_info: Some(auth_info), - }); - } - Err(e) if e.is_auth_error() => { - info!("✗ Configured credentials failed authentication: {}", e); - info!("→ Falling back to Spoofer to obtain new credentials..."); - // Continuer vers le Spoofer (voir après le match) - } - Err(e) => { - // Autre erreur (réseau, etc.) → propager - return Err(e); - } - } - } - Err(e) => { - info!("✗ Failed to create API with configured credentials: {}", e); - info!("→ Falling back to Spoofer..."); - // Continuer vers le Spoofer - } - } - - // Si on arrive ici, les credentials configurés ont échoué - // → Appel du Spoofer - Self::try_spoofer_fallback(config).await? - } - - // Cas 2: Aucun ou seulement l'un des deux → utiliser directement le Spoofer - _ => { - info!("AppID or secret not configured, using Spoofer to obtain valid credentials..."); - Self::try_spoofer_fallback(config).await? - } - }; - - // Configure rate limiting - Self::configure_rate_limiting(&mut api, config); - - // Authentifier l'utilisateur - let auth_info = api.login(&username, &password).await?; - - // Sauvegarder le token dans la configuration pour éviter de re-login la prochaine fois - use std::time::{Duration, SystemTime, UNIX_EPOCH}; - let expires_at = SystemTime::now() - .duration_since(UNIX_EPOCH) - .unwrap() - .as_secs() - + Duration::from_secs(24 * 3600).as_secs(); // 24h - - if let Err(e) = config.set_qobuz_auth_info( - &auth_info.token, - &auth_info.user_id, - auth_info.subscription_label.as_deref(), - expires_at, - ) { - debug!("Failed to save authentication to config: {}", e); - } else { - info!("✓ Saved authentication token to configuration"); - } - - Ok(Self { - api, - cache: Arc::new(QobuzCache::new()), - auth_info: Some(auth_info), - }) - } - - /// Tente d'utiliser le Spoofer pour obtenir des credentials valides - /// - /// Cette méthode est appelée soit : - /// - Quand aucun appid/secret n'est configuré - /// - Quand les credentials configurés sont invalides/expirés - async fn try_spoofer_fallback(config: &Config) -> Result { - match crate::api::Spoofer::new().await { - Ok(spoofer) => { - match spoofer.get_app_id() { - Ok(app_id) => { - info!("Spoofer found App ID: {}", app_id); - - match spoofer.get_secrets() { - Ok(secrets) => { - info!("Spoofer found {} secret(s), testing them...", secrets.len()); - - // Tester chaque secret pour trouver celui qui fonctionne - for (timezone, secret) in secrets.iter() { - debug!("Testing secret for timezone: {}", timezone); - - match QobuzApi::with_secret(&app_id, secret) { - Ok(test_api) => { - info!("✓ Successfully created API with secret from timezone: {}", timezone); - - // Sauvegarder les credentials valides dans la config - if let Err(e) = config.set_qobuz_appid(&app_id) { - debug!("Could not save appid to config: {}", e); - } - if let Err(e) = config.set_qobuz_secret(secret) { - debug!("Could not save secret to config: {}", e); - } - - return Ok(test_api); - } - Err(e) => { - debug!("Failed to create API with secret from {}: {}", timezone, e); - continue; - } - } - } - - // Si aucun secret n'a fonctionné, utiliser le fallback - info!("✗ No valid secret found from Spoofer, falling back to DEFAULT_APP_ID without secret"); - QobuzApi::new(DEFAULT_APP_ID) - } - Err(e) => { - info!("Spoofer failed to extract secrets: {}, falling back to DEFAULT_APP_ID", e); - QobuzApi::new(DEFAULT_APP_ID) - } - } - } - Err(e) => { - info!("Spoofer failed to extract app_id: {}, falling back to DEFAULT_APP_ID", e); - QobuzApi::new(DEFAULT_APP_ID) - } - } - } - Err(e) => { - info!("Spoofer failed: {}, falling back to DEFAULT_APP_ID without secret", e); - QobuzApi::new(DEFAULT_APP_ID) - } - } - } - - /// Définit le format audio par défaut - pub fn set_format(&mut self, format: AudioFormat) { - self.api.set_format(format); - } - - /// Retourne le format audio configuré - pub fn format(&self) -> AudioFormat { - self.api.format() - } - - /// Retourne les informations d'authentification - pub fn auth_info(&self) -> Option<&AuthInfo> { - self.auth_info.as_ref() - } - - /// Retourne une référence au cache - pub fn cache(&self) -> Arc { - self.cache.clone() - } - - // ============ Albums ============ - - /// Récupère un album par son ID - pub async fn get_album(&self, album_id: &str) -> Result { - // Vérifier le cache d'abord - if let Some(album) = self.cache.get_album(album_id).await { - debug!("Album {} found in cache", album_id); - return Ok(album); - } - - // Sinon, récupérer depuis l'API - let album = self.api.get_album(album_id).await?; - - // Mettre en cache - self.cache - .put_album(album_id.to_string(), album.clone()) - .await; - - Ok(album) - } - - /// Récupère les tracks d'un album - pub async fn get_album_tracks(&self, album_id: &str) -> Result> { - let tracks = self.api.get_album_tracks(album_id).await?; - - // Mettre les tracks en cache - for track in &tracks { - self.cache.put_track(track.id.clone(), track.clone()).await; - } - - Ok(tracks) - } - - // ============ Tracks ============ - - /// Récupère une track par son ID - pub async fn get_track(&self, track_id: &str) -> Result { - if let Some(track) = self.cache.get_track(track_id).await { - debug!("Track {} found in cache", track_id); - return Ok(track); - } - - let track = self.api.get_track(track_id).await?; - self.cache - .put_track(track_id.to_string(), track.clone()) - .await; - - Ok(track) - } - - /// Récupère l'URL de streaming d'une track - pub async fn get_stream_url(&self, track_id: &str) -> Result { - // Vérifier le cache d'abord - if let Some(info) = self.cache.get_stream_url(track_id).await { - if info.expires_at > chrono::Utc::now() { - debug!("Stream URL for track {} found in cache", track_id); - return Ok(info.url); - } - } - - // Sinon, récupérer depuis l'API - let info = self.api.get_file_url(track_id).await?; - let url = info.url.clone(); - - // Mettre en cache - self.cache.put_stream_url(track_id.to_string(), info).await; - - Ok(url) - } - - // ============ Artists ============ - - /// Récupère un artiste par son ID - pub async fn get_artist(&self, artist_id: &str) -> Result { - if let Some(artist) = self.cache.get_artist(artist_id).await { - debug!("Artist {} found in cache", artist_id); - return Ok(artist); - } - - // Pour récupérer un artiste, on doit passer par get_artist_albums - let albums = self.api.get_artist_albums(artist_id).await?; - - if let Some(first_album) = albums.first() { - let artist = first_album.artist.clone(); - self.cache - .put_artist(artist_id.to_string(), artist.clone()) - .await; - Ok(artist) - } else { - Err(QobuzError::NotFound(format!( - "Artist {} not found", - artist_id - ))) - } - } - - /// Récupère les albums d'un artiste - pub async fn get_artist_albums(&self, artist_id: &str) -> Result> { - self.api.get_artist_albums(artist_id).await - } - - /// Récupère les artistes similaires - pub async fn get_similar_artists(&self, artist_id: &str) -> Result> { - self.api.get_similar_artists(artist_id).await - } - - // ============ Playlists ============ - - /// Récupère une playlist par son ID - pub async fn get_playlist(&self, playlist_id: &str) -> Result { - if let Some(playlist) = self.cache.get_playlist(playlist_id).await { - debug!("Playlist {} found in cache", playlist_id); - return Ok(playlist); - } - - let playlist = self.api.get_playlist(playlist_id).await?; - self.cache - .put_playlist(playlist_id.to_string(), playlist.clone()) - .await; - - Ok(playlist) - } - - /// Récupère les tracks d'une playlist - pub async fn get_playlist_tracks(&self, playlist_id: &str) -> Result> { - self.api.get_playlist_tracks(playlist_id).await - } - - // ============ Catalogue ============ - - /// Récupère la liste des genres - pub async fn get_genres(&self) -> Result> { - self.api.get_genres().await - } - - /// Récupère les albums featured (nouveautés, éditeur, etc.) - pub async fn get_featured_albums( - &self, - genre_id: Option<&str>, - type_: &str, - ) -> Result> { - self.api.get_featured_albums(genre_id, type_).await - } - - /// Récupère les playlists featured - pub async fn get_featured_playlists( - &self, - genre_id: Option<&str>, - tags: Option<&str>, - ) -> Result> { - self.api.get_featured_playlists(genre_id, tags).await - } - - // ============ Recherche ============ - - /// Recherche dans le catalogue Qobuz - /// - /// # Arguments - /// - /// * `query` - Termes de recherche - /// * `type_` - Type de recherche : None (tous), Some("albums"), Some("artists"), Some("tracks"), Some("playlists") - pub async fn search(&self, query: &str, type_: Option<&str>) -> Result { - // Créer une clé de cache - let cache_key = format!("{}:{}", query, type_.unwrap_or("all")); - - // Vérifier le cache - if let Some(result) = self.cache.get_search(&cache_key).await { - debug!("Search results for '{}' found in cache", query); - return Ok(result); - } - - // Sinon, rechercher via l'API - let result = self.api.search(query, type_).await?; - - // Mettre en cache - self.cache.put_search(cache_key, result.clone()).await; - - Ok(result) - } - - /// Recherche des albums - pub async fn search_albums(&self, query: &str) -> Result> { - let result = self.search(query, Some("albums")).await?; - Ok(result.albums) - } - - /// Recherche des artistes - pub async fn search_artists(&self, query: &str) -> Result> { - let result = self.search(query, Some("artists")).await?; - Ok(result.artists) - } - - /// Recherche des tracks - pub async fn search_tracks(&self, query: &str) -> Result> { - let result = self.search(query, Some("tracks")).await?; - Ok(result.tracks) - } - - /// Recherche des playlists - pub async fn search_playlists(&self, query: &str) -> Result> { - let result = self.search(query, Some("playlists")).await?; - Ok(result.playlists) - } - - // ============ Favoris ============ - - /// Récupère les albums favoris de l'utilisateur - pub async fn get_favorite_albums(&self) -> Result> { - self.api.get_favorite_albums().await - } - - /// Récupère les artistes favoris de l'utilisateur - pub async fn get_favorite_artists(&self) -> Result> { - self.api.get_favorite_artists().await - } - - /// Récupère les tracks favorites de l'utilisateur - pub async fn get_favorite_tracks(&self) -> Result> { - self.api.get_favorite_tracks().await - } - - /// Récupère les playlists de l'utilisateur - pub async fn get_user_playlists(&self) -> Result> { - self.api.get_user_playlists().await - } - - /// Ajoute un album aux favoris - pub async fn add_favorite_album(&self, album_id: &str) -> Result<()> { - self.api.add_favorite_album(album_id).await - } - - /// Supprime un album des favoris - pub async fn remove_favorite_album(&self, album_id: &str) -> Result<()> { - self.api.remove_favorite_album(album_id).await - } - - /// Ajoute un track aux favoris - pub async fn add_favorite_track(&self, track_id: &str) -> Result<()> { - self.api.add_favorite_track(track_id).await - } - - /// Supprime un track des favoris - pub async fn remove_favorite_track(&self, track_id: &str) -> Result<()> { - self.api.remove_favorite_track(track_id).await - } - - /// Ajoute un track à une playlist - pub async fn add_to_playlist(&self, playlist_id: &str, track_id: &str) -> Result<()> { - self.api.add_to_playlist(playlist_id, track_id).await - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_audio_format() { - assert_eq!(AudioFormat::default(), AudioFormat::Flac_Lossless); - } -} -========= End of pmoqobuz/src/client.rs =========== - -=============== pmoqobuz/src/error.rs ============ -//! Gestion des erreurs pour le client Qobuz - -use thiserror::Error; - -/// Type Result personnalisé pour pmoqobuz -pub type Result = std::result::Result; - -/// Erreurs possibles lors de l'utilisation du client Qobuz -#[derive(Error, Debug)] -pub enum QobuzError { - /// Erreur d'authentification (credentials invalides) - #[error("Authentication failed: {0}")] - Unauthorized(String), - - /// Ressource non trouvée (album, track, etc.) - #[error("Resource not found: {0}")] - NotFound(String), - - /// Erreur HTTP - #[error("HTTP error: {0}")] - Http(#[from] reqwest::Error), - - /// Erreur de parsing JSON - #[error("JSON parsing error: {0}")] - JsonParse(#[from] serde_json::Error), - - /// Erreur de configuration (anyhow) - #[error("Configuration error: {0}")] - Config(#[from] anyhow::Error), - - /// Erreur de configuration Qobuz (App ID, secret, etc.) - #[error("Qobuz configuration error: {0}")] - Configuration(String), - - /// Erreur de l'API Qobuz - #[error("Qobuz API error (code {code}): {message}")] - ApiError { code: u16, message: String }, - - /// Quota dépassé (rate limiting) - #[error("Rate limit exceeded, please try again later")] - RateLimitExceeded, - - /// Contenu non disponible dans la région de l'utilisateur - #[error("Content not available in your region")] - NotAvailable, - - /// Abonnement insuffisant pour accéder au contenu - #[error("Subscription level insufficient: {0}")] - SubscriptionRequired(String), - - /// Erreur de cache - #[error("Cache error: {0}")] - Cache(String), - - /// Erreur d'export DIDL - #[error("DIDL export error: {0}")] - DidlExport(String), - - /// Erreur générique - #[error("Qobuz error: {0}")] - Other(String), -} - -impl QobuzError { - /// Crée une erreur API depuis un code de statut HTTP et un message - pub fn from_status_code(code: u16, message: impl Into) -> Self { - match code { - 401 | 403 => Self::Unauthorized(message.into()), - 404 => Self::NotFound(message.into()), - 429 => Self::RateLimitExceeded, - _ => Self::ApiError { - code, - message: message.into(), - }, - } - } - - /// Vérifie si l'erreur est une erreur de credentials (401/403) - /// ou d'AppID invalide (400 avec "app_id") - pub fn is_auth_error(&self) -> bool { - match self { - QobuzError::Unauthorized(_) => true, - QobuzError::ApiError { code: 400, message } - if message.contains("app_id") || message.contains("Invalid") => true, - _ => false, - } - } - - /// Vérifie si l'erreur est une erreur de rate limiting - pub fn is_rate_limit(&self) -> bool { - matches!(self, QobuzError::RateLimitExceeded) - } -} -========= End of pmoqobuz/src/error.rs =========== - -=============== pmoqobuz/src/lib.rs ============ -//! # pmoqobuz - Client Qobuz pour PMOMusic -//! -//! Cette crate fournit un client Rust pour l'API Qobuz, inspiré de l'implémentation Python d'upmpdcli, -//! avec un système de cache en mémoire et une intégration avec les autres modules PMOMusic. -//! -//! ## Vue d'ensemble -//! -//! `pmoqobuz` permet d'accéder aux fonctionnalités de Qobuz : -//! - Authentification avec les credentials configurés -//! - Navigation dans le catalogue (albums, artistes, playlists, tracks) -//! - Recherche dans le catalogue -//! - Accès aux favoris de l'utilisateur -//! - Cache en mémoire pour minimiser les requêtes API -//! - Export des objets en format DIDL-Lite (via `pmodidl`) -//! - Cache des images d'albums (via `pmocovers`) -//! -//! ## Architecture -//! -//! La crate suit le pattern d'extension des autres crates PMO : -//! - `QobuzClient` : Client principal avec authentification et cache -//! - `models` : Structures de données (Album, Track, Artist, etc.) -//! - `api` : Couche d'accès à l'API REST Qobuz -//! - `cache` : Système de cache en mémoire avec TTL -//! - `didl` : Export des objets en format DIDL-Lite -//! -//! ## Structure des modules -//! -//! ```text -//! pmoqobuz/ -//! ├── src/ -//! │ ├── lib.rs # Module principal (ce fichier) -//! │ ├── client.rs # Client Qobuz principal -//! │ ├── models.rs # Structures de données -//! │ ├── api/ -//! │ │ ├── mod.rs # API client -//! │ │ ├── auth.rs # Authentification -//! │ │ ├── catalog.rs # Accès au catalogue -//! │ │ └── user.rs # API utilisateur (favoris) -//! │ ├── cache.rs # Cache en mémoire -//! │ ├── didl.rs # Export DIDL-Lite -//! │ └── error.rs # Gestion des erreurs -//! ``` -//! -//! ## Utilisation -//! -//! ### Exemple basique avec configuration automatique -//! -//! ```rust,no_run -//! use pmoqobuz::QobuzClient; -//! -//! #[tokio::main] -//! async fn main() -> anyhow::Result<()> { -//! // Utilise automatiquement la config depuis pmoconfig -//! let client = QobuzClient::from_config().await?; -//! -//! // Rechercher des albums -//! let results = client.search_albums("Miles Davis").await?; -//! for album in results { -//! println!("{} - {}", album.artist.name, album.title); -//! } -//! -//! Ok(()) -//! } -//! ``` -//! -//! ### Exemple avec credentials personnalisés -//! -//! ```rust,no_run -//! use pmoqobuz::QobuzClient; -//! -//! #[tokio::main] -//! async fn main() -> anyhow::Result<()> { -//! let client = QobuzClient::new("user@example.com", "password").await?; -//! -//! // Obtenir les albums favoris -//! let favorites = client.get_favorite_albums().await?; -//! -//! Ok(()) -//! } -//! ``` -//! -//! ### Export DIDL-Lite -//! -//! ```rust,no_run -//! use pmoqobuz::QobuzClient; -//! -//! #[tokio::main] -//! async fn main() -> anyhow::Result<()> { -//! let client = QobuzClient::from_config().await?; -//! -//! let album = client.get_album("12345").await?; -//! let didl_container = album.to_didl_container("parent_id")?; -//! -//! Ok(()) -//! } -//! ``` -//! -//! ## Cache -//! -//! Le client utilise un cache en mémoire avec TTL pour minimiser les requêtes à l'API Qobuz : -//! - Albums : 1 heure -//! - Tracks : 1 heure -//! - Artistes : 1 heure -//! - Playlists : 30 minutes -//! - Résultats de recherche : 15 minutes -//! - URLs de streaming : 5 minutes -//! -//! ## Intégration pmocovers et pmoaudiocache -//! -//! La feature `cache` active le support complet du cache pour les images et l'audio. -//! -//! ### Cache d'images (pmocovers) -//! -//! Les images de couverture sont automatiquement téléchargées et converties en WebP : -//! -//! ```rust,no_run -//! use pmoqobuz::{QobuzSource, QobuzClient}; -//! use pmocovers::Cache as CoverCache; -//! use std::sync::Arc; -//! -//! # async fn example() -> Result<(), Box> { -//! let client = QobuzClient::from_config().await?; -//! let cover_cache = Arc::new(CoverCache::new("./cache/covers", 500)?); -//! -//! let source = QobuzSource::new_with_cache( -//! client, -//! "http://localhost:8080", -//! Some(cover_cache), -//! None, -//! ); -//! # Ok(()) -//! # } -//! ``` -//! -//! ### Cache audio (pmoaudiocache) -//! -//! L'audio haute résolution est téléchargé et caché localement avec métadonnées enrichies : -//! -//! ```rust,no_run -//! use pmoqobuz::{QobuzSource, QobuzClient}; -//! use pmocovers::Cache as CoverCache; -//! use pmoaudiocache::AudioCache; -//! use std::sync::Arc; -//! -//! # async fn example() -> Result<(), Box> { -//! let client = QobuzClient::from_config().await?; -//! let cover_cache = Arc::new(CoverCache::new("./cache/covers", 500)?); -//! let audio_cache = Arc::new(AudioCache::new("./cache/audio", 100)?); -//! -//! let source = QobuzSource::new_with_cache( -//! client.clone(), -//! "http://localhost:8080", -//! Some(cover_cache), -//! Some(audio_cache), -//! ); -//! -//! // Add a track with caching -//! let tracks = client.get_favorite_tracks().await?; -//! if let Some(track) = tracks.first() { -//! let track_id = source.add_track(track).await?; -//! // Audio and cover are now cached with rich metadata -//! -//! // Resolve URI (returns cached version if available) -//! let uri = source.resolve_uri(&track_id).await?; -//! } -//! # Ok(()) -//! # } -//! ``` -//! -//! ### Métadonnées enrichies -//! -//! Qobuz fournit des métadonnées détaillées qui sont préservées dans le cache : -//! - Titre, artiste, album -//! - Numéro de piste et de disque -//! - Année de sortie -//! - Genre(s) -//! - Label -//! - Qualité audio (sample rate, bit depth, channels) -//! - Durée -//! -//! ### Exemple complet -//! -//! Voir `examples/with_cache.rs` pour un exemple complet d'utilisation avec cache. -//! -//! ## Formats audio supportés -//! -//! Qobuz propose plusieurs formats : -//! - Format 5 : MP3 320 kbps -//! - Format 6 : FLAC 16 bit / 44.1 kHz (CD Quality) -//! - Format 7 : FLAC 24 bit / jusqu'à 96 kHz (Hi-Res) -//! - Format 27 : FLAC 24 bit / jusqu'à 192 kHz (Hi-Res+) -//! -//! ## Gestion des erreurs -//! -//! La crate utilise `thiserror` pour définir des erreurs typées : -//! -//! ```rust,ignore -//! use pmoqobuz::{QobuzClient, QobuzError}; -//! -//! match client.get_album("invalid").await { -//! Ok(album) => println!("Album: {}", album.title), -//! Err(QobuzError::NotFound) => println!("Album not found"), -//! Err(QobuzError::Unauthorized) => println!("Authentication failed"), -//! Err(e) => println!("Error: {}", e), -//! } -//! ``` -//! -//! ## Voir aussi -//! -//! - [`pmodidl`] : Format DIDL-Lite -//! - [`pmocovers`] : Cache d'images -//! - [`pmoaudiocache`] : Cache audio -//! - [`pmoconfig`] : Configuration -//! - [`pmoserver`] : Serveur HTTP - -pub mod api; -pub mod cache; -pub mod client; -pub mod config_ext; -pub mod didl; -pub mod disk_cache; -pub mod error; -pub mod models; -pub mod source; - -// Extension pmoserver (feature-gated) -#[cfg(feature = "pmoserver")] -pub mod api_rest; - -#[cfg(feature = "pmoserver")] -pub mod pmoserver_ext; - -#[cfg(feature = "pmoserver")] -mod pmoserver_impl; - -pub use client::QobuzClient; -pub use config_ext::QobuzConfigExt; -pub use error::{QobuzError, Result}; -pub use models::{Album, Artist, AudioFormat, Genre, Playlist, SearchResult, Track}; -pub use source::QobuzSource; - -/// Ré-exporte les types DIDL pour faciliter l'utilisation -pub use didl::ToDIDL; - -/// Ré-exporte le trait d'extension pmoserver -#[cfg(feature = "pmoserver")] -pub use pmoserver_ext::QobuzServerExt; -========= End of pmoqobuz/src/lib.rs =========== - -=============== pmoqobuz/src/disk_cache.rs ============ -//! Cache disque simple pour les données volumineuses de l'API Qobuz -//! -//! Ce module gère le cache sur disque des données qui changent rarement : -//! - Favoris (albums, tracks, artistes) -//! - Playlists utilisateur -//! - Bibliothèque -//! -//! Contrairement à pmocache (conçu pour des fichiers binaires avec téléchargement), -//! ce cache est optimisé pour du JSON provenant de l'API. - -use anyhow::{anyhow, Result}; -use serde::{de::DeserializeOwned, Serialize}; -use std::fs; -use std::path::{Path, PathBuf}; -use std::time::{Duration, SystemTime}; -use tracing::{debug, info}; - -/// Cache disque pour données JSON de l'API Qobuz -pub struct DiskCache { - /// Répertoire de cache - cache_dir: PathBuf, -} - -impl DiskCache { - /// Crée un nouveau cache disque - /// - /// # Arguments - /// - /// * `cache_dir` - Répertoire où stocker les fichiers cachés - /// - /// # Example - /// - /// ```rust,no_run - /// use pmoqobuz::disk_cache::DiskCache; - /// - /// let cache = DiskCache::new(".pmomusic/cache/qobuz")?; - /// # Ok::<(), anyhow::Error>(()) - /// ``` - pub fn new>(cache_dir: P) -> Result { - let cache_dir = cache_dir.as_ref().to_path_buf(); - - // Créer le répertoire s'il n'existe pas - if !cache_dir.exists() { - fs::create_dir_all(&cache_dir)?; - info!("Created cache directory: {}", cache_dir.display()); - } - - Ok(Self { cache_dir }) - } - - /// Construit le chemin d'un fichier de cache - /// - /// Format: `{cache_dir}/{key}.json` - fn cache_path(&self, key: &str) -> PathBuf { - self.cache_dir.join(format!("{}.json", key)) - } - - /// Sauvegarde des données dans le cache - /// - /// # Arguments - /// - /// * `key` - Identifiant unique du cache (ex: "favorites_albums_123456") - /// * `data` - Données à sauvegarder - /// - /// # Example - /// - /// ```rust,no_run - /// # use pmoqobuz::disk_cache::DiskCache; - /// # use pmoqobuz::Album; - /// # let cache = DiskCache::new(".cache")?; - /// let albums: Vec = vec![/* ... */]; - /// cache.save("favorites_albums_123", &albums)?; - /// # Ok::<(), anyhow::Error>(()) - /// ``` - pub fn save(&self, key: &str, data: &T) -> Result<()> { - let path = self.cache_path(key); - let json = serde_json::to_string_pretty(data)?; - - fs::write(&path, json)?; - debug!("Saved cache to {}", path.display()); - - Ok(()) - } - - /// Charge des données depuis le cache - /// - /// # Arguments - /// - /// * `key` - Identifiant unique du cache - /// - /// # Returns - /// - /// Les données désérialisées, ou None si le cache n'existe pas - /// - /// # Example - /// - /// ```rust,no_run - /// # use pmoqobuz::disk_cache::DiskCache; - /// # use pmoqobuz::Album; - /// # let cache = DiskCache::new(".cache")?; - /// if let Some(albums) = cache.load::>("favorites_albums_123")? { - /// println!("Loaded {} albums from cache", albums.len()); - /// } - /// # Ok::<(), anyhow::Error>(()) - /// ``` - pub fn load(&self, key: &str) -> Result> { - let path = self.cache_path(key); - - if !path.exists() { - debug!("Cache file does not exist: {}", path.display()); - return Ok(None); - } - - let json = fs::read_to_string(&path)?; - let data: T = serde_json::from_str(&json)?; - - debug!("Loaded cache from {}", path.display()); - Ok(Some(data)) - } - - /// Charge des données avec vérification du TTL - /// - /// # Arguments - /// - /// * `key` - Identifiant unique du cache - /// * `ttl` - Durée de validité maximale - /// - /// # Returns - /// - /// Les données si le cache existe ET n'est pas expiré, None sinon - /// - /// # Example - /// - /// ```rust,no_run - /// # use pmoqobuz::disk_cache::DiskCache; - /// # use pmoqobuz::Album; - /// # use std::time::Duration; - /// # let cache = DiskCache::new(".cache")?; - /// // Cache valide pendant 1 heure - /// if let Some(albums) = cache.load_with_ttl::>( - /// "favorites_albums_123", - /// Duration::from_secs(3600) - /// )? { - /// println!("Cache still valid!"); - /// } else { - /// println!("Cache expired or missing"); - /// } - /// # Ok::<(), anyhow::Error>(()) - /// ``` - pub fn load_with_ttl( - &self, - key: &str, - ttl: Duration, - ) -> Result> { - let path = self.cache_path(key); - - if !path.exists() { - debug!("Cache file does not exist: {}", path.display()); - return Ok(None); - } - - // Vérifier l'âge du fichier - let metadata = fs::metadata(&path)?; - let modified = metadata.modified()?; - let age = SystemTime::now() - .duration_since(modified) - .unwrap_or(Duration::MAX); - - if age > ttl { - debug!( - "Cache expired (age: {}s > ttl: {}s): {}", - age.as_secs(), - ttl.as_secs(), - path.display() - ); - // Optionnel : supprimer le fichier expiré - let _ = fs::remove_file(&path); - return Ok(None); - } - - debug!( - "Cache valid (age: {}s < ttl: {}s): {}", - age.as_secs(), - ttl.as_secs(), - path.display() - ); - - let json = fs::read_to_string(&path)?; - let data: T = serde_json::from_str(&json)?; - - Ok(Some(data)) - } - - /// Invalide (supprime) un cache - /// - /// # Arguments - /// - /// * `key` - Identifiant unique du cache - pub fn invalidate(&self, key: &str) -> Result<()> { - let path = self.cache_path(key); - - if path.exists() { - fs::remove_file(&path)?; - debug!("Invalidated cache: {}", path.display()); - } - - Ok(()) - } - - /// Supprime tous les fichiers de cache - pub fn clear_all(&self) -> Result<()> { - for entry in fs::read_dir(&self.cache_dir)? { - let entry = entry?; - let path = entry.path(); - - if path.extension().and_then(|s| s.to_str()) == Some("json") { - fs::remove_file(&path)?; - debug!("Removed cache file: {}", path.display()); - } - } - - info!("Cleared all cache files"); - Ok(()) - } - - /// Retourne la taille totale du cache en octets - pub fn size(&self) -> Result { - let mut total = 0u64; - - for entry in fs::read_dir(&self.cache_dir)? { - let entry = entry?; - let metadata = entry.metadata()?; - - if metadata.is_file() { - total += metadata.len(); - } - } - - Ok(total) - } - - /// Retourne le nombre de fichiers en cache - pub fn count(&self) -> Result { - let mut count = 0; - - for entry in fs::read_dir(&self.cache_dir)? { - let entry = entry?; - - if entry.path().extension().and_then(|s| s.to_str()) == Some("json") { - count += 1; - } - } - - Ok(count) - } -} - -#[cfg(test)] -mod tests { - use super::*; - use serde::{Deserialize, Serialize}; - use tempfile::tempdir; - - #[derive(Debug, Serialize, Deserialize, PartialEq)] - struct TestData { - id: String, - value: i32, - } - - #[test] - fn test_save_and_load() -> Result<()> { - let dir = tempdir()?; - let cache = DiskCache::new(dir.path())?; - - let data = TestData { - id: "test123".to_string(), - value: 42, - }; - - // Sauvegarder - cache.save("test_key", &data)?; - - // Charger - let loaded: Option = cache.load("test_key")?; - assert!(loaded.is_some()); - assert_eq!(loaded.unwrap(), data); - - Ok(()) - } - - #[test] - fn test_load_nonexistent() -> Result<()> { - let dir = tempdir()?; - let cache = DiskCache::new(dir.path())?; - - let loaded: Option = cache.load("nonexistent")?; - assert!(loaded.is_none()); - - Ok(()) - } - - #[test] - fn test_ttl() -> Result<()> { - let dir = tempdir()?; - let cache = DiskCache::new(dir.path())?; - - let data = TestData { - id: "test123".to_string(), - value: 42, - }; - - cache.save("test_key", &data)?; - - // Charger immédiatement (< TTL) - let loaded: Option = - cache.load_with_ttl("test_key", Duration::from_secs(60))?; - assert!(loaded.is_some()); - - // Charger avec TTL expiré - let loaded: Option = cache.load_with_ttl("test_key", Duration::from_secs(0))?; - assert!(loaded.is_none()); - - Ok(()) - } - - #[test] - fn test_invalidate() -> Result<()> { - let dir = tempdir()?; - let cache = DiskCache::new(dir.path())?; - - let data = TestData { - id: "test123".to_string(), - value: 42, - }; - - cache.save("test_key", &data)?; - assert!(cache.load::("test_key")?.is_some()); - - cache.invalidate("test_key")?; - assert!(cache.load::("test_key")?.is_none()); - - Ok(()) - } - - #[test] - fn test_size_and_count() -> Result<()> { - let dir = tempdir()?; - let cache = DiskCache::new(dir.path())?; - - assert_eq!(cache.count()?, 0); - assert_eq!(cache.size()?, 0); - - let data = TestData { - id: "test123".to_string(), - value: 42, - }; - - cache.save("test1", &data)?; - cache.save("test2", &data)?; - - assert_eq!(cache.count()?, 2); - assert!(cache.size()? > 0); - - Ok(()) - } -} -========= End of pmoqobuz/src/disk_cache.rs =========== - -=============== pmoqobuz/src/models.rs ============ -//! Structures de données pour représenter les objets Qobuz - -use chrono::{DateTime, Utc}; -use serde::{Deserialize, Deserializer, Serialize}; - -/// Désérialiseur flexible pour les IDs qui peuvent être des strings ou des integers -pub(crate) fn deserialize_id<'de, D>(deserializer: D) -> Result -where - D: Deserializer<'de>, -{ - use serde::de::Error; - use serde_json::Value; - - let value = Value::deserialize(deserializer)?; - match value { - Value::String(s) => Ok(s), - Value::Number(n) => Ok(n.to_string()), - _ => Err(Error::custom("ID must be a string or number")), - } -} - -/// Représente un artiste Qobuz -#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)] -pub struct Artist { - /// Identifiant unique de l'artiste - #[serde(deserialize_with = "deserialize_id")] - pub id: String, - /// Nom de l'artiste - pub name: String, - /// URL de l'image de l'artiste (optionnelle) - #[serde(default)] - pub image: Option, - /// URL de l'image cachée localement (via pmocovers) - #[serde(skip)] - pub image_cached: Option, -} - -/// Représente un album Qobuz -#[derive(Debug, Clone, Serialize, Deserialize)] -pub struct Album { - /// Identifiant unique de l'album - #[serde(deserialize_with = "deserialize_id")] - pub id: String, - /// Titre de l'album - pub title: String, - /// Artiste principal de l'album - pub artist: Artist, - /// Nombre de pistes - #[serde(default)] - pub tracks_count: Option, - /// Durée totale en secondes - #[serde(default)] - pub duration: Option, - /// Date de sortie (format ISO 8601) - #[serde(default)] - pub release_date: Option, - /// URL de l'image de couverture - #[serde(default)] - pub image: Option, - /// URL de l'image cachée localement (via pmocovers) - #[serde(skip)] - pub image_cached: Option, - /// Indique si l'album est disponible pour le streaming - #[serde(default = "default_true")] - pub streamable: bool, - /// Description de l'album - #[serde(default)] - pub description: Option, - /// Taux d'échantillonnage maximum (Hz) - #[serde(default)] - pub maximum_sampling_rate: Option, - /// Profondeur de bits maximale - #[serde(default)] - pub maximum_bit_depth: Option, - /// Genre(s) de l'album - #[serde(default)] - pub genres: Vec, - /// Label de l'album - #[serde(default)] - pub label: Option, -} - -/// Représente une piste (track) Qobuz -#[derive(Debug, Clone, Serialize, Deserialize)] -pub struct Track { - /// Identifiant unique de la piste - #[serde(deserialize_with = "deserialize_id")] - pub id: String, - /// Titre de la piste - pub title: String, - /// Artiste de la piste (peut différer de l'artiste de l'album) - pub performer: Option, - /// Album contenant la piste - pub album: Option, - /// Durée en secondes - pub duration: u32, - /// Numéro de piste - pub track_number: u32, - /// Numéro de disque (pour les albums multi-disques) - pub media_number: u32, - /// Indique si la piste est disponible pour le streaming - #[serde(default = "default_true")] - pub streamable: bool, - /// Type MIME du fichier audio (déterminé après obtention de l'URL) - #[serde(skip)] - pub mime_type: Option, - /// Fréquence d'échantillonnage (Hz) - #[serde(skip)] - pub sample_rate: Option, - /// Profondeur de bits - #[serde(skip)] - pub bit_depth: Option, - /// Nombre de canaux audio - #[serde(skip)] - pub channels: Option, -} - -/// Représente une playlist Qobuz -#[derive(Debug, Clone, Serialize, Deserialize)] -pub struct Playlist { - /// Identifiant unique de la playlist - #[serde(deserialize_with = "deserialize_id")] - pub id: String, - /// Nom de la playlist - pub name: String, - /// Description de la playlist - #[serde(default)] - pub description: Option, - /// Nombre de pistes - #[serde(default)] - pub tracks_count: Option, - /// Durée totale en secondes - #[serde(default)] - pub duration: Option, - /// URL de l'image de la playlist - #[serde(default)] - pub image: Option, - /// URL de l'image cachée localement - #[serde(skip)] - pub image_cached: Option, - /// Indique si c'est une playlist publique - #[serde(default)] - pub is_public: bool, - /// Propriétaire de la playlist - #[serde(default)] - pub owner: Option, -} - -/// Propriétaire d'une playlist -#[derive(Debug, Clone, Serialize, Deserialize)] -pub struct PlaylistOwner { - /// Identifiant de l'utilisateur - pub id: u64, - /// Nom de l'utilisateur - pub name: String, -} - -/// Représente un genre musical -#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)] -pub struct Genre { - /// Identifiant du genre (peut être None pour "All Genres") - pub id: Option, - /// Nom du genre - pub name: String, - /// Genres enfants - #[serde(default)] - pub children: Vec, -} - -/// Résultats de recherche -#[derive(Debug, Clone, Default, Serialize, Deserialize)] -pub struct SearchResult { - /// Albums trouvés - #[serde(default)] - pub albums: Vec, - /// Artistes trouvés - #[serde(default)] - pub artists: Vec, - /// Pistes trouvées - #[serde(default)] - pub tracks: Vec, - /// Playlists trouvées - #[serde(default)] - pub playlists: Vec, -} - -/// Informations sur un fichier de streaming -#[derive(Debug, Clone, Serialize, Deserialize)] -pub struct StreamInfo { - /// URL de streaming - pub url: String, - /// Type MIME - pub mime_type: String, - /// Fréquence d'échantillonnage (Hz) - pub sampling_rate: u32, - /// Profondeur de bits - pub bit_depth: u32, - /// Format ID Qobuz - pub format_id: u8, - /// Date d'expiration de l'URL - #[serde(skip)] - pub expires_at: DateTime, -} - -/// Format audio demandé pour le streaming -#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] -#[repr(u8)] -#[allow(non_camel_case_types)] -pub enum AudioFormat { - /// MP3 320 kbps - Mp3_320 = 5, - /// FLAC 16 bit / 44.1 kHz (CD Quality) - Flac_Lossless = 6, - /// FLAC 24 bit / jusqu'à 96 kHz (Hi-Res) - Flac_HiRes_96 = 7, - /// FLAC 24 bit / jusqu'à 192 kHz (Hi-Res+) - Flac_HiRes_192 = 27, -} - -impl AudioFormat { - /// Retourne l'ID du format pour l'API Qobuz - pub fn id(&self) -> u8 { - *self as u8 - } - - /// Retourne une description lisible du format - pub fn description(&self) -> &'static str { - match self { - AudioFormat::Mp3_320 => "MP3 320 kbps", - AudioFormat::Flac_Lossless => "FLAC 16 bit / 44.1 kHz", - AudioFormat::Flac_HiRes_96 => "FLAC 24 bit / up to 96 kHz", - AudioFormat::Flac_HiRes_192 => "FLAC 24 bit / up to 192 kHz", - } - } - - /// Retourne le type MIME associé - pub fn mime_type(&self) -> &'static str { - match self { - AudioFormat::Mp3_320 => "audio/mpeg", - _ => "audio/flac", - } - } -} - -impl Default for AudioFormat { - fn default() -> Self { - AudioFormat::Flac_Lossless - } -} - -// Helper functions -fn default_true() -> bool { - true -} - -impl Artist { - /// Crée un nouvel artiste avec un ID et un nom - pub fn new(id: impl Into, name: impl Into) -> Self { - Self { - id: id.into(), - name: name.into(), - image: None, - image_cached: None, - } - } -} - -impl Album { - /// Retourne un titre formaté avec les informations audio si disponibles - pub fn formatted_title(&self) -> String { - if let (Some(rate), Some(depth)) = (self.maximum_sampling_rate, self.maximum_bit_depth) { - format!("{} ({:.0}/{} bit)", self.title, rate / 1000.0, depth) - } else { - self.title.clone() - } - } - - /// Vérifie si l'album est disponible pour le streaming - pub fn is_available(&self) -> bool { - self.streamable - } -} - -impl Track { - /// Retourne l'artiste à afficher (performer ou artiste de l'album) - pub fn display_artist(&self) -> Option<&Artist> { - self.performer - .as_ref() - .or_else(|| self.album.as_ref().map(|a| &a.artist)) - } - - /// Retourne le nom de l'album si disponible - pub fn album_name(&self) -> Option<&str> { - self.album.as_ref().map(|a| a.title.as_str()) - } - - /// Vérifie si la piste est disponible pour le streaming - pub fn is_available(&self) -> bool { - self.streamable - } -} - -impl SearchResult { - /// Crée un résultat de recherche vide - pub fn new() -> Self { - Self::default() - } - - /// Retourne le nombre total de résultats - pub fn total_count(&self) -> usize { - self.albums.len() + self.artists.len() + self.tracks.len() + self.playlists.len() - } - - /// Vérifie si la recherche n'a retourné aucun résultat - pub fn is_empty(&self) -> bool { - self.total_count() == 0 - } -} -========= End of pmoqobuz/src/models.rs =========== - -=============== pmoqobuz/src/didl.rs ============ -//! Export des objets Qobuz en format DIDL-Lite -//! -//! Ce module permet de convertir les structures Qobuz (Album, Track, etc.) -//! en objets DIDL-Lite compatibles avec UPnP/DLNA. - -use crate::error::{QobuzError, Result}; -use crate::models::{Album, Playlist, Track}; -use pmodidl::{Container, Item, Resource}; - -/// Trait pour convertir un objet Qobuz en DIDL-Lite -pub trait ToDIDL { - /// Convertit l'objet en Container DIDL - fn to_didl_container(&self, parent_id: &str) -> Result; - - /// Convertit l'objet en Item DIDL - fn to_didl_item(&self, parent_id: &str) -> Result; -} - -impl ToDIDL for Album { - /// Convertit un album en Container DIDL - /// - /// # Arguments - /// - /// * `parent_id` - ID du container parent - /// - /// # Exemple - /// - /// ```rust,ignore - /// let album = client.get_album("12345").await?; - /// let container = album.to_didl_container("0$qobuz$albums")?; - /// ``` - fn to_didl_container(&self, parent_id: &str) -> Result { - let id = format!("0$qobuz$album${}", self.id); - - Ok(Container { - id, - parent_id: parent_id.to_string(), - restricted: Some("1".to_string()), - child_count: self.tracks_count.map(|c| c.to_string()), - searchable: Some("1".to_string()), - title: self.formatted_title(), - class: "object.container.album.musicAlbum".to_string(), - containers: Vec::new(), - items: Vec::new(), - }) - } - - /// Un album ne peut pas être converti directement en Item - fn to_didl_item(&self, _parent_id: &str) -> Result { - Err(QobuzError::DidlExport( - "Album cannot be converted to Item, use to_didl_container instead".to_string(), - )) - } -} - -impl ToDIDL for Track { - /// Une track ne peut pas être convertie en Container - fn to_didl_container(&self, _parent_id: &str) -> Result { - Err(QobuzError::DidlExport( - "Track cannot be converted to Container, use to_didl_item instead".to_string(), - )) - } - - /// Convertit une track en Item DIDL - /// - /// # Arguments - /// - /// * `parent_id` - ID du container parent - /// - /// # Exemple - /// - /// ```rust,ignore - /// let track = client.get_track("98765").await?; - /// let item = track.to_didl_item("0$qobuz$album$12345")?; - /// ``` - fn to_didl_item(&self, parent_id: &str) -> Result { - let id = format!("0$qobuz$track${}", self.id); - - // Déterminer l'artiste à afficher - let artist_name = self - .display_artist() - .map(|a| a.name.clone()) - .or_else(|| self.album.as_ref().map(|a| a.artist.name.clone())); - - // Déterminer l'album - let album_name = self.album_name().map(|s| s.to_string()); - - // Déterminer l'image de couverture - let album_art = self - .album - .as_ref() - .and_then(|a| a.image_cached.clone().or_else(|| a.image.clone())); - - // Créer la ressource (URL de streaming) - // Note: L'URL sera remplie plus tard via get_stream_url - let resource = Resource { - protocol_info: format!( - "http-get:*:{}:*", - self.mime_type.as_deref().unwrap_or("audio/flac") - ), - bits_per_sample: self.bit_depth.map(|b| b.to_string()), - sample_frequency: self.sample_rate.map(|r| r.to_string()), - nr_audio_channels: self.channels.map(|c| c.to_string()), - duration: Some(format_duration(self.duration)), - url: format!("qobuz://track/{}", self.id), // URL symbolique - }; - - Ok(Item { - id, - parent_id: parent_id.to_string(), - restricted: Some("1".to_string()), - title: self.title.clone(), - creator: artist_name.clone(), - class: "object.item.audioItem.musicTrack".to_string(), - artist: artist_name, - album: album_name, - genre: None, // Qobuz ne fournit pas le genre au niveau track - album_art, - album_art_pk: None, - date: self.album.as_ref().and_then(|a| a.release_date.clone()), - original_track_number: Some(self.track_number.to_string()), - resources: vec![resource], - descriptions: Vec::new(), - }) - } -} - -impl ToDIDL for Playlist { - /// Convertit une playlist en Container DIDL - fn to_didl_container(&self, parent_id: &str) -> Result { - let id = format!("0$qobuz$playlist${}", self.id); - - Ok(Container { - id, - parent_id: parent_id.to_string(), - restricted: Some("1".to_string()), - child_count: self.tracks_count.map(|c| c.to_string()), - searchable: Some("1".to_string()), - title: self.name.clone(), - class: "object.container.playlistContainer".to_string(), - containers: Vec::new(), - items: Vec::new(), - }) - } - - /// Une playlist ne peut pas être convertie en Item - fn to_didl_item(&self, _parent_id: &str) -> Result { - Err(QobuzError::DidlExport( - "Playlist cannot be converted to Item, use to_didl_container instead".to_string(), - )) - } -} - -/// Formate une durée en secondes au format HH:MM:SS -fn format_duration(seconds: u32) -> String { - let hours = seconds / 3600; - let minutes = (seconds % 3600) / 60; - let secs = seconds % 60; - format!("{:02}:{:02}:{:02}", hours, minutes, secs) -} - -/// Convertit une liste de tracks en items DIDL -pub fn tracks_to_didl_items(tracks: &[Track], parent_id: &str) -> Result> { - tracks - .iter() - .map(|track| track.to_didl_item(parent_id)) - .collect() -} - -/// Convertit une liste d'albums en containers DIDL -pub fn albums_to_didl_containers(albums: &[Album], parent_id: &str) -> Result> { - albums - .iter() - .map(|album| album.to_didl_container(parent_id)) - .collect() -} - -/// Convertit une liste de playlists en containers DIDL -pub fn playlists_to_didl_containers( - playlists: &[Playlist], - parent_id: &str, -) -> Result> { - playlists - .iter() - .map(|playlist| playlist.to_didl_container(parent_id)) - .collect() -} - -#[cfg(test)] -mod tests { - use super::*; - use crate::models::{Album, Artist, Track}; - - #[test] - fn test_album_to_didl_container() { - let album = Album { - id: "123".to_string(), - title: "Test Album".to_string(), - artist: Artist::new("456", "Test Artist"), - tracks_count: Some(10), - duration: Some(3000), - release_date: Some("2024-01-01".to_string()), - image: None, - image_cached: None, - streamable: true, - description: None, - maximum_sampling_rate: Some(96000.0), - maximum_bit_depth: Some(24), - genres: vec![], - label: None, - }; - - let container = album.to_didl_container("parent").unwrap(); - assert_eq!(container.id, "0$qobuz$album$123"); - assert_eq!(container.parent_id, "parent"); - assert!(container.title.contains("Test Album")); - } - - #[test] - fn test_track_to_didl_item() { - let track = Track { - id: "789".to_string(), - title: "Test Track".to_string(), - performer: Some(Artist::new("456", "Test Artist")), - album: None, - duration: 180, - track_number: 1, - media_number: 1, - streamable: true, - mime_type: Some("audio/flac".to_string()), - sample_rate: Some(44100), - bit_depth: Some(16), - channels: Some(2), - }; - - let item = track.to_didl_item("parent").unwrap(); - assert_eq!(item.id, "0$qobuz$track$789"); - assert_eq!(item.parent_id, "parent"); - assert_eq!(item.title, "Test Track"); - } - - #[test] - fn test_format_duration() { - assert_eq!(format_duration(0), "00:00:00"); - assert_eq!(format_duration(90), "00:01:30"); - assert_eq!(format_duration(3665), "01:01:05"); - } -} -========= End of pmoqobuz/src/didl.rs =========== - -=============== pmoqobuz/src/source.rs ============ -//! Music source implementation for Qobuz -//! -//! This module implements the [`pmosource::MusicSource`] trait for Qobuz, -//! providing a complete music catalog browsing and searching experience. - -use crate::client::QobuzClient; -use crate::didl::ToDIDL; -use crate::models::Track; -use pmoaudiocache::{AudioMetadata, Cache as AudioCache}; -use pmocovers::Cache as CoverCache; -use pmodidl::{Container, Item}; -use pmosource::SourceCacheManager; -use pmosource::{async_trait, BrowseResult, MusicSource, MusicSourceError, Result}; -use std::sync::Arc; -use std::time::SystemTime; - -/// Default image for Qobuz (300x300 WebP, embedded in binary) -const DEFAULT_IMAGE: &[u8] = include_bytes!("../assets/default.webp"); - -/// Qobuz music source with full MusicSource trait implementation -/// -/// This struct combines a [`QobuzClient`] for API access with browsing and -/// navigation capabilities, implementing the complete [`MusicSource`] trait. -/// -/// # Features -/// -/// - **Catalog Navigation**: Browse albums, artists, playlists, favorites -/// - **Search**: Full-text search across the Qobuz catalog -/// - **URI Resolution**: Resolves track streaming URIs with authentication -/// - **DIDL-Lite Export**: Converts albums, tracks, and playlists to UPnP formats -/// - **Caching**: Integrated with QobuzClient's cache for performance -/// -/// # Architecture -/// -/// Unlike streaming sources like Radio Paradise, Qobuz is a catalog-based source: -/// - Root container has multiple sub-containers (Albums, Artists, Favorites, etc.) -/// - No FIFO support (it's a static catalog, not a dynamic stream) -/// - Hierarchical browsing: Root → Category → Albums → Tracks -/// -/// # Examples -/// -/// ```no_run -/// use pmoqobuz::{QobuzSource, QobuzClient}; -/// use pmosource::MusicSource; -/// -/// #[tokio::main] -/// async fn main() -> Result<(), Box> { -/// let client = QobuzClient::from_config().await?; -/// let source = QobuzSource::new(client); -/// -/// println!("Source: {}", source.name()); -/// println!("Supports FIFO: {}", source.supports_fifo()); -/// -/// // Browse root container -/// let root = source.root_container().await?; -/// println!("Root: {} with {} children", root.title, root.child_count.unwrap_or_default()); -/// -/// Ok(()) -/// } -/// ``` -#[derive(Clone)] -pub struct QobuzSource { - inner: Arc, -} - -struct QobuzSourceInner { - /// Qobuz API client - client: QobuzClient, - - /// Cache manager (centralisé) - cache_manager: SourceCacheManager, - - /// Update tracking - update_counter: tokio::sync::RwLock, - last_change: tokio::sync::RwLock, -} - -impl std::fmt::Debug for QobuzSource { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - f.debug_struct("QobuzSource").finish() - } -} - -impl QobuzSource { - /// Create a new Qobuz source from the cache registry - /// - /// This is the recommended way to create a source when using the UPnP server. - /// The caches are automatically retrieved from the global registry. - /// - /// # Arguments - /// - /// * `client` - Authenticated Qobuz API client - /// - /// # Errors - /// - /// Returns an error if the caches are not initialized in the registry - #[cfg(feature = "server")] - pub fn from_registry(client: QobuzClient) -> Result { - let cache_manager = SourceCacheManager::from_registry("qobuz".to_string())?; - - Ok(Self { - inner: Arc::new(QobuzSourceInner { - client, - cache_manager, - update_counter: tokio::sync::RwLock::new(0), - last_change: tokio::sync::RwLock::new(SystemTime::now()), - }), - }) - } - - /// Create a new Qobuz source with explicit caches (for tests) - /// - /// # Arguments - /// - /// * `client` - Authenticated Qobuz API client - /// * `cover_cache` - Cover image cache (required) - /// * `audio_cache` - Audio cache (required) - pub fn new( - client: QobuzClient, - cover_cache: Arc, - audio_cache: Arc, - ) -> Self { - let cache_manager = SourceCacheManager::new("qobuz".to_string(), cover_cache, audio_cache); - - Self { - inner: Arc::new(QobuzSourceInner { - client, - cache_manager, - update_counter: tokio::sync::RwLock::new(0), - last_change: tokio::sync::RwLock::new(SystemTime::now()), - }), - } - } - - /// Get the Qobuz client - pub fn client(&self) -> &QobuzClient { - &self.inner.client - } - - /// Add a track from Qobuz with caching - /// - /// This method downloads and caches both cover art and audio data. - pub async fn add_track(&self, track: &Track) -> Result { - let track_id = format!("qobuz://track/{}", track.id); - - // Get streaming URL - let stream_url = self - .inner - .client - .get_stream_url(&track.id) - .await - .map_err(|e| MusicSourceError::UriResolutionError(e.to_string()))?; - - // 1. Cache cover via manager - let cached_cover_pk = if let Some(ref album) = track.album { - if let Some(ref image_url) = album.image { - self.inner.cache_manager.cache_cover(image_url).await.ok() - } else { - None - } - } else { - None - }; - - // 2. Prepare rich metadata from Qobuz track - let metadata = AudioMetadata { - title: Some(track.title.clone()), - artist: track.performer.as_ref().map(|p| p.name.clone()), - album: track.album.as_ref().map(|a| a.title.clone()), - duration_secs: Some(track.duration as u64), - year: track.album.as_ref().and_then(|a| { - a.release_date - .as_ref() - .and_then(|d| d.split('-').next()?.parse().ok()) - }), - track_number: Some(track.track_number), - track_total: track.album.as_ref().and_then(|a| a.tracks_count), - disc_number: Some(track.media_number), - disc_total: None, - genre: track.album.as_ref().and_then(|a| { - if !a.genres.is_empty() { - Some(a.genres.join(", ")) - } else { - None - } - }), - sample_rate: track.sample_rate, - channels: track.channels, - bitrate: None, - conversion: None, - }; - - // 3. Cache audio via manager - let cached_audio_pk = self - .inner - .cache_manager - .cache_audio(&stream_url, Some(metadata)) - .await - .ok(); - - // 4. Store metadata - self.inner - .cache_manager - .update_metadata( - track_id.clone(), - pmosource::TrackMetadata { - original_uri: stream_url, - cached_audio_pk, - cached_cover_pk, - }, - ) - .await; - - Ok(track_id) - } - - /// Add track with lazy audio caching (cover eager, audio lazy) - /// - /// This method caches cover art immediately (small, needed for UI) but - /// defers audio download until the track is actually played. - /// - /// # Arguments - /// - /// * `track` - The Qobuz track to add - /// - /// # Returns - /// - /// The track ID (e.g., "qobuz://track/12345") - pub async fn add_track_lazy(&self, track: &Track) -> Result { - let track_id = format!("qobuz://track/{}", track.id); - - // Get streaming URL - let stream_url = self - .inner - .client - .get_stream_url(&track.id) - .await - .map_err(|e| MusicSourceError::UriResolutionError(e.to_string()))?; - - // 1. Cache cover EAGERLY (small, UI needs it) - let cached_cover_pk = if let Some(ref album) = track.album { - if let Some(ref image_url) = album.image { - self.inner.cache_manager.cache_cover(image_url).await.ok() - } else { - None - } - } else { - None - }; - - // 2. Prepare rich metadata from Qobuz track - let metadata = AudioMetadata { - title: Some(track.title.clone()), - artist: track.performer.as_ref().map(|p| p.name.clone()), - album: track.album.as_ref().map(|a| a.title.clone()), - duration_secs: Some(track.duration as u64), - year: track.album.as_ref().and_then(|a| { - a.release_date - .as_ref() - .and_then(|d| d.split('-').next()?.parse().ok()) - }), - track_number: Some(track.track_number), - track_total: track.album.as_ref().and_then(|a| a.tracks_count), - disc_number: Some(track.media_number), - disc_total: None, - genre: track.album.as_ref().and_then(|a| { - if !a.genres.is_empty() { - Some(a.genres.join(", ")) - } else { - None - } - }), - sample_rate: track.sample_rate, - channels: track.channels, - bitrate: None, - conversion: None, - }; - - // 3. Cache audio LAZILY (KEY CHANGE: use cache_audio_lazy) - let cached_audio_pk = self - .inner - .cache_manager - .cache_audio_lazy(&stream_url, Some(metadata)) - .await - .ok(); - - // 4. Store metadata - self.inner - .cache_manager - .update_metadata( - track_id.clone(), - pmosource::TrackMetadata { - original_uri: stream_url, - cached_audio_pk, - cached_cover_pk, - }, - ) - .await; - - Ok(track_id) - } - - /// Load full album into pmoplaylist with lazy audio - /// - /// This method fetches all tracks from a Qobuz album and adds them to a playlist - /// with lazy audio loading. Covers are downloaded eagerly, audio lazily. - /// - /// # Arguments - /// - /// * `playlist_id` - ID of the target playlist - /// * `album_id` - Qobuz album ID - /// - /// # Returns - /// - /// Number of tracks successfully added - pub async fn add_album_to_playlist( - &self, - playlist_id: &str, - album_id: &str, - ) -> Result { - use tracing::{info, warn, debug}; - - // 1. Get tracks from Qobuz (goes through rate limiter) - let tracks = self - .inner - .client - .get_album_tracks(album_id) - .await - .map_err(|e| MusicSourceError::BrowseError(e.to_string()))?; - - if tracks.is_empty() { - return Ok(0); - } - - info!( - "Adding album {} ({} tracks) to playlist {} with lazy audio", - album_id, - tracks.len(), - playlist_id - ); - - // 2. Add each track lazily + collect lazy PKs - let mut lazy_pks = Vec::with_capacity(tracks.len()); - - for (i, track) in tracks.iter().enumerate() { - match self.add_track_lazy(track).await { - Ok(track_id) => { - debug!("Track {}/{}: {} (lazy)", i + 1, tracks.len(), track.title); - - // Extract lazy PK from cache manager - if let Some(metadata) = self.inner.cache_manager.get_metadata(&track_id).await { - if let Some(audio_pk) = metadata.cached_audio_pk { - lazy_pks.push(audio_pk); - } - } - } - Err(e) => { - warn!( - "Failed to add track {} ({}): {}", - i + 1, - track.title, - e - ); - // Continue with other tracks - } - } - } - - // 3. Batch insert into playlist (single DB transaction) - let playlist_manager = pmoplaylist::PlaylistManager(); - let writer = playlist_manager - .get_write_handle(playlist_id.to_string()) - .await - .map_err(|e| MusicSourceError::PlaylistError(e.to_string()))?; - - writer - .push_lazy_batch(lazy_pks.clone()) - .await - .map_err(|e| MusicSourceError::PlaylistError(e.to_string()))?; - - // 4. Enable lazy mode with lookahead of 2 tracks - playlist_manager.enable_lazy_mode(playlist_id, 2); - - info!( - "Album {} added: {}/{} tracks", - album_id, - lazy_pks.len(), - tracks.len() - ); - - Ok(lazy_pks.len()) - } - - /// Load Qobuz playlist into pmoplaylist with lazy audio - /// - /// This method fetches all tracks from a Qobuz playlist and adds them to a pmoplaylist - /// with lazy audio loading. Covers are downloaded eagerly, audio lazily. - /// - /// # Arguments - /// - /// * `playlist_id` - ID of the target pmoplaylist - /// * `qobuz_playlist_id` - Qobuz playlist ID - /// - /// # Returns - /// - /// Number of tracks successfully added - pub async fn add_qobuz_playlist_to_playlist( - &self, - playlist_id: &str, - qobuz_playlist_id: &str, - ) -> Result { - use tracing::{debug, info, warn}; - - // 1. Get tracks from Qobuz playlist (goes through rate limiter) - let tracks = self - .inner - .client - .get_playlist_tracks(qobuz_playlist_id) - .await - .map_err(|e| MusicSourceError::BrowseError(e.to_string()))?; - - if tracks.is_empty() { - return Ok(0); - } - - info!( - "Adding Qobuz playlist {} ({} tracks) to pmoplaylist {} with lazy audio", - qobuz_playlist_id, - tracks.len(), - playlist_id - ); - - // 2. Add each track lazily + collect lazy PKs - let mut lazy_pks = Vec::with_capacity(tracks.len()); - - for (i, track) in tracks.iter().enumerate() { - match self.add_track_lazy(track).await { - Ok(track_id) => { - debug!("Track {}/{}: {} (lazy)", i + 1, tracks.len(), track.title); - - // Extract lazy PK from cache manager - if let Some(metadata) = self.inner.cache_manager.get_metadata(&track_id).await { - if let Some(audio_pk) = metadata.cached_audio_pk { - lazy_pks.push(audio_pk); - } - } - } - Err(e) => { - warn!( - "Failed to add track {} ({}): {}", - i + 1, - track.title, - e - ); - // Continue with other tracks - } - } - } - - // 3. Batch insert into playlist (single DB transaction) - let playlist_manager = pmoplaylist::PlaylistManager(); - let writer = playlist_manager - .get_write_handle(playlist_id.to_string()) - .await - .map_err(|e| MusicSourceError::PlaylistError(e.to_string()))?; - - writer - .push_lazy_batch(lazy_pks.clone()) - .await - .map_err(|e| MusicSourceError::PlaylistError(e.to_string()))?; - - // 4. Enable lazy mode with lookahead of 2 tracks - playlist_manager.enable_lazy_mode(playlist_id, 2); - - info!( - "Qobuz playlist {} added: {}/{} tracks", - qobuz_playlist_id, - lazy_pks.len(), - tracks.len() - ); - - Ok(lazy_pks.len()) - } - - /// Increment update counter (called on catalog changes) - async fn increment_update_id(&self) { - let mut counter = self.inner.update_counter.write().await; - *counter = counter.wrapping_add(1); - let mut last = self.inner.last_change.write().await; - *last = SystemTime::now(); - } - - /// Parse object_id to determine what to browse - /// - /// Object IDs follow these patterns: - /// - "qobuz" or "0" → Root container - /// - "qobuz:favorites" → User's favorite albums - /// - "qobuz:album:{id}" → Tracks in album - /// - "qobuz:playlist:{id}" → Tracks in playlist - fn parse_object_id(&self, object_id: &str) -> ObjectIdType { - if object_id == "qobuz" || object_id == "0" { - return ObjectIdType::Root; - } - - let parts: Vec<&str> = object_id.split(':').collect(); - match parts.as_slice() { - ["qobuz", "favorites"] => ObjectIdType::Favorites, - ["qobuz", "album", id] => ObjectIdType::Album(id.to_string()), - ["qobuz", "playlist", id] => ObjectIdType::Playlist(id.to_string()), - ["qobuz", "artist", id] => ObjectIdType::Artist(id.to_string()), - _ => ObjectIdType::Unknown, - } - } -} - -#[derive(Debug)] -enum ObjectIdType { - Root, - Favorites, - Album(String), - Playlist(String), - Artist(String), - Unknown, -} - -#[async_trait] -impl MusicSource for QobuzSource { - fn name(&self) -> &str { - "Qobuz" - } - - fn id(&self) -> &str { - "qobuz" - } - - fn default_image(&self) -> &[u8] { - DEFAULT_IMAGE - } - - async fn root_container(&self) -> Result { - // Create the root container with sub-containers for different categories - Ok(Container { - id: "qobuz".to_string(), - parent_id: "0".to_string(), - restricted: Some("1".to_string()), - child_count: Some("2".to_string()), // Favorites + Search (simplified) - searchable: Some("1".to_string()), - title: "Qobuz".to_string(), - class: "object.container".to_string(), - containers: vec![ - // Favorites container - Container { - id: "qobuz:favorites".to_string(), - parent_id: "qobuz".to_string(), - restricted: Some("1".to_string()), - child_count: None, // Will be determined when browsed - searchable: Some("1".to_string()), - title: "My Favorites".to_string(), - class: "object.container".to_string(), - containers: vec![], - items: vec![], - }, - ], - items: vec![], - }) - } - - async fn browse(&self, object_id: &str) -> Result { - match self.parse_object_id(object_id) { - ObjectIdType::Root => { - // Return the root container's children - let root = self.root_container().await?; - Ok(BrowseResult::Containers(root.containers)) - } - - ObjectIdType::Favorites => { - // Get user's favorite albums - let albums = self - .inner - .client - .get_favorite_albums() - .await - .map_err(|e| MusicSourceError::BrowseError(e.to_string()))?; - - let containers: Vec = albums - .into_iter() - .filter_map(|album| album.to_didl_container("qobuz:favorites").ok()) - .collect(); - - Ok(BrowseResult::Containers(containers)) - } - - ObjectIdType::Album(album_id) => { - // Get tracks in album - let tracks = self - .inner - .client - .get_album_tracks(&album_id) - .await - .map_err(|e| MusicSourceError::BrowseError(e.to_string()))?; - - let items: Vec = tracks - .into_iter() - .filter_map(|track| { - track - .to_didl_item(&format!("qobuz:album:{}", album_id)) - .ok() - }) - .collect(); - - Ok(BrowseResult::Items(items)) - } - - ObjectIdType::Playlist(playlist_id) => { - // Get tracks in playlist - let tracks = self - .inner - .client - .get_playlist_tracks(&playlist_id) - .await - .map_err(|e| MusicSourceError::BrowseError(e.to_string()))?; - - let items: Vec = tracks - .into_iter() - .filter_map(|track| { - track - .to_didl_item(&format!("qobuz:playlist:{}", playlist_id)) - .ok() - }) - .collect(); - - Ok(BrowseResult::Items(items)) - } - - ObjectIdType::Artist(artist_id) => { - // Get albums by artist - let albums = self - .inner - .client - .get_artist_albums(&artist_id) - .await - .map_err(|e| MusicSourceError::BrowseError(e.to_string()))?; - - let containers: Vec = albums - .into_iter() - .filter_map(|album| { - album - .to_didl_container(&format!("qobuz:artist:{}", artist_id)) - .ok() - }) - .collect(); - - Ok(BrowseResult::Containers(containers)) - } - - ObjectIdType::Unknown => Err(MusicSourceError::ObjectNotFound(object_id.to_string())), - } - } - - async fn resolve_uri(&self, object_id: &str) -> Result { - // Try cache manager first - if let Ok(uri) = self.inner.cache_manager.resolve_uri(object_id).await { - return Ok(uri); - } - - // If not cached, extract track ID and get streaming URL from Qobuz - let track_id = object_id - .strip_prefix("qobuz://track/") - .unwrap_or(object_id); - - self.inner - .client - .get_stream_url(track_id) - .await - .map_err(|e| MusicSourceError::UriResolutionError(e.to_string())) - } - - fn supports_fifo(&self) -> bool { - // Qobuz is a catalog, not a dynamic stream - false - } - - async fn append_track(&self, _track: Item) -> Result<()> { - Err(MusicSourceError::FifoNotSupported) - } - - async fn remove_oldest(&self) -> Result> { - Err(MusicSourceError::FifoNotSupported) - } - - async fn update_id(&self) -> u32 { - *self.inner.update_counter.read().await - } - - async fn last_change(&self) -> Option { - Some(*self.inner.last_change.read().await) - } - - async fn get_items(&self, offset: usize, count: usize) -> Result> { - // For Qobuz, "get_items" returns favorite tracks with pagination - let all_tracks = self - .inner - .client - .get_favorite_tracks() - .await - .map_err(|e| MusicSourceError::BrowseError(e.to_string()))?; - - let items: Vec = all_tracks - .into_iter() - .skip(offset) - .take(count) - .filter_map(|track| track.to_didl_item("qobuz:favorites").ok()) - .collect(); - - Ok(items) - } - - async fn search(&self, query: &str) -> Result { - // Search across Qobuz catalog - let results = self - .inner - .client - .search(query, None) - .await - .map_err(|e| MusicSourceError::BrowseError(e.to_string()))?; - - // Convert albums to containers and tracks to items - let containers: Vec = results - .albums - .into_iter() - .filter_map(|album| album.to_didl_container("qobuz").ok()) - .collect(); - - let items: Vec = results - .tracks - .into_iter() - .filter_map(|track| track.to_didl_item("qobuz").ok()) - .collect(); - - if !containers.is_empty() || !items.is_empty() { - Ok(BrowseResult::Mixed { containers, items }) - } else { - Ok(BrowseResult::Items(vec![])) - } - } - - // ============= Extended Features Implementation ============= - - fn capabilities(&self) -> pmosource::SourceCapabilities { - pmosource::SourceCapabilities { - supports_fifo: false, - supports_search: true, - supports_favorites: true, - supports_playlists: true, - supports_user_content: false, - supports_high_res_audio: true, - max_sample_rate: Some(192_000), // Qobuz supports up to 192kHz - supports_multiple_formats: true, - supports_advanced_search: false, // TODO: Qobuz API supports it, not yet implemented - supports_pagination: true, - } - } - - async fn get_available_formats(&self, object_id: &str) -> Result> { - use pmosource::AudioFormat; - - // Extract track ID from object_id - let track_id = if let Some(id) = object_id.strip_prefix("qobuz://track/") { - id - } else { - object_id - }; - - // Get track details from Qobuz - let track = self - .inner - .client - .get_track(track_id) - .await - .map_err(|e| MusicSourceError::BrowseError(e.to_string()))?; - - // Qobuz provides multiple formats based on subscription - let mut formats = vec![]; - - // MP3 320 (format_id 5) - available to all - formats.push(AudioFormat { - format_id: "mp3-320".to_string(), - mime_type: "audio/mpeg".to_string(), - sample_rate: Some(44100), - bit_depth: None, - bitrate: Some(320), - channels: Some(2), - }); - - // FLAC 16/44.1 (format_id 6) - CD quality - formats.push(AudioFormat { - format_id: "flac-16-44".to_string(), - mime_type: "audio/flac".to_string(), - sample_rate: Some(44100), - bit_depth: Some(16), - bitrate: None, - channels: Some(2), - }); - - // Hi-Res formats (if available for this track) - if let Some(sample_rate) = track.sample_rate { - if sample_rate > 44100 { - // FLAC 24-bit Hi-Res - let bit_depth = track.bit_depth.map(|d| d as u8).or(Some(24)); - - formats.push(AudioFormat { - format_id: format!("flac-{}-{}", bit_depth.unwrap_or(24), sample_rate / 1000), - mime_type: "audio/flac".to_string(), - sample_rate: Some(sample_rate), - bit_depth, - bitrate: None, - channels: track.channels, - }); - } - } - - Ok(formats) - } - - async fn get_cache_status(&self, object_id: &str) -> Result { - self.inner.cache_manager.get_cache_status(object_id).await - } - - async fn cache_item(&self, object_id: &str) -> Result { - // Extract track ID - let track_id = object_id - .strip_prefix("qobuz://track/") - .unwrap_or(object_id); - - // Get track details from Qobuz - let track = self - .inner - .client - .get_track(track_id) - .await - .map_err(|e| MusicSourceError::BrowseError(e.to_string()))?; - - // Add track to cache (via manager) - let cached_id = self.add_track(&track).await?; - - // Return the cache status - self.get_cache_status(&cached_id).await - } - - async fn add_favorite(&self, object_id: &str) -> Result<()> { - // Parse object_id to determine type - let parts: Vec<&str> = object_id.split(':').collect(); - - match parts.as_slice() { - ["qobuz", "album", id] | ["qobuz://album", id] => { - self.inner - .client - .add_favorite_album(id) - .await - .map_err(|e| MusicSourceError::FavoritesError(e.to_string()))?; - } - ["qobuz", "track", id] | ["qobuz://track", id] => { - self.inner - .client - .add_favorite_track(id) - .await - .map_err(|e| MusicSourceError::FavoritesError(e.to_string()))?; - } - _ => { - return Err(MusicSourceError::NotSupported( - "Favorites only supported for albums and tracks".to_string(), - )); - } - } - - self.increment_update_id().await; - Ok(()) - } - - async fn remove_favorite(&self, object_id: &str) -> Result<()> { - // Parse object_id to determine type - let parts: Vec<&str> = object_id.split(':').collect(); - - match parts.as_slice() { - ["qobuz", "album", id] | ["qobuz://album", id] => { - self.inner - .client - .remove_favorite_album(id) - .await - .map_err(|e| MusicSourceError::FavoritesError(e.to_string()))?; - } - ["qobuz", "track", id] | ["qobuz://track", id] => { - self.inner - .client - .remove_favorite_track(id) - .await - .map_err(|e| MusicSourceError::FavoritesError(e.to_string()))?; - } - _ => { - return Err(MusicSourceError::NotSupported( - "Favorites only supported for albums and tracks".to_string(), - )); - } - } - - self.increment_update_id().await; - Ok(()) - } - - async fn is_favorite(&self, object_id: &str) -> Result { - // Parse object_id to determine type - let parts: Vec<&str> = object_id.split(':').collect(); - - match parts.as_slice() { - ["qobuz", "album", id] | ["qobuz://album", id] => { - let favorites = self - .inner - .client - .get_favorite_albums() - .await - .map_err(|e| MusicSourceError::FavoritesError(e.to_string()))?; - - Ok(favorites.iter().any(|album| album.id == *id)) - } - ["qobuz", "track", id] | ["qobuz://track", id] => { - let favorites = self - .inner - .client - .get_favorite_tracks() - .await - .map_err(|e| MusicSourceError::FavoritesError(e.to_string()))?; - - Ok(favorites.iter().any(|track| track.id == *id)) - } - _ => Err(MusicSourceError::NotSupported( - "Favorites only supported for albums and tracks".to_string(), - )), - } - } - - async fn get_user_playlists(&self) -> Result> { - let playlists = self - .inner - .client - .get_user_playlists() - .await - .map_err(|e| MusicSourceError::PlaylistError(e.to_string()))?; - - let containers: Vec = playlists - .into_iter() - .filter_map(|playlist| playlist.to_didl_container("qobuz").ok()) - .collect(); - - Ok(containers) - } - - async fn add_to_playlist(&self, playlist_id: &str, item_id: &str) -> Result<()> { - // Extract track ID from item_id - let track_id = if let Some(id) = item_id.strip_prefix("qobuz://track/") { - id - } else if let Some(id) = item_id.strip_prefix("qobuz:track:") { - id - } else { - item_id - }; - - self.inner - .client - .add_to_playlist(playlist_id, track_id) - .await - .map_err(|e| MusicSourceError::PlaylistError(e.to_string()))?; - - self.increment_update_id().await; - Ok(()) - } - - async fn get_item_count(&self, object_id: &str) -> Result { - match self.parse_object_id(object_id) { - ObjectIdType::Album(album_id) => { - let album = self - .inner - .client - .get_album(&album_id) - .await - .map_err(|e| MusicSourceError::BrowseError(e.to_string()))?; - - Ok(album.tracks_count.unwrap_or(0) as usize) - } - ObjectIdType::Playlist(playlist_id) => { - let playlist = self - .inner - .client - .get_playlist(&playlist_id) - .await - .map_err(|e| MusicSourceError::BrowseError(e.to_string()))?; - - Ok(playlist.tracks_count.unwrap_or(0) as usize) - } - _ => { - // Fall back to default implementation - let result = self.browse(object_id).await?; - Ok(result.count()) - } - } - } - - async fn browse_paginated( - &self, - object_id: &str, - offset: usize, - limit: usize, - ) -> Result { - match self.parse_object_id(object_id) { - ObjectIdType::Album(album_id) => { - // Qobuz returns all tracks, so we slice them - let tracks = self - .inner - .client - .get_album_tracks(&album_id) - .await - .map_err(|e| MusicSourceError::BrowseError(e.to_string()))?; - - let items: Vec = tracks - .into_iter() - .skip(offset) - .take(limit) - .filter_map(|track| { - track - .to_didl_item(&format!("qobuz:album:{}", album_id)) - .ok() - }) - .collect(); - - Ok(BrowseResult::Items(items)) - } - ObjectIdType::Favorites => { - let albums = self - .inner - .client - .get_favorite_albums() - .await - .map_err(|e| MusicSourceError::BrowseError(e.to_string()))?; - - let containers: Vec = albums - .into_iter() - .skip(offset) - .take(limit) - .filter_map(|album| album.to_didl_container("qobuz:favorites").ok()) - .collect(); - - Ok(BrowseResult::Containers(containers)) - } - _ => { - // Fall back to default implementation - self.browse(object_id).await - } - } - } - - async fn statistics(&self) -> Result { - let mut stats = pmosource::SourceStatistics::default(); - - // Try to get favorite counts - if let Ok(albums) = self.inner.client.get_favorite_albums().await { - stats.total_containers = Some(albums.len()); - } - - if let Ok(tracks) = self.inner.client.get_favorite_tracks().await { - stats.total_items = Some(tracks.len()); - } - - // Get cache statistics from manager - let cache_stats = self.inner.cache_manager.statistics().await; - stats.cached_items = Some(cache_stats.cached_tracks); - - Ok(stats) - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_default_image_present() { - assert!(DEFAULT_IMAGE.len() > 0, "Default image should not be empty"); - - // Check WebP magic bytes (RIFF...WEBP) - assert!( - DEFAULT_IMAGE.len() >= 12, - "Image too small to be valid WebP" - ); - assert_eq!(&DEFAULT_IMAGE[0..4], b"RIFF", "Missing RIFF header"); - assert_eq!(&DEFAULT_IMAGE[8..12], b"WEBP", "Missing WEBP signature"); - } - - // Note: We can't easily test parse_object_id without creating a real client - // which requires authentication. The parsing logic is simple enough that - // it's covered by integration tests. -} -========= End of pmoqobuz/src/source.rs =========== - -=============== pmoqobuz/src/api_rest.rs ============ -//! Endpoints API REST pour Qobuz -//! -//! Ce module définit les handlers HTTP pour accéder aux fonctionnalités Qobuz. - -#[cfg(feature = "pmoserver")] -use axum::{ - extract::{Path, Query, State}, - http::StatusCode, - response::{IntoResponse, Response}, - Json, Router, -}; - -#[cfg(feature = "pmoserver")] -use serde::{Deserialize, Serialize}; - -#[cfg(feature = "pmoserver")] -use std::sync::Arc; - -#[cfg(feature = "pmoserver")] -use crate::{client::QobuzClient, error::QobuzError, models::*}; - -/// État partagé de l'application -#[cfg(feature = "pmoserver")] -#[derive(Clone)] -pub struct QobuzState { - pub client: Arc, - #[cfg(feature = "covers")] - pub cover_cache: Option>, -} - -/// Paramètres de recherche -#[cfg(feature = "pmoserver")] -#[derive(Debug, Deserialize)] -pub struct SearchParams { - /// Requête de recherche - pub q: String, - /// Type de recherche (albums, artists, tracks, playlists) - #[serde(rename = "type")] - pub search_type: Option, -} - -/// Paramètres pour featured albums -#[cfg(feature = "pmoserver")] -#[derive(Debug, Deserialize)] -pub struct FeaturedAlbumsParams { - /// ID du genre (optionnel) - pub genre_id: Option, - /// Type (new-releases, ideal-discography, etc.) - #[serde(rename = "type", default = "default_featured_type")] - pub type_: String, -} - -#[cfg(feature = "pmoserver")] -fn default_featured_type() -> String { - "new-releases".to_string() -} - -/// Paramètres pour featured playlists -#[cfg(feature = "pmoserver")] -#[derive(Debug, Deserialize)] -pub struct FeaturedPlaylistsParams { - /// ID du genre (optionnel) - pub genre_id: Option, - /// Tags (optionnel) - pub tags: Option, -} - -/// Crée le router Axum avec tous les endpoints Qobuz -#[cfg(feature = "pmoserver")] -pub fn create_router(state: QobuzState) -> Router { - Router::new() - // Albums - .route("/albums/:id", axum::routing::get(get_album)) - .route("/albums/:id/tracks", axum::routing::get(get_album_tracks)) - // Tracks - .route("/tracks/:id", axum::routing::get(get_track)) - .route("/tracks/:id/stream", axum::routing::get(get_stream_url)) - // Artists - .route("/artists/:id/albums", axum::routing::get(get_artist_albums)) - .route( - "/artists/:id/similar", - axum::routing::get(get_similar_artists), - ) - // Playlists - .route("/playlists/:id", axum::routing::get(get_playlist)) - .route( - "/playlists/:id/tracks", - axum::routing::get(get_playlist_tracks), - ) - // Recherche - .route("/search", axum::routing::get(search)) - // Favoris - .route("/favorites/albums", axum::routing::get(get_favorite_albums)) - .route( - "/favorites/artists", - axum::routing::get(get_favorite_artists), - ) - .route("/favorites/tracks", axum::routing::get(get_favorite_tracks)) - .route( - "/favorites/playlists", - axum::routing::get(get_user_playlists), - ) - // Catalogue - .route("/genres", axum::routing::get(get_genres)) - .route("/featured/albums", axum::routing::get(get_featured_albums)) - .route( - "/featured/playlists", - axum::routing::get(get_featured_playlists), - ) - // Cache - .route("/cache/stats", axum::routing::get(get_cache_stats)) - .with_state(state) -} - -// ============ Handlers ============ - -#[cfg(feature = "pmoserver")] -async fn get_album( - State(state): State, - Path(id): Path, -) -> Result, AppError> { - let mut album = state.client.get_album(&id).await?; - - #[cfg(feature = "covers")] - if let Some(ref cover_cache) = state.cover_cache { - album = cache_album_image(album, cover_cache).await; - } - - Ok(Json(album)) -} - -#[cfg(feature = "pmoserver")] -async fn get_album_tracks( - State(state): State, - Path(id): Path, -) -> Result>, AppError> { - let tracks = state.client.get_album_tracks(&id).await?; - Ok(Json(tracks)) -} - -#[cfg(feature = "pmoserver")] -async fn get_track( - State(state): State, - Path(id): Path, -) -> Result, AppError> { - let track = state.client.get_track(&id).await?; - Ok(Json(track)) -} - -#[cfg(feature = "pmoserver")] -async fn get_stream_url( - State(state): State, - Path(id): Path, -) -> Result, AppError> { - let url = state.client.get_stream_url(&id).await?; - Ok(Json(serde_json::json!({ "url": url }))) -} - -#[cfg(feature = "pmoserver")] -async fn get_artist_albums( - State(state): State, - Path(id): Path, -) -> Result>, AppError> { - let mut albums = state.client.get_artist_albums(&id).await?; - - #[cfg(feature = "covers")] - if let Some(ref cover_cache) = state.cover_cache { - albums = cache_albums_images(albums, cover_cache).await; - } - - Ok(Json(albums)) -} - -#[cfg(feature = "pmoserver")] -async fn get_similar_artists( - State(state): State, - Path(id): Path, -) -> Result>, AppError> { - let artists = state.client.get_similar_artists(&id).await?; - Ok(Json(artists)) -} - -#[cfg(feature = "pmoserver")] -async fn get_playlist( - State(state): State, - Path(id): Path, -) -> Result, AppError> { - let playlist = state.client.get_playlist(&id).await?; - Ok(Json(playlist)) -} - -#[cfg(feature = "pmoserver")] -async fn get_playlist_tracks( - State(state): State, - Path(id): Path, -) -> Result>, AppError> { - let tracks = state.client.get_playlist_tracks(&id).await?; - Ok(Json(tracks)) -} - -#[cfg(feature = "pmoserver")] -async fn search( - State(state): State, - Query(params): Query, -) -> Result, AppError> { - let mut result = state - .client - .search(¶ms.q, params.search_type.as_deref()) - .await?; - - #[cfg(feature = "covers")] - if let Some(ref cover_cache) = state.cover_cache { - result.albums = cache_albums_images(result.albums, cover_cache).await; - } - - Ok(Json(result)) -} - -#[cfg(feature = "pmoserver")] -async fn get_favorite_albums( - State(state): State, -) -> Result>, AppError> { - let mut albums = state.client.get_favorite_albums().await?; - - #[cfg(feature = "covers")] - if let Some(ref cover_cache) = state.cover_cache { - albums = cache_albums_images(albums, cover_cache).await; - } - - Ok(Json(albums)) -} - -#[cfg(feature = "pmoserver")] -async fn get_favorite_artists( - State(state): State, -) -> Result>, AppError> { - let artists = state.client.get_favorite_artists().await?; - Ok(Json(artists)) -} - -#[cfg(feature = "pmoserver")] -async fn get_favorite_tracks( - State(state): State, -) -> Result>, AppError> { - let tracks = state.client.get_favorite_tracks().await?; - Ok(Json(tracks)) -} - -#[cfg(feature = "pmoserver")] -async fn get_user_playlists( - State(state): State, -) -> Result>, AppError> { - let playlists = state.client.get_user_playlists().await?; - Ok(Json(playlists)) -} - -#[cfg(feature = "pmoserver")] -async fn get_genres(State(state): State) -> Result>, AppError> { - let genres = state.client.get_genres().await?; - Ok(Json(genres)) -} - -#[cfg(feature = "pmoserver")] -async fn get_featured_albums( - State(state): State, - Query(params): Query, -) -> Result>, AppError> { - let mut albums = state - .client - .get_featured_albums(params.genre_id.as_deref(), ¶ms.type_) - .await?; - - #[cfg(feature = "covers")] - if let Some(ref cover_cache) = state.cover_cache { - albums = cache_albums_images(albums, cover_cache).await; - } - - Ok(Json(albums)) -} - -#[cfg(feature = "pmoserver")] -async fn get_featured_playlists( - State(state): State, - Query(params): Query, -) -> Result>, AppError> { - let playlists = state - .client - .get_featured_playlists(params.genre_id.as_deref(), params.tags.as_deref()) - .await?; - Ok(Json(playlists)) -} - -#[cfg(feature = "pmoserver")] -async fn get_cache_stats( - State(state): State, -) -> Result, AppError> { - let stats = state.client.cache().stats().await; - Ok(Json(stats)) -} - -// ============ Helpers pour le cache d'images ============ - -#[cfg(all(feature = "pmoserver", feature = "covers"))] -async fn cache_album_image(mut album: Album, cover_cache: &Arc) -> Album { - if let Some(ref image_url) = album.image { - match cover_cache.add_from_url(image_url, None).await { - Ok(pk) => { - album.image_cached = Some(format!("/covers/images/{}", pk)); - } - Err(e) => { - tracing::warn!("Failed to cache album image: {}", e); - } - } - } - album -} - -#[cfg(all(feature = "pmoserver", feature = "covers"))] -async fn cache_albums_images( - albums: Vec, - cover_cache: &Arc, -) -> Vec { - let mut cached_albums = Vec::with_capacity(albums.len()); - for album in albums { - cached_albums.push(cache_album_image(album, cover_cache).await); - } - cached_albums -} - -// ============ Gestion des erreurs ============ - -#[cfg(feature = "pmoserver")] -struct AppError(QobuzError); - -#[cfg(feature = "pmoserver")] -impl IntoResponse for AppError { - fn into_response(self) -> Response { - let (status, message) = match self.0 { - QobuzError::Unauthorized(_) => (StatusCode::UNAUTHORIZED, self.0.to_string()), - QobuzError::NotFound(_) => (StatusCode::NOT_FOUND, self.0.to_string()), - QobuzError::RateLimitExceeded => (StatusCode::TOO_MANY_REQUESTS, self.0.to_string()), - _ => (StatusCode::INTERNAL_SERVER_ERROR, self.0.to_string()), - }; - - let body = Json(serde_json::json!({ - "error": message - })); - - (status, body).into_response() - } -} - -#[cfg(feature = "pmoserver")] -impl From for AppError -where - E: Into, -{ - fn from(err: E) -> Self { - Self(err.into()) - } -} -========= End of pmoqobuz/src/api_rest.rs =========== - -=============== pmoqobuz/src/config_ext.rs ============ -//! Extension pour intégrer la configuration Qobuz dans pmoconfig -//! -//! Ce module fournit le trait `QobuzConfigExt` qui permet d'ajouter facilement -//! des méthodes de gestion des credentials Qobuz à pmoconfig::Config. - -use anyhow::{anyhow, Result}; -use pmoconfig::Config; -use serde_yaml::Value; - -/// Trait d'extension pour gérer la configuration Qobuz dans pmoconfig -/// -/// Ce trait étend `pmoconfig::Config` avec des méthodes spécifiques -/// aux credentials et paramètres Qobuz. -/// -/// # Exemple -/// -/// ```rust,ignore -/// use pmoconfig::get_config; -/// use pmoqobuz::QobuzConfigExt; -/// -/// let config = get_config(); -/// let (username, password) = config.get_qobuz_credentials()?; -/// println!("Qobuz user: {}", username); -/// ``` -pub trait QobuzConfigExt { - /// Récupère le nom d'utilisateur Qobuz depuis la configuration - /// - /// # Returns - /// - /// Le nom d'utilisateur (email) configuré pour Qobuz - /// - /// # Errors - /// - /// Retourne une erreur si le nom d'utilisateur n'est pas configuré - fn get_qobuz_username(&self) -> Result; - - /// Définit le nom d'utilisateur Qobuz dans la configuration - /// - /// # Arguments - /// - /// * `username` - Le nom d'utilisateur (email) Qobuz - fn set_qobuz_username(&self, username: &str) -> Result<()>; - - /// Récupère le mot de passe Qobuz depuis la configuration - /// - /// # Returns - /// - /// Le mot de passe configuré pour Qobuz - /// - /// # Errors - /// - /// Retourne une erreur si le mot de passe n'est pas configuré - fn get_qobuz_password(&self) -> Result; - - /// Définit le mot de passe Qobuz dans la configuration - /// - /// # Arguments - /// - /// * `password` - Le mot de passe Qobuz - fn set_qobuz_password(&self, password: &str) -> Result<()>; - - /// Récupère les credentials Qobuz (username et password) - /// - /// # Returns - /// - /// Un tuple (username, password) contenant les credentials Qobuz - /// - /// # Errors - /// - /// Retourne une erreur si l'un des credentials n'est pas configuré - /// - /// # Exemple - /// - /// ```rust,ignore - /// use pmoconfig::get_config; - /// use pmoqobuz::QobuzConfigExt; - /// - /// let config = get_config(); - /// match config.get_qobuz_credentials() { - /// Ok((username, password)) => { - /// println!("Credentials configured for: {}", username); - /// } - /// Err(e) => { - /// eprintln!("Qobuz credentials not configured: {}", e); - /// } - /// } - /// ``` - fn get_qobuz_credentials(&self) -> Result<(String, String)>; - - /// Récupère l'App ID Qobuz depuis la configuration - /// - /// # Returns - /// - /// L'App ID configuré pour Qobuz, ou None si non configuré - /// - /// # Note - /// - /// Si aucun App ID n'est configuré, le client utilisera soit le Spoofer - /// pour en obtenir un dynamiquement, soit un App ID par défaut. - fn get_qobuz_appid(&self) -> Result>; - - /// Définit l'App ID Qobuz dans la configuration - /// - /// # Arguments - /// - /// * `appid` - L'App ID Qobuz (ex: "1401488693436528") - fn set_qobuz_appid(&self, appid: &str) -> Result<()>; - - /// Récupère le secret Qobuz depuis la configuration - /// - /// # Returns - /// - /// Le secret encodé en base64, ou None si non configuré - /// - /// # Note - /// - /// Le secret est la valeur `configvalue` du code Python. - /// Il est décodé et XORé avec l'App ID pour obtenir le secret `s4` - /// utilisé pour signer les requêtes sensibles. - /// - /// Si aucun secret n'est configuré, le client utilisera le Spoofer - /// pour en obtenir un dynamiquement. - fn get_qobuz_secret(&self) -> Result>; - - /// Définit le secret Qobuz dans la configuration - /// - /// # Arguments - /// - /// * `secret` - Le secret encodé en base64 (configvalue) - fn set_qobuz_secret(&self, secret: &str) -> Result<()>; - - /// Récupère le token d'authentification depuis la configuration - /// - /// # Returns - /// - /// Le token d'authentification, ou None si non configuré ou expiré - fn get_qobuz_auth_token(&self) -> Result>; - - /// Récupère l'ID utilisateur depuis la configuration - /// - /// # Returns - /// - /// L'ID utilisateur, ou None si non configuré - fn get_qobuz_user_id(&self) -> Result>; - - /// Récupère le timestamp d'expiration du token - /// - /// # Returns - /// - /// Le timestamp d'expiration (Unix timestamp), ou None si non configuré - fn get_qobuz_token_expires_at(&self) -> Result>; - - /// Récupère le label de l'abonnement depuis la configuration - fn get_qobuz_subscription_label(&self) -> Result>; - - /// Sauvegarde les informations d'authentification dans la configuration - /// - /// # Arguments - /// - /// * `token` - Le token d'authentification - /// * `user_id` - L'ID utilisateur - /// * `subscription_label` - Le label de l'abonnement (optionnel) - /// * `expires_at` - Timestamp d'expiration (Unix timestamp) - fn set_qobuz_auth_info( - &self, - token: &str, - user_id: &str, - subscription_label: Option<&str>, - expires_at: u64, - ) -> Result<()>; - - /// Supprime les informations d'authentification de la configuration - fn clear_qobuz_auth_info(&self) -> Result<()>; - - /// Vérifie si le token d'authentification est encore valide - /// - /// # Returns - /// - /// true si un token existe et n'est pas expiré, false sinon - fn is_qobuz_auth_valid(&self) -> bool; - - /// Récupère le répertoire de cache Qobuz - /// - /// # Returns - /// - /// Le chemin absolu du répertoire de cache, créé s'il n'existe pas - fn get_qobuz_cache_dir(&self) -> Result; - - /// Définit le répertoire de cache Qobuz - fn set_qobuz_cache_dir(&self, directory: String) -> Result<()>; - - /// Récupère le nombre maximum de requêtes concurrentes - /// - /// # Returns - /// - /// Le nombre maximum de requêtes concurrentes, ou None si non configuré (défaut: 2) - fn get_qobuz_rate_limit_max_concurrent(&self) -> Result>; - - /// Définit le nombre maximum de requêtes concurrentes - fn set_qobuz_rate_limit_max_concurrent(&self, max: usize) -> Result<()>; - - /// Récupère le délai minimum entre requêtes en millisecondes - /// - /// # Returns - /// - /// Le délai minimum en ms, ou None si non configuré (défaut: 400ms) - fn get_qobuz_rate_limit_min_delay_ms(&self) -> Result>; - - /// Définit le délai minimum entre requêtes - fn set_qobuz_rate_limit_min_delay_ms(&self, delay_ms: u64) -> Result<()>; - - /// Vérifie si le rate limiting est activé - /// - /// # Returns - /// - /// true si activé (défaut), false sinon - fn is_qobuz_rate_limiting_enabled(&self) -> bool; - - /// Active ou désactive le rate limiting - fn set_qobuz_rate_limiting_enabled(&self, enabled: bool) -> Result<()>; -} - -impl QobuzConfigExt for Config { - fn get_qobuz_username(&self) -> Result { - match self.get_value(&["accounts", "qobuz", "username"])? { - Value::String(s) => Ok(s), - _ => Err(anyhow!("Qobuz username not configured")), - } - } - - fn set_qobuz_username(&self, username: &str) -> Result<()> { - self.set_value( - &["accounts", "qobuz", "username"], - Value::String(username.to_string()), - ) - } - - fn get_qobuz_password(&self) -> Result { - match self.get_value(&["accounts", "qobuz", "password"])? { - Value::String(s) => { - // Déchiffrement automatique si le mot de passe est chiffré - pmoconfig::encryption::get_password(&s) - .map_err(|e| anyhow!("Failed to decrypt password: {}", e)) - } - _ => Err(anyhow!("Qobuz password not configured")), - } - } - - fn set_qobuz_password(&self, password: &str) -> Result<()> { - self.set_value( - &["accounts", "qobuz", "password"], - Value::String(password.to_string()), - ) - } - - fn get_qobuz_credentials(&self) -> Result<(String, String)> { - let username = self.get_qobuz_username()?; - let password = self.get_qobuz_password()?; - Ok((username, password)) - } - - fn get_qobuz_appid(&self) -> Result> { - match self.get_value(&["accounts", "qobuz", "appid"]) { - Ok(Value::String(s)) if !s.is_empty() => Ok(Some(s)), - Ok(Value::String(_)) => Ok(None), // Empty string - Ok(_) => Ok(None), // Wrong type - Err(_) => Ok(None), // Not configured - } - } - - fn set_qobuz_appid(&self, appid: &str) -> Result<()> { - self.set_value( - &["accounts", "qobuz", "appid"], - Value::String(appid.to_string()), - ) - } - - fn get_qobuz_secret(&self) -> Result> { - match self.get_value(&["accounts", "qobuz", "secret"]) { - Ok(Value::String(s)) if !s.is_empty() => Ok(Some(s)), - Ok(Value::String(_)) => Ok(None), // Empty string - Ok(_) => Ok(None), // Wrong type - Err(_) => Ok(None), // Not configured - } - } - - fn set_qobuz_secret(&self, secret: &str) -> Result<()> { - self.set_value( - &["accounts", "qobuz", "secret"], - Value::String(secret.to_string()), - ) - } - - fn get_qobuz_auth_token(&self) -> Result> { - match self.get_value(&["accounts", "qobuz", "auth_token"]) { - Ok(Value::String(s)) if !s.is_empty() => Ok(Some(s)), - Ok(Value::String(_)) => Ok(None), // Empty string - Ok(_) => Ok(None), // Wrong type - Err(_) => Ok(None), // Not configured - } - } - - fn get_qobuz_user_id(&self) -> Result> { - match self.get_value(&["accounts", "qobuz", "user_id"]) { - Ok(Value::String(s)) if !s.is_empty() => Ok(Some(s)), - Ok(Value::String(_)) => Ok(None), // Empty string - Ok(_) => Ok(None), // Wrong type - Err(_) => Ok(None), // Not configured - } - } - - fn get_qobuz_token_expires_at(&self) -> Result> { - match self.get_value(&["accounts", "qobuz", "token_expires_at"]) { - Ok(Value::Number(n)) if n.is_u64() => Ok(Some(n.as_u64().unwrap())), - Ok(Value::Number(n)) if n.is_i64() => Ok(Some(n.as_i64().unwrap() as u64)), - Ok(_) => Ok(None), // Wrong type - Err(_) => Ok(None), // Not configured - } - } - - fn get_qobuz_subscription_label(&self) -> Result> { - match self.get_value(&["accounts", "qobuz", "subscription_label"]) { - Ok(Value::String(s)) if !s.is_empty() => Ok(Some(s)), - Ok(Value::String(_)) => Ok(None), // Empty string - Ok(_) => Ok(None), // Wrong type - Err(_) => Ok(None), // Not configured - } - } - - fn set_qobuz_auth_info( - &self, - token: &str, - user_id: &str, - subscription_label: Option<&str>, - expires_at: u64, - ) -> Result<()> { - self.set_value( - &["accounts", "qobuz", "auth_token"], - Value::String(token.to_string()), - )?; - self.set_value( - &["accounts", "qobuz", "user_id"], - Value::String(user_id.to_string()), - )?; - self.set_value( - &["accounts", "qobuz", "token_expires_at"], - Value::Number(serde_yaml::Number::from(expires_at)), - )?; - - if let Some(label) = subscription_label { - self.set_value( - &["accounts", "qobuz", "subscription_label"], - Value::String(label.to_string()), - )?; - } - - Ok(()) - } - - fn clear_qobuz_auth_info(&self) -> Result<()> { - // On ne propage pas les erreurs car les valeurs peuvent ne pas exister - let _ = self.set_value(&["accounts", "qobuz", "auth_token"], Value::String(String::new())); - let _ = self.set_value(&["accounts", "qobuz", "user_id"], Value::String(String::new())); - let _ = self.set_value( - &["accounts", "qobuz", "token_expires_at"], - Value::Number(serde_yaml::Number::from(0)), - ); - let _ = self.set_value( - &["accounts", "qobuz", "subscription_label"], - Value::String(String::new()), - ); - Ok(()) - } - - fn is_qobuz_auth_valid(&self) -> bool { - // Vérifier si un token existe - if self.get_qobuz_auth_token().ok().flatten().is_none() { - return false; - } - - // Vérifier si le token n'est pas expiré - if let Ok(Some(expires_at)) = self.get_qobuz_token_expires_at() { - use std::time::{SystemTime, UNIX_EPOCH}; - let now = SystemTime::now() - .duration_since(UNIX_EPOCH) - .unwrap() - .as_secs(); - - now < expires_at - } else { - false - } - } - - fn get_qobuz_cache_dir(&self) -> Result { - self.get_managed_dir(&["host", "qobuz_cache", "directory"], "cache_qobuz") - } - - fn set_qobuz_cache_dir(&self, directory: String) -> Result<()> { - self.set_managed_dir(&["host", "qobuz_cache", "directory"], directory) - } - - fn get_qobuz_rate_limit_max_concurrent(&self) -> Result> { - match self.get_value(&["accounts", "qobuz", "rate_limit", "max_concurrent"]) { - Ok(Value::Number(n)) if n.is_u64() => Ok(Some(n.as_u64().unwrap() as usize)), - Ok(_) => Ok(None), - Err(_) => Ok(Some(2)), // Default: 2 concurrent requests - } - } - - fn set_qobuz_rate_limit_max_concurrent(&self, max: usize) -> Result<()> { - self.set_value( - &["accounts", "qobuz", "rate_limit", "max_concurrent"], - Value::Number(serde_yaml::Number::from(max)), - ) - } - - fn get_qobuz_rate_limit_min_delay_ms(&self) -> Result> { - match self.get_value(&["accounts", "qobuz", "rate_limit", "min_delay_ms"]) { - Ok(Value::Number(n)) if n.is_u64() => Ok(Some(n.as_u64().unwrap())), - Ok(_) => Ok(None), - Err(_) => Ok(Some(400)), // Default: 400ms - } - } - - fn set_qobuz_rate_limit_min_delay_ms(&self, delay_ms: u64) -> Result<()> { - self.set_value( - &["accounts", "qobuz", "rate_limit", "min_delay_ms"], - Value::Number(serde_yaml::Number::from(delay_ms)), - ) - } - - fn is_qobuz_rate_limiting_enabled(&self) -> bool { - match self.get_value(&["accounts", "qobuz", "rate_limit", "enabled"]) { - Ok(Value::Bool(b)) => b, - _ => true, // Default: enabled - } - } - - fn set_qobuz_rate_limiting_enabled(&self, enabled: bool) -> Result<()> { - self.set_value( - &["accounts", "qobuz", "rate_limit", "enabled"], - Value::Bool(enabled), - ) - } -} -========= End of pmoqobuz/src/config_ext.rs =========== - -=============== pmoqobuz/src/pmoserver_impl.rs ============ -//! Implémentation du trait QobuzServerExt pour pmoserver::Server -//! -//! Ce module enrichit `pmoserver::Server` avec les fonctionnalités du client Qobuz en -//! implémentant le trait [`QobuzServerExt`](crate::QobuzServerExt). Cette implémentation -//! permet d'initialiser facilement le client Qobuz et d'enregistrer les routes HTTP. -//! -//! ## Architecture -//! -//! `pmoqobuz` étend `pmoserver::Server` sans que `pmoserver` connaisse `pmoqobuz`. -//! C'est le pattern d'extension : `pmoqobuz` ajoute des fonctionnalités à un type -//! externe via un trait, similaire au pattern utilisé par `pmocovers` pour `CoverCacheExt`. -//! -//! ## Exemple d'utilisation -//! -//! ```rust,no_run -//! use pmoqobuz::QobuzServerExt; -//! use pmoserver::ServerBuilder; -//! -//! # async fn example() -> anyhow::Result<()> { -//! let mut server = ServerBuilder::new_configured().build(); -//! -//! // Le trait QobuzServerExt est automatiquement disponible -//! let client = server.init_qobuz_client_configured().await?; -//! -//! server.start().await; -//! # Ok(()) -//! # } -//! ``` - -use crate::api_rest::{create_router, QobuzState}; -use crate::client::QobuzClient; -use crate::pmoserver_ext::QobuzServerExt; -use anyhow::Result; -use pmoconfig::Config; -use pmoserver::Server; -use std::sync::Arc; -use tracing::info; - -impl QobuzServerExt for Server { - async fn init_qobuz_client( - &mut self, - username: &str, - password: &str, - ) -> Result> { - info!("Initializing Qobuz client for user: {}", username); - - // Créer le client Qobuz - let client = QobuzClient::new(username, password).await?; - let client = Arc::new(client); - - // Créer l'état de l'API sans cache d'images - let state = QobuzState { - client: client.clone(), - #[cfg(feature = "covers")] - cover_cache: None, - }; - - // Créer le router et l'enregistrer - let router = create_router(state); - self.add_router("/qobuz", router).await; - - info!("Qobuz client initialized successfully"); - info!("API endpoints available at /qobuz/*"); - - Ok(client) - } - - async fn init_qobuz_client_configured(&mut self) -> Result> { - info!("Initializing Qobuz client from configuration"); - - // Récupérer les credentials depuis la config - let config = pmoconfig::get_config(); - let (username, password) = config.get_qobuz_credentials()?; - - self.init_qobuz_client(&username, &password).await - } - - #[cfg(feature = "covers")] - async fn init_qobuz_client_with_covers( - &mut self, - username: &str, - password: &str, - cover_cache: Arc, - ) -> Result> { - info!("Initializing Qobuz client with pmocovers integration"); - - // Créer le client Qobuz - let client = QobuzClient::new(username, password).await?; - let client = Arc::new(client); - - info!("pmocovers integration enabled - album images will be cached automatically"); - - // Créer l'état de l'API avec le cache - let state = QobuzState { - client: client.clone(), - cover_cache: Some(cover_cache), - }; - - // Créer le router et l'enregistrer - let router = create_router(state); - self.add_router("/qobuz", router).await; - - info!("Qobuz client initialized successfully with covers"); - info!("API endpoints available at /qobuz/*"); - - Ok(client) - } - - #[cfg(feature = "covers")] - async fn init_qobuz_client_configured_with_covers( - &mut self, - cover_cache: Arc, - ) -> Result> { - info!("Initializing Qobuz client from configuration with pmocovers"); - - // Récupérer les credentials depuis la config - let config = pmoconfig::get_config(); - let (username, password) = config.get_qobuz_credentials()?; - - self.init_qobuz_client_with_covers(&username, &password, cover_cache) - .await - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_trait_implemented() { - // Ce test vérifie simplement que le trait est bien implémenté - // Les tests fonctionnels nécessiteraient un serveur et des credentials réels - } -} -========= End of pmoqobuz/src/pmoserver_impl.rs =========== - -=============== pmoqobuz/src/api/spoofer.rs ============ -use anyhow::Result; -use base64::{engine::general_purpose::STANDARD, Engine}; -use indexmap::IndexMap; -use regex::Regex; -use reqwest::Client; - -pub struct Spoofer { - bundle: String, - seed_timezone_regex: Regex, - info_extras_regex_template: String, - app_id_regex: Regex, -} - -impl Spoofer { - /// Crée un nouveau Spoofer et télécharge le bundle.js - pub async fn new() -> Result { - // Expressions régulières (équivalent Python) - let seed_timezone_regex = Regex::new( - r#"[a-z]\.initialSeed\("(?P[\w=]+)",window\.utimezone\.(?P[a-z]+)\)"#, - )?; - - let info_extras_regex_template = - r#"name:"\w+/(?P{timezones})",info:"(?P[\w=]+)",extras:"(?P[\w=]+)""# - .to_string(); - - let app_id_regex = Regex::new( - r#"production:\{api:\{appId:"(?P\d{9})",appSecret:"(?P\w{32})"\},braze:.\(.\(\{\},.\),\{\},\{apiKey:"([-0-9a-fA-F]{36})"\}\),extra:.\}"#, - )?; - - // Créer un client HTTP - let client = Client::builder() - .user_agent("Mozilla/5.0 (compatible; PMOMusic/1.0)") - .build()?; - - println!("Récupération de la page de login..."); - let login_page = client - .get("https://play.qobuz.com/login") - .send() - .await? - .text() - .await?; - - // Extraire l'URL du bundle - let bundle_url_regex = - Regex::new(r#""#)?; - let bundle_url = bundle_url_regex - .captures(&login_page) - .and_then(|cap| cap.get(1)) - .ok_or_else(|| anyhow::anyhow!("Impossible de trouver l'URL du bundle"))? - .as_str(); - - println!("Téléchargement du bundle depuis: {}", bundle_url); - let bundle_full_url = format!("https://play.qobuz.com{}", bundle_url); - let bundle = client.get(&bundle_full_url).send().await?.text().await?; - - println!("Bundle téléchargé ({} bytes)", bundle.len()); - - Ok(Self { - bundle, - seed_timezone_regex, - info_extras_regex_template, - app_id_regex, - }) - } - - /// Extrait l'App ID depuis le bundle - pub fn get_app_id(&self) -> Result { - let captures = self - .app_id_regex - .captures(&self.bundle) - .ok_or_else(|| anyhow::anyhow!("AppID non trouvé dans le bundle"))?; - - Ok(captures - .name("app_id") - .ok_or_else(|| anyhow::anyhow!("Groupe app_id non trouvé"))? - .as_str() - .to_string()) - } - - /// Extrait les secrets depuis le bundle - pub fn get_secrets(&self) -> Result> { - // Étape 1: Extraire tous les seed/timezone pairs - let mut secrets: IndexMap> = IndexMap::new(); - - for captures in self.seed_timezone_regex.captures_iter(&self.bundle) { - let seed = captures - .name("seed") - .ok_or_else(|| anyhow::anyhow!("Groupe seed non trouvé"))? - .as_str(); - let timezone = captures - .name("timezone") - .ok_or_else(|| anyhow::anyhow!("Groupe timezone non trouvé"))? - .as_str(); - - secrets - .entry(timezone.to_string()) - .or_insert_with(Vec::new) - .push(seed.to_string()); - } - - println!("Timezones trouvées: {:?}", secrets.keys()); - - // Étape 2: Réordonner - on met la deuxième timezone en premier - // (comme le fait le code Python avec move_to_end) - if secrets.len() >= 2 { - let keys: Vec = secrets.keys().cloned().collect(); - let second_key = keys[1].clone(); - let second_value = secrets.get(&second_key).unwrap().clone(); - - // Retirer et réinsérer pour le mettre en premier - secrets.shift_remove(&second_key); - let mut new_secrets = IndexMap::new(); - new_secrets.insert(second_key, second_value); - for (k, v) in secrets { - new_secrets.insert(k, v); - } - secrets = new_secrets; - } - - // Étape 3: Construire la regex pour info/extras - let timezones_capitalized: Vec = secrets - .keys() - .map(|tz| { - let mut chars = tz.chars(); - match chars.next() { - None => String::new(), - Some(first) => first.to_uppercase().collect::() + chars.as_str(), - } - }) - .collect(); - - let info_extras_regex_str = self - .info_extras_regex_template - .replace("{timezones}", &timezones_capitalized.join("|")); - - let info_extras_regex = Regex::new(&info_extras_regex_str)?; - - // Étape 4: Extraire info et extras pour chaque timezone - for captures in info_extras_regex.captures_iter(&self.bundle) { - let timezone_cap = captures - .name("timezone") - .ok_or_else(|| anyhow::anyhow!("Groupe timezone non trouvé"))? - .as_str(); - let info = captures - .name("info") - .ok_or_else(|| anyhow::anyhow!("Groupe info non trouvé"))? - .as_str(); - let extras = captures - .name("extras") - .ok_or_else(|| anyhow::anyhow!("Groupe extras non trouvé"))? - .as_str(); - - let timezone_lower = timezone_cap.to_lowercase(); - if let Some(vec) = secrets.get_mut(&timezone_lower) { - vec.push(info.to_string()); - vec.push(extras.to_string()); - } - } - - // Étape 5: Décoder les secrets en base64 - let mut decoded_secrets = IndexMap::new(); - for (timezone, parts) in secrets { - let concatenated = parts.join(""); - - // Retirer les 44 derniers caractères (comme Python [:-44]) - if concatenated.len() > 44 { - let trimmed = &concatenated[..concatenated.len() - 44]; - - // Décoder en base64 - match STANDARD.decode(trimmed) { - Ok(decoded_bytes) => { - match String::from_utf8(decoded_bytes) { - Ok(decoded_str) => { - decoded_secrets.insert(timezone, decoded_str); - } - Err(e) => { - eprintln!( - "Erreur UTF-8 pour timezone {}: {}", - timezone, e - ); - } - } - } - Err(e) => { - eprintln!( - "Erreur de décodage base64 pour timezone {}: {}", - timezone, e - ); - } - } - } - } - - Ok(decoded_secrets) - } -} -========= End of pmoqobuz/src/api/spoofer.rs =========== - -=============== pmoqobuz/src/api/auth.rs ============ -//! Module d'authentification pour l'API Qobuz - -use super::QobuzApi; -use crate::error::{QobuzError, Result}; -use serde::{Deserialize, Serialize}; -use tracing::{debug, info}; - -/// Réponse de l'endpoint /user/login -#[derive(Debug, Deserialize)] -struct LoginResponse { - user: UserInfo, - user_auth_token: String, -} - -/// Informations utilisateur retournées par l'API -#[derive(Debug, Deserialize)] -struct UserInfo { - #[serde(deserialize_with = "crate::models::deserialize_id")] - id: String, - #[serde(default)] - email: Option, - #[serde(default)] - firstname: Option, - #[serde(default)] - lastname: Option, - credential: CredentialInfo, -} - -/// Informations sur les credentials de l'utilisateur -#[derive(Debug, Deserialize)] -struct CredentialInfo { - #[serde(default)] - parameters: Option, -} - -/// Paramètres du niveau d'abonnement -#[derive(Debug, Deserialize)] -struct CredentialParameters { - #[serde(default)] - short_label: Option, -} - -/// Informations d'authentification -#[derive(Debug, Clone, Serialize, Deserialize)] -pub struct AuthInfo { - /// Token d'authentification - pub token: String, - /// ID utilisateur - pub user_id: String, - /// Label de l'abonnement (ex: "Studio", "Hi-Fi", etc.) - pub subscription_label: Option, -} - -impl QobuzApi { - /// Authentifie l'utilisateur avec username et password - /// - /// # Arguments - /// - /// * `username` - Email ou nom d'utilisateur Qobuz - /// * `password` - Mot de passe - /// - /// # Returns - /// - /// Retourne les informations d'authentification si le login est réussi - /// - /// # Errors - /// - /// * `QobuzError::Unauthorized` - Credentials invalides - /// * `QobuzError::SubscriptionRequired` - Compte gratuit (non éligible) - pub async fn login(&mut self, username: &str, password: &str) -> Result { - info!("Attempting to login to Qobuz as {}", username); - - let params = [("username", username), ("password", password)]; - - let response: LoginResponse = self.post("/user/login", ¶ms).await?; - - // Vérifier que l'utilisateur a un abonnement valide - if response.user.credential.parameters.is_none() { - return Err(QobuzError::SubscriptionRequired( - "Free accounts are not eligible for streaming".to_string(), - )); - } - - let user_id = response.user.id; - let subscription_label = response - .user - .credential - .parameters - .and_then(|p| p.short_label); - - debug!( - "Login successful - User ID: {}, Subscription: {:?}", - user_id, subscription_label - ); - - // Stocker les informations d'authentification - self.set_auth_token(response.user_auth_token.clone(), user_id.clone()); - - Ok(AuthInfo { - token: response.user_auth_token, - user_id, - subscription_label, - }) - } - - /// Vérifie si le client est authentifié - pub fn is_authenticated(&self) -> bool { - self.user_auth_token.is_some() && self.user_id.is_some() - } - - /// Déconnecte l'utilisateur - pub fn logout(&mut self) { - debug!("Logging out"); - self.user_auth_token = None; - self.user_id = None; - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_is_authenticated() { - let mut api = QobuzApi::new("test_app_id").unwrap(); - assert!(!api.is_authenticated()); - - api.set_auth_token("token".to_string(), "user123".to_string()); - assert!(api.is_authenticated()); - - api.logout(); - assert!(!api.is_authenticated()); - } -} -========= End of pmoqobuz/src/api/auth.rs =========== - -=============== pmoqobuz/src/api/signing.rs ============ -//! Module de signature MD5 pour les requêtes Qobuz -//! -//! Certaines requêtes Qobuz (notamment track/getFileUrl et userLibrary/*) -//! nécessitent une signature MD5 incluant le secret s4. - -use md5::{Digest, Md5}; -use std::time::{SystemTime, UNIX_EPOCH}; - -/// Génère un timestamp Unix actuel -/// -/// # Returns -/// -/// Timestamp Unix sous forme de string avec décimales -/// -/// # Exemple -/// -/// ``` -/// use pmoqobuz::api::signing::get_timestamp; -/// let ts = get_timestamp(); -/// println!("Timestamp: {}", ts); -/// ``` -pub fn get_timestamp() -> String { - SystemTime::now() - .duration_since(UNIX_EPOCH) - .unwrap() - .as_secs_f64() - .to_string() -} - -/// Signe une requête track/getFileUrl -/// -/// Reproduit la logique Python: -/// ```python -/// stringvalue = ("trackgetFileUrlformat_id" + fmt_id + -/// "intent" + intent + -/// "track_id" + track_id + ts) -/// stringvalue += self.s4 -/// rq_sig = str(hashlib.md5(stringvalue).hexdigest()) -/// ``` -/// -/// # Arguments -/// -/// * `format_id` - ID du format audio (ex: "27") -/// * `intent` - Intention (typiquement "stream") -/// * `track_id` - ID de la track -/// * `timestamp` - Timestamp Unix -/// * `secret` - Secret s4 en bytes -/// -/// # Returns -/// -/// Signature MD5 hexadécimale -pub fn sign_track_get_file_url( - format_id: &str, - intent: &str, - track_id: &str, - timestamp: &str, - secret: &[u8], -) -> String { - let mut hasher = Md5::new(); - - // Construction de la chaîne à hasher - hasher.update(b"trackgetFileUrlformat_id"); - hasher.update(format_id.as_bytes()); - hasher.update(b"intent"); - hasher.update(intent.as_bytes()); - hasher.update(b"track_id"); - hasher.update(track_id.as_bytes()); - hasher.update(timestamp.as_bytes()); - hasher.update(secret); - - // Retourner le hash hexadécimal - format!("{:x}", hasher.finalize()) -} - -/// Signe une requête userLibrary/getAlbumsList -/// -/// Reproduit la logique Python: -/// ```python -/// r_sig = "userLibrarygetAlbumsList" + str(ts) + str(ka["sec"]) -/// r_sig_hashed = hashlib.md5(r_sig.encode("utf-8")).hexdigest() -/// ``` -/// -/// # Arguments -/// -/// * `timestamp` - Timestamp Unix -/// * `secret` - Secret s4 en bytes -/// -/// # Returns -/// -/// Signature MD5 hexadécimale -pub fn sign_userlib_get_albums(timestamp: &str, secret: &[u8]) -> String { - let mut hasher = Md5::new(); - - // Construction de la chaîne à hasher - hasher.update(b"userLibrarygetAlbumsList"); - hasher.update(timestamp.as_bytes()); - hasher.update(secret); - - // Retourner le hash hexadécimal - format!("{:x}", hasher.finalize()) -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_get_timestamp() { - let ts = get_timestamp(); - // Vérifier que c'est un nombre valide - assert!(ts.parse::().is_ok()); - // Vérifier que c'est proche du temps actuel (>= 2024) - assert!(ts.parse::().unwrap() > 1704067200.0); // 1er janvier 2024 - } - - #[test] - fn test_sign_track_get_file_url() { - let signature = sign_track_get_file_url( - "27", - "stream", - "12345", - "1234567890.123", - b"test_secret", - ); - - // Vérifier que c'est un hash MD5 valide (32 caractères hex) - assert_eq!(signature.len(), 32); - assert!(signature.chars().all(|c| c.is_ascii_hexdigit())); - } - - #[test] - fn test_sign_userlib_get_albums() { - let signature = sign_userlib_get_albums("1234567890.123", b"test_secret"); - - // Vérifier que c'est un hash MD5 valide (32 caractères hex) - assert_eq!(signature.len(), 32); - assert!(signature.chars().all(|c| c.is_ascii_hexdigit())); - } - - #[test] - fn test_signature_consistency() { - // La même entrée doit produire la même signature - let sig1 = sign_track_get_file_url("27", "stream", "123", "100", b"secret"); - let sig2 = sign_track_get_file_url("27", "stream", "123", "100", b"secret"); - assert_eq!(sig1, sig2); - - // Des entrées différentes doivent produire des signatures différentes - let sig3 = sign_track_get_file_url("6", "stream", "123", "100", b"secret"); - assert_ne!(sig1, sig3); - } -} -========= End of pmoqobuz/src/api/signing.rs =========== - -=============== pmoqobuz/src/api/catalog.rs ============ -//! Module d'accès au catalogue Qobuz (albums, tracks, artistes, playlists) - -use super::QobuzApi; -use crate::error::{QobuzError, Result}; -use crate::models::*; -use serde::Deserialize; -use tracing::debug; - -/// Réponse paginée de l'API -#[derive(Debug, Deserialize)] -struct PaginatedResponse { - items: Vec, - #[serde(default)] - total: Option, - #[serde(default)] - limit: Option, - #[serde(default)] - offset: Option, -} - -/// Réponse de l'endpoint /album/get -#[derive(Debug, Deserialize)] -pub(crate) struct AlbumResponse { - #[serde(deserialize_with = "crate::models::deserialize_id")] - id: String, - title: String, - artist: ArtistResponse, - #[serde(default)] - tracks_count: Option, - #[serde(default)] - duration: Option, - #[serde(default)] - release_date_original: Option, - #[serde(default)] - image: Option, - #[serde(default = "default_streamable")] - streamable: bool, - #[serde(default)] - description: Option, - #[serde(default)] - maximum_sampling_rate: Option, - #[serde(default)] - maximum_bit_depth: Option, - #[serde(default)] - genre: Option, - #[serde(default)] - label: Option, - #[serde(default)] - tracks: Option>, -} - -/// Réponse de l'endpoint /track/get -#[derive(Debug, Deserialize)] -pub(crate) struct TrackResponse { - #[serde(deserialize_with = "crate::models::deserialize_id")] - id: String, - title: String, - #[serde(default)] - performer: Option, - #[serde(default)] - artist: Option, - #[serde(default)] - album: Option, - duration: u32, - track_number: u32, - media_number: u32, - #[serde(default = "default_streamable")] - streamable: bool, -} - -/// Réponse artiste -#[derive(Debug, Deserialize)] -pub(crate) struct ArtistResponse { - #[serde(deserialize_with = "crate::models::deserialize_id")] - id: String, - name: String, - #[serde(default)] - image: Option, - #[serde(default)] - albums: Option>, -} - -/// Réponse image -#[derive(Debug, Deserialize)] -struct ImageResponse { - #[serde(default)] - large: Option, -} - -/// Réponse genre -#[derive(Debug, Deserialize)] -struct GenreResponse { - #[serde(default)] - id: Option, - name: String, -} - -/// Réponse label -#[derive(Debug, Deserialize)] -struct LabelResponse { - name: String, -} - -/// Réponse playlist -#[derive(Debug, Deserialize)] -pub(crate) struct PlaylistResponse { - #[serde(deserialize_with = "crate::models::deserialize_id")] - id: String, - name: String, - #[serde(default)] - description: Option, - #[serde(default)] - tracks_count: Option, - #[serde(default)] - duration: Option, - #[serde(default)] - images300: Option>, - #[serde(default)] - is_public: bool, - #[serde(default)] - owner: Option, - #[serde(default)] - tracks: Option>, -} - -/// Réponse propriétaire -#[derive(Debug, Deserialize)] -struct OwnerResponse { - #[serde(deserialize_with = "crate::models::deserialize_id")] - id: String, - name: String, -} - -/// Réponse genres list -#[derive(Debug, Deserialize)] -struct GenresResponse { - genres: PaginatedResponse, -} - -/// Réponse albums featured -#[derive(Debug, Deserialize)] -struct FeaturedAlbumsResponse { - albums: PaginatedResponse, -} - -/// Réponse playlists featured -#[derive(Debug, Deserialize)] -struct FeaturedPlaylistsResponse { - playlists: PaginatedResponse, -} - -/// Réponse search -#[derive(Debug, Deserialize)] -struct SearchResponse { - #[serde(default)] - albums: Option>, - #[serde(default)] - artists: Option>, - #[serde(default)] - tracks: Option>, - #[serde(default)] - playlists: Option>, -} - -/// Réponse track file URL -#[derive(Debug, Deserialize)] -struct FileUrlResponse { - url: String, - mime_type: String, - sampling_rate: u32, - bit_depth: u32, - format_id: u8, -} - -fn default_streamable() -> bool { - true -} - -impl QobuzApi { - /// Récupère les détails d'un album - pub async fn get_album(&self, album_id: &str) -> Result { - debug!("Fetching album {}", album_id); - let params = [("album_id", album_id)]; - let response: AlbumResponse = self.get("/album/get", ¶ms).await?; - Ok(Self::parse_album(response)) - } - - /// Récupère les tracks d'un album - pub async fn get_album_tracks(&self, album_id: &str) -> Result> { - debug!("Fetching tracks for album {}", album_id); - let params = [("album_id", album_id)]; - let mut response: AlbumResponse = self.get("/album/get", ¶ms).await?; - - if let Some(tracks) = response.tracks.take() { - let album = Self::parse_album(response); - Ok(tracks - .items - .into_iter() - .map(|t| Self::parse_track(t, Some(album.clone()))) - .collect()) - } else { - Ok(Vec::new()) - } - } - - /// Récupère les détails d'une track - pub async fn get_track(&self, track_id: &str) -> Result { - debug!("Fetching track {}", track_id); - let params = [("track_id", track_id)]; - let response: TrackResponse = self.get("/track/get", ¶ms).await?; - Ok(Self::parse_track(response, None)) - } - - /// Récupère l'URL de streaming d'une track - /// - /// Cette méthode nécessite un secret s4 pour signer la requête. - /// Si aucun secret n'est configuré, retourne une erreur. - /// - /// # Errors - /// - /// Retourne `QobuzError::Configuration` si le secret n'est pas configuré. - pub async fn get_file_url(&self, track_id: &str) -> Result { - use super::signing; - - debug!("Fetching file URL for track {}", track_id); - - // Vérifier que le secret est disponible - let secret = self - .secret().await - .ok_or_else(|| { - QobuzError::Configuration( - "Secret not configured. Cannot sign track/getFileUrl request.".to_string(), - ) - })?; - - let format_id = self.format_id.id().to_string(); - let intent = "stream"; - let timestamp = signing::get_timestamp(); - - // Signer la requête (comme Python: track_getFileUrl) - let signature = signing::sign_track_get_file_url( - &format_id, - intent, - track_id, - ×tamp, - &secret, - ); - - debug!( - "Signing track/getFileUrl: track_id={}, format_id={}, ts={}", - track_id, format_id, timestamp - ); - - // Construire les paramètres signés - let params = [ - ("track_id", track_id), - ("format_id", format_id.as_str()), - ("intent", intent), - ("request_ts", timestamp.as_str()), - ("request_sig", signature.as_str()), - ]; - - // Utiliser GET (comme Python après sept 2024 selon le commentaire) - let response: FileUrlResponse = self.get("/track/getFileUrl", ¶ms).await?; - - Ok(StreamInfo { - url: response.url, - mime_type: response.mime_type, - sampling_rate: response.sampling_rate, - bit_depth: response.bit_depth, - format_id: response.format_id, - expires_at: chrono::Utc::now() + chrono::Duration::minutes(5), - }) - } - - /// Récupère les albums d'un artiste - pub async fn get_artist_albums(&self, artist_id: &str) -> Result> { - debug!("Fetching albums for artist {}", artist_id); - let params = [("artist_id", artist_id), ("extra", "albums")]; - let response: ArtistResponse = self.get("/artist/get", ¶ms).await?; - - if let Some(albums) = response.albums { - Ok(albums - .items - .into_iter() - .map(Self::parse_album) - .filter(|a| a.streamable) - .collect()) - } else { - Ok(Vec::new()) - } - } - - /// Récupère les artistes similaires - pub async fn get_similar_artists(&self, artist_id: &str) -> Result> { - debug!("Fetching similar artists for {}", artist_id); - let params = [("artist_id", artist_id)]; - - #[derive(Debug, Deserialize)] - struct SimilarArtistsResponse { - artists: PaginatedResponse, - } - - let response: SimilarArtistsResponse = - self.get("/artist/getSimilarArtists", ¶ms).await?; - Ok(response - .artists - .items - .into_iter() - .map(Self::parse_artist) - .collect()) - } - - /// Récupère les détails d'une playlist - pub async fn get_playlist(&self, playlist_id: &str) -> Result { - debug!("Fetching playlist {}", playlist_id); - let params = [("playlist_id", playlist_id)]; - let response: PlaylistResponse = self.get("/playlist/get", ¶ms).await?; - Ok(Self::parse_playlist(response)) - } - - /// Récupère les tracks d'une playlist - pub async fn get_playlist_tracks(&self, playlist_id: &str) -> Result> { - debug!("Fetching tracks for playlist {}", playlist_id); - let params = [("playlist_id", playlist_id), ("extra", "tracks")]; - let response: PlaylistResponse = self.get("/playlist/get", ¶ms).await?; - - if let Some(tracks) = response.tracks { - Ok(tracks - .items - .into_iter() - .map(|t| Self::parse_track(t, None)) - .collect()) - } else { - Ok(Vec::new()) - } - } - - /// Récupère la liste des genres - pub async fn get_genres(&self) -> Result> { - debug!("Fetching genres"); - let response: GenresResponse = self.get("/genre/list", &[]).await?; - Ok(response - .genres - .items - .into_iter() - .map(Self::parse_genre) - .collect()) - } - - /// Récupère les albums featured (nouveautés, éditeur, etc.) - pub async fn get_featured_albums( - &self, - genre_id: Option<&str>, - type_: &str, - ) -> Result> { - debug!("Fetching featured albums (type: {})", type_); - let mut params = vec![("type", type_), ("limit", "100")]; - - if let Some(gid) = genre_id { - params.push(("genre_ids", gid)); - } - - let response: FeaturedAlbumsResponse = self.get("/album/getFeatured", ¶ms).await?; - Ok(response - .albums - .items - .into_iter() - .map(Self::parse_album) - .filter(|a| a.streamable) - .collect()) - } - - /// Récupère les playlists featured - pub async fn get_featured_playlists( - &self, - genre_id: Option<&str>, - tags: Option<&str>, - ) -> Result> { - debug!("Fetching featured playlists"); - let mut params = vec![("type", "editor-picks"), ("limit", "100")]; - - if let Some(gid) = genre_id { - params.push(("genre_ids", gid)); - } - if let Some(t) = tags { - params.push(("tags", t)); - } - - let response: FeaturedPlaylistsResponse = - self.get("/playlist/getFeatured", ¶ms).await?; - Ok(response - .playlists - .items - .into_iter() - .map(Self::parse_playlist) - .collect()) - } - - /// Recherche dans le catalogue - pub async fn search(&self, query: &str, type_: Option<&str>) -> Result { - debug!("Searching for '{}' (type: {:?})", query, type_); - let mut params = vec![("query", query), ("limit", "200")]; - - if let Some(t) = type_ { - params.push(("type", t)); - } - - let response: SearchResponse = self.get("/catalog/search", ¶ms).await?; - - Ok(SearchResult { - albums: response - .albums - .map(|a| { - a.items - .into_iter() - .map(Self::parse_album) - .filter(|album| album.streamable) - .collect() - }) - .unwrap_or_default(), - artists: response - .artists - .map(|a| a.items.into_iter().map(Self::parse_artist).collect()) - .unwrap_or_default(), - tracks: response - .tracks - .map(|t| { - t.items - .into_iter() - .map(|track| Self::parse_track(track, None)) - .filter(|track| track.streamable) - .collect() - }) - .unwrap_or_default(), - playlists: response - .playlists - .map(|p| p.items.into_iter().map(Self::parse_playlist).collect()) - .unwrap_or_default(), - }) - } - - // Fonctions de parsing publiques (utilisées aussi par le module user) - - pub(crate) fn parse_album(response: AlbumResponse) -> Album { - Album { - id: response.id, - title: response.title, - artist: Self::parse_artist(response.artist), - tracks_count: response.tracks_count, - duration: response.duration, - release_date: response.release_date_original, - image: response.image.and_then(|i| i.large), - image_cached: None, - streamable: response.streamable, - description: response.description, - maximum_sampling_rate: response.maximum_sampling_rate, - maximum_bit_depth: response.maximum_bit_depth, - genres: response.genre.map(|g| vec![g.name]).unwrap_or_default(), - label: response.label.map(|l| l.name), - } - } - - pub(crate) fn parse_track(response: TrackResponse, album: Option) -> Track { - let performer = response - .performer - .or(response.artist) - .map(Self::parse_artist); - - let album = album.or_else(|| response.album.map(Self::parse_album)); - - Track { - id: response.id, - title: response.title, - performer, - album, - duration: response.duration, - track_number: response.track_number, - media_number: response.media_number, - streamable: response.streamable, - mime_type: None, - sample_rate: None, - bit_depth: None, - channels: None, - } - } - - pub(crate) fn parse_artist(response: ArtistResponse) -> Artist { - Artist { - id: response.id, - name: response.name, - image: response.image.and_then(|i| i.large), - image_cached: None, - } - } - - pub(crate) fn parse_playlist(response: PlaylistResponse) -> Playlist { - Playlist { - id: response.id, - name: response.name, - description: response.description, - tracks_count: response.tracks_count, - duration: response.duration, - image: response.images300.and_then(|imgs| imgs.first().cloned()), - image_cached: None, - is_public: response.is_public, - owner: response.owner.map(|o| PlaylistOwner { - id: o.id.parse().unwrap_or(0), - name: o.name, - }), - } - } - - pub(crate) fn parse_genre(response: GenreResponse) -> Genre { - Genre { - id: response.id, - name: response.name, - children: Vec::new(), - } - } -} -========= End of pmoqobuz/src/api/catalog.rs =========== - -=============== pmoqobuz/src/api/user.rs ============ -//! Module d'accès aux données utilisateur (favoris) - -use super::catalog::{AlbumResponse, ArtistResponse, PlaylistResponse, TrackResponse}; -use super::QobuzApi; -use crate::error::{QobuzError, Result}; -use crate::models::*; -use serde::Deserialize; -use tracing::debug; - -/// Réponse paginée -#[derive(Debug, Deserialize)] -struct PaginatedResponse { - items: Vec, -} - -/// Réponse de l'endpoint /favorite/getUserFavorites -#[derive(Debug, Deserialize)] -struct FavoritesResponse { - #[serde(default)] - albums: Option>, - #[serde(default)] - artists: Option>, - #[serde(default)] - tracks: Option>, -} - -/// Réponse de l'endpoint /playlist/getUserPlaylists -#[derive(Debug, Deserialize)] -struct UserPlaylistsResponse { - playlists: PaginatedResponse, -} - -impl QobuzApi { - /// Vérifie que l'utilisateur est authentifié - fn ensure_authenticated(&self) -> Result<&str> { - self.user_id - .as_deref() - .ok_or_else(|| QobuzError::Unauthorized("Not authenticated".to_string())) - } - - /// Récupère les albums favoris de l'utilisateur - pub async fn get_favorite_albums(&self) -> Result> { - let user_id = self.ensure_authenticated()?; - debug!("Fetching favorite albums for user {}", user_id); - - let params = [("user_id", user_id), ("type", "albums"), ("limit", "1000")]; - - let response: FavoritesResponse = self.get("/favorite/getUserFavorites", ¶ms).await?; - - if let Some(albums) = response.albums { - Ok(albums - .items - .into_iter() - .map(QobuzApi::parse_album) - .filter(|a| a.streamable) - .collect()) - } else { - Ok(Vec::new()) - } - } - - /// Récupère les artistes favoris de l'utilisateur - pub async fn get_favorite_artists(&self) -> Result> { - let user_id = self.ensure_authenticated()?; - debug!("Fetching favorite artists for user {}", user_id); - - let params = [("user_id", user_id), ("type", "artists"), ("limit", "1000")]; - - let response: FavoritesResponse = self.get("/favorite/getUserFavorites", ¶ms).await?; - - if let Some(artists) = response.artists { - Ok(artists - .items - .into_iter() - .map(QobuzApi::parse_artist) - .collect()) - } else { - Ok(Vec::new()) - } - } - - /// Récupère les tracks favorites de l'utilisateur - pub async fn get_favorite_tracks(&self) -> Result> { - let user_id = self.ensure_authenticated()?; - debug!("Fetching favorite tracks for user {}", user_id); - - let params = [("user_id", user_id), ("type", "tracks"), ("limit", "1000")]; - - let response: FavoritesResponse = self.get("/favorite/getUserFavorites", ¶ms).await?; - - if let Some(tracks) = response.tracks { - Ok(tracks - .items - .into_iter() - .map(|t| QobuzApi::parse_track(t, None)) - .filter(|t| t.streamable) - .collect()) - } else { - Ok(Vec::new()) - } - } - - /// Récupère les playlists de l'utilisateur - pub async fn get_user_playlists(&self) -> Result> { - let user_id = self.ensure_authenticated()?; - debug!("Fetching playlists for user {}", user_id); - - let params = [("user_id", user_id), ("limit", "1000")]; - - let response: UserPlaylistsResponse = - self.get("/playlist/getUserPlaylists", ¶ms).await?; - - Ok(response - .playlists - .items - .into_iter() - .map(QobuzApi::parse_playlist) - .collect()) - } - - /// Ajoute un album aux favoris - pub async fn add_favorite_album(&self, album_id: &str) -> Result<()> { - let user_id = self.ensure_authenticated()?; - debug!( - "Adding album {} to favorites for user {}", - album_id, user_id - ); - - let params = [("album_id", album_id), ("user_id", user_id)]; - - self.get::("/favorite/create", ¶ms) - .await?; - Ok(()) - } - - /// Supprime un album des favoris - pub async fn remove_favorite_album(&self, album_id: &str) -> Result<()> { - let user_id = self.ensure_authenticated()?; - debug!( - "Removing album {} from favorites for user {}", - album_id, user_id - ); - - let params = [("album_ids", album_id), ("user_id", user_id)]; - - self.get::("/favorite/delete", ¶ms) - .await?; - Ok(()) - } - - /// Ajoute un track aux favoris - pub async fn add_favorite_track(&self, track_id: &str) -> Result<()> { - let user_id = self.ensure_authenticated()?; - debug!( - "Adding track {} to favorites for user {}", - track_id, user_id - ); - - let params = [("track_id", track_id), ("user_id", user_id)]; - - self.get::("/favorite/create", ¶ms) - .await?; - Ok(()) - } - - /// Supprime un track des favoris - pub async fn remove_favorite_track(&self, track_id: &str) -> Result<()> { - let user_id = self.ensure_authenticated()?; - debug!( - "Removing track {} from favorites for user {}", - track_id, user_id - ); - - let params = [("track_ids", track_id), ("user_id", user_id)]; - - self.get::("/favorite/delete", ¶ms) - .await?; - Ok(()) - } - - /// Ajoute un track à une playlist - pub async fn add_to_playlist(&self, playlist_id: &str, track_id: &str) -> Result<()> { - let user_id = self.ensure_authenticated()?; - debug!( - "Adding track {} to playlist {} for user {}", - track_id, playlist_id, user_id - ); - - let params = [("playlist_id", playlist_id), ("track_ids", track_id)]; - - self.get::("/playlist/addTracks", ¶ms) - .await?; - Ok(()) - } - - /// Récupère la liste des albums de la bibliothèque utilisateur - /// - /// Cette méthode nécessite un secret s4 pour signer la requête. - /// Elle est principalement utilisée pour tester la validité d'un secret. - /// - /// Dans le code Python, cette méthode est utilisée par `setSec()` pour - /// tester chaque secret retourné par le Spoofer. - /// - /// # Errors - /// - /// Retourne `QobuzError::Configuration` si le secret n'est pas configuré. - /// Retourne `QobuzError::Unauthorized` si l'utilisateur n'est pas authentifié. - pub async fn userlib_get_albums(&self) -> Result { - use super::signing; - - // Vérifier l'authentification - self.ensure_authenticated()?; - - // Vérifier que le secret est disponible - let secret = self - .secret().await - .ok_or_else(|| { - QobuzError::Configuration( - "Secret not configured. Cannot sign userLibrary/getAlbumsList request." - .to_string(), - ) - })?; - - let timestamp = signing::get_timestamp(); - - // Signer la requête (comme Python: userlib_getAlbums) - let signature = signing::sign_userlib_get_albums(×tamp, &secret); - - debug!( - "Signing userLibrary/getAlbumsList: app_id={}, ts={}", - self.app_id(), - timestamp - ); - - // Construire les paramètres signés - let user_auth_token = self - .auth_token() - .ok_or_else(|| QobuzError::Unauthorized("No auth token".to_string()))?; - - let params = [ - ("app_id", self.app_id()), - ("user_auth_token", user_auth_token), - ("request_ts", timestamp.as_str()), - ("request_sig", signature.as_str()), - ]; - - // Utiliser POST (comme Python) - self.post("/userLibrary/getAlbumsList", ¶ms).await - } - - /// Teste si un secret est valide en essayant de récupérer les albums - /// - /// Cette méthode est équivalente au test fait dans `setSec()` en Python. - /// Elle retourne `true` si le secret fonctionne, `false` sinon. - pub async fn test_secret(&self, _secret: &[u8]) -> bool { - // Sauvegarder le secret actuel - let _current_secret = self.secret().await; - - // Définir temporairement le nouveau secret - // Note: cette méthode nécessite &mut self, donc on doit la rendre mutable - // Pour l'instant, on ne peut pas modifier self dans cette méthode - // TODO: Refactoriser pour permettre de tester les secrets - - // Restaurer le secret original - false - } -} -========= End of pmoqobuz/src/api/user.rs =========== - -=============== pmoqobuz/src/api/mod.rs ============ -//! Couche d'accès à l'API REST Qobuz -//! -//! Ce module fournit une interface bas-niveau pour communiquer avec l'API Qobuz. - -pub mod auth; -pub mod catalog; -pub mod signing; -pub mod spoofer; -pub mod user; - -use crate::error::{QobuzError, Result}; -use crate::models::AudioFormat; -use reqwest::{Client, Response}; -use serde::de::DeserializeOwned; -use serde_json::Value; -use std::sync::Arc; -use std::time::{Duration, Instant}; -use tracing::{debug, warn}; - -pub use spoofer::Spoofer; - -/// URL de base de l'API Qobuz -const API_BASE_URL: &str = "https://www.qobuz.com/api.json/0.2"; - -/// App ID Qobuz par défaut -/// -/// Cet App ID est un fallback au cas où : -/// - Aucun appID n'est configuré dans pmoconfig -/// - Le Spoofer n'est pas disponible ou échoue -/// -/// Note: Cet App ID peut devenir obsolète avec le temps. -/// Il est recommandé d'utiliser soit la configuration manuelle, -/// soit le Spoofer pour obtenir un App ID à jour. -pub const DEFAULT_APP_ID: &str = "1401488693436528"; - -/// Client API bas-niveau pour communiquer avec Qobuz -pub struct QobuzApi { - /// Client HTTP - client: Client, - /// App ID pour l'authentification - app_id: String, - /// Secret s4 pour signer les requêtes sensibles (track/getFileUrl, userLibrary/*) - /// - /// Ce secret est obtenu soit : - /// - En décodant un `configvalue` (base64) et XOR avec l'app_id - /// - Depuis le Spoofer (secrets dynamiques) - /// - /// Utilise Arc pour permettre le refresh automatique en cas d'erreur de signature - secret: Arc>>>, - /// Token d'authentification utilisateur - user_auth_token: Option, - /// ID utilisateur - user_id: Option, - /// Format audio par défaut - format_id: AudioFormat, - /// Rate limiter: Semaphore for max concurrent requests - rate_limiter: Option>, - /// Last request timestamp (for minimum delay) - last_request: Arc>, - /// Minimum delay between requests (milliseconds) - min_delay_ms: u64, -} - -impl QobuzApi { - /// Crée une nouvelle instance de l'API - pub fn new(app_id: impl Into) -> Result { - let client = Client::builder() - .timeout(Duration::from_secs(30)) - .user_agent( - "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:67.0) Gecko/20100101 Firefox/67.0", - ) - .build()?; - - Ok(Self { - client, - app_id: app_id.into(), - secret: Arc::new(tokio::sync::RwLock::new(None)), - user_auth_token: None, - user_id: None, - format_id: AudioFormat::default(), - rate_limiter: None, - last_request: Arc::new(tokio::sync::Mutex::new(std::time::Instant::now())), - min_delay_ms: 0, - }) - } - - /// Crée une API avec un secret depuis configvalue (base64) - /// - /// # Arguments - /// - /// * `app_id` - App ID Qobuz - /// * `configvalue` - Secret encodé en base64 (à XORer avec l'app_id) - /// - /// # Note - /// - /// Cette méthode reproduit le comportement Python de `__set_s4()`. - /// Le configvalue est décodé depuis base64, puis XORé avec l'app_id - /// pour obtenir le secret s4. - pub async fn with_secret(app_id: impl Into, configvalue: &str) -> Result { - let api = Self::new(app_id)?; - api.set_secret_from_configvalue(configvalue).await?; - Ok(api) - } - - /// Définit le secret s4 directement - /// - /// # Arguments - /// - /// * `secret` - Secret s4 en bytes (déjà décodé et dérivé) - pub async fn set_secret(&self, secret: Vec) { - *self.secret.write().await = Some(secret); - } - - /// Dérive et définit le secret s4 depuis un configvalue - /// - /// Reproduit la logique Python de `__set_s4()`: - /// 1. Décode le configvalue depuis base64 - /// 2. XOR avec l'app_id - /// 3. Stocke le résultat comme secret s4 - async fn set_secret_from_configvalue(&self, configvalue: &str) -> Result<()> { - use base64::{engine::general_purpose::STANDARD, Engine}; - - // Décoder le configvalue depuis base64 - let s3s = STANDARD - .decode(configvalue.trim()) - .map_err(|e| QobuzError::Configuration(format!("Invalid configvalue: {}", e)))?; - - // XOR avec l'app_id - let app_id_bytes = self.app_id.as_bytes(); - let mut s4 = Vec::with_capacity(s3s.len()); - - for (i, &byte) in s3s.iter().enumerate() { - let app_byte = app_id_bytes[i % app_id_bytes.len()]; - s4.push(byte ^ app_byte); - } - - *self.secret.write().await = Some(s4); - Ok(()) - } - - /// Retourne le secret s4 si disponible - pub async fn secret(&self) -> Option> { - self.secret.read().await.clone() - } - - /// Définit le token d'authentification - pub fn set_auth_token(&mut self, token: String, user_id: String) { - self.user_auth_token = Some(token); - self.user_id = Some(user_id); - } - - /// Définit le format audio par défaut - pub fn set_format(&mut self, format: AudioFormat) { - self.format_id = format; - } - - /// Retourne le format audio configuré - pub fn format(&self) -> AudioFormat { - self.format_id - } - - /// Retourne l'App ID - pub fn app_id(&self) -> &str { - &self.app_id - } - - /// Retourne le token d'authentification si disponible - pub fn auth_token(&self) -> Option<&str> { - self.user_auth_token.as_deref() - } - - /// Retourne l'ID utilisateur si disponible - pub fn user_id(&self) -> Option<&str> { - self.user_id.as_deref() - } - - /// Enable rate limiting with configurable parameters - /// - /// # Arguments - /// - /// * `max_concurrent` - Maximum number of concurrent requests - /// * `min_delay_ms` - Minimum delay between requests in milliseconds - /// - /// # Example - /// - /// ```ignore - /// api.enable_rate_limiting(2, 400); // Max 2 concurrent, 400ms delay - /// ``` - pub fn enable_rate_limiting(&mut self, max_concurrent: usize, min_delay_ms: u64) { - self.rate_limiter = Some(Arc::new(tokio::sync::Semaphore::new(max_concurrent))); - self.min_delay_ms = min_delay_ms; - debug!( - "Rate limiting enabled: {} concurrent requests, {}ms min delay", - max_concurrent, min_delay_ms - ); - } - - /// Check if rate limiting is enabled - pub fn is_rate_limiting_enabled(&self) -> bool { - self.rate_limiter.is_some() - } - - /// Effectue une requête GET à l'API - pub(crate) async fn get( - &self, - endpoint: &str, - params: &[(&str, &str)], - ) -> Result { - self.request("GET", endpoint, params).await - } - - /// Effectue une requête POST à l'API - pub(crate) async fn post( - &self, - endpoint: &str, - params: &[(&str, &str)], - ) -> Result { - self.request("POST", endpoint, params).await - } - - /// Effectue une requête à l'API (générique) - async fn request( - &self, - method: &str, - endpoint: &str, - params: &[(&str, &str)], - ) -> Result { - let url = format!("{}{}", API_BASE_URL, endpoint); - - // ===== RATE LIMITING LOGIC ===== - let _permit = if let Some(ref limiter) = self.rate_limiter { - // 1. Acquire semaphore permit (blocks if max concurrent reached) - let permit = limiter - .acquire() - .await - .map_err(|e| QobuzError::Other(format!("Rate limiter error: {}", e)))?; - - // 2. Enforce minimum delay - if self.min_delay_ms > 0 { - let mut last = self.last_request.lock().await; - let elapsed = last.elapsed(); - let min_delay = Duration::from_millis(self.min_delay_ms); - - if elapsed < min_delay { - let wait_time = min_delay - elapsed; - debug!("Rate limiting: waiting {:?} before request", wait_time); - tokio::time::sleep(wait_time).await; - } - - *last = Instant::now(); - } - - Some(permit) // Keep permit alive until request completes - } else { - None - }; - // ===== END RATE LIMITING ===== - - debug!("{} {} with {} params", method, url, params.len()); - - let mut request = if method == "GET" { - self.client.get(&url) - } else { - self.client.post(&url) - }; - - // Ajouter les headers - request = request.header("X-App-Id", &self.app_id); - - if let Some(ref token) = self.user_auth_token { - request = request.header("X-User-Auth-Token", token); - } - - // Ajouter les paramètres - if method == "GET" { - request = request.query(params); - } else { - request = request.form(params); - } - - // Envoyer la requête - let response = request.send().await?; - self.handle_response(response).await - } - - /// Traite la réponse HTTP - async fn handle_response(&self, response: Response) -> Result { - let status = response.status(); - let status_code = status.as_u16(); - - debug!("Response status: {}", status); - - if !status.is_success() { - let error_text = response.text().await.unwrap_or_default(); - warn!("API error ({}): {}", status_code, error_text); - return Err(QobuzError::from_status_code(status_code, error_text)); - } - - let text = response.text().await?; - - // Vérifier si la réponse contient une erreur Qobuz - if let Ok(json) = serde_json::from_str::(&text) { - if let Some(status_obj) = json.get("status") { - if status_obj == "error" { - let message = json - .get("message") - .and_then(|m| m.as_str()) - .unwrap_or("Unknown error"); - warn!("Qobuz API error: {}", message); - return Err(QobuzError::ApiError { - code: status_code, - message: message.to_string(), - }); - } - } - } - - // Parser la réponse - serde_json::from_str(&text).map_err(|e| { - warn!("Failed to parse response: {}", e); - QobuzError::JsonParse(e) - }) - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_api_creation() { - let api = QobuzApi::new("test_app_id").unwrap(); - assert_eq!(api.app_id(), "test_app_id"); - assert!(api.auth_token().is_none()); - } - - #[test] - fn test_set_auth_token() { - let mut api = QobuzApi::new("test_app_id").unwrap(); - api.set_auth_token("test_token".to_string(), "user123".to_string()); - assert_eq!(api.auth_token(), Some("test_token")); - assert_eq!(api.user_id(), Some("user123")); - } - - #[test] - fn test_set_format() { - let mut api = QobuzApi::new("test_app_id").unwrap(); - api.set_format(AudioFormat::Flac_HiRes_96); - assert_eq!(api.format(), AudioFormat::Flac_HiRes_96); - } -} -========= End of pmoqobuz/src/api/mod.rs =========== - -=============== pmoqobuz/src/pmoserver_ext.rs ============ -//! Extension de pmoserver::Server pour intégrer le client Qobuz -//! -//! Ce module fournit un trait d'extension permettant d'ajouter facilement -//! le client Qobuz et ses endpoints à un serveur pmoserver. - -use crate::client::QobuzClient; -use anyhow::Result; -use std::sync::Arc; - -/// Trait d'extension pour ajouter le support Qobuz à un serveur pmoserver -/// -/// Ce trait permet à `pmoqobuz` d'ajouter des méthodes d'extension sur -/// `pmoserver::Server` sans que pmoserver dépende de pmoqobuz. -/// -/// # Architecture -/// -/// Similaire au pattern utilisé par `pmocovers` avec `CoverCacheExt`, ce trait permet -/// une extension propre et découplée : -/// -/// - `pmoserver` définit un serveur HTTP générique -/// - `pmoqobuz` étend ce serveur avec des fonctionnalités Qobuz via ce trait -/// - Le serveur n'a pas besoin de connaître `pmoqobuz` -/// -/// # Exemple -/// -/// ```rust,no_run -/// use pmoqobuz::QobuzServerExt; -/// use pmoserver::ServerBuilder; -/// -/// #[tokio::main] -/// async fn main() -> anyhow::Result<()> { -/// let mut server = ServerBuilder::new_configured().build(); -/// -/// // Initialise le client Qobuz depuis la config -/// server.init_qobuz_client_configured().await?; -/// -/// server.start().await; -/// server.wait().await; -/// Ok(()) -/// } -/// ``` -pub trait QobuzServerExt { - /// Initialise le client Qobuz et enregistre les routes HTTP - /// - /// # Arguments - /// - /// * `username` - Email ou nom d'utilisateur Qobuz - /// * `password` - Mot de passe - /// - /// # Returns - /// - /// * `Arc` - Instance partagée du client - /// - /// # Routes enregistrées - /// - /// - `GET /qobuz/albums/{id}` - Détails d'un album - /// - `GET /qobuz/albums/{id}/tracks` - Tracks d'un album - /// - `GET /qobuz/tracks/{id}` - Détails d'une track - /// - `GET /qobuz/tracks/{id}/stream` - URL de streaming - /// - `GET /qobuz/artists/{id}` - Détails d'un artiste - /// - `GET /qobuz/artists/{id}/albums` - Albums d'un artiste - /// - `GET /qobuz/playlists/{id}` - Détails d'une playlist - /// - `GET /qobuz/playlists/{id}/tracks` - Tracks d'une playlist - /// - `GET /qobuz/search` - Recherche (query params: q, type) - /// - `GET /qobuz/favorites/albums` - Albums favoris - /// - `GET /qobuz/favorites/artists` - Artistes favoris - /// - `GET /qobuz/favorites/tracks` - Tracks favoris - /// - `GET /qobuz/favorites/playlists` - Playlists utilisateur - /// - `GET /qobuz/genres` - Liste des genres - /// - `GET /qobuz/featured/albums` - Albums featured - /// - `GET /qobuz/featured/playlists` - Playlists featured - /// - `GET /qobuz/cache/stats` - Statistiques du cache - /// - `GET /swagger-ui` - Documentation interactive - async fn init_qobuz_client( - &mut self, - username: &str, - password: &str, - ) -> Result>; - - /// Initialise le client Qobuz avec la configuration par défaut - /// - /// Utilise automatiquement les credentials de `pmoconfig::Config` : - /// - `accounts.qobuz.username` pour le nom d'utilisateur - /// - `accounts.qobuz.password` pour le mot de passe - /// - /// # Returns - /// - /// * `Arc` - Instance partagée du client - /// - /// # Exemple - /// - /// ```rust,no_run - /// use pmoqobuz::QobuzServerExt; - /// use pmoserver::ServerBuilder; - /// - /// #[tokio::main] - /// async fn main() -> anyhow::Result<()> { - /// let mut server = ServerBuilder::new_configured().build(); - /// - /// // Utilise automatiquement la config - /// server.init_qobuz_client_configured().await?; - /// - /// server.start().await; - /// Ok(()) - /// } - /// ``` - async fn init_qobuz_client_configured(&mut self) -> Result>; - - /// Initialise le client Qobuz avec intégration pmocovers - /// - /// Les images d'albums seront automatiquement ajoutées au cache pmocovers fourni. - /// - /// # Arguments - /// - /// * `username` - Email ou nom d'utilisateur Qobuz - /// * `password` - Mot de passe - /// * `cover_cache` - Instance du cache pmocovers à utiliser - /// - /// # Returns - /// - /// * `Arc` - Instance partagée du client avec cache d'images - /// - /// # Exemple - /// - /// ```rust,no_run - /// use pmoqobuz::QobuzServerExt; - /// use pmocovers::CoverCacheExt; - /// use pmoserver::ServerBuilder; - /// - /// #[tokio::main] - /// async fn main() -> anyhow::Result<()> { - /// let mut server = ServerBuilder::new_configured().build(); - /// - /// // D'abord initialiser le cache d'images - /// let cache = server.init_cover_cache_configured().await?; - /// - /// // Puis initialiser Qobuz avec le cache - /// server.init_qobuz_client_with_covers("user", "pass", cache).await?; - /// - /// server.start().await; - /// Ok(()) - /// } - /// ``` - #[cfg(feature = "covers")] - async fn init_qobuz_client_with_covers( - &mut self, - username: &str, - password: &str, - cover_cache: Arc, - ) -> Result>; - - /// Initialise le client Qobuz avec intégration pmocovers depuis la configuration - /// - /// # Arguments - /// - /// * `cover_cache` - Instance du cache pmocovers à utiliser - /// - /// # Exemple - /// - /// ```rust,no_run - /// use pmoqobuz::QobuzServerExt; - /// use pmocovers::CoverCacheExt; - /// use pmoserver::ServerBuilder; - /// - /// #[tokio::main] - /// async fn main() -> anyhow::Result<()> { - /// let mut server = ServerBuilder::new_configured().build(); - /// - /// // D'abord initialiser le cache - /// let cache = server.init_cover_cache_configured().await?; - /// - /// // Puis initialiser Qobuz avec le cache - /// server.init_qobuz_client_configured_with_covers(cache).await?; - /// - /// server.start().await; - /// Ok(()) - /// } - /// ``` - #[cfg(feature = "covers")] - async fn init_qobuz_client_configured_with_covers( - &mut self, - cover_cache: Arc, - ) -> Result>; -} - -// L'implémentation du trait sera dans un module séparé (pmoserver_impl.rs) -// pour éviter les dépendances circulaires -========= End of pmoqobuz/src/pmoserver_ext.rs =========== - diff --git a/pmoqobuz_028.txt b/pmoqobuz_028.txt deleted file mode 100644 index 3fe87d9a..00000000 --- a/pmoqobuz_028.txt +++ /dev/null @@ -1,8610 +0,0 @@ -=============== pmoqobuz/Cargo.toml ============ -[package] -name = "pmoqobuz" -version = "0.1.0" -edition = "2021" - -[dependencies] -regex = "1.12" -base64 = "0.22" -indexmap = "2.0" -async-trait = { version = "0.1", optional = true } - -# HTTP client pour les requêtes à l'API Qobuz -reqwest = { version = "0.12", features = ["json", "cookies"] } - -# Gestion asynchrone -tokio = { version = "1", features = ["full"] } - -# Sérialisation/Désérialisation JSON -serde = { version = "1.0", features = ["derive"] } -serde_json = "1.0" -serde_yaml = "0.9" - -# Gestion des erreurs -anyhow = "1.0" -thiserror = "1.0" - -# Hashing pour les clés de cache et signatures -sha1 = "0.10" -hex = "0.4" -md-5 = "0.10" - -# Cache en mémoire avec TTL -moka = { version = "0.12", features = ["future"] } - -# Logging -tracing = "0.1" - -# Gestion du temps -chrono = { version = "0.4", features = ["serde"] } - -# Configuration -pmoconfig = { path = "../pmoconfig" } - -# Intégration avec pmocovers pour le cache d'images (OBLIGATOIRE) -pmocovers = { path = "../pmocovers" } - -# Intégration avec pmoaudiocache pour le cache audio (OBLIGATOIRE) -pmoaudiocache = { path = "../pmoaudiocache" } - -# Intégration avec pmodidl pour l'export DIDL -pmodidl = { path = "../pmodidl" } - -# Intégration avec pmoserver pour l'API HTTP -pmoserver = { path = "../pmoserver", optional = true } -axum = { version = "0.8", optional = true } -rusqlite = { version = "0.32", features = ["bundled"], optional = true } - -# Documentation OpenAPI -utoipa = { version = "5.3", optional = true } - -# Common music source traits -pmosource = { path = "../pmosource" } - -# Playlist management -pmoplaylist = { path = "../pmoplaylist" } - -[features] -default = [] -# Feature pour activer les extensions pmoserver -pmoserver = ["dep:pmoserver", "dep:axum", "dep:utoipa"] -# Feature pour activer le support serveur (cache registry) -server = ["pmosource/server"] -# Feature cache (deprecated - toujours actif maintenant) -cache = [] -disk-cache = ["dep:rusqlite", "dep:async-trait"] - -[dev-dependencies] -# Tests -tokio-test = "0.4" -mockito = "1.0" -tempfile = "3.0" -# Pour les exemples -tracing-subscriber = "0.3" -pmocache = { path = "../pmocache" } -# Pour l'exemple spoofer - -# Specify that the with_cache example requires the cache feature -[[example]] -name = "with_cache" -required-features = ["cache"] -========= End of pmoqobuz/Cargo.toml =========== - -=============== pmoqobuz/IMPLEMENTATION_STATUS.md ============ -# Statut d'implémentation de l'API Qobuz - -**Date** : 2025-12-10 -**Statut** : ✅ **PRODUCTION READY avec Spoofer intégré** - -## Résumé - -L'implémentation Rust de `pmoqobuz` suit maintenant fidèlement l'API de référence Python (`qobuz.api.raw`) pour toutes les fonctionnalités critiques. Le Spoofer est désormais intégré automatiquement dans le client pour obtenir dynamiquement des AppID et secrets valides. - -## ✅ Problèmes corrigés - -### 1. ✅ Gestion du secret `s4` - -**État** : **TERMINÉ** - -- **Fichier** : [pmoqobuz/src/api/mod.rs](src/api/mod.rs) -- **Ajouts** : - - Champ `secret: Option>` dans `QobuzApi` - - `with_secret()` - Crée une API avec appID + configvalue (base64) - - `set_secret()` - Définit le secret directement - - `set_secret_from_configvalue()` - Décodage base64 + XOR avec appID - - `secret()` - Getter pour le secret - -### 2. ✅ Signature MD5 des requêtes - -**État** : **TERMINÉ** - -- **Fichier** : [pmoqobuz/src/api/signing.rs](src/api/signing.rs) (nouveau) -- **Fonctions implémentées** : - - `get_timestamp()` - Génère timestamp Unix - - `sign_track_get_file_url()` - Signature pour `track/getFileUrl` - - `sign_userlib_get_albums()` - Signature pour `userLibrary/getAlbumsList` -- **Tests unitaires** : ✅ Tous passants - -### 3. ✅ Méthode `get_file_url` avec signature - -**État** : **TERMINÉ** - -- **Fichier** : [pmoqobuz/src/api/catalog.rs](src/api/catalog.rs:217-269) -- **Modifications** : - - Vérification du secret avant la requête - - Génération du timestamp - - Signature MD5 de la requête - - Ajout de `request_ts` et `request_sig` aux paramètres -- **Comportement** : Retourne `QobuzError::Configuration` si le secret n'est pas configuré - -### 4. ✅ Méthode `userlib_getAlbums` - -**État** : **TERMINÉ** - -- **Fichier** : [pmoqobuz/src/api/user.rs](src/api/user.rs:196-249) -- **Fonctionnalités** : - - Signature MD5 avec le secret - - Utilisée pour tester la validité des secrets - - Requête POST vers `/userLibrary/getAlbumsList` - -### 5. ✅ Configuration AppID et Secret - -**État** : **TERMINÉ** - -- **Fichier** : [pmoqobuz/src/config_ext.rs](src/config_ext.rs) -- **Méthodes ajoutées** : - - `get_qobuz_appid()` / `set_qobuz_appid()` - - `get_qobuz_secret()` / `set_qobuz_secret()` -- **Configuration YAML** : - ```yaml - accounts: - qobuz: - username: "user@example.com" - password: "password" - appid: "1401488693436528" # Optionnel - secret: "base64_encoded_secret" # Optionnel - ``` - -### 6. ✅ Intégration dans QobuzClient - -**État** : **TERMINÉ** - -- **Fichier** : [pmoqobuz/src/client.rs](src/client.rs:80-129) -- **Logique** : - 1. Si `appid` ET `secret` configurés → `QobuzApi::with_secret()` - 2. Sinon → `QobuzApi::new()` avec appid (ou DEFAULT_APP_ID) -- **Note** : Les requêtes signées échouent si le secret n'est pas configuré - -## 📦 Dépendances ajoutées - -```toml -md-5 = "0.10" # Pour les signatures MD5 -``` - -## 📁 Fichiers créés/modifiés - -### Nouveaux fichiers -- ✅ `src/api/signing.rs` - Module de signatures MD5 -- ✅ `src/config_ext.rs` - Trait d'extension pour la configuration -- ✅ `API_ANALYSIS.md` - Analyse des différences avec Python -- ✅ `IMPLEMENTATION_STATUS.md` - Ce fichier - -### Fichiers modifiés -- ✅ `src/api/mod.rs` - Ajout du support du secret s4 -- ✅ `src/api/catalog.rs` - Signature de `get_file_url` -- ✅ `src/api/user.rs` - Ajout de `userlib_get_albums` -- ✅ `src/client.rs` - Intégration du secret dans `from_config_obj` -- ✅ `src/error.rs` - Ajout de `QobuzError::Configuration` -- ✅ `src/lib.rs` - Export de `QobuzConfigExt` -- ✅ `Cargo.toml` - Ajout de `md-5` - -## 🧪 Tests - -### Compilation -```bash -cargo check -# ✅ warning: `pmoqobuz` (lib) generated 6 warnings -# ✅ Finished `dev` profile -``` - -### Exemples -```bash -cargo check --example basic_usage -# ✅ Finished `dev` profile -``` - -## 🚀 Utilisation - -### Option 1 : Sans secret (limité) - -**Configuration minimale** : -```yaml -accounts: - qobuz: - username: "user@example.com" - password: "password" -``` - -**Fonctionnalités disponibles** : -- ✅ Authentification -- ✅ Recherche (albums, artistes, tracks, playlists) -- ✅ Récupération des métadonnées (albums, tracks, etc.) -- ✅ Favoris -- ✅ Playlists -- ❌ Streaming (requiert signature) -- ❌ Bibliothèque utilisateur complète (requiert signature) - -### Option 2 : Avec secret (complet) - -**Configuration complète** : -```yaml -accounts: - qobuz: - username: "user@example.com" - password: "password" - appid: "1401488693436528" - secret: "Ym9vdHN0cmFw..." # Base64 encoded -``` - -**Fonctionnalités disponibles** : -- ✅ Toutes les fonctionnalités de l'Option 1 -- ✅ Streaming (avec `get_stream_url`) -- ✅ Bibliothèque utilisateur complète - -### Option 3 : Avec Spoofer (TODO) - -Le Spoofer permet d'obtenir automatiquement un AppID et des secrets valides. - -**Status** : 🚧 En cours (nécessite intégration dans `QobuzClient::from_config`) - -## ✅ Nouvelles fonctionnalités (2025-12-10) - -### 1. ✅ Désérialisation flexible des IDs - -**Problème résolu** : Les IDs Qobuz peuvent être des integers ou des strings dans les réponses JSON - -**Modifications** : -- Ajout de `deserialize_id()` dans [models.rs](src/models.rs:7-20) -- Application à toutes les structures (Artist, Album, Track, Playlist, etc.) -- Support automatique des deux formats - -### 2. ✅ Intégration automatique du Spoofer avec fallback intelligent - -**Fonctionnalité** : Le client gère automatiquement les credentials invalides/expirés - -**Logique d'initialisation** (client.rs:90-222) : -1. Si `appid` ET `secret` configurés → **test avec authentification** -2. Si l'authentification réussit → utilisation directe (pas de Spoofer) -3. Si l'authentification échoue (credentials invalides/expirés) → **fallback automatique vers Spoofer** -4. Si aucun `appid`/`secret` configuré → appel direct du Spoofer -5. Le Spoofer teste chaque secret et sauvegarde le premier valide -6. Fallback ultime vers DEFAULT_APP_ID si tout échoue - -**Avantages** : -- ✅ Aucune configuration manuelle requise -- ✅ **Gestion automatique de l'expiration des credentials** -- ✅ **Auto-réparation si les credentials deviennent invalides** -- ✅ Secrets toujours à jour -- ✅ Fonctionnement transparent pour l'utilisateur -- ✅ Configuration sauvegardée automatiquement - -## ⚠️ Limitations connues - -1. **Test des secrets** : La méthode `test_secret()` est incomplète (nécessite refactoring pour &mut self) - -## 📚 Documentation - -- [API_ANALYSIS.md](API_ANALYSIS.md) - Analyse détaillée des différences -- [examples/basic_usage.rs](examples/basic_usage.rs) - Exemple fonctionnel -- [examples/spoofer.rs](examples/spoofer.rs) - Exemple d'extraction AppID/secrets -- [examples/config_usage.rs](examples/config_usage.rs) - Exemple de configuration - -## ✅ Conclusion - -L'implémentation Rust reproduit fidèlement le comportement de l'API Python de référence pour toutes les opérations critiques. Le système de signatures MD5 fonctionne correctement, et le Spoofer intégré permet un fonctionnement automatique sans configuration manuelle. - -**Status global** : ✅ **PRODUCTION READY** - -### Avantages par rapport à la version Python : -- ✅ Intégration automatique du Spoofer (pas besoin de configuration manuelle) -- ✅ Désérialisation robuste (gère integers et strings pour les IDs) -- ✅ Sauvegarde automatique des credentials valides -- ✅ Performance supérieure (Rust) -- ✅ Type safety (compilation) -========= End of pmoqobuz/IMPLEMENTATION_STATUS.md =========== - -=============== pmoqobuz/tests/disk_cache.rs ============ -#![cfg(feature = "disk-cache")] - -use pmoqobuz::disk_cache::{CacheStore, SqliteCacheStore}; -use std::time::Duration; -use tokio::time::sleep; - -#[tokio::test] -async fn sqlite_cache_returns_fresh_entries() -> anyhow::Result<()> { - let dir = tempfile::tempdir()?; - let path = dir.path().join("cache.sqlite"); - let store = SqliteCacheStore::new(path)?; - - let data = vec!["album".to_string()]; - store - .put_json("user", "favorites_albums", "all", Duration::from_secs(3600), &data) - .await?; - - let entry = store - .get_json::>("user", "favorites_albums", "all") - .await? - .expect("cache entry"); - - assert!(entry.fresh); - assert_eq!(entry.value, data); - - Ok(()) -} - -#[tokio::test] -async fn sqlite_cache_marks_entries_as_stale_after_ttl() -> anyhow::Result<()> { - let dir = tempfile::tempdir()?; - let path = dir.path().join("cache.sqlite"); - let store = SqliteCacheStore::new(path)?; - - let data = vec!["track".to_string()]; - store - .put_json("user", "favorites_tracks", "all", Duration::from_secs(1), &data) - .await?; - - sleep(Duration::from_secs(2)).await; - - let entry = store - .get_json::>("user", "favorites_tracks", "all") - .await? - .expect("cache entry"); - - assert!(!entry.fresh); - - Ok(()) -} - -#[tokio::test] -async fn sqlite_cache_purge_expired_removes_entries() -> anyhow::Result<()> { - let dir = tempfile::tempdir()?; - let path = dir.path().join("cache.sqlite"); - let store = SqliteCacheStore::new(path)?; - - let data = vec!["playlist".to_string()]; - store - .put_json("user", "user_playlists", "all", Duration::from_secs(1), &data) - .await?; - - sleep(Duration::from_secs(2)).await; - - let removed = store.purge_expired().await?; - assert_eq!(removed, 1); - - let entry = store - .get_json::>("user", "user_playlists", "all") - .await?; - - assert!(entry.is_none()); - - Ok(()) -} -========= End of pmoqobuz/tests/disk_cache.rs =========== - -=============== pmoqobuz/CACHE_STRATEGY.md ============ -# Stratégie de cache pour pmoqobuz - -## Vue d'ensemble - -Ce document décrit la stratégie complète de mise en cache dans `pmoqobuz` pour **minimiser le nombre de requêtes API** et **limiter les logins**. - -## Objectifs - -1. **Limiter les login** - Éviter de se reconnecter à chaque démarrage -2. **Minimiser les requêtes API** - Réduire la charge sur les serveurs Qobuz -3. **Améliorer les performances** - Réponses instantanées pour les données déjà chargées -4. **Transparence** - Le cache doit être invisible pour l'utilisateur final - -## Architecture du cache - -### 1. Cache du token d'authentification ✅ IMPLÉMENTÉ - -**Localisation** : Fichier `config.yaml` dans la section `accounts.qobuz` - -**Données stockées** : -```yaml -accounts: - qobuz: - username: eric@coissac.eu - password: encrypted:yRyu/jNlJRSdVz0eE+JX56UC2Tk016TmESDoLT6npLBJB3ZuhJ0XTqNOQjiXkkcB - appid: '798273057' - secret: 806331c3b0b641da923b890aed01d04a - # Token d'authentification (ajouté automatiquement) - auth_token: "r7xPjQ5Kn8..." - user_id: "1217710" - token_expires_at: 1733953200 - subscription_label: "Studio" -``` - -**Stratégie** : -- Au **démarrage** : Réutiliser le token stocké SANS vérifier l'expiration -- Si une requête échoue avec **401/403** : Re-login automatique (TODO) -- Après un **login réussi** : Sauvegarder le token dans la config -- **TTL** : 24 heures (mais validation lazy) - -**Bénéfices** : -- ✅ **Zéro login inutile au démarrage** -- ✅ Démarrage instantané de l'application -- ✅ Token persisté entre les sessions - -**Implémentation** : [config_ext.rs:254-354](src/config_ext.rs#L254-354) - -```rust -// Au démarrage - aucun login ! -if let (Ok(Some(token)), Ok(Some(user_id))) = - (config.get_qobuz_auth_token(), config.get_qobuz_user_id()) -{ - api.set_auth_token(token, user_id); - info!("✓ Reusing authentication token (no login required)"); - // → Pas de requête réseau, démarrage instantané -} -``` - -### 2. Cache en mémoire (données API) ✅ IMPLÉMENTÉ - -**Localisation** : En mémoire (bibliothèque `moka`) - -**Implémentation** : [cache.rs](src/cache.rs) - -| Type de données | TTL | Capacité | Invalidation | -|----------------------|---------|-----------|--------------| -| Albums | 1h | 1000 | Manuelle | -| Tracks | 1h | 2000 | Manuelle | -| Artistes | 1h | 500 | Manuelle | -| Playlists | 30min | 250 | Manuelle | -| Résultats recherche | 15min | 500 | Manuelle | -| URLs streaming | 5min | 250 | Manuelle | - -**Stratégie** : -- **Vérifier le cache** avant chaque requête API -- Si donnée en cache ET non expirée → retour immédiat -- Sinon → requête API + mise en cache - -**Exemple** ([client.rs:247-263](src/client.rs#L247-263)) : -```rust -pub async fn get_album(&self, album_id: &str) -> Result { - // 1. Vérifier le cache d'abord - if let Some(album) = self.cache.get_album(album_id).await { - debug!("Album {} found in cache", album_id); - return Ok(album); // ← Aucune requête API ! - } - - // 2. Sinon, récupérer depuis l'API - let album = self.api.get_album(album_id).await?; - - // 3. Mettre en cache pour la prochaine fois - self.cache.put_album(album_id.to_string(), album.clone()).await; - - Ok(album) -} -``` - -**Bénéfices** : -- ✅ Réponses instantanées pour les données fréquemment accédées -- ✅ Réduction drastique des requêtes API -- ✅ Expiration automatique (TTL) -- ✅ Limite de mémoire (LRU éviction) - -### 3. Cache sur disque (favoris et bibliothèque) ❌ TODO - -**Problème actuel** : Les favoris et la bibliothèque ne sont PAS cachés - -```rust -pub async fn get_favorite_albums(&self) -> Result> { - // ❌ Requête API à CHAQUE appel - self.api.get_favorite_albums().await -} -``` - -**Impact** : -- 375 albums favoris → requête complète à chaque fois -- Playlists utilisateur → requête complète à chaque fois - -**Solution proposée** : Cache disque avec invalidation intelligente - -```rust -// Fichier: ~/.pmomusic/cache/favorites_{user_id}.json -pub async fn get_favorite_albums(&self) -> Result> { - let cache_file = format!("cache/favorites_{}.json", self.user_id); - - // Vérifier le cache sur disque - if let Ok(cached) = load_from_disk(&cache_file) { - if !is_expired(&cached, Duration::from_secs(3600)) { - return Ok(cached.albums); - } - } - - // Sinon, récupérer depuis l'API - let albums = self.api.get_favorite_albums().await?; - - // Sauvegarder pour la prochaine fois - save_to_disk(&cache_file, &albums)?; - - Ok(albums) -} -``` - -**Bénéfices potentiels** : -- ✅ Cache persistant entre les sessions -- ✅ Réduction majeure des requêtes pour les gros catalogues -- ✅ TTL configurable (ex: 1h pour favoris, 24h pour bibliothèque) - -## Statistiques et monitoring - -### Métriques disponibles - -```rust -let stats = client.cache().stats().await; -println!("Albums en cache: {}", stats.albums_count); -println!("Tracks en cache: {}", stats.tracks_count); -println!("Total: {} entrées", stats.total_count()); -``` - -### Logs de debug - -```bash -RUST_LOG=debug ./pmomusic -# → Voir les hits/miss du cache -# → Voir les requêtes API effectuées -``` - -## Impact mesuré - -### Avant optimisations -- **Login à chaque démarrage** : ~500ms -- **Recherche "Miles Davis"** (2ème fois) : ~300ms (nouvelle requête API) -- **get_album("123")** (2ème fois) : ~200ms (nouvelle requête API) - -### Après optimisations -- **Login au démarrage** : 0ms (token réutilisé) ✅ -- **Recherche "Miles Davis"** (2ème fois) : ~1ms (cache mémoire) ✅ -- **get_album("123")** (2ème fois) : ~0.5ms (cache mémoire) ✅ - -**Réduction** : **~99% du temps de réponse** pour les données déjà chargées - -## Recommandations - -### Court terme - -1. ✅ **Token d'authentification** - IMPLÉMENTÉ -2. ✅ **Cache mémoire** - IMPLÉMENTÉ -3. ❌ **Cache disque pour favoris** - TODO (priorité haute) - -### Moyen terme - -4. ❌ **Re-login automatique** sur erreur 401/403 - TODO -5. ❌ **Cache des playlists utilisateur** - TODO -6. ❌ **Invalidation intelligente** (ex: invalider cache favoris après ajout) - TODO - -### Long terme - -7. ❌ **Cache partagé entre instances** (Redis/SQLite) - TODO -8. ❌ **Préchargement** (favoris au démarrage en arrière-plan) - TODO -9. ❌ **Compression** du cache disque - TODO - -## Configuration - -### Configurer la taille du cache - -```rust -let cache = QobuzCache::with_capacity(2000); // 2000 albums max -let client = QobuzClient::new_with_cache(username, password, cache).await?; -``` - -### Désactiver le cache (debugging) - -```rust -let cache = QobuzCache::with_capacity(0); // Cache désactivé -``` - -### Invalider le cache - -```rust -// Invalider un album spécifique -client.cache().invalidate_album("123").await; - -// Tout effacer -client.cache().clear_all().await; -``` - -## Tests - -```bash -# Tests du module cache -cargo test -p pmoqobuz cache - -# Tests d'intégration avec Qobuz -cargo run --example basic_usage - -# Vérifier les logs de cache -RUST_LOG=debug,pmoqobuz::cache=trace cargo run --example basic_usage -``` - -## Conclusion - -La stratégie de cache actuelle offre déjà **d'excellentes performances** : -- ✅ Démarrage instantané (pas de login) -- ✅ Requêtes ultra-rapides (cache mémoire) -- ✅ Réduction de ~99% des requêtes répétées - -**Prochaine étape prioritaire** : Implémenter le cache disque pour les favoris et bibliothèque utilisateur. -========= End of pmoqobuz/CACHE_STRATEGY.md =========== - -=============== pmoqobuz/API_ANALYSIS.md ============ -# Analyse des différences entre l'API Rust et Python - -## Vue d'ensemble - -L'implémentation actuelle de `pmoqobuz` ne suit pas complètement l'API de référence Python (`qobuz.api.raw`). Voici les principales différences et ce qui doit être corrigé. - -## Problèmes identifiés - -### 1. ❌ Gestion du secret `s4` manquante - -**Python** : -- Accepte soit `appid` + `configvalue` (secret encodé en base64) -- Soit utilise le `Spoofer` pour obtenir l'appID et les secrets dynamiquement -- Le `configvalue` est décodé et XORé avec l'appID pour obtenir le secret `s4` -- Le secret `s4` est utilisé pour signer certaines requêtes critiques - -**Rust actuel** : -- ❌ Utilise un `DEFAULT_APP_ID` codé en dur -- ❌ Pas de gestion du secret `s4` -- ❌ Pas d'utilisation du Spoofer pour obtenir l'appID/secret -- ❌ Pas de méthode pour décoder et dériver le secret depuis un `configvalue` - -**Impact** : -- Les requêtes `track/getFileUrl` et `userLibrary/getAlbumsList` échoueront probablement car elles nécessitent une signature MD5 - -### 2. ❌ Signature MD5 des requêtes manquante - -**Python - track_getFileUrl** : -```python -ts = str(time.time()) -stringvalue = ("trackgetFileUrlformat_id" + fmt_id + - "intent" + intent + - "track_id" + track_id + ts).encode("ASCII") -stringvalue += self.s4 # Secret ajouté -rq_sig = str(hashlib.md5(stringvalue).hexdigest()) -params = { - "format_id": fmt_id, - "intent": intent, - "request_ts": ts, # ← Timestamp - "request_sig": rq_sig, # ← Signature MD5 - "track_id": track_id, -} -``` - -**Rust actuel (catalog.rs:210-218)** : -```rust -let params = [ - ("track_id", track_id), - ("format_id", &format_id), - ("intent", "stream"), - // ❌ MANQUE: request_ts - // ❌ MANQUE: request_sig -]; -``` - -**Impact** : -- Les requêtes de streaming peuvent échouer ou retourner des URLs invalides - -### 3. ❌ Méthode `userlib_getAlbums` manquante - -**Python** : -```python -def userlib_getAlbums(self, **ka): - ts = str(time.time()) - r_sig = "userLibrarygetAlbumsList" + str(ts) + str(ka["sec"]) - r_sig_hashed = hashlib.md5(r_sig.encode("utf-8")).hexdigest() - params = { - "app_id": self.appid, - "user_auth_token": self.user_auth_token, - "request_ts": ts, - "request_sig": r_sig_hashed, - } - return self._api_request(params, "/userLibrary/getAlbumsList") -``` - -**Rust actuel** : -- ❌ Méthode totalement absente - -**Impact** : -- Impossible de tester les secrets (méthode `setSec()`) -- Impossible de récupérer la bibliothèque d'albums de l'utilisateur - -### 4. ❌ Méthode `setSec()` manquante - -**Python** : -```python -def setSec(self): - # Teste tous les secrets du spoofer - for value in self.spoofer.getSecrets().values(): - self.s4 = value.encode("utf-8") - if self.userlib_getAlbums(sec=self.s4) is not None: - # Ce secret fonctionne ! - return -``` - -**Rust actuel** : -- ❌ Méthode totalement absente -- ❌ Pas de mécanisme pour tester et sélectionner le bon secret - -**Impact** : -- Si on utilise le Spoofer, impossible de trouver le bon secret parmi ceux retournés - -### 5. ⚠️ Configuration incomplète - -**Python** : -- Peut être initialisé avec `appid` + `configvalue` OU utiliser le Spoofer - -**Rust actuel** : -- ✅ Configuration du username/password via `QobuzConfigExt` -- ❌ Pas de configuration pour `appid` et `secret`/`configvalue` - -**Impact** : -- Impossible de configurer manuellement un appID et secret valides -- Dépendance à un appID codé en dur qui peut devenir obsolète - -## Plan de correction - -### Phase 1: Extension de la configuration - -**Fichier: `pmoqobuz/src/config_ext.rs`** - -Ajouter au trait `QobuzConfigExt` : -- `get_qobuz_appid()` / `set_qobuz_appid()` -- `get_qobuz_secret()` / `set_qobuz_secret()` (stocke la valeur base64) - -### Phase 2: Ajout du support du secret dans QobuzApi - -**Fichier: `pmoqobuz/src/api/mod.rs`** - -Modifications de `QobuzApi` : -```rust -pub struct QobuzApi { - client: Client, - app_id: String, - secret: Option>, // ← Nouveau : secret s4 décodé - user_auth_token: Option, - user_id: Option, - format_id: AudioFormat, -} -``` - -Nouvelles méthodes : -```rust -impl QobuzApi { - /// Crée une API avec appid + configvalue - pub fn with_secret(app_id: impl Into, configvalue: &str) -> Result; - - /// Crée une API en utilisant le Spoofer - pub async fn with_spoofer() -> Result; - - /// Définit le secret s4 - pub fn set_secret(&mut self, secret: Vec); - - /// Teste un secret en appelant userlib_getAlbums - async fn test_secret(&self, secret: &[u8]) -> bool; - - /// Teste et sélectionne le bon secret depuis le Spoofer - async fn set_secret_from_spoofer(&mut self, spoofer: &Spoofer) -> Result<()>; -} -``` - -### Phase 3: Implémentation des méthodes signées - -**Fichier: `pmoqobuz/src/api/signing.rs` (nouveau)** - -```rust -use md5::{Md5, Digest}; -use std::time::{SystemTime, UNIX_EPOCH}; - -/// Génère un timestamp Unix -pub fn get_timestamp() -> String { - SystemTime::now() - .duration_since(UNIX_EPOCH) - .unwrap() - .as_secs_f64() - .to_string() -} - -/// Signe une requête track/getFileUrl -pub fn sign_track_get_file_url( - format_id: &str, - intent: &str, - track_id: &str, - timestamp: &str, - secret: &[u8], -) -> String { - let mut hasher = Md5::new(); - hasher.update(b"trackgetFileUrlformat_id"); - hasher.update(format_id.as_bytes()); - hasher.update(b"intent"); - hasher.update(intent.as_bytes()); - hasher.update(b"track_id"); - hasher.update(track_id.as_bytes()); - hasher.update(timestamp.as_bytes()); - hasher.update(secret); - format!("{:x}", hasher.finalize()) -} - -/// Signe une requête userLibrary/getAlbumsList -pub fn sign_userlib_get_albums(timestamp: &str, secret: &[u8]) -> String { - let mut hasher = Md5::new(); - hasher.update(b"userLibrarygetAlbumsList"); - hasher.update(timestamp.as_bytes()); - hasher.update(secret); - format!("{:x}", hasher.finalize()) -} -``` - -**Fichier: `pmoqobuz/src/api/catalog.rs`** - -Modifier `get_file_url` : -```rust -pub async fn get_file_url(&self, track_id: &str) -> Result { - let format_id = self.format_id.id().to_string(); - let timestamp = signing::get_timestamp(); - - // Signature MD5 requise ! - let secret = self.secret.as_ref() - .ok_or_else(|| QobuzError::Configuration("Secret not configured".into()))?; - - let signature = signing::sign_track_get_file_url( - &format_id, - "stream", - track_id, - ×tamp, - secret, - ); - - let params = [ - ("track_id", track_id), - ("format_id", format_id.as_str()), - ("intent", "stream"), - ("request_ts", timestamp.as_str()), - ("request_sig", signature.as_str()), - ]; - - let response: FileUrlResponse = self.get("/track/getFileUrl", ¶ms).await?; - // ... -} -``` - -**Fichier: `pmoqobuz/src/api/user.rs`** - -Ajouter : -```rust -pub async fn get_user_albums(&self) -> Result { - let timestamp = signing::get_timestamp(); - - let secret = self.secret.as_ref() - .ok_or_else(|| QobuzError::Configuration("Secret not configured".into()))?; - - let signature = signing::sign_userlib_get_albums(×tamp, secret); - - let params = [ - ("app_id", self.app_id.as_str()), - ("user_auth_token", self.user_auth_token.as_ref() - .ok_or_else(|| QobuzError::Unauthorized("Not logged in".into()))? - .as_str()), - ("request_ts", timestamp.as_str()), - ("request_sig", signature.as_str()), - ]; - - self.post("/userLibrary/getAlbumsList", ¶ms).await -} -``` - -### Phase 4: Modification de QobuzClient - -**Fichier: `pmoqobuz/src/client.rs`** - -```rust -impl QobuzClient { - /// Crée un client avec appID et secret depuis la config - pub async fn from_config() -> Result { - let config = pmoconfig::get_config(); - - // Essayer d'obtenir appid et secret depuis la config - let api = if let (Ok(appid), Ok(secret)) = ( - config.get_qobuz_appid(), - config.get_qobuz_secret() - ) { - QobuzApi::with_secret(appid, &secret)? - } else { - // Sinon, utiliser le Spoofer - warn!("AppID/secret not configured, using Spoofer"); - QobuzApi::with_spoofer().await? - }; - - // Login... - let (username, password) = config.get_qobuz_credentials()?; - // ... - } -} -``` - -## Dépendances à ajouter - -**Cargo.toml** : -```toml -md5 = "0.7" -``` - -## Résumé des fichiers à modifier/créer - -### Modifications -- [x] `pmoqobuz/src/config_ext.rs` - Ajouter appid et secret -- [ ] `pmoqobuz/src/api/mod.rs` - Ajouter champ secret et nouvelles méthodes -- [ ] `pmoqobuz/src/api/auth.rs` - Appeler `set_secret_from_spoofer` après login -- [ ] `pmoqobuz/src/api/catalog.rs` - Ajouter signature à `get_file_url` -- [ ] `pmoqobuz/src/api/user.rs` - Ajouter `get_user_albums` avec signature -- [ ] `pmoqobuz/src/client.rs` - Utiliser Spoofer si pas de config -- [ ] `pmoqobuz/Cargo.toml` - Ajouter dépendance `md5` - -### Nouveaux fichiers -- [ ] `pmoqobuz/src/api/signing.rs` - Fonctions de signature MD5 - -## Tests nécessaires - -1. **Test avec Spoofer** : Vérifier que l'obtention automatique de l'appID fonctionne -2. **Test avec config manuelle** : Vérifier qu'on peut configurer un appID/secret -3. **Test de signature** : Vérifier que les signatures MD5 sont correctes -4. **Test de setSec** : Vérifier que le bon secret est sélectionné -5. **Test de streaming** : Vérifier qu'on obtient des URLs valides avec `get_file_url` -========= End of pmoqobuz/API_ANALYSIS.md =========== - -=============== pmoqobuz/README.md ============ -# pmoqobuz - Client Rust pour l'API Qobuz - -Client Rust pour l'API Qobuz avec intégration automatique du Spoofer pour obtenir des AppID et secrets valides. - -## 🎯 Fonctionnalités - -- ✅ **Authentification** automatique avec credentials -- ✅ **Spoofer intégré** - Obtention automatique d'AppID et secrets valides -- ✅ **Signatures MD5** pour les requêtes sensibles (streaming, bibliothèque) -- ✅ **Cache** en mémoire pour optimiser les performances -- ✅ **Support DIDL-Lite** pour l'export UPnP/DLNA -- ✅ **Recherche** dans le catalogue (albums, artistes, tracks, playlists) -- ✅ **Favoris** et playlists utilisateur -- ✅ **Désérialisation robuste** (gère integers et strings pour les IDs) - -## 🚀 Utilisation rapide - -### Configuration minimale - -```yaml -# ~/.pmomusic/config.yaml -accounts: - qobuz: - username: "your_email@example.com" - password: "your_password" - # AppID et secret seront automatiquement obtenus via le Spoofer -``` - -### Code d'exemple - -```rust -use pmoqobuz::QobuzClient; - -#[tokio::main] -async fn main() -> anyhow::Result<()> { - // Le Spoofer s'exécute automatiquement si nécessaire - let client = QobuzClient::from_config().await?; - - // Rechercher des albums - let albums = client.search_albums("Miles Davis").await?; - for album in albums.iter().take(5) { - println!("{} - {}", album.artist.name, album.title); - } - - Ok(()) -} -``` - -## 📖 Documentation - -- [IMPLEMENTATION_STATUS.md](IMPLEMENTATION_STATUS.md) - Statut d'implémentation complet -- [API_ANALYSIS.md](API_ANALYSIS.md) - Analyse des différences avec l'API Python -- [examples/basic_usage.rs](examples/basic_usage.rs) - Exemple complet -- [examples/spoofer.rs](examples/spoofer.rs) - Utilisation manuelle du Spoofer -========= End of pmoqobuz/README.md =========== - -=============== pmoqobuz/examples/config.yaml.example ============ -# Configuration exemple pour pmoqobuz -# -# Ce fichier montre comment configurer l'accès à Qobuz avec AppID et Secret. -# Pour utiliser cette configuration : -# -# 1. Copier ce fichier vers ~/.pmomusic/config.yaml (ou le répertoire de config approprié) -# 2. Remplacer les valeurs par vos propres credentials -# 3. Utiliser le Spoofer pour obtenir un AppID et Secret valides : -# cargo run --example spoofer - -host: - http_port: '8080' - cover_cache: - directory: cache_covers - size: 2000 - audio_cache: - directory: cache_audio - size: 500 - logger: - buffer_capacity: 200 - enable_console: true - min_level: INFO - -playlists: - directory: playlists - -devices: - mediarenderer: - pmo_mediarenderer: - udn: e4b68fbc-2bd5-4cea-98d8-be843fec0bd4 - mediaserver: - pmo_mediaserver: - udn: 17fe2ea6-8908-4e30-bc52-b28ea4cab3e4 - -accounts: - qobuz: - # Credentials utilisateur (REQUIS) - username: "your_email@example.com" - password: "your_password" - - # AppID et Secret (OPTIONNEL mais RECOMMANDÉ) - # Pour obtenir ces valeurs, exécutez : cargo run --example spoofer - # - # Exemple de valeurs récupérées le 2025-12-10 : - appid: "798273057" - secret: "f69a7734686cb9427629378a4b7ac381" # Secret pour timezone "london" - - # Autres secrets disponibles (testez si "london" ne fonctionne pas) : - # secret: "806331c3b0b641da923b890aed01d04a" # Secret pour timezone "abidjan" - # secret: "abb21364945c0583309667d13ca3d93a" # Secret pour timezone "berlin" - - # Note sur les secrets : - # - Les secrets sont des valeurs base64-encodées retournées par le Spoofer - # - Ils sont nécessaires pour les requêtes signées (streaming, bibliothèque) - # - Sans secret, seules les fonctionnalités de base sont disponibles - # - Les secrets peuvent expirer : réexécutez le Spoofer pour en obtenir de nouveaux -========= End of pmoqobuz/examples/config.yaml.example =========== - -=============== pmoqobuz/examples/spoofer.rs ============ -//! Exemple de Spoofer Qobuz - Extraction dynamique des AppID et secrets -//! -//! Cet exemple reproduit le comportement du spoofer Python : -//! 1. Récupère la page de login Qobuz -//! 2. Extrait l'URL du bundle.js -//! 3. Télécharge le bundle -//! 4. Extrait l'AppID et les secrets via regex -//! 5. Décode les secrets en base64 -//! -//! Usage: -//! ```bash -//! cargo run --example spoofer -//! ``` - -use anyhow::Result; -use base64::{engine::general_purpose::STANDARD, Engine}; -use indexmap::IndexMap; -use regex::Regex; -use reqwest::Client; - -struct Spoofer { - bundle: String, - seed_timezone_regex: Regex, - info_extras_regex_template: String, - app_id_regex: Regex, -} - -impl Spoofer { - /// Crée un nouveau Spoofer et télécharge le bundle.js - async fn new() -> Result { - // Expressions régulières (équivalent Python) - let seed_timezone_regex = Regex::new( - r#"[a-z]\.initialSeed\("(?P[\w=]+)",window\.utimezone\.(?P[a-z]+)\)"#, - )?; - - let info_extras_regex_template = - r#"name:"\w+/(?P{timezones})",info:"(?P[\w=]+)",extras:"(?P[\w=]+)""# - .to_string(); - - let app_id_regex = Regex::new( - r#"production:\{api:\{appId:"(?P\d{9})",appSecret:"(?P\w{32})"\},braze:.\(.\(\{\},.\),\{\},\{apiKey:"([-0-9a-fA-F]{36})"\}\),extra:.\}"#, - )?; - - // Créer un client HTTP - let client = Client::builder() - .user_agent("Mozilla/5.0 (compatible; PMOMusic/1.0)") - .build()?; - - println!("Récupération de la page de login..."); - let login_page = client - .get("https://play.qobuz.com/login") - .send() - .await? - .text() - .await?; - - // Extraire l'URL du bundle - let bundle_url_regex = - Regex::new(r#""#)?; - let bundle_url = bundle_url_regex - .captures(&login_page) - .and_then(|cap| cap.get(1)) - .ok_or_else(|| anyhow::anyhow!("Impossible de trouver l'URL du bundle"))? - .as_str(); - - println!("Téléchargement du bundle depuis: {}", bundle_url); - let bundle_full_url = format!("https://play.qobuz.com{}", bundle_url); - let bundle = client.get(&bundle_full_url).send().await?.text().await?; - - println!("Bundle téléchargé ({} bytes)", bundle.len()); - - Ok(Self { - bundle, - seed_timezone_regex, - info_extras_regex_template, - app_id_regex, - }) - } - - /// Extrait l'App ID depuis le bundle - fn get_app_id(&self) -> Result { - let captures = self - .app_id_regex - .captures(&self.bundle) - .ok_or_else(|| anyhow::anyhow!("AppID non trouvé dans le bundle"))?; - - Ok(captures - .name("app_id") - .ok_or_else(|| anyhow::anyhow!("Groupe app_id non trouvé"))? - .as_str() - .to_string()) - } - - /// Extrait les secrets depuis le bundle - fn get_secrets(&self) -> Result> { - // Étape 1: Extraire tous les seed/timezone pairs - let mut secrets: IndexMap> = IndexMap::new(); - - for captures in self.seed_timezone_regex.captures_iter(&self.bundle) { - let seed = captures - .name("seed") - .ok_or_else(|| anyhow::anyhow!("Groupe seed non trouvé"))? - .as_str(); - let timezone = captures - .name("timezone") - .ok_or_else(|| anyhow::anyhow!("Groupe timezone non trouvé"))? - .as_str(); - - secrets - .entry(timezone.to_string()) - .or_insert_with(Vec::new) - .push(seed.to_string()); - } - - println!("Timezones trouvées: {:?}", secrets.keys()); - - // Étape 2: Réordonner - on met la deuxième timezone en premier - // (comme le fait le code Python avec move_to_end) - if secrets.len() >= 2 { - let keys: Vec = secrets.keys().cloned().collect(); - let second_key = keys[1].clone(); - let second_value = secrets.get(&second_key).unwrap().clone(); - - // Retirer et réinsérer pour le mettre en premier - secrets.shift_remove(&second_key); - let mut new_secrets = IndexMap::new(); - new_secrets.insert(second_key, second_value); - for (k, v) in secrets { - new_secrets.insert(k, v); - } - secrets = new_secrets; - } - - // Étape 3: Construire la regex pour info/extras - let timezones_capitalized: Vec = secrets - .keys() - .map(|tz| { - let mut chars = tz.chars(); - match chars.next() { - None => String::new(), - Some(first) => first.to_uppercase().collect::() + chars.as_str(), - } - }) - .collect(); - - let info_extras_regex_str = self - .info_extras_regex_template - .replace("{timezones}", &timezones_capitalized.join("|")); - - let info_extras_regex = Regex::new(&info_extras_regex_str)?; - - // Étape 4: Extraire info et extras pour chaque timezone - for captures in info_extras_regex.captures_iter(&self.bundle) { - let timezone_cap = captures - .name("timezone") - .ok_or_else(|| anyhow::anyhow!("Groupe timezone non trouvé"))? - .as_str(); - let info = captures - .name("info") - .ok_or_else(|| anyhow::anyhow!("Groupe info non trouvé"))? - .as_str(); - let extras = captures - .name("extras") - .ok_or_else(|| anyhow::anyhow!("Groupe extras non trouvé"))? - .as_str(); - - let timezone_lower = timezone_cap.to_lowercase(); - if let Some(vec) = secrets.get_mut(&timezone_lower) { - vec.push(info.to_string()); - vec.push(extras.to_string()); - } - } - - // Étape 5: Décoder les secrets en base64 - let mut decoded_secrets = IndexMap::new(); - for (timezone, parts) in secrets { - let concatenated = parts.join(""); - - // Retirer les 44 derniers caractères (comme Python [:-44]) - if concatenated.len() > 44 { - let trimmed = &concatenated[..concatenated.len() - 44]; - - // Décoder en base64 - match STANDARD.decode(trimmed) { - Ok(decoded_bytes) => { - match String::from_utf8(decoded_bytes) { - Ok(decoded_str) => { - decoded_secrets.insert(timezone, decoded_str); - } - Err(e) => { - eprintln!( - "Erreur UTF-8 pour timezone {}: {}", - timezone, e - ); - } - } - } - Err(e) => { - eprintln!( - "Erreur de décodage base64 pour timezone {}: {}", - timezone, e - ); - } - } - } - } - - Ok(decoded_secrets) - } -} - -#[tokio::main] -async fn main() -> Result<()> { - // Initialiser le logging - tracing_subscriber::fmt::init(); - - println!("=== Spoofer Qobuz ===\n"); - - // Créer le spoofer - let spoofer = Spoofer::new().await?; - - // Extraire l'App ID - println!("\n--- App ID ---"); - match spoofer.get_app_id() { - Ok(app_id) => println!("App ID: {}", app_id), - Err(e) => eprintln!("Erreur lors de l'extraction de l'App ID: {}", e), - } - - // Extraire les secrets - println!("\n--- Secrets ---"); - match spoofer.get_secrets() { - Ok(secrets) => { - for (timezone, secret) in secrets { - println!("{}: {}", timezone, secret); - } - } - Err(e) => eprintln!("Erreur lors de l'extraction des secrets: {}", e), - } - - Ok(()) -} -========= End of pmoqobuz/examples/spoofer.rs =========== - -=============== pmoqobuz/examples/server_with_covers.rs ============ -//! Exemple d'utilisation de pmoqobuz avec pmoserver et pmocovers -//! -//! Cet exemple montre comment : -//! - Créer un serveur HTTP avec pmoserver -//! - Initialiser le cache d'images avec pmocovers -//! - Initialiser le client Qobuz avec intégration pmocovers -//! - Les images d'albums sont automatiquement mises en cache -//! -//! Pour tester : -//! ```bash -//! cargo run --example server_with_covers --features "pmoserver,covers" -//! ``` -//! -//! Endpoints disponibles : -//! - GET /qobuz/search?q=query&type=albums - Recherche d'albums (images auto-cachées) -//! - GET /qobuz/albums/{id} - Détails d'un album (image auto-cachée) -//! - GET /qobuz/favorites/albums - Albums favoris (images auto-cachées) -//! - GET /covers/images/{pk} - Image originale mise en cache -//! - GET /covers/images/{pk}/{size} - Variante redimensionnée -//! - GET /api/covers - API REST du cache d'images -//! - GET /swagger-ui - Documentation interactive - -#[cfg(all(feature = "pmoserver", feature = "covers"))] -use pmocovers::CoverCacheExt; - -#[cfg(all(feature = "pmoserver", feature = "covers"))] -use pmoqobuz::QobuzServerExt; - -#[cfg(all(feature = "pmoserver", feature = "covers"))] -use pmoserver::ServerBuilder; - -#[cfg(all(feature = "pmoserver", feature = "covers"))] -#[tokio::main] -async fn main() -> anyhow::Result<()> { - // Initialiser le logging - tracing_subscriber::fmt() - .with_max_level(tracing::Level::INFO) - .init(); - - println!("=== PMOQobuz + PMOCovers - Serveur HTTP avec cache d'images ===\n"); - - // Créer le serveur depuis la configuration - let mut server = ServerBuilder::new_configured().build(); - - println!("1. Initialisation du cache d'images (pmocovers)..."); - // Initialiser le cache d'images avec la configuration - let cache = server.init_cover_cache_configured().await?; - println!(" ✓ Cache d'images initialisé: {}", cache.cache_dir()); - - println!("\n2. Initialisation du client Qobuz avec intégration pmocovers..."); - // Initialiser le client Qobuz avec intégration pmocovers - // Les images d'albums seront automatiquement ajoutées au cache - let client = server - .init_qobuz_client_configured_with_covers(cache.clone()) - .await?; - - if let Some(auth_info) = client.auth_info() { - println!(" ✓ Client Qobuz connecté !"); - println!(" User ID: {}", auth_info.user_id); - if let Some(label) = &auth_info.subscription_label { - println!(" Abonnement: {}", label); - } - } - - println!("\n3. Démarrage du serveur HTTP..."); - server.start().await; - - println!("\n✓ Serveur démarré avec succès !\n"); - println!("Endpoints disponibles :"); - println!(" • Qobuz API:"); - println!(" - GET /qobuz/search?q=query&type=albums"); - println!(" - GET /qobuz/albums/{{id}}"); - println!(" - GET /qobuz/albums/{{id}}/tracks"); - println!(" - GET /qobuz/favorites/albums"); - println!(" - GET /qobuz/favorites/artists"); - println!(" - GET /qobuz/cache/stats"); - println!(" • Images (auto-cachées depuis Qobuz):"); - println!(" - GET /covers/images/{{pk}}"); - println!(" - GET /covers/images/{{pk}}/{{size}}"); - println!(" • API REST du cache:"); - println!(" - GET /api/covers"); - println!(" - POST /api/covers"); - println!(" - DELETE /api/covers/{{pk}}"); - println!(" • Documentation:"); - println!(" - GET /swagger-ui"); - println!("\nExemple de requête :"); - println!(" curl 'http://localhost:3000/qobuz/search?q=Miles%20Davis&type=albums' | jq '.[0].image_cached'"); - println!(" # Retourne: \"/covers/images/{{pk}}\""); - println!("\nAppuyez sur Ctrl+C pour arrêter le serveur...\n"); - - // Attendre indéfiniment - server.wait().await; - - Ok(()) -} - -#[cfg(not(all(feature = "pmoserver", feature = "covers")))] -fn main() { - eprintln!("Cet exemple nécessite les features 'pmoserver' et 'covers'"); - eprintln!("Exécutez: cargo run --example server_with_covers --features \"pmoserver,covers\""); - std::process::exit(1); -} -========= End of pmoqobuz/examples/server_with_covers.rs =========== - -=============== pmoqobuz/examples/README_SPOOFER.md ============ -# Exemple Spoofer Qobuz - -Cet exemple reproduit le comportement du spoofer Python original pour extraire dynamiquement l'AppID et les secrets de l'API Qobuz. - -## Vue d'ensemble - -Le spoofer effectue les opérations suivantes : - -1. **Récupère la page de login** : `https://play.qobuz.com/login` -2. **Extrait l'URL du bundle.js** : Via regex sur la page HTML -3. **Télécharge le bundle** : JavaScript obfusqué contenant les secrets -4. **Extrait l'AppID** : Via regex spécifique -5. **Extrait les secrets** : Via une série de regex et décodage base64 - -## Équivalences Python ↔ Rust - -| Python | Rust | Notes | -|--------|------|-------| -| `requests.get()` | `reqwest::Client::get()` | Client HTTP asynchrone | -| `re.search()` / `re.finditer()` | `regex::Regex::captures()` / `captures_iter()` | Expressions régulières | -| `OrderedDict` | `indexmap::IndexMap` | Maintient l'ordre d'insertion | -| `base64.standard_b64decode()` | `base64::STANDARD.decode()` | Décodage base64 | -| String slicing `[:-44]` | `&string[..len-44]` | Extraction de sous-chaînes | - -## Différences notables - -### 1. Gestion asynchrone -Le code Rust est entièrement asynchrone avec Tokio : -```rust -#[tokio::main] -async fn main() -> Result<()> { - let spoofer = Spoofer::new().await?; - // ... -} -``` - -### 2. Gestion d'erreurs explicite -Rust utilise `Result` pour la gestion d'erreurs : -```rust -fn get_app_id(&self) -> Result { - let captures = self.app_id_regex - .captures(&self.bundle) - .ok_or_else(|| anyhow::anyhow!("AppID non trouvé"))?; - // ... -} -``` - -### 3. Propriété et emprunt -Rust nécessite une gestion explicite de la propriété : -```rust -// Clone pour éviter les problèmes de borrowing -let second_key = keys[1].clone(); -let second_value = secrets.get(&second_key).unwrap().clone(); -``` - -### 4. Réorganisation de l'IndexMap -Le code Python utilise `move_to_end()` : -```python -secrets.move_to_end(keypairs[1][0], last=False) -``` - -En Rust, on reconstruit une nouvelle map : -```rust -secrets.shift_remove(&second_key); -let mut new_secrets = IndexMap::new(); -new_secrets.insert(second_key, second_value); -for (k, v) in secrets { - new_secrets.insert(k, v); -} -``` - -## Usage - -```bash -# Compiler et lancer l'exemple -cargo run --example spoofer - -# Ou compiler uniquement -cargo check --example spoofer -``` - -## Sortie attendue - -``` -=== Spoofer Qobuz === - -Récupération de la page de login... -Téléchargement du bundle depuis: /resources/x.x.x-xxxx/bundle.js -Bundle téléchargé (xxxxx bytes) -Timezones trouvées: ["america", "europe", "asia", ...] - ---- App ID --- -App ID: 123456789 - ---- Secrets --- -america: xxxxxxxxxxxxxxxxxxxxxxxxx -europe: yyyyyyyyyyyyyyyyyyyyyyyyy -... -``` - -## Dépendances - -Les dépendances suivantes sont nécessaires (ajoutées dans `[dev-dependencies]`) : - -```toml -regex = "1.10" -base64 = "0.22" -indexmap = "2.0" -``` - -## Avertissement - -⚠️ **Note importante** : Ce code est fourni à des fins éducatives et de reverse engineering. L'extraction de secrets depuis des applications web peut violer les conditions d'utilisation de certains services. Utilisez-le de manière responsable et conformément aux lois applicables. - -## Références - -- Code Python original : Basé sur le spoofer Qobuz de la communauté -- Documentation Qobuz API : https://github.com/Qobuz/api-documentation -========= End of pmoqobuz/examples/README_SPOOFER.md =========== - -=============== pmoqobuz/examples/basic_usage.rs ============ -//! Exemple d'utilisation basique de pmoqobuz -//! -//! Cet exemple montre comment : -//! - Se connecter à Qobuz avec les credentials de la configuration -//! - Rechercher des albums -//! - Récupérer les détails d'un album -//! - Exporter un album en format DIDL-Lite - -use pmoqobuz::{QobuzClient, ToDIDL}; - -#[tokio::main] -async fn main() -> anyhow::Result<()> { - // Initialiser le logging - tracing_subscriber::fmt::init(); - - println!("=== PMOQobuz - Exemple d'utilisation basique ===\n"); - - // Créer un client depuis la configuration - println!("Connexion à Qobuz..."); - let client = QobuzClient::from_config().await?; - - if let Some(auth_info) = client.auth_info() { - println!("✓ Connecté avec succès !"); - println!(" User ID: {}", auth_info.user_id); - if let Some(label) = &auth_info.subscription_label { - println!(" Abonnement: {}", label); - } - } - - println!("\n--- Recherche d'albums ---"); - let query = "Miles Davis"; - println!("Recherche: '{}'...", query); - - let albums = client.search_albums(query).await?; - println!("✓ {} album(s) trouvé(s)\n", albums.len()); - - // Afficher les 5 premiers albums - for (i, album) in albums.iter().take(5).enumerate() { - println!(" {}. {} - {}", i + 1, album.artist.name, album.title); - if let Some(date) = &album.release_date { - println!(" Date: {}", date); - } - if let Some(count) = album.tracks_count { - println!(" Pistes: {}", count); - } - } - - // Récupérer les détails du premier album - if let Some(first_album) = albums.first() { - println!("\n--- Détails de l'album ---"); - println!("Album: {} - {}", first_album.artist.name, first_album.title); - - // Récupérer les tracks - let tracks = client.get_album_tracks(&first_album.id).await?; - println!("Tracks ({}):", tracks.len()); - - for track in tracks.iter().take(3) { - println!( - " {}. {} - {} ({}:{})", - track.track_number, - track - .display_artist() - .map(|a| a.name.as_str()) - .unwrap_or("Unknown"), - track.title, - track.duration / 60, - track.duration % 60 - ); - } - - if tracks.len() > 3 { - println!(" ... et {} autres pistes", tracks.len() - 3); - } - - // Export DIDL - println!("\n--- Export DIDL-Lite ---"); - let didl_container = first_album.to_didl_container("0")?; - println!("Container ID: {}", didl_container.id); - println!("Title: {}", didl_container.title); - println!("Class: {}", didl_container.class); - - if let Some(first_track) = tracks.first() { - let didl_item = first_track.to_didl_item(&didl_container.id)?; - println!("\nPremière track en DIDL:"); - println!(" Item ID: {}", didl_item.id); - println!(" Title: {}", didl_item.title); - if let Some(artist) = &didl_item.artist { - println!(" Artist: {}", artist); - } - } - } - - // Afficher les statistiques du cache - println!("\n--- Statistiques du cache ---"); - let stats = client.cache().stats().await; - println!("Albums en cache: {}", stats.albums_count); - println!("Tracks en cache: {}", stats.tracks_count); - println!("Artistes en cache: {}", stats.artists_count); - println!("Total: {} entrées", stats.total_count()); - - // Favoris - println!("\n--- Albums favoris ---"); - match client.get_favorite_albums().await { - Ok(favorites) => { - println!("✓ {} album(s) favori(s)", favorites.len()); - for (i, album) in favorites.iter().take(5).enumerate() { - println!(" {}. {} - {}", i + 1, album.artist.name, album.title); - } - if favorites.len() > 5 { - println!(" ... et {} autres", favorites.len() - 5); - } - } - Err(e) => { - println!("⚠ Impossible de récupérer les favoris: {}", e); - } - } - - println!("\n✓ Exemple terminé avec succès !"); - - Ok(()) -} -========= End of pmoqobuz/examples/basic_usage.rs =========== - -=============== pmoqobuz/examples/with_cache.rs ============ -//! Example demonstrating Qobuz with cache support -//! -//! This example shows how to use the QobuzSource with pmocovers -//! and pmoaudiocache to cache both cover images and audio tracks. -//! -//! Run with: -//! ```bash -//! cargo run --example with_cache --features cache -//! ``` - -use pmoaudiocache::AudioCache; -use pmocovers::Cache as CoverCache; -use pmoqobuz::{QobuzClient, QobuzSource}; -use pmosource::MusicSource; -use std::sync::Arc; - -#[tokio::main] -async fn main() -> Result<(), Box> { - // Initialize tracing - tracing_subscriber::fmt::init(); - - println!("🎵 Qobuz with Cache Support"); - println!("============================\n"); - - // Create the Qobuz client using configuration - println!("📡 Connecting to Qobuz..."); - let client = QobuzClient::from_config().await?; - println!("✅ Connected!\n"); - - // Initialize caches - println!("💾 Initializing caches..."); - let cover_cache = Arc::new(CoverCache::new("./cache/qobuz-covers", 500)?); - let audio_cache = Arc::new(AudioCache::new("./cache/qobuz-audio", 100)?); - println!("✅ Caches initialized!\n"); - - // Create the source with caching enabled - let source = QobuzSource::new_with_cache( - client, - "http://localhost:8080", - Some(cover_cache.clone()), - Some(audio_cache.clone()), - ); - - println!("📻 Source: {}", source.name()); - println!("🆔 ID: {}", source.id()); - println!("📝 Supports FIFO: {}\n", source.supports_fifo()); - - // Get user's favorite tracks - println!("🎧 Fetching your favorite tracks..."); - let favorite_tracks = source.client().get_favorite_tracks().await?; - - if favorite_tracks.is_empty() { - println!("⚠️ No favorite tracks found. Add some favorites on Qobuz first!"); - println!("\n💡 Tip: You can also search for tracks:"); - - // Example: Search for tracks - println!("\n🔍 Searching for 'Miles Davis'..."); - let search_results = source.client().search("Miles Davis", None).await?; - - if !search_results.tracks.is_empty() { - println!("\n📋 Found {} tracks:", search_results.tracks.len()); - for (i, track) in search_results.tracks.iter().enumerate().take(3) { - println!( - " {}. {} - {}", - i + 1, - track - .performer - .as_ref() - .map(|p| p.name.as_str()) - .unwrap_or("Unknown"), - track.title - ); - - // Demonstrate adding a track with caching - if i == 0 { - println!("\n➕ Adding first track to cache..."); - let track_id = source.add_track(track).await?; - println!("✅ Track added with ID: {}", track_id); - println!(" - Cover image caching started"); - println!(" - Audio caching started (high-quality FLAC)"); - - // Show resolved URI (will use cached version if available) - if let Ok(uri) = source.resolve_uri(&track_id).await { - println!(" - Stream URI: {}", uri); - } - } - } - } - } else { - println!("✅ Found {} favorite tracks!\n", favorite_tracks.len()); - - // Add first 3 favorite tracks with caching - for (i, track) in favorite_tracks.iter().enumerate().take(3) { - println!( - "{}. {} - {}", - i + 1, - track - .performer - .as_ref() - .map(|p| p.name.as_str()) - .unwrap_or("Unknown"), - track.title - ); - - if let Some(album) = &track.album { - println!(" Album: {}", album.title); - if let Some(label) = &album.label { - println!(" Label: {}", label); - } - if let Some(sample_rate) = album.maximum_sampling_rate { - println!(" Max Sample Rate: {} kHz", sample_rate / 1000.0); - } - if let Some(bit_depth) = album.maximum_bit_depth { - println!(" Max Bit Depth: {} bit", bit_depth); - } - } - - println!("\n ➕ Adding to cache..."); - match source.add_track(track).await { - Ok(track_id) => { - println!(" ✅ Track cached successfully!"); - - // Show resolved URI - if let Ok(uri) = source.resolve_uri(&track_id).await { - println!(" 📍 Stream URI: {}", uri); - } - } - Err(e) => { - println!(" ⚠️ Failed to cache track: {}", e); - } - } - println!(); - } - } - - // Browse favorite albums - println!("\n📚 Browsing your favorite albums..."); - let favorite_albums = source.client().get_favorite_albums().await?; - - if !favorite_albums.is_empty() { - println!("✅ Found {} favorite albums!\n", favorite_albums.len()); - - for (i, album) in favorite_albums.iter().enumerate().take(3) { - println!("{}. {} - {}", i + 1, album.artist.name, album.title); - if let Some(release_date) = &album.release_date { - println!(" Released: {}", release_date); - } - if let Some(tracks_count) = album.tracks_count { - println!(" Tracks: {}", tracks_count); - } - if !album.genres.is_empty() { - println!(" Genres: {}", album.genres.join(", ")); - } - } - } else { - println!("⚠️ No favorite albums found."); - } - - println!("\n✨ Example complete!"); - println!("\n💡 Tips:"); - println!(" - Run the example again to see faster loading from cache"); - println!(" - Check ./cache/qobuz-covers/ for cached cover images (WebP)"); - println!(" - Check ./cache/qobuz-audio/ for cached Hi-Res FLAC files"); - println!(" - Qobuz provides rich metadata (label, ISRC, sample rate, bit depth)"); - println!(" - Cached audio retains original quality (up to 24bit/192kHz)"); - - Ok(()) -} -========= End of pmoqobuz/examples/with_cache.rs =========== - -=============== pmoqobuz/examples/lazy_loading.rs ============ -//! Example demonstrating Qobuz lazy loading with rate limiting -//! -//! This example shows how to use the new lazy loading feature to add albums -//! to playlists without downloading all audio files immediately. Only covers -//! are downloaded eagerly, audio is downloaded on-demand when played. -//! -//! Features demonstrated: -//! - Rate limiting (max 2 concurrent requests, 400ms delay) -//! - Lazy audio loading (saves ~99% initial bandwidth) -//! - Eager cover loading (UI responsiveness) -//! - Automatic PK switching when audio is downloaded -//! - Prefetch of next 2 tracks during playback -//! -//! Run with: -//! ```bash -//! cargo run -p pmoqobuz --example lazy_loading -//! ``` - -use pmoaudiocache::Cache as AudioCache; -use pmocovers::Cache as CoverCache; -use pmoplaylist::PlaylistManager; -use pmoqobuz::{QobuzClient, QobuzSource}; -use std::sync::Arc; -use std::time::Instant; - -#[tokio::main] -async fn main() -> Result<(), Box> { - // Initialize tracing with debug level to see rate limiting - tracing_subscriber::fmt() - .with_max_level(tracing::Level::INFO) - .with_target(false) - .init(); - - println!("🎵 Qobuz Lazy Loading Demo"); - println!("============================\n"); - - // Step 1: Connect to Qobuz with rate limiting enabled - println!("📡 Connecting to Qobuz (rate limiting enabled)..."); - let client = QobuzClient::from_config().await?; - println!("✅ Connected with rate limiting:"); - println!(" - Max 2 concurrent requests"); - println!(" - 400ms minimum delay between requests\n"); - - // Step 2: Initialize caches - println!("💾 Initializing caches..."); - let cover_cache = Arc::new(CoverCache::new("./cache/qobuz-covers", 500)?); - let audio_cache = Arc::new(AudioCache::new("./cache/qobuz-audio", 100)?); - println!("✅ Caches initialized\n"); - - // Step 3: Create QobuzSource with caches - let source = QobuzSource::new(client, cover_cache.clone(), audio_cache.clone()); - - // Step 4: Get user's favorite albums - println!("🎧 Fetching your favorite albums..."); - let favorite_albums = source.client().get_favorite_albums().await?; - - if favorite_albums.is_empty() { - println!("⚠️ No favorite albums found!"); - println!(" Please add some albums to your Qobuz favorites first.\n"); - return Ok(()); - } - - println!("✅ Found {} favorite albums\n", favorite_albums.len()); - - // Step 5: Select first album for testing - let album = &favorite_albums[0]; - println!("📀 Selected album: {} - {}", album.artist.name, album.title); - println!(" Tracks: {}", album.tracks_count.unwrap_or(0)); - println!(" Album ID: {}\n", album.id); - - // Step 6: Create a test playlist - println!("📝 Creating test playlist..."); - let playlist_manager = PlaylistManager(); - let playlist_id = { - let writer = playlist_manager - .create_persistent_playlist("lazy-test".to_string()) - .await?; - writer.id().to_string() - }; // Drop writer here to release the lock - println!("✅ Playlist created: {}\n", playlist_id); - - // Step 7: Add album with lazy loading (measure time and track downloads) - println!("⏱️ Adding album to playlist with LAZY loading..."); - println!(" This will:"); - println!(" - Download covers immediately (~400 KB each)"); - println!(" - Create lazy PKs for audio (NO download)"); - println!(" - Enable prefetch for next 2 tracks\n"); - - let start = Instant::now(); - let count = source - .add_album_to_playlist(&playlist_id, &album.id) - .await?; - let elapsed = start.elapsed(); - - println!("✅ Album added: {} tracks in {:.2}s", count, elapsed.as_secs_f64()); - println!(" Average: {:.0}ms per track\n", elapsed.as_millis() as f64 / count as f64); - - // Step 8: Verify lazy PKs - println!("🔍 Verifying lazy PKs..."); - let reader = playlist_manager.get_read_handle(&playlist_id).await?; - - // Read all tracks from playlist - let mut tracks = Vec::new(); - loop { - match reader.peek().await? { - Some(track) => { - tracks.push(track); - reader.pop().await?; - } - None => break, - } - } - - if tracks.is_empty() { - println!("⚠️ No tracks in playlist!"); - return Ok(()); - } - - let first_track_pk = tracks[0].cache_pk(); - let is_lazy = pmocache::is_lazy_pk(&first_track_pk); - - println!(" First track PK: {}", first_track_pk); - println!(" Is lazy: {}", if is_lazy { "✅ YES (starts with 'L:')" } else { "❌ NO" }); - - // Count lazy vs downloaded - let lazy_count = tracks.iter().filter(|t| pmocache::is_lazy_pk(t.cache_pk())).count(); - let downloaded_count = tracks.len() - lazy_count; - - println!("\n📊 Track status:"); - println!(" Lazy (not downloaded): {} tracks", lazy_count); - println!(" Downloaded: {} tracks", downloaded_count); - - // Step 9: Check cache sizes - println!("\n💾 Cache disk usage:"); - println!(" Covers: {:?}", get_dir_size("./cache/qobuz-covers")?); - println!(" Audio: {:?}", get_dir_size("./cache/qobuz-audio")?); - - // Step 10: Demonstrate on-demand download - if is_lazy { - println!("\n🎵 Simulating playback of first track..."); - println!(" This would trigger download via HTTP request to:"); - println!(" GET /cache/flac/{}", first_track_pk); - println!("\n The lazy PK will automatically:"); - println!(" 1. Download the audio file from Qobuz"); - println!(" 2. Convert to FLAC"); - println!(" 3. Calculate real PK from content"); - println!(" 4. Update playlist (lazy_pk → real_pk)"); - println!(" 5. Prefetch next 2 tracks in background"); - } - - // Step 11: Summary - println!("\n╭─────────────────────────────────────────╮"); - println!("│ 🎉 Lazy Loading Demo Complete! │"); - println!("╰─────────────────────────────────────────╯"); - println!("\n📈 Benefits demonstrated:"); - println!(" ✓ Fast album loading (~{}ms per track)", elapsed.as_millis() / count as u128); - println!(" ✓ Minimal initial download (covers only)"); - println!(" ✓ Audio downloaded on-demand"); - println!(" ✓ Rate limiting active (respectful to Qobuz)"); - println!(" ✓ Automatic prefetching during playback"); - - println!("\n💡 For 375 favorite albums (~3750 tracks):"); - println!(" Without lazy: ~15 GB download, ~75s (no rate limit)"); - println!(" With lazy: ~150 MB download, ~5 min (rate limited)"); - println!(" Savings: ~99% bandwidth, natural request pattern"); - - Ok(()) -} - -/// Calculate directory size recursively -fn get_dir_size(path: &str) -> Result> { - use std::fs; - - let mut total: u64 = 0; - - if let Ok(entries) = fs::read_dir(path) { - for entry in entries.flatten() { - if let Ok(metadata) = entry.metadata() { - if metadata.is_file() { - total += metadata.len(); - } else if metadata.is_dir() { - if let Ok(size_str) = get_dir_size(&entry.path().to_string_lossy()) { - // Parse size from string (hacky but works for this example) - if let Some(num) = size_str.split_whitespace().next() { - if let Ok(size) = num.parse::() { - total += (size * 1024.0 * 1024.0) as u64; - } - } - } - } - } - } - } - - Ok(format_size(total)) -} - -/// Format bytes to human-readable size -fn format_size(bytes: u64) -> String { - const KB: u64 = 1024; - const MB: u64 = KB * 1024; - const GB: u64 = MB * 1024; - - if bytes >= GB { - format!("{:.2} GB", bytes as f64 / GB as f64) - } else if bytes >= MB { - format!("{:.2} MB", bytes as f64 / MB as f64) - } else if bytes >= KB { - format!("{:.2} KB", bytes as f64 / KB as f64) - } else { - format!("{} B", bytes) - } -} -========= End of pmoqobuz/examples/lazy_loading.rs =========== - -=============== pmoqobuz/examples/show_source_image.rs ============ -//! Example showing how to access and save the Qobuz source image -//! -//! This example demonstrates: -//! - Getting source information via the MusicSource trait -//! - Accessing the embedded WebP image -//! - Optionally saving it to a file - -use pmoqobuz::{QobuzClient, QobuzSource}; -use pmosource::MusicSource; -use std::fs; -use std::io::Write; - -#[tokio::main] -async fn main() -> Result<(), Box> { - // Create the client and source - let client = QobuzClient::from_config().await?; - let source = QobuzSource::new(client, "http://localhost:8080"); - - // Display source information - println!("Music Source Information"); - println!("========================"); - println!("Name: {}", source.name()); - println!("ID: {}", source.id()); - println!("Image MIME type: {}", source.default_image_mime_type()); - - // Get the embedded image - let image_data = source.default_image(); - println!("Embedded image size: {} bytes", image_data.len()); - - // Verify WebP format - if image_data.len() >= 12 { - let is_webp = &image_data[0..4] == b"RIFF" && &image_data[8..12] == b"WEBP"; - println!("Valid WebP format: {}", is_webp); - } - - // Optional: save to file - if std::env::args().any(|arg| arg == "--save") { - let filename = format!("{}_default.webp", source.id()); - let mut file = fs::File::create(&filename)?; - file.write_all(image_data)?; - println!("\nImage saved to: {}", filename); - println!("You can view it with: open {}", filename); - } else { - println!("\nTo save the image to disk, run with: --save"); - } - - Ok(()) -} -========= End of pmoqobuz/examples/show_source_image.rs =========== - -=============== pmoqobuz/examples/config_usage.rs ============ -//! Exemple d'utilisation du trait QobuzConfigExt -//! -//! Cet exemple montre comment utiliser le trait d'extension pour gérer -//! les credentials Qobuz via pmoconfig. -//! -//! Usage: -//! ```bash -//! cargo run --example config_usage -//! ``` - -use pmoconfig::get_config; -use pmoqobuz::QobuzConfigExt; - -fn main() -> anyhow::Result<()> { - // Initialiser le logging - tracing_subscriber::fmt::init(); - - println!("=== QobuzConfigExt Example ===\n"); - - // Récupérer la configuration globale - let config = get_config(); - - // Exemple 1: Lire les credentials existants - println!("--- Lecture des credentials ---"); - match config.get_qobuz_credentials() { - Ok((username, password)) => { - println!("Username: {}", username); - println!("Password: {}", "*".repeat(password.len())); - } - Err(e) => { - println!("Credentials non configurés: {}", e); - } - } - - // Exemple 2: Lire username et password séparément - println!("\n--- Lecture séparée ---"); - match config.get_qobuz_username() { - Ok(username) => println!("Username: {}", username), - Err(e) => println!("Username non configuré: {}", e), - } - - match config.get_qobuz_password() { - Ok(password) => println!("Password: {}", "*".repeat(password.len())), - Err(e) => println!("Password non configuré: {}", e), - } - - // Exemple 3: Définir de nouveaux credentials (commenté pour ne pas modifier la config) - /* - println!("\n--- Définition de nouveaux credentials ---"); - config.set_qobuz_username("user@example.com")?; - config.set_qobuz_password("my_secure_password")?; - println!("Nouveaux credentials enregistrés !"); - */ - - // Exemple 4: Utilisation avec QobuzClient - println!("\n--- Utilisation avec QobuzClient ---"); - println!("Pour créer un client Qobuz à partir de la config:"); - println!(" let client = QobuzClient::from_config().await?;"); - println!("\nCette méthode utilise automatiquement QobuzConfigExt"); - println!("pour récupérer les credentials depuis pmoconfig."); - - Ok(()) -} -========= End of pmoqobuz/examples/config_usage.rs =========== - -=============== pmoqobuz/DISK_CACHE_USAGE.md ============ -# Utilisation du cache disque pour favoris/bibliothèque - -## Intégration dans QobuzClient - -### Étape 1 : Ajouter le cache disque au client - -```rust -// Dans src/client.rs - -use crate::disk_cache::DiskCache; - -pub struct QobuzClient { - api: QobuzApi, - cache: Arc, // Cache mémoire (existant) - disk_cache: Arc, // Cache disque (nouveau) - auth_info: Option, -} - -impl QobuzClient { - pub async fn from_config_obj(config: &Config) -> Result { - // ... code existant ... - - // Créer le cache disque (utilise le répertoire configuré) - let disk_cache_dir = config.get_qobuz_cache_dir()?; - let disk_cache = Arc::new(DiskCache::new(disk_cache_dir)?); - - Ok(Self { - api, - cache: Arc::new(QobuzCache::new()), - disk_cache, - auth_info: Some(auth_info), - }) - } -} -``` - -### Étape 2 : Utiliser le cache pour get_favorite_albums - -```rust -// Dans src/client.rs - -impl QobuzClient { - /// Récupère les albums favoris (avec cache disque) - pub async fn get_favorite_albums(&self) -> Result> { - let user_id = self.auth_info - .as_ref() - .map(|a| &a.user_id) - .ok_or_else(|| QobuzError::Unauthorized("Not authenticated".to_string()))?; - - let cache_key = format!("favorites_albums_{}", user_id); - - // 1. Essayer de charger depuis le cache disque (TTL: 1 heure) - if let Ok(Some(albums)) = self.disk_cache.load_with_ttl::>( - &cache_key, - Duration::from_secs(3600) - ) { - info!("✓ Loaded {} favorite albums from disk cache", albums.len()); - return Ok(albums); - } - - // 2. Sinon, requête API - info!("Fetching favorite albums from API..."); - let albums = self.api.get_favorite_albums().await?; - - // 3. Sauvegarder dans le cache disque - if let Err(e) = self.disk_cache.save(&cache_key, &albums) { - debug!("Failed to save favorites to disk cache: {}", e); - } else { - info!("✓ Saved {} favorite albums to disk cache", albums.len()); - } - - Ok(albums) - } - - /// Récupère les tracks favoris (avec cache disque) - pub async fn get_favorite_tracks(&self) -> Result> { - let user_id = self.auth_info - .as_ref() - .map(|a| &a.user_id) - .ok_or_else(|| QobuzError::Unauthorized("Not authenticated".to_string()))?; - - let cache_key = format!("favorites_tracks_{}", user_id); - - // 1. Cache disque (TTL: 1 heure) - if let Ok(Some(tracks)) = self.disk_cache.load_with_ttl::>( - &cache_key, - Duration::from_secs(3600) - ) { - info!("✓ Loaded {} favorite tracks from disk cache", tracks.len()); - return Ok(tracks); - } - - // 2. API - info!("Fetching favorite tracks from API..."); - let tracks = self.api.get_favorite_tracks().await?; - - // 3. Sauvegarder - if let Err(e) = self.disk_cache.save(&cache_key, &tracks) { - debug!("Failed to save favorites to disk cache: {}", e); - } else { - info!("✓ Saved {} favorite tracks to disk cache", tracks.len()); - } - - Ok(tracks) - } - - /// Récupère les playlists (avec cache disque) - pub async fn get_user_playlists(&self) -> Result> { - let user_id = self.auth_info - .as_ref() - .map(|a| &a.user_id) - .ok_or_else(|| QobuzError::Unauthorized("Not authenticated".to_string()))?; - - let cache_key = format!("playlists_{}", user_id); - - // 1. Cache disque (TTL: 30 minutes - les playlists changent plus souvent) - if let Ok(Some(playlists)) = self.disk_cache.load_with_ttl::>( - &cache_key, - Duration::from_secs(1800) - ) { - info!("✓ Loaded {} playlists from disk cache", playlists.len()); - return Ok(playlists); - } - - // 2. API - info!("Fetching playlists from API..."); - let playlists = self.api.get_user_playlists().await?; - - // 3. Sauvegarder - if let Err(e) = self.disk_cache.save(&cache_key, &playlists) { - debug!("Failed to save playlists to disk cache: {}", e); - } else { - info!("✓ Saved {} playlists to disk cache", playlists.len()); - } - - Ok(playlists) - } - - /// Invalide le cache des favoris (après ajout/suppression) - pub async fn invalidate_favorites_cache(&self) -> Result<()> { - let user_id = self.auth_info - .as_ref() - .map(|a| &a.user_id) - .ok_or_else(|| QobuzError::Unauthorized("Not authenticated".to_string()))?; - - self.disk_cache.invalidate(&format!("favorites_albums_{}", user_id))?; - self.disk_cache.invalidate(&format!("favorites_tracks_{}", user_id))?; - self.disk_cache.invalidate(&format!("playlists_{}", user_id))?; - - info!("✓ Invalidated favorites cache"); - Ok(()) - } -} -``` - -### Étape 3 : Méthodes utilitaires - -```rust -impl QobuzClient { - /// Retourne des statistiques sur le cache disque - pub fn disk_cache_stats(&self) -> Result<(usize, u64)> { - let count = self.disk_cache.count()?; - let size = self.disk_cache.size()?; - Ok((count, size)) - } - - /// Vide complètement le cache disque - pub fn clear_disk_cache(&self) -> Result<()> { - self.disk_cache.clear_all() - } -} -``` - -## Structure sur disque - -``` -.pmomusic/ -├── config.yaml -└── cache/ - └── qobuz/ - ├── favorites_albums_1217710.json # 375 albums (~200 KB) - ├── favorites_tracks_1217710.json # Tracks favoris - └── playlists_1217710.json # Playlists utilisateur -``` - -## Bénéfices - -### Sans cache disque (AVANT) -```bash -# Lancement 1 -INFO Fetching 375 favorite albums from API... (2.5s) - -# Lancement 2 (app redémarrée) -INFO Fetching 375 favorite albums from API... (2.5s) ← Requête inutile ! - -# Lancement 3 -INFO Fetching 375 favorite albums from API... (2.5s) ← Requête inutile ! -``` - -**Total** : 3 requêtes API × 2.5s = **7.5 secondes** - -### Avec cache disque (APRÈS) -```bash -# Lancement 1 (cache miss) -INFO Fetching 375 favorite albums from API... (2.5s) -INFO ✓ Saved 375 favorite albums to disk cache - -# Lancement 2 (cache hit!) -INFO ✓ Loaded 375 favorite albums from disk cache (5ms) ← Instantané ! - -# Lancement 3 (cache hit!) -INFO ✓ Loaded 375 favorite albums from disk cache (5ms) ← Instantané ! -``` - -**Total** : 1 requête API × 2.5s + 2 cache hits × 5ms = **2.51 secondes** - -**Amélioration** : **66% plus rapide** + réduction de **66% des requêtes API** - -## TTL recommandés - -| Donnée | TTL | Justification | -|--------|-----|---------------| -| Albums favoris | 1h | Changent rarement | -| Tracks favoris | 1h | Changent rarement | -| Playlists | 30min | Modifiées plus souvent | -| Bibliothèque complète | 24h | Très volumineuse, change peu | - -## Invalidation intelligente - -Invalider le cache après modifications : - -```rust -// Après ajout d'un favori -client.add_favorite_album("123").await?; -client.invalidate_favorites_cache().await?; - -// Après suppression -client.remove_favorite_album("123").await?; -client.invalidate_favorites_cache().await?; -``` - -## Tests - -```bash -# Test du cache disque -cargo test -p pmoqobuz disk_cache - -# Test d'intégration -cargo run --example basic_usage - -# Logs détaillés -RUST_LOG=info,pmoqobuz::disk_cache=debug cargo run --example basic_usage -``` - -## Migration - -Pour ajouter le cache disque au client existant : - -1. Ajouter le champ `disk_cache` à `QobuzClient` -2. Initialiser dans `from_config_obj()` -3. Modifier `get_favorite_albums()`, `get_favorite_tracks()`, etc. -4. Tester avec des gros catalogues (375+ albums) - -## Taille estimée du cache - -Pour un utilisateur avec : -- 375 albums favoris -- 100 tracks favoris -- 10 playlists - -**Taille totale** : ~300 KB (négligeable) - -## Comparaison : pmocache vs DiskCache - -| Critère | pmocache | DiskCache | -|---------|----------|-----------| -| **Complexité** | Élevée (SQLite, download, variants) | Faible (fichiers JSON simples) | -| **Taille overhead** | ~100 KB (SQLite + tables) | 0 (juste les JSON) | -| **Performance** | Excellent pour binaires | Excellent pour JSON | -| **Maintenance** | Complexe | Simple | -| **Adapté pour JSON** | ❌ Non | ✅ Oui | - -**Conclusion** : `DiskCache` est **parfaitement adapté** pour le cache de favoris/bibliothèque. -========= End of pmoqobuz/DISK_CACHE_USAGE.md =========== - -=============== pmoqobuz/src/cache.rs ============ -//! Système de cache en mémoire pour les données Qobuz -//! -//! Ce module fournit un cache en mémoire avec TTL pour minimiser les requêtes à l'API Qobuz. - -use crate::models::{Album, Artist, Playlist, SearchResult, StreamInfo, Track}; -use moka::future::Cache as MokaCache; -use std::sync::Arc; -use std::time::Duration; - -/// Cache principal pour les données Qobuz -#[derive(Clone)] -pub struct QobuzCache { - /// Cache des albums (TTL: 1 heure) - albums: Arc>, - /// Cache des tracks (TTL: 1 heure) - tracks: Arc>, - /// Cache des artistes (TTL: 1 heure) - artists: Arc>, - /// Cache des playlists (TTL: 30 minutes) - playlists: Arc>, - /// Cache des résultats de recherche (TTL: 15 minutes) - searches: Arc>, - /// Cache des URLs de streaming (TTL: 5 minutes) - stream_urls: Arc>, -} - -impl QobuzCache { - /// Crée un nouveau cache avec les paramètres par défaut - pub fn new() -> Self { - Self::with_capacity(1000) - } - - /// Crée un nouveau cache avec une capacité spécifique - pub fn with_capacity(max_capacity: u64) -> Self { - Self { - albums: Arc::new( - MokaCache::builder() - .max_capacity(max_capacity) - .time_to_live(Duration::from_secs(3600)) // 1 heure - .build(), - ), - tracks: Arc::new( - MokaCache::builder() - .max_capacity(max_capacity * 2) - .time_to_live(Duration::from_secs(3600)) // 1 heure - .build(), - ), - artists: Arc::new( - MokaCache::builder() - .max_capacity(max_capacity / 2) - .time_to_live(Duration::from_secs(3600)) // 1 heure - .build(), - ), - playlists: Arc::new( - MokaCache::builder() - .max_capacity(max_capacity / 4) - .time_to_live(Duration::from_secs(1800)) // 30 minutes - .build(), - ), - searches: Arc::new( - MokaCache::builder() - .max_capacity(max_capacity / 2) - .time_to_live(Duration::from_secs(900)) // 15 minutes - .build(), - ), - stream_urls: Arc::new( - MokaCache::builder() - .max_capacity(max_capacity / 4) - .time_to_live(Duration::from_secs(300)) // 5 minutes - .build(), - ), - } - } - - // ============ Albums ============ - - /// Récupère un album depuis le cache - pub async fn get_album(&self, id: &str) -> Option { - self.albums.get(id).await - } - - /// Ajoute un album au cache - pub async fn put_album(&self, id: String, album: Album) { - self.albums.insert(id, album).await; - } - - /// Invalide un album du cache - pub async fn invalidate_album(&self, id: &str) { - self.albums.invalidate(id).await; - } - - // ============ Tracks ============ - - /// Récupère une track depuis le cache - pub async fn get_track(&self, id: &str) -> Option { - self.tracks.get(id).await - } - - /// Ajoute une track au cache - pub async fn put_track(&self, id: String, track: Track) { - self.tracks.insert(id, track).await; - } - - /// Invalide une track du cache - pub async fn invalidate_track(&self, id: &str) { - self.tracks.invalidate(id).await; - } - - // ============ Artists ============ - - /// Récupère un artiste depuis le cache - pub async fn get_artist(&self, id: &str) -> Option { - self.artists.get(id).await - } - - /// Ajoute un artiste au cache - pub async fn put_artist(&self, id: String, artist: Artist) { - self.artists.insert(id, artist).await; - } - - /// Invalide un artiste du cache - pub async fn invalidate_artist(&self, id: &str) { - self.artists.invalidate(id).await; - } - - // ============ Playlists ============ - - /// Récupère une playlist depuis le cache - pub async fn get_playlist(&self, id: &str) -> Option { - self.playlists.get(id).await - } - - /// Ajoute une playlist au cache - pub async fn put_playlist(&self, id: String, playlist: Playlist) { - self.playlists.insert(id, playlist).await; - } - - /// Invalide une playlist du cache - pub async fn invalidate_playlist(&self, id: &str) { - self.playlists.invalidate(id).await; - } - - // ============ Recherches ============ - - /// Récupère un résultat de recherche depuis le cache - pub async fn get_search(&self, query: &str) -> Option { - self.searches.get(query).await - } - - /// Ajoute un résultat de recherche au cache - pub async fn put_search(&self, query: String, result: SearchResult) { - self.searches.insert(query, result).await; - } - - /// Invalide un résultat de recherche du cache - pub async fn invalidate_search(&self, query: &str) { - self.searches.invalidate(query).await; - } - - // ============ URLs de streaming ============ - - /// Récupère une URL de streaming depuis le cache - pub async fn get_stream_url(&self, track_id: &str) -> Option { - self.stream_urls.get(track_id).await - } - - /// Ajoute une URL de streaming au cache - pub async fn put_stream_url(&self, track_id: String, info: StreamInfo) { - self.stream_urls.insert(track_id, info).await; - } - - /// Invalide une URL de streaming du cache - pub async fn invalidate_stream_url(&self, track_id: &str) { - self.stream_urls.invalidate(track_id).await; - } - - // ============ Maintenance ============ - - /// Vide tous les caches - pub async fn clear_all(&self) { - self.albums.invalidate_all(); - self.tracks.invalidate_all(); - self.artists.invalidate_all(); - self.playlists.invalidate_all(); - self.searches.invalidate_all(); - self.stream_urls.invalidate_all(); - } - - /// Retourne des statistiques sur le cache - pub async fn stats(&self) -> CacheStats { - CacheStats { - albums_count: self.albums.entry_count(), - tracks_count: self.tracks.entry_count(), - artists_count: self.artists.entry_count(), - playlists_count: self.playlists.entry_count(), - searches_count: self.searches.entry_count(), - stream_urls_count: self.stream_urls.entry_count(), - } - } -} - -impl Default for QobuzCache { - fn default() -> Self { - Self::new() - } -} - -/// Statistiques du cache -#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] -pub struct CacheStats { - /// Nombre d'albums en cache - pub albums_count: u64, - /// Nombre de tracks en cache - pub tracks_count: u64, - /// Nombre d'artistes en cache - pub artists_count: u64, - /// Nombre de playlists en cache - pub playlists_count: u64, - /// Nombre de recherches en cache - pub searches_count: u64, - /// Nombre d'URLs de streaming en cache - pub stream_urls_count: u64, -} - -impl CacheStats { - /// Retourne le nombre total d'entrées en cache - pub fn total_count(&self) -> u64 { - self.albums_count - + self.tracks_count - + self.artists_count - + self.playlists_count - + self.searches_count - + self.stream_urls_count - } -} - -#[cfg(test)] -mod tests { - use super::*; - use crate::models::Artist; - - #[tokio::test] - async fn test_cache_basic_operations() { - let cache = QobuzCache::new(); - - let artist = Artist::new("123", "Test Artist"); - - // Test insertion - cache.put_artist("123".to_string(), artist.clone()).await; - - // Test récupération - let retrieved = cache.get_artist("123").await; - assert!(retrieved.is_some()); - assert_eq!(retrieved.unwrap().name, "Test Artist"); - - // Test invalidation - cache.invalidate_artist("123").await; - let after_invalidation = cache.get_artist("123").await; - assert!(after_invalidation.is_none()); - } - - #[tokio::test] - async fn test_cache_stats() { - let cache = QobuzCache::new(); - - let artist = Artist::new("123", "Test Artist"); - cache.put_artist("123".to_string(), artist).await; - - let stats = cache.stats().await; - assert_eq!(stats.artists_count, 1); - assert_eq!(stats.albums_count, 0); - } - - #[tokio::test] - async fn test_cache_clear_all() { - let cache = QobuzCache::new(); - - let artist = Artist::new("123", "Test Artist"); - cache.put_artist("123".to_string(), artist).await; - - cache.clear_all().await; - - let stats = cache.stats().await; - assert_eq!(stats.total_count(), 0); - } -} -========= End of pmoqobuz/src/cache.rs =========== - -=============== pmoqobuz/src/client.rs ============ -//! Client principal pour interagir avec l'API Qobuz -//! -//! Ce module fournit un client haut-niveau avec authentification et cache intégré. - -use crate::api::auth::AuthInfo; -use crate::api::{QobuzApi, DEFAULT_APP_ID}; -use crate::cache::QobuzCache; -use crate::config_ext::QobuzConfigExt; -use crate::error::{QobuzError, Result}; -use crate::models::*; -use pmoconfig::Config; -use std::sync::Arc; -use tracing::{debug, info}; - -/// Client Qobuz haut-niveau avec cache -pub struct QobuzClient { - /// API bas-niveau - api: QobuzApi, - /// Cache en mémoire - cache: Arc, - /// Informations d'authentification - auth_info: Option, - #[cfg(feature = "disk-cache")] - /// Cache disque optionnel - disk_cache: Option>, -} - -impl QobuzClient { - /// Crée un nouveau client et authentifie avec les credentials fournis - /// - /// # Arguments - /// - /// * `username` - Email ou nom d'utilisateur Qobuz - /// * `password` - Mot de passe - /// - /// # Exemple - /// - /// ```rust,no_run - /// use pmoqobuz::QobuzClient; - /// - /// #[tokio::main] - /// async fn main() -> anyhow::Result<()> { - /// let client = QobuzClient::new("user@example.com", "password").await?; - /// Ok(()) - /// } - /// ``` - pub async fn new(username: &str, password: &str) -> Result { - Self::with_app_id(DEFAULT_APP_ID, username, password).await - } - - /// Crée un nouveau client avec un App ID personnalisé - pub async fn with_app_id(app_id: &str, username: &str, password: &str) -> Result { - info!("Creating Qobuz client with app ID: {}", app_id); - - let mut api = QobuzApi::new(app_id)?; - let auth_info = api.login(username, password).await?; - - let client = Self { - api, - cache: Arc::new(QobuzCache::new()), - auth_info: Some(auth_info), - #[cfg(feature = "disk-cache")] - disk_cache: None, - }; - - Ok(client.finalize_disk_cache().await) - } - - /// Crée un client en utilisant la configuration de pmoconfig - /// - /// # Exemple - /// - /// ```rust,no_run - /// use pmoqobuz::QobuzClient; - /// - /// #[tokio::main] - /// async fn main() -> anyhow::Result<()> { - /// let client = QobuzClient::from_config().await?; - /// Ok(()) - /// } - /// ``` - pub async fn from_config() -> Result { - let config = pmoconfig::get_config(); - Self::from_config_obj(config.as_ref()).await - } - - /// Configure le rate limiting sur une API depuis la configuration - /// - /// # Arguments - /// - /// * `api` - L'API Qobuz à configurer - /// * `config` - La configuration contenant les paramètres de rate limiting - fn configure_rate_limiting(api: &mut QobuzApi, config: &Config) { - let rate_limit_enabled = config.is_qobuz_rate_limiting_enabled(); - if rate_limit_enabled { - let max_concurrent = config.get_qobuz_rate_limit_max_concurrent() - .ok() - .flatten() - .unwrap_or(2); - let min_delay = config.get_qobuz_rate_limit_min_delay_ms() - .ok() - .flatten() - .unwrap_or(400); - - info!( - "Enabling Qobuz rate limiting: {} concurrent, {}ms delay", - max_concurrent, min_delay - ); - api.enable_rate_limiting(max_concurrent, min_delay); - } else { - debug!("Qobuz rate limiting disabled in configuration"); - } - } - - /// Crée un client depuis un objet Config spécifique - /// - /// Cette méthode récupère les credentials, l'App ID et optionnellement - /// le secret depuis la configuration. - /// - /// Ordre de priorité pour l'initialisation : - /// 0. **Vérifier le cache du token d'authentification** (évite un login si token valide) - /// 1. Si `appid` ET `secret` configurés → teste d'abord avec ces credentials - /// 2. Si échec d'authentification → utilise le Spoofer pour obtenir de nouveaux credentials - /// 3. Si aucun `appid`/`secret` configuré → utilise directement le Spoofer - /// 4. Fallback ultime → utilise DEFAULT_APP_ID sans secret (requêtes signées échoueront) - pub async fn from_config_obj(config: &Config) -> Result { - let (username, password) = config.get_qobuz_credentials()?; - - // Étape 0 : Essayer de réutiliser le token stocké dans la configuration - // DÉSACTIVÉ TEMPORAIREMENT : Le secret peut être obsolète même si le token est valide. - // Le login est nécessaire pour valider les credentials (app_id) et déclencher le - // Spoofer si besoin. Si le login échoue avec une erreur d'auth, le Spoofer sera - // automatiquement utilisé pour obtenir de nouveaux credentials. - // - // TODO: Implémenter un retry intelligent dans get_stream_url() qui détecte les - // erreurs de signature et rafraîchit automatiquement les credentials via Spoofer. - // Cela permettrait de réactiver la réutilisation du token sans risque. - /* - if let (Ok(Some(token)), Ok(Some(user_id))) = - (config.get_qobuz_auth_token(), config.get_qobuz_user_id()) - { - info!("✓ Found stored authentication token in configuration"); - - // Récupérer l'App ID et le secret depuis la config pour créer l'API - let config_appid = config.get_qobuz_appid()?; - let config_secret = config.get_qobuz_secret()?; - - match (config_appid, config_secret) { - (Some(app_id), Some(secret)) => match QobuzApi::with_secret(&app_id, &secret) { - Ok(mut api) => { - // Configure rate limiting - Self::configure_rate_limiting(&mut api, config); - - // Réutiliser le token de la configuration - api.set_auth_token(token.clone(), user_id.clone()); - - info!("✓ Reusing authentication token (no login required)"); - info!(" → Token will be validated on first API request"); - - let auth_info = AuthInfo { - token, - user_id, - subscription_label: config.get_qobuz_subscription_label().ok().flatten(), - }; - - let client = Self { - api, - cache: Arc::new(QobuzCache::new()), - auth_info: Some(auth_info), - #[cfg(feature = "disk-cache")] - disk_cache: None, - }; - - return Ok(client.finalize_disk_cache().await); - } - Err(e) => { - debug!("Failed to create API with stored credentials: {}", e); - info!("→ Credentials in config are invalid, will perform login"); - // Continuer vers le login normal - } - }, - _ => { - debug!("No appid/secret in config, cannot reuse token"); - info!("→ Missing AppID/secret, will perform login"); - // Continuer vers le login normal - } - } - } else { - debug!("No stored authentication token found in configuration, will perform login"); - } - */ - - info!("Performing login to validate credentials and obtain fresh token"); - - // Récupérer l'App ID et le secret depuis la config - let config_appid = config.get_qobuz_appid()?; - let config_secret = config.get_qobuz_secret()?; - - // Déterminer comment créer l'API - let mut api = match (config_appid, config_secret) { - // Cas 1: AppID ET secret configurés → test avec authentification - (Some(app_id), Some(secret)) => { - info!( - "Creating Qobuz API with configured App ID: {} and secret", - app_id - ); - - match QobuzApi::with_secret(&app_id, &secret) { - Ok(mut test_api) => { - // Configure rate limiting - Self::configure_rate_limiting(&mut test_api, config); - - // Tenter l'authentification pour valider les credentials - debug!("Testing configured credentials with login..."); - match test_api.login(&username, &password).await { - Ok(auth_info) => { - info!("✓ Configured credentials are valid"); - - // Sauvegarder le token dans la configuration - use std::time::{SystemTime, UNIX_EPOCH, Duration}; - let expires_at = SystemTime::now() - .duration_since(UNIX_EPOCH) - .unwrap() - .as_secs() - + Duration::from_secs(24 * 3600).as_secs(); // 24h - - if let Err(e) = config.set_qobuz_auth_info( - &auth_info.token, - &auth_info.user_id, - auth_info.subscription_label.as_deref(), - expires_at, - ) { - debug!("Failed to save authentication to config: {}", e); - } else { - info!("✓ Saved authentication token to configuration"); - } - - // Les credentials sont valides, retourner directement - let client = Self { - api: test_api, - cache: Arc::new(QobuzCache::new()), - auth_info: Some(auth_info), - #[cfg(feature = "disk-cache")] - disk_cache: None, - }; - - return Ok(client.finalize_disk_cache().await); - } - Err(e) if e.is_auth_error() => { - info!("✗ Configured credentials failed authentication: {}", e); - info!("→ Falling back to Spoofer to obtain new credentials..."); - // Continuer vers le Spoofer (voir après le match) - } - Err(e) => { - // Autre erreur (réseau, etc.) → propager - return Err(e); - } - } - } - Err(e) => { - info!("✗ Failed to create API with configured credentials: {}", e); - info!("→ Falling back to Spoofer..."); - // Continuer vers le Spoofer - } - } - - // Si on arrive ici, les credentials configurés ont échoué - // → Appel du Spoofer - Self::try_spoofer_fallback(config).await? - } - - // Cas 2: Aucun ou seulement l'un des deux → utiliser directement le Spoofer - _ => { - info!("AppID or secret not configured, using Spoofer to obtain valid credentials..."); - Self::try_spoofer_fallback(config).await? - } - }; - - // Configure rate limiting - Self::configure_rate_limiting(&mut api, config); - - // Authentifier l'utilisateur - let auth_info = api.login(&username, &password).await?; - - // Sauvegarder le token dans la configuration pour éviter de re-login la prochaine fois - use std::time::{Duration, SystemTime, UNIX_EPOCH}; - let expires_at = SystemTime::now() - .duration_since(UNIX_EPOCH) - .unwrap() - .as_secs() - + Duration::from_secs(24 * 3600).as_secs(); // 24h - - if let Err(e) = config.set_qobuz_auth_info( - &auth_info.token, - &auth_info.user_id, - auth_info.subscription_label.as_deref(), - expires_at, - ) { - debug!("Failed to save authentication to config: {}", e); - } else { - info!("✓ Saved authentication token to configuration"); - } - - let client = Self { - api, - cache: Arc::new(QobuzCache::new()), - auth_info: Some(auth_info), - #[cfg(feature = "disk-cache")] - disk_cache: None, - }; - - Ok(client.finalize_disk_cache().await) - } - - /// Tente d'utiliser le Spoofer pour obtenir des credentials valides - /// - /// Cette méthode est appelée soit : - /// - Quand aucun appid/secret n'est configuré - /// - Quand les credentials configurés sont invalides/expirés - async fn try_spoofer_fallback(config: &Config) -> Result { - match crate::api::Spoofer::new().await { - Ok(spoofer) => { - match spoofer.get_app_id() { - Ok(app_id) => { - info!("Spoofer found App ID: {}", app_id); - - match spoofer.get_secrets() { - Ok(secrets) => { - info!("Spoofer found {} secret(s), testing them...", secrets.len()); - - // Tester chaque secret pour trouver celui qui fonctionne - for (timezone, secret) in secrets.iter() { - debug!("Testing secret for timezone: {}", timezone); - - match QobuzApi::with_secret(&app_id, secret) { - Ok(test_api) => { - info!("✓ Successfully created API with secret from timezone: {}", timezone); - - // Sauvegarder les credentials valides dans la config - if let Err(e) = config.set_qobuz_appid(&app_id) { - debug!("Could not save appid to config: {}", e); - } - if let Err(e) = config.set_qobuz_secret(secret) { - debug!("Could not save secret to config: {}", e); - } - - return Ok(test_api); - } - Err(e) => { - debug!("Failed to create API with secret from {}: {}", timezone, e); - continue; - } - } - } - - // Si aucun secret n'a fonctionné, utiliser le fallback - info!("✗ No valid secret found from Spoofer, falling back to DEFAULT_APP_ID without secret"); - QobuzApi::new(DEFAULT_APP_ID) - } - Err(e) => { - info!("Spoofer failed to extract secrets: {}, falling back to DEFAULT_APP_ID", e); - QobuzApi::new(DEFAULT_APP_ID) - } - } - } - Err(e) => { - info!("Spoofer failed to extract app_id: {}, falling back to DEFAULT_APP_ID", e); - QobuzApi::new(DEFAULT_APP_ID) - } - } - } - Err(e) => { - info!("Spoofer failed: {}, falling back to DEFAULT_APP_ID without secret", e); - QobuzApi::new(DEFAULT_APP_ID) - } - } - } - - /// Définit le format audio par défaut - pub fn set_format(&mut self, format: AudioFormat) { - self.api.set_format(format); - } - - /// Retourne le format audio configuré - pub fn format(&self) -> AudioFormat { - self.api.format() - } - - /// Retourne les informations d'authentification - pub fn auth_info(&self) -> Option<&AuthInfo> { - self.auth_info.as_ref() - } - - #[cfg(feature = "disk-cache")] - fn user_id(&self) -> Option { - self.auth_info.as_ref().map(|info| info.user_id.clone()) - } - - /// Retourne une référence au cache - pub fn cache(&self) -> Arc { - self.cache.clone() - } - - #[cfg(feature = "disk-cache")] - pub async fn purge_disk_cache(&self) -> Result { - if let Some(disk) = &self.disk_cache { - disk.purge_expired() - .await - .map_err(|err| QobuzError::Cache(err.to_string())) - } else { - Ok(0) - } - } - - #[cfg(feature = "disk-cache")] - pub fn with_disk_cache( - mut self, - store: Arc, - ) -> Self { - self.disk_cache = Some(store); - self - } - - #[cfg(feature = "disk-cache")] - fn attach_default_disk_cache(mut self) -> Self { - if let Some(store) = Self::default_disk_cache_store() { - self = self.with_disk_cache(store); - } - self - } - - #[cfg(not(feature = "disk-cache"))] - fn attach_default_disk_cache(self) -> Self { - self - } - - #[cfg(feature = "disk-cache")] - async fn finalize_disk_cache(self) -> Self { - let client = self.attach_default_disk_cache(); - if let Err(err) = client.purge_disk_cache().await { - debug!("Failed to purge disk cache on startup: {}", err); - } - client - } - - #[cfg(not(feature = "disk-cache"))] - async fn finalize_disk_cache(self) -> Self { - self.attach_default_disk_cache() - } - - #[cfg(feature = "disk-cache")] - fn default_disk_cache_store() -> Option> { - let mut path = match std::env::var_os("HOME") { - Some(home) => std::path::PathBuf::from(home), - None => std::path::PathBuf::from("."), - }; - path.push(".pmomusic"); - path.push("cache"); - path.push("qobuz_cache.sqlite"); - - if let Some(parent) = path.parent() { - if let Err(err) = std::fs::create_dir_all(parent) { - debug!( - "Failed to create disk cache directory {}: {}", - parent.display(), - err - ); - return None; - } - } - - match crate::disk_cache::SqliteCacheStore::new(path) { - Ok(store) => { - let store: Arc = Arc::new(store); - Some(store) - } - Err(err) => { - debug!("Failed to initialize SQLite disk cache: {}", err); - None - } - } - } - - // ============ Albums ============ - - /// Récupère un album par son ID - pub async fn get_album(&self, album_id: &str) -> Result { - // Vérifier le cache d'abord - if let Some(album) = self.cache.get_album(album_id).await { - debug!("Album {} found in cache", album_id); - return Ok(album); - } - - // Sinon, récupérer depuis l'API - let album = self.api.get_album(album_id).await?; - - // Mettre en cache - self.cache - .put_album(album_id.to_string(), album.clone()) - .await; - - Ok(album) - } - - /// Récupère les tracks d'un album - pub async fn get_album_tracks(&self, album_id: &str) -> Result> { - let tracks = self.api.get_album_tracks(album_id).await?; - - // Mettre les tracks en cache - for track in &tracks { - self.cache.put_track(track.id.clone(), track.clone()).await; - } - - Ok(tracks) - } - - // ============ Tracks ============ - - /// Récupère une track par son ID - pub async fn get_track(&self, track_id: &str) -> Result { - if let Some(track) = self.cache.get_track(track_id).await { - debug!("Track {} found in cache", track_id); - return Ok(track); - } - - let track = self.api.get_track(track_id).await?; - self.cache - .put_track(track_id.to_string(), track.clone()) - .await; - - Ok(track) - } - - /// Récupère l'URL de streaming d'une track - pub async fn get_stream_url(&self, track_id: &str) -> Result { - // Vérifier le cache d'abord - if let Some(info) = self.cache.get_stream_url(track_id).await { - if info.expires_at > chrono::Utc::now() { - debug!("Stream URL for track {} found in cache", track_id); - return Ok(info.url); - } - } - - // Sinon, récupérer depuis l'API - let info = self.api.get_file_url(track_id).await?; - let url = info.url.clone(); - - // Mettre en cache - self.cache.put_stream_url(track_id.to_string(), info).await; - - Ok(url) - } - - // ============ Artists ============ - - /// Récupère un artiste par son ID - pub async fn get_artist(&self, artist_id: &str) -> Result { - if let Some(artist) = self.cache.get_artist(artist_id).await { - debug!("Artist {} found in cache", artist_id); - return Ok(artist); - } - - // Pour récupérer un artiste, on doit passer par get_artist_albums - let albums = self.api.get_artist_albums(artist_id).await?; - - if let Some(first_album) = albums.first() { - let artist = first_album.artist.clone(); - self.cache - .put_artist(artist_id.to_string(), artist.clone()) - .await; - Ok(artist) - } else { - Err(QobuzError::NotFound(format!( - "Artist {} not found", - artist_id - ))) - } - } - - /// Récupère les albums d'un artiste - pub async fn get_artist_albums(&self, artist_id: &str) -> Result> { - self.api.get_artist_albums(artist_id).await - } - - /// Récupère les artistes similaires - pub async fn get_similar_artists(&self, artist_id: &str) -> Result> { - self.api.get_similar_artists(artist_id).await - } - - // ============ Playlists ============ - - /// Récupère une playlist par son ID - pub async fn get_playlist(&self, playlist_id: &str) -> Result { - if let Some(playlist) = self.cache.get_playlist(playlist_id).await { - debug!("Playlist {} found in cache", playlist_id); - return Ok(playlist); - } - - let playlist = self.api.get_playlist(playlist_id).await?; - self.cache - .put_playlist(playlist_id.to_string(), playlist.clone()) - .await; - - Ok(playlist) - } - - /// Récupère les tracks d'une playlist - pub async fn get_playlist_tracks(&self, playlist_id: &str) -> Result> { - self.api.get_playlist_tracks(playlist_id).await - } - - // ============ Catalogue ============ - - /// Récupère la liste des genres - pub async fn get_genres(&self) -> Result> { - self.api.get_genres().await - } - - /// Récupère les albums featured (nouveautés, éditeur, etc.) - pub async fn get_featured_albums( - &self, - genre_id: Option<&str>, - type_: &str, - ) -> Result> { - self.api.get_featured_albums(genre_id, type_).await - } - - /// Récupère les playlists featured - pub async fn get_featured_playlists( - &self, - genre_id: Option<&str>, - tags: Option<&str>, - ) -> Result> { - self.api.get_featured_playlists(genre_id, tags).await - } - - // ============ Recherche ============ - - /// Recherche dans le catalogue Qobuz - /// - /// # Arguments - /// - /// * `query` - Termes de recherche - /// * `type_` - Type de recherche : None (tous), Some("albums"), Some("artists"), Some("tracks"), Some("playlists") - pub async fn search(&self, query: &str, type_: Option<&str>) -> Result { - // Créer une clé de cache - let cache_key = format!("{}:{}", query, type_.unwrap_or("all")); - - // Vérifier le cache - if let Some(result) = self.cache.get_search(&cache_key).await { - debug!("Search results for '{}' found in cache", query); - return Ok(result); - } - - // Sinon, rechercher via l'API - let result = self.api.search(query, type_).await?; - - // Mettre en cache - self.cache.put_search(cache_key, result.clone()).await; - - Ok(result) - } - - /// Recherche des albums - pub async fn search_albums(&self, query: &str) -> Result> { - let result = self.search(query, Some("albums")).await?; - Ok(result.albums) - } - - /// Recherche des artistes - pub async fn search_artists(&self, query: &str) -> Result> { - let result = self.search(query, Some("artists")).await?; - Ok(result.artists) - } - - /// Recherche des tracks - pub async fn search_tracks(&self, query: &str) -> Result> { - let result = self.search(query, Some("tracks")).await?; - Ok(result.tracks) - } - - /// Recherche des playlists - pub async fn search_playlists(&self, query: &str) -> Result> { - let result = self.search(query, Some("playlists")).await?; - Ok(result.playlists) - } - - // ============ Favoris ============ - - /// Récupère les albums favoris de l'utilisateur - pub async fn get_favorite_albums(&self) -> Result> { - #[cfg(feature = "disk-cache")] - let user_id = self - .user_id() - .ok_or_else(|| QobuzError::Unauthorized("Missing authenticated user ID".into()))?; - - #[cfg(feature = "disk-cache")] - let ttl = std::time::Duration::from_secs(6 * 3600); - - #[cfg(feature = "disk-cache")] - if let Some(disk) = &self.disk_cache { - if let Some(entry) = disk - .get_json::>(&user_id, "favorites_albums", "all") - .await? - { - if entry.fresh { - return Ok(entry.value); - } - } - } - - let albums = self.api.get_favorite_albums().await?; - - #[cfg(feature = "disk-cache")] - if let Some(disk) = &self.disk_cache { - let _ = disk - .put_json(&user_id, "favorites_albums", "all", ttl, &albums) - .await; - } - - Ok(albums) - } - - /// Récupère les artistes favoris de l'utilisateur - pub async fn get_favorite_artists(&self) -> Result> { - self.api.get_favorite_artists().await - } - - /// Récupère les tracks favorites de l'utilisateur - pub async fn get_favorite_tracks(&self) -> Result> { - #[cfg(feature = "disk-cache")] - let user_id = self - .user_id() - .ok_or_else(|| QobuzError::Unauthorized("Missing authenticated user ID".into()))?; - - #[cfg(feature = "disk-cache")] - let ttl = std::time::Duration::from_secs(6 * 3600); - - #[cfg(feature = "disk-cache")] - if let Some(disk) = &self.disk_cache { - if let Some(entry) = disk - .get_json::>(&user_id, "favorites_tracks", "all") - .await? - { - if entry.fresh { - return Ok(entry.value); - } - } - } - - let tracks = self.api.get_favorite_tracks().await?; - - #[cfg(feature = "disk-cache")] - if let Some(disk) = &self.disk_cache { - let _ = disk - .put_json(&user_id, "favorites_tracks", "all", ttl, &tracks) - .await; - } - - Ok(tracks) - } - - /// Récupère les playlists de l'utilisateur - pub async fn get_user_playlists(&self) -> Result> { - #[cfg(feature = "disk-cache")] - let user_id = self - .user_id() - .ok_or_else(|| QobuzError::Unauthorized("Missing authenticated user ID".into()))?; - - #[cfg(feature = "disk-cache")] - let ttl = std::time::Duration::from_secs(6 * 3600); - - #[cfg(feature = "disk-cache")] - if let Some(disk) = &self.disk_cache { - if let Some(entry) = disk - .get_json::>(&user_id, "user_playlists", "all") - .await? - { - if entry.fresh { - return Ok(entry.value); - } - } - } - - let playlists = self.api.get_user_playlists().await?; - - #[cfg(feature = "disk-cache")] - if let Some(disk) = &self.disk_cache { - let _ = disk - .put_json(&user_id, "user_playlists", "all", ttl, &playlists) - .await; - } - - Ok(playlists) - } - - /// Ajoute un album aux favoris - pub async fn add_favorite_album(&self, album_id: &str) -> Result<()> { - self.api.add_favorite_album(album_id).await - } - - /// Supprime un album des favoris - pub async fn remove_favorite_album(&self, album_id: &str) -> Result<()> { - self.api.remove_favorite_album(album_id).await - } - - /// Ajoute un track aux favoris - pub async fn add_favorite_track(&self, track_id: &str) -> Result<()> { - self.api.add_favorite_track(track_id).await - } - - /// Supprime un track des favoris - pub async fn remove_favorite_track(&self, track_id: &str) -> Result<()> { - self.api.remove_favorite_track(track_id).await - } - - /// Ajoute un track à une playlist - pub async fn add_to_playlist(&self, playlist_id: &str, track_id: &str) -> Result<()> { - self.api.add_to_playlist(playlist_id, track_id).await - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_audio_format() { - assert_eq!(AudioFormat::default(), AudioFormat::Flac_Lossless); - } -} -========= End of pmoqobuz/src/client.rs =========== - -=============== pmoqobuz/src/error.rs ============ -//! Gestion des erreurs pour le client Qobuz - -use thiserror::Error; - -/// Type Result personnalisé pour pmoqobuz -pub type Result = std::result::Result; - -/// Erreurs possibles lors de l'utilisation du client Qobuz -#[derive(Error, Debug)] -pub enum QobuzError { - /// Erreur d'authentification (credentials invalides) - #[error("Authentication failed: {0}")] - Unauthorized(String), - - /// Ressource non trouvée (album, track, etc.) - #[error("Resource not found: {0}")] - NotFound(String), - - /// Erreur HTTP - #[error("HTTP error: {0}")] - Http(#[from] reqwest::Error), - - /// Erreur de parsing JSON - #[error("JSON parsing error: {0}")] - JsonParse(#[from] serde_json::Error), - - /// Erreur de configuration (anyhow) - #[error("Configuration error: {0}")] - Config(#[from] anyhow::Error), - - /// Erreur de configuration Qobuz (App ID, secret, etc.) - #[error("Qobuz configuration error: {0}")] - Configuration(String), - - /// Erreur de l'API Qobuz - #[error("Qobuz API error (code {code}): {message}")] - ApiError { code: u16, message: String }, - - /// Quota dépassé (rate limiting) - #[error("Rate limit exceeded, please try again later")] - RateLimitExceeded, - - /// Contenu non disponible dans la région de l'utilisateur - #[error("Content not available in your region")] - NotAvailable, - - /// Abonnement insuffisant pour accéder au contenu - #[error("Subscription level insufficient: {0}")] - SubscriptionRequired(String), - - /// Erreur de cache - #[error("Cache error: {0}")] - Cache(String), - - /// Erreur d'export DIDL - #[error("DIDL export error: {0}")] - DidlExport(String), - - /// Erreur générique - #[error("Qobuz error: {0}")] - Other(String), -} - -impl QobuzError { - /// Crée une erreur API depuis un code de statut HTTP et un message - pub fn from_status_code(code: u16, message: impl Into) -> Self { - match code { - 401 | 403 => Self::Unauthorized(message.into()), - 404 => Self::NotFound(message.into()), - 429 => Self::RateLimitExceeded, - _ => Self::ApiError { - code, - message: message.into(), - }, - } - } - - /// Vérifie si l'erreur est une erreur de credentials (401/403) - /// ou d'AppID invalide (400 avec "app_id") - pub fn is_auth_error(&self) -> bool { - match self { - QobuzError::Unauthorized(_) => true, - QobuzError::ApiError { code: 400, message } - if message.contains("app_id") || message.contains("Invalid") => true, - _ => false, - } - } - - /// Vérifie si l'erreur est une erreur de rate limiting - pub fn is_rate_limit(&self) -> bool { - matches!(self, QobuzError::RateLimitExceeded) - } -} -========= End of pmoqobuz/src/error.rs =========== - -=============== pmoqobuz/src/lib.rs ============ -//! # pmoqobuz - Client Qobuz pour PMOMusic -//! -//! Cette crate fournit un client Rust pour l'API Qobuz, inspiré de l'implémentation Python d'upmpdcli, -//! avec un système de cache en mémoire et une intégration avec les autres modules PMOMusic. -//! -//! ## Vue d'ensemble -//! -//! `pmoqobuz` permet d'accéder aux fonctionnalités de Qobuz : -//! - Authentification avec les credentials configurés -//! - Navigation dans le catalogue (albums, artistes, playlists, tracks) -//! - Recherche dans le catalogue -//! - Accès aux favoris de l'utilisateur -//! - Cache en mémoire pour minimiser les requêtes API -//! - Export des objets en format DIDL-Lite (via `pmodidl`) -//! - Cache des images d'albums (via `pmocovers`) -//! -//! ## Architecture -//! -//! La crate suit le pattern d'extension des autres crates PMO : -//! - `QobuzClient` : Client principal avec authentification et cache -//! - `models` : Structures de données (Album, Track, Artist, etc.) -//! - `api` : Couche d'accès à l'API REST Qobuz -//! - `cache` : Système de cache en mémoire avec TTL -//! - `didl` : Export des objets en format DIDL-Lite -//! -//! ## Structure des modules -//! -//! ```text -//! pmoqobuz/ -//! ├── src/ -//! │ ├── lib.rs # Module principal (ce fichier) -//! │ ├── client.rs # Client Qobuz principal -//! │ ├── models.rs # Structures de données -//! │ ├── api/ -//! │ │ ├── mod.rs # API client -//! │ │ ├── auth.rs # Authentification -//! │ │ ├── catalog.rs # Accès au catalogue -//! │ │ └── user.rs # API utilisateur (favoris) -//! │ ├── cache.rs # Cache en mémoire -//! │ ├── didl.rs # Export DIDL-Lite -//! │ └── error.rs # Gestion des erreurs -//! ``` -//! -//! ## Utilisation -//! -//! ### Exemple basique avec configuration automatique -//! -//! ```rust,no_run -//! use pmoqobuz::QobuzClient; -//! -//! #[tokio::main] -//! async fn main() -> anyhow::Result<()> { -//! // Utilise automatiquement la config depuis pmoconfig -//! let client = QobuzClient::from_config().await?; -//! -//! // Rechercher des albums -//! let results = client.search_albums("Miles Davis").await?; -//! for album in results { -//! println!("{} - {}", album.artist.name, album.title); -//! } -//! -//! Ok(()) -//! } -//! ``` -//! -//! ### Exemple avec credentials personnalisés -//! -//! ```rust,no_run -//! use pmoqobuz::QobuzClient; -//! -//! #[tokio::main] -//! async fn main() -> anyhow::Result<()> { -//! let client = QobuzClient::new("user@example.com", "password").await?; -//! -//! // Obtenir les albums favoris -//! let favorites = client.get_favorite_albums().await?; -//! -//! Ok(()) -//! } -//! ``` -//! -//! ### Export DIDL-Lite -//! -//! ```rust,no_run -//! use pmoqobuz::QobuzClient; -//! -//! #[tokio::main] -//! async fn main() -> anyhow::Result<()> { -//! let client = QobuzClient::from_config().await?; -//! -//! let album = client.get_album("12345").await?; -//! let didl_container = album.to_didl_container("parent_id")?; -//! -//! Ok(()) -//! } -//! ``` -//! -//! ## Cache -//! -//! Le client utilise un cache en mémoire avec TTL pour minimiser les requêtes à l'API Qobuz : -//! - Albums : 1 heure -//! - Tracks : 1 heure -//! - Artistes : 1 heure -//! - Playlists : 30 minutes -//! - Résultats de recherche : 15 minutes -//! - URLs de streaming : 5 minutes -//! -//! ## Intégration pmocovers et pmoaudiocache -//! -//! La feature `cache` active le support complet du cache pour les images et l'audio. -//! -//! ### Cache d'images (pmocovers) -//! -//! Les images de couverture sont automatiquement téléchargées et converties en WebP : -//! -//! ```rust,no_run -//! use pmoqobuz::{QobuzSource, QobuzClient}; -//! use pmocovers::Cache as CoverCache; -//! use std::sync::Arc; -//! -//! # async fn example() -> Result<(), Box> { -//! let client = QobuzClient::from_config().await?; -//! let cover_cache = Arc::new(CoverCache::new("./cache/covers", 500)?); -//! -//! let source = QobuzSource::new_with_cache( -//! client, -//! "http://localhost:8080", -//! Some(cover_cache), -//! None, -//! ); -//! # Ok(()) -//! # } -//! ``` -//! -//! ### Cache audio (pmoaudiocache) -//! -//! L'audio haute résolution est téléchargé et caché localement avec métadonnées enrichies : -//! -//! ```rust,no_run -//! use pmoqobuz::{QobuzSource, QobuzClient}; -//! use pmocovers::Cache as CoverCache; -//! use pmoaudiocache::AudioCache; -//! use std::sync::Arc; -//! -//! # async fn example() -> Result<(), Box> { -//! let client = QobuzClient::from_config().await?; -//! let cover_cache = Arc::new(CoverCache::new("./cache/covers", 500)?); -//! let audio_cache = Arc::new(AudioCache::new("./cache/audio", 100)?); -//! -//! let source = QobuzSource::new_with_cache( -//! client.clone(), -//! "http://localhost:8080", -//! Some(cover_cache), -//! Some(audio_cache), -//! ); -//! -//! // Add a track with caching -//! let tracks = client.get_favorite_tracks().await?; -//! if let Some(track) = tracks.first() { -//! let track_id = source.add_track(track).await?; -//! // Audio and cover are now cached with rich metadata -//! -//! // Resolve URI (returns cached version if available) -//! let uri = source.resolve_uri(&track_id).await?; -//! } -//! # Ok(()) -//! # } -//! ``` -//! -//! ### Métadonnées enrichies -//! -//! Qobuz fournit des métadonnées détaillées qui sont préservées dans le cache : -//! - Titre, artiste, album -//! - Numéro de piste et de disque -//! - Année de sortie -//! - Genre(s) -//! - Label -//! - Qualité audio (sample rate, bit depth, channels) -//! - Durée -//! -//! ### Exemple complet -//! -//! Voir `examples/with_cache.rs` pour un exemple complet d'utilisation avec cache. -//! -//! ## Formats audio supportés -//! -//! Qobuz propose plusieurs formats : -//! - Format 5 : MP3 320 kbps -//! - Format 6 : FLAC 16 bit / 44.1 kHz (CD Quality) -//! - Format 7 : FLAC 24 bit / jusqu'à 96 kHz (Hi-Res) -//! - Format 27 : FLAC 24 bit / jusqu'à 192 kHz (Hi-Res+) -//! -//! ## Gestion des erreurs -//! -//! La crate utilise `thiserror` pour définir des erreurs typées : -//! -//! ```rust,ignore -//! use pmoqobuz::{QobuzClient, QobuzError}; -//! -//! match client.get_album("invalid").await { -//! Ok(album) => println!("Album: {}", album.title), -//! Err(QobuzError::NotFound) => println!("Album not found"), -//! Err(QobuzError::Unauthorized) => println!("Authentication failed"), -//! Err(e) => println!("Error: {}", e), -//! } -//! ``` -//! -//! ## Voir aussi -//! -//! - [`pmodidl`] : Format DIDL-Lite -//! - [`pmocovers`] : Cache d'images -//! - [`pmoaudiocache`] : Cache audio -//! - [`pmoconfig`] : Configuration -//! - [`pmoserver`] : Serveur HTTP - -pub mod api; -pub mod cache; -pub mod client; -pub mod config_ext; -pub mod didl; -#[cfg(feature = "disk-cache")] -pub mod disk_cache; -pub mod error; -pub mod models; -pub mod source; - -// Extension pmoserver (feature-gated) -#[cfg(feature = "pmoserver")] -pub mod api_rest; - -#[cfg(feature = "pmoserver")] -pub mod pmoserver_ext; - -#[cfg(feature = "pmoserver")] -mod pmoserver_impl; - -pub use client::QobuzClient; -pub use config_ext::QobuzConfigExt; -pub use error::{QobuzError, Result}; -pub use models::{Album, Artist, AudioFormat, Genre, Playlist, SearchResult, Track}; -pub use source::QobuzSource; - -/// Ré-exporte les types DIDL pour faciliter l'utilisation -pub use didl::ToDIDL; - -/// Ré-exporte le trait d'extension pmoserver -#[cfg(feature = "pmoserver")] -pub use pmoserver_ext::QobuzServerExt; -========= End of pmoqobuz/src/lib.rs =========== - -=============== pmoqobuz/src/disk_cache.rs ============ -#![cfg(feature = "disk-cache")] - -use anyhow::anyhow; -use serde::{de::DeserializeOwned, Serialize}; -use std::{ - path::PathBuf, - time::{Duration, SystemTime, UNIX_EPOCH}, -}; - -use rusqlite::{params, Connection}; -use tokio::task; - -#[derive(Debug, Clone)] -pub struct CacheEntry { - pub value: T, - pub age: Duration, - pub fresh: bool, -} - -#[async_trait::async_trait] -pub trait CacheStore: Send + Sync { - async fn get_json( - &self, - user_id: &str, - namespace: &str, - key: &str, - ) -> anyhow::Result>>; - - async fn put_json( - &self, - user_id: &str, - namespace: &str, - key: &str, - ttl: Duration, - value: &T, - ) -> anyhow::Result<()>; - - async fn invalidate( - &self, - user_id: &str, - namespace: &str, - key: &str, - ) -> anyhow::Result<()>; - - async fn purge_expired(&self) -> anyhow::Result; -} - -pub struct SqliteCacheStore { - db_path: PathBuf, -} - -impl SqliteCacheStore { - pub fn new(db_path: PathBuf) -> anyhow::Result { - let store = Self { db_path }; - store.init_blocking()?; - Ok(store) - } - - fn init_blocking(&self) -> anyhow::Result<()> { - let conn = Connection::open(&self.db_path)?; - conn.execute_batch( - r#" - CREATE TABLE IF NOT EXISTS qobuz_cache ( - user_id TEXT NOT NULL, - namespace TEXT NOT NULL, - key TEXT NOT NULL, - fetched_at INTEGER NOT NULL, - ttl_seconds INTEGER NOT NULL, - json BLOB NOT NULL, - PRIMARY KEY (user_id, namespace, key) - ); - CREATE INDEX IF NOT EXISTS qobuz_cache_expiry - ON qobuz_cache (fetched_at, ttl_seconds); - "#, - )?; - Ok(()) - } - - fn now_seconds() -> i64 { - match SystemTime::now().duration_since(UNIX_EPOCH) { - Ok(duration) => i64::try_from(duration.as_secs()).unwrap_or(i64::MAX), - Err(_) => 0, - } - } -} - -#[async_trait::async_trait] -impl CacheStore for SqliteCacheStore { - async fn get_json( - &self, - user_id: &str, - namespace: &str, - key: &str, - ) -> anyhow::Result>> { - let user_id = user_id.to_owned(); - let namespace = namespace.to_owned(); - let key = key.to_owned(); - let db_path = self.db_path.clone(); - - task::spawn_blocking(move || { - let conn = Connection::open(db_path)?; - let mut stmt = conn.prepare( - "SELECT fetched_at, ttl_seconds, json - FROM qobuz_cache - WHERE user_id = ?1 AND namespace = ?2 AND key = ?3", - )?; - - let result = stmt.query_row( - params![user_id, namespace, key], - |row| { - let fetched_at: i64 = row.get(0)?; - let ttl_seconds: i64 = row.get(1)?; - let data: Vec = row.get(2)?; - let now = Self::now_seconds(); - let fresh = now <= fetched_at + ttl_seconds; - let age_secs = if now >= fetched_at { - (now - fetched_at) as u64 - } else { - 0 - }; - let age = Duration::from_secs(age_secs); - let value = serde_json::from_slice(&data)?; - Ok(CacheEntry { - value, - age, - fresh, - }) - }, - ); - - match result { - Ok(entry) => Ok(Some(entry)), - Err(rusqlite::Error::QueryReturnedNoRows) => Ok(None), - Err(err) => Err(err.into()), - } - }) - .await - .map_err(|err| anyhow!(err))? - } - - async fn put_json( - &self, - user_id: &str, - namespace: &str, - key: &str, - ttl: Duration, - value: &T, - ) -> anyhow::Result<()> { - let user_id = user_id.to_owned(); - let namespace = namespace.to_owned(); - let key = key.to_owned(); - let db_path = self.db_path.clone(); - let ttl_seconds = i64::try_from(ttl.as_secs()).unwrap_or(i64::MAX); - let now = Self::now_seconds(); - let json = serde_json::to_vec(value)?; - - task::spawn_blocking(move || { - let conn = Connection::open(db_path)?; - let tx = conn.transaction()?; - tx.execute( - "INSERT OR REPLACE INTO qobuz_cache - (user_id, namespace, key, fetched_at, ttl_seconds, json) - VALUES (?1, ?2, ?3, ?4, ?5, ?6)", - params![user_id, namespace, key, now, ttl_seconds, json], - )?; - tx.commit()?; - Ok(()) - }) - .await - .map_err(|err| anyhow!(err))? - } - - async fn invalidate( - &self, - user_id: &str, - namespace: &str, - key: &str, - ) -> anyhow::Result<()> { - let user_id = user_id.to_owned(); - let namespace = namespace.to_owned(); - let key = key.to_owned(); - let db_path = self.db_path.clone(); - - task::spawn_blocking(move || { - let conn = Connection::open(db_path)?; - conn.execute( - "DELETE FROM qobuz_cache - WHERE user_id = ?1 AND namespace = ?2 AND key = ?3", - params![user_id, namespace, key], - )?; - Ok(()) - }) - .await - .map_err(|err| anyhow!(err))? - } - - async fn purge_expired(&self) -> anyhow::Result { - let db_path = self.db_path.clone(); - let now = Self::now_seconds(); - - task::spawn_blocking(move || { - let conn = Connection::open(db_path)?; - let changes = conn.execute( - "DELETE FROM qobuz_cache - WHERE (fetched_at + ttl_seconds) <= ?1", - params![now], - )?; - Ok(changes) - }) - .await - .map_err(|err| anyhow!(err))? - } -} - -pub use {CacheEntry, CacheStore, SqliteCacheStore}; -========= End of pmoqobuz/src/disk_cache.rs =========== - -=============== pmoqobuz/src/models.rs ============ -//! Structures de données pour représenter les objets Qobuz - -use chrono::{DateTime, Utc}; -use serde::{Deserialize, Deserializer, Serialize}; - -/// Désérialiseur flexible pour les IDs qui peuvent être des strings ou des integers -pub(crate) fn deserialize_id<'de, D>(deserializer: D) -> Result -where - D: Deserializer<'de>, -{ - use serde::de::Error; - use serde_json::Value; - - let value = Value::deserialize(deserializer)?; - match value { - Value::String(s) => Ok(s), - Value::Number(n) => Ok(n.to_string()), - _ => Err(Error::custom("ID must be a string or number")), - } -} - -/// Représente un artiste Qobuz -#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)] -pub struct Artist { - /// Identifiant unique de l'artiste - #[serde(deserialize_with = "deserialize_id")] - pub id: String, - /// Nom de l'artiste - pub name: String, - /// URL de l'image de l'artiste (optionnelle) - #[serde(default)] - pub image: Option, - /// URL de l'image cachée localement (via pmocovers) - #[serde(skip)] - pub image_cached: Option, -} - -/// Représente un album Qobuz -#[derive(Debug, Clone, Serialize, Deserialize)] -pub struct Album { - /// Identifiant unique de l'album - #[serde(deserialize_with = "deserialize_id")] - pub id: String, - /// Titre de l'album - pub title: String, - /// Artiste principal de l'album - pub artist: Artist, - /// Nombre de pistes - #[serde(default)] - pub tracks_count: Option, - /// Durée totale en secondes - #[serde(default)] - pub duration: Option, - /// Date de sortie (format ISO 8601) - #[serde(default)] - pub release_date: Option, - /// URL de l'image de couverture - #[serde(default)] - pub image: Option, - /// URL de l'image cachée localement (via pmocovers) - #[serde(skip)] - pub image_cached: Option, - /// Indique si l'album est disponible pour le streaming - #[serde(default = "default_true")] - pub streamable: bool, - /// Description de l'album - #[serde(default)] - pub description: Option, - /// Taux d'échantillonnage maximum (Hz) - #[serde(default)] - pub maximum_sampling_rate: Option, - /// Profondeur de bits maximale - #[serde(default)] - pub maximum_bit_depth: Option, - /// Genre(s) de l'album - #[serde(default)] - pub genres: Vec, - /// Label de l'album - #[serde(default)] - pub label: Option, -} - -/// Représente une piste (track) Qobuz -#[derive(Debug, Clone, Serialize, Deserialize)] -pub struct Track { - /// Identifiant unique de la piste - #[serde(deserialize_with = "deserialize_id")] - pub id: String, - /// Titre de la piste - pub title: String, - /// Artiste de la piste (peut différer de l'artiste de l'album) - pub performer: Option, - /// Album contenant la piste - pub album: Option, - /// Durée en secondes - pub duration: u32, - /// Numéro de piste - pub track_number: u32, - /// Numéro de disque (pour les albums multi-disques) - pub media_number: u32, - /// Indique si la piste est disponible pour le streaming - #[serde(default = "default_true")] - pub streamable: bool, - /// Type MIME du fichier audio (déterminé après obtention de l'URL) - #[serde(skip)] - pub mime_type: Option, - /// Fréquence d'échantillonnage (Hz) - #[serde(skip)] - pub sample_rate: Option, - /// Profondeur de bits - #[serde(skip)] - pub bit_depth: Option, - /// Nombre de canaux audio - #[serde(skip)] - pub channels: Option, -} - -/// Représente une playlist Qobuz -#[derive(Debug, Clone, Serialize, Deserialize)] -pub struct Playlist { - /// Identifiant unique de la playlist - #[serde(deserialize_with = "deserialize_id")] - pub id: String, - /// Nom de la playlist - pub name: String, - /// Description de la playlist - #[serde(default)] - pub description: Option, - /// Nombre de pistes - #[serde(default)] - pub tracks_count: Option, - /// Durée totale en secondes - #[serde(default)] - pub duration: Option, - /// URL de l'image de la playlist - #[serde(default)] - pub image: Option, - /// URL de l'image cachée localement - #[serde(skip)] - pub image_cached: Option, - /// Indique si c'est une playlist publique - #[serde(default)] - pub is_public: bool, - /// Propriétaire de la playlist - #[serde(default)] - pub owner: Option, -} - -/// Propriétaire d'une playlist -#[derive(Debug, Clone, Serialize, Deserialize)] -pub struct PlaylistOwner { - /// Identifiant de l'utilisateur - pub id: u64, - /// Nom de l'utilisateur - pub name: String, -} - -/// Représente un genre musical -#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)] -pub struct Genre { - /// Identifiant du genre (peut être None pour "All Genres") - pub id: Option, - /// Nom du genre - pub name: String, - /// Genres enfants - #[serde(default)] - pub children: Vec, -} - -/// Résultats de recherche -#[derive(Debug, Clone, Default, Serialize, Deserialize)] -pub struct SearchResult { - /// Albums trouvés - #[serde(default)] - pub albums: Vec, - /// Artistes trouvés - #[serde(default)] - pub artists: Vec, - /// Pistes trouvées - #[serde(default)] - pub tracks: Vec, - /// Playlists trouvées - #[serde(default)] - pub playlists: Vec, -} - -/// Informations sur un fichier de streaming -#[derive(Debug, Clone, Serialize, Deserialize)] -pub struct StreamInfo { - /// URL de streaming - pub url: String, - /// Type MIME - pub mime_type: String, - /// Fréquence d'échantillonnage (Hz) - pub sampling_rate: u32, - /// Profondeur de bits - pub bit_depth: u32, - /// Format ID Qobuz - pub format_id: u8, - /// Date d'expiration de l'URL - #[serde(skip)] - pub expires_at: DateTime, -} - -/// Format audio demandé pour le streaming -#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)] -#[repr(u8)] -#[allow(non_camel_case_types)] -pub enum AudioFormat { - /// MP3 320 kbps - Mp3_320 = 5, - /// FLAC 16 bit / 44.1 kHz (CD Quality) - Flac_Lossless = 6, - /// FLAC 24 bit / jusqu'à 96 kHz (Hi-Res) - Flac_HiRes_96 = 7, - /// FLAC 24 bit / jusqu'à 192 kHz (Hi-Res+) - Flac_HiRes_192 = 27, -} - -impl AudioFormat { - /// Retourne l'ID du format pour l'API Qobuz - pub fn id(&self) -> u8 { - *self as u8 - } - - /// Retourne une description lisible du format - pub fn description(&self) -> &'static str { - match self { - AudioFormat::Mp3_320 => "MP3 320 kbps", - AudioFormat::Flac_Lossless => "FLAC 16 bit / 44.1 kHz", - AudioFormat::Flac_HiRes_96 => "FLAC 24 bit / up to 96 kHz", - AudioFormat::Flac_HiRes_192 => "FLAC 24 bit / up to 192 kHz", - } - } - - /// Retourne le type MIME associé - pub fn mime_type(&self) -> &'static str { - match self { - AudioFormat::Mp3_320 => "audio/mpeg", - _ => "audio/flac", - } - } -} - -impl Default for AudioFormat { - fn default() -> Self { - AudioFormat::Flac_Lossless - } -} - -// Helper functions -fn default_true() -> bool { - true -} - -impl Artist { - /// Crée un nouvel artiste avec un ID et un nom - pub fn new(id: impl Into, name: impl Into) -> Self { - Self { - id: id.into(), - name: name.into(), - image: None, - image_cached: None, - } - } -} - -impl Album { - /// Retourne un titre formaté avec les informations audio si disponibles - pub fn formatted_title(&self) -> String { - if let (Some(rate), Some(depth)) = (self.maximum_sampling_rate, self.maximum_bit_depth) { - format!("{} ({:.0}/{} bit)", self.title, rate / 1000.0, depth) - } else { - self.title.clone() - } - } - - /// Vérifie si l'album est disponible pour le streaming - pub fn is_available(&self) -> bool { - self.streamable - } -} - -impl Track { - /// Retourne l'artiste à afficher (performer ou artiste de l'album) - pub fn display_artist(&self) -> Option<&Artist> { - self.performer - .as_ref() - .or_else(|| self.album.as_ref().map(|a| &a.artist)) - } - - /// Retourne le nom de l'album si disponible - pub fn album_name(&self) -> Option<&str> { - self.album.as_ref().map(|a| a.title.as_str()) - } - - /// Vérifie si la piste est disponible pour le streaming - pub fn is_available(&self) -> bool { - self.streamable - } -} - -impl SearchResult { - /// Crée un résultat de recherche vide - pub fn new() -> Self { - Self::default() - } - - /// Retourne le nombre total de résultats - pub fn total_count(&self) -> usize { - self.albums.len() + self.artists.len() + self.tracks.len() + self.playlists.len() - } - - /// Vérifie si la recherche n'a retourné aucun résultat - pub fn is_empty(&self) -> bool { - self.total_count() == 0 - } -} -========= End of pmoqobuz/src/models.rs =========== - -=============== pmoqobuz/src/didl.rs ============ -//! Export des objets Qobuz en format DIDL-Lite -//! -//! Ce module permet de convertir les structures Qobuz (Album, Track, etc.) -//! en objets DIDL-Lite compatibles avec UPnP/DLNA. - -use crate::error::{QobuzError, Result}; -use crate::models::{Album, Playlist, Track}; -use pmodidl::{Container, Item, Resource}; - -/// Trait pour convertir un objet Qobuz en DIDL-Lite -pub trait ToDIDL { - /// Convertit l'objet en Container DIDL - fn to_didl_container(&self, parent_id: &str) -> Result; - - /// Convertit l'objet en Item DIDL - fn to_didl_item(&self, parent_id: &str) -> Result; -} - -impl ToDIDL for Album { - /// Convertit un album en Container DIDL - /// - /// # Arguments - /// - /// * `parent_id` - ID du container parent - /// - /// # Exemple - /// - /// ```rust,ignore - /// let album = client.get_album("12345").await?; - /// let container = album.to_didl_container("0$qobuz$albums")?; - /// ``` - fn to_didl_container(&self, parent_id: &str) -> Result { - let id = format!("0$qobuz$album${}", self.id); - - Ok(Container { - id, - parent_id: parent_id.to_string(), - restricted: Some("1".to_string()), - child_count: self.tracks_count.map(|c| c.to_string()), - searchable: Some("1".to_string()), - title: self.formatted_title(), - class: "object.container.album.musicAlbum".to_string(), - containers: Vec::new(), - items: Vec::new(), - }) - } - - /// Un album ne peut pas être converti directement en Item - fn to_didl_item(&self, _parent_id: &str) -> Result { - Err(QobuzError::DidlExport( - "Album cannot be converted to Item, use to_didl_container instead".to_string(), - )) - } -} - -impl ToDIDL for Track { - /// Une track ne peut pas être convertie en Container - fn to_didl_container(&self, _parent_id: &str) -> Result { - Err(QobuzError::DidlExport( - "Track cannot be converted to Container, use to_didl_item instead".to_string(), - )) - } - - /// Convertit une track en Item DIDL - /// - /// # Arguments - /// - /// * `parent_id` - ID du container parent - /// - /// # Exemple - /// - /// ```rust,ignore - /// let track = client.get_track("98765").await?; - /// let item = track.to_didl_item("0$qobuz$album$12345")?; - /// ``` - fn to_didl_item(&self, parent_id: &str) -> Result { - let id = format!("0$qobuz$track${}", self.id); - - // Déterminer l'artiste à afficher - let artist_name = self - .display_artist() - .map(|a| a.name.clone()) - .or_else(|| self.album.as_ref().map(|a| a.artist.name.clone())); - - // Déterminer l'album - let album_name = self.album_name().map(|s| s.to_string()); - - // Déterminer l'image de couverture - let album_art = self - .album - .as_ref() - .and_then(|a| a.image_cached.clone().or_else(|| a.image.clone())); - - // Créer la ressource (URL de streaming) - // Note: L'URL sera remplie plus tard via get_stream_url - let resource = Resource { - protocol_info: format!( - "http-get:*:{}:*", - self.mime_type.as_deref().unwrap_or("audio/flac") - ), - bits_per_sample: self.bit_depth.map(|b| b.to_string()), - sample_frequency: self.sample_rate.map(|r| r.to_string()), - nr_audio_channels: self.channels.map(|c| c.to_string()), - duration: Some(format_duration(self.duration)), - url: format!("qobuz://track/{}", self.id), // URL symbolique - }; - - Ok(Item { - id, - parent_id: parent_id.to_string(), - restricted: Some("1".to_string()), - title: self.title.clone(), - creator: artist_name.clone(), - class: "object.item.audioItem.musicTrack".to_string(), - artist: artist_name, - album: album_name, - genre: None, // Qobuz ne fournit pas le genre au niveau track - album_art, - album_art_pk: None, - date: self.album.as_ref().and_then(|a| a.release_date.clone()), - original_track_number: Some(self.track_number.to_string()), - resources: vec![resource], - descriptions: Vec::new(), - }) - } -} - -impl ToDIDL for Playlist { - /// Convertit une playlist en Container DIDL - fn to_didl_container(&self, parent_id: &str) -> Result { - let id = format!("0$qobuz$playlist${}", self.id); - - Ok(Container { - id, - parent_id: parent_id.to_string(), - restricted: Some("1".to_string()), - child_count: self.tracks_count.map(|c| c.to_string()), - searchable: Some("1".to_string()), - title: self.name.clone(), - class: "object.container.playlistContainer".to_string(), - containers: Vec::new(), - items: Vec::new(), - }) - } - - /// Une playlist ne peut pas être convertie en Item - fn to_didl_item(&self, _parent_id: &str) -> Result { - Err(QobuzError::DidlExport( - "Playlist cannot be converted to Item, use to_didl_container instead".to_string(), - )) - } -} - -/// Formate une durée en secondes au format HH:MM:SS -fn format_duration(seconds: u32) -> String { - let hours = seconds / 3600; - let minutes = (seconds % 3600) / 60; - let secs = seconds % 60; - format!("{:02}:{:02}:{:02}", hours, minutes, secs) -} - -/// Convertit une liste de tracks en items DIDL -pub fn tracks_to_didl_items(tracks: &[Track], parent_id: &str) -> Result> { - tracks - .iter() - .map(|track| track.to_didl_item(parent_id)) - .collect() -} - -/// Convertit une liste d'albums en containers DIDL -pub fn albums_to_didl_containers(albums: &[Album], parent_id: &str) -> Result> { - albums - .iter() - .map(|album| album.to_didl_container(parent_id)) - .collect() -} - -/// Convertit une liste de playlists en containers DIDL -pub fn playlists_to_didl_containers( - playlists: &[Playlist], - parent_id: &str, -) -> Result> { - playlists - .iter() - .map(|playlist| playlist.to_didl_container(parent_id)) - .collect() -} - -#[cfg(test)] -mod tests { - use super::*; - use crate::models::{Album, Artist, Track}; - - #[test] - fn test_album_to_didl_container() { - let album = Album { - id: "123".to_string(), - title: "Test Album".to_string(), - artist: Artist::new("456", "Test Artist"), - tracks_count: Some(10), - duration: Some(3000), - release_date: Some("2024-01-01".to_string()), - image: None, - image_cached: None, - streamable: true, - description: None, - maximum_sampling_rate: Some(96000.0), - maximum_bit_depth: Some(24), - genres: vec![], - label: None, - }; - - let container = album.to_didl_container("parent").unwrap(); - assert_eq!(container.id, "0$qobuz$album$123"); - assert_eq!(container.parent_id, "parent"); - assert!(container.title.contains("Test Album")); - } - - #[test] - fn test_track_to_didl_item() { - let track = Track { - id: "789".to_string(), - title: "Test Track".to_string(), - performer: Some(Artist::new("456", "Test Artist")), - album: None, - duration: 180, - track_number: 1, - media_number: 1, - streamable: true, - mime_type: Some("audio/flac".to_string()), - sample_rate: Some(44100), - bit_depth: Some(16), - channels: Some(2), - }; - - let item = track.to_didl_item("parent").unwrap(); - assert_eq!(item.id, "0$qobuz$track$789"); - assert_eq!(item.parent_id, "parent"); - assert_eq!(item.title, "Test Track"); - } - - #[test] - fn test_format_duration() { - assert_eq!(format_duration(0), "00:00:00"); - assert_eq!(format_duration(90), "00:01:30"); - assert_eq!(format_duration(3665), "01:01:05"); - } -} -========= End of pmoqobuz/src/didl.rs =========== - -=============== pmoqobuz/src/source.rs ============ -//! Music source implementation for Qobuz -//! -//! This module implements the [`pmosource::MusicSource`] trait for Qobuz, -//! providing a complete music catalog browsing and searching experience. - -use crate::client::QobuzClient; -use crate::didl::ToDIDL; -use crate::models::Track; -use pmoaudiocache::{AudioMetadata, Cache as AudioCache}; -use pmocovers::Cache as CoverCache; -use pmodidl::{Container, Item}; -use pmosource::SourceCacheManager; -use pmosource::{async_trait, BrowseResult, MusicSource, MusicSourceError, Result}; -use std::sync::Arc; -use std::time::SystemTime; - -/// Default image for Qobuz (300x300 WebP, embedded in binary) -const DEFAULT_IMAGE: &[u8] = include_bytes!("../assets/default.webp"); - -/// Qobuz music source with full MusicSource trait implementation -/// -/// This struct combines a [`QobuzClient`] for API access with browsing and -/// navigation capabilities, implementing the complete [`MusicSource`] trait. -/// -/// # Features -/// -/// - **Catalog Navigation**: Browse albums, artists, playlists, favorites -/// - **Search**: Full-text search across the Qobuz catalog -/// - **URI Resolution**: Resolves track streaming URIs with authentication -/// - **DIDL-Lite Export**: Converts albums, tracks, and playlists to UPnP formats -/// - **Caching**: Integrated with QobuzClient's cache for performance -/// -/// # Architecture -/// -/// Unlike streaming sources like Radio Paradise, Qobuz is a catalog-based source: -/// - Root container has multiple sub-containers (Albums, Artists, Favorites, etc.) -/// - No FIFO support (it's a static catalog, not a dynamic stream) -/// - Hierarchical browsing: Root → Category → Albums → Tracks -/// -/// # Examples -/// -/// ```no_run -/// use pmoqobuz::{QobuzSource, QobuzClient}; -/// use pmosource::MusicSource; -/// -/// #[tokio::main] -/// async fn main() -> Result<(), Box> { -/// let client = QobuzClient::from_config().await?; -/// let source = QobuzSource::new(client); -/// -/// println!("Source: {}", source.name()); -/// println!("Supports FIFO: {}", source.supports_fifo()); -/// -/// // Browse root container -/// let root = source.root_container().await?; -/// println!("Root: {} with {} children", root.title, root.child_count.unwrap_or_default()); -/// -/// Ok(()) -/// } -/// ``` -#[derive(Clone)] -pub struct QobuzSource { - inner: Arc, -} - -struct QobuzSourceInner { - /// Qobuz API client - client: QobuzClient, - - /// Cache manager (centralisé) - cache_manager: SourceCacheManager, - - /// Update tracking - update_counter: tokio::sync::RwLock, - last_change: tokio::sync::RwLock, -} - -impl std::fmt::Debug for QobuzSource { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - f.debug_struct("QobuzSource").finish() - } -} - -impl QobuzSource { - /// Create a new Qobuz source from the cache registry - /// - /// This is the recommended way to create a source when using the UPnP server. - /// The caches are automatically retrieved from the global registry. - /// - /// # Arguments - /// - /// * `client` - Authenticated Qobuz API client - /// - /// # Errors - /// - /// Returns an error if the caches are not initialized in the registry - #[cfg(feature = "server")] - pub fn from_registry(client: QobuzClient) -> Result { - let cache_manager = SourceCacheManager::from_registry("qobuz".to_string())?; - - Ok(Self { - inner: Arc::new(QobuzSourceInner { - client, - cache_manager, - update_counter: tokio::sync::RwLock::new(0), - last_change: tokio::sync::RwLock::new(SystemTime::now()), - }), - }) - } - - /// Create a new Qobuz source with explicit caches (for tests) - /// - /// # Arguments - /// - /// * `client` - Authenticated Qobuz API client - /// * `cover_cache` - Cover image cache (required) - /// * `audio_cache` - Audio cache (required) - pub fn new( - client: QobuzClient, - cover_cache: Arc, - audio_cache: Arc, - ) -> Self { - let cache_manager = SourceCacheManager::new("qobuz".to_string(), cover_cache, audio_cache); - - Self { - inner: Arc::new(QobuzSourceInner { - client, - cache_manager, - update_counter: tokio::sync::RwLock::new(0), - last_change: tokio::sync::RwLock::new(SystemTime::now()), - }), - } - } - - /// Get the Qobuz client - pub fn client(&self) -> &QobuzClient { - &self.inner.client - } - - /// Add a track from Qobuz with caching - /// - /// This method downloads and caches both cover art and audio data. - pub async fn add_track(&self, track: &Track) -> Result { - let track_id = format!("qobuz://track/{}", track.id); - - // Get streaming URL - let stream_url = self - .inner - .client - .get_stream_url(&track.id) - .await - .map_err(|e| MusicSourceError::UriResolutionError(e.to_string()))?; - - // 1. Cache cover via manager - let cached_cover_pk = if let Some(ref album) = track.album { - if let Some(ref image_url) = album.image { - self.inner.cache_manager.cache_cover(image_url).await.ok() - } else { - None - } - } else { - None - }; - - // 2. Prepare rich metadata from Qobuz track - let metadata = AudioMetadata { - title: Some(track.title.clone()), - artist: track.performer.as_ref().map(|p| p.name.clone()), - album: track.album.as_ref().map(|a| a.title.clone()), - duration_secs: Some(track.duration as u64), - year: track.album.as_ref().and_then(|a| { - a.release_date - .as_ref() - .and_then(|d| d.split('-').next()?.parse().ok()) - }), - track_number: Some(track.track_number), - track_total: track.album.as_ref().and_then(|a| a.tracks_count), - disc_number: Some(track.media_number), - disc_total: None, - genre: track.album.as_ref().and_then(|a| { - if !a.genres.is_empty() { - Some(a.genres.join(", ")) - } else { - None - } - }), - sample_rate: track.sample_rate, - channels: track.channels, - bitrate: None, - conversion: None, - }; - - // 3. Cache audio via manager - let cached_audio_pk = self - .inner - .cache_manager - .cache_audio(&stream_url, Some(metadata)) - .await - .ok(); - - // 4. Store metadata - self.inner - .cache_manager - .update_metadata( - track_id.clone(), - pmosource::TrackMetadata { - original_uri: stream_url, - cached_audio_pk, - cached_cover_pk, - }, - ) - .await; - - Ok(track_id) - } - - /// Add track with lazy audio caching (cover eager, audio lazy) - /// - /// This method caches cover art immediately (small, needed for UI) but - /// defers audio download until the track is actually played. - /// - /// # Arguments - /// - /// * `track` - The Qobuz track to add - /// - /// # Returns - /// - /// The track ID (e.g., "qobuz://track/12345") - pub async fn add_track_lazy(&self, track: &Track) -> Result { - let track_id = format!("qobuz://track/{}", track.id); - - // Get streaming URL - let stream_url = self - .inner - .client - .get_stream_url(&track.id) - .await - .map_err(|e| MusicSourceError::UriResolutionError(e.to_string()))?; - - // 1. Cache cover EAGERLY (small, UI needs it) - let cached_cover_pk = if let Some(ref album) = track.album { - if let Some(ref image_url) = album.image { - self.inner.cache_manager.cache_cover(image_url).await.ok() - } else { - None - } - } else { - None - }; - - // 2. Prepare rich metadata from Qobuz track - let metadata = AudioMetadata { - title: Some(track.title.clone()), - artist: track.performer.as_ref().map(|p| p.name.clone()), - album: track.album.as_ref().map(|a| a.title.clone()), - duration_secs: Some(track.duration as u64), - year: track.album.as_ref().and_then(|a| { - a.release_date - .as_ref() - .and_then(|d| d.split('-').next()?.parse().ok()) - }), - track_number: Some(track.track_number), - track_total: track.album.as_ref().and_then(|a| a.tracks_count), - disc_number: Some(track.media_number), - disc_total: None, - genre: track.album.as_ref().and_then(|a| { - if !a.genres.is_empty() { - Some(a.genres.join(", ")) - } else { - None - } - }), - sample_rate: track.sample_rate, - channels: track.channels, - bitrate: None, - conversion: None, - }; - - // 3. Cache audio LAZILY (KEY CHANGE: use cache_audio_lazy) - let cached_audio_pk = self - .inner - .cache_manager - .cache_audio_lazy(&stream_url, Some(metadata)) - .await - .ok(); - - // 4. Store metadata - self.inner - .cache_manager - .update_metadata( - track_id.clone(), - pmosource::TrackMetadata { - original_uri: stream_url, - cached_audio_pk, - cached_cover_pk, - }, - ) - .await; - - Ok(track_id) - } - - /// Load full album into pmoplaylist with lazy audio - /// - /// This method fetches all tracks from a Qobuz album and adds them to a playlist - /// with lazy audio loading. Covers are downloaded eagerly, audio lazily. - /// - /// # Arguments - /// - /// * `playlist_id` - ID of the target playlist - /// * `album_id` - Qobuz album ID - /// - /// # Returns - /// - /// Number of tracks successfully added - pub async fn add_album_to_playlist( - &self, - playlist_id: &str, - album_id: &str, - ) -> Result { - use tracing::{info, warn, debug}; - - // 1. Get tracks from Qobuz (goes through rate limiter) - let tracks = self - .inner - .client - .get_album_tracks(album_id) - .await - .map_err(|e| MusicSourceError::BrowseError(e.to_string()))?; - - if tracks.is_empty() { - return Ok(0); - } - - info!( - "Adding album {} ({} tracks) to playlist {} with lazy audio", - album_id, - tracks.len(), - playlist_id - ); - - // 2. Add each track lazily + collect lazy PKs - let mut lazy_pks = Vec::with_capacity(tracks.len()); - - for (i, track) in tracks.iter().enumerate() { - match self.add_track_lazy(track).await { - Ok(track_id) => { - debug!("Track {}/{}: {} (lazy)", i + 1, tracks.len(), track.title); - - // Extract lazy PK from cache manager - if let Some(metadata) = self.inner.cache_manager.get_metadata(&track_id).await { - if let Some(audio_pk) = metadata.cached_audio_pk { - lazy_pks.push(audio_pk); - } - } - } - Err(e) => { - warn!( - "Failed to add track {} ({}): {}", - i + 1, - track.title, - e - ); - // Continue with other tracks - } - } - } - - // 3. Batch insert into playlist (single DB transaction) - let playlist_manager = pmoplaylist::PlaylistManager(); - let writer = playlist_manager - .get_write_handle(playlist_id.to_string()) - .await - .map_err(|e| MusicSourceError::PlaylistError(e.to_string()))?; - - writer - .push_lazy_batch(lazy_pks.clone()) - .await - .map_err(|e| MusicSourceError::PlaylistError(e.to_string()))?; - - // 4. Enable lazy mode with lookahead of 2 tracks - playlist_manager.enable_lazy_mode(playlist_id, 2); - - info!( - "Album {} added: {}/{} tracks", - album_id, - lazy_pks.len(), - tracks.len() - ); - - Ok(lazy_pks.len()) - } - - /// Load Qobuz playlist into pmoplaylist with lazy audio - /// - /// This method fetches all tracks from a Qobuz playlist and adds them to a pmoplaylist - /// with lazy audio loading. Covers are downloaded eagerly, audio lazily. - /// - /// # Arguments - /// - /// * `playlist_id` - ID of the target pmoplaylist - /// * `qobuz_playlist_id` - Qobuz playlist ID - /// - /// # Returns - /// - /// Number of tracks successfully added - pub async fn add_qobuz_playlist_to_playlist( - &self, - playlist_id: &str, - qobuz_playlist_id: &str, - ) -> Result { - use tracing::{debug, info, warn}; - - // 1. Get tracks from Qobuz playlist (goes through rate limiter) - let tracks = self - .inner - .client - .get_playlist_tracks(qobuz_playlist_id) - .await - .map_err(|e| MusicSourceError::BrowseError(e.to_string()))?; - - if tracks.is_empty() { - return Ok(0); - } - - info!( - "Adding Qobuz playlist {} ({} tracks) to pmoplaylist {} with lazy audio", - qobuz_playlist_id, - tracks.len(), - playlist_id - ); - - // 2. Add each track lazily + collect lazy PKs - let mut lazy_pks = Vec::with_capacity(tracks.len()); - - for (i, track) in tracks.iter().enumerate() { - match self.add_track_lazy(track).await { - Ok(track_id) => { - debug!("Track {}/{}: {} (lazy)", i + 1, tracks.len(), track.title); - - // Extract lazy PK from cache manager - if let Some(metadata) = self.inner.cache_manager.get_metadata(&track_id).await { - if let Some(audio_pk) = metadata.cached_audio_pk { - lazy_pks.push(audio_pk); - } - } - } - Err(e) => { - warn!( - "Failed to add track {} ({}): {}", - i + 1, - track.title, - e - ); - // Continue with other tracks - } - } - } - - // 3. Batch insert into playlist (single DB transaction) - let playlist_manager = pmoplaylist::PlaylistManager(); - let writer = playlist_manager - .get_write_handle(playlist_id.to_string()) - .await - .map_err(|e| MusicSourceError::PlaylistError(e.to_string()))?; - - writer - .push_lazy_batch(lazy_pks.clone()) - .await - .map_err(|e| MusicSourceError::PlaylistError(e.to_string()))?; - - // 4. Enable lazy mode with lookahead of 2 tracks - playlist_manager.enable_lazy_mode(playlist_id, 2); - - info!( - "Qobuz playlist {} added: {}/{} tracks", - qobuz_playlist_id, - lazy_pks.len(), - tracks.len() - ); - - Ok(lazy_pks.len()) - } - - /// Increment update counter (called on catalog changes) - async fn increment_update_id(&self) { - let mut counter = self.inner.update_counter.write().await; - *counter = counter.wrapping_add(1); - let mut last = self.inner.last_change.write().await; - *last = SystemTime::now(); - } - - /// Parse object_id to determine what to browse - /// - /// Object IDs follow these patterns: - /// - "qobuz" or "0" → Root container - /// - "qobuz:favorites" → User's favorite albums - /// - "qobuz:album:{id}" → Tracks in album - /// - "qobuz:playlist:{id}" → Tracks in playlist - fn parse_object_id(&self, object_id: &str) -> ObjectIdType { - if object_id == "qobuz" || object_id == "0" { - return ObjectIdType::Root; - } - - let parts: Vec<&str> = object_id.split(':').collect(); - match parts.as_slice() { - ["qobuz", "favorites"] => ObjectIdType::Favorites, - ["qobuz", "album", id] => ObjectIdType::Album(id.to_string()), - ["qobuz", "playlist", id] => ObjectIdType::Playlist(id.to_string()), - ["qobuz", "artist", id] => ObjectIdType::Artist(id.to_string()), - _ => ObjectIdType::Unknown, - } - } -} - -#[derive(Debug)] -enum ObjectIdType { - Root, - Favorites, - Album(String), - Playlist(String), - Artist(String), - Unknown, -} - -#[async_trait] -impl MusicSource for QobuzSource { - fn name(&self) -> &str { - "Qobuz" - } - - fn id(&self) -> &str { - "qobuz" - } - - fn default_image(&self) -> &[u8] { - DEFAULT_IMAGE - } - - async fn root_container(&self) -> Result { - // Create the root container with sub-containers for different categories - Ok(Container { - id: "qobuz".to_string(), - parent_id: "0".to_string(), - restricted: Some("1".to_string()), - child_count: Some("2".to_string()), // Favorites + Search (simplified) - searchable: Some("1".to_string()), - title: "Qobuz".to_string(), - class: "object.container".to_string(), - containers: vec![ - // Favorites container - Container { - id: "qobuz:favorites".to_string(), - parent_id: "qobuz".to_string(), - restricted: Some("1".to_string()), - child_count: None, // Will be determined when browsed - searchable: Some("1".to_string()), - title: "My Favorites".to_string(), - class: "object.container".to_string(), - containers: vec![], - items: vec![], - }, - ], - items: vec![], - }) - } - - async fn browse(&self, object_id: &str) -> Result { - match self.parse_object_id(object_id) { - ObjectIdType::Root => { - // Return the root container's children - let root = self.root_container().await?; - Ok(BrowseResult::Containers(root.containers)) - } - - ObjectIdType::Favorites => { - // Get user's favorite albums - let albums = self - .inner - .client - .get_favorite_albums() - .await - .map_err(|e| MusicSourceError::BrowseError(e.to_string()))?; - - let containers: Vec = albums - .into_iter() - .filter_map(|album| album.to_didl_container("qobuz:favorites").ok()) - .collect(); - - Ok(BrowseResult::Containers(containers)) - } - - ObjectIdType::Album(album_id) => { - // Get tracks in album - let tracks = self - .inner - .client - .get_album_tracks(&album_id) - .await - .map_err(|e| MusicSourceError::BrowseError(e.to_string()))?; - - let items: Vec = tracks - .into_iter() - .filter_map(|track| { - track - .to_didl_item(&format!("qobuz:album:{}", album_id)) - .ok() - }) - .collect(); - - Ok(BrowseResult::Items(items)) - } - - ObjectIdType::Playlist(playlist_id) => { - // Get tracks in playlist - let tracks = self - .inner - .client - .get_playlist_tracks(&playlist_id) - .await - .map_err(|e| MusicSourceError::BrowseError(e.to_string()))?; - - let items: Vec = tracks - .into_iter() - .filter_map(|track| { - track - .to_didl_item(&format!("qobuz:playlist:{}", playlist_id)) - .ok() - }) - .collect(); - - Ok(BrowseResult::Items(items)) - } - - ObjectIdType::Artist(artist_id) => { - // Get albums by artist - let albums = self - .inner - .client - .get_artist_albums(&artist_id) - .await - .map_err(|e| MusicSourceError::BrowseError(e.to_string()))?; - - let containers: Vec = albums - .into_iter() - .filter_map(|album| { - album - .to_didl_container(&format!("qobuz:artist:{}", artist_id)) - .ok() - }) - .collect(); - - Ok(BrowseResult::Containers(containers)) - } - - ObjectIdType::Unknown => Err(MusicSourceError::ObjectNotFound(object_id.to_string())), - } - } - - async fn resolve_uri(&self, object_id: &str) -> Result { - // Try cache manager first - if let Ok(uri) = self.inner.cache_manager.resolve_uri(object_id).await { - return Ok(uri); - } - - // If not cached, extract track ID and get streaming URL from Qobuz - let track_id = object_id - .strip_prefix("qobuz://track/") - .unwrap_or(object_id); - - self.inner - .client - .get_stream_url(track_id) - .await - .map_err(|e| MusicSourceError::UriResolutionError(e.to_string())) - } - - fn supports_fifo(&self) -> bool { - // Qobuz is a catalog, not a dynamic stream - false - } - - async fn append_track(&self, _track: Item) -> Result<()> { - Err(MusicSourceError::FifoNotSupported) - } - - async fn remove_oldest(&self) -> Result> { - Err(MusicSourceError::FifoNotSupported) - } - - async fn update_id(&self) -> u32 { - *self.inner.update_counter.read().await - } - - async fn last_change(&self) -> Option { - Some(*self.inner.last_change.read().await) - } - - async fn get_items(&self, offset: usize, count: usize) -> Result> { - // For Qobuz, "get_items" returns favorite tracks with pagination - let all_tracks = self - .inner - .client - .get_favorite_tracks() - .await - .map_err(|e| MusicSourceError::BrowseError(e.to_string()))?; - - let items: Vec = all_tracks - .into_iter() - .skip(offset) - .take(count) - .filter_map(|track| track.to_didl_item("qobuz:favorites").ok()) - .collect(); - - Ok(items) - } - - async fn search(&self, query: &str) -> Result { - // Search across Qobuz catalog - let results = self - .inner - .client - .search(query, None) - .await - .map_err(|e| MusicSourceError::BrowseError(e.to_string()))?; - - // Convert albums to containers and tracks to items - let containers: Vec = results - .albums - .into_iter() - .filter_map(|album| album.to_didl_container("qobuz").ok()) - .collect(); - - let items: Vec = results - .tracks - .into_iter() - .filter_map(|track| track.to_didl_item("qobuz").ok()) - .collect(); - - if !containers.is_empty() || !items.is_empty() { - Ok(BrowseResult::Mixed { containers, items }) - } else { - Ok(BrowseResult::Items(vec![])) - } - } - - // ============= Extended Features Implementation ============= - - fn capabilities(&self) -> pmosource::SourceCapabilities { - pmosource::SourceCapabilities { - supports_fifo: false, - supports_search: true, - supports_favorites: true, - supports_playlists: true, - supports_user_content: false, - supports_high_res_audio: true, - max_sample_rate: Some(192_000), // Qobuz supports up to 192kHz - supports_multiple_formats: true, - supports_advanced_search: false, // TODO: Qobuz API supports it, not yet implemented - supports_pagination: true, - } - } - - async fn get_available_formats(&self, object_id: &str) -> Result> { - use pmosource::AudioFormat; - - // Extract track ID from object_id - let track_id = if let Some(id) = object_id.strip_prefix("qobuz://track/") { - id - } else { - object_id - }; - - // Get track details from Qobuz - let track = self - .inner - .client - .get_track(track_id) - .await - .map_err(|e| MusicSourceError::BrowseError(e.to_string()))?; - - // Qobuz provides multiple formats based on subscription - let mut formats = vec![]; - - // MP3 320 (format_id 5) - available to all - formats.push(AudioFormat { - format_id: "mp3-320".to_string(), - mime_type: "audio/mpeg".to_string(), - sample_rate: Some(44100), - bit_depth: None, - bitrate: Some(320), - channels: Some(2), - }); - - // FLAC 16/44.1 (format_id 6) - CD quality - formats.push(AudioFormat { - format_id: "flac-16-44".to_string(), - mime_type: "audio/flac".to_string(), - sample_rate: Some(44100), - bit_depth: Some(16), - bitrate: None, - channels: Some(2), - }); - - // Hi-Res formats (if available for this track) - if let Some(sample_rate) = track.sample_rate { - if sample_rate > 44100 { - // FLAC 24-bit Hi-Res - let bit_depth = track.bit_depth.map(|d| d as u8).or(Some(24)); - - formats.push(AudioFormat { - format_id: format!("flac-{}-{}", bit_depth.unwrap_or(24), sample_rate / 1000), - mime_type: "audio/flac".to_string(), - sample_rate: Some(sample_rate), - bit_depth, - bitrate: None, - channels: track.channels, - }); - } - } - - Ok(formats) - } - - async fn get_cache_status(&self, object_id: &str) -> Result { - self.inner.cache_manager.get_cache_status(object_id).await - } - - async fn cache_item(&self, object_id: &str) -> Result { - // Extract track ID - let track_id = object_id - .strip_prefix("qobuz://track/") - .unwrap_or(object_id); - - // Get track details from Qobuz - let track = self - .inner - .client - .get_track(track_id) - .await - .map_err(|e| MusicSourceError::BrowseError(e.to_string()))?; - - // Add track to cache (via manager) - let cached_id = self.add_track(&track).await?; - - // Return the cache status - self.get_cache_status(&cached_id).await - } - - async fn add_favorite(&self, object_id: &str) -> Result<()> { - // Parse object_id to determine type - let parts: Vec<&str> = object_id.split(':').collect(); - - match parts.as_slice() { - ["qobuz", "album", id] | ["qobuz://album", id] => { - self.inner - .client - .add_favorite_album(id) - .await - .map_err(|e| MusicSourceError::FavoritesError(e.to_string()))?; - } - ["qobuz", "track", id] | ["qobuz://track", id] => { - self.inner - .client - .add_favorite_track(id) - .await - .map_err(|e| MusicSourceError::FavoritesError(e.to_string()))?; - } - _ => { - return Err(MusicSourceError::NotSupported( - "Favorites only supported for albums and tracks".to_string(), - )); - } - } - - self.increment_update_id().await; - Ok(()) - } - - async fn remove_favorite(&self, object_id: &str) -> Result<()> { - // Parse object_id to determine type - let parts: Vec<&str> = object_id.split(':').collect(); - - match parts.as_slice() { - ["qobuz", "album", id] | ["qobuz://album", id] => { - self.inner - .client - .remove_favorite_album(id) - .await - .map_err(|e| MusicSourceError::FavoritesError(e.to_string()))?; - } - ["qobuz", "track", id] | ["qobuz://track", id] => { - self.inner - .client - .remove_favorite_track(id) - .await - .map_err(|e| MusicSourceError::FavoritesError(e.to_string()))?; - } - _ => { - return Err(MusicSourceError::NotSupported( - "Favorites only supported for albums and tracks".to_string(), - )); - } - } - - self.increment_update_id().await; - Ok(()) - } - - async fn is_favorite(&self, object_id: &str) -> Result { - // Parse object_id to determine type - let parts: Vec<&str> = object_id.split(':').collect(); - - match parts.as_slice() { - ["qobuz", "album", id] | ["qobuz://album", id] => { - let favorites = self - .inner - .client - .get_favorite_albums() - .await - .map_err(|e| MusicSourceError::FavoritesError(e.to_string()))?; - - Ok(favorites.iter().any(|album| album.id == *id)) - } - ["qobuz", "track", id] | ["qobuz://track", id] => { - let favorites = self - .inner - .client - .get_favorite_tracks() - .await - .map_err(|e| MusicSourceError::FavoritesError(e.to_string()))?; - - Ok(favorites.iter().any(|track| track.id == *id)) - } - _ => Err(MusicSourceError::NotSupported( - "Favorites only supported for albums and tracks".to_string(), - )), - } - } - - async fn get_user_playlists(&self) -> Result> { - let playlists = self - .inner - .client - .get_user_playlists() - .await - .map_err(|e| MusicSourceError::PlaylistError(e.to_string()))?; - - let containers: Vec = playlists - .into_iter() - .filter_map(|playlist| playlist.to_didl_container("qobuz").ok()) - .collect(); - - Ok(containers) - } - - async fn add_to_playlist(&self, playlist_id: &str, item_id: &str) -> Result<()> { - // Extract track ID from item_id - let track_id = if let Some(id) = item_id.strip_prefix("qobuz://track/") { - id - } else if let Some(id) = item_id.strip_prefix("qobuz:track:") { - id - } else { - item_id - }; - - self.inner - .client - .add_to_playlist(playlist_id, track_id) - .await - .map_err(|e| MusicSourceError::PlaylistError(e.to_string()))?; - - self.increment_update_id().await; - Ok(()) - } - - async fn get_item_count(&self, object_id: &str) -> Result { - match self.parse_object_id(object_id) { - ObjectIdType::Album(album_id) => { - let album = self - .inner - .client - .get_album(&album_id) - .await - .map_err(|e| MusicSourceError::BrowseError(e.to_string()))?; - - Ok(album.tracks_count.unwrap_or(0) as usize) - } - ObjectIdType::Playlist(playlist_id) => { - let playlist = self - .inner - .client - .get_playlist(&playlist_id) - .await - .map_err(|e| MusicSourceError::BrowseError(e.to_string()))?; - - Ok(playlist.tracks_count.unwrap_or(0) as usize) - } - _ => { - // Fall back to default implementation - let result = self.browse(object_id).await?; - Ok(result.count()) - } - } - } - - async fn browse_paginated( - &self, - object_id: &str, - offset: usize, - limit: usize, - ) -> Result { - match self.parse_object_id(object_id) { - ObjectIdType::Album(album_id) => { - // Qobuz returns all tracks, so we slice them - let tracks = self - .inner - .client - .get_album_tracks(&album_id) - .await - .map_err(|e| MusicSourceError::BrowseError(e.to_string()))?; - - let items: Vec = tracks - .into_iter() - .skip(offset) - .take(limit) - .filter_map(|track| { - track - .to_didl_item(&format!("qobuz:album:{}", album_id)) - .ok() - }) - .collect(); - - Ok(BrowseResult::Items(items)) - } - ObjectIdType::Favorites => { - let albums = self - .inner - .client - .get_favorite_albums() - .await - .map_err(|e| MusicSourceError::BrowseError(e.to_string()))?; - - let containers: Vec = albums - .into_iter() - .skip(offset) - .take(limit) - .filter_map(|album| album.to_didl_container("qobuz:favorites").ok()) - .collect(); - - Ok(BrowseResult::Containers(containers)) - } - _ => { - // Fall back to default implementation - self.browse(object_id).await - } - } - } - - async fn statistics(&self) -> Result { - let mut stats = pmosource::SourceStatistics::default(); - - // Try to get favorite counts - if let Ok(albums) = self.inner.client.get_favorite_albums().await { - stats.total_containers = Some(albums.len()); - } - - if let Ok(tracks) = self.inner.client.get_favorite_tracks().await { - stats.total_items = Some(tracks.len()); - } - - // Get cache statistics from manager - let cache_stats = self.inner.cache_manager.statistics().await; - stats.cached_items = Some(cache_stats.cached_tracks); - - Ok(stats) - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_default_image_present() { - assert!(DEFAULT_IMAGE.len() > 0, "Default image should not be empty"); - - // Check WebP magic bytes (RIFF...WEBP) - assert!( - DEFAULT_IMAGE.len() >= 12, - "Image too small to be valid WebP" - ); - assert_eq!(&DEFAULT_IMAGE[0..4], b"RIFF", "Missing RIFF header"); - assert_eq!(&DEFAULT_IMAGE[8..12], b"WEBP", "Missing WEBP signature"); - } - - // Note: We can't easily test parse_object_id without creating a real client - // which requires authentication. The parsing logic is simple enough that - // it's covered by integration tests. -} -========= End of pmoqobuz/src/source.rs =========== - -=============== pmoqobuz/src/api_rest.rs ============ -//! Endpoints API REST pour Qobuz -//! -//! Ce module définit les handlers HTTP pour accéder aux fonctionnalités Qobuz. - -#[cfg(feature = "pmoserver")] -use axum::{ - extract::{Path, Query, State}, - http::StatusCode, - response::{IntoResponse, Response}, - Json, Router, -}; - -#[cfg(feature = "pmoserver")] -use serde::{Deserialize, Serialize}; - -#[cfg(feature = "pmoserver")] -use std::sync::Arc; - -#[cfg(feature = "pmoserver")] -use crate::{client::QobuzClient, error::QobuzError, models::*}; - -/// État partagé de l'application -#[cfg(feature = "pmoserver")] -#[derive(Clone)] -pub struct QobuzState { - pub client: Arc, - #[cfg(feature = "covers")] - pub cover_cache: Option>, -} - -/// Paramètres de recherche -#[cfg(feature = "pmoserver")] -#[derive(Debug, Deserialize)] -pub struct SearchParams { - /// Requête de recherche - pub q: String, - /// Type de recherche (albums, artists, tracks, playlists) - #[serde(rename = "type")] - pub search_type: Option, -} - -/// Paramètres pour featured albums -#[cfg(feature = "pmoserver")] -#[derive(Debug, Deserialize)] -pub struct FeaturedAlbumsParams { - /// ID du genre (optionnel) - pub genre_id: Option, - /// Type (new-releases, ideal-discography, etc.) - #[serde(rename = "type", default = "default_featured_type")] - pub type_: String, -} - -#[cfg(feature = "pmoserver")] -fn default_featured_type() -> String { - "new-releases".to_string() -} - -/// Paramètres pour featured playlists -#[cfg(feature = "pmoserver")] -#[derive(Debug, Deserialize)] -pub struct FeaturedPlaylistsParams { - /// ID du genre (optionnel) - pub genre_id: Option, - /// Tags (optionnel) - pub tags: Option, -} - -/// Crée le router Axum avec tous les endpoints Qobuz -#[cfg(feature = "pmoserver")] -pub fn create_router(state: QobuzState) -> Router { - Router::new() - // Albums - .route("/albums/:id", axum::routing::get(get_album)) - .route("/albums/:id/tracks", axum::routing::get(get_album_tracks)) - // Tracks - .route("/tracks/:id", axum::routing::get(get_track)) - .route("/tracks/:id/stream", axum::routing::get(get_stream_url)) - // Artists - .route("/artists/:id/albums", axum::routing::get(get_artist_albums)) - .route( - "/artists/:id/similar", - axum::routing::get(get_similar_artists), - ) - // Playlists - .route("/playlists/:id", axum::routing::get(get_playlist)) - .route( - "/playlists/:id/tracks", - axum::routing::get(get_playlist_tracks), - ) - // Recherche - .route("/search", axum::routing::get(search)) - // Favoris - .route("/favorites/albums", axum::routing::get(get_favorite_albums)) - .route( - "/favorites/artists", - axum::routing::get(get_favorite_artists), - ) - .route("/favorites/tracks", axum::routing::get(get_favorite_tracks)) - .route( - "/favorites/playlists", - axum::routing::get(get_user_playlists), - ) - // Catalogue - .route("/genres", axum::routing::get(get_genres)) - .route("/featured/albums", axum::routing::get(get_featured_albums)) - .route( - "/featured/playlists", - axum::routing::get(get_featured_playlists), - ) - // Cache - .route("/cache/stats", axum::routing::get(get_cache_stats)) - .with_state(state) -} - -// ============ Handlers ============ - -#[cfg(feature = "pmoserver")] -async fn get_album( - State(state): State, - Path(id): Path, -) -> Result, AppError> { - let mut album = state.client.get_album(&id).await?; - - #[cfg(feature = "covers")] - if let Some(ref cover_cache) = state.cover_cache { - album = cache_album_image(album, cover_cache).await; - } - - Ok(Json(album)) -} - -#[cfg(feature = "pmoserver")] -async fn get_album_tracks( - State(state): State, - Path(id): Path, -) -> Result>, AppError> { - let tracks = state.client.get_album_tracks(&id).await?; - Ok(Json(tracks)) -} - -#[cfg(feature = "pmoserver")] -async fn get_track( - State(state): State, - Path(id): Path, -) -> Result, AppError> { - let track = state.client.get_track(&id).await?; - Ok(Json(track)) -} - -#[cfg(feature = "pmoserver")] -async fn get_stream_url( - State(state): State, - Path(id): Path, -) -> Result, AppError> { - let url = state.client.get_stream_url(&id).await?; - Ok(Json(serde_json::json!({ "url": url }))) -} - -#[cfg(feature = "pmoserver")] -async fn get_artist_albums( - State(state): State, - Path(id): Path, -) -> Result>, AppError> { - let mut albums = state.client.get_artist_albums(&id).await?; - - #[cfg(feature = "covers")] - if let Some(ref cover_cache) = state.cover_cache { - albums = cache_albums_images(albums, cover_cache).await; - } - - Ok(Json(albums)) -} - -#[cfg(feature = "pmoserver")] -async fn get_similar_artists( - State(state): State, - Path(id): Path, -) -> Result>, AppError> { - let artists = state.client.get_similar_artists(&id).await?; - Ok(Json(artists)) -} - -#[cfg(feature = "pmoserver")] -async fn get_playlist( - State(state): State, - Path(id): Path, -) -> Result, AppError> { - let playlist = state.client.get_playlist(&id).await?; - Ok(Json(playlist)) -} - -#[cfg(feature = "pmoserver")] -async fn get_playlist_tracks( - State(state): State, - Path(id): Path, -) -> Result>, AppError> { - let tracks = state.client.get_playlist_tracks(&id).await?; - Ok(Json(tracks)) -} - -#[cfg(feature = "pmoserver")] -async fn search( - State(state): State, - Query(params): Query, -) -> Result, AppError> { - let mut result = state - .client - .search(¶ms.q, params.search_type.as_deref()) - .await?; - - #[cfg(feature = "covers")] - if let Some(ref cover_cache) = state.cover_cache { - result.albums = cache_albums_images(result.albums, cover_cache).await; - } - - Ok(Json(result)) -} - -#[cfg(feature = "pmoserver")] -async fn get_favorite_albums( - State(state): State, -) -> Result>, AppError> { - let mut albums = state.client.get_favorite_albums().await?; - - #[cfg(feature = "covers")] - if let Some(ref cover_cache) = state.cover_cache { - albums = cache_albums_images(albums, cover_cache).await; - } - - Ok(Json(albums)) -} - -#[cfg(feature = "pmoserver")] -async fn get_favorite_artists( - State(state): State, -) -> Result>, AppError> { - let artists = state.client.get_favorite_artists().await?; - Ok(Json(artists)) -} - -#[cfg(feature = "pmoserver")] -async fn get_favorite_tracks( - State(state): State, -) -> Result>, AppError> { - let tracks = state.client.get_favorite_tracks().await?; - Ok(Json(tracks)) -} - -#[cfg(feature = "pmoserver")] -async fn get_user_playlists( - State(state): State, -) -> Result>, AppError> { - let playlists = state.client.get_user_playlists().await?; - Ok(Json(playlists)) -} - -#[cfg(feature = "pmoserver")] -async fn get_genres(State(state): State) -> Result>, AppError> { - let genres = state.client.get_genres().await?; - Ok(Json(genres)) -} - -#[cfg(feature = "pmoserver")] -async fn get_featured_albums( - State(state): State, - Query(params): Query, -) -> Result>, AppError> { - let mut albums = state - .client - .get_featured_albums(params.genre_id.as_deref(), ¶ms.type_) - .await?; - - #[cfg(feature = "covers")] - if let Some(ref cover_cache) = state.cover_cache { - albums = cache_albums_images(albums, cover_cache).await; - } - - Ok(Json(albums)) -} - -#[cfg(feature = "pmoserver")] -async fn get_featured_playlists( - State(state): State, - Query(params): Query, -) -> Result>, AppError> { - let playlists = state - .client - .get_featured_playlists(params.genre_id.as_deref(), params.tags.as_deref()) - .await?; - Ok(Json(playlists)) -} - -#[cfg(feature = "pmoserver")] -async fn get_cache_stats( - State(state): State, -) -> Result, AppError> { - let stats = state.client.cache().stats().await; - Ok(Json(stats)) -} - -// ============ Helpers pour le cache d'images ============ - -#[cfg(all(feature = "pmoserver", feature = "covers"))] -async fn cache_album_image(mut album: Album, cover_cache: &Arc) -> Album { - if let Some(ref image_url) = album.image { - match cover_cache.add_from_url(image_url, None).await { - Ok(pk) => { - album.image_cached = Some(format!("/covers/images/{}", pk)); - } - Err(e) => { - tracing::warn!("Failed to cache album image: {}", e); - } - } - } - album -} - -#[cfg(all(feature = "pmoserver", feature = "covers"))] -async fn cache_albums_images( - albums: Vec, - cover_cache: &Arc, -) -> Vec { - let mut cached_albums = Vec::with_capacity(albums.len()); - for album in albums { - cached_albums.push(cache_album_image(album, cover_cache).await); - } - cached_albums -} - -// ============ Gestion des erreurs ============ - -#[cfg(feature = "pmoserver")] -struct AppError(QobuzError); - -#[cfg(feature = "pmoserver")] -impl IntoResponse for AppError { - fn into_response(self) -> Response { - let (status, message) = match self.0 { - QobuzError::Unauthorized(_) => (StatusCode::UNAUTHORIZED, self.0.to_string()), - QobuzError::NotFound(_) => (StatusCode::NOT_FOUND, self.0.to_string()), - QobuzError::RateLimitExceeded => (StatusCode::TOO_MANY_REQUESTS, self.0.to_string()), - _ => (StatusCode::INTERNAL_SERVER_ERROR, self.0.to_string()), - }; - - let body = Json(serde_json::json!({ - "error": message - })); - - (status, body).into_response() - } -} - -#[cfg(feature = "pmoserver")] -impl From for AppError -where - E: Into, -{ - fn from(err: E) -> Self { - Self(err.into()) - } -} -========= End of pmoqobuz/src/api_rest.rs =========== - -=============== pmoqobuz/src/config_ext.rs ============ -//! Extension pour intégrer la configuration Qobuz dans pmoconfig -//! -//! Ce module fournit le trait `QobuzConfigExt` qui permet d'ajouter facilement -//! des méthodes de gestion des credentials Qobuz à pmoconfig::Config. - -use anyhow::{anyhow, Result}; -use pmoconfig::Config; -use serde_yaml::Value; - -/// Trait d'extension pour gérer la configuration Qobuz dans pmoconfig -/// -/// Ce trait étend `pmoconfig::Config` avec des méthodes spécifiques -/// aux credentials et paramètres Qobuz. -/// -/// # Exemple -/// -/// ```rust,ignore -/// use pmoconfig::get_config; -/// use pmoqobuz::QobuzConfigExt; -/// -/// let config = get_config(); -/// let (username, password) = config.get_qobuz_credentials()?; -/// println!("Qobuz user: {}", username); -/// ``` -pub trait QobuzConfigExt { - /// Récupère le nom d'utilisateur Qobuz depuis la configuration - /// - /// # Returns - /// - /// Le nom d'utilisateur (email) configuré pour Qobuz - /// - /// # Errors - /// - /// Retourne une erreur si le nom d'utilisateur n'est pas configuré - fn get_qobuz_username(&self) -> Result; - - /// Définit le nom d'utilisateur Qobuz dans la configuration - /// - /// # Arguments - /// - /// * `username` - Le nom d'utilisateur (email) Qobuz - fn set_qobuz_username(&self, username: &str) -> Result<()>; - - /// Récupère le mot de passe Qobuz depuis la configuration - /// - /// # Returns - /// - /// Le mot de passe configuré pour Qobuz - /// - /// # Errors - /// - /// Retourne une erreur si le mot de passe n'est pas configuré - fn get_qobuz_password(&self) -> Result; - - /// Définit le mot de passe Qobuz dans la configuration - /// - /// # Arguments - /// - /// * `password` - Le mot de passe Qobuz - fn set_qobuz_password(&self, password: &str) -> Result<()>; - - /// Récupère les credentials Qobuz (username et password) - /// - /// # Returns - /// - /// Un tuple (username, password) contenant les credentials Qobuz - /// - /// # Errors - /// - /// Retourne une erreur si l'un des credentials n'est pas configuré - /// - /// # Exemple - /// - /// ```rust,ignore - /// use pmoconfig::get_config; - /// use pmoqobuz::QobuzConfigExt; - /// - /// let config = get_config(); - /// match config.get_qobuz_credentials() { - /// Ok((username, password)) => { - /// println!("Credentials configured for: {}", username); - /// } - /// Err(e) => { - /// eprintln!("Qobuz credentials not configured: {}", e); - /// } - /// } - /// ``` - fn get_qobuz_credentials(&self) -> Result<(String, String)>; - - /// Récupère l'App ID Qobuz depuis la configuration - /// - /// # Returns - /// - /// L'App ID configuré pour Qobuz, ou None si non configuré - /// - /// # Note - /// - /// Si aucun App ID n'est configuré, le client utilisera soit le Spoofer - /// pour en obtenir un dynamiquement, soit un App ID par défaut. - fn get_qobuz_appid(&self) -> Result>; - - /// Définit l'App ID Qobuz dans la configuration - /// - /// # Arguments - /// - /// * `appid` - L'App ID Qobuz (ex: "1401488693436528") - fn set_qobuz_appid(&self, appid: &str) -> Result<()>; - - /// Récupère le secret Qobuz depuis la configuration - /// - /// # Returns - /// - /// Le secret encodé en base64, ou None si non configuré - /// - /// # Note - /// - /// Le secret est la valeur `configvalue` du code Python. - /// Il est décodé et XORé avec l'App ID pour obtenir le secret `s4` - /// utilisé pour signer les requêtes sensibles. - /// - /// Si aucun secret n'est configuré, le client utilisera le Spoofer - /// pour en obtenir un dynamiquement. - fn get_qobuz_secret(&self) -> Result>; - - /// Définit le secret Qobuz dans la configuration - /// - /// # Arguments - /// - /// * `secret` - Le secret encodé en base64 (configvalue) - fn set_qobuz_secret(&self, secret: &str) -> Result<()>; - - /// Récupère le token d'authentification depuis la configuration - /// - /// # Returns - /// - /// Le token d'authentification, ou None si non configuré ou expiré - fn get_qobuz_auth_token(&self) -> Result>; - - /// Récupère l'ID utilisateur depuis la configuration - /// - /// # Returns - /// - /// L'ID utilisateur, ou None si non configuré - fn get_qobuz_user_id(&self) -> Result>; - - /// Récupère le timestamp d'expiration du token - /// - /// # Returns - /// - /// Le timestamp d'expiration (Unix timestamp), ou None si non configuré - fn get_qobuz_token_expires_at(&self) -> Result>; - - /// Récupère le label de l'abonnement depuis la configuration - fn get_qobuz_subscription_label(&self) -> Result>; - - /// Sauvegarde les informations d'authentification dans la configuration - /// - /// # Arguments - /// - /// * `token` - Le token d'authentification - /// * `user_id` - L'ID utilisateur - /// * `subscription_label` - Le label de l'abonnement (optionnel) - /// * `expires_at` - Timestamp d'expiration (Unix timestamp) - fn set_qobuz_auth_info( - &self, - token: &str, - user_id: &str, - subscription_label: Option<&str>, - expires_at: u64, - ) -> Result<()>; - - /// Supprime les informations d'authentification de la configuration - fn clear_qobuz_auth_info(&self) -> Result<()>; - - /// Vérifie si le token d'authentification est encore valide - /// - /// # Returns - /// - /// true si un token existe et n'est pas expiré, false sinon - fn is_qobuz_auth_valid(&self) -> bool; - - /// Récupère le répertoire de cache Qobuz - /// - /// # Returns - /// - /// Le chemin absolu du répertoire de cache, créé s'il n'existe pas - fn get_qobuz_cache_dir(&self) -> Result; - - /// Définit le répertoire de cache Qobuz - fn set_qobuz_cache_dir(&self, directory: String) -> Result<()>; - - /// Récupère le nombre maximum de requêtes concurrentes - /// - /// # Returns - /// - /// Le nombre maximum de requêtes concurrentes, ou None si non configuré (défaut: 2) - fn get_qobuz_rate_limit_max_concurrent(&self) -> Result>; - - /// Définit le nombre maximum de requêtes concurrentes - fn set_qobuz_rate_limit_max_concurrent(&self, max: usize) -> Result<()>; - - /// Récupère le délai minimum entre requêtes en millisecondes - /// - /// # Returns - /// - /// Le délai minimum en ms, ou None si non configuré (défaut: 400ms) - fn get_qobuz_rate_limit_min_delay_ms(&self) -> Result>; - - /// Définit le délai minimum entre requêtes - fn set_qobuz_rate_limit_min_delay_ms(&self, delay_ms: u64) -> Result<()>; - - /// Vérifie si le rate limiting est activé - /// - /// # Returns - /// - /// true si activé (défaut), false sinon - fn is_qobuz_rate_limiting_enabled(&self) -> bool; - - /// Active ou désactive le rate limiting - fn set_qobuz_rate_limiting_enabled(&self, enabled: bool) -> Result<()>; -} - -impl QobuzConfigExt for Config { - fn get_qobuz_username(&self) -> Result { - match self.get_value(&["accounts", "qobuz", "username"])? { - Value::String(s) => Ok(s), - _ => Err(anyhow!("Qobuz username not configured")), - } - } - - fn set_qobuz_username(&self, username: &str) -> Result<()> { - self.set_value( - &["accounts", "qobuz", "username"], - Value::String(username.to_string()), - ) - } - - fn get_qobuz_password(&self) -> Result { - match self.get_value(&["accounts", "qobuz", "password"])? { - Value::String(s) => { - // Déchiffrement automatique si le mot de passe est chiffré - pmoconfig::encryption::get_password(&s) - .map_err(|e| anyhow!("Failed to decrypt password: {}", e)) - } - _ => Err(anyhow!("Qobuz password not configured")), - } - } - - fn set_qobuz_password(&self, password: &str) -> Result<()> { - self.set_value( - &["accounts", "qobuz", "password"], - Value::String(password.to_string()), - ) - } - - fn get_qobuz_credentials(&self) -> Result<(String, String)> { - let username = self.get_qobuz_username()?; - let password = self.get_qobuz_password()?; - Ok((username, password)) - } - - fn get_qobuz_appid(&self) -> Result> { - match self.get_value(&["accounts", "qobuz", "appid"]) { - Ok(Value::String(s)) if !s.is_empty() => Ok(Some(s)), - Ok(Value::String(_)) => Ok(None), // Empty string - Ok(_) => Ok(None), // Wrong type - Err(_) => Ok(None), // Not configured - } - } - - fn set_qobuz_appid(&self, appid: &str) -> Result<()> { - self.set_value( - &["accounts", "qobuz", "appid"], - Value::String(appid.to_string()), - ) - } - - fn get_qobuz_secret(&self) -> Result> { - match self.get_value(&["accounts", "qobuz", "secret"]) { - Ok(Value::String(s)) if !s.is_empty() => Ok(Some(s)), - Ok(Value::String(_)) => Ok(None), // Empty string - Ok(_) => Ok(None), // Wrong type - Err(_) => Ok(None), // Not configured - } - } - - fn set_qobuz_secret(&self, secret: &str) -> Result<()> { - self.set_value( - &["accounts", "qobuz", "secret"], - Value::String(secret.to_string()), - ) - } - - fn get_qobuz_auth_token(&self) -> Result> { - match self.get_value(&["accounts", "qobuz", "auth_token"]) { - Ok(Value::String(s)) if !s.is_empty() => Ok(Some(s)), - Ok(Value::String(_)) => Ok(None), // Empty string - Ok(_) => Ok(None), // Wrong type - Err(_) => Ok(None), // Not configured - } - } - - fn get_qobuz_user_id(&self) -> Result> { - match self.get_value(&["accounts", "qobuz", "user_id"]) { - Ok(Value::String(s)) if !s.is_empty() => Ok(Some(s)), - Ok(Value::String(_)) => Ok(None), // Empty string - Ok(_) => Ok(None), // Wrong type - Err(_) => Ok(None), // Not configured - } - } - - fn get_qobuz_token_expires_at(&self) -> Result> { - match self.get_value(&["accounts", "qobuz", "token_expires_at"]) { - Ok(Value::Number(n)) if n.is_u64() => Ok(Some(n.as_u64().unwrap())), - Ok(Value::Number(n)) if n.is_i64() => Ok(Some(n.as_i64().unwrap() as u64)), - Ok(_) => Ok(None), // Wrong type - Err(_) => Ok(None), // Not configured - } - } - - fn get_qobuz_subscription_label(&self) -> Result> { - match self.get_value(&["accounts", "qobuz", "subscription_label"]) { - Ok(Value::String(s)) if !s.is_empty() => Ok(Some(s)), - Ok(Value::String(_)) => Ok(None), // Empty string - Ok(_) => Ok(None), // Wrong type - Err(_) => Ok(None), // Not configured - } - } - - fn set_qobuz_auth_info( - &self, - token: &str, - user_id: &str, - subscription_label: Option<&str>, - expires_at: u64, - ) -> Result<()> { - self.set_value( - &["accounts", "qobuz", "auth_token"], - Value::String(token.to_string()), - )?; - self.set_value( - &["accounts", "qobuz", "user_id"], - Value::String(user_id.to_string()), - )?; - self.set_value( - &["accounts", "qobuz", "token_expires_at"], - Value::Number(serde_yaml::Number::from(expires_at)), - )?; - - if let Some(label) = subscription_label { - self.set_value( - &["accounts", "qobuz", "subscription_label"], - Value::String(label.to_string()), - )?; - } - - Ok(()) - } - - fn clear_qobuz_auth_info(&self) -> Result<()> { - // On ne propage pas les erreurs car les valeurs peuvent ne pas exister - let _ = self.set_value(&["accounts", "qobuz", "auth_token"], Value::String(String::new())); - let _ = self.set_value(&["accounts", "qobuz", "user_id"], Value::String(String::new())); - let _ = self.set_value( - &["accounts", "qobuz", "token_expires_at"], - Value::Number(serde_yaml::Number::from(0)), - ); - let _ = self.set_value( - &["accounts", "qobuz", "subscription_label"], - Value::String(String::new()), - ); - Ok(()) - } - - fn is_qobuz_auth_valid(&self) -> bool { - // Vérifier si un token existe - if self.get_qobuz_auth_token().ok().flatten().is_none() { - return false; - } - - // Vérifier si le token n'est pas expiré - if let Ok(Some(expires_at)) = self.get_qobuz_token_expires_at() { - use std::time::{SystemTime, UNIX_EPOCH}; - let now = SystemTime::now() - .duration_since(UNIX_EPOCH) - .unwrap() - .as_secs(); - - now < expires_at - } else { - false - } - } - - fn get_qobuz_cache_dir(&self) -> Result { - self.get_managed_dir(&["host", "qobuz_cache", "directory"], "cache_qobuz") - } - - fn set_qobuz_cache_dir(&self, directory: String) -> Result<()> { - self.set_managed_dir(&["host", "qobuz_cache", "directory"], directory) - } - - fn get_qobuz_rate_limit_max_concurrent(&self) -> Result> { - match self.get_value(&["accounts", "qobuz", "rate_limit", "max_concurrent"]) { - Ok(Value::Number(n)) if n.is_u64() => Ok(Some(n.as_u64().unwrap() as usize)), - Ok(_) => Ok(None), - Err(_) => Ok(Some(2)), // Default: 2 concurrent requests - } - } - - fn set_qobuz_rate_limit_max_concurrent(&self, max: usize) -> Result<()> { - self.set_value( - &["accounts", "qobuz", "rate_limit", "max_concurrent"], - Value::Number(serde_yaml::Number::from(max)), - ) - } - - fn get_qobuz_rate_limit_min_delay_ms(&self) -> Result> { - match self.get_value(&["accounts", "qobuz", "rate_limit", "min_delay_ms"]) { - Ok(Value::Number(n)) if n.is_u64() => Ok(Some(n.as_u64().unwrap())), - Ok(_) => Ok(None), - Err(_) => Ok(Some(400)), // Default: 400ms - } - } - - fn set_qobuz_rate_limit_min_delay_ms(&self, delay_ms: u64) -> Result<()> { - self.set_value( - &["accounts", "qobuz", "rate_limit", "min_delay_ms"], - Value::Number(serde_yaml::Number::from(delay_ms)), - ) - } - - fn is_qobuz_rate_limiting_enabled(&self) -> bool { - match self.get_value(&["accounts", "qobuz", "rate_limit", "enabled"]) { - Ok(Value::Bool(b)) => b, - _ => true, // Default: enabled - } - } - - fn set_qobuz_rate_limiting_enabled(&self, enabled: bool) -> Result<()> { - self.set_value( - &["accounts", "qobuz", "rate_limit", "enabled"], - Value::Bool(enabled), - ) - } -} -========= End of pmoqobuz/src/config_ext.rs =========== - -=============== pmoqobuz/src/pmoserver_impl.rs ============ -//! Implémentation du trait QobuzServerExt pour pmoserver::Server -//! -//! Ce module enrichit `pmoserver::Server` avec les fonctionnalités du client Qobuz en -//! implémentant le trait [`QobuzServerExt`](crate::QobuzServerExt). Cette implémentation -//! permet d'initialiser facilement le client Qobuz et d'enregistrer les routes HTTP. -//! -//! ## Architecture -//! -//! `pmoqobuz` étend `pmoserver::Server` sans que `pmoserver` connaisse `pmoqobuz`. -//! C'est le pattern d'extension : `pmoqobuz` ajoute des fonctionnalités à un type -//! externe via un trait, similaire au pattern utilisé par `pmocovers` pour `CoverCacheExt`. -//! -//! ## Exemple d'utilisation -//! -//! ```rust,no_run -//! use pmoqobuz::QobuzServerExt; -//! use pmoserver::ServerBuilder; -//! -//! # async fn example() -> anyhow::Result<()> { -//! let mut server = ServerBuilder::new_configured().build(); -//! -//! // Le trait QobuzServerExt est automatiquement disponible -//! let client = server.init_qobuz_client_configured().await?; -//! -//! server.start().await; -//! # Ok(()) -//! # } -//! ``` - -use crate::api_rest::{create_router, QobuzState}; -use crate::client::QobuzClient; -use crate::pmoserver_ext::QobuzServerExt; -use anyhow::Result; -use pmoconfig::Config; -use pmoserver::Server; -use std::sync::Arc; -use tracing::info; - -impl QobuzServerExt for Server { - async fn init_qobuz_client( - &mut self, - username: &str, - password: &str, - ) -> Result> { - info!("Initializing Qobuz client for user: {}", username); - - // Créer le client Qobuz - let client = QobuzClient::new(username, password).await?; - let client = Arc::new(client); - - // Créer l'état de l'API sans cache d'images - let state = QobuzState { - client: client.clone(), - #[cfg(feature = "covers")] - cover_cache: None, - }; - - // Créer le router et l'enregistrer - let router = create_router(state); - self.add_router("/qobuz", router).await; - - info!("Qobuz client initialized successfully"); - info!("API endpoints available at /qobuz/*"); - - Ok(client) - } - - async fn init_qobuz_client_configured(&mut self) -> Result> { - info!("Initializing Qobuz client from configuration"); - - // Récupérer les credentials depuis la config - let config = pmoconfig::get_config(); - let (username, password) = config.get_qobuz_credentials()?; - - self.init_qobuz_client(&username, &password).await - } - - #[cfg(feature = "covers")] - async fn init_qobuz_client_with_covers( - &mut self, - username: &str, - password: &str, - cover_cache: Arc, - ) -> Result> { - info!("Initializing Qobuz client with pmocovers integration"); - - // Créer le client Qobuz - let client = QobuzClient::new(username, password).await?; - let client = Arc::new(client); - - info!("pmocovers integration enabled - album images will be cached automatically"); - - // Créer l'état de l'API avec le cache - let state = QobuzState { - client: client.clone(), - cover_cache: Some(cover_cache), - }; - - // Créer le router et l'enregistrer - let router = create_router(state); - self.add_router("/qobuz", router).await; - - info!("Qobuz client initialized successfully with covers"); - info!("API endpoints available at /qobuz/*"); - - Ok(client) - } - - #[cfg(feature = "covers")] - async fn init_qobuz_client_configured_with_covers( - &mut self, - cover_cache: Arc, - ) -> Result> { - info!("Initializing Qobuz client from configuration with pmocovers"); - - // Récupérer les credentials depuis la config - let config = pmoconfig::get_config(); - let (username, password) = config.get_qobuz_credentials()?; - - self.init_qobuz_client_with_covers(&username, &password, cover_cache) - .await - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_trait_implemented() { - // Ce test vérifie simplement que le trait est bien implémenté - // Les tests fonctionnels nécessiteraient un serveur et des credentials réels - } -} -========= End of pmoqobuz/src/pmoserver_impl.rs =========== - -=============== pmoqobuz/src/api/spoofer.rs ============ -use anyhow::Result; -use base64::{engine::general_purpose::STANDARD, Engine}; -use indexmap::IndexMap; -use regex::Regex; -use reqwest::Client; - -pub struct Spoofer { - bundle: String, - seed_timezone_regex: Regex, - info_extras_regex_template: String, - app_id_regex: Regex, -} - -impl Spoofer { - /// Crée un nouveau Spoofer et télécharge le bundle.js - pub async fn new() -> Result { - // Expressions régulières (équivalent Python) - let seed_timezone_regex = Regex::new( - r#"[a-z]\.initialSeed\("(?P[\w=]+)",window\.utimezone\.(?P[a-z]+)\)"#, - )?; - - let info_extras_regex_template = - r#"name:"\w+/(?P{timezones})",info:"(?P[\w=]+)",extras:"(?P[\w=]+)""# - .to_string(); - - let app_id_regex = Regex::new( - r#"production:\{api:\{appId:"(?P\d{9})",appSecret:"(?P\w{32})"\},braze:.\(.\(\{\},.\),\{\},\{apiKey:"([-0-9a-fA-F]{36})"\}\),extra:.\}"#, - )?; - - // Créer un client HTTP - let client = Client::builder() - .user_agent("Mozilla/5.0 (compatible; PMOMusic/1.0)") - .build()?; - - println!("Récupération de la page de login..."); - let login_page = client - .get("https://play.qobuz.com/login") - .send() - .await? - .text() - .await?; - - // Extraire l'URL du bundle - let bundle_url_regex = - Regex::new(r#""#)?; - let bundle_url = bundle_url_regex - .captures(&login_page) - .and_then(|cap| cap.get(1)) - .ok_or_else(|| anyhow::anyhow!("Impossible de trouver l'URL du bundle"))? - .as_str(); - - println!("Téléchargement du bundle depuis: {}", bundle_url); - let bundle_full_url = format!("https://play.qobuz.com{}", bundle_url); - let bundle = client.get(&bundle_full_url).send().await?.text().await?; - - println!("Bundle téléchargé ({} bytes)", bundle.len()); - - Ok(Self { - bundle, - seed_timezone_regex, - info_extras_regex_template, - app_id_regex, - }) - } - - /// Extrait l'App ID depuis le bundle - pub fn get_app_id(&self) -> Result { - let captures = self - .app_id_regex - .captures(&self.bundle) - .ok_or_else(|| anyhow::anyhow!("AppID non trouvé dans le bundle"))?; - - Ok(captures - .name("app_id") - .ok_or_else(|| anyhow::anyhow!("Groupe app_id non trouvé"))? - .as_str() - .to_string()) - } - - /// Extrait les secrets depuis le bundle - pub fn get_secrets(&self) -> Result> { - // Étape 1: Extraire tous les seed/timezone pairs - let mut secrets: IndexMap> = IndexMap::new(); - - for captures in self.seed_timezone_regex.captures_iter(&self.bundle) { - let seed = captures - .name("seed") - .ok_or_else(|| anyhow::anyhow!("Groupe seed non trouvé"))? - .as_str(); - let timezone = captures - .name("timezone") - .ok_or_else(|| anyhow::anyhow!("Groupe timezone non trouvé"))? - .as_str(); - - secrets - .entry(timezone.to_string()) - .or_insert_with(Vec::new) - .push(seed.to_string()); - } - - println!("Timezones trouvées: {:?}", secrets.keys()); - - // Étape 2: Réordonner - on met la deuxième timezone en premier - // (comme le fait le code Python avec move_to_end) - if secrets.len() >= 2 { - let keys: Vec = secrets.keys().cloned().collect(); - let second_key = keys[1].clone(); - let second_value = secrets.get(&second_key).unwrap().clone(); - - // Retirer et réinsérer pour le mettre en premier - secrets.shift_remove(&second_key); - let mut new_secrets = IndexMap::new(); - new_secrets.insert(second_key, second_value); - for (k, v) in secrets { - new_secrets.insert(k, v); - } - secrets = new_secrets; - } - - // Étape 3: Construire la regex pour info/extras - let timezones_capitalized: Vec = secrets - .keys() - .map(|tz| { - let mut chars = tz.chars(); - match chars.next() { - None => String::new(), - Some(first) => first.to_uppercase().collect::() + chars.as_str(), - } - }) - .collect(); - - let info_extras_regex_str = self - .info_extras_regex_template - .replace("{timezones}", &timezones_capitalized.join("|")); - - let info_extras_regex = Regex::new(&info_extras_regex_str)?; - - // Étape 4: Extraire info et extras pour chaque timezone - for captures in info_extras_regex.captures_iter(&self.bundle) { - let timezone_cap = captures - .name("timezone") - .ok_or_else(|| anyhow::anyhow!("Groupe timezone non trouvé"))? - .as_str(); - let info = captures - .name("info") - .ok_or_else(|| anyhow::anyhow!("Groupe info non trouvé"))? - .as_str(); - let extras = captures - .name("extras") - .ok_or_else(|| anyhow::anyhow!("Groupe extras non trouvé"))? - .as_str(); - - let timezone_lower = timezone_cap.to_lowercase(); - if let Some(vec) = secrets.get_mut(&timezone_lower) { - vec.push(info.to_string()); - vec.push(extras.to_string()); - } - } - - // Étape 5: Décoder les secrets en base64 - let mut decoded_secrets = IndexMap::new(); - for (timezone, parts) in secrets { - let concatenated = parts.join(""); - - // Retirer les 44 derniers caractères (comme Python [:-44]) - if concatenated.len() > 44 { - let trimmed = &concatenated[..concatenated.len() - 44]; - - // Décoder en base64 - match STANDARD.decode(trimmed) { - Ok(decoded_bytes) => { - match String::from_utf8(decoded_bytes) { - Ok(decoded_str) => { - decoded_secrets.insert(timezone, decoded_str); - } - Err(e) => { - eprintln!( - "Erreur UTF-8 pour timezone {}: {}", - timezone, e - ); - } - } - } - Err(e) => { - eprintln!( - "Erreur de décodage base64 pour timezone {}: {}", - timezone, e - ); - } - } - } - } - - Ok(decoded_secrets) - } -} -========= End of pmoqobuz/src/api/spoofer.rs =========== - -=============== pmoqobuz/src/api/auth.rs ============ -//! Module d'authentification pour l'API Qobuz - -use super::QobuzApi; -use crate::error::{QobuzError, Result}; -use serde::{Deserialize, Serialize}; -use tracing::{debug, info}; - -/// Réponse de l'endpoint /user/login -#[derive(Debug, Deserialize)] -struct LoginResponse { - user: UserInfo, - user_auth_token: String, -} - -/// Informations utilisateur retournées par l'API -#[derive(Debug, Deserialize)] -struct UserInfo { - #[serde(deserialize_with = "crate::models::deserialize_id")] - id: String, - #[serde(default)] - email: Option, - #[serde(default)] - firstname: Option, - #[serde(default)] - lastname: Option, - credential: CredentialInfo, -} - -/// Informations sur les credentials de l'utilisateur -#[derive(Debug, Deserialize)] -struct CredentialInfo { - #[serde(default)] - parameters: Option, -} - -/// Paramètres du niveau d'abonnement -#[derive(Debug, Deserialize)] -struct CredentialParameters { - #[serde(default)] - short_label: Option, -} - -/// Informations d'authentification -#[derive(Debug, Clone, Serialize, Deserialize)] -pub struct AuthInfo { - /// Token d'authentification - pub token: String, - /// ID utilisateur - pub user_id: String, - /// Label de l'abonnement (ex: "Studio", "Hi-Fi", etc.) - pub subscription_label: Option, -} - -impl QobuzApi { - /// Authentifie l'utilisateur avec username et password - /// - /// # Arguments - /// - /// * `username` - Email ou nom d'utilisateur Qobuz - /// * `password` - Mot de passe - /// - /// # Returns - /// - /// Retourne les informations d'authentification si le login est réussi - /// - /// # Errors - /// - /// * `QobuzError::Unauthorized` - Credentials invalides - /// * `QobuzError::SubscriptionRequired` - Compte gratuit (non éligible) - pub async fn login(&mut self, username: &str, password: &str) -> Result { - info!("Attempting to login to Qobuz as {}", username); - - let params = [("username", username), ("password", password)]; - - let response: LoginResponse = self.post("/user/login", ¶ms).await?; - - // Vérifier que l'utilisateur a un abonnement valide - if response.user.credential.parameters.is_none() { - return Err(QobuzError::SubscriptionRequired( - "Free accounts are not eligible for streaming".to_string(), - )); - } - - let user_id = response.user.id; - let subscription_label = response - .user - .credential - .parameters - .and_then(|p| p.short_label); - - debug!( - "Login successful - User ID: {}, Subscription: {:?}", - user_id, subscription_label - ); - - // Stocker les informations d'authentification - self.set_auth_token(response.user_auth_token.clone(), user_id.clone()); - - Ok(AuthInfo { - token: response.user_auth_token, - user_id, - subscription_label, - }) - } - - /// Vérifie si le client est authentifié - pub fn is_authenticated(&self) -> bool { - self.user_auth_token.is_some() && self.user_id.is_some() - } - - /// Déconnecte l'utilisateur - pub fn logout(&mut self) { - debug!("Logging out"); - self.user_auth_token = None; - self.user_id = None; - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_is_authenticated() { - let mut api = QobuzApi::new("test_app_id").unwrap(); - assert!(!api.is_authenticated()); - - api.set_auth_token("token".to_string(), "user123".to_string()); - assert!(api.is_authenticated()); - - api.logout(); - assert!(!api.is_authenticated()); - } -} -========= End of pmoqobuz/src/api/auth.rs =========== - -=============== pmoqobuz/src/api/signing.rs ============ -//! Module de signature MD5 pour les requêtes Qobuz -//! -//! Certaines requêtes Qobuz (notamment track/getFileUrl et userLibrary/*) -//! nécessitent une signature MD5 incluant le secret s4. - -use md5::{Digest, Md5}; -use std::time::{SystemTime, UNIX_EPOCH}; - -/// Génère un timestamp Unix actuel -/// -/// # Returns -/// -/// Timestamp Unix sous forme de string avec décimales -/// -/// # Exemple -/// -/// ``` -/// use pmoqobuz::api::signing::get_timestamp; -/// let ts = get_timestamp(); -/// println!("Timestamp: {}", ts); -/// ``` -pub fn get_timestamp() -> String { - SystemTime::now() - .duration_since(UNIX_EPOCH) - .unwrap() - .as_secs_f64() - .to_string() -} - -/// Signe une requête track/getFileUrl -/// -/// Reproduit la logique Python: -/// ```python -/// stringvalue = ("trackgetFileUrlformat_id" + fmt_id + -/// "intent" + intent + -/// "track_id" + track_id + ts) -/// stringvalue += self.s4 -/// rq_sig = str(hashlib.md5(stringvalue).hexdigest()) -/// ``` -/// -/// # Arguments -/// -/// * `format_id` - ID du format audio (ex: "27") -/// * `intent` - Intention (typiquement "stream") -/// * `track_id` - ID de la track -/// * `timestamp` - Timestamp Unix -/// * `secret` - Secret s4 en bytes -/// -/// # Returns -/// -/// Signature MD5 hexadécimale -pub fn sign_track_get_file_url( - format_id: &str, - intent: &str, - track_id: &str, - timestamp: &str, - secret: &[u8], -) -> String { - let mut hasher = Md5::new(); - - // Construction de la chaîne à hasher - hasher.update(b"trackgetFileUrlformat_id"); - hasher.update(format_id.as_bytes()); - hasher.update(b"intent"); - hasher.update(intent.as_bytes()); - hasher.update(b"track_id"); - hasher.update(track_id.as_bytes()); - hasher.update(timestamp.as_bytes()); - hasher.update(secret); - - // Retourner le hash hexadécimal - format!("{:x}", hasher.finalize()) -} - -/// Signe une requête userLibrary/getAlbumsList -/// -/// Reproduit la logique Python: -/// ```python -/// r_sig = "userLibrarygetAlbumsList" + str(ts) + str(ka["sec"]) -/// r_sig_hashed = hashlib.md5(r_sig.encode("utf-8")).hexdigest() -/// ``` -/// -/// # Arguments -/// -/// * `timestamp` - Timestamp Unix -/// * `secret` - Secret s4 en bytes -/// -/// # Returns -/// -/// Signature MD5 hexadécimale -pub fn sign_userlib_get_albums(timestamp: &str, secret: &[u8]) -> String { - let mut hasher = Md5::new(); - - // Construction de la chaîne à hasher - hasher.update(b"userLibrarygetAlbumsList"); - hasher.update(timestamp.as_bytes()); - hasher.update(secret); - - // Retourner le hash hexadécimal - format!("{:x}", hasher.finalize()) -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_get_timestamp() { - let ts = get_timestamp(); - // Vérifier que c'est un nombre valide - assert!(ts.parse::().is_ok()); - // Vérifier que c'est proche du temps actuel (>= 2024) - assert!(ts.parse::().unwrap() > 1704067200.0); // 1er janvier 2024 - } - - #[test] - fn test_sign_track_get_file_url() { - let signature = sign_track_get_file_url( - "27", - "stream", - "12345", - "1234567890.123", - b"test_secret", - ); - - // Vérifier que c'est un hash MD5 valide (32 caractères hex) - assert_eq!(signature.len(), 32); - assert!(signature.chars().all(|c| c.is_ascii_hexdigit())); - } - - #[test] - fn test_sign_userlib_get_albums() { - let signature = sign_userlib_get_albums("1234567890.123", b"test_secret"); - - // Vérifier que c'est un hash MD5 valide (32 caractères hex) - assert_eq!(signature.len(), 32); - assert!(signature.chars().all(|c| c.is_ascii_hexdigit())); - } - - #[test] - fn test_signature_consistency() { - // La même entrée doit produire la même signature - let sig1 = sign_track_get_file_url("27", "stream", "123", "100", b"secret"); - let sig2 = sign_track_get_file_url("27", "stream", "123", "100", b"secret"); - assert_eq!(sig1, sig2); - - // Des entrées différentes doivent produire des signatures différentes - let sig3 = sign_track_get_file_url("6", "stream", "123", "100", b"secret"); - assert_ne!(sig1, sig3); - } -} -========= End of pmoqobuz/src/api/signing.rs =========== - -=============== pmoqobuz/src/api/catalog.rs ============ -//! Module d'accès au catalogue Qobuz (albums, tracks, artistes, playlists) - -use super::QobuzApi; -use crate::error::{QobuzError, Result}; -use crate::models::*; -use serde::Deserialize; -use tracing::debug; - -/// Réponse paginée de l'API -#[derive(Debug, Deserialize)] -struct PaginatedResponse { - items: Vec, - #[serde(default)] - total: Option, - #[serde(default)] - limit: Option, - #[serde(default)] - offset: Option, -} - -/// Réponse de l'endpoint /album/get -#[derive(Debug, Deserialize)] -pub(crate) struct AlbumResponse { - #[serde(deserialize_with = "crate::models::deserialize_id")] - id: String, - title: String, - artist: ArtistResponse, - #[serde(default)] - tracks_count: Option, - #[serde(default)] - duration: Option, - #[serde(default)] - release_date_original: Option, - #[serde(default)] - image: Option, - #[serde(default = "default_streamable")] - streamable: bool, - #[serde(default)] - description: Option, - #[serde(default)] - maximum_sampling_rate: Option, - #[serde(default)] - maximum_bit_depth: Option, - #[serde(default)] - genre: Option, - #[serde(default)] - label: Option, - #[serde(default)] - tracks: Option>, -} - -/// Réponse de l'endpoint /track/get -#[derive(Debug, Deserialize)] -pub(crate) struct TrackResponse { - #[serde(deserialize_with = "crate::models::deserialize_id")] - id: String, - title: String, - #[serde(default)] - performer: Option, - #[serde(default)] - artist: Option, - #[serde(default)] - album: Option, - duration: u32, - track_number: u32, - media_number: u32, - #[serde(default = "default_streamable")] - streamable: bool, -} - -/// Réponse artiste -#[derive(Debug, Deserialize)] -pub(crate) struct ArtistResponse { - #[serde(deserialize_with = "crate::models::deserialize_id")] - id: String, - name: String, - #[serde(default)] - image: Option, - #[serde(default)] - albums: Option>, -} - -/// Réponse image -#[derive(Debug, Deserialize)] -struct ImageResponse { - #[serde(default)] - large: Option, -} - -/// Réponse genre -#[derive(Debug, Deserialize)] -struct GenreResponse { - #[serde(default)] - id: Option, - name: String, -} - -/// Réponse label -#[derive(Debug, Deserialize)] -struct LabelResponse { - name: String, -} - -/// Réponse playlist -#[derive(Debug, Deserialize)] -pub(crate) struct PlaylistResponse { - #[serde(deserialize_with = "crate::models::deserialize_id")] - id: String, - name: String, - #[serde(default)] - description: Option, - #[serde(default)] - tracks_count: Option, - #[serde(default)] - duration: Option, - #[serde(default)] - images300: Option>, - #[serde(default)] - is_public: bool, - #[serde(default)] - owner: Option, - #[serde(default)] - tracks: Option>, -} - -/// Réponse propriétaire -#[derive(Debug, Deserialize)] -struct OwnerResponse { - #[serde(deserialize_with = "crate::models::deserialize_id")] - id: String, - name: String, -} - -/// Réponse genres list -#[derive(Debug, Deserialize)] -struct GenresResponse { - genres: PaginatedResponse, -} - -/// Réponse albums featured -#[derive(Debug, Deserialize)] -struct FeaturedAlbumsResponse { - albums: PaginatedResponse, -} - -/// Réponse playlists featured -#[derive(Debug, Deserialize)] -struct FeaturedPlaylistsResponse { - playlists: PaginatedResponse, -} - -/// Réponse search -#[derive(Debug, Deserialize)] -struct SearchResponse { - #[serde(default)] - albums: Option>, - #[serde(default)] - artists: Option>, - #[serde(default)] - tracks: Option>, - #[serde(default)] - playlists: Option>, -} - -/// Réponse track file URL -#[derive(Debug, Deserialize)] -struct FileUrlResponse { - url: String, - mime_type: String, - sampling_rate: u32, - bit_depth: u32, - format_id: u8, -} - -fn default_streamable() -> bool { - true -} - -impl QobuzApi { - /// Récupère les détails d'un album - pub async fn get_album(&self, album_id: &str) -> Result { - debug!("Fetching album {}", album_id); - let params = [("album_id", album_id)]; - let response: AlbumResponse = self.get("/album/get", ¶ms).await?; - Ok(Self::parse_album(response)) - } - - /// Récupère les tracks d'un album - pub async fn get_album_tracks(&self, album_id: &str) -> Result> { - debug!("Fetching tracks for album {}", album_id); - let params = [("album_id", album_id)]; - let mut response: AlbumResponse = self.get("/album/get", ¶ms).await?; - - if let Some(tracks) = response.tracks.take() { - let album = Self::parse_album(response); - Ok(tracks - .items - .into_iter() - .map(|t| Self::parse_track(t, Some(album.clone()))) - .collect()) - } else { - Ok(Vec::new()) - } - } - - /// Récupère les détails d'une track - pub async fn get_track(&self, track_id: &str) -> Result { - debug!("Fetching track {}", track_id); - let params = [("track_id", track_id)]; - let response: TrackResponse = self.get("/track/get", ¶ms).await?; - Ok(Self::parse_track(response, None)) - } - - /// Récupère l'URL de streaming d'une track - /// - /// Cette méthode nécessite un secret s4 pour signer la requête. - /// Si aucun secret n'est configuré, retourne une erreur. - /// - /// # Errors - /// - /// Retourne `QobuzError::Configuration` si le secret n'est pas configuré. - pub async fn get_file_url(&self, track_id: &str) -> Result { - use super::signing; - - debug!("Fetching file URL for track {}", track_id); - - // Vérifier que le secret est disponible - let secret = self - .secret().await - .ok_or_else(|| { - QobuzError::Configuration( - "Secret not configured. Cannot sign track/getFileUrl request.".to_string(), - ) - })?; - - let format_id = self.format_id.id().to_string(); - let intent = "stream"; - let timestamp = signing::get_timestamp(); - - // Signer la requête (comme Python: track_getFileUrl) - let signature = signing::sign_track_get_file_url( - &format_id, - intent, - track_id, - ×tamp, - &secret, - ); - - debug!( - "Signing track/getFileUrl: track_id={}, format_id={}, ts={}", - track_id, format_id, timestamp - ); - - // Construire les paramètres signés - let params = [ - ("track_id", track_id), - ("format_id", format_id.as_str()), - ("intent", intent), - ("request_ts", timestamp.as_str()), - ("request_sig", signature.as_str()), - ]; - - // Utiliser GET (comme Python après sept 2024 selon le commentaire) - let response: FileUrlResponse = self.get("/track/getFileUrl", ¶ms).await?; - - Ok(StreamInfo { - url: response.url, - mime_type: response.mime_type, - sampling_rate: response.sampling_rate, - bit_depth: response.bit_depth, - format_id: response.format_id, - expires_at: chrono::Utc::now() + chrono::Duration::minutes(5), - }) - } - - /// Récupère les albums d'un artiste - pub async fn get_artist_albums(&self, artist_id: &str) -> Result> { - debug!("Fetching albums for artist {}", artist_id); - let params = [("artist_id", artist_id), ("extra", "albums")]; - let response: ArtistResponse = self.get("/artist/get", ¶ms).await?; - - if let Some(albums) = response.albums { - Ok(albums - .items - .into_iter() - .map(Self::parse_album) - .filter(|a| a.streamable) - .collect()) - } else { - Ok(Vec::new()) - } - } - - /// Récupère les artistes similaires - pub async fn get_similar_artists(&self, artist_id: &str) -> Result> { - debug!("Fetching similar artists for {}", artist_id); - let params = [("artist_id", artist_id)]; - - #[derive(Debug, Deserialize)] - struct SimilarArtistsResponse { - artists: PaginatedResponse, - } - - let response: SimilarArtistsResponse = - self.get("/artist/getSimilarArtists", ¶ms).await?; - Ok(response - .artists - .items - .into_iter() - .map(Self::parse_artist) - .collect()) - } - - /// Récupère les détails d'une playlist - pub async fn get_playlist(&self, playlist_id: &str) -> Result { - debug!("Fetching playlist {}", playlist_id); - let params = [("playlist_id", playlist_id)]; - let response: PlaylistResponse = self.get("/playlist/get", ¶ms).await?; - Ok(Self::parse_playlist(response)) - } - - /// Récupère les tracks d'une playlist - pub async fn get_playlist_tracks(&self, playlist_id: &str) -> Result> { - debug!("Fetching tracks for playlist {}", playlist_id); - let params = [("playlist_id", playlist_id), ("extra", "tracks")]; - let response: PlaylistResponse = self.get("/playlist/get", ¶ms).await?; - - if let Some(tracks) = response.tracks { - Ok(tracks - .items - .into_iter() - .map(|t| Self::parse_track(t, None)) - .collect()) - } else { - Ok(Vec::new()) - } - } - - /// Récupère la liste des genres - pub async fn get_genres(&self) -> Result> { - debug!("Fetching genres"); - let response: GenresResponse = self.get("/genre/list", &[]).await?; - Ok(response - .genres - .items - .into_iter() - .map(Self::parse_genre) - .collect()) - } - - /// Récupère les albums featured (nouveautés, éditeur, etc.) - pub async fn get_featured_albums( - &self, - genre_id: Option<&str>, - type_: &str, - ) -> Result> { - debug!("Fetching featured albums (type: {})", type_); - let mut params = vec![("type", type_), ("limit", "100")]; - - if let Some(gid) = genre_id { - params.push(("genre_ids", gid)); - } - - let response: FeaturedAlbumsResponse = self.get("/album/getFeatured", ¶ms).await?; - Ok(response - .albums - .items - .into_iter() - .map(Self::parse_album) - .filter(|a| a.streamable) - .collect()) - } - - /// Récupère les playlists featured - pub async fn get_featured_playlists( - &self, - genre_id: Option<&str>, - tags: Option<&str>, - ) -> Result> { - debug!("Fetching featured playlists"); - let mut params = vec![("type", "editor-picks"), ("limit", "100")]; - - if let Some(gid) = genre_id { - params.push(("genre_ids", gid)); - } - if let Some(t) = tags { - params.push(("tags", t)); - } - - let response: FeaturedPlaylistsResponse = - self.get("/playlist/getFeatured", ¶ms).await?; - Ok(response - .playlists - .items - .into_iter() - .map(Self::parse_playlist) - .collect()) - } - - /// Recherche dans le catalogue - pub async fn search(&self, query: &str, type_: Option<&str>) -> Result { - debug!("Searching for '{}' (type: {:?})", query, type_); - let mut params = vec![("query", query), ("limit", "200")]; - - if let Some(t) = type_ { - params.push(("type", t)); - } - - let response: SearchResponse = self.get("/catalog/search", ¶ms).await?; - - Ok(SearchResult { - albums: response - .albums - .map(|a| { - a.items - .into_iter() - .map(Self::parse_album) - .filter(|album| album.streamable) - .collect() - }) - .unwrap_or_default(), - artists: response - .artists - .map(|a| a.items.into_iter().map(Self::parse_artist).collect()) - .unwrap_or_default(), - tracks: response - .tracks - .map(|t| { - t.items - .into_iter() - .map(|track| Self::parse_track(track, None)) - .filter(|track| track.streamable) - .collect() - }) - .unwrap_or_default(), - playlists: response - .playlists - .map(|p| p.items.into_iter().map(Self::parse_playlist).collect()) - .unwrap_or_default(), - }) - } - - // Fonctions de parsing publiques (utilisées aussi par le module user) - - pub(crate) fn parse_album(response: AlbumResponse) -> Album { - Album { - id: response.id, - title: response.title, - artist: Self::parse_artist(response.artist), - tracks_count: response.tracks_count, - duration: response.duration, - release_date: response.release_date_original, - image: response.image.and_then(|i| i.large), - image_cached: None, - streamable: response.streamable, - description: response.description, - maximum_sampling_rate: response.maximum_sampling_rate, - maximum_bit_depth: response.maximum_bit_depth, - genres: response.genre.map(|g| vec![g.name]).unwrap_or_default(), - label: response.label.map(|l| l.name), - } - } - - pub(crate) fn parse_track(response: TrackResponse, album: Option) -> Track { - let performer = response - .performer - .or(response.artist) - .map(Self::parse_artist); - - let album = album.or_else(|| response.album.map(Self::parse_album)); - - Track { - id: response.id, - title: response.title, - performer, - album, - duration: response.duration, - track_number: response.track_number, - media_number: response.media_number, - streamable: response.streamable, - mime_type: None, - sample_rate: None, - bit_depth: None, - channels: None, - } - } - - pub(crate) fn parse_artist(response: ArtistResponse) -> Artist { - Artist { - id: response.id, - name: response.name, - image: response.image.and_then(|i| i.large), - image_cached: None, - } - } - - pub(crate) fn parse_playlist(response: PlaylistResponse) -> Playlist { - Playlist { - id: response.id, - name: response.name, - description: response.description, - tracks_count: response.tracks_count, - duration: response.duration, - image: response.images300.and_then(|imgs| imgs.first().cloned()), - image_cached: None, - is_public: response.is_public, - owner: response.owner.map(|o| PlaylistOwner { - id: o.id.parse().unwrap_or(0), - name: o.name, - }), - } - } - - pub(crate) fn parse_genre(response: GenreResponse) -> Genre { - Genre { - id: response.id, - name: response.name, - children: Vec::new(), - } - } -} -========= End of pmoqobuz/src/api/catalog.rs =========== - -=============== pmoqobuz/src/api/user.rs ============ -//! Module d'accès aux données utilisateur (favoris) - -use super::catalog::{AlbumResponse, ArtistResponse, PlaylistResponse, TrackResponse}; -use super::QobuzApi; -use crate::error::{QobuzError, Result}; -use crate::models::*; -use serde::Deserialize; -use tracing::debug; - -/// Réponse paginée -#[derive(Debug, Deserialize)] -struct PaginatedResponse { - items: Vec, -} - -/// Réponse de l'endpoint /favorite/getUserFavorites -#[derive(Debug, Deserialize)] -struct FavoritesResponse { - #[serde(default)] - albums: Option>, - #[serde(default)] - artists: Option>, - #[serde(default)] - tracks: Option>, -} - -/// Réponse de l'endpoint /playlist/getUserPlaylists -#[derive(Debug, Deserialize)] -struct UserPlaylistsResponse { - playlists: PaginatedResponse, -} - -impl QobuzApi { - /// Vérifie que l'utilisateur est authentifié - fn ensure_authenticated(&self) -> Result<&str> { - self.user_id - .as_deref() - .ok_or_else(|| QobuzError::Unauthorized("Not authenticated".to_string())) - } - - /// Récupère les albums favoris de l'utilisateur - pub async fn get_favorite_albums(&self) -> Result> { - let user_id = self.ensure_authenticated()?; - debug!("Fetching favorite albums for user {}", user_id); - - let params = [("user_id", user_id), ("type", "albums"), ("limit", "1000")]; - - let response: FavoritesResponse = self.get("/favorite/getUserFavorites", ¶ms).await?; - - if let Some(albums) = response.albums { - Ok(albums - .items - .into_iter() - .map(QobuzApi::parse_album) - .filter(|a| a.streamable) - .collect()) - } else { - Ok(Vec::new()) - } - } - - /// Récupère les artistes favoris de l'utilisateur - pub async fn get_favorite_artists(&self) -> Result> { - let user_id = self.ensure_authenticated()?; - debug!("Fetching favorite artists for user {}", user_id); - - let params = [("user_id", user_id), ("type", "artists"), ("limit", "1000")]; - - let response: FavoritesResponse = self.get("/favorite/getUserFavorites", ¶ms).await?; - - if let Some(artists) = response.artists { - Ok(artists - .items - .into_iter() - .map(QobuzApi::parse_artist) - .collect()) - } else { - Ok(Vec::new()) - } - } - - /// Récupère les tracks favorites de l'utilisateur - pub async fn get_favorite_tracks(&self) -> Result> { - let user_id = self.ensure_authenticated()?; - debug!("Fetching favorite tracks for user {}", user_id); - - let params = [("user_id", user_id), ("type", "tracks"), ("limit", "1000")]; - - let response: FavoritesResponse = self.get("/favorite/getUserFavorites", ¶ms).await?; - - if let Some(tracks) = response.tracks { - Ok(tracks - .items - .into_iter() - .map(|t| QobuzApi::parse_track(t, None)) - .filter(|t| t.streamable) - .collect()) - } else { - Ok(Vec::new()) - } - } - - /// Récupère les playlists de l'utilisateur - pub async fn get_user_playlists(&self) -> Result> { - let user_id = self.ensure_authenticated()?; - debug!("Fetching playlists for user {}", user_id); - - let params = [("user_id", user_id), ("limit", "1000")]; - - let response: UserPlaylistsResponse = - self.get("/playlist/getUserPlaylists", ¶ms).await?; - - Ok(response - .playlists - .items - .into_iter() - .map(QobuzApi::parse_playlist) - .collect()) - } - - /// Ajoute un album aux favoris - pub async fn add_favorite_album(&self, album_id: &str) -> Result<()> { - let user_id = self.ensure_authenticated()?; - debug!( - "Adding album {} to favorites for user {}", - album_id, user_id - ); - - let params = [("album_id", album_id), ("user_id", user_id)]; - - self.get::("/favorite/create", ¶ms) - .await?; - Ok(()) - } - - /// Supprime un album des favoris - pub async fn remove_favorite_album(&self, album_id: &str) -> Result<()> { - let user_id = self.ensure_authenticated()?; - debug!( - "Removing album {} from favorites for user {}", - album_id, user_id - ); - - let params = [("album_ids", album_id), ("user_id", user_id)]; - - self.get::("/favorite/delete", ¶ms) - .await?; - Ok(()) - } - - /// Ajoute un track aux favoris - pub async fn add_favorite_track(&self, track_id: &str) -> Result<()> { - let user_id = self.ensure_authenticated()?; - debug!( - "Adding track {} to favorites for user {}", - track_id, user_id - ); - - let params = [("track_id", track_id), ("user_id", user_id)]; - - self.get::("/favorite/create", ¶ms) - .await?; - Ok(()) - } - - /// Supprime un track des favoris - pub async fn remove_favorite_track(&self, track_id: &str) -> Result<()> { - let user_id = self.ensure_authenticated()?; - debug!( - "Removing track {} from favorites for user {}", - track_id, user_id - ); - - let params = [("track_ids", track_id), ("user_id", user_id)]; - - self.get::("/favorite/delete", ¶ms) - .await?; - Ok(()) - } - - /// Ajoute un track à une playlist - pub async fn add_to_playlist(&self, playlist_id: &str, track_id: &str) -> Result<()> { - let user_id = self.ensure_authenticated()?; - debug!( - "Adding track {} to playlist {} for user {}", - track_id, playlist_id, user_id - ); - - let params = [("playlist_id", playlist_id), ("track_ids", track_id)]; - - self.get::("/playlist/addTracks", ¶ms) - .await?; - Ok(()) - } - - /// Récupère la liste des albums de la bibliothèque utilisateur - /// - /// Cette méthode nécessite un secret s4 pour signer la requête. - /// Elle est principalement utilisée pour tester la validité d'un secret. - /// - /// Dans le code Python, cette méthode est utilisée par `setSec()` pour - /// tester chaque secret retourné par le Spoofer. - /// - /// # Errors - /// - /// Retourne `QobuzError::Configuration` si le secret n'est pas configuré. - /// Retourne `QobuzError::Unauthorized` si l'utilisateur n'est pas authentifié. - pub async fn userlib_get_albums(&self) -> Result { - use super::signing; - - // Vérifier l'authentification - self.ensure_authenticated()?; - - // Vérifier que le secret est disponible - let secret = self - .secret().await - .ok_or_else(|| { - QobuzError::Configuration( - "Secret not configured. Cannot sign userLibrary/getAlbumsList request." - .to_string(), - ) - })?; - - let timestamp = signing::get_timestamp(); - - // Signer la requête (comme Python: userlib_getAlbums) - let signature = signing::sign_userlib_get_albums(×tamp, &secret); - - debug!( - "Signing userLibrary/getAlbumsList: app_id={}, ts={}", - self.app_id(), - timestamp - ); - - // Construire les paramètres signés - let user_auth_token = self - .auth_token() - .ok_or_else(|| QobuzError::Unauthorized("No auth token".to_string()))?; - - let params = [ - ("app_id", self.app_id()), - ("user_auth_token", user_auth_token), - ("request_ts", timestamp.as_str()), - ("request_sig", signature.as_str()), - ]; - - // Utiliser POST (comme Python) - self.post("/userLibrary/getAlbumsList", ¶ms).await - } - - /// Teste si un secret est valide en essayant de récupérer les albums - /// - /// Cette méthode est équivalente au test fait dans `setSec()` en Python. - /// Elle retourne `true` si le secret fonctionne, `false` sinon. - pub async fn test_secret(&self, _secret: &[u8]) -> bool { - // Sauvegarder le secret actuel - let _current_secret = self.secret().await; - - // Définir temporairement le nouveau secret - // Note: cette méthode nécessite &mut self, donc on doit la rendre mutable - // Pour l'instant, on ne peut pas modifier self dans cette méthode - // TODO: Refactoriser pour permettre de tester les secrets - - // Restaurer le secret original - false - } -} -========= End of pmoqobuz/src/api/user.rs =========== - -=============== pmoqobuz/src/api/mod.rs ============ -//! Couche d'accès à l'API REST Qobuz -//! -//! Ce module fournit une interface bas-niveau pour communiquer avec l'API Qobuz. - -pub mod auth; -pub mod catalog; -pub mod signing; -pub mod spoofer; -pub mod user; - -use crate::error::{QobuzError, Result}; -use crate::models::AudioFormat; -use reqwest::{Client, Response}; -use serde::de::DeserializeOwned; -use serde_json::Value; -use std::sync::Arc; -use std::time::{Duration, Instant}; -use tracing::{debug, warn}; - -pub use spoofer::Spoofer; - -/// URL de base de l'API Qobuz -const API_BASE_URL: &str = "https://www.qobuz.com/api.json/0.2"; - -/// App ID Qobuz par défaut -/// -/// Cet App ID est un fallback au cas où : -/// - Aucun appID n'est configuré dans pmoconfig -/// - Le Spoofer n'est pas disponible ou échoue -/// -/// Note: Cet App ID peut devenir obsolète avec le temps. -/// Il est recommandé d'utiliser soit la configuration manuelle, -/// soit le Spoofer pour obtenir un App ID à jour. -pub const DEFAULT_APP_ID: &str = "1401488693436528"; - -/// Client API bas-niveau pour communiquer avec Qobuz -pub struct QobuzApi { - /// Client HTTP - client: Client, - /// App ID pour l'authentification - app_id: String, - /// Secret s4 pour signer les requêtes sensibles (track/getFileUrl, userLibrary/*) - /// - /// Ce secret est obtenu soit : - /// - En décodant un `configvalue` (base64) et XOR avec l'app_id - /// - Depuis le Spoofer (secrets dynamiques) - /// - /// Utilise Arc pour permettre le refresh automatique en cas d'erreur de signature - secret: Arc>>>, - /// Token d'authentification utilisateur - user_auth_token: Option, - /// ID utilisateur - user_id: Option, - /// Format audio par défaut - format_id: AudioFormat, - /// Rate limiter: Semaphore for max concurrent requests - rate_limiter: Option>, - /// Last request timestamp (for minimum delay) - last_request: Arc>, - /// Minimum delay between requests (milliseconds) - min_delay_ms: u64, -} - -impl QobuzApi { - /// Crée une nouvelle instance de l'API - pub fn new(app_id: impl Into) -> Result { - let client = Client::builder() - .timeout(Duration::from_secs(30)) - .user_agent( - "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:67.0) Gecko/20100101 Firefox/67.0", - ) - .build()?; - - Ok(Self { - client, - app_id: app_id.into(), - secret: Arc::new(tokio::sync::RwLock::new(None)), - user_auth_token: None, - user_id: None, - format_id: AudioFormat::default(), - rate_limiter: None, - last_request: Arc::new(tokio::sync::Mutex::new(std::time::Instant::now())), - min_delay_ms: 0, - }) - } - - /// Crée une API avec un secret depuis configvalue (base64) - /// - /// # Arguments - /// - /// * `app_id` - App ID Qobuz - /// * `configvalue` - Secret encodé en base64 (à XORer avec l'app_id) - /// - /// # Note - /// - /// Cette méthode reproduit le comportement Python de `__set_s4()`. - /// Le configvalue est décodé depuis base64, puis XORé avec l'app_id - /// pour obtenir le secret s4. - pub async fn with_secret(app_id: impl Into, configvalue: &str) -> Result { - let api = Self::new(app_id)?; - api.set_secret_from_configvalue(configvalue).await?; - Ok(api) - } - - /// Définit le secret s4 directement - /// - /// # Arguments - /// - /// * `secret` - Secret s4 en bytes (déjà décodé et dérivé) - pub async fn set_secret(&self, secret: Vec) { - *self.secret.write().await = Some(secret); - } - - /// Dérive et définit le secret s4 depuis un configvalue - /// - /// Reproduit la logique Python de `__set_s4()`: - /// 1. Décode le configvalue depuis base64 - /// 2. XOR avec l'app_id - /// 3. Stocke le résultat comme secret s4 - async fn set_secret_from_configvalue(&self, configvalue: &str) -> Result<()> { - use base64::{engine::general_purpose::STANDARD, Engine}; - - // Décoder le configvalue depuis base64 - let s3s = STANDARD - .decode(configvalue.trim()) - .map_err(|e| QobuzError::Configuration(format!("Invalid configvalue: {}", e)))?; - - // XOR avec l'app_id - let app_id_bytes = self.app_id.as_bytes(); - let mut s4 = Vec::with_capacity(s3s.len()); - - for (i, &byte) in s3s.iter().enumerate() { - let app_byte = app_id_bytes[i % app_id_bytes.len()]; - s4.push(byte ^ app_byte); - } - - *self.secret.write().await = Some(s4); - Ok(()) - } - - /// Retourne le secret s4 si disponible - pub async fn secret(&self) -> Option> { - self.secret.read().await.clone() - } - - /// Définit le token d'authentification - pub fn set_auth_token(&mut self, token: String, user_id: String) { - self.user_auth_token = Some(token); - self.user_id = Some(user_id); - } - - /// Définit le format audio par défaut - pub fn set_format(&mut self, format: AudioFormat) { - self.format_id = format; - } - - /// Retourne le format audio configuré - pub fn format(&self) -> AudioFormat { - self.format_id - } - - /// Retourne l'App ID - pub fn app_id(&self) -> &str { - &self.app_id - } - - /// Retourne le token d'authentification si disponible - pub fn auth_token(&self) -> Option<&str> { - self.user_auth_token.as_deref() - } - - /// Retourne l'ID utilisateur si disponible - pub fn user_id(&self) -> Option<&str> { - self.user_id.as_deref() - } - - /// Enable rate limiting with configurable parameters - /// - /// # Arguments - /// - /// * `max_concurrent` - Maximum number of concurrent requests - /// * `min_delay_ms` - Minimum delay between requests in milliseconds - /// - /// # Example - /// - /// ```ignore - /// api.enable_rate_limiting(2, 400); // Max 2 concurrent, 400ms delay - /// ``` - pub fn enable_rate_limiting(&mut self, max_concurrent: usize, min_delay_ms: u64) { - self.rate_limiter = Some(Arc::new(tokio::sync::Semaphore::new(max_concurrent))); - self.min_delay_ms = min_delay_ms; - debug!( - "Rate limiting enabled: {} concurrent requests, {}ms min delay", - max_concurrent, min_delay_ms - ); - } - - /// Check if rate limiting is enabled - pub fn is_rate_limiting_enabled(&self) -> bool { - self.rate_limiter.is_some() - } - - /// Effectue une requête GET à l'API - pub(crate) async fn get( - &self, - endpoint: &str, - params: &[(&str, &str)], - ) -> Result { - self.request("GET", endpoint, params).await - } - - /// Effectue une requête POST à l'API - pub(crate) async fn post( - &self, - endpoint: &str, - params: &[(&str, &str)], - ) -> Result { - self.request("POST", endpoint, params).await - } - - /// Effectue une requête à l'API (générique) - async fn request( - &self, - method: &str, - endpoint: &str, - params: &[(&str, &str)], - ) -> Result { - let url = format!("{}{}", API_BASE_URL, endpoint); - - // ===== RATE LIMITING LOGIC ===== - let _permit = if let Some(ref limiter) = self.rate_limiter { - // 1. Acquire semaphore permit (blocks if max concurrent reached) - let permit = limiter - .acquire() - .await - .map_err(|e| QobuzError::Other(format!("Rate limiter error: {}", e)))?; - - // 2. Enforce minimum delay - if self.min_delay_ms > 0 { - let mut last = self.last_request.lock().await; - let elapsed = last.elapsed(); - let min_delay = Duration::from_millis(self.min_delay_ms); - - if elapsed < min_delay { - let wait_time = min_delay - elapsed; - debug!("Rate limiting: waiting {:?} before request", wait_time); - tokio::time::sleep(wait_time).await; - } - - *last = Instant::now(); - } - - Some(permit) // Keep permit alive until request completes - } else { - None - }; - // ===== END RATE LIMITING ===== - - debug!("{} {} with {} params", method, url, params.len()); - - let mut request = if method == "GET" { - self.client.get(&url) - } else { - self.client.post(&url) - }; - - // Ajouter les headers - request = request.header("X-App-Id", &self.app_id); - - if let Some(ref token) = self.user_auth_token { - request = request.header("X-User-Auth-Token", token); - } - - // Ajouter les paramètres - if method == "GET" { - request = request.query(params); - } else { - request = request.form(params); - } - - // Envoyer la requête - let response = request.send().await?; - self.handle_response(response).await - } - - /// Traite la réponse HTTP - async fn handle_response(&self, response: Response) -> Result { - let status = response.status(); - let status_code = status.as_u16(); - - debug!("Response status: {}", status); - - if !status.is_success() { - let error_text = response.text().await.unwrap_or_default(); - warn!("API error ({}): {}", status_code, error_text); - return Err(QobuzError::from_status_code(status_code, error_text)); - } - - let text = response.text().await?; - - // Vérifier si la réponse contient une erreur Qobuz - if let Ok(json) = serde_json::from_str::(&text) { - if let Some(status_obj) = json.get("status") { - if status_obj == "error" { - let message = json - .get("message") - .and_then(|m| m.as_str()) - .unwrap_or("Unknown error"); - warn!("Qobuz API error: {}", message); - return Err(QobuzError::ApiError { - code: status_code, - message: message.to_string(), - }); - } - } - } - - // Parser la réponse - serde_json::from_str(&text).map_err(|e| { - warn!("Failed to parse response: {}", e); - QobuzError::JsonParse(e) - }) - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_api_creation() { - let api = QobuzApi::new("test_app_id").unwrap(); - assert_eq!(api.app_id(), "test_app_id"); - assert!(api.auth_token().is_none()); - } - - #[test] - fn test_set_auth_token() { - let mut api = QobuzApi::new("test_app_id").unwrap(); - api.set_auth_token("test_token".to_string(), "user123".to_string()); - assert_eq!(api.auth_token(), Some("test_token")); - assert_eq!(api.user_id(), Some("user123")); - } - - #[test] - fn test_set_format() { - let mut api = QobuzApi::new("test_app_id").unwrap(); - api.set_format(AudioFormat::Flac_HiRes_96); - assert_eq!(api.format(), AudioFormat::Flac_HiRes_96); - } -} -========= End of pmoqobuz/src/api/mod.rs =========== - -=============== pmoqobuz/src/pmoserver_ext.rs ============ -//! Extension de pmoserver::Server pour intégrer le client Qobuz -//! -//! Ce module fournit un trait d'extension permettant d'ajouter facilement -//! le client Qobuz et ses endpoints à un serveur pmoserver. - -use crate::client::QobuzClient; -use anyhow::Result; -use std::sync::Arc; - -/// Trait d'extension pour ajouter le support Qobuz à un serveur pmoserver -/// -/// Ce trait permet à `pmoqobuz` d'ajouter des méthodes d'extension sur -/// `pmoserver::Server` sans que pmoserver dépende de pmoqobuz. -/// -/// # Architecture -/// -/// Similaire au pattern utilisé par `pmocovers` avec `CoverCacheExt`, ce trait permet -/// une extension propre et découplée : -/// -/// - `pmoserver` définit un serveur HTTP générique -/// - `pmoqobuz` étend ce serveur avec des fonctionnalités Qobuz via ce trait -/// - Le serveur n'a pas besoin de connaître `pmoqobuz` -/// -/// # Exemple -/// -/// ```rust,no_run -/// use pmoqobuz::QobuzServerExt; -/// use pmoserver::ServerBuilder; -/// -/// #[tokio::main] -/// async fn main() -> anyhow::Result<()> { -/// let mut server = ServerBuilder::new_configured().build(); -/// -/// // Initialise le client Qobuz depuis la config -/// server.init_qobuz_client_configured().await?; -/// -/// server.start().await; -/// server.wait().await; -/// Ok(()) -/// } -/// ``` -pub trait QobuzServerExt { - /// Initialise le client Qobuz et enregistre les routes HTTP - /// - /// # Arguments - /// - /// * `username` - Email ou nom d'utilisateur Qobuz - /// * `password` - Mot de passe - /// - /// # Returns - /// - /// * `Arc` - Instance partagée du client - /// - /// # Routes enregistrées - /// - /// - `GET /qobuz/albums/{id}` - Détails d'un album - /// - `GET /qobuz/albums/{id}/tracks` - Tracks d'un album - /// - `GET /qobuz/tracks/{id}` - Détails d'une track - /// - `GET /qobuz/tracks/{id}/stream` - URL de streaming - /// - `GET /qobuz/artists/{id}` - Détails d'un artiste - /// - `GET /qobuz/artists/{id}/albums` - Albums d'un artiste - /// - `GET /qobuz/playlists/{id}` - Détails d'une playlist - /// - `GET /qobuz/playlists/{id}/tracks` - Tracks d'une playlist - /// - `GET /qobuz/search` - Recherche (query params: q, type) - /// - `GET /qobuz/favorites/albums` - Albums favoris - /// - `GET /qobuz/favorites/artists` - Artistes favoris - /// - `GET /qobuz/favorites/tracks` - Tracks favoris - /// - `GET /qobuz/favorites/playlists` - Playlists utilisateur - /// - `GET /qobuz/genres` - Liste des genres - /// - `GET /qobuz/featured/albums` - Albums featured - /// - `GET /qobuz/featured/playlists` - Playlists featured - /// - `GET /qobuz/cache/stats` - Statistiques du cache - /// - `GET /swagger-ui` - Documentation interactive - async fn init_qobuz_client( - &mut self, - username: &str, - password: &str, - ) -> Result>; - - /// Initialise le client Qobuz avec la configuration par défaut - /// - /// Utilise automatiquement les credentials de `pmoconfig::Config` : - /// - `accounts.qobuz.username` pour le nom d'utilisateur - /// - `accounts.qobuz.password` pour le mot de passe - /// - /// # Returns - /// - /// * `Arc` - Instance partagée du client - /// - /// # Exemple - /// - /// ```rust,no_run - /// use pmoqobuz::QobuzServerExt; - /// use pmoserver::ServerBuilder; - /// - /// #[tokio::main] - /// async fn main() -> anyhow::Result<()> { - /// let mut server = ServerBuilder::new_configured().build(); - /// - /// // Utilise automatiquement la config - /// server.init_qobuz_client_configured().await?; - /// - /// server.start().await; - /// Ok(()) - /// } - /// ``` - async fn init_qobuz_client_configured(&mut self) -> Result>; - - /// Initialise le client Qobuz avec intégration pmocovers - /// - /// Les images d'albums seront automatiquement ajoutées au cache pmocovers fourni. - /// - /// # Arguments - /// - /// * `username` - Email ou nom d'utilisateur Qobuz - /// * `password` - Mot de passe - /// * `cover_cache` - Instance du cache pmocovers à utiliser - /// - /// # Returns - /// - /// * `Arc` - Instance partagée du client avec cache d'images - /// - /// # Exemple - /// - /// ```rust,no_run - /// use pmoqobuz::QobuzServerExt; - /// use pmocovers::CoverCacheExt; - /// use pmoserver::ServerBuilder; - /// - /// #[tokio::main] - /// async fn main() -> anyhow::Result<()> { - /// let mut server = ServerBuilder::new_configured().build(); - /// - /// // D'abord initialiser le cache d'images - /// let cache = server.init_cover_cache_configured().await?; - /// - /// // Puis initialiser Qobuz avec le cache - /// server.init_qobuz_client_with_covers("user", "pass", cache).await?; - /// - /// server.start().await; - /// Ok(()) - /// } - /// ``` - #[cfg(feature = "covers")] - async fn init_qobuz_client_with_covers( - &mut self, - username: &str, - password: &str, - cover_cache: Arc, - ) -> Result>; - - /// Initialise le client Qobuz avec intégration pmocovers depuis la configuration - /// - /// # Arguments - /// - /// * `cover_cache` - Instance du cache pmocovers à utiliser - /// - /// # Exemple - /// - /// ```rust,no_run - /// use pmoqobuz::QobuzServerExt; - /// use pmocovers::CoverCacheExt; - /// use pmoserver::ServerBuilder; - /// - /// #[tokio::main] - /// async fn main() -> anyhow::Result<()> { - /// let mut server = ServerBuilder::new_configured().build(); - /// - /// // D'abord initialiser le cache - /// let cache = server.init_cover_cache_configured().await?; - /// - /// // Puis initialiser Qobuz avec le cache - /// server.init_qobuz_client_configured_with_covers(cache).await?; - /// - /// server.start().await; - /// Ok(()) - /// } - /// ``` - #[cfg(feature = "covers")] - async fn init_qobuz_client_configured_with_covers( - &mut self, - cover_cache: Arc, - ) -> Result>; -} - -// L'implémentation du trait sera dans un module séparé (pmoserver_impl.rs) -// pour éviter les dépendances circulaires -========= End of pmoqobuz/src/pmoserver_ext.rs =========== -