Add support for more cover devices in Fibaro (home-assistant#146486)

Author: rappenze

homeassistant/components/fibaro/cover.py

@@ -28,66 +28,52 @@ async def async_setup_entry(
 ) -> None:
     """Set up the Fibaro covers."""
     controller = entry.runtime_data
-    async_add_entities(
-        [FibaroCover(device) for device in controller.fibaro_devices[Platform.COVER]],
-        True,
-    )
 
+    entities: list[FibaroEntity] = []
+    for device in controller.fibaro_devices[Platform.COVER]:
+        # Positionable covers report the position over value
+        if device.value.has_value:
+            entities.append(PositionableFibaroCover(device))
+        else:
+            entities.append(FibaroCover(device))
+    async_add_entities(entities, True)
 
-class FibaroCover(FibaroEntity, CoverEntity):
-    """Representation a Fibaro Cover."""
+
+class PositionableFibaroCover(FibaroEntity, CoverEntity):
+    """Representation of a fibaro cover which supports positioning."""
 
     def __init__(self, fibaro_device: DeviceModel) -> None:
-        """Initialize the Vera device."""
+        """Initialize the device."""
         super().__init__(fibaro_device)
         self.entity_id = ENTITY_ID_FORMAT.format(self.ha_id)
 
-        if self._is_open_close_only():
-            self._attr_supported_features = (
-                CoverEntityFeature.OPEN | CoverEntityFeature.CLOSE
-            )
-            if "stop" in self.fibaro_device.actions:
-                self._attr_supported_features |= CoverEntityFeature.STOP
-
     @staticmethod
-    def bound(position):
+    def bound(position: int | None) -> int | None:
         """Normalize the position."""
         if position is None:
             return None
-        position = int(position)
         if position <= 5:
             return 0
         if position >= 95:
             return 100
         return position
 
-    def _is_open_close_only(self) -> bool:
-        """Return if only open / close is supported."""
-        # Normally positionable devices report the position over value,
-        # so if it is missing we have a device which supports open / close only
-        return not self.fibaro_device.value.has_value
-
     def update(self) -> None:
         """Update the state."""
         super().update()
 
         self._attr_current_cover_position = self.bound(self.level)
         self._attr_current_cover_tilt_position = self.bound(self.level2)
 
-        device_state = self.fibaro_device.state
-
         # Be aware that opening and closing is only available for some modern
         # devices.
         # For example the Fibaro Roller Shutter 4 reports this correctly.
-        if device_state.has_value:
-            self._attr_is_opening = device_state.str_value().lower() == "opening"
-            self._attr_is_closing = device_state.str_value().lower() == "closing"
+        device_state = self.fibaro_device.state.str_value(default="").lower()
+        self._attr_is_opening = device_state == "opening"
+        self._attr_is_closing = device_state == "closing"
 
         closed: bool | None = None
-        if self._is_open_close_only():
-            if device_state.has_value and device_state.str_value().lower() != "unknown":
-                closed = device_state.str_value().lower() == "closed"
-        elif self.current_cover_position is not None:
+        if self.current_cover_position is not None:
             closed = self.current_cover_position == 0
         self._attr_is_closed = closed
 
@@ -96,7 +82,7 @@ def set_cover_position(self, **kwargs: Any) -> None:
         self.set_level(cast(int, kwargs.get(ATTR_POSITION)))
 
     def set_cover_tilt_position(self, **kwargs: Any) -> None:
-        """Move the cover to a specific position."""
+        """Move the slats to a specific position."""
         self.set_level2(cast(int, kwargs.get(ATTR_TILT_POSITION)))
 
     def open_cover(self, **kwargs: Any) -> None:
@@ -118,3 +104,62 @@ def close_cover_tilt(self, **kwargs: Any) -> None:
     def stop_cover(self, **kwargs: Any) -> None:
         """Stop the cover."""
         self.action("stop")
+
+
+class FibaroCover(FibaroEntity, CoverEntity):
+    """Representation of a fibaro cover which supports only open / close commands."""
+
+    def __init__(self, fibaro_device: DeviceModel) -> None:
+        """Initialize the device."""
+        super().__init__(fibaro_device)
+        self.entity_id = ENTITY_ID_FORMAT.format(self.ha_id)
+
+        self._attr_supported_features = (
+            CoverEntityFeature.OPEN | CoverEntityFeature.CLOSE
+        )
+        if "stop" in self.fibaro_device.actions:
+            self._attr_supported_features |= CoverEntityFeature.STOP
+        if "rotateSlatsUp" in self.fibaro_device.actions:
+            self._attr_supported_features |= CoverEntityFeature.OPEN_TILT
+        if "rotateSlatsDown" in self.fibaro_device.actions:
+            self._attr_supported_features |= CoverEntityFeature.CLOSE_TILT
+        if "stopSlats" in self.fibaro_device.actions:
+            self._attr_supported_features |= CoverEntityFeature.STOP_TILT
+
+    def update(self) -> None:
+        """Update the state."""
+        super().update()
+
+        device_state = self.fibaro_device.state.str_value(default="").lower()
+
+        self._attr_is_opening = device_state == "opening"
+        self._attr_is_closing = device_state == "closing"
+
+        closed: bool | None = None
+        if device_state not in {"", "unknown"}:
+            closed = device_state == "closed"
+        self._attr_is_closed = closed
+
+    def open_cover(self, **kwargs: Any) -> None:
+        """Open the cover."""
+        self.action("open")
+
+    def close_cover(self, **kwargs: Any) -> None:
+        """Close the cover."""
+        self.action("close")
+
+    def stop_cover(self, **kwargs: Any) -> None:
+        """Stop the cover."""
+        self.action("stop")
+
+    def open_cover_tilt(self, **kwargs: Any) -> None:
+        """Open the cover slats."""
+        self.action("rotateSlatsUp")
+
+    def close_cover_tilt(self, **kwargs: Any) -> None:
+        """Close the cover slats."""
+        self.action("rotateSlatsDown")
+
+    def stop_cover_tilt(self, **kwargs: Any) -> None:
+        """Stop the cover slats turning."""
+        self.action("stopSlats")

tests/components/fibaro/conftest.py

@@ -83,8 +83,8 @@ def mock_power_sensor() -> Mock:
 
 
 @pytest.fixture
-def mock_cover() -> Mock:
-    """Fixture for a cover."""
+def mock_positionable_cover() -> Mock:
+    """Fixture for a positionable cover."""
     cover = Mock()
     cover.fibaro_id = 3
     cover.parent_fibaro_id = 0
@@ -112,6 +112,42 @@ def mock_cover() -> Mock:
     return cover
 
 
+@pytest.fixture
+def mock_cover() -> Mock:
+    """Fixture for a cover supporting slats but without positioning."""
+    cover = Mock()
+    cover.fibaro_id = 4
+    cover.parent_fibaro_id = 0
+    cover.name = "Test cover"
+    cover.room_id = 1
+    cover.dead = False
+    cover.visible = True
+    cover.enabled = True
+    cover.type = "com.fibaro.baseShutter"
+    cover.base_type = "com.fibaro.actor"
+    cover.properties = {"manufacturer": ""}
+    cover.actions = {
+        "open": 0,
+        "close": 0,
+        "stop": 0,
+        "rotateSlatsUp": 0,
+        "rotateSlatsDown": 0,
+        "stopSlats": 0,
+    }
+    cover.supported_features = {}
+    value_mock = Mock()
+    value_mock.has_value = False
+    cover.value = value_mock
+    value2_mock = Mock()
+    value2_mock.has_value = False
+    cover.value_2 = value2_mock
+    state_mock = Mock()
+    state_mock.has_value = True
+    state_mock.str_value.return_value = "closed"
+    cover.state = state_mock
+    return cover
+
+
 @pytest.fixture
 def mock_light() -> Mock:
     """Fixture for a dimmmable light."""