Add Light platform to Switchbot cloud (#146382)

homeassistant/components/switchbot_cloud/__init__.py

@@ -30,6 +30,7 @@ PLATFORMS: list[Platform] = [
     Platform.BUTTON,
     Platform.CLIMATE,
     Platform.FAN,
+    Platform.LIGHT,
     Platform.LOCK,
     Platform.SENSOR,
     Platform.SWITCH,
@@ -53,6 +54,7 @@ class SwitchbotDevices:
     vacuums: list[tuple[Device, SwitchBotCoordinator]] = field(default_factory=list)
     locks: list[tuple[Device, SwitchBotCoordinator]] = field(default_factory=list)
     fans: list[tuple[Device, SwitchBotCoordinator]] = field(default_factory=list)
+    lights: list[tuple[Device, SwitchBotCoordinator]] = field(default_factory=list)
 
 
 @dataclass
@@ -191,6 +193,17 @@ async def make_device_data(
         devices_data.fans.append((device, coordinator))
         devices_data.sensors.append((device, coordinator))
 
+    if isinstance(device, Device) and device.device_type in [
+        "Strip Light",
+        "Strip Light 3",
+        "Floor Lamp",
+        "Color Bulb",
+    ]:
+        coordinator = await coordinator_for_device(
+            hass, entry, api, device, coordinators_by_id
+        )
+        devices_data.lights.append((device, coordinator))
+
 
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Set up SwitchBot via API from a config entry."""

homeassistant/components/switchbot_cloud/const.py

@@ -15,3 +15,5 @@ VACUUM_FAN_SPEED_QUIET = "quiet"
 VACUUM_FAN_SPEED_STANDARD = "standard"
 VACUUM_FAN_SPEED_STRONG = "strong"
 VACUUM_FAN_SPEED_MAX = "max"
+
+AFTER_COMMAND_REFRESH = 5

homeassistant/components/switchbot_cloud/light.py

@@ -0,0 +1,153 @@
+"""Support for the Switchbot Light."""
+
+import asyncio
+from typing import Any
+
+from switchbot_api import (
+    CommonCommands,
+    Device,
+    Remote,
+    RGBWLightCommands,
+    RGBWWLightCommands,
+    SwitchBotAPI,
+)
+
+from homeassistant.components.light import ColorMode, LightEntity
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from . import SwitchbotCloudData, SwitchBotCoordinator
+from .const import AFTER_COMMAND_REFRESH, DOMAIN
+from .entity import SwitchBotCloudEntity
+
+
+def value_map_brightness(value: int) -> int:
+    """Return value for brightness map."""
+    return int(value / 255 * 100)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config: ConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up SwitchBot Cloud entry."""
+    data: SwitchbotCloudData = hass.data[DOMAIN][config.entry_id]
+    async_add_entities(
+        _async_make_entity(data.api, device, coordinator)
+        for device, coordinator in data.devices.lights
+    )
+
+
+class SwitchBotCloudLight(SwitchBotCloudEntity, LightEntity):
+    """Base Class for SwitchBot Light."""
+
+    _attr_is_on: bool | None = None
+    _attr_name: str | None = None
+
+    _attr_color_mode = ColorMode.UNKNOWN
+
+    def _set_attributes(self) -> None:
+        """Set attributes from coordinator data."""
+        if self.coordinator.data is None:
+            return
+
+        power: str | None = self.coordinator.data.get("power")
+        brightness: int | None = self.coordinator.data.get("brightness")
+        color: str | None = self.coordinator.data.get("color")
+        color_temperature: int | None = self.coordinator.data.get("colorTemperature")
+        self._attr_is_on = power == "on" if power else None
+        self._attr_brightness: int | None = brightness if brightness else None
+        self._attr_rgb_color: tuple | None = (
+            (tuple(int(i) for i in color.split(":"))) if color else None
+        )
+        self._attr_color_temp_kelvin: int | None = (
+            color_temperature if color_temperature else None
+        )
+
+    async def async_turn_off(self, **kwargs: Any) -> None:
+        """Turn the light off."""
+        await self.send_api_command(CommonCommands.OFF)
+        await asyncio.sleep(AFTER_COMMAND_REFRESH)
+        await self.coordinator.async_request_refresh()
+
+    async def async_turn_on(self, **kwargs: Any) -> None:
+        """Turn the light on."""
+        brightness: int | None = kwargs.get("brightness")
+        rgb_color: tuple[int, int, int] | None = kwargs.get("rgb_color")
+        color_temp_kelvin: int | None = kwargs.get("color_temp_kelvin")
+        if brightness is not None:
+            self._attr_color_mode = ColorMode.RGB
+            await self._send_brightness_command(brightness)
+        elif rgb_color is not None:
+            self._attr_color_mode = ColorMode.RGB
+            await self._send_rgb_color_command(rgb_color)
+        elif color_temp_kelvin is not None:
+            self._attr_color_mode = ColorMode.COLOR_TEMP
+            await self._send_color_temperature_command(color_temp_kelvin)
+        else:
+            self._attr_color_mode = ColorMode.RGB
+            await self.send_api_command(CommonCommands.ON)
+        await asyncio.sleep(AFTER_COMMAND_REFRESH)
+        await self.coordinator.async_request_refresh()
+
+    async def _send_brightness_command(self, brightness: int) -> None:
+        """Send a brightness command."""
+        await self.send_api_command(
+            RGBWLightCommands.SET_BRIGHTNESS,
+            parameters=str(value_map_brightness(brightness)),
+        )
+
+    async def _send_rgb_color_command(self, rgb_color: tuple) -> None:
+        """Send an RGB command."""
+        await self.send_api_command(
+            RGBWLightCommands.SET_COLOR,
+            parameters=f"{rgb_color[2]}:{rgb_color[1]}:{rgb_color[0]}",
+        )
+
+    async def _send_color_temperature_command(self, color_temp_kelvin: int) -> None:
+        """Send a color temperature command."""
+        await self.send_api_command(
+            RGBWWLightCommands.SET_COLOR_TEMPERATURE,
+            parameters=str(color_temp_kelvin),
+        )
+
+
+class SwitchBotCloudStripLight(SwitchBotCloudLight):
+    """Representation of a SwitchBot Strip Light."""
+
+    _attr_supported_color_modes = {ColorMode.RGB}
+
+
+class SwitchBotCloudRGBWWLight(SwitchBotCloudLight):
+    """Representation of SwitchBot |Strip Light|Floor Lamp|Color Bulb."""
+
+    _attr_max_color_temp_kelvin = 6500
+    _attr_min_color_temp_kelvin = 2700
+
+    _attr_supported_color_modes = {ColorMode.RGB, ColorMode.COLOR_TEMP}
+
+    async def _send_brightness_command(self, brightness: int) -> None:
+        """Send a brightness command."""
+        await self.send_api_command(
+            RGBWWLightCommands.SET_BRIGHTNESS,
+            parameters=str(value_map_brightness(brightness)),
+        )
+
+    async def _send_rgb_color_command(self, rgb_color: tuple) -> None:
+        """Send an RGB command."""
+        await self.send_api_command(
+            RGBWWLightCommands.SET_COLOR,
+            parameters=f"{rgb_color[0]}:{rgb_color[1]}:{rgb_color[2]}",
+        )
+
+
+@callback
+def _async_make_entity(
+    api: SwitchBotAPI, device: Device | Remote, coordinator: SwitchBotCoordinator
+) -> SwitchBotCloudStripLight | SwitchBotCloudRGBWWLight:
+    """Make a SwitchBotCloudLight."""
+    if device.device_type == "Strip Light":
+        return SwitchBotCloudStripLight(api, device, coordinator)
+    return SwitchBotCloudRGBWWLight(api, device, coordinator)

tests/components/switchbot_cloud/conftest.py

@@ -30,3 +30,12 @@ def mock_get_status():
     """Mock get_status."""
     with patch.object(SwitchBotAPI, "get_status") as mock_get_status:
         yield mock_get_status
+
+
+@pytest.fixture(scope="package", autouse=True)
+def mock_after_command_refresh():
+    """Mock after command refresh."""
+    with patch(
+        "homeassistant.components.switchbot_cloud.const.AFTER_COMMAND_REFRESH", 0
+    ):
+        yield

tests/components/switchbot_cloud/test_light.py

@@ -0,0 +1,300 @@
+"""Test for the Switchbot Light Entity."""
+
+from unittest.mock import patch
+
+from switchbot_api import Device, SwitchBotAPI
+
+from homeassistant.components.light import DOMAIN as LIGHT_DOMAIN
+from homeassistant.config_entries import ConfigEntryState
+from homeassistant.const import (
+    ATTR_ENTITY_ID,
+    SERVICE_TURN_OFF,
+    SERVICE_TURN_ON,
+    STATE_OFF,
+    STATE_ON,
+    STATE_UNKNOWN,
+)
+from homeassistant.core import HomeAssistant
+
+from . import configure_integration
+
+
+async def test_coordinator_data_is_none(
+    hass: HomeAssistant, mock_list_devices, mock_get_status
+) -> None:
+    """Test coordinator data is none."""
+
+    mock_list_devices.return_value = [
+        Device(
+            version="V1.0",
+            deviceId="light-id-1",
+            deviceName="light-1",
+            deviceType="Strip Light",
+            hubDeviceId="test-hub-id",
+        ),
+    ]
+    mock_get_status.side_effect = [None]
+    entry = await configure_integration(hass)
+    assert entry.state is ConfigEntryState.LOADED
+    entity_id = "light.light_1"
+    state = hass.states.get(entity_id)
+    assert state.state is STATE_UNKNOWN
+
+
+async def test_strip_light_turn_off(
+    hass: HomeAssistant, mock_list_devices, mock_get_status
+) -> None:
+    """Test strip light turn off."""
+
+    mock_list_devices.return_value = [
+        Device(
+            version="V1.0",
+            deviceId="light-id-1",
+            deviceName="light-1",
+            deviceType="Strip Light",
+            hubDeviceId="test-hub-id",
+        ),
+    ]
+    mock_get_status.side_effect = [
+        {"power": "off", "brightness": 1, "color": "0:0:0", "colorTemperature": 4567},
+        {"power": "off", "brightness": 10, "color": "0:0:0", "colorTemperature": 5555},
+    ]
+    entry = await configure_integration(hass)
+    assert entry.state is ConfigEntryState.LOADED
+    entity_id = "light.light_1"
+    # state = hass.states.get(entity_id)
+
+    with patch.object(SwitchBotAPI, "send_command") as mock_send_command:
+        await hass.services.async_call(
+            LIGHT_DOMAIN, SERVICE_TURN_OFF, {ATTR_ENTITY_ID: entity_id}, blocking=True
+        )
+        mock_send_command.assert_called_once()
+    state = hass.states.get(entity_id)
+    assert state.state is STATE_OFF
+
+
+async def test_rgbww_light_turn_off(
+    hass: HomeAssistant, mock_list_devices, mock_get_status
+) -> None:
+    """Test rgbww light turn_off."""
+
+    mock_list_devices.return_value = [
+        Device(
+            version="V1.0",
+            deviceId="light-id-1",
+            deviceName="light-1",
+            deviceType="Strip Light 3",
+            hubDeviceId="test-hub-id",
+        ),
+    ]
+    mock_get_status.side_effect = [
+        {"power": "off", "brightness": 1, "color": "0:0:0", "colorTemperature": 4567},
+        {"power": "off", "brightness": 10, "color": "0:0:0", "colorTemperature": 5555},
+    ]
+    entry = await configure_integration(hass)
+    assert entry.state is ConfigEntryState.LOADED
+    entity_id = "light.light_1"
+
+    with (
+        patch.object(SwitchBotAPI, "send_command") as mock_send_command,
+    ):
+        await hass.services.async_call(
+            LIGHT_DOMAIN, SERVICE_TURN_OFF, {ATTR_ENTITY_ID: entity_id}, blocking=True
+        )
+        mock_send_command.assert_called_once()
+    state = hass.states.get(entity_id)
+    assert state.state is STATE_OFF
+
+
+async def test_strip_light_turn_on(
+    hass: HomeAssistant, mock_list_devices, mock_get_status
+) -> None:
+    """Test strip light turn on."""
+    mock_list_devices.return_value = [
+        Device(
+            version="V1.0",
+            deviceId="light-id-1",
+            deviceName="light-1",
+            deviceType="Strip Light",
+            hubDeviceId="test-hub-id",
+        ),
+    ]
+    mock_get_status.side_effect = [
+        {"power": "off", "brightness": 1, "color": "0:0:0", "colorTemperature": 4567},
+        {"power": "on", "brightness": 10, "color": "0:0:0", "colorTemperature": 5555},
+        {
+            "power": "on",
+            "brightness": 10,
+            "color": "255:255:255",
+            "colorTemperature": 5555,
+        },
+        {
+            "power": "on",
+            "brightness": 10,
+            "color": "255:255:255",
+            "colorTemperature": 5555,
+        },
+        {
+            "power": "on",
+            "brightness": 10,
+            "color": "255:255:255",
+            "colorTemperature": 5555,
+        },
+        {
+            "power": "on",
+            "brightness": 10,
+            "color": "255:255:255",
+            "colorTemperature": 5555,
+        },
+    ]
+    entry = await configure_integration(hass)
+    assert entry.state is ConfigEntryState.LOADED
+    entity_id = "light.light_1"
+    state = hass.states.get(entity_id)
+    assert state.state is STATE_OFF
+    with patch.object(SwitchBotAPI, "send_command") as mock_send_command:
+        await hass.services.async_call(
+            LIGHT_DOMAIN,
+            SERVICE_TURN_ON,
+            {ATTR_ENTITY_ID: entity_id, "brightness": 99},
+            blocking=True,
+        )
+        mock_send_command.assert_called()
+    state = hass.states.get(entity_id)
+    assert state.state is STATE_ON
+
+    with patch.object(SwitchBotAPI, "send_command") as mock_send_command:
+        await hass.services.async_call(
+            LIGHT_DOMAIN,
+            SERVICE_TURN_ON,
+            {ATTR_ENTITY_ID: entity_id, "rgb_color": (255, 246, 158)},
+            blocking=True,
+        )
+        mock_send_command.assert_called()
+    state = hass.states.get(entity_id)
+    assert state.state is STATE_ON
+
+    with patch.object(SwitchBotAPI, "send_command") as mock_send_command:
+        await hass.services.async_call(
+            LIGHT_DOMAIN,
+            SERVICE_TURN_ON,
+            {ATTR_ENTITY_ID: entity_id, "color_temp_kelvin": 3333},
+            blocking=True,
+        )
+        mock_send_command.assert_called()
+    state = hass.states.get(entity_id)
+    assert state.state is STATE_ON
+
+    with patch.object(SwitchBotAPI, "send_command") as mock_send_command:
+        await hass.services.async_call(
+            LIGHT_DOMAIN,
+            SERVICE_TURN_ON,
+            {ATTR_ENTITY_ID: entity_id},
+            blocking=True,
+        )
+        mock_send_command.assert_called()
+    state = hass.states.get(entity_id)
+    assert state.state is STATE_ON
+
+
+async def test_rgbww_light_turn_on(
+    hass: HomeAssistant, mock_list_devices, mock_get_status
+) -> None:
+    """Test rgbww light turn on."""
+    mock_list_devices.return_value = [
+        Device(
+            version="V1.0",
+            deviceId="light-id-1",
+            deviceName="light-1",
+            deviceType="Strip Light 3",
+            hubDeviceId="test-hub-id",
+        ),
+    ]
+    mock_get_status.side_effect = [
+        {"power": "off", "brightness": 1, "color": "0:0:0", "colorTemperature": 4567},
+        {"power": "on", "brightness": 10, "color": "0:0:0", "colorTemperature": 5555},
+        {
+            "power": "on",
+            "brightness": 10,
+            "color": "255:255:255",
+            "colorTemperature": 5555,
+        },
+        {
+            "power": "on",
+            "brightness": 10,
+            "color": "255:255:255",
+            "colorTemperature": 5555,
+        },
+        {
+            "power": "on",
+            "brightness": 10,
+            "color": "255:255:255",
+            "colorTemperature": 5555,
+        },
+        {
+            "power": "on",
+            "brightness": 10,
+            "color": "255:255:255",
+            "colorTemperature": 5555,
+        },
+        {
+            "power": "on",
+            "brightness": 10,
+            "color": "255:255:255",
+            "colorTemperature": 5555,
+        },
+        {
+            "power": "on",
+            "brightness": 10,
+            "color": "255:255:255",
+            "colorTemperature": 5555,
+        },
+    ]
+    entry = await configure_integration(hass)
+    assert entry.state is ConfigEntryState.LOADED
+    entity_id = "light.light_1"
+    state = hass.states.get(entity_id)
+    assert state.state is STATE_OFF
+    with patch.object(SwitchBotAPI, "send_command") as mock_send_command:
+        await hass.services.async_call(
+            LIGHT_DOMAIN,
+            SERVICE_TURN_ON,
+            {ATTR_ENTITY_ID: entity_id, "color_temp_kelvin": 2800},
+            blocking=True,
+        )
+        mock_send_command.assert_called()
+    state = hass.states.get(entity_id)
+    assert state.state is STATE_ON
+
+    with patch.object(SwitchBotAPI, "send_command") as mock_send_command:
+        await hass.services.async_call(
+            LIGHT_DOMAIN,
+            SERVICE_TURN_ON,
+            {ATTR_ENTITY_ID: entity_id, "brightness": 99},
+            blocking=True,
+        )
+        mock_send_command.assert_called()
+    state = hass.states.get(entity_id)
+    assert state.state is STATE_ON
+
+    with patch.object(SwitchBotAPI, "send_command") as mock_send_command:
+        await hass.services.async_call(
+            LIGHT_DOMAIN,
+            SERVICE_TURN_ON,
+            {ATTR_ENTITY_ID: entity_id},
+            blocking=True,
+        )
+        mock_send_command.assert_called()
+    state = hass.states.get(entity_id)
+    assert state.state is STATE_ON
+
+    with patch.object(SwitchBotAPI, "send_command") as mock_send_command:
+        await hass.services.async_call(
+            LIGHT_DOMAIN,
+            SERVICE_TURN_ON,
+            {ATTR_ENTITY_ID: entity_id, "rgb_color": (255, 246, 158)},
+            blocking=True,
+        )
+        mock_send_command.assert_called()
+    state = hass.states.get(entity_id)
+    assert state.state is STATE_ON