Reolink add binary sensors

.coveragerc

@@ -1064,6 +1064,7 @@ omit =
     homeassistant/components/remember_the_milk/__init__.py
     homeassistant/components/remote_rpi_gpio/*
     homeassistant/components/reolink/__init__.py
+    homeassistant/components/reolink/binary_sensor.py
     homeassistant/components/reolink/camera.py
     homeassistant/components/reolink/const.py
     homeassistant/components/reolink/entity.py

homeassistant/components/reolink/__init__.py

@@ -30,7 +30,7 @@
 
 _LOGGER = logging.getLogger(__name__)
 
-PLATFORMS = [Platform.CAMERA]
+PLATFORMS = [Platform.BINARY_SENSOR, Platform.CAMERA]
 DEVICE_UPDATE_INTERVAL = 60
 
 
@@ -49,7 +49,7 @@ async def async_setup_entry(hass: HomeAssistant, config_entry: ConfigEntry) -> b
     try:
         await host.async_init()
     except UserNotAdmin as err:
-        raise ConfigEntryAuthFailed(err) from UserNotAdmin
+        raise ConfigEntryAuthFailed(err) from err
     except (
         ClientConnectorError,
         asyncio.TimeoutError,
@@ -62,7 +62,7 @@ async def async_setup_entry(hass: HomeAssistant, config_entry: ConfigEntry) -> b
     ) as err:
         await host.stop()
         raise ConfigEntryNotReady(
-            f'Error while trying to setup {host.api.host}:{host.api.port}: "{str(err)}".'
+            f"Error while trying to setup {host.api.host}:{host.api.port}: {str(err)}"
         ) from err
 
     config_entry.async_on_unload(
@@ -79,6 +79,9 @@ async def async_device_config_update():
                     f"Error updating Reolink {host.api.nvr_name}"
                 ) from err
 
+        async with async_timeout.timeout(host.api.timeout):
+            await host.renew()
+
     coordinator_device_config_update = DataUpdateCoordinator(
         hass,
         _LOGGER,

homeassistant/components/reolink/binary_sensor.py

@@ -0,0 +1,168 @@
+"""This component provides support for Reolink binary sensors."""
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+
+from reolink_aio.api import (
+    FACE_DETECTION_TYPE,
+    PERSON_DETECTION_TYPE,
+    PET_DETECTION_TYPE,
+    VEHICLE_DETECTION_TYPE,
+    Host,
+)
+
+from homeassistant.components.binary_sensor import (
+    BinarySensorDeviceClass,
+    BinarySensorEntity,
+    BinarySensorEntityDescription,
+)
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.dispatcher import async_dispatcher_connect
+from homeassistant.helpers.entity_platform import AddEntitiesCallback
+
+from . import ReolinkData
+from .const import DOMAIN
+from .entity import ReolinkCoordinatorEntity
+
+
+@dataclass
+class ReolinkBinarySensorEntityDescriptionMixin:
+    """Mixin values for Reolink binary sensor entities."""
+
+    value: Callable[[Host, int | None], bool]
+
+
+@dataclass
+class ReolinkBinarySensorEntityDescription(
+    BinarySensorEntityDescription, ReolinkBinarySensorEntityDescriptionMixin
+):
+    """A class that describes binary sensor entities."""
+
+    icon: str = "mdi:motion-sensor"
+    icon_off: str = "mdi:motion-sensor-off"
+    supported: Callable[[Host, int | None], bool] = lambda host, ch: True
+
+
+BINARY_SENSORS = (
+    ReolinkBinarySensorEntityDescription(
+        key="motion",
+        name="Motion",
+        device_class=BinarySensorDeviceClass.MOTION,
+        value=lambda api, ch: api.motion_detected(ch),
+    ),
+    ReolinkBinarySensorEntityDescription(
+        key=FACE_DETECTION_TYPE,
+        name="Face",
+        icon="mdi:face-recognition",
+        value=lambda api, ch: api.ai_detected(ch, FACE_DETECTION_TYPE),
+        supported=lambda api, ch: api.ai_supported(ch, FACE_DETECTION_TYPE),
+    ),
+    ReolinkBinarySensorEntityDescription(
+        key=PERSON_DETECTION_TYPE,
+        name="Person",
+        value=lambda api, ch: api.ai_detected(ch, PERSON_DETECTION_TYPE),
+        supported=lambda api, ch: api.ai_supported(ch, PERSON_DETECTION_TYPE),
+    ),
+    ReolinkBinarySensorEntityDescription(
+        key=VEHICLE_DETECTION_TYPE,
+        name="Vehicle",
+        icon="mdi:car",
+        icon_off="mdi:car-off",
+        value=lambda api, ch: api.ai_detected(ch, VEHICLE_DETECTION_TYPE),
+        supported=lambda api, ch: api.ai_supported(ch, VEHICLE_DETECTION_TYPE),
+    ),
+    ReolinkBinarySensorEntityDescription(
+        key=PET_DETECTION_TYPE,
+        name="Pet",
+        icon="mdi:dog-side",
+        icon_off="mdi:dog-side-off",
+        value=lambda api, ch: api.ai_detected(ch, PET_DETECTION_TYPE),
+        supported=lambda api, ch: api.ai_supported(ch, PET_DETECTION_TYPE),
+    ),
+    ReolinkBinarySensorEntityDescription(
+        key="visitor",
+        name="Visitor",
+        icon="mdi:bell-ring-outline",
+        icon_off="mdi:doorbell",
+        value=lambda api, ch: api.visitor_detected(ch),
+        supported=lambda api, ch: api.is_doorbell_enabled(ch),
+    ),
+)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: ConfigEntry,
+    async_add_entities: AddEntitiesCallback,
+) -> None:
+    """Set up a Reolink IP Camera."""
+    reolink_data: ReolinkData = hass.data[DOMAIN][config_entry.entry_id]
+
+    entities: list[ReolinkBinarySensorEntity] = []
+    for channel in reolink_data.host.api.channels:
+        entities.extend(
+            [
+                ReolinkBinarySensorEntity(reolink_data, channel, entity_description)
+                for entity_description in BINARY_SENSORS
+                if entity_description.supported(reolink_data.host.api, channel)
+            ]
+        )
+
+    async_add_entities(entities)
+
+
+class ReolinkBinarySensorEntity(ReolinkCoordinatorEntity, BinarySensorEntity):
+    """Base binary-sensor class for Reolink IP camera motion sensors."""
+
+    _attr_has_entity_name = True
+    entity_description: ReolinkBinarySensorEntityDescription
+
+    def __init__(
+        self,
+        reolink_data: ReolinkData,
+        channel: int,
+        entity_description: ReolinkBinarySensorEntityDescription,
+    ) -> None:
+        """Initialize Reolink binary sensor."""
+        super().__init__(reolink_data, channel)
+        self.entity_description = entity_description
+
+        self._attr_unique_id = (
+            f"{self._host.unique_id}_{self._channel}_{entity_description.key}"
+        )
+
+    @property
+    def icon(self) -> str | None:
+        """Icon of the sensor."""
+        if self.is_on is False:
+            return self.entity_description.icon_off
+        return super().icon
+
+    @property
+    def is_on(self) -> bool:
+        """State of the sensor."""
+        return self.entity_description.value(self._host.api, self._channel)
+
+    async def async_added_to_hass(self) -> None:
+        """Entity created."""
+        await super().async_added_to_hass()
+        self.async_on_remove(
+            async_dispatcher_connect(
+                self.hass,
+                f"{self._host.webhook_id}_{self._channel}",
+                self._async_handle_event,
+            )
+        )
+        self.async_on_remove(
+            async_dispatcher_connect(
+                self.hass,
+                f"{self._host.webhook_id}_all",
+                self._async_handle_event,
+            )
+        )
+
+    async def _async_handle_event(self, event):
+        """Handle incoming event for motion detection."""
+        self.async_write_ha_state()

homeassistant/components/reolink/camera.py

@@ -34,9 +34,9 @@ async def async_setup_entry(
             stream_url = await host.api.get_stream_source(channel, stream)
             if stream_url is None and stream != "snapshots":
                 continue
-            cameras.append(ReolinkCamera(reolink_data, config_entry, channel, stream))
+            cameras.append(ReolinkCamera(reolink_data, channel, stream))
 
-    async_add_entities(cameras, update_before_add=True)
+    async_add_entities(cameras)
 
 
 class ReolinkCamera(ReolinkCoordinatorEntity, Camera):
@@ -48,12 +48,11 @@ class ReolinkCamera(ReolinkCoordinatorEntity, Camera):
     def __init__(
         self,
         reolink_data: ReolinkData,
-        config_entry: ConfigEntry,
         channel: int,
         stream: str,
     ) -> None:
         """Initialize Reolink camera stream."""
-        ReolinkCoordinatorEntity.__init__(self, reolink_data, config_entry, channel)
+        ReolinkCoordinatorEntity.__init__(self, reolink_data, channel)
         Camera.__init__(self)
 
         self._stream = stream

homeassistant/components/reolink/config_flow.py

@@ -14,12 +14,13 @@
 from homeassistant.data_entry_flow import FlowResult
 from homeassistant.helpers import config_validation as cv
 
-from .const import CONF_PROTOCOL, CONF_USE_HTTPS, DEFAULT_PROTOCOL, DOMAIN
+from .const import CONF_PROTOCOL, CONF_USE_HTTPS, DOMAIN
 from .exceptions import ReolinkException, UserNotAdmin
 from .host import ReolinkHost
 
 _LOGGER = logging.getLogger(__name__)
 
+DEFAULT_PROTOCOL = "rtsp"
 DEFAULT_OPTIONS = {CONF_PROTOCOL: DEFAULT_PROTOCOL}
 
 

homeassistant/components/reolink/const.py

@@ -4,6 +4,3 @@
 
 CONF_USE_HTTPS = "use_https"
 CONF_PROTOCOL = "protocol"
-
-DEFAULT_PROTOCOL = "rtsp"
-DEFAULT_TIMEOUT = 60

homeassistant/components/reolink/entity.py

@@ -1,7 +1,6 @@
 """Reolink parent entity class."""
 from __future__ import annotations
 
-from homeassistant.config_entries import ConfigEntry
 from homeassistant.helpers.device_registry import CONNECTION_NETWORK_MAC
 from homeassistant.helpers.entity import DeviceInfo
 from homeassistant.helpers.update_coordinator import CoordinatorEntity
@@ -11,12 +10,10 @@
 
 
 class ReolinkCoordinatorEntity(CoordinatorEntity):
-    """Parent class for Reolink Entities."""
+    """Parent class for Reolink hardware camera entities."""
 
-    def __init__(
-        self, reolink_data: ReolinkData, config_entry: ConfigEntry, channel: int | None
-    ) -> None:
-        """Initialize ReolinkCoordinatorEntity."""
+    def __init__(self, reolink_data: ReolinkData, channel: int) -> None:
+        """Initialize ReolinkCoordinatorEntity for a hardware camera."""
         coordinator = reolink_data.device_coordinator
         super().__init__(coordinator)
 
@@ -25,7 +22,7 @@ def __init__(
 
         http_s = "https" if self._host.api.use_https else "http"
         conf_url = f"{http_s}://{self._host.api.host}:{self._host.api.port}"
-        if self._host.api.is_nvr and self._channel is not None:
+        if self._host.api.is_nvr:
             self._attr_device_info = DeviceInfo(
                 identifiers={(DOMAIN, f"{self._host.unique_id}_ch{self._channel}")},
                 via_device=(DOMAIN, self._host.unique_id),

homeassistant/components/reolink/exceptions.py

@@ -10,5 +10,9 @@ class ReolinkSetupException(ReolinkException):
     """Raised when setting up the Reolink host failed."""
 
 
+class ReolinkWebhookException(ReolinkException):
+    """Raised when registering the reolink webhook failed."""
+
+
 class UserNotAdmin(ReolinkException):
     """Raised when user is not admin."""