Refactor squeezebox integration media_player to use coordinator (#127695)

Author: rajlaud

homeassistant/components/squeezebox/__init__.py

@@ -2,9 +2,10 @@
 
 from asyncio import timeout
 from dataclasses import dataclass
+from datetime import datetime
 import logging
 
-from pysqueezebox import Server
+from pysqueezebox import Player, Server
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import (
@@ -23,20 +24,30 @@
     DeviceEntryType,
     format_mac,
 )
+from homeassistant.helpers.dispatcher import async_dispatcher_send
+from homeassistant.helpers.event import async_call_later
 
 from .const import (
     CONF_HTTPS,
+    DISCOVERY_INTERVAL,
     DISCOVERY_TASK,
     DOMAIN,
+    KNOWN_PLAYERS,
+    KNOWN_SERVERS,
     MANUFACTURER,
     SERVER_MODEL,
+    SIGNAL_PLAYER_DISCOVERED,
+    SIGNAL_PLAYER_REDISCOVERED,
     STATUS_API_TIMEOUT,
     STATUS_QUERY_LIBRARYNAME,
     STATUS_QUERY_MAC,
     STATUS_QUERY_UUID,
     STATUS_QUERY_VERSION,
 )
-from .coordinator import LMSStatusDataUpdateCoordinator
+from .coordinator import (
+    LMSStatusDataUpdateCoordinator,
+    SqueezeBoxPlayerUpdateCoordinator,
+)
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -117,15 +128,55 @@ async def async_setup_entry(hass: HomeAssistant, entry: SqueezeboxConfigEntry) -
     )
     _LOGGER.debug("LMS Device %s", device)
 
-    coordinator = LMSStatusDataUpdateCoordinator(hass, lms)
+    server_coordinator = LMSStatusDataUpdateCoordinator(hass, lms)
 
     entry.runtime_data = SqueezeboxData(
-        coordinator=coordinator,
+        coordinator=server_coordinator,
         server=lms,
     )
 
-    await coordinator.async_config_entry_first_refresh()
+    # set up player discovery
+    known_servers = hass.data.setdefault(DOMAIN, {}).setdefault(KNOWN_SERVERS, {})
+    known_players = known_servers.setdefault(lms.uuid, {}).setdefault(KNOWN_PLAYERS, [])
+
+    async def _player_discovery(now: datetime | None = None) -> None:
+        """Discover squeezebox players by polling server."""
+
+        async def _discovered_player(player: Player) -> None:
+            """Handle a (re)discovered player."""
+            if player.player_id in known_players:
+                await player.async_update()
+                async_dispatcher_send(
+                    hass, SIGNAL_PLAYER_REDISCOVERED, player.player_id, player.connected
+                )
+            else:
+                _LOGGER.debug("Adding new entity: %s", player)
+                player_coordinator = SqueezeBoxPlayerUpdateCoordinator(
+                    hass, player, lms.uuid
+                )
+                known_players.append(player.player_id)
+                async_dispatcher_send(
+                    hass, SIGNAL_PLAYER_DISCOVERED, player_coordinator
+                )
+
+        if players := await lms.async_get_players():
+            for player in players:
+                hass.async_create_task(_discovered_player(player))
+
+        entry.async_on_unload(
+            async_call_later(hass, DISCOVERY_INTERVAL, _player_discovery)
+        )
+
+    await server_coordinator.async_config_entry_first_refresh()
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+
+    _LOGGER.debug(
+        "Adding player discovery job for LMS server: %s", entry.data[CONF_HOST]
+    )
+    entry.async_create_background_task(
+        hass, _player_discovery(), "squeezebox.media_player.player_discovery"
+    )
+
     return True
 
 

homeassistant/components/squeezebox/const.py

@@ -5,6 +5,7 @@
 DOMAIN = "squeezebox"
 DEFAULT_PORT = 9000
 KNOWN_PLAYERS = "known_players"
+KNOWN_SERVERS = "known_servers"
 MANUFACTURER = "https://lyrion.org/"
 PLAYER_DISCOVERY_UNSUB = "player_discovery_unsub"
 SENSOR_UPDATE_INTERVAL = 60
@@ -27,3 +28,7 @@
 STATUS_QUERY_UUID = "uuid"
 STATUS_QUERY_VERSION = "version"
 SQUEEZEBOX_SOURCE_STRINGS = ("source:", "wavin:", "spotify:")
+SIGNAL_PLAYER_DISCOVERED = "squeezebox_player_discovered"
+SIGNAL_PLAYER_REDISCOVERED = "squeezebox_player_rediscovered"
+DISCOVERY_INTERVAL = 60
+PLAYER_UPDATE_INTERVAL = 5

homeassistant/components/squeezebox/coordinator.py

@@ -1,18 +1,23 @@
 """DataUpdateCoordinator for the Squeezebox integration."""
 
 from asyncio import timeout
+from collections.abc import Callable
 from datetime import timedelta
 import logging
 import re
+from typing import Any
 
-from pysqueezebox import Server
+from pysqueezebox import Player, Server
 
-from homeassistant.core import HomeAssistant
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 from homeassistant.util import dt as dt_util
 
 from .const import (
+    PLAYER_UPDATE_INTERVAL,
     SENSOR_UPDATE_INTERVAL,
+    SIGNAL_PLAYER_REDISCOVERED,
     STATUS_API_TIMEOUT,
     STATUS_SENSOR_LASTSCAN,
     STATUS_SENSOR_NEEDSRESTART,
@@ -38,7 +43,7 @@ def __init__(self, hass: HomeAssistant, lms: Server) -> None:
         self.newversion_regex = re.compile("<.*$")
 
     async def _async_update_data(self) -> dict:
-        """Fetch data fromn LMS status call.
+        """Fetch data from LMS status call.
 
         Then we process only a subset to make then nice for HA
         """
@@ -70,3 +75,46 @@ def _prepare_status_data(self, data: dict) -> dict:
 
         _LOGGER.debug("Processed serverstatus %s=%s", self.lms.name, data)
         return data
+
+
+class SqueezeBoxPlayerUpdateCoordinator(DataUpdateCoordinator[dict[str, Any]]):
+    """Coordinator for Squeezebox players."""
+
+    def __init__(self, hass: HomeAssistant, player: Player, server_uuid: str) -> None:
+        """Initialize the coordinator."""
+        super().__init__(
+            hass,
+            _LOGGER,
+            name=player.name,
+            update_interval=timedelta(seconds=PLAYER_UPDATE_INTERVAL),
+            always_update=True,
+        )
+        self.player = player
+        self.available = True
+        self._remove_dispatcher: Callable | None = None
+        self.server_uuid = server_uuid
+
+    async def _async_update_data(self) -> dict[str, Any]:
+        """Update Player if available, or listen for rediscovery if not."""
+        if self.available:
+            # Only update players available at last update, unavailable players are rediscovered instead
+            await self.player.async_update()
+
+            if self.player.connected is False:
+                _LOGGER.debug("Player %s is not available", self.name)
+                self.available = False
+
+                # start listening for restored players
+                self._remove_dispatcher = async_dispatcher_connect(
+                    self.hass, SIGNAL_PLAYER_REDISCOVERED, self.rediscovered
+                )
+        return {}
+
+    @callback
+    def rediscovered(self, unique_id: str, connected: bool) -> None:
+        """Make a player available again."""
+        if unique_id == self.player.player_id and connected:
+            self.available = True
+            _LOGGER.debug("Player %s is available again", self.name)
+            if self._remove_dispatcher:
+                self._remove_dispatcher()