Premier exemple pour tester si le controle point marche

pmocontrol/examples/arylic_tcp_demo.rs

@@ -38,14 +38,11 @@ fn main() -> io::Result<()> {
         );
     }
 
-    let arylic_renderers: Vec<MusicRenderer> = {
-        let reg = registry.read().unwrap();
-        renderers
+    let arylic_renderers: Vec<MusicRenderer> = renderers
         .iter()
         .filter(|info| info.capabilities.has_arylic_tcp)
-            .filter_map(|info| MusicRenderer::from_registry_info(info.clone(), &reg))
-            .collect()
-    };
+        .filter_map(|info| MusicRenderer::from_registry_info(info.clone(), &registry))
+        .collect();
 
     if arylic_renderers.is_empty() {
         println!("\nNo Arylic TCP-capable renderers detected.");

pmocontrol/examples/linkplay_demo.rs

@@ -34,14 +34,11 @@ fn main() -> io::Result<()> {
         );
     }
 
-    let linkplay_renderers: Vec<MusicRenderer> = {
-        let reg = registry.read().unwrap();
-        renderers
+    let linkplay_renderers: Vec<MusicRenderer> = renderers
         .iter()
         .filter(|info| info.capabilities.has_linkplay_http)
-            .filter_map(|info| MusicRenderer::from_registry_info(info.clone(), &reg))
-            .collect()
-    };
+        .filter_map(|info| MusicRenderer::from_registry_info(info.clone(), &registry))
+        .collect();
 
     if linkplay_renderers.is_empty() {
         println!("\nNo LinkPlay-capable renderers detected.");

pmocontrol/examples/queue_pmomusic_demo.rs

@@ -0,0 +1,429 @@
+//! End-to-end queue demo that prefers the PMOMusic media server and exercises
+//! the ControlPoint playback queue API.
+
+use std::collections::VecDeque;
+use std::env;
+use std::process;
+use std::thread;
+use std::time::Duration;
+
+use anyhow::{Context, Result};
+use pmocontrol::{
+    ControlPoint, DeviceRegistryRead, MediaBrowser, MediaEntry, MediaResource, MediaServerInfo,
+    MusicRenderer, MusicServer, PlaybackItem, PlaybackPosition, PlaybackPositionInfo, RendererInfo,
+    RendererProtocol,
+};
+
+const DEFAULT_TIMEOUT_SECS: u64 = 5;
+const DEFAULT_DISCOVERY_SECS: u64 = 5;
+const DEFAULT_MAX_TRACKS: usize = 3;
+const MONITOR_DURATION_SECS: u64 = 600;
+const MONITOR_POLL_SECS: u64 = 5;
+const MAX_BROWSE_DEPTH: usize = 2;
+
+fn main() -> Result<()> {
+    let _ = tracing_subscriber::fmt::try_init();
+    let config = CliConfig::parse_from_env().unwrap_or_else(|err| {
+        eprintln!("Error parsing arguments: {err}");
+        print_usage_and_exit();
+    });
+
+    if config.max_tracks == 0 {
+        eprintln!("--max-tracks must be >= 1");
+        process::exit(1);
+    }
+
+    println!(
+        "Starting queue_pmomusic_demo with timeout={}s discovery={}s max_tracks={}",
+        config.timeout_secs, config.discovery_secs, config.max_tracks
+    );
+
+    // ControlPoint::spawn starts the HttpXmlDescriptionProvider + DiscoveryManager combo.
+    let control_point =
+        ControlPoint::spawn(config.timeout_secs).context("Failed to start control point")?;
+
+    println!(
+        "Discovery running for {} seconds before selecting devices...",
+        config.discovery_secs
+    );
+    thread::sleep(Duration::from_secs(config.discovery_secs));
+
+    let registry = control_point.registry();
+    let (renderer, server_info) = {
+        let reg = registry.read().expect("registry poisoned");
+        let renderer_candidates: Vec<RendererInfo> = reg
+            .list_renderers()
+            .into_iter()
+            .filter(|info| !is_pmomusic_renderer(info))
+            .collect();
+        let renderer = pick_renderer(renderer_candidates)
+            .unwrap_or_else(|| no_renderer_and_exit("No suitable renderer found after discovery."));
+        let server = pick_media_server(reg.list_servers())
+            .unwrap_or_else(|| no_server_and_exit("No media server with ContentDirectory."));
+        (renderer, server)
+    };
+
+    println!(
+        "Selected renderer \"{}\" (protocol={:?}, id={})",
+        renderer.friendly_name, renderer.protocol, renderer.id.0
+    );
+    println!(
+        "Selected media server \"{}\" at {} (id={})",
+        server_info.friendly_name, server_info.location, server_info.id.0
+    );
+
+    let renderer_instance = MusicRenderer::from_registry_info(renderer.clone(), &registry)
+        .expect("Selected renderer is not usable by MusicRenderer façade");
+    let supports_set_next = renderer_instance
+        .as_upnp()
+        .map(|upnp| upnp.supports_set_next())
+        .unwrap_or(false);
+    println!(
+        "Renderer \"{}\": AVTransport present = {}, SetNextAVTransportURI supported = {}",
+        renderer.friendly_name,
+        renderer.capabilities.has_avtransport,
+        supports_set_next
+    );
+
+    let timeout = Duration::from_secs(config.timeout_secs);
+    let server =
+        MusicServer::from_info(&server_info, timeout).context("Failed to init MusicServer")?;
+
+    let root_entries = server
+        .browse_root()
+        .context("Failed to browse ContentDirectory root")?;
+    println!("Root returned {} entries", root_entries.len());
+
+    let playback_items = collect_playable_items(&server, &root_entries, config.max_tracks)
+        .context("Failed to derive playable items from ContentDirectory root/children")?;
+
+    if playback_items.is_empty() {
+        println!("No playable tracks were found on the selected server.");
+        process::exit(1);
+    }
+
+    println!(
+        "Discovered {} playable items; enqueuing…",
+        playback_items.len()
+    );
+
+    let mut planned_queue: VecDeque<PlaybackItem>;
+    let renderer_id = renderer.id.clone();
+    control_point
+        .clear_queue(&renderer_id)
+        .context("Failed to clear playback queue")?;
+    control_point
+        .enqueue_items(&renderer_id, playback_items)
+        .context("Failed to enqueue playback items")?;
+
+    let snapshot = control_point
+        .get_queue_snapshot(&renderer_id)
+        .context("Failed to snapshot queue after enqueue")?;
+    print_queue_snapshot(&snapshot);
+    planned_queue = snapshot.clone().into();
+
+    control_point
+        .play_next_from_queue(&renderer_id)
+        .context("Failed to start playback from queue")?;
+    let mut current_track = planned_queue.pop_front();
+    let remaining = control_point
+        .get_queue_snapshot(&renderer_id)
+        .context("Failed to snapshot queue after play_next_from_queue")?;
+    planned_queue = remaining.clone().into();
+    println!(
+        "Playback started on \"{}\"; {} tracks remaining in queue.",
+        renderer.friendly_name,
+        remaining.len()
+    );
+
+    println!(
+        "Monitoring queue auto-advance for {} seconds (poll every {}s)…",
+        MONITOR_DURATION_SECS, MONITOR_POLL_SECS
+    );
+    let poll_count = MONITOR_DURATION_SECS / MONITOR_POLL_SECS;
+    for tick in 0..poll_count {
+        thread::sleep(Duration::from_secs(MONITOR_POLL_SECS));
+        let snapshot = control_point
+            .get_queue_snapshot(&renderer_id)
+            .context("Queue snapshot failed during monitoring loop")?;
+        let new_plan: VecDeque<PlaybackItem> = snapshot.clone().into();
+        if planned_queue.len() > new_plan.len() {
+            let removed = planned_queue.len() - new_plan.len();
+            for _ in 0..removed {
+                current_track = planned_queue.pop_front();
+            }
+        }
+        planned_queue = new_plan;
+
+        let playback_info = control_point
+            .music_renderer_by_id(&renderer_id)
+            .and_then(|renderer| renderer.playback_position().ok());
+
+        let title = current_track_title(current_track.as_ref());
+        if let Some(info) = playback_info {
+            println!(
+                "[tick {tick}] Queue length = {} | now playing: {} [{}]",
+                snapshot.len(),
+                title,
+                format_playback_position(&info)
+            );
+        } else {
+            println!(
+                "[tick {tick}] Queue length = {} | now playing: {} [position unavailable]",
+                snapshot.len(),
+                title
+            );
+        }
+    }
+
+    println!("Monitoring finished, exiting.");
+    Ok(())
+}
+
+#[derive(Debug)]
+struct CliConfig {
+    timeout_secs: u64,
+    discovery_secs: u64,
+    max_tracks: usize,
+}
+
+impl CliConfig {
+    fn parse_from_env() -> Result<Self, String> {
+        let mut timeout_secs = DEFAULT_TIMEOUT_SECS;
+        let mut discovery_secs = DEFAULT_DISCOVERY_SECS;
+        let mut max_tracks = DEFAULT_MAX_TRACKS;
+
+        let mut args = env::args().skip(1);
+        while let Some(arg) = args.next() {
+            match arg.as_str() {
+                "--timeout-secs" => {
+                    let value = args
+                        .next()
+                        .ok_or_else(|| "--timeout-secs requires a value".to_string())?;
+                    timeout_secs = value.parse().map_err(|err| {
+                        format!("Invalid value for --timeout-secs ({value}): {err}")
+                    })?;
+                }
+                "--discovery-secs" => {
+                    let value = args
+                        .next()
+                        .ok_or_else(|| "--discovery-secs requires a value".to_string())?;
+                    discovery_secs = value.parse().map_err(|err| {
+                        format!("Invalid value for --discovery-secs ({value}): {err}")
+                    })?;
+                }
+                "--max-tracks" => {
+                    let value = args
+                        .next()
+                        .ok_or_else(|| "--max-tracks requires a value".to_string())?;
+                    max_tracks = value.parse().map_err(|err| {
+                        format!("Invalid value for --max-tracks ({value}): {err}")
+                    })?;
+                }
+                "--help" | "-h" => {
+                    print_usage_and_exit();
+                }
+                unknown => {
+                    return Err(format!("Unknown argument: {unknown}"));
+                }
+            }
+        }
+
+        Ok(Self {
+            timeout_secs,
+            discovery_secs,
+            max_tracks,
+        })
+    }
+}
+
+fn pick_renderer(renderers: Vec<RendererInfo>) -> Option<RendererInfo> {
+    let mut candidates: Vec<RendererInfo> = renderers
+        .into_iter()
+        .filter(|info| match info.protocol {
+            RendererProtocol::OpenHomeOnly => false,
+            RendererProtocol::UpnpAvOnly | RendererProtocol::Hybrid => true,
+        })
+        .collect();
+
+    if candidates.is_empty() {
+        return None;
+    }
+
+    println!("Renderer candidates:");
+    for (idx, info) in candidates.iter().enumerate() {
+        println!(
+            "  [{}] {} | model={} | location={} | online={}",
+            idx, info.friendly_name, info.model_name, info.location, info.online
+        );
+    }
+
+    let selected = candidates.remove(0);
+    println!(
+        "Automatically selecting renderer index 0: {}",
+        selected.friendly_name
+    );
+    Some(selected)
+}
+
+fn pick_media_server(servers: Vec<MediaServerInfo>) -> Option<MediaServerInfo> {
+    let mut candidates: Vec<MediaServerInfo> = servers
+        .into_iter()
+        .filter(|info| info.has_content_directory)
+        .filter(|info| info.content_directory_control_url.is_some())
+        .collect();
+
+    if candidates.is_empty() {
+        return None;
+    }
+
+    if let Some(idx) = candidates.iter().position(is_pmomusic_server) {
+        let server = candidates.remove(idx);
+        println!(
+            "Preferring PMOMusic server \"{}\" (server header: {}).",
+            server.friendly_name, server.server_header
+        );
+        Some(server)
+    } else {
+        println!("No PMOMusic server discovered; falling back to first ContentDirectory server.");
+        Some(candidates.remove(0))
+    }
+}
+
+fn is_pmomusic_server(info: &MediaServerInfo) -> bool {
+    let name = info.friendly_name.to_ascii_lowercase();
+    let header = info.server_header.to_ascii_lowercase();
+    name.contains("pmomusic") || header.contains("pmomusic")
+}
+
+fn is_pmomusic_renderer(info: &RendererInfo) -> bool {
+    info.friendly_name
+        .to_ascii_lowercase()
+        .contains("pmomusic audio renderer")
+}
+
+fn collect_playable_items(
+    server: &MusicServer,
+    entries: &[MediaEntry],
+    max_tracks: usize,
+) -> Result<Vec<PlaybackItem>> {
+    let mut items = Vec::new();
+    for entry in entries {
+        gather_items_from_entry(server, entry, max_tracks, 0, &mut items)?;
+        if items.len() >= max_tracks {
+            break;
+        }
+    }
+    Ok(items)
+}
+
+fn gather_items_from_entry(
+    server: &MusicServer,
+    entry: &MediaEntry,
+    max_tracks: usize,
+    depth: usize,
+    out: &mut Vec<PlaybackItem>,
+) -> Result<()> {
+    if out.len() >= max_tracks {
+        return Ok(());
+    }
+
+    if entry.is_container {
+        if depth >= MAX_BROWSE_DEPTH {
+            return Ok(());
+        }
+
+        match server.browse_children(&entry.id, 0, 50) {
+            Ok(children) => {
+                for child in children {
+                    gather_items_from_entry(server, &child, max_tracks, depth + 1, out)?;
+                    if out.len() >= max_tracks {
+                        break;
+                    }
+                }
+            }
+            Err(err) => {
+                tracing::warn!(
+                    container_id = entry.id.as_str(),
+                    error = %err,
+                    "Failed to browse child container"
+                );
+            }
+        }
+        return Ok(());
+    }
+
+    if let Some(item) = playback_item_from_entry(server, entry) {
+        out.push(item);
+    }
+    Ok(())
+}
+
+fn playback_item_from_entry(server: &MusicServer, entry: &MediaEntry) -> Option<PlaybackItem> {
+    if entry.title.to_ascii_lowercase().contains("live stream") {
+        return None;
+    }
+    let resource = entry.resources.iter().find(|res| is_audio_resource(res))?;
+    let mut item = PlaybackItem::new(resource.uri.clone());
+    item.title = Some(entry.title.clone());
+    item.server_id = Some(server.id().clone());
+    item.object_id = Some(entry.id.clone());
+    Some(item)
+}
+
+fn is_audio_resource(res: &MediaResource) -> bool {
+    let lower = res.protocol_info.to_ascii_lowercase();
+    if lower.contains("audio/") {
+        return true;
+    }
+    lower
+        .split(':')
+        .nth(2)
+        .map(|mime| mime.starts_with("audio/"))
+        .unwrap_or(false)
+}
+
+fn print_queue_snapshot(items: &[PlaybackItem]) {
+    println!("Current queue snapshot ({} items):", items.len());
+    for (idx, item) in items.iter().enumerate() {
+        let label = item.title.as_deref().unwrap_or_else(|| item.uri.as_str());
+        println!("  [{}] {} -> {}", idx, label, item.uri);
+    }
+    if items.is_empty() {
+        println!("  <queue is empty>");
+    }
+}
+
+fn current_track_title(item: Option<&PlaybackItem>) -> String {
+    match item {
+        Some(track) => track
+            .title
+            .as_deref()
+            .unwrap_or_else(|| track.uri.as_str())
+            .to_string(),
+        None => "<unknown>".to_string(),
+    }
+}
+
+fn format_playback_position(info: &PlaybackPositionInfo) -> String {
+    let rel = info.rel_time.as_deref().unwrap_or("-");
+    let dur = info.track_duration.as_deref().unwrap_or("-");
+    format!("{rel} / {dur}")
+}
+
+fn no_renderer_and_exit(message: &str) -> ! {
+    println!("{message}");
+    process::exit(1);
+}
+
+fn no_server_and_exit(message: &str) -> ! {
+    println!("{message}");
+    process::exit(1);
+}
+
+fn print_usage_and_exit() -> ! {
+    println!(
+        "Usage: cargo run -p pmocontrol --example queue_pmomusic_demo -- [--timeout-secs N] [--discovery-secs N] [--max-tracks N]"
+    );
+    process::exit(1);
+}

pmocontrol/src/avtransport_client.rs

@@ -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),

pmocontrol/src/control_point.rs

@@ -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 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 info = {
             let reg = self.registry.read().unwrap();
-        reg.list_renderers()
-            .into_iter()
-            .next()
-            .map(|info| UpnpRenderer::from_registry(info, &reg))
+            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 info = {
             let reg = self.registry.read().unwrap();
             reg.get_renderer(id)
-            .map(|info| UpnpRenderer::from_registry(info, &reg))
+        }?;
+
+        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 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 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 info = {
             let reg = self.registry.read().unwrap();
             reg.get_renderer(id)
-            .and_then(|info| MusicRenderer::from_registry_info(info, &reg))
+        }?;
+
+        MusicRenderer::from_registry_info(info, &self.registry)
     }
 
     /// Snapshot list of media servers currently known by the registry.
@@ -374,9 +394,7 @@ impl ControlPoint {
             "Dequeued next playback item"
         );
 
-        let renderer = self
-            .music_renderer_by_id(renderer_id)
-            .ok_or_else(|| {
+        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"
@@ -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) {

pmocontrol/src/model.rs

@@ -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,

pmocontrol/src/music_renderer.rs

@@ -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;

pmocontrol/src/registry.rs

@@ -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"
+                );
+            }
+        }
+    }
 }

pmocontrol/src/upnp_renderer.rs

@@ -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]