"""Reolink integration for HomeAssistant.""" from __future__ import annotations import asyncio from datetime import timedelta import logging from reolink_aio.api import RETRY_ATTEMPTS from reolink_aio.exceptions import CredentialsInvalidError, ReolinkError from homeassistant.config_entries import ConfigEntryState from homeassistant.const import EVENT_HOMEASSISTANT_STOP, Platform from homeassistant.core import HomeAssistant from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady from homeassistant.helpers import ( config_validation as cv, device_registry as dr, entity_registry as er, ) from homeassistant.helpers.device_registry import format_mac from homeassistant.helpers.typing import ConfigType from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed from .const import DOMAIN from .exceptions import PasswordIncompatible, ReolinkException, UserNotAdmin from .host import ReolinkHost from .services import async_setup_services from .util import ReolinkConfigEntry, ReolinkData, get_device_uid_and_ch _LOGGER = logging.getLogger(__name__) PLATFORMS = [ Platform.BINARY_SENSOR, Platform.BUTTON, Platform.CAMERA, Platform.LIGHT, Platform.NUMBER, Platform.SELECT, Platform.SENSOR, Platform.SIREN, Platform.SWITCH, Platform.UPDATE, ] DEVICE_UPDATE_INTERVAL = timedelta(seconds=60) FIRMWARE_UPDATE_INTERVAL = timedelta(hours=12) NUM_CRED_ERRORS = 3 CONFIG_SCHEMA = cv.empty_config_schema(DOMAIN) async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool: """Set up Reolink shared code.""" async_setup_services(hass) return True async def async_setup_entry( hass: HomeAssistant, config_entry: ReolinkConfigEntry ) -> bool: """Set up Reolink from a config entry.""" host = ReolinkHost(hass, config_entry.data, config_entry.options) try: await host.async_init() except (UserNotAdmin, CredentialsInvalidError, PasswordIncompatible) as err: await host.stop() raise ConfigEntryAuthFailed(err) from err except ( ReolinkException, ReolinkError, ) as err: await host.stop() raise ConfigEntryNotReady( f"Error while trying to setup {host.api.host}:{host.api.port}: {err!s}" ) from err except BaseException: await host.stop() raise config_entry.async_on_unload( hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, host.stop) ) async def async_device_config_update() -> None: """Update the host state cache and renew the ONVIF-subscription.""" async with asyncio.timeout(host.api.timeout * (RETRY_ATTEMPTS + 2)): try: await host.update_states() except CredentialsInvalidError as err: host.credential_errors += 1 if host.credential_errors >= NUM_CRED_ERRORS: await host.stop() raise ConfigEntryAuthFailed(err) from err raise UpdateFailed(str(err)) from err except ReolinkError as err: host.credential_errors = 0 raise UpdateFailed(str(err)) from err host.credential_errors = 0 async with asyncio.timeout(host.api.timeout * (RETRY_ATTEMPTS + 2)): await host.renew() if host.api.new_devices and config_entry.state == ConfigEntryState.LOADED: # Their are new cameras/chimes connected, reload to add them. hass.async_create_task( hass.config_entries.async_reload(config_entry.entry_id) ) async def async_check_firmware_update() -> None: """Check for firmware updates.""" async with asyncio.timeout(host.api.timeout * (RETRY_ATTEMPTS + 2)): try: await host.api.check_new_firmware(host.firmware_ch_list) except ReolinkError as err: if host.starting: _LOGGER.debug( "Error checking Reolink firmware update at startup " "from %s, possibly internet access is blocked", host.api.nvr_name, ) return raise UpdateFailed( f"Error checking Reolink firmware update from {host.api.nvr_name}, " "if the camera is blocked from accessing the internet, " "disable the update entity" ) from err finally: host.starting = False device_coordinator = DataUpdateCoordinator( hass, _LOGGER, name=f"reolink.{host.api.nvr_name}", update_method=async_device_config_update, update_interval=DEVICE_UPDATE_INTERVAL, ) firmware_coordinator = DataUpdateCoordinator( hass, _LOGGER, name=f"reolink.{host.api.nvr_name}.firmware", update_method=async_check_firmware_update, update_interval=FIRMWARE_UPDATE_INTERVAL, ) # If camera WAN blocked, firmware check fails and takes long, do not prevent setup config_entry.async_create_background_task( hass, firmware_coordinator.async_refresh(), f"Reolink firmware check {config_entry.entry_id}", ) # Fetch initial data so we have data when entities subscribe try: await device_coordinator.async_config_entry_first_refresh() except BaseException: await host.stop() raise config_entry.runtime_data = ReolinkData( host=host, device_coordinator=device_coordinator, firmware_coordinator=firmware_coordinator, ) migrate_entity_ids(hass, config_entry.entry_id, host) await hass.config_entries.async_forward_entry_setups(config_entry, PLATFORMS) config_entry.async_on_unload( config_entry.add_update_listener(entry_update_listener) ) return True async def entry_update_listener( hass: HomeAssistant, config_entry: ReolinkConfigEntry ) -> None: """Update the configuration of the host entity.""" await hass.config_entries.async_reload(config_entry.entry_id) async def async_unload_entry( hass: HomeAssistant, config_entry: ReolinkConfigEntry ) -> bool: """Unload a config entry.""" host: ReolinkHost = config_entry.runtime_data.host await host.stop() return await hass.config_entries.async_unload_platforms(config_entry, PLATFORMS) async def async_remove_config_entry_device( hass: HomeAssistant, config_entry: ReolinkConfigEntry, device: dr.DeviceEntry ) -> bool: """Remove a device from a config entry.""" host: ReolinkHost = config_entry.runtime_data.host (device_uid, ch, is_chime) = get_device_uid_and_ch(device, host) if is_chime: await host.api.get_state(cmd="GetDingDongList") chime = host.api.chime(ch) if ( chime is None or chime.connect_state is None or chime.connect_state < 0 or chime.channel not in host.api.channels ): _LOGGER.debug( "Removing Reolink chime %s with id %s, " "since it is not coupled to %s anymore", device.name, ch, host.api.nvr_name, ) return True # remove the chime from the host await chime.remove() await host.api.get_state(cmd="GetDingDongList") if chime.connect_state < 0: _LOGGER.debug( "Removed Reolink chime %s with id %s from %s", device.name, ch, host.api.nvr_name, ) return True _LOGGER.warning( "Cannot remove Reolink chime %s with id %s, because it is still connected " "to %s, please first remove the chime " "in the reolink app", device.name, ch, host.api.nvr_name, ) return False if not host.api.is_nvr or ch is None: _LOGGER.warning( "Cannot remove Reolink device %s, because it is not a camera connected " "to a NVR/Hub, please remove the integration entry instead", device.name, ) return False # Do not remove the host/NVR itself if ch not in host.api.channels: _LOGGER.debug( "Removing Reolink device %s, " "since no camera is connected to NVR channel %s anymore", device.name, ch, ) return True await host.api.get_state(cmd="GetChannelstatus") # update the camera_online status if not host.api.camera_online(ch): _LOGGER.debug( "Removing Reolink device %s, " "since the camera connected to channel %s is offline", device.name, ch, ) return True _LOGGER.warning( "Cannot remove Reolink device %s on channel %s, because it is still connected " "to the NVR/Hub, please first remove the camera from the NVR/Hub " "in the reolink app", device.name, ch, ) return False def migrate_entity_ids( hass: HomeAssistant, config_entry_id: str, host: ReolinkHost ) -> None: """Migrate entity IDs if needed.""" device_reg = dr.async_get(hass) devices = dr.async_entries_for_config_entry(device_reg, config_entry_id) ch_device_ids = {} for device in devices: (device_uid, ch, is_chime) = get_device_uid_and_ch(device, host) if host.api.supported(None, "UID") and device_uid[0] != host.unique_id: if ch is None: new_device_id = f"{host.unique_id}" else: new_device_id = f"{host.unique_id}_{device_uid[1]}" new_identifiers = {(DOMAIN, new_device_id)} device_reg.async_update_device(device.id, new_identifiers=new_identifiers) if ch is None or is_chime: continue # Do not consider the NVR itself or chimes ch_device_ids[device.id] = ch if host.api.supported(ch, "UID") and device_uid[1] != host.api.camera_uid(ch): if host.api.supported(None, "UID"): new_device_id = f"{host.unique_id}_{host.api.camera_uid(ch)}" else: new_device_id = f"{device_uid[0]}_{host.api.camera_uid(ch)}" new_identifiers = {(DOMAIN, new_device_id)} device_reg.async_update_device(device.id, new_identifiers=new_identifiers) entity_reg = er.async_get(hass) entities = er.async_entries_for_config_entry(entity_reg, config_entry_id) for entity in entities: # Can be removed in HA 2025.1.0 if entity.domain == "update" and entity.unique_id in [ host.unique_id, format_mac(host.api.mac_address), ]: entity_reg.async_update_entity( entity.entity_id, new_unique_id=f"{host.unique_id}_firmware" ) continue if host.api.supported(None, "UID") and not entity.unique_id.startswith( host.unique_id ): new_id = f"{host.unique_id}_{entity.unique_id.split("_", 1)[1]}" entity_reg.async_update_entity(entity.entity_id, new_unique_id=new_id) if entity.device_id in ch_device_ids: ch = ch_device_ids[entity.device_id] id_parts = entity.unique_id.split("_", 2) if host.api.supported(ch, "UID") and id_parts[1] != host.api.camera_uid(ch): new_id = f"{host.unique_id}_{host.api.camera_uid(ch)}_{id_parts[2]}" entity_reg.async_update_entity(entity.entity_id, new_unique_id=new_id)