feat: dynamic device discovery and add D36HD dimmer support

Add D36HD model (Decora Smart Wi-Fi 2 / Matter 600W Dimmer) to the
supported lights list so newer dimmers like the office main light
are exposed.

Each platform now listens to coordinator updates and creates entities
for newly-discovered devices instead of only enumerating once at
setup. The WebSocket now subscribes to new device IDs as they appear,
so real-time updates work for devices added after HA started.

Bump version to 1.1.4.

Author: simplytoast1

custom_components/leviton_smart/__init__.py

@@ -15,7 +15,7 @@
 from typing import Dict, Any, List
 
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.core import HomeAssistant
+from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers import device_registry as dr
 from homeassistant.const import CONF_EMAIL, CONF_PASSWORD
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
@@ -89,6 +89,9 @@ async def async_update_data():
     # Initial fetch
     await coordinator.async_config_entry_first_refresh()
 
+    # Track which device IDs the WebSocket has subscribed to.
+    known_ws_ids: set[str] = set()
+
     # Callback for WebSocket updates
     def on_update(data: Dict[str, Any]) -> None:
         """
@@ -112,9 +115,23 @@ def on_update(data: Dict[str, Any]) -> None:
     # Initialize and start WebSocket
     ws = LevitonWebSocket(session, login_response, on_update)
     _LOGGER.info("Starting WebSocket connection...")
-    
+
     # device_ids are keys in coordinator.data
-    ws.start(list(coordinator.data.keys()))
+    initial_ids = [str(k) for k in coordinator.data.keys()]
+    known_ws_ids.update(initial_ids)
+    ws.start(initial_ids)
+
+    # Subscribe to any new devices that appear on subsequent coordinator refreshes.
+    @callback
+    def _subscribe_new_devices() -> None:
+        new_ids = [str(d) for d in coordinator.data.keys() if str(d) not in known_ws_ids]
+        for device_id in new_ids:
+            known_ws_ids.add(device_id)
+            hass.async_create_task(ws.add_device(device_id))
+        if new_ids:
+            _LOGGER.info("Discovered %d new Leviton device(s): %s", len(new_ids), new_ids)
+
+    entry.async_on_unload(coordinator.async_add_listener(_subscribe_new_devices))
 
     # Store everything in hass.data for platforms to access
     hass.data[DOMAIN][entry.entry_id] = {

custom_components/leviton_smart/binary_sensor.py

@@ -13,7 +13,7 @@
     BinarySensorDeviceClass,
 )
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.core import HomeAssistant
+from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 
 from .const import DOMAIN, MODELS_MOTION_SENSOR
@@ -31,15 +31,26 @@ async def async_setup_entry(
     client = hass.data[DOMAIN][config_entry.entry_id]["client"]
     coordinator = hass.data[DOMAIN][config_entry.entry_id]["coordinator"]
 
-    entities = []
+    known_ids: set[str] = set()
 
-    for device_id, device_data in coordinator.data.items():
-        model = device_data.get("model", "")
-        # Create motion sensor entities for motion-capable models
-        if model in MODELS_MOTION_SENSOR:
-            entities.append(LevitonMotionSensor(client, coordinator, device_id, config_entry.entry_id))
+    @callback
+    def _add_new_entities() -> None:
+        new_entities = []
+        for device_id, device_data in coordinator.data.items():
+            device_id = str(device_id)
+            if device_id in known_ids:
+                continue
+            model = device_data.get("model", "")
+            if model in MODELS_MOTION_SENSOR:
+                known_ids.add(device_id)
+                new_entities.append(
+                    LevitonMotionSensor(client, coordinator, device_id, config_entry.entry_id)
+                )
+        if new_entities:
+            async_add_entities(new_entities)
 
-    async_add_entities(entities)
+    _add_new_entities()
+    config_entry.async_on_unload(coordinator.async_add_listener(_add_new_entities))
 
 
 class LevitonMotionSensor(LevitonEntity, BinarySensorEntity):

custom_components/leviton_smart/const.py

@@ -29,6 +29,7 @@
     "D26HD",  # 600W Dimmer
     "D2ELV",  # ELV Dimmer
     "D2MSD",  # Motion Sensor Dimmer
+    "D36HD",  # Decora Smart Wi-Fi 2 / Matter 600W Dimmer
     "DW1KD",  # 1000W Dimmer
     "DW3HL",  # 300W Dimmer
     "DW6HD",  # 600W Dimmer

custom_components/leviton_smart/fan.py

@@ -12,7 +12,7 @@
 
 from homeassistant.components.fan import FanEntity, FanEntityFeature
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.core import HomeAssistant
+from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.util.percentage import (
     ordered_list_item_to_percentage,
@@ -42,14 +42,26 @@ async def async_setup_entry(
     client = hass.data[DOMAIN][config_entry.entry_id]["client"]
     coordinator = hass.data[DOMAIN][config_entry.entry_id]["coordinator"]
 
-    entities = []
-
-    for device_id, device_data in coordinator.data.items():
-        model = device_data.get("model", "")
-        if model in MODELS_FAN:
-            entities.append(LevitonFan(client, coordinator, device_id, config_entry.entry_id))
-
-    async_add_entities(entities)
+    known_ids: set[str] = set()
+
+    @callback
+    def _add_new_entities() -> None:
+        new_entities = []
+        for device_id, device_data in coordinator.data.items():
+            device_id = str(device_id)
+            if device_id in known_ids:
+                continue
+            model = device_data.get("model", "")
+            if model in MODELS_FAN:
+                known_ids.add(device_id)
+                new_entities.append(
+                    LevitonFan(client, coordinator, device_id, config_entry.entry_id)
+                )
+        if new_entities:
+            async_add_entities(new_entities)
+
+    _add_new_entities()
+    config_entry.async_on_unload(coordinator.async_add_listener(_add_new_entities))
 
 
 class LevitonFan(LevitonEntity, FanEntity):

custom_components/leviton_smart/leviton_api/websocket.py

@@ -190,25 +190,42 @@ async def _subscribe_all(self) -> None:
             return
 
         for device_id in self._device_ids:
-            # modelId must be an integer in the subscription
-            try:
-                model_id = int(device_id)
-            except (ValueError, TypeError):
-                _LOGGER.warning("Invalid device ID format: %s", device_id)
-                continue
-
-            payload = {
-                "type": "subscribe",
-                "subscription": {
-                    "modelName": "IotSwitch",
-                    "modelId": model_id,
-                }
-            }
-            _LOGGER.debug("Subscribing to device %d", model_id)
-            await self._ws.send_json(payload)
+            await self._send_subscribe(device_id)
 
         _LOGGER.info("Subscribed to %d devices.", len(self._device_ids))
 
+    async def _send_subscribe(self, device_id: str) -> None:
+        """Send a single subscribe payload for a device."""
+        if not self._ws:
+            return
+        try:
+            model_id = int(device_id)
+        except (ValueError, TypeError):
+            _LOGGER.warning("Invalid device ID format: %s", device_id)
+            return
+
+        payload = {
+            "type": "subscribe",
+            "subscription": {
+                "modelName": "IotSwitch",
+                "modelId": model_id,
+            }
+        }
+        _LOGGER.debug("Subscribing to device %d", model_id)
+        await self._ws.send_json(payload)
+
+    async def add_device(self, device_id: str) -> None:
+        """
+        Track a newly-discovered device and subscribe to it if connected.
+        Safe to call repeatedly; duplicates are ignored.
+        """
+        device_id = str(device_id)
+        if device_id in self._device_ids:
+            return
+        self._device_ids.append(device_id)
+        if self._ws is not None and not self._ws.closed:
+            await self._send_subscribe(device_id)
+
     def _process_notification(self, data: Dict[str, Any]) -> None:
         """
         Extract meaningful data from a notification and trigger the update callback.

custom_components/leviton_smart/light.py

@@ -18,7 +18,7 @@
     ATTR_BRIGHTNESS,
 )
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.core import HomeAssistant
+from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 
 from .const import DOMAIN, MODELS_LIGHT, MODELS_FAN
@@ -36,15 +36,26 @@ async def async_setup_entry(
     client = hass.data[DOMAIN][config_entry.entry_id]["client"]
     coordinator = hass.data[DOMAIN][config_entry.entry_id]["coordinator"]
 
-    entities = []
-
-    for device_id, device_data in coordinator.data.items():
-        model = device_data.get("model", "")
-        # Only create light entities for dimmer models (not fans, not switches)
-        if model in MODELS_LIGHT and model not in MODELS_FAN:
-            entities.append(LevitonDimmer(client, coordinator, device_id, config_entry.entry_id))
-
-    async_add_entities(entities)
+    known_ids: set[str] = set()
+
+    @callback
+    def _add_new_entities() -> None:
+        new_entities = []
+        for device_id, device_data in coordinator.data.items():
+            device_id = str(device_id)
+            if device_id in known_ids:
+                continue
+            model = device_data.get("model", "")
+            if model in MODELS_LIGHT and model not in MODELS_FAN:
+                known_ids.add(device_id)
+                new_entities.append(
+                    LevitonDimmer(client, coordinator, device_id, config_entry.entry_id)
+                )
+        if new_entities:
+            async_add_entities(new_entities)
+
+    _add_new_entities()
+    config_entry.async_on_unload(coordinator.async_add_listener(_add_new_entities))
 
 
 class LevitonDimmer(LevitonEntity, LightEntity):

custom_components/leviton_smart/manifest.json

@@ -9,5 +9,5 @@
   "iot_class": "cloud_push",
   "issue_tracker": "https://github.com/simplytoast1/ha-levitonsmart/issues",
   "requirements": [],
-  "version": "1.1.3"
+  "version": "1.1.4"
 }

custom_components/leviton_smart/switch.py

@@ -11,7 +11,7 @@
 
 from homeassistant.components.switch import SwitchEntity
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.core import HomeAssistant
+from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 
 from .const import DOMAIN, MODELS_SWITCH, MODELS_OUTLET, MODELS_GFCI
@@ -32,15 +32,26 @@ async def async_setup_entry(
     client = hass.data[DOMAIN][config_entry.entry_id]["client"]
     coordinator = hass.data[DOMAIN][config_entry.entry_id]["coordinator"]
 
-    entities = []
-
-    for device_id, device_data in coordinator.data.items():
-        model = device_data.get("model", "")
-        # Create switch entities for switches, outlets, and GFCI devices
-        if model in SWITCH_MODELS:
-            entities.append(LevitonSwitch(client, coordinator, device_id, config_entry.entry_id))
-
-    async_add_entities(entities)
+    known_ids: set[str] = set()
+
+    @callback
+    def _add_new_entities() -> None:
+        new_entities = []
+        for device_id, device_data in coordinator.data.items():
+            device_id = str(device_id)
+            if device_id in known_ids:
+                continue
+            model = device_data.get("model", "")
+            if model in SWITCH_MODELS:
+                known_ids.add(device_id)
+                new_entities.append(
+                    LevitonSwitch(client, coordinator, device_id, config_entry.entry_id)
+                )
+        if new_entities:
+            async_add_entities(new_entities)
+
+    _add_new_entities()
+    config_entry.async_on_unload(coordinator.async_add_listener(_add_new_entities))
 
 
 class LevitonSwitch(LevitonEntity, SwitchEntity):