refactor: introduce provider abstraction for multi-platform lock support

custom_components/keymaster/binary_sensor.py

@@ -16,7 +16,6 @@
 from .const import CONF_SLOTS, CONF_START, COORDINATOR, DOMAIN
 from .coordinator import KeymasterCoordinator
 from .entity import KeymasterEntity, KeymasterEntityDescription
-from .helpers import async_using_zwave_js
 
 _LOGGER: logging.Logger = logging.getLogger(__name__)
 
@@ -30,7 +29,17 @@ async def async_setup_entry(
     coordinator: KeymasterCoordinator = hass.data[DOMAIN][COORDINATOR]
     kmlock = await coordinator.get_lock_by_config_entry_id(config_entry.entry_id)
     entities: list = []
-    if async_using_zwave_js(hass=hass, kmlock=kmlock):
+
+    if not kmlock:
+        _LOGGER.error("Lock not found for config entry %s", config_entry.entry_id)
+        raise PlatformNotReady
+
+    # Provider is guaranteed to exist - config flow filters to supported platforms
+    # and coordinator fails setup if provider creation fails
+    assert kmlock.provider is not None
+
+    # Add connection status sensor if provider supports it
+    if kmlock.provider.supports_connection_status:
         entities.append(
             KeymasterBinarySensor(
                 entity_description=KeymasterBinarySensorEntityDescription(
@@ -44,28 +53,27 @@ async def async_setup_entry(
                 ),
             )
         )
-        entities.extend(
-            [
-                KeymasterBinarySensor(
-                    entity_description=KeymasterBinarySensorEntityDescription(
-                        key=f"binary_sensor.code_slots:{x}.active",
-                        name=f"Code Slot {x}: Active",
-                        icon="mdi:run",
-                        entity_registry_enabled_default=True,
-                        hass=hass,
-                        config_entry=config_entry,
-                        coordinator=coordinator,
-                    )
-                )
-                for x in range(
-                    config_entry.data[CONF_START],
-                    config_entry.data[CONF_START] + config_entry.data[CONF_SLOTS],
+
+    # Add code slot active sensors
+    entities.extend(
+        [
+            KeymasterBinarySensor(
+                entity_description=KeymasterBinarySensorEntityDescription(
+                    key=f"binary_sensor.code_slots:{x}.active",
+                    name=f"Code Slot {x}: Active",
+                    icon="mdi:run",
+                    entity_registry_enabled_default=True,
+                    hass=hass,
+                    config_entry=config_entry,
+                    coordinator=coordinator,
                 )
-            ]
-        )
-    else:
-        _LOGGER.error("Z-Wave integration not found")
-        raise PlatformNotReady
+            )
+            for x in range(
+                config_entry.data[CONF_START],
+                config_entry.data[CONF_START] + config_entry.data[CONF_SLOTS],
+            )
+        ]
+    )
 
     async_add_entities(entities, True)
 

custom_components/keymaster/config_flow.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from collections.abc import MutableMapping
+from collections.abc import Callable, MutableMapping
 import logging
 from typing import Any
 
@@ -39,6 +39,7 @@
     NONE_TEXT,
 )
 from .coordinator import KeymasterCoordinator
+from .providers import is_platform_supported
 
 _LOGGER: logging.Logger = logging.getLogger(__name__)
 
@@ -155,14 +156,32 @@ def _get_entities(
     extra_entities: list[str] | None = None,
     exclude_entities: list[str] | None = None,
     sort: bool = True,
+    filter_func: Callable[[HomeAssistant, str], bool] | None = None,
 ) -> list[str]:
+    """Get entities from a domain with optional filtering.
+
+    Args:
+        hass: Home Assistant instance
+        domain: Entity domain (e.g., "lock", "sensor")
+        search: Only include entities whose ID contains one of these strings
+        extra_entities: Additional entity IDs to append to results
+        exclude_entities: Entity IDs to remove from results
+        sort: Whether to sort the results alphabetically
+        filter_func: Optional callback(hass, entity_id) -> bool to filter entities.
+            Entity is included only if filter_func returns True.
+
+    """
     data: list[str] = []
     if domain not in hass.data:
         return extra_entities or []
 
     for entity in hass.data[domain].entities:
+        # Skip if search terms provided and entity ID doesn't contain any of them
         if search is not None and not any(map(entity.entity_id.__contains__, search)):
             continue
+        # Skip if filter function provided and it returns False for this entity
+        if filter_func is not None and not filter_func(hass, entity.entity_id):
+            continue
         data.append(entity.entity_id)
 
     if extra_entities:
@@ -220,6 +239,7 @@ def _get_default(key: str, fallback_default: Any = None) -> Any:
         hass=hass,
         domain=LOCK_DOMAIN,
         exclude_entities=_get_locks_in_use(hass=hass, exclude=_get_default(CONF_LOCK_ENTITY_ID)),
+        filter_func=is_platform_supported,
     )
     if not lock_entities:
         if flow is not None: