Add initial support for SwitchBot relay switch

homeassistant/components/switchbot/__init__.py

@@ -24,6 +24,7 @@
     CONF_RETRY_COUNT,
     CONNECTABLE_SUPPORTED_MODEL_TYPES,
     DEFAULT_RETRY_COUNT,
+    ENCRYPTED_MODELS,
     HASS_SENSOR_TYPE_TO_SWITCHBOT_MODEL,
     SupportedModels,
 )
@@ -61,6 +62,8 @@
         Platform.SENSOR,
     ],
     SupportedModels.HUB2.value: [Platform.SENSOR],
+    SupportedModels.RELAY_SWITCH_1PM.value: [Platform.SWITCH, Platform.SENSOR],
+    SupportedModels.RELAY_SWITCH_1.value: [Platform.SWITCH],
 }
 CLASS_BY_DEVICE = {
     SupportedModels.CEILING_LIGHT.value: switchbot.SwitchbotCeilingLight,
@@ -73,6 +76,8 @@
     SupportedModels.LOCK.value: switchbot.SwitchbotLock,
     SupportedModels.LOCK_PRO.value: switchbot.SwitchbotLock,
     SupportedModels.BLIND_TILT.value: switchbot.SwitchbotBlindTilt,
+    SupportedModels.RELAY_SWITCH_1PM.value: switchbot.SwitchbotRelaySwitch,
+    SupportedModels.RELAY_SWITCH_1.value: switchbot.SwitchbotRelaySwitch,
 }
 
 
@@ -129,6 +134,19 @@
             raise ConfigEntryNotReady(
                 "Invalid encryption configuration provided"
             ) from error
+    elif switchbot_model in ENCRYPTED_MODELS:
+        try:
+            device = cls(
+                device=ble_device,
+                key_id=entry.data.get(CONF_KEY_ID),
+                encryption_key=entry.data.get(CONF_ENCRYPTION_KEY),
+                retry_count=entry.options[CONF_RETRY_COUNT],
+                model=switchbot_model,
+            )
+        except ValueError as error:
+            raise ConfigEntryNotReady(
+                "Invalid encryption configuration provided"
+            ) from error
     else:
         device = cls(
             device=ble_device,

homeassistant/components/switchbot/config_flow.py

@@ -44,6 +44,7 @@
     DEFAULT_LOCK_NIGHTLATCH,
     DEFAULT_RETRY_COUNT,
     DOMAIN,
+    ENCRYPTED_MODELS,
     NON_CONNECTABLE_SUPPORTED_MODEL_TYPES,
     SUPPORTED_LOCK_MODELS,
     SUPPORTED_MODEL_TYPES,
@@ -114,6 +115,8 @@ async def async_step_bluetooth(
         }
         if model_name in SUPPORTED_LOCK_MODELS:
             return await self.async_step_lock_choose_method()
+        if model_name in ENCRYPTED_MODELS:
+            return await self.async_step_choose_method()
         if self._discovered_adv.data["isEncrypted"]:
             return await self.async_step_password()
         return await self.async_step_confirm()
@@ -265,6 +268,91 @@ async def async_step_lock_key(
             },
         )
 
+    async def async_step_choose_method(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle the SwitchBot API chose method step."""
+        assert self._discovered_adv is not None
+
+        return self.async_show_menu(
+            step_id="choose_method",
+            menu_options=["auth", "key"],
+            description_placeholders={
+                "name": name_from_discovery(self._discovered_adv),
+            },
+        )
+
+    async def async_step_auth(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle the SwitchBot API auth step."""
+        errors = {}
+        assert self._discovered_adv is not None
+        description_placeholders = {}
+        if user_input is not None:
+            try:
+                key_details = await SwitchbotLock.async_retrieve_encryption_key(
+                    async_get_clientsession(self.hass),
+                    self._discovered_adv.address,
+                    user_input[CONF_USERNAME],
+                    user_input[CONF_PASSWORD],
+                )
+            except (SwitchbotApiError, SwitchbotAccountConnectionError) as ex:
+                _LOGGER.debug(
+                    "Failed to connect to SwitchBot API: %s", ex, exc_info=True
+                )
+                return self.async_abort(
+                    reason="api_error",
+                    description_placeholders={"error_detail": str(ex)},
+                )
+            except SwitchbotAuthenticationError as ex:
+                _LOGGER.debug("Authentication failed: %s", ex, exc_info=True)
+                errors = {"base": "auth_failed"}
+                description_placeholders = {"error_detail": str(ex)}
+            else:
+                return await self.async_step_key(key_details)
+
+        user_input = user_input or {}
+        return self.async_show_form(
+            step_id="auth",
+            errors=errors,
+            data_schema=vol.Schema(
+                {
+                    vol.Required(
+                        CONF_USERNAME, default=user_input.get(CONF_USERNAME)
+                    ): str,
+                    vol.Required(CONF_PASSWORD): str,
+                }
+            ),
+            description_placeholders={
+                "name": name_from_discovery(self._discovered_adv),
+                **description_placeholders,
+            },
+        )
+
+    async def async_step_key(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle the encryption key step."""
+        errors: dict[str, str] = {}
+        assert self._discovered_adv is not None
+        if user_input is not None:
+            return await self._async_create_entry_from_discovery(user_input)
+
+        return self.async_show_form(
+            step_id="key",
+            errors=errors,
+            data_schema=vol.Schema(
+                {
+                    vol.Required(CONF_KEY_ID): str,
+                    vol.Required(CONF_ENCRYPTION_KEY): str,
+                }
+            ),
+            description_placeholders={
+                "name": name_from_discovery(self._discovered_adv),
+            },
+        )
+
     @callback
     def _async_discover_devices(self) -> None:
         current_addresses = self._async_current_ids()
@@ -323,6 +411,8 @@ async def async_step_user(
             await self._async_set_device(device_adv)
             if device_adv.data.get("modelName") in SUPPORTED_LOCK_MODELS:
                 return await self.async_step_lock_choose_method()
+            if device_adv.data.get("modelName") in ENCRYPTED_MODELS:
+                return await self.async_step_choose_method()
             if device_adv.data["isEncrypted"]:
                 return await self.async_step_password()
             return await self.async_step_confirm()

homeassistant/components/switchbot/const.py

@@ -30,6 +30,8 @@ class SupportedModels(StrEnum):
     LOCK_PRO = "lock_pro"
     BLIND_TILT = "blind_tilt"
     HUB2 = "hub2"
+    RELAY_SWITCH_1PM = "relay_switch_1pm"
+    RELAY_SWITCH_1 = "relay_switch_1"
 
 
 CONNECTABLE_SUPPORTED_MODEL_TYPES = {
@@ -44,6 +46,8 @@ class SupportedModels(StrEnum):
     SwitchbotModel.LOCK_PRO: SupportedModels.LOCK_PRO,
     SwitchbotModel.BLIND_TILT: SupportedModels.BLIND_TILT,
     SwitchbotModel.HUB2: SupportedModels.HUB2,
+    SwitchbotModel.RELAY_SWITCH_1PM: SupportedModels.RELAY_SWITCH_1PM,
+    SwitchbotModel.RELAY_SWITCH_1: SupportedModels.RELAY_SWITCH_1,
 }
 
 NON_CONNECTABLE_SUPPORTED_MODEL_TYPES = {
@@ -60,6 +64,7 @@ class SupportedModels(StrEnum):
 )
 
 SUPPORTED_LOCK_MODELS = {SwitchbotModel.LOCK, SwitchbotModel.LOCK_PRO}
+ENCRYPTED_MODELS = {SwitchbotModel.RELAY_SWITCH_1, SwitchbotModel.RELAY_SWITCH_1PM}
 
 HASS_SENSOR_TYPE_TO_SWITCHBOT_MODEL = {
     str(v): k for k, v in SUPPORTED_MODEL_TYPES.items()

homeassistant/components/switchbot/sensor.py

@@ -14,6 +14,8 @@
     PERCENTAGE,
     SIGNAL_STRENGTH_DECIBELS_MILLIWATT,
     EntityCategory,
+    UnitOfElectricCurrent,
+    UnitOfElectricPotential,
     UnitOfPower,
     UnitOfTemperature,
 )
@@ -82,6 +84,18 @@
         state_class=SensorStateClass.MEASUREMENT,
         device_class=SensorDeviceClass.POWER,
     ),
+    "current": SensorEntityDescription(
+        key="current",
+        native_unit_of_measurement=UnitOfElectricCurrent.MILLIAMPERE,
+        state_class=SensorStateClass.MEASUREMENT,
+        device_class=SensorDeviceClass.CURRENT,
+    ),
+    "voltage": SensorEntityDescription(
+        key="voltage",
+        native_unit_of_measurement=UnitOfElectricPotential.VOLT,
+        state_class=SensorStateClass.MEASUREMENT,
+        device_class=SensorDeviceClass.VOLTAGE,
+    ),
 }
 
 

homeassistant/components/switchbot/strings.json

@@ -36,6 +36,27 @@
           "lock_auth": "SwitchBot account (recommended)",
           "lock_key": "Enter lock encryption key manually"
         }
+      },
+      "key": {
+        "description": "The {name} device requires encryption key, details on how to obtain it can be found in the documentation.",
+        "data": {
+          "key_id": "Key ID",
+          "encryption_key": "Encryption key"
+        }
+      },
+      "auth": {
+        "description": "Please provide your SwitchBot app username and password. This data won't be saved and only used to retrieve your device encryption key. Usernames and passwords are case sensitive.",
+        "data": {
+          "username": "[%key:common::config_flow::data::username%]",
+          "password": "[%key:common::config_flow::data::password%]"
+        }
+      },
+      "choose_method": {
+        "description": "A SwitchBot device can be set up in Home Assistant in two different ways.\n\nYou can enter the key id and encryption key yourself, or Home Assistant can import them from your SwitchBot account.",
+        "menu_options": {
+          "auth": "SwitchBot account (recommended)",
+          "key": "Enter lock encryption key manually"
+        }
       }
     },
     "error": {

tests/components/switchbot/__init__.py

@@ -230,3 +230,23 @@ async def init_integration(hass: HomeAssistant) -> MockConfigEntry:
     connectable=True,
     tx_power=-127,
 )
+
+WORELAY_SWITCH_1PM_SERVICE_INFO = BluetoothServiceInfoBleak(
+    name="W1080000",
+    manufacturer_data={2409: b"$X|\x0866G\x81\x00\x00\x001\x00\x00\x00\x00"},
+    service_data={"0000fd3d-0000-1000-8000-00805f9b34fb": b"<\x00\x00\x00"},
+    service_uuids=["cba20d00-224d-11e6-9fb8-0002a5d5c51b"],
+    address="AA:BB:CC:DD:EE:FF",
+    rssi=-60,
+    source="local",
+    advertisement=generate_advertisement_data(
+        local_name="W1080000",
+        manufacturer_data={2409: b"$X|\x0866G\x81\x00\x00\x001\x00\x00\x00\x00"},
+        service_data={"0000fd3d-0000-1000-8000-00805f9b34fb": b"<\x00\x00\x00"},
+        service_uuids=["cba20d00-224d-11e6-9fb8-0002a5d5c51b"],
+    ),
+    device=generate_ble_device("AA:BB:CC:DD:EE:FF", "W1080000"),
+    time=0,
+    connectable=True,
+    tx_power=-127,
+)