Cargo.lock

@@ -4,7 +4,7 @@ version = 4
 
 [[package]]
 name = "PMOMusic"
-version = "0.3.35"
+version = "0.3.36"
 dependencies = [
  "axum 0.8.7",
  "console-subscriber",

PMOMusic/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "PMOMusic"
-version = "0.3.35"
+version = "0.3.37"
 edition = "2024"
 
 [dependencies]

pmoapp/webapp/src/components/unified/RendererDrawer.vue

@@ -36,10 +36,16 @@ const myUdn = computed(() => webRenderer.rendererUdn.value);
 
 const filteredRenderers = computed(() => {
     const udn = myUdn.value;
+    const normalizedUdn = udn?.replace(/^uuid:/, '') ?? null;
     return allRenderers.value.filter((r: RendererSummary) => {
-        if (r.model_name !== "WebRenderer") return true;
-        if (udn === null) return false;
-        return r.id === udn;
+        // WebRenderers have "Web Audio – " as friendly_name prefix
+        const isWebRenderer = r.friendly_name?.startsWith("Web Audio – ") ?? false;
+        if (isWebRenderer) {
+            if (normalizedUdn === null) return false;
+            const normalizedId = r.id.replace(/^uuid:/, '');
+            return normalizedId === normalizedUdn;
+        }
+        return true;
     });
 });
 

pmoapp/webapp/src/composables/useRenderers.ts

@@ -63,6 +63,7 @@ function ensureSSEInitialized() {
         id: rendererId,
         friendly_name: event.friendly_name,
         model_name: event.model_name,
+        manufacturer: event.manufacturer,
         protocol: "upnp", // Valeur par défaut, sera mise à jour par le fetch
         capabilities: {
           has_avtransport: false,
@@ -269,30 +270,40 @@ function selectRenderer(id: string | null) {
   snapshotState.selectedRendererId = id;
 }
 
-async function fetchRenderers(force = false) {
+async function fetchRenderers(force = false, retries = 2) {
   ensureSSEInitialized();
 
-  try {
-    loading.value = true;
-    error.value = null;
+  let lastError: Error | null = null;
+  
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    try {
+      loading.value = true;
+      error.value = null;
 
-    // Utiliser le cache API centralisé
-    const data = await apiCache.fetch(
-      '/renderers',
-      undefined,
-      () => api.getRenderers(),
-      { force, ttl: RENDERERS_CACHE_MS }
-    );
-    
-    renderersCache.value = new Map(
-      data.map((renderer) => [renderer.id, renderer]),
-    );
-  } catch (err) {
-    error.value = err instanceof Error ? err.message : "Erreur fetch renderers";
-    console.error("[useRenderers] Erreur fetch:", err);
-  } finally {
-    loading.value = false;
+      // Utiliser le cache API centralisé
+      const data = await apiCache.fetch(
+        '/renderers',
+        undefined,
+        () => api.getRenderers(),
+        { force, ttl: RENDERERS_CACHE_MS }
+      );
+      
+      renderersCache.value = new Map(
+        data.map((renderer) => [renderer.id, renderer]),
+      );
+      return;
+    } catch (err) {
+      lastError = err instanceof Error ? err : new Error("Erreur fetch renderers");
+      console.error("[useRenderers] Erreur fetch (attempt " + (attempt + 1) + "):", lastError);
+      if (attempt < retries) {
+        await new Promise(r => setTimeout(r, 500 * (attempt + 1)));
+      }
+    } finally {
+      loading.value = false;
+    }
   }
+  
+  error.value = lastError?.message ?? "Erreur fetch renderers";
 }
 
 async function fetchRendererSnapshot(

pmoapp/webapp/src/composables/useWebRenderer.ts

@@ -22,6 +22,24 @@ function generateUUID(): string {
 }
 
 const INSTANCE_ID_KEY = "pmomusic_webrenderer_instance_id";
+const RENDERER_UDN_KEY = "pmomusic_webrenderer_udn";
+
+// Load persisted UDN on module load
+function loadPersistedUdn(): string | null {
+    try {
+        return sessionStorage.getItem(RENDERER_UDN_KEY);
+    } catch {
+        return null;
+    }
+}
+
+function savePersistedUdn(udn: string) {
+    try {
+        sessionStorage.setItem(RENDERER_UDN_KEY, udn);
+    } catch {
+        // ignore storage errors
+    }
+}
 
 // Module-level singleton for PMOPlayer to prevent duplicate instances
 let globalPlayer: PMOPlayer | null = null;
@@ -31,7 +49,7 @@ let registering = false;
 // Module-level reactive state shared across all composable invocations
 const sharedConnected = ref(false);
 const sharedStreamUrl = ref<string | null>(null);
-const sharedRendererUdn = ref<string | null>(null);
+const sharedRendererUdn = ref<string | null>(loadPersistedUdn());
 
 function getOrCreateInstanceId(): string {
     try {
@@ -55,17 +73,41 @@ export function useWebRenderer() {
     let onConnectedCallback: (() => void) | null = null;
 
     async function register(): Promise<void> {
-        // Prevent concurrent registrations (race condition → double player)
-        if (globalPlayer || registering) {
+        // Allow re-registration if we have a stale player but no connection
+        if (globalPlayer && !connected.value) {
+            console.log('[WebRenderer] stale globalPlayer, clearing');
+            globalPlayer = null;
+        }
+        
+        if (globalPlayer) {
+            player = globalPlayer;
+            connected.value = true;
+            console.log('[WebRenderer] reusing existing player');
+            return;
+        }
+
+        if (registering) {
+            console.log('[WebRenderer] already registering, waiting...');
+            // Wait a bit and try once
+            await new Promise(r => setTimeout(r, 1000));
             if (globalPlayer) {
                 player = globalPlayer;
                 connected.value = true;
+                return;
             }
-            return;
         }
+        
         registering = true;
 
-        const instanceId = getOrCreateInstanceId();
+        let instanceId;
+        try {
+            instanceId = getOrCreateInstanceId();
+        } catch (e) {
+            console.error('[WebRenderer] failed to get instanceId:', e);
+            registering = false;
+            return;
+        }
+        
         console.log('[WebRenderer] registering with instanceId:', instanceId);
 
         try {
@@ -86,6 +128,7 @@ export function useWebRenderer() {
             const data = await resp.json();
             streamUrl.value = data.stream_url;
             rendererUdn.value = data.udn;
+            savePersistedUdn(data.udn);
 
             player = new PMOPlayer(instanceId);
             globalPlayer = player;
@@ -103,6 +146,13 @@ export function useWebRenderer() {
 
             connected.value = true;
             onConnectedCallback?.();
+            
+            // Force refresh renderers list after registration
+            // The SSE might miss the initial event
+            setTimeout(() => {
+                console.log('[WebRenderer] forcing renderers refresh');
+                window.dispatchEvent(new CustomEvent('webrenderer-registered'));
+            }, 500);
         } catch (e) {
             console.error("[WebRenderer] register error:", e);
         } finally {

pmoapp/webapp/src/services/pmocontrol/types.ts

@@ -29,6 +29,7 @@ export interface RendererSummary {
   id: string;
   friendly_name: string;
   model_name: string;
+  manufacturer?: string;
   protocol: RendererProtocolSummary;
   capabilities: RendererCapabilitiesSummary;
   online: boolean;

pmoapp/webapp/src/views/UnifiedControlView.vue

@@ -77,9 +77,9 @@ const onlineServersCount = computed(
     () => allServers.value.filter((s) => s.online).length,
 );
 
-// Nombre de renderers online pour afficher dans le badge
+// Nombre de renderers online (filtrés) pour afficher dans le badge
 const onlineRenderersCount = computed(
-    () => allRenderers.value.filter((r) => r.online).length,
+    () => filterRenderers(allRenderers.value).filter((r) => r.online).length,
 );
 
 // Gestion de l'ouverture du drawer depuis le bouton
@@ -103,14 +103,19 @@ function handleRendererSelect(rendererId: string) {
     }
 }
 
-// Filtre la liste des renderers pour exclure les WebRenderers d'autres navigateurs.
-// Seul le WebRenderer créé par ce navigateur (identifié par son UDN) reste visible.
+// Filter to show only our own WebRenderer based on UDN match
 function filterRenderers(renderers: typeof allRenderers.value) {
     const myUdn = webRenderer.rendererUdn.value;
+    const normalizedUdn = myUdn?.replace(/^uuid:/, '') ?? null;
     return renderers.filter((r) => {
-        if (r.model_name !== "WebRenderer") return true; // renderer classique : toujours visible
-        if (myUdn === null) return false; // pas encore de session : masquer tous les WebRenderers
-        return r.id === myUdn; // ne garder que le nôtre
+        // WebRenderers have "Web Audio – " as friendly_name prefix
+        const isWebRenderer = r.friendly_name?.startsWith("Web Audio – ") ?? false;
+        if (isWebRenderer) {
+            if (normalizedUdn === null) return false;
+            const normalizedId = r.id.replace(/^uuid:/, '');
+            return normalizedId === normalizedUdn;
+        }
+        return true;
     });
 }
 

pmomediarenderer/src/registry.rs

@@ -65,6 +65,7 @@ impl MediaRendererRegistry {
         instance_id: &str,
         stream_url_base: &str,
         renderer_name: &str,
+        friendly_name: &str,
         adapter_fn: impl FnOnce(SharedState) -> Arc<dyn DeviceAdapter>,
     ) -> Result<(String, String, bool), MediaRendererError> {
         if let Some(cancel) = self.pending_unregister.write().remove(instance_id) {
@@ -77,7 +78,7 @@ impl MediaRendererRegistry {
             if let Some(existing) = instances.get(instance_id) {
                 tracing::info!(instance_id = %instance_id, "MediaRenderer: reconnecting existing instance");
                 #[cfg(feature = "pmoserver")]
-                self.register_with_control_point(&existing.device_instance, renderer_name)?;
+                self.register_with_control_point(&existing.device_instance, renderer_name, &existing.udn)?;
                 let stream_url = format!("{}/{}/stream", stream_url_base, instance_id);
                 let should_play = {
                     let s = existing.state.read();
@@ -90,7 +91,7 @@ impl MediaRendererRegistry {
             }
         }
 
-        let instance = self.create_instance_with_adapter(instance_id, stream_url_base, renderer_name, adapter_fn).await?;
+        let instance = self.create_instance_with_adapter(instance_id, stream_url_base, renderer_name, friendly_name, adapter_fn).await?;
         let instance = Arc::new(instance);
         let stream_url = format!("{}/{}/stream", stream_url_base, instance_id);
         let udn = instance.udn.clone();
@@ -231,18 +232,14 @@ impl MediaRendererRegistry {
         instance_id: &str,
         stream_url_base: &str,
         renderer_name: &str,
+        friendly_name: &str,
         adapter_fn: impl FnOnce(SharedState) -> Arc<dyn DeviceAdapter>,
     ) -> Result<MediaRendererInstance, MediaRendererError> {
         let candidate_udn = instance_id.to_ascii_lowercase();
         let full_udn = format!("uuid:{}", candidate_udn);
 
-        if let Err(e) = pmoconfig::get_config().set_device_udn(
-            "MediaRenderer",
-            instance_id,
-            candidate_udn.clone(),
-        ) {
-            tracing::warn!("MediaRenderer: failed to persist UDN: {:?}", e);
-        }
+        // Note: WebRenderers don't need to persist UDN to config since they're tied to browser tabs
+        // (instance_id comes from sessionStorage, not a persistent device)
 
         let state: SharedState = Arc::new(parking_lot::RwLock::new(RendererState::default()));
         let adapter = adapter_fn(state.clone());
@@ -275,7 +272,7 @@ impl MediaRendererRegistry {
                 let device = MediaRendererFactory::create_device_with_pipeline(
                     instance_id,
                     "MediaRenderer",
-                    "WebRenderer",
+                    friendly_name,
                     pipeline.clone(),
                     state.clone(),
                     stream_url_base,
@@ -289,7 +286,7 @@ impl MediaRendererRegistry {
                     .map_err(|e| MediaRendererError::RegistrationError(e.to_string()))?
             };
 
-            self.register_with_control_point(&di, renderer_name)?;
+            self.register_with_control_point(&di, renderer_name, &full_udn)?;
             (di, ip)
         };
 
@@ -307,7 +304,7 @@ impl MediaRendererRegistry {
             let device = MediaRendererFactory::create_device_with_pipeline(
                 instance_id,
                 "MediaRenderer",
-                "WebRenderer",
+                friendly_name,
                 pipeline.clone(),
                 state.clone(),
                 stream_url_base,
@@ -334,9 +331,11 @@ impl MediaRendererRegistry {
         &self,
         di: &Arc<DeviceInstance>,
         renderer_name: &str,
+        instance_udn: &str,
     ) -> Result<(), MediaRendererError> {
         let base_url = di.base_url().to_string();
-        let udn = di.udn().to_ascii_lowercase();
+        // Use the instance's UDN, not the device's stored UDN
+        let udn = instance_udn.trim_start_matches("uuid:").to_ascii_lowercase();
         let udn_with_prefix = format!("uuid:{}", udn);
         let device_route = di.route();
         let model = di.get_model();
@@ -359,7 +358,7 @@ impl MediaRendererRegistry {
             udn_with_prefix.clone(),
             model.friendly_name().to_string(),
             model.model_name().to_string(),
-            "PMOMusic".to_string(),
+            "PMOMusic-WebRenderer".to_string(),
             RendererProtocol::UpnpAvOnly,
             RendererCapabilities {
                 has_avtransport: true,

pmomediarenderer/src/renderer.rs

@@ -87,19 +87,24 @@ impl MediaRendererFactory {
     pub fn create_device_with_pipeline(
         device_name: &str,
         device_type: &str,
-        friendly_name_suffix: &str,
+        friendly_name: &str,
         pipeline: PipelineHandle,
         state: SharedState,
         stream_url_base: &str,
     ) -> Result<Device, FactoryError> {
-        let avtransport = Self::build_avtransport(pipeline.clone(), state.clone(), device_name, stream_url_base)?;
+        let avtransport = Self::build_avtransport(
+            pipeline.clone(),
+            state.clone(),
+            device_name,
+            stream_url_base,
+        )?;
         let renderingcontrol = Self::build_renderingcontrol(state.clone())?;
         let connectionmanager = Self::build_connectionmanager()?;
 
-        let device = Device::new_from_config(
+        let device = Device::new(
             device_name.to_string(),
             device_type.to_string(),
-            friendly_name_suffix.to_string(),
+            friendly_name.to_string(),
         );
         device
             .add_service(Arc::new(avtransport))

pmowebrenderer/src/helpers.rs

@@ -0,0 +1,15 @@
+pub fn extract_browser_name(ua: &str) -> &str {
+    if ua.contains("Edg/") || ua.contains("EdgA/") {
+        "Edge"
+    } else if ua.contains("OPR/") || ua.contains("Opera") {
+        "Opera"
+    } else if ua.contains("Chrome/") {
+        "Chrome"
+    } else if ua.contains("Firefox/") {
+        "Firefox"
+    } else if ua.contains("Safari/") {
+        "Safari"
+    } else {
+        "Browser"
+    }
+}

pmowebrenderer/src/lib.rs

@@ -6,6 +6,7 @@
 //! - Les commandes UPnP sont relayées vers le pipeline audio via PipelineControl
 
 mod adapter;
+mod helpers;
 mod register;
 mod stream;
 
@@ -13,6 +14,7 @@ mod stream;
 mod config;
 
 pub use adapter::BrowserAdapter;
+pub use helpers::extract_browser_name;
 
 #[cfg(feature = "pmoserver")]
 pub use config::WebRendererExt;

pmowebrenderer/src/register.rs

@@ -17,6 +17,7 @@ use pmomediarenderer::PipelineControl;
 use pmomediarenderer::{DeviceCommand, MediaRendererRegistry};
 
 use crate::adapter::BrowserAdapter;
+use crate::helpers::extract_browser_name;
 
 #[derive(Debug, serde::Deserialize)]
 pub struct PlayerStateReport {
@@ -51,11 +52,15 @@ pub async fn register_handler(
         "WebRenderer: register request"
     );
 
+    let browser_name = extract_browser_name(&req.user_agent);
+    let friendly_name = format!("Web Audio – {}", browser_name);
+
     match registry
         .register_or_reconnect(
             &req.instance_id,
             "/api/webrenderer",
             "PMOMusic WebRenderer/2.0",
+            &friendly_name,
             |state| Arc::new(BrowserAdapter::new(state)),
         )
         .await

version.txt

@@ -1 +1 @@
-0.3.35
+0.3.37