home-assistant · alistair23 · Jan 12, 2025 · Mar 19, 2025 · Mar 19, 2025 · Mar 19, 2025
diff --git a/homeassistant/components/husqvarna_automower_ble/__init__.py b/homeassistant/components/husqvarna_automower_ble/__init__.py
@@ -3,14 +3,15 @@
 from __future__ import annotations
 
 from automower_ble.mower import Mower
+from automower_ble.protocol import ResponseResult
 from bleak import BleakError
 from bleak_retry_connector import close_stale_connections_by_address, get_device
 
 from homeassistant.components import bluetooth
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import CONF_ADDRESS, CONF_CLIENT_ID, Platform
+from homeassistant.const import CONF_ADDRESS, CONF_CLIENT_ID, CONF_PIN, Platform
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryNotReady
+from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
 
 from .const import LOGGER
 from .coordinator import HusqvarnaCoordinator
@@ -24,10 +25,14 @@
 
 async def async_setup_entry(hass: HomeAssistant, entry: HusqvarnaConfigEntry) -> bool:
     """Set up Husqvarna Autoconnect Bluetooth from a config entry."""
+    if CONF_PIN not in entry.data:
+        raise ConfigEntryAuthFailed
+
     address = entry.data[CONF_ADDRESS]
+    pin = entry.data[CONF_PIN]
     channel_id = entry.data[CONF_CLIENT_ID]
 
-    mower = Mower(channel_id, address)
+    mower = Mower(channel_id, address, pin)
 
     await close_stale_connections_by_address(address)
 
@@ -36,12 +41,18 @@ async def async_setup_entry(hass: HomeAssistant, entry: HusqvarnaConfigEntry) ->
         device = bluetooth.async_ble_device_from_address(
             hass, address, connectable=True
         ) or await get_device(address)
-        if not await mower.connect(device):
-            raise ConfigEntryNotReady
+        response_result = await mower.connect(device)
+        if response_result == ResponseResult.INVALID_PIN:
+            raise ConfigEntryAuthFailed(f"Unable to connect to device {address}")
+        if response_result != ResponseResult.OK:
+            raise ConfigEntryNotReady(
+                f"Unable to connect to device {address}, mower returned {response_result}"
+            )
     except (TimeoutError, BleakError) as exception:
         raise ConfigEntryNotReady(
             f"Unable to connect to device {address} due to {exception}"
         ) from exception
+
     LOGGER.debug("connected and paired")
 
     model = await mower.get_model()

diff --git a/homeassistant/components/husqvarna_automower_ble/config_flow.py b/homeassistant/components/husqvarna_automower_ble/config_flow.py
@@ -2,17 +2,20 @@
 
 from __future__ import annotations
 
+from collections.abc import Mapping
 import random
 from typing import Any
 
 from automower_ble.mower import Mower
+from automower_ble.protocol import ResponseResult
 from bleak import BleakError
+from bleak_retry_connector import get_device
 import voluptuous as vol
 
 from homeassistant.components import bluetooth
 from homeassistant.components.bluetooth import BluetoothServiceInfo
 from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
-from homeassistant.const import CONF_ADDRESS, CONF_CLIENT_ID
+from homeassistant.const import CONF_ADDRESS, CONF_CLIENT_ID, CONF_PIN
 
 from .const import DOMAIN, LOGGER
 
@@ -46,7 +49,8 @@ class HusqvarnaAutomowerBleConfigFlow(ConfigFlow, domain=DOMAIN):
 
     def __init__(self) -> None:
         """Initialize the config flow."""
-        self.address: str | None
+        self.address: str
+        self.pin: int | None
 
     async def async_step_bluetooth(
         self, discovery_info: BluetoothServiceInfo
@@ -60,62 +64,212 @@ async def async_step_bluetooth(
         self.address = discovery_info.address
         await self.async_set_unique_id(self.address)
         self._abort_if_unique_id_configured()
-        return await self.async_step_confirm()
+        return await self.async_step_bluetooth_confirm()
 
-    async def async_step_confirm(
+    async def async_step_bluetooth_confirm(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
-        """Confirm discovery."""
-        assert self.address
+        """Confirm Bluetooth discovery."""
 
-        device = bluetooth.async_ble_device_from_address(
-            self.hass, self.address, connectable=True
+        if user_input is not None:
+            self.pin = self.validate_pin(user_input[CONF_PIN])
+            return await self.async_step_bluetooth_finalise()
+
+        return self.async_show_form(
+            step_id="bluetooth_confirm",
+            data_schema=vol.Schema(
+                {
+                    vol.Required(CONF_PIN): int,
+                },
+            ),
+        )
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle the initial manual step."""
+
+        if user_input is not None:
+            self.address = user_input[CONF_ADDRESS]
+            self.pin = self.validate_pin(user_input[CONF_PIN])
+            await self.async_set_unique_id(self.address, raise_on_progress=False)
+            self._abort_if_unique_id_configured()
+            return await self.async_step_finalise()
+
+        return self.async_show_form(
+            step_id="user",
+            data_schema=vol.Schema(
+                {
+                    vol.Required(CONF_ADDRESS): str,
+                    vol.Required(CONF_PIN): int,
+                },
+            ),
         )
+
+    async def probe_mower(self, device) -> str | None:
+        """Probe the mower to see if it exists."""
         channel_id = random.randint(1, 0xFFFFFFFF)
 
+        assert self.address
+
         try:
             (manufacturer, device_type, model) = await Mower(
                 channel_id, self.address
             ).probe_gatts(device)
         except (BleakError, TimeoutError) as exception:
-            LOGGER.exception("Failed to connect to device: %s", exception)
-            return self.async_abort(reason="cannot_connect")
+            LOGGER.exception(f"Failed to probe device ({self.address}): {exception}")
+            return None
 
         title = manufacturer + " " + device_type
 
         LOGGER.debug("Found device: %s", title)
 
-        if user_input is not None:
-            return self.async_create_entry(
-                title=title,
-                data={CONF_ADDRESS: self.address, CONF_CLIENT_ID: channel_id},
-            )
+        return title
 
-        self.context["title_placeholders"] = {
-            "name": title,
-        }
+    async def connect_mower(self, device) -> tuple[int, Mower]:
+        """Connect to the Mower."""
+        assert self.address
+        assert self.pin is not None
 
-        self._set_confirm_only()
-        return self.async_show_form(
-            step_id="confirm",
-            description_placeholders=self.context["title_placeholders"],
+        channel_id = random.randint(1, 0xFFFFFFFF)
+        mower = Mower(channel_id, self.address, self.pin)
+
+        return (channel_id, mower)
+
+    def validate_pin(self, pin_str: str) -> int:
+        """Validate the PIN."""
+        try:
+            return int(pin_str)
+        except ValueError:
+            raise vol.Invalid("PIN needs to be an integer") from None
+
+    async def check_mower(
+        self,
+        ble_flow: bool,
+        user_input: dict[str, Any] | None = None,
+    ) -> ConfigFlowResult:
+        """Check that the mower exists and is setup."""
+        device = bluetooth.async_ble_device_from_address(
+            self.hass, self.address, connectable=True
         )
 
-    async def async_step_user(
+        title = await self.probe_mower(device)
+        if title is None:
+            return self.async_abort(reason="cannot_connect")
+
+        try:
+            errors: dict[str, str] = {}
+
+            (channel_id, mower) = await self.connect_mower(device)
+
+            response_result = await mower.connect(device)
+
+            if response_result is not ResponseResult.OK:
+                if (
+                    response_result is ResponseResult.INVALID_PIN
+                    or response_result is ResponseResult.NOT_ALLOWED
+                ):
+                    errors["base"] = "invalid_auth"
+                else:
+                    errors["base"] = "cannot_connect"
+
+                if ble_flow:
+                    return self.async_show_form(
+                        step_id="bluetooth_confirm",
+                        data_schema=vol.Schema(
+                            {
+                                vol.Required(CONF_PIN): int,
+                            },
+                        ),
+                        errors=errors,
+                    )
+                return self.async_show_form(
+                    step_id="user",
+                    data_schema=vol.Schema(
+                        {
+                            vol.Required(CONF_ADDRESS): str,
+                            vol.Required(CONF_PIN): int,
+                        },
+                    ),
+                    errors=errors,
+                )
+        except (TimeoutError, BleakError):
+            return self.async_abort(reason="cannot_connect")
+
+        return self.async_create_entry(
+            title=title,
+            data={
+                CONF_ADDRESS: self.address,
+                CONF_CLIENT_ID: channel_id,
+                CONF_PIN: self.pin,
+            },
+        )
+
+    async def async_step_bluetooth_finalise(
+        self,
+        user_input: dict[str, Any] | None = None,
+    ) -> ConfigFlowResult:
+        """Finalise the Bluetooth setup."""
+        return await self.check_mower(True, user_input)
+
+    async def async_step_finalise(
+        self,
+        user_input: dict[str, Any] | None = None,
+    ) -> ConfigFlowResult:
+        """Finalise the Manual setup."""
+        return await self.check_mower(False, user_input)
+
+    async def async_step_reauth(
+        self, entry_data: Mapping[str, Any]
+    ) -> ConfigFlowResult:
+        """Perform reauthentication upon an API authentication error."""
+        return await self.async_step_reauth_confirm()
+
+    async def async_step_reauth_confirm(
         self, user_input: dict[str, Any] | None = None
     ) -> ConfigFlowResult:
-        """Handle the initial step."""
-        if user_input is not None:
+        """Confirm reauthentication dialog."""
+        errors: dict[str, str] = {}
+
+        if user_input:
             self.address = user_input[CONF_ADDRESS]
-            await self.async_set_unique_id(self.address, raise_on_progress=False)
-            self._abort_if_unique_id_configured()
-            return await self.async_step_confirm()
+            self.pin = self.validate_pin(user_input[CONF_PIN])
+
+            try:
+                device = bluetooth.async_ble_device_from_address(
+                    self.hass, self.address, connectable=True
+                ) or await get_device(self.address)
+
+                (channel_id, mower) = await self.connect_mower(device)
+
+                response_result = await mower.connect(device)
+                if (
+                    response_result is ResponseResult.INVALID_PIN
+                    or response_result is ResponseResult.NOT_ALLOWED
+                ):
+                    errors["base"] = "invalid_auth"
+                elif response_result is not ResponseResult.OK:
+                    errors["base"] = "cannot_connect"
+                else:
+                    data = {
+                        CONF_ADDRESS: self.address,
+                        CONF_PIN: self.pin,
+                    }
+
+                    return self.async_update_reload_and_abort(
+                        self._get_reauth_entry(), data=data
+                    )
+
+            except (TimeoutError, BleakError):
+                return self.async_abort(reason="cannot_connect")
 
         return self.async_show_form(
-            step_id="user",
+            step_id="reauth_confirm",
             data_schema=vol.Schema(
                 {
                     vol.Required(CONF_ADDRESS): str,
+                    vol.Required(CONF_PIN): int,
                 },
             ),
+            errors=errors,
         )
diff --git a/homeassistant/components/husqvarna_automower_ble/coordinator.py b/homeassistant/components/husqvarna_automower_ble/coordinator.py
@@ -6,6 +6,7 @@
 from typing import TYPE_CHECKING
 
 from automower_ble.mower import Mower
+from automower_ble.protocol import ResponseResult
 from bleak import BleakError
 from bleak_retry_connector import close_stale_connections_by_address
 
@@ -62,7 +63,7 @@ async def _async_find_device(self):
         )
 
         try:
-            if not await self.mower.connect(device):
+            if await self.mower.connect(device) is not ResponseResult.OK:
                 raise UpdateFailed("Failed to connect")
         except BleakError as err:
             raise UpdateFailed("Failed to connect") from err

diff --git a/homeassistant/components/husqvarna_automower_ble/lawn_mower.py b/homeassistant/components/husqvarna_automower_ble/lawn_mower.py
@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from automower_ble.protocol import MowerActivity, MowerState
+from automower_ble.protocol import MowerActivity, MowerState, ResponseResult
 
 from homeassistant.components import bluetooth
 from homeassistant.components.lawn_mower import (
@@ -107,7 +107,7 @@ async def async_start_mowing(self) -> None:
             device = bluetooth.async_ble_device_from_address(
                 self.coordinator.hass, self.coordinator.address, connectable=True
             )
-            if not await self.coordinator.mower.connect(device):
+            if await self.coordinator.mower.connect(device) is not ResponseResult.OK:
                 return
 
         await self.coordinator.mower.mower_resume()
@@ -126,7 +126,7 @@ async def async_dock(self) -> None:
             device = bluetooth.async_ble_device_from_address(
                 self.coordinator.hass, self.coordinator.address, connectable=True
             )
-            if not await self.coordinator.mower.connect(device):
+            if await self.coordinator.mower.connect(device) is not ResponseResult.OK:
                 return
 
         await self.coordinator.mower.mower_park()
@@ -143,7 +143,7 @@ async def async_pause(self) -> None:
             device = bluetooth.async_ble_device_from_address(
                 self.coordinator.hass, self.coordinator.address, connectable=True
             )
-            if not await self.coordinator.mower.connect(device):
+            if await self.coordinator.mower.connect(device) is not ResponseResult.OK:
                 return
 
         await self.coordinator.mower.mower_pause()

diff --git a/homeassistant/components/husqvarna_automower_ble/manifest.json b/homeassistant/components/husqvarna_automower_ble/manifest.json
@@ -12,5 +12,5 @@
   "dependencies": ["bluetooth_adapters"],
   "documentation": "https://www.home-assistant.io/integrations/husqvarna_automower_ble",
   "iot_class": "local_polling",
-  "requirements": ["automower-ble==0.2.1"]
+  "requirements": ["automower-ble==0.2.6"]
 }