Add config_flow for Roomba

homeassistant/components/roomba/.translations/en.json

@@ -0,0 +1,32 @@
+{
+  "config": {
+    "title": "iRobot Roomba",
+    "step": {
+      "user": {
+        "title": "Connect to the device",
+        "data": {
+          "host": "Hostname or IP Address",
+          "blid": "Username",
+          "password": "Password",
+          "certificate": "Certificate",
+          "continuous": "Continuous",
+          "delay": "Delay"
+        }
+      }
+    },
+    "error": {
+      "unknown" : "Unexpected error",    
+      "cannot_connect": "Failed to connect, please try again"
+    }
+  },
+  "options": {
+    "step": {
+      "init": {
+        "data": {
+          "continuous": "Continuous",
+          "delay": "Delay"
+        }
+      }
+    }
+  }
+}

homeassistant/components/roomba/.translations/fr.json

@@ -0,0 +1,32 @@
+{
+  "config": {
+    "title": "iRobot Roomba",
+    "step": {
+      "user": {
+        "title": "Connexion au périphérique",
+        "data": {
+          "host": "Nom ou Addresse IP",
+          "blid": "Utilisateur",
+          "password": "Mot de passe",
+          "certificate": "Certificat",
+          "continuous": "Continue",
+          "delay": "Delais"
+        }
+      }
+    },
+    "error": {
+      "unknown" : "Erreur imprévu",    
+      "cannot_connect": "Impossible de se connecter"
+    }
+  },
+  "options": {
+    "step": {
+      "init": {
+        "data": {
+          "continuous": "Continue",
+          "delay": "Delais"
+        }
+      }
+    }
+  }
+}

homeassistant/components/roomba/__init__.py

@@ -1 +1,170 @@
 """The roomba component."""
+import asyncio
+import logging
+
+import async_timeout
+from roomba import Roomba, RoombaConnectionError
+import voluptuous as vol
+
+from homeassistant import config_entries, exceptions
+from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
+
+from .const import (
+    COMPONENTS,
+    CONF_BLID,
+    CONF_CERT,
+    CONF_CONTINUOUS,
+    CONF_DELAY,
+    CONF_NAME,
+    DEFAULT_CERT,
+    DEFAULT_CONTINUOUS,
+    DEFAULT_DELAY,
+    DOMAIN,
+    ROOMBA_SESSION,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+CONFIG_SCHEMA = vol.Schema(
+    {
+        DOMAIN: vol.Schema(
+            {
+                vol.Required(CONF_HOST): str,
+                vol.Required(CONF_USERNAME): str,
+                vol.Required(CONF_PASSWORD): str,
+                vol.Optional(CONF_CERT, default=DEFAULT_CERT): str,
+                vol.Optional(CONF_CONTINUOUS, default=DEFAULT_CONTINUOUS): bool,
+                vol.Optional(CONF_DELAY, default=DEFAULT_DELAY): int,
+            }
+        )
+    },
+    extra=vol.ALLOW_EXTRA,
+)
+
+
+async def async_setup(hass, config):
+    """Set up the roomba environment."""
+    hass.data.setdefault(DOMAIN, {})
+
+    if DOMAIN not in config:
+        return True
+
+    if not hass.config_entries.async_entries(DOMAIN):
+        hass.async_create_task(
+            hass.config_entries.flow.async_init(
+                DOMAIN,
+                context={"source": config_entries.SOURCE_IMPORT},
+                data=config[DOMAIN],
+            )
+        )
+
+    return True
+
+
+async def async_setup_entry(hass, config_entry):
+    """Set the config entry up."""
+    # Set up roomba platforms with config entry
+    if config_entry.data is None:
+        return False
+
+    if not config_entry.options:
+        hass.config_entries.async_update_entry(
+            config_entry,
+            options={
+                "continuous": config_entry.data[CONF_CONTINUOUS],
+                "delay": config_entry.data[CONF_DELAY],
+            },
+        )
+
+    roomba = Roomba(
+        address=config_entry.data[CONF_HOST],
+        blid=config_entry.data[CONF_BLID],
+        password=config_entry.data[CONF_PASSWORD],
+        cert_name=config_entry.data[CONF_CERT],
+        continuous=config_entry.options[CONF_CONTINUOUS],
+        delay=config_entry.options[CONF_DELAY],
+    )
+
+    try:
+        if not await async_connect_or_timeout(hass, roomba):
+            return False
+    except CannotConnect:
+        raise exceptions.ConfigEntryNotReady
+
+    hass.data[DOMAIN][config_entry.entry_id] = roomba
+    hass.data[DOMAIN][CONF_BLID] = config_entry.data[CONF_BLID]
+
+    for component in COMPONENTS:
+        hass.async_create_task(
+            hass.config_entries.async_forward_entry_setup(config_entry, component)
+        )
+
+    if not config_entry.update_listeners:
+        config_entry.add_update_listener(async_update_options)
+
+    return True
+
+
+async def async_connect_or_timeout(hass, roomba):
+    """Connect to vacuum."""
+    try:
+        name = None
+        with async_timeout.timeout(10):
+            _LOGGER.debug("Initialize connection to vacuum")
+            await hass.async_add_job(roomba.connect)
+            while not roomba.roomba_connected or name is None:
+                # Waiting for connection and check datas ready
+                name = roomba_reported_state(roomba).get("name", None)
+                await asyncio.sleep(1)
+    except RoombaConnectionError:
+        _LOGGER.error("Error to connect to vacuum")
+        raise CannotConnect
+    except asyncio.TimeoutError:
+        # api looping if user or password incorrect and roomba exist
+        await async_disconnect_or_timeout(hass, roomba)
+        _LOGGER.error("Timeout expired")
+        raise CannotConnect
+
+    return {ROOMBA_SESSION: roomba, CONF_NAME: name}
+
+
+async def async_disconnect_or_timeout(hass, roomba):
+    """Disconnect to vacuum."""
+    _LOGGER.debug("Disconnect vacuum")
+    with async_timeout.timeout(3):
+        await hass.async_add_job(roomba.disconnect)
+    await asyncio.sleep(1)
+    return True
+
+
+async def async_update_options(hass, config_entry):
+    """Update options."""
+    await hass.config_entries.async_reload(config_entry.entry_id)
+
+
+async def async_unload_entry(hass, config_entry):
+    """Unload a config entry."""
+    unload_ok = all(
+        await asyncio.gather(
+            *[
+                hass.config_entries.async_forward_entry_unload(config_entry, component)
+                for component in COMPONENTS
+            ]
+        )
+    )
+    if unload_ok:
+        await async_disconnect_or_timeout(
+            hass, roomba=hass.data[DOMAIN][config_entry.entry_id]
+        )
+        hass.data[DOMAIN].pop(config_entry.entry_id)
+
+    return unload_ok
+
+
+def roomba_reported_state(roomba):
+    """Roomba report."""
+    return roomba.master_state.get("state", {}).get("reported", {})
+
+
+class CannotConnect(exceptions.HomeAssistantError):
+    """Error to indicate we cannot connect."""

homeassistant/components/roomba/binary_sensor.py

@@ -0,0 +1,73 @@
+"""Roomba binary sensor entities."""
+import logging
+
+from homeassistant.components.binary_sensor import BinarySensorDevice
+
+from . import roomba_reported_state
+from .const import CONF_BLID, DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+
+async def async_setup_entry(hass, config_entry, async_add_entities):
+    """Set up the iRobot Roomba vacuum cleaner."""
+    roomba = hass.data[DOMAIN][config_entry.entry_id]
+    blid = hass.data[DOMAIN][CONF_BLID]
+    status = roomba_reported_state(roomba).get("bin", {})
+    if "full" in status:
+        roomba_vac = RoombaBinStatus(roomba, blid)
+        async_add_entities([roomba_vac], True)
+
+
+class RoombaBinStatus(BinarySensorDevice):
+    """Class to hold Roomba Sensor basic info."""
+
+    ICON = "mdi:delete-variant"
+
+    def __init__(self, roomba, blid):
+        """Initialize the sensor object."""
+        self.vacuum = roomba
+        self.vacuum_state = roomba_reported_state(roomba)
+        self._blid = blid
+        self._name = self.vacuum_state.get("name")
+        self._identifier = f"roomba_{self._blid}"
+        self._bin_status = None
+
+    @property
+    def name(self):
+        """Return the name of the sensor."""
+        return f"{self._name} bin full"
+
+    @property
+    def unique_id(self):
+        """Return the ID of this sensor."""
+        return f"bin_{self._blid}"
+
+    @property
+    def icon(self):
+        """Return the icon of this sensor."""
+        return self.ICON
+
+    @property
+    def state(self):
+        """Return the state of the sensor."""
+        return self._bin_status
+
+    @property
+    def device_info(self):
+        """Return the device info of the vacuum cleaner."""
+        return {
+            "identifiers": {(DOMAIN, self._identifier)},
+            "name": str(self._name),
+        }
+
+    async def async_update(self):
+        """Return the update info of the vacuum cleaner."""
+        # No data, no update
+        if not self.vacuum.master_state:
+            _LOGGER.debug("Roomba %s has no data yet. Skip update", self.name)
+            return
+        self._bin_status = (
+            roomba_reported_state(self.vacuum).get("bin", {}).get("full", False)
+        )
+        _LOGGER.debug("Update Full Bin status from the vacuum: %s", self._bin_status)