Remove async_remove_config_entry_device from Yoto

The coordinator already removes players that left the account, so this handler could never allow a deletion. Automatic removal alone satisfies the stale-devices rule.

homeassistant/components/yoto/coordinator.py

@@ -9,6 +9,7 @@ from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_ACCESS_TOKEN
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryNotReady, OAuth2TokenRequestError
+from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.config_entry_oauth2_flow import OAuth2Session
 from homeassistant.helpers.event import async_track_time_interval
@@ -41,6 +42,7 @@ class YotoDataUpdateCoordinator(DataUpdateCoordinator[dict[str, YotoPlayer]]):
         )
         self._session = session
         self.client = YotoClient(session=async_get_clientsession(hass))
+        self._subscribed_players: set[str] = set()
         self._sync_token()
 
     def _sync_token(self) -> None:
@@ -77,6 +79,8 @@ class YotoDataUpdateCoordinator(DataUpdateCoordinator[dict[str, YotoPlayer]]):
                 translation_placeholders={"error": str(err)},
             ) from err
 
+        self._subscribed_players = set(self.client.players)
+
         # The MQTT data/status topic is not pushed spontaneously; the firmware
         # only emits it in response to a command/status/request publish.
         self.config_entry.async_on_unload(
@@ -111,8 +115,33 @@ class YotoDataUpdateCoordinator(DataUpdateCoordinator[dict[str, YotoPlayer]]):
                 translation_placeholders={"error": str(err)},
             ) from err
 
+        await self._async_sync_subscriptions()
+        self._remove_stale_devices()
         return self.client.players
 
+    async def _async_sync_subscriptions(self) -> None:
+        """Subscribe new players to MQTT events and unsubscribe removed ones."""
+        current = set(self.client.players)
+        for device_id in current - self._subscribed_players:
+            await self.client.subscribe_player_events(device_id)
+        for device_id in self._subscribed_players - current:
+            await self.client.unsubscribe_player_events(device_id)
+        self._subscribed_players = current
+
+    def _remove_stale_devices(self) -> None:
+        """Drop devices for players no longer returned by the account."""
+        device_registry = dr.async_get(self.hass)
+        for device in dr.async_entries_for_config_entry(
+            device_registry, self.config_entry.entry_id
+        ):
+            player_id = next(
+                (ident[1] for ident in device.identifiers if ident[0] == DOMAIN), None
+            )
+            if player_id is not None and player_id not in self.client.players:
+                device_registry.async_update_device(
+                    device.id, remove_config_entry_id=self.config_entry.entry_id
+                )
+
     async def _async_load_library(self) -> None:
         """Load the card library and groups; failures only affect browsing."""
         try:

homeassistant/components/yoto/media_player.py

@@ -16,7 +16,7 @@ from homeassistant.components.media_player import (
     MediaPlayerState,
     MediaType,
 )
-from homeassistant.core import HomeAssistant
+from homeassistant.core import HomeAssistant, callback
 from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
@@ -47,10 +47,22 @@ async def async_setup_entry(
 ) -> None:
     """Set up the Yoto media player platform."""
     coordinator = entry.runtime_data
-    async_add_entities(
-        YotoMediaPlayer(coordinator, player)
-        for player in coordinator.client.players.values()
-    )
+    known_players: set[str] = set()
+
+    @callback
+    def _add_players() -> None:
+        current = set(coordinator.data)
+        new_players = current - known_players
+        known_players.clear()
+        known_players.update(current)
+        if new_players:
+            async_add_entities(
+                YotoMediaPlayer(coordinator, coordinator.data[player_id])
+                for player_id in new_players
+            )
+
+    entry.async_on_unload(coordinator.async_add_listener(_add_players))
+    _add_players()
 
 
 class YotoMediaPlayer(YotoEntity, MediaPlayerEntity):

homeassistant/components/yoto/quality_scale.yaml

@@ -56,7 +56,7 @@ rules:
   docs-supported-functions: todo
   docs-troubleshooting: todo
   docs-use-cases: todo
-  dynamic-devices: todo
+  dynamic-devices: done
   entity-category:
     status: exempt
     comment: Only the media_player entity ships in this PR; no diagnostic entities yet.
@@ -77,7 +77,7 @@ rules:
   repair-issues:
     status: exempt
     comment: No repair issues are raised yet.
-  stale-devices: todo
+  stale-devices: done
 
   # Platinum
   async-dependency: done

tests/components/yoto/test_init.py

@@ -5,7 +5,7 @@ from unittest.mock import MagicMock, Mock, patch
 import aiohttp
 from freezegun.api import FrozenDateTimeFactory
 import pytest
-from yoto_api import YotoAPIError, YotoError
+from yoto_api import Device, YotoAPIError, YotoError, YotoPlayer
 
 from homeassistant.components.yoto.const import (
     DOMAIN,
@@ -15,11 +15,13 @@ from homeassistant.components.yoto.const import (
 from homeassistant.config_entries import ConfigEntryState
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import OAuth2TokenRequestError
+from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers.config_entry_oauth2_flow import (
     ImplementationUnavailableError,
 )
 
 from . import setup_integration
+from .conftest import PLAYER_ID
 
 from tests.common import MockConfigEntry, async_fire_time_changed
 
@@ -235,3 +237,59 @@ async def test_periodic_poll_fails_on_api_error(
 
     coordinator = mock_config_entry.runtime_data
     assert coordinator.last_update_success is False
+
+
+def _build_second_player() -> YotoPlayer:
+    """Build a second Yoto player discovered after setup."""
+    return YotoPlayer(
+        device=Device(
+            device_id="player-2",
+            name="Playroom Yoto",
+            device_type="v3",
+            device_family="v3",
+            generation="gen3",
+        ),
+        is_online=True,
+    )
+
+
+async def test_dynamic_device_added(
+    hass: HomeAssistant,
+    mock_yoto_client: MagicMock,
+    mock_config_entry: MockConfigEntry,
+    freezer: FrozenDateTimeFactory,
+) -> None:
+    """A player discovered after setup gets its entity without a reload."""
+    await setup_integration(hass, mock_config_entry)
+    assert hass.states.get("media_player.nursery_yoto") is not None
+    assert hass.states.get("media_player.playroom_yoto") is None
+
+    mock_yoto_client.players["player-2"] = _build_second_player()
+    freezer.tick(SCAN_INTERVAL)
+    async_fire_time_changed(hass)
+    await hass.async_block_till_done()
+
+    assert hass.states.get("media_player.playroom_yoto") is not None
+    mock_yoto_client.subscribe_player_events.assert_called_once_with("player-2")
+
+
+async def test_stale_device_removed(
+    hass: HomeAssistant,
+    mock_yoto_client: MagicMock,
+    mock_config_entry: MockConfigEntry,
+    device_registry: dr.DeviceRegistry,
+    freezer: FrozenDateTimeFactory,
+) -> None:
+    """A player removed from the account has its device dropped."""
+    await setup_integration(hass, mock_config_entry)
+    assert (
+        device_registry.async_get_device(identifiers={(DOMAIN, PLAYER_ID)}) is not None
+    )
+
+    mock_yoto_client.players.clear()
+    freezer.tick(SCAN_INTERVAL)
+    async_fire_time_changed(hass)
+    await hass.async_block_till_done()
+
+    assert device_registry.async_get_device(identifiers={(DOMAIN, PLAYER_ID)}) is None
+    mock_yoto_client.unsubscribe_player_events.assert_called_once_with(PLAYER_ID)