Add mute alarm button for Shelly Plus Smoke (home-assistant#154673)

Author: bieniu

homeassistant/components/shelly/__init__.py

@@ -98,6 +98,7 @@
 ]
 RPC_SLEEPING_PLATFORMS: Final = [
     Platform.BINARY_SENSOR,
+    Platform.BUTTON,
     Platform.SENSOR,
     Platform.UPDATE,
 ]

homeassistant/components/shelly/button.py

@@ -24,6 +24,7 @@
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
 
 from .const import (
+    CONF_SLEEP_PERIOD,
     DOMAIN,
     LOGGER,
     MODEL_FRANKEVER_WATER_VALVE,
@@ -34,6 +35,7 @@
 from .entity import (
     RpcEntityDescription,
     ShellyRpcAttributeEntity,
+    ShellySleepingRpcAttributeEntity,
     async_setup_entry_rpc,
     get_entity_block_device_info,
     get_entity_rpc_device_info,
@@ -190,9 +192,10 @@ async def async_setup_entry(
     if TYPE_CHECKING:
         assert coordinator is not None
 
-    await er.async_migrate_entries(
-        hass, config_entry.entry_id, partial(async_migrate_unique_ids, coordinator)
-    )
+    if coordinator.device.initialized:
+        await er.async_migrate_entries(
+            hass, config_entry.entry_id, partial(async_migrate_unique_ids, coordinator)
+        )
 
     entities: list[ShellyButton] = []
 
@@ -208,22 +211,31 @@ async def async_setup_entry(
         return
 
     # add RPC buttons
-    async_setup_entry_rpc(
-        hass, config_entry, async_add_entities, RPC_BUTTONS, RpcVirtualButton
-    )
+    if config_entry.data[CONF_SLEEP_PERIOD]:
+        async_setup_entry_rpc(
+            hass,
+            config_entry,
+            async_add_entities,
+            RPC_BUTTONS,
+            RpcSleepingSmokeMuteButton,
+        )
+    else:
+        async_setup_entry_rpc(
+            hass, config_entry, async_add_entities, RPC_BUTTONS, RpcVirtualButton
+        )
 
-    # the user can remove virtual components from the device configuration, so
-    # we need to remove orphaned entities
-    virtual_button_component_ids = get_virtual_component_ids(
-        coordinator.device.config, BUTTON_PLATFORM
-    )
-    async_remove_orphaned_entities(
-        hass,
-        config_entry.entry_id,
-        coordinator.mac,
-        BUTTON_PLATFORM,
-        virtual_button_component_ids,
-    )
+        # the user can remove virtual components from the device configuration, so
+        # we need to remove orphaned entities
+        virtual_button_component_ids = get_virtual_component_ids(
+            coordinator.device.config, BUTTON_PLATFORM
+        )
+        async_remove_orphaned_entities(
+            hass,
+            config_entry.entry_id,
+            coordinator.mac,
+            BUTTON_PLATFORM,
+            virtual_button_component_ids,
+        )
 
 
 class ShellyBaseButton(
@@ -354,6 +366,31 @@ async def async_press(self) -> None:
         await self.coordinator.device.button_trigger(self._id, "single_push")
 
 
+class RpcSleepingSmokeMuteButton(ShellySleepingRpcAttributeEntity, ButtonEntity):
+    """Defines a Shelly RPC Smoke mute alarm button."""
+
+    entity_description: RpcButtonDescription
+
+    @rpc_call
+    async def async_press(self) -> None:
+        """Triggers the Shelly button press service."""
+        if TYPE_CHECKING:
+            assert isinstance(self.coordinator, ShellyRpcCoordinator)
+
+        _id = int(self.key.split(":")[-1])
+        await self.coordinator.device.smoke_mute_alarm(_id)
+
+    @property
+    def available(self) -> bool:
+        """Available."""
+        available = super().available
+
+        if self.coordinator.device.initialized:
+            return available and self.status["alarm"]
+
+        return False
+
+
 RPC_BUTTONS = {
     "button_generic": RpcButtonDescription(
         key="button",
@@ -379,4 +416,10 @@ async def async_press(self) -> None:
         entity_class=ShellyBluTrvButton,
         models={MODEL_BLU_GATEWAY_G3},
     ),
+    "smoke_mute": RpcButtonDescription(
+        key="smoke",
+        sub_key="mute",
+        name="Mute alarm",
+        translation_key="mute",
+    ),
 }

tests/components/shelly/test_button.py

@@ -3,15 +3,20 @@
 from copy import deepcopy
 from unittest.mock import Mock
 
-from aioshelly.const import MODEL_BLU_GATEWAY_G3
+from aioshelly.const import MODEL_BLU_GATEWAY_G3, MODEL_PLUS_SMOKE
 from aioshelly.exceptions import DeviceConnectionError, InvalidAuthError, RpcCallError
 import pytest
 from syrupy.assertion import SnapshotAssertion
 
 from homeassistant.components.button import DOMAIN as BUTTON_DOMAIN, SERVICE_PRESS
 from homeassistant.components.shelly.const import DOMAIN, MODEL_FRANKEVER_WATER_VALVE
 from homeassistant.config_entries import SOURCE_REAUTH, ConfigEntryState
-from homeassistant.const import ATTR_ENTITY_ID, STATE_UNKNOWN, Platform
+from homeassistant.const import (
+    ATTR_ENTITY_ID,
+    STATE_UNAVAILABLE,
+    STATE_UNKNOWN,
+    Platform,
+)
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.device_registry import DeviceRegistry
@@ -20,6 +25,7 @@
 from . import (
     MOCK_MAC,
     init_integration,
+    mutate_rpc_device_status,
     patch_platforms,
     register_device,
     register_entity,
@@ -476,3 +482,59 @@ async def test_migrate_unique_id_virtual_components_roles(
     assert entity_entry.unique_id == new_unique_id
 
     assert "Migrating unique_id for button.test_name_test_button" in caplog.text
+
+
+async def test_rpc_smoke_mute_alarm_button(
+    hass: HomeAssistant,
+    mock_rpc_device: Mock,
+    device_registry: DeviceRegistry,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Test RPC smoke mute alarm button."""
+    entity_id = f"{BUTTON_DOMAIN}.test_name_mute_alarm"
+    status = {
+        "sys": {"wakeup_period": 1000},
+        "smoke:0": {
+            "id": 0,
+            "alarm": False,
+            "mute": False,
+        },
+    }
+    monkeypatch.setattr(mock_rpc_device, "status", status)
+    config = {"smoke:0": {"id": 0, "name": None}}
+    monkeypatch.setattr(mock_rpc_device, "config", config)
+    monkeypatch.setattr(mock_rpc_device, "connected", False)
+    entry = await init_integration(hass, 2, sleep_period=1000, model=MODEL_PLUS_SMOKE)
+
+    # Sensor should be created when device is online
+    assert hass.states.get(entity_id) is None
+
+    register_entity(
+        hass,
+        BUTTON_DOMAIN,
+        "test_name_mute_alarm",
+        "smoke:0-smoke_mute",
+        entry,
+    )
+
+    # Make device online
+    mock_rpc_device.mock_online()
+    await hass.async_block_till_done(wait_background_tasks=True)
+
+    assert (state := hass.states.get(entity_id))
+    assert state.state == STATE_UNAVAILABLE
+
+    mutate_rpc_device_status(monkeypatch, mock_rpc_device, "smoke:0", "alarm", True)
+    mock_rpc_device.mock_update()
+
+    assert (state := hass.states.get(entity_id))
+    assert state.state == STATE_UNKNOWN
+
+    await hass.services.async_call(
+        BUTTON_DOMAIN,
+        SERVICE_PRESS,
+        {ATTR_ENTITY_ID: entity_id},
+        blocking=True,
+    )
+    mock_rpc_device.mock_update()
+    mock_rpc_device.smoke_mute_alarm.assert_called_once_with(0)