eric/pmomusic
1
0
Fork 0
Code Issues 5 Pull Requests Actions Packages Projects Releases 3 Wiki Activity

Premier exemple pour tester si le controle point marche

Browse Source
This commit is contained in:
Eric Coissac
2025-12-01 20:40:24 +01:00
parent f434c521e8
commit ea1774f216
10 changed files with 8607 additions and 68 deletions
Download Patch File Download Diff File Expand all files Collapse all files

54
pmocontrol/src/avtransport_client.rs
View File

@@ -1,10 +1,14 @@
// pmocontrol/src/avtransport_client.rs
use crate::soap_client::{SoapCallResult, invoke_upnp_action};
use std::time::Duration;
use crate::soap_client::{SoapCallResult, invoke_upnp_action, invoke_upnp_action_with_timeout};
use anyhow::{Result, anyhow};
use pmoupnp::soap::SoapEnvelope;
use xmltree::{Element, XMLNode};
const AVTRANSPORT_ACTION_TIMEOUT: Duration = Duration::from_secs(5);
#[derive(Debug, Clone)]
pub struct AvTransportClient {
pub control_url: String,
@@ -121,6 +125,45 @@ impl AvTransportClient {
handle_action_response("Seek", &call_result)
}
/// Optional AVTransport:1 action SetNextAVTransportURI.
///
/// This should configure the *next* track to be played after the current one.
/// Many renderers do NOT implement this action; in that case the method
/// returns an error derived from the UPnP error code.
pub fn set_next_av_transport_uri(&self, next_uri: &str, next_meta: &str) -> Result<()> {
let args = [
("InstanceID", "0"),
("NextURI", next_uri),
("NextURIMetaData", next_meta),
];
let call_result = invoke_upnp_action_with_timeout(
&self.control_url,
&self.service_type,
"SetNextAVTransportURI",
&args,
Some(AVTRANSPORT_ACTION_TIMEOUT),
)?;
if let Err(err) = handle_action_response("SetNextAVTransportURI", &call_result) {
if let Some(env) = &call_result.envelope {
if let Some(upnp_error) = parse_upnp_error(env) {
if is_set_next_not_supported_error(&upnp_error) {
return Err(anyhow!(
"Renderer does not support AVTransport.SetNextAVTransportURI (UPnP error {}: {})",
upnp_error.error_code,
upnp_error.error_description
));
}
}
}
return Err(err);
}
Ok(())
}
}
fn handle_action_response(action: &str, call_result: &SoapCallResult) -> Result<()> {
@@ -230,6 +273,15 @@ fn parse_upnp_error(envelope: &SoapEnvelope) -> Option<UpnpError> {
})
}
fn is_set_next_not_supported_error(err: &UpnpError) -> bool {
if err.error_code == 401 {
return true;
}
let desc = err.error_description.to_ascii_lowercase();
desc.contains("invalid action") || desc.contains("not implemented")
}
fn find_child_with_suffix<'a>(parent: &'a Element, suffix: &str) -> Option<&'a Element> {
parent.children.iter().find_map(|node| match node {
XMLNode::Element(elem) if elem.name.ends_with(suffix) => Some(elem),

121
pmocontrol/src/control_point.rs
View File

@@ -96,13 +96,14 @@ impl ControlPoint {
thread::spawn(move || {
loop {
let renderers = {
let infos = {
let reg = runtime_cp.registry.read().unwrap();
reg.list_renderers()
.into_iter()
.filter_map(|info| MusicRenderer::from_registry_info(info, &reg))
.collect::<Vec<_>>()
};
let renderers = infos
.into_iter()
.filter_map(|info| MusicRenderer::from_registry_info(info, &runtime_cp.registry))
.collect::<Vec<_>>();
for renderer in renderers {
let info = renderer.info();
@@ -204,27 +205,35 @@ impl ControlPoint {
/// Snapshot list of renderers currently known by the registry.
pub fn list_upnp_renderers(&self) -> Vec<UpnpRenderer> {
let reg = self.registry.read().unwrap();
reg.list_renderers()
let infos = {
let reg = self.registry.read().unwrap();
reg.list_renderers()
};
infos
.into_iter()
.map(|info| UpnpRenderer::from_registry(info, &reg))
.map(|info| UpnpRenderer::from_registry(info, &self.registry))
.collect()
}
/// Return the first renderer in the registry, if any.
pub fn default_upnp_renderer(&self) -> Option<UpnpRenderer> {
let reg = self.registry.read().unwrap();
reg.list_renderers()
.into_iter()
.next()
.map(|info| UpnpRenderer::from_registry(info, &reg))
let info = {
let reg = self.registry.read().unwrap();
reg.list_renderers().into_iter().next()
}?;
Some(UpnpRenderer::from_registry(info, &self.registry))
}
/// Lookup a renderer by id.
pub fn upnp_renderer_by_id(&self, id: &RendererId) -> Option<UpnpRenderer> {
let reg = self.registry.read().unwrap();
reg.get_renderer(id)
.map(|info| UpnpRenderer::from_registry(info, &reg))
let info = {
let reg = self.registry.read().unwrap();
reg.get_renderer(id)
}?;
Some(UpnpRenderer::from_registry(info, &self.registry))
}
/// Snapshot list of music renderers (protocol-agnostic view).
@@ -233,26 +242,37 @@ impl ControlPoint {
/// [`MusicRenderer::Upnp`]. OpenHome-only devices will be
/// ignored until an OpenHome backend is implemented.
pub fn list_music_renderers(&self) -> Vec<MusicRenderer> {
let reg = self.registry.read().unwrap();
reg.list_renderers()
let infos = {
let reg = self.registry.read().unwrap();
reg.list_renderers()
};
infos
.into_iter()
.filter_map(|info| MusicRenderer::from_registry_info(info, &reg))
.filter_map(|info| MusicRenderer::from_registry_info(info, &self.registry))
.collect()
}
/// Return the first music renderer in the registry, if any.
pub fn default_music_renderer(&self) -> Option<MusicRenderer> {
let reg = self.registry.read().unwrap();
reg.list_renderers()
let infos = {
let reg = self.registry.read().unwrap();
reg.list_renderers()
};
infos
.into_iter()
.find_map(|info| MusicRenderer::from_registry_info(info, &reg))
.find_map(|info| MusicRenderer::from_registry_info(info, &self.registry))
}
/// Lookup a music renderer by id.
pub fn music_renderer_by_id(&self, id: &RendererId) -> Option<MusicRenderer> {
let reg = self.registry.read().unwrap();
reg.get_renderer(id)
.and_then(|info| MusicRenderer::from_registry_info(info, &reg))
let info = {
let reg = self.registry.read().unwrap();
reg.get_renderer(id)
}?;
MusicRenderer::from_registry_info(info, &self.registry)
}
/// Snapshot list of media servers currently known by the registry.
@@ -374,15 +394,13 @@ impl ControlPoint {
"Dequeued next playback item"
);
let renderer = self
.music_renderer_by_id(renderer_id)
.ok_or_else(|| {
warn!(
renderer = renderer_id.0.as_str(),
"Renderer disappeared before queue playback could start"
);
anyhow!("Renderer {} not found", renderer_id.0)
})?;
let renderer = self.music_renderer_by_id(renderer_id).ok_or_else(|| {
warn!(
renderer = renderer_id.0.as_str(),
"Renderer disappeared before queue playback could start"
);
anyhow!("Renderer {} not found", renderer_id.0)
})?;
if matches!(renderer.info().protocol, RendererProtocol::OpenHomeOnly) {
self.runtime
@@ -430,6 +448,28 @@ impl ControlPoint {
queue_len = remaining_after,
"Started playback from queue"
);
if let Some(snapshot) = self.runtime.queue_snapshot(renderer_id) {
if let Some(next_item) = snapshot.first() {
if let Some(upnp) = renderer.as_upnp() {
let known_supported = upnp.supports_set_next();
if known_supported || upnp.has_avtransport() {
match upnp.set_next_uri(&next_item.uri, "") {
Ok(_) => debug!(
renderer = renderer_id.0.as_str(),
"Prefetched next track via SetNextAVTransportURI"
),
Err(err) => debug!(
renderer = renderer_id.0.as_str(),
error = %err,
"SetNextAVTransportURI failed for next queue item; continuing without prefetch"
),
}
}
}
}
}
Ok(())
}
@@ -460,12 +500,10 @@ impl ControlPoint {
error = %err,
"Auto-advance failed; clearing queue playback state"
);
self.runtime
.set_playback_source(id, PlaybackSource::None);
self.runtime.set_playback_source(id, PlaybackSource::None);
}
} else {
self.runtime
.set_playback_source(id, PlaybackSource::None);
self.runtime.set_playback_source(id, PlaybackSource::None);
}
}
PlaybackState::Playing => {
@@ -542,9 +580,7 @@ impl RuntimeState {
F: FnOnce(&mut PlaybackQueue) -> R,
{
let mut entries = self.entries.lock().unwrap();
entries
.get_mut(id)
.map(|entry| f(&mut entry.queue))
entries.get_mut(id).map(|entry| f(&mut entry.queue))
}
fn queue_snapshot(&self, id: &RendererId) -> Option<Vec<PlaybackItem>> {
@@ -576,10 +612,7 @@ impl RuntimeState {
}
fn is_playing_from_queue(&self, id: &RendererId) -> bool {
matches!(
self.playback_source(id),
PlaybackSource::FromQueue
)
matches!(self.playback_source(id), PlaybackSource::FromQueue)
}
fn mark_external_if_idle(&self, id: &RendererId) {

10
pmocontrol/src/model.rs
View File

@@ -13,6 +13,10 @@ pub enum RendererProtocol {
#[derive(Clone, Debug, Default)]
pub struct RendererCapabilities {
pub has_avtransport: bool,
/// True if the renderer is known to support AVTransport.SetNextAVTransportURI.
///
/// This is discovered lazily at runtime; default is false.
pub has_avtransport_set_next: bool,
pub has_rendering_control: bool,
pub has_connection_manager: bool,
pub has_linkplay_http: bool,
@@ -25,6 +29,12 @@ pub struct RendererCapabilities {
pub has_oh_radio: bool,
}
impl RendererCapabilities {
pub fn supports_set_next(&self) -> bool {
self.has_avtransport && self.has_avtransport_set_next
}
}
#[derive(Clone, Debug)]
pub struct RendererInfo {
pub id: RendererId,

7
pmocontrol/src/music_renderer.rs
View File

@@ -6,6 +6,8 @@
//! this type so that transport, volume, and state queries stay backend-neutral.
//! OpenHome-only renderers are intentionally unsupported for now.
use std::sync::{Arc, RwLock};
use crate::capabilities::{PlaybackPositionInfo, PlaybackStatus};
use crate::model::{RendererId, RendererInfo, RendererProtocol};
use crate::{
@@ -90,7 +92,10 @@ impl MusicRenderer {
/// Returns `None` when no supported backend can be built for this renderer.
/// UPnP AV / hybrid renderers map either to [`MusicRenderer::LinkPlay`] (when supported)
/// or [`MusicRenderer::Upnp`].
pub fn from_registry_info(info: RendererInfo, registry: &DeviceRegistry) -> Option<Self> {
pub fn from_registry_info(
info: RendererInfo,
registry: &Arc<RwLock<DeviceRegistry>>,
) -> Option<Self> {
match info.protocol {
RendererProtocol::UpnpAvOnly | RendererProtocol::Hybrid => {
let has_arylic = info.capabilities.has_arylic_tcp;

13
pmocontrol/src/registry.rs
View File

@@ -6,6 +6,7 @@ use crate::connection_manager_client::ConnectionManagerClient;
use crate::media_server::{MediaServerInfo, ServerId};
use crate::model::{RendererId, RendererInfo};
use crate::rendering_control_client::RenderingControlClient;
use tracing::debug;
#[derive(Clone, Debug)]
enum DeviceKey {
@@ -190,4 +191,16 @@ impl DeviceRegistry {
service_type.clone(),
))
}
pub fn mark_renderer_supports_set_next(&mut self, id: &RendererId) {
if let Some(info) = self.renderers.get_mut(id) {
if !info.capabilities.has_avtransport_set_next {
info.capabilities.has_avtransport_set_next = true;
debug!(
renderer = id.0.as_str(),
"Renderer now marked as supporting AVTransport.SetNextAVTransportURI"
);
}
}
}
}

45
pmocontrol/src/upnp_renderer.rs
View File

@@ -1,7 +1,10 @@
use std::sync::{Arc, RwLock};
use anyhow::{Result, anyhow};
use crate::capabilities::{PlaybackPositionInfo, PlaybackStatus};
use crate::connection_manager_client::{ConnectionInfo, ConnectionManagerClient, ProtocolInfo};
use crate::music_renderer::op_not_supported;
use crate::rendering_control_client::RenderingControlClient;
use crate::{
AvTransportClient, DeviceRegistry, PlaybackPosition, PlaybackState, PositionInfo, RendererId,
@@ -12,6 +15,7 @@ use crate::{
#[derive(Clone, Debug)]
pub struct UpnpRenderer {
pub info: RendererInfo,
registry: Arc<RwLock<DeviceRegistry>>,
avtransport: Option<AvTransportClient>,
rendering_control: Option<RenderingControlClient>,
connection_manager: Option<ConnectionManagerClient>,
@@ -38,6 +42,11 @@ impl UpnpRenderer {
self.connection_manager.is_some()
}
/// Returns true if this renderer is known to support SetNextAVTransportURI.
pub fn supports_set_next(&self) -> bool {
self.info.capabilities.supports_set_next()
}
pub fn avtransport(&self) -> Result<&AvTransportClient> {
self.avtransport
.as_ref()
@@ -62,6 +71,23 @@ impl UpnpRenderer {
avt.play(0, "1")
}
/// Best-effort attempt to configure the next URI via AVTransport SetNextAVTransportURI.
pub fn set_next_uri(&self, next_uri: &str, next_meta: &str) -> Result<()> {
if !self.info.capabilities.has_avtransport {
return Err(op_not_supported("SetNextAVTransportURI", "AVTransport"));
}
let client = self.avtransport()?;
let result = client.set_next_av_transport_uri(next_uri, next_meta);
if result.is_ok() {
let mut reg = self.registry.write().unwrap();
reg.mark_renderer_supports_set_next(&self.info.id);
}
result
}
pub fn pause(&self) -> Result<()> {
let avt = self.avtransport()?;
avt.pause(0)
@@ -112,12 +138,18 @@ impl UpnpRenderer {
cm.get_current_connection_info(connection_id)
}
pub fn from_registry(info: RendererInfo, registry: &DeviceRegistry) -> Self {
let avtransport = registry.avtransport_client_for_renderer(&info.id);
let rendering_control = registry.rendering_control_client_for_renderer(&info.id);
let connection_manager = registry.connection_manager_client_for_renderer(&info.id);
pub fn from_registry(info: RendererInfo, registry: &Arc<RwLock<DeviceRegistry>>) -> Self {
let (avtransport, rendering_control, connection_manager) = {
let reg = registry.read().unwrap();
(
reg.avtransport_client_for_renderer(&info.id),
reg.rendering_control_client_for_renderer(&info.id),
reg.connection_manager_client_for_renderer(&info.id),
)
};
Self {
info,
registry: Arc::clone(registry),
avtransport,
rendering_control,
connection_manager,
@@ -130,6 +162,7 @@ mod tests {
use super::*;
use crate::model::{RendererCapabilities, RendererProtocol};
use crate::registry::{DeviceRegistry, DeviceUpdate};
use std::sync::{Arc, RwLock};
use std::time::SystemTime;
fn renderer_info(id_suffix: &str, with_avtransport: bool) -> RendererInfo {
@@ -160,10 +193,10 @@ mod tests {
}
}
fn registry_with_renderer(info: RendererInfo) -> DeviceRegistry {
fn registry_with_renderer(info: RendererInfo) -> Arc<RwLock<DeviceRegistry>> {
let mut registry = DeviceRegistry::new();
registry.apply_update(DeviceUpdate::RendererOnline(info));
registry
Arc::new(RwLock::new(registry))
}
#[test]