Add Interlogix Ultrasync Alarm System Integration

CODEOWNERS

@@ -520,6 +520,7 @@ homeassistant/components/tuya/* @ollo69
 homeassistant/components/twentemilieu/* @frenck
 homeassistant/components/twinkly/* @dr1rrb
 homeassistant/components/ubus/* @noltari
+homeassistant/components/ultrasync/* @caronc
 homeassistant/components/unifi/* @Kane610
 homeassistant/components/unifiled/* @florisvdk
 homeassistant/components/upb/* @gwww

homeassistant/components/ultrasync/__init__.py

@@ -0,0 +1,143 @@
+"""The Interlogix/Hills ComNav UltraSync Hub component."""
+
+import asyncio
+from datetime import timedelta
+
+from ultrasync import AlarmScene
+import voluptuous as vol
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import CONF_SCAN_INTERVAL
+from homeassistant.exceptions import ConfigEntryNotReady
+from homeassistant.helpers.typing import HomeAssistantType
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
+
+from .const import (
+    DATA_COORDINATOR,
+    DATA_UNDO_UPDATE_LISTENER,
+    DEFAULT_SCAN_INTERVAL,
+    DOMAIN,
+    SENSORS,
+    SERVICE_AWAY,
+    SERVICE_DISARM,
+    SERVICE_STAY,
+)
+from .coordinator import UltraSyncDataUpdateCoordinator
+
+PLATFORMS = ["sensor"]
+
+
+async def async_setup(hass: HomeAssistantType, config: dict) -> bool:
+    """Set up the UltraSync integration."""
+    hass.data.setdefault(DOMAIN, {})
+
+    return True
+
+
+async def async_setup_entry(hass: HomeAssistantType, entry: ConfigEntry) -> bool:
+    """Set up UltraSync from a config entry."""
+    if not entry.options:
+        options = {
+            CONF_SCAN_INTERVAL: entry.data.get(
+                CONF_SCAN_INTERVAL, DEFAULT_SCAN_INTERVAL
+            ),
+        }
+        hass.config_entries.async_update_entry(entry, options=options)
+
+    coordinator = UltraSyncDataUpdateCoordinator(
+        hass,
+        config=entry.data,
+        options=entry.options,
+    )
+
+    await coordinator.async_refresh()
+
+    if not coordinator.last_update_success:
+        raise ConfigEntryNotReady
+
+    undo_listener = entry.add_update_listener(_async_update_listener)
+
+    hass.data[DOMAIN][entry.entry_id] = {
+        DATA_COORDINATOR: coordinator,
+        DATA_UNDO_UPDATE_LISTENER: [undo_listener],
+        SENSORS: {},
+    }
+
+    for component in PLATFORMS:
+        hass.async_create_task(
+            hass.config_entries.async_forward_entry_setup(entry, component)
+        )
+
+    _async_register_services(hass, coordinator)
+
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistantType, entry: ConfigEntry) -> bool:
+    """Unload a config entry."""
+    unload_ok = all(
+        await asyncio.gather(
+            *[
+                hass.config_entries.async_forward_entry_unload(entry, component)
+                for component in PLATFORMS
+            ]
+        )
+    )
+
+    if unload_ok:
+        for unsub in hass.data[DOMAIN][entry.entry_id][DATA_UNDO_UPDATE_LISTENER]:
+            unsub()
+        hass.data[DOMAIN].pop(entry.entry_id)
+
+    return unload_ok
+
+
+def _async_register_services(
+    hass: HomeAssistantType,
+    coordinator: UltraSyncDataUpdateCoordinator,
+) -> None:
+    """Register integration-level services."""
+
+    def away(call) -> None:
+        """Service call to set alarm system to 'away' mode in UltraSync Hub."""
+        coordinator.hub.set_alarm(state=AlarmScene.AWAY)
+
+    def stay(call) -> None:
+        """Service call to set alarm system to 'stay' mode in UltraSync Hub."""
+        coordinator.hub.set_alarm(state=AlarmScene.STAY)
+
+    def disarm(call) -> None:
+        """Service call to disable alarm in UltraSync Hub."""
+        coordinator.hub.set_alarm(state=AlarmScene.DISARMED)
+
+    hass.services.async_register(DOMAIN, SERVICE_AWAY, away, schema=vol.Schema({}))
+    hass.services.async_register(DOMAIN, SERVICE_STAY, stay, schema=vol.Schema({}))
+    hass.services.async_register(DOMAIN, SERVICE_DISARM, disarm, schema=vol.Schema({}))
+
+
+async def _async_update_listener(hass: HomeAssistantType, entry: ConfigEntry) -> None:
+    """Handle options update."""
+    if entry.options[CONF_SCAN_INTERVAL]:
+        coordinator = hass.data[DOMAIN][entry.entry_id]["coordinator"]
+        coordinator.update_interval = timedelta(
+            seconds=entry.options[CONF_SCAN_INTERVAL]
+        )
+
+        await coordinator.async_refresh()
+
+
+class UltraSyncEntity(CoordinatorEntity):
+    """Defines a base UltraSync entity."""
+
+    def __init__(
+        self, *, entry_id: str, name: str, coordinator: UltraSyncDataUpdateCoordinator
+    ) -> None:
+        """Initialize the UltraSync entity."""
+        super().__init__(coordinator)
+        self._name = name
+        self._entry_id = entry_id
+
+    @property
+    def name(self) -> str:
+        """Return the name of the entity."""
+        return self._name

homeassistant/components/ultrasync/config_flow.py

@@ -0,0 +1,123 @@
+"""Config flow for the Interlogix/Hills ComNav UltraSync Hub."""
+import logging
+from typing import Any, Dict, Optional
+
+import ultrasync
+import voluptuous as vol
+
+from homeassistant import config_entries
+from homeassistant.const import (
+    CONF_HOST,
+    CONF_NAME,
+    CONF_PIN,
+    CONF_SCAN_INTERVAL,
+    CONF_USERNAME,
+)
+from homeassistant.core import callback
+from homeassistant.helpers.typing import ConfigType, HomeAssistantType
+
+from .const import DEFAULT_NAME, DEFAULT_SCAN_INTERVAL
+from .const import DOMAIN  # pylint: disable=unused-import
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class AuthFailureException(Exception):
+    """A general exception we can use to track Authentication failures."""
+
+    pass
+
+
+def validate_input(hass: HomeAssistantType, data: dict) -> Dict[str, Any]:
+    """Validate the user input allows us to connect."""
+
+    usync = ultrasync.UltraSync(
+        host=data[CONF_HOST], user=data[CONF_USERNAME], pin=data[CONF_PIN]
+    )
+
+    # validate by attempting to authenticate with our hub
+
+    if not usync.login():
+        # report our connection issue
+        raise AuthFailureException()
+
+    return True
+
+
+class UltraSyncConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
+    """UltraSync config flow."""
+
+    VERSION = 1
+    CONNECTION_CLASS = config_entries.CONN_CLASS_LOCAL_POLL
+
+    @staticmethod
+    @callback
+    def async_get_options_flow(config_entry):
+        """Get the options flow for this handler."""
+        return UltraSyncOptionsFlowHandler(config_entry)
+
+    async def async_step_user(
+        self, user_input: Optional[ConfigType] = None
+    ) -> Dict[str, Any]:
+        """Handle user flow."""
+
+        errors = {}
+
+        if user_input is not None:
+            await self.async_set_unique_id(user_input.get(CONF_HOST))
+            self._abort_if_unique_id_configured()
+
+            try:
+                await self.hass.async_add_executor_job(
+                    validate_input, self.hass, user_input
+                )
+
+            except AuthFailureException:
+                errors["base"] = "invalid_auth"
+
+            except Exception:  # pylint: disable=broad-except
+                _LOGGER.exception("Unexpected exception")
+                errors["base"] = "unknown"
+
+            else:
+                return self.async_create_entry(
+                    title=user_input[CONF_HOST],
+                    data=user_input,
+                )
+
+        return self.async_show_form(
+            step_id="user",
+            data_schema=vol.Schema(
+                {
+                    vol.Optional(CONF_NAME, default=DEFAULT_NAME): str,
+                    vol.Required(CONF_HOST): str,
+                    vol.Required(CONF_USERNAME): str,
+                    vol.Required(CONF_PIN): str,
+                }
+            ),
+            errors=errors,
+        )
+
+
+class UltraSyncOptionsFlowHandler(config_entries.OptionsFlow):
+    """Handle UltraSync client options."""
+
+    def __init__(self, config_entry):
+        """Initialize options flow."""
+        self.config_entry = config_entry
+
+    async def async_step_init(self, user_input: Optional[ConfigType] = None):
+        """Manage UltraSync options."""
+        if user_input is not None:
+            return self.async_create_entry(title="", data=user_input)
+
+        options = {
+            vol.Optional(
+                CONF_SCAN_INTERVAL,
+                default=self.config_entry.options.get(
+                    CONF_SCAN_INTERVAL, DEFAULT_SCAN_INTERVAL
+                ),
+            ): int,
+        }
+
+        return self.async_show_form(step_id="init", data_schema=vol.Schema(options))

homeassistant/components/ultrasync/const.py

@@ -0,0 +1,20 @@
+"""Constants the Interlogix/Hills ComNav UltraSync Hub."""
+
+DOMAIN = "ultrasync"
+
+# Scan Time (in seconds)
+DEFAULT_SCAN_INTERVAL = 1
+
+DEFAULT_NAME = "UltraSync"
+
+# Services
+SERVICE_AWAY = "away"
+SERVICE_STAY = "stay"
+SERVICE_DISARM = "disarm"
+
+# Index used for managing loaded sensors
+SENSORS = "sensors"
+
+DATA_COORDINATOR = "coordinator"
+DATA_UNDO_UPDATE_LISTENER = "undo_update_listener"
+SENSOR_UPDATE_LISTENER = "ultrasync_update_sensors"