Add cover platform for switchbee integration

.coveragerc

@@ -1231,6 +1231,7 @@ omit =
     homeassistant/components/switchbee/__init__.py
     homeassistant/components/switchbee/button.py
     homeassistant/components/switchbee/coordinator.py
+    homeassistant/components/switchbee/cover.py
     homeassistant/components/switchbee/entity.py
     homeassistant/components/switchbee/light.py
     homeassistant/components/switchbee/switch.py

homeassistant/components/switchbee/__init__.py

@@ -13,7 +13,12 @@
 from .const import DOMAIN
 from .coordinator import SwitchBeeCoordinator
 
-PLATFORMS: list[Platform] = [Platform.BUTTON, Platform.LIGHT, Platform.SWITCH]
+PLATFORMS: list[Platform] = [
+    Platform.BUTTON,
+    Platform.COVER,
+    Platform.LIGHT,
+    Platform.SWITCH,
+]
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:

homeassistant/components/switchbee/coordinator.py

@@ -62,6 +62,8 @@ async def _async_update_data(self) -> Mapping[int, SwitchBeeBaseDevice]:
                         DeviceType.TimedPowerSwitch,
                         DeviceType.Scenario,
                         DeviceType.Dimmer,
+                        DeviceType.Shutter,
+                        DeviceType.Somfy,
                     ]
                 )
             except SwitchBeeError as exp:

homeassistant/components/switchbee/cover.py

@@ -0,0 +1,182 @@
+"""Support for SwitchBee cover."""
+
+from __future__ import annotations
+
+from typing import Any, cast
+
+from switchbee.api import SwitchBeeError, SwitchBeeTokenError
+from switchbee.const import SomfyCommand
+from switchbee.device import SwitchBeeShutter, SwitchBeeSomfy
+
+from homeassistant.components.cover import (
+    ATTR_POSITION,
+    CoverDeviceClass,
+    CoverEntity,
+    CoverEntityFeature,
+)
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers.entity_platform import AddEntitiesCallback
+
+from .const import DOMAIN
+from .coordinator import SwitchBeeCoordinator
+from .entity import SwitchBeeDeviceEntity
+
+
+async def async_setup_entry(
+    hass: HomeAssistant, entry: ConfigEntry, async_add_entities: AddEntitiesCallback
+) -> None:
+    """Set up SwitchBee switch."""
+    coordinator: SwitchBeeCoordinator = hass.data[DOMAIN][entry.entry_id]
+    async_add_entities(
+        SwitchBeeCoverEntity(device, coordinator)
+        for device in coordinator.data.values()
+        if isinstance(
+            device,
+            SwitchBeeShutter,
+        )
+    )
+
+    async_add_entities(
+        SwitchBeeSomfyEntity(device, coordinator)
+        for device in coordinator.data.values()
+        if isinstance(
+            device,
+            SwitchBeeSomfy,
+        )
+    )
+
+
+class SwitchBeeSomfyEntity(SwitchBeeDeviceEntity[SwitchBeeSomfy], CoverEntity):
+    """Representation of a SwitchBee Somfy cover."""
+
+    _attr_device_class = CoverDeviceClass.SHUTTER
+
+    def __init__(
+        self,
+        device: SwitchBeeSomfy,
+        coordinator: SwitchBeeCoordinator,
+    ) -> None:
+        """Initialize the SwitchBee cover."""
+        super().__init__(device, coordinator)
+        self._attr_current_cover_position = 0
+        self._attr_is_closed = True
+        self._attr_supported_features = (
+            CoverEntityFeature.CLOSE | CoverEntityFeature.OPEN | CoverEntityFeature.STOP
+        )
+
+    async def _fire_somfy_command(self, command: str) -> None:
+        """Async function to fire Somfy device command."""
+        try:
+            await self.coordinator.api.set_state(self._device.id, command)
+        except (SwitchBeeError, SwitchBeeTokenError) as exp:
+            raise HomeAssistantError(
+                f"Failed to fire {command} for {self.name}, {str(exp)}"
+            ) from exp
+
+    async def async_open_cover(self, **kwargs: Any) -> None:
+        """Open the cover."""
+        return await self._fire_somfy_command(SomfyCommand.UP)
+
+    async def async_close_cover(self, **kwargs: Any) -> None:
+        """Close the cover."""
+        return await self._fire_somfy_command(SomfyCommand.DOWN)
+
+    async def async_stop_cover(self, **kwargs: Any) -> None:
+        """Stop a moving cover."""
+        return await self._fire_somfy_command(SomfyCommand.MY)
+
+
+class SwitchBeeCoverEntity(SwitchBeeDeviceEntity[SwitchBeeShutter], CoverEntity):
+    """Representation of a SwitchBee cover."""
+
+    _attr_device_class = CoverDeviceClass.SHUTTER
+
+    def __init__(
+        self,
+        device: SwitchBeeShutter,
+        coordinator: SwitchBeeCoordinator,
+    ) -> None:
+        """Initialize the SwitchBee cover."""
+        super().__init__(device, coordinator)
+        self._attr_current_cover_position = 0
+        self._attr_is_closed = True
+        self._attr_supported_features = (
+            CoverEntityFeature.CLOSE
+            | CoverEntityFeature.OPEN
+            | CoverEntityFeature.SET_POSITION
+            | CoverEntityFeature.STOP
+        )
+
+    @callback
+    def _handle_coordinator_update(self) -> None:
+        """Handle updated data from the coordinator."""
+        self._update_from_coordinator()
+        super()._handle_coordinator_update()
+
+    def _update_from_coordinator(self) -> None:
+        """Update the entity attributes from the coordinator data."""
+
+        coordinator_device = cast(
+            SwitchBeeShutter, self.coordinator.data[self._device.id]
+        )
+
+        if coordinator_device.position == -1:
+            self._check_if_became_offline()
+            return
+
+        # check if the device was offline (now online) and bring it back
+        self._check_if_became_online()
+
+        self._attr_current_cover_position = coordinator_device.position
+
+        if self._attr_current_cover_position == 0:
+            self._attr_is_closed = True
+        else:
+            self._attr_is_closed = False
+        super()._handle_coordinator_update()
+
+    async def async_open_cover(self, **kwargs: Any) -> None:
+        """Open the cover."""
+        if self._attr_current_cover_position == 100:
+            return
+
+        await self.async_set_cover_position(position=100)
+
+    async def async_close_cover(self, **kwargs: Any) -> None:
+        """Close the cover."""
+        if self._attr_current_cover_position == 0:
+            return
+
+        await self.async_set_cover_position(position=0)
+
+    async def async_stop_cover(self, **kwargs: Any) -> None:
+        """Stop a moving cover."""
+        # to stop the shutter, we just interrupt it with any state during operation
+        await self.async_set_cover_position(
+            position=self._attr_current_cover_position, force=True
+        )
+
+        # fetch data from the Central Unit to get the new position
+        await self.coordinator.async_request_refresh()
+
+    async def async_set_cover_position(self, **kwargs: Any) -> None:
+        """Async function to set position to cover."""
+        if (
+            self._attr_current_cover_position == kwargs[ATTR_POSITION]
+            and "force" not in kwargs
+        ):
+            return
+        try:
+            await self.coordinator.api.set_state(self._device.id, kwargs[ATTR_POSITION])
+        except (SwitchBeeError, SwitchBeeTokenError) as exp:
+            raise HomeAssistantError(
+                f"Failed to set {self._attr_name} position to {str(kwargs[ATTR_POSITION])}, error: {str(exp)}"
+            ) from exp
+        else:
+            cast(
+                SwitchBeeShutter, self.coordinator.data[self._device.id]
+            ).position = kwargs[ATTR_POSITION]
+            self.coordinator.async_set_updated_data(self.coordinator.data)
+            self.async_write_ha_state()

homeassistant/components/switchbee/entity.py

@@ -4,7 +4,7 @@
 
 from switchbee import SWITCHBEE_BRAND
 from switchbee.api import SwitchBeeDeviceOfflineError, SwitchBeeError
-from switchbee.device import SwitchBeeBaseDevice
+from switchbee.device import SwitchBeeBaseDevice, DeviceType
 
 from homeassistant.helpers.entity import DeviceInfo
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
@@ -46,22 +46,23 @@ def __init__(
         """Initialize the Switchbee device."""
         super().__init__(device, coordinator)
         self._is_online: bool = True
-        self._attr_device_info = DeviceInfo(
-            name=f"SwitchBee {device.unit_id}",
-            identifiers={
-                (
+        if self._device.type not in [DeviceType.Somfy]:
+            self._attr_device_info = DeviceInfo(
+                name=f"SwitchBee {device.unit_id}",
+                identifiers={
+                    (
+                        DOMAIN,
+                        f"{device.unit_id}-{coordinator.mac_formatted}",
+                    )
+                },
+                manufacturer=SWITCHBEE_BRAND,
+                model=coordinator.api.module_display(device.unit_id),
+                suggested_area=device.zone,
+                via_device=(
                     DOMAIN,
-                    f"{device.unit_id}-{coordinator.mac_formatted}",
-                )
-            },
-            manufacturer=SWITCHBEE_BRAND,
-            model=coordinator.api.module_display(device.unit_id),
-            suggested_area=device.zone,
-            via_device=(
-                DOMAIN,
-                f"{coordinator.api.name} ({coordinator.api.mac})",
-            ),
-        )
+                    f"{coordinator.api.name} ({coordinator.api.mac})",
+                ),
+            )
 
     @property
     def available(self) -> bool: