Add reolink IP NVR/Camera integration

.coveragerc

@@ -1047,6 +1047,11 @@ omit =
     homeassistant/components/rejseplanen/sensor.py
     homeassistant/components/remember_the_milk/__init__.py
     homeassistant/components/remote_rpi_gpio/*
+    homeassistant/components/reolink/__init__.py
+    homeassistant/components/reolink/camera.py
+    homeassistant/components/reolink/const.py
+    homeassistant/components/reolink/entity.py
+    homeassistant/components/reolink/host.py
     homeassistant/components/repetier/__init__.py
     homeassistant/components/repetier/sensor.py
     homeassistant/components/rest/notify.py

CODEOWNERS

@@ -942,6 +942,8 @@ build.json @home-assistant/supervisor
 /tests/components/remote/ @home-assistant/core
 /homeassistant/components/renault/ @epenet
 /tests/components/renault/ @epenet
+/homeassistant/components/reolink/ @starkillerOG @JimStar
+/tests/components/reolink/ @starkillerOG @JimStar
 /homeassistant/components/repairs/ @home-assistant/core
 /tests/components/repairs/ @home-assistant/core
 /homeassistant/components/repetier/ @MTrab @ShadowBr0ther

homeassistant/components/reolink/__init__.py

@@ -0,0 +1,108 @@
+"""Reolink integration for HomeAssistant."""
+
+from __future__ import annotations
+
+from datetime import timedelta
+import logging
+from typing import cast
+
+import async_timeout
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import EVENT_HOMEASSISTANT_STOP
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryNotReady
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
+
+from .const import (
+    DEVICE_CONFIG_UPDATE_COORDINATOR,
+    DEVICE_UPDATE_INTERVAL,
+    DOMAIN,
+    HOST,
+    PLATFORMS,
+    SERVICE_PTZ_CONTROL,
+    SERVICE_SET_BACKLIGHT,
+    SERVICE_SET_DAYNIGHT,
+    SERVICE_SET_SENSITIVITY,
+)
+from .host import ReolinkHost
+
+_LOGGER = logging.getLogger(__name__)
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+    """Set up Reolink from a config entry."""
+    hass.data.setdefault(DOMAIN, {})
+
+    host = ReolinkHost(hass, cast(dict, entry.data), cast(dict, entry.options))
+
+    try:
+        if not await host.init():
+            raise ConfigEntryNotReady(
+                f"Error while trying to setup {host.api.host}:{host.api.port}: failed to obtain data from device."
+            )
+    except Exception as error:  # pylint: disable=broad-except
+        err = str(error)
+        if err:
+            raise ConfigEntryNotReady(
+                f'Error while trying to setup {host.api.host}:{host.api.port}: "{err}".'
+            ) from error
+        raise ConfigEntryNotReady(
+            f"Error while trying to setup {host.api.host}:{host.api.port}: failed to connect to device."
+        ) from error
+
+    entry.async_on_unload(
+        hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, host.stop)
+    )
+
+    hass.data[DOMAIN][entry.entry_id] = {HOST: host}
+
+    async def async_device_config_update():
+        """Perform the update of the host config-state cache, and renew the ONVIF-subscription."""
+        async with async_timeout.timeout(host.api.timeout):
+            await host.update_states()  # Login session is implicitly updated here, so no need to explicitly do it in a timer
+
+    coordinator_device_config_update = DataUpdateCoordinator(
+        hass,
+        _LOGGER,
+        name=f"reolink.{host.api.nvr_name}",
+        update_method=async_device_config_update,
+        update_interval=timedelta(seconds=DEVICE_UPDATE_INTERVAL),
+    )
+    # Fetch initial data so we have data when entities subscribe
+    await coordinator_device_config_update.async_config_entry_first_refresh()
+
+    hass.data[DOMAIN][entry.entry_id][
+        DEVICE_CONFIG_UPDATE_COORDINATOR
+    ] = coordinator_device_config_update
+
+    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+
+    entry.async_on_unload(entry.add_update_listener(entry_update_listener))
+
+    return True
+
+
+async def entry_update_listener(hass: HomeAssistant, entry: ConfigEntry):
+    """Update the configuration of the host entity."""
+    await hass.config_entries.async_reload(entry.entry_id)
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+    """Unload a config entry."""
+    host: ReolinkHost = hass.data[DOMAIN][entry.entry_id][HOST]
+
+    await host.stop()
+
+    unload_ok = await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
+
+    if unload_ok:
+        hass.data[DOMAIN].pop(entry.entry_id)
+
+    if len(hass.data[DOMAIN]) == 0:
+        hass.services.async_remove(DOMAIN, SERVICE_SET_SENSITIVITY)
+        hass.services.async_remove(DOMAIN, SERVICE_SET_DAYNIGHT)
+        hass.services.async_remove(DOMAIN, SERVICE_SET_BACKLIGHT)
+        hass.services.async_remove(DOMAIN, SERVICE_PTZ_CONTROL)
+
+    return unload_ok

homeassistant/components/reolink/camera.py

@@ -0,0 +1,221 @@
+"""This component provides support for Reolink IP cameras."""
+from __future__ import annotations
+
+from datetime import datetime
+import logging
+from typing import Any, cast
+
+import voluptuous as vol
+
+from homeassistant.components.camera import Camera, CameraEntityFeature
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers import config_validation as cv, entity_platform
+from homeassistant.helpers.entity_platform import AddEntitiesCallback
+
+from .const import (
+    DOMAIN,
+    HOST,
+    SERVICE_PTZ_CONTROL,
+    SERVICE_SET_BACKLIGHT,
+    SERVICE_SET_DAYNIGHT,
+    SERVICE_SET_SENSITIVITY,
+    SUPPORT_PTZ,
+)
+from .entity import ReolinkCoordinatorEntity
+from .host import ReolinkHost
+
+_LOGGER = logging.getLogger(__name__)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: ConfigEntry,
+    async_add_devices: AddEntitiesCallback,
+) -> None:
+    """Set up a Reolink IP Camera."""
+    platform = entity_platform.async_get_current_platform()
+    platform.async_register_entity_service(
+        SERVICE_SET_SENSITIVITY,
+        {
+            vol.Required("sensitivity"): cv.positive_int,
+            vol.Optional("preset"): cv.positive_int,
+        },
+        SERVICE_SET_SENSITIVITY,
+    )
+
+    platform.async_register_entity_service(
+        SERVICE_SET_DAYNIGHT,
+        {vol.Required("mode"): cv.string},
+        SERVICE_SET_DAYNIGHT,
+    )
+
+    platform.async_register_entity_service(
+        SERVICE_SET_BACKLIGHT,
+        {vol.Required("mode"): cv.string},
+        SERVICE_SET_BACKLIGHT,
+    )
+
+    platform.async_register_entity_service(
+        SERVICE_PTZ_CONTROL,
+        {
+            vol.Required("command"): cv.string,
+            vol.Optional("preset"): cv.positive_int,
+            vol.Optional("speed"): cv.positive_int,
+        },
+        SERVICE_PTZ_CONTROL,
+        [SUPPORT_PTZ],
+    )
+
+    host: ReolinkHost = hass.data[DOMAIN][config_entry.entry_id][HOST]
+
+    cameras = []
+    for channel in host.api.channels:
+        streams = ["sub", "main", "snapshots"]
+        if host.api.protocol == "rtmp":
+            streams.append("ext")
+
+        for stream in streams:
+            cameras.append(ReolinkCamera(hass, config_entry, channel, stream))
+
+    async_add_devices(cameras, update_before_add=True)
+
+
+class ReolinkCamera(ReolinkCoordinatorEntity, Camera):
+    """An implementation of a Reolink IP camera."""
+
+    def __init__(self, hass, config, channel, stream):
+        """Initialize Reolink camera stream."""
+        ReolinkCoordinatorEntity.__init__(self, hass, config)
+        Camera.__init__(self)
+
+        self._channel = channel
+        self._stream = stream
+
+        self._attr_name = f"{self._host.api.camera_name(self._channel)} {self._stream}"
+        self._attr_unique_id = (
+            f"reolink_camera_{self._host.unique_id}_{self._channel}_{self._stream}"
+        )
+        self._attr_entity_registry_enabled_default = stream == "sub"
+
+        self._ptz_commands = {
+            "AUTO": "Auto",
+            "DOWN": "Down",
+            "FOCUSDEC": "FocusDec",
+            "FOCUSINC": "FocusInc",
+            "LEFT": "Left",
+            "LEFTDOWN": "LeftDown",
+            "LEFTUP": "LeftUp",
+            "RIGHT": "Right",
+            "RIGHTDOWN": "RightDown",
+            "RIGHTUP": "RightUp",
+            "STOP": "Stop",
+            "TOPOS": "ToPos",
+            "UP": "Up",
+            "ZOOMDEC": "ZoomDec",
+            "ZOOMINC": "ZoomInc",
+        }
+        self._daynight_modes = {
+            "AUTO": "Auto",
+            "COLOR": "Color",
+            "BLACKANDWHITE": "Black&White",
+        }
+
+        self._backlight_modes = {
+            "BACKLIGHTCONTROL": "BackLightControl",
+            "DYNAMICRANGECONTROL": "DynamicRangeControl",
+            "OFF": "Off",
+        }
+
+    @property
+    def ptz_supported(self):
+        """Supports ptz control."""
+        return self._host.api.ptz_supported(self._channel)
+
+    @property
+    def supported_features(self) -> CameraEntityFeature:
+        """Flag supported features."""
+        features = int(CameraEntityFeature.STREAM)
+        if self.ptz_supported:
+            features += SUPPORT_PTZ
+        return cast(CameraEntityFeature, features)
+
+    @property
+    def extra_state_attributes(self) -> dict[str, Any] | None:
+        """Return the extra state attributes."""
+        attrs = {}
+
+        if self._host.api.ptz_supported(self._channel):
+            attrs["ptz_presets"] = self._host.api.ptz_presets(self._channel)
+
+        for key, value in self._backlight_modes.items():
+            if value == self._host.api.backlight_state(self._channel):
+                attrs["backlight_state"] = key
+
+        for key, value in self._daynight_modes.items():
+            if value == self._host.api.daynight_state(self._channel):
+                attrs["daynight_state"] = key
+
+        if self._host.api.sensitivity_presets:
+            attrs["sensitivity"] = self.get_sensitivity_presets()
+
+        return attrs
+
+    async def stream_source(self) -> str | None:
+        """Return the source of the stream."""
+        return await self._host.api.get_stream_source(self._channel, self._stream)
+
+    async def async_camera_image(
+        self, width: int | None = None, height: int | None = None
+    ) -> bytes | None:
+        """Return a still image response from the camera."""
+        return await self._host.api.get_snapshot(self._channel)
+
+    async def ptz_control(self, command, **kwargs):
+        """Pass PTZ command to the camera."""
+        if not self.ptz_supported:
+            _LOGGER.error("PTZ is not supported on %s camera", self.name)
+            return
+
+        await self._host.api.set_ptz_command(
+            self._channel, command=self._ptz_commands[command], **kwargs
+        )
+
+    def get_sensitivity_presets(self):
+        """Get formatted sensitivity presets."""
+        presets = []
+        preset = {}
+
+        for api_preset in self._host.api.sensitivity_presets(self._channel):
+            preset["id"] = api_preset["id"]
+            preset["sensitivity"] = api_preset["sensitivity"]
+
+            time_string = f'{api_preset["beginHour"]}:{api_preset["beginMin"]}'
+            begin = datetime.strptime(time_string, "%H:%M")
+            preset["begin"] = begin.strftime("%H:%M")
+
+            time_string = f'{api_preset["endHour"]}:{api_preset["endMin"]}'
+            end = datetime.strptime(time_string, "%H:%M")
+            preset["end"] = end.strftime("%H:%M")
+
+            presets.append(preset.copy())
+
+        return presets
+
+    async def set_sensitivity(self, sensitivity, **kwargs):
+        """Set the sensitivity to the camera."""
+        if "preset" in kwargs:
+            kwargs["preset"] += 1
+        await self._host.api.set_sensitivity(self._channel, value=sensitivity, **kwargs)
+
+    async def set_daynight(self, mode):
+        """Set the day and night mode to the camera."""
+        await self._host.api.set_daynight(
+            self._channel, value=self._daynight_modes[mode]
+        )
+
+    async def set_backlight(self, mode):
+        """Set the backlight mode to the camera."""
+        await self._host.api.set_backlight(
+            self._channel, value=self._backlight_modes[mode]
+        )