Stabilize Alarmo alarm entity unique IDs and avoid ID collisions

Author: codyc1515

custom_components/alarmo/alarm_control_panel.py

@@ -18,8 +18,9 @@
     ATTR_CODE_FORMAT,
     STATE_UNAVAILABLE,
 )
-from homeassistant.helpers import entity_platform
-from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers import entity_platform
+from homeassistant.helpers import entity_registry as er
+from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.event import (
     async_call_later,
     async_track_point_in_time,
@@ -45,10 +46,53 @@
 _LOGGER = logging.getLogger(__name__)
 
 # Store per-config-entry unsubscribe callbacks for platform-level dispatcher listeners
-PLATFORM_UNSUBS = "platform_unsubs"
-
-
-async def async_setup(hass, config):
+PLATFORM_UNSUBS = "platform_unsubs"
+
+
+def _build_unique_id(hass: HomeAssistant, area_id: str | None = None) -> str:
+    """Build a stable unique ID for Alarmo entities."""
+    coordinator_id = hass.data[const.DOMAIN]["coordinator"].id
+    suffix = area_id if area_id else "master"
+    return f"{coordinator_id}_{suffix}"
+
+
+def _get_available_entity_id(
+    hass: HomeAssistant, suggested_entity_id: str, exclude_entity_id: str | None = None
+) -> str:
+    """Return an entity_id that does not collide with existing entities."""
+    used_ids = set(hass.states.async_entity_ids(PLATFORM))
+    entity_registry = er.async_get(hass)
+    used_ids.update(
+        entity_id
+        for entity_id in entity_registry.entities
+        if entity_id.startswith(f"{PLATFORM}.")
+    )
+
+    areas = hass.data.get(const.DOMAIN, {}).get("areas", {})
+    for alarm_entity in areas.values():
+        existing_id = getattr(alarm_entity, "entity_id", None)
+        if existing_id:
+            used_ids.add(existing_id)
+
+    master = hass.data.get(const.DOMAIN, {}).get("master")
+    if master and getattr(master, "entity_id", None):
+        used_ids.add(master.entity_id)
+
+    if exclude_entity_id:
+        used_ids.discard(exclude_entity_id)
+
+    if suggested_entity_id not in used_ids:
+        return suggested_entity_id
+
+    index = 2
+    while True:
+        candidate = f"{suggested_entity_id}_{index}"
+        if candidate not in used_ids:
+            return candidate
+        index += 1
+
+
+async def async_setup(hass, config):
     """Track states and offer events for alarm_control_panel."""
     return True
 
@@ -61,54 +105,72 @@ async def async_setup_platform(hass, config, async_add_entities, discovery_info=
 async def async_setup_entry(hass, config_entry, async_add_devices):
     """Set up the Alarmo entities."""
 
-    @callback
-    def async_add_alarm_entity(config: dict):
-        """Add each entity as Alarm Control Panel."""
-        entity_id = f"{PLATFORM}.{slugify(config['name'])}"
-
-        # Guard against duplicate registration (reloads/upgrade timing)
-        if config["area_id"] in hass.data[const.DOMAIN]["areas"]:
-            existing = hass.data[const.DOMAIN]["areas"][config["area_id"]]
-            if existing and getattr(existing, "entity_id", None) == entity_id:
+    @callback
+    def async_add_alarm_entity(config: dict):
+        """Add each entity as Alarm Control Panel."""
+        unique_id = _build_unique_id(hass, config["area_id"])
+        entity_registry = er.async_get(hass)
+        existing_entity_id = entity_registry.async_get_entity_id(
+            PLATFORM, const.DOMAIN, unique_id
+        )
+        suggested_entity_id = f"{PLATFORM}.{slugify(config['name'])}"
+        entity_id = existing_entity_id or _get_available_entity_id(
+            hass, suggested_entity_id
+        )
+
+        # Guard against duplicate registration (reloads/upgrade timing)
+        if config["area_id"] in hass.data[const.DOMAIN]["areas"]:
+            existing = hass.data[const.DOMAIN]["areas"][config["area_id"]]
+            if existing and getattr(existing, "entity_id", None) == entity_id:
                 _LOGGER.debug(
                     "Area %s already registered as %s; skipping duplicate add",
                     config["area_id"],
                     entity_id,
                 )
                 return
 
-        alarm_entity = AlarmoAreaEntity(
-            hass=hass,
-            entity_id=entity_id,
-            name=config["name"],
-            area_id=config["area_id"],
-        )
+        alarm_entity = AlarmoAreaEntity(
+            hass=hass,
+            entity_id=entity_id,
+            unique_id=unique_id,
+            name=config["name"],
+            area_id=config["area_id"],
+        )
         hass.data[const.DOMAIN]["areas"][config["area_id"]] = alarm_entity
         async_add_devices([alarm_entity])
 
     unsub_area = async_dispatcher_connect(
         hass, "alarmo_register_entity", async_add_alarm_entity
     )
 
-    @callback
-    def async_add_alarm_master(config: dict):
-        """Add each entity as Alarm Control Panel."""
-        entity_id = f"{PLATFORM}.{slugify(config['name'])}"
-
-        # Guard against duplicate master registration
-        if hass.data[const.DOMAIN]["master"] is not None:
-            existing = hass.data[const.DOMAIN]["master"]
-            if existing and getattr(existing, "entity_id", None) == entity_id:
+    @callback
+    def async_add_alarm_master(config: dict):
+        """Add each entity as Alarm Control Panel."""
+        unique_id = _build_unique_id(hass)
+        entity_registry = er.async_get(hass)
+        existing_entity_id = entity_registry.async_get_entity_id(
+            PLATFORM, const.DOMAIN, unique_id
+        )
+        suggested_entity_id = f"{PLATFORM}.{slugify(config['name'])}"
+        entity_id = existing_entity_id or _get_available_entity_id(
+            hass, suggested_entity_id
+        )
+
+        # Guard against duplicate master registration
+        if hass.data[const.DOMAIN]["master"] is not None:
+            existing = hass.data[const.DOMAIN]["master"]
+            if existing and getattr(existing, "entity_id", None) == entity_id:
                 _LOGGER.debug(
                     "Master already registered as %s; skipping duplicate add", entity_id
                 )
                 return
 
-        alarm_entity = AlarmoMasterEntity(
-            hass=hass,
-            entity_id=entity_id,
-            name=config["name"],
-        )
+        alarm_entity = AlarmoMasterEntity(
+            hass=hass,
+            entity_id=entity_id,
+            unique_id=unique_id,
+            name=config["name"],
+        )
         hass.data[const.DOMAIN]["master"] = alarm_entity
         async_add_devices([alarm_entity])
 
@@ -155,13 +217,16 @@ async def async_unload_entry(hass, config_entry):
     return True
 
 
-class AlarmoBaseEntity(AlarmControlPanelEntity, RestoreEntity):
+class AlarmoBaseEntity(AlarmControlPanelEntity, RestoreEntity):
     """Defines a base alarm_control_panel entity."""
 
-    def __init__(self, hass: HomeAssistant, name: str, entity_id: str) -> None:
-        """Initialize the alarm_control_panel entity."""
-        self.entity_id = entity_id
-        self._name = name
+    def __init__(
+        self, hass: HomeAssistant, name: str, entity_id: str, unique_id: str
+    ) -> None:
+        """Initialize the alarm_control_panel entity."""
+        self.entity_id = entity_id
+        self._attr_unique_id = unique_id
+        self._name = name
         self._state = None
         self.hass = hass
         self._config = {}
@@ -191,9 +256,9 @@ def device_info(self) -> dict:
         }
 
     @property
-    def unique_id(self):
-        """Return a unique ID to use for this entity."""
-        return f"{self.entity_id}"
+    def unique_id(self):
+        """Return a unique ID to use for this entity."""
+        return self._attr_unique_id
 
     @property
     def name(self):
@@ -698,14 +763,19 @@ async def async_will_remove_from_hass(self):
         )
 
 
-class AlarmoAreaEntity(AlarmoBaseEntity):
+class AlarmoAreaEntity(AlarmoBaseEntity):
     """Defines a base alarm_control_panel entity."""
 
-    def __init__(
-        self, hass: HomeAssistant, name: str, entity_id: str, area_id: str
-    ) -> None:
-        """Initialize the alarm_control_panel entity."""
-        super().__init__(hass, name, entity_id)
+    def __init__(
+        self,
+        hass: HomeAssistant,
+        name: str,
+        entity_id: str,
+        unique_id: str,
+        area_id: str,
+    ) -> None:
+        """Initialize the alarm_control_panel entity."""
+        super().__init__(hass, name, entity_id, unique_id)
 
         self.area_id = area_id
         self._timer = None
@@ -1169,12 +1239,14 @@ def update_ready_to_arm_modes(self, value):
         )
 
 
-class AlarmoMasterEntity(AlarmoBaseEntity):
+class AlarmoMasterEntity(AlarmoBaseEntity):
     """Defines a base alarm_control_panel entity."""
 
-    def __init__(self, hass: HomeAssistant, name: str, entity_id: str) -> None:
-        """Initialize the alarm_control_panel entity."""
-        super().__init__(hass, name, entity_id)
+    def __init__(
+        self, hass: HomeAssistant, name: str, entity_id: str, unique_id: str
+    ) -> None:
+        """Initialize the alarm_control_panel entity."""
+        super().__init__(hass, name, entity_id, unique_id)
         self.area_id = None
         self._target_state = None