mirror of
https://github.com/home-assistant/core
synced 2024-08-28 03:36:46 +02:00
505 lines
19 KiB
Python
505 lines
19 KiB
Python
"""Config flow for DLNA DMR."""
|
|
from __future__ import annotations
|
|
|
|
from collections.abc import Callable, Mapping
|
|
from functools import partial
|
|
from ipaddress import IPv6Address, ip_address
|
|
import logging
|
|
from pprint import pformat
|
|
from typing import Any, cast
|
|
from urllib.parse import urlparse
|
|
|
|
from async_upnp_client.client import UpnpError
|
|
from async_upnp_client.profiles.dlna import DmrDevice
|
|
from async_upnp_client.profiles.profile import find_device_of_type
|
|
from getmac import get_mac_address
|
|
import voluptuous as vol
|
|
|
|
from homeassistant import config_entries
|
|
from homeassistant.components import ssdp
|
|
from homeassistant.const import CONF_DEVICE_ID, CONF_HOST, CONF_MAC, CONF_TYPE, CONF_URL
|
|
from homeassistant.core import HomeAssistant, callback
|
|
from homeassistant.data_entry_flow import FlowResult
|
|
from homeassistant.exceptions import IntegrationError
|
|
from homeassistant.helpers import config_validation as cv, device_registry as dr
|
|
|
|
from .const import (
|
|
CONF_BROWSE_UNFILTERED,
|
|
CONF_CALLBACK_URL_OVERRIDE,
|
|
CONF_LISTEN_PORT,
|
|
CONF_POLL_AVAILABILITY,
|
|
DEFAULT_NAME,
|
|
DOMAIN,
|
|
)
|
|
from .data import get_domain_data
|
|
|
|
LOGGER = logging.getLogger(__name__)
|
|
|
|
FlowInput = Mapping[str, Any] | None
|
|
|
|
|
|
class ConnectError(IntegrationError):
|
|
"""Error occurred when trying to connect to a device."""
|
|
|
|
|
|
class DlnaDmrFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
|
|
"""Handle a DLNA DMR config flow.
|
|
|
|
The Unique Device Name (UDN) of the DMR device is used as the unique_id for
|
|
config entries and for entities. This UDN may differ from the root UDN if
|
|
the DMR is an embedded device.
|
|
"""
|
|
|
|
VERSION = 1
|
|
|
|
def __init__(self) -> None:
|
|
"""Initialize flow."""
|
|
self._discoveries: dict[str, ssdp.SsdpServiceInfo] = {}
|
|
self._location: str | None = None
|
|
self._udn: str | None = None
|
|
self._device_type: str | None = None
|
|
self._name: str | None = None
|
|
self._mac: str | None = None
|
|
self._options: dict[str, Any] = {}
|
|
|
|
@staticmethod
|
|
@callback
|
|
def async_get_options_flow(
|
|
config_entry: config_entries.ConfigEntry,
|
|
) -> config_entries.OptionsFlow:
|
|
"""Define the config flow to handle options."""
|
|
return DlnaDmrOptionsFlowHandler(config_entry)
|
|
|
|
async def async_step_user(self, user_input: FlowInput = None) -> FlowResult:
|
|
"""Handle a flow initialized by the user.
|
|
|
|
Let user choose from a list of found and unconfigured devices or to
|
|
enter an URL manually.
|
|
"""
|
|
LOGGER.debug("async_step_user: user_input: %s", user_input)
|
|
|
|
if user_input is not None:
|
|
if not (host := user_input.get(CONF_HOST)):
|
|
# No device chosen, user might want to directly enter an URL
|
|
return await self.async_step_manual()
|
|
# User has chosen a device, ask for confirmation
|
|
discovery = self._discoveries[host]
|
|
await self._async_set_info_from_discovery(discovery)
|
|
return self._create_entry()
|
|
|
|
if not (discoveries := await self._async_get_discoveries()):
|
|
# Nothing found, maybe the user knows an URL to try
|
|
return await self.async_step_manual()
|
|
|
|
self._discoveries = {
|
|
discovery.upnp.get(ssdp.ATTR_UPNP_FRIENDLY_NAME)
|
|
or cast(str, urlparse(discovery.ssdp_location).hostname): discovery
|
|
for discovery in discoveries
|
|
}
|
|
|
|
data_schema = vol.Schema(
|
|
{vol.Optional(CONF_HOST): vol.In(self._discoveries.keys())}
|
|
)
|
|
return self.async_show_form(step_id="user", data_schema=data_schema)
|
|
|
|
async def async_step_manual(self, user_input: FlowInput = None) -> FlowResult:
|
|
"""Manual URL entry by the user."""
|
|
LOGGER.debug("async_step_manual: user_input: %s", user_input)
|
|
|
|
# Device setup manually, assume we don't get SSDP broadcast notifications
|
|
self._options[CONF_POLL_AVAILABILITY] = True
|
|
|
|
errors = {}
|
|
if user_input is not None:
|
|
self._location = user_input[CONF_URL]
|
|
try:
|
|
await self._async_connect()
|
|
except ConnectError as err:
|
|
errors["base"] = err.args[0]
|
|
else:
|
|
return self._create_entry()
|
|
|
|
data_schema = vol.Schema({CONF_URL: str})
|
|
return self.async_show_form(
|
|
step_id="manual", data_schema=data_schema, errors=errors
|
|
)
|
|
|
|
async def async_step_ssdp(self, discovery_info: ssdp.SsdpServiceInfo) -> FlowResult:
|
|
"""Handle a flow initialized by SSDP discovery."""
|
|
if LOGGER.isEnabledFor(logging.DEBUG):
|
|
LOGGER.debug("async_step_ssdp: discovery_info %s", pformat(discovery_info))
|
|
|
|
await self._async_set_info_from_discovery(discovery_info)
|
|
|
|
if _is_ignored_device(discovery_info):
|
|
return self.async_abort(reason="alternative_integration")
|
|
|
|
# Abort if the device doesn't support all services required for a DmrDevice.
|
|
if not _is_dmr_device(discovery_info):
|
|
return self.async_abort(reason="not_dmr")
|
|
|
|
# Abort if another config entry has the same location or MAC address, in
|
|
# case the device doesn't have a static and unique UDN (breaking the
|
|
# UPnP spec).
|
|
for entry in self._async_current_entries(include_ignore=True):
|
|
if self._location == entry.data[CONF_URL]:
|
|
return self.async_abort(reason="already_configured")
|
|
if self._mac and self._mac == entry.data.get(CONF_MAC):
|
|
return self.async_abort(reason="already_configured")
|
|
|
|
self.context["title_placeholders"] = {"name": self._name}
|
|
|
|
return await self.async_step_confirm()
|
|
|
|
async def async_step_ignore(self, user_input: Mapping[str, Any]) -> FlowResult:
|
|
"""Ignore this config flow, and add MAC address as secondary identifier.
|
|
|
|
Not all DMR devices correctly implement the spec, so their UDN may
|
|
change between boots. Use the MAC address as a secondary identifier so
|
|
they can still be ignored in this case.
|
|
"""
|
|
LOGGER.debug("async_step_ignore: user_input: %s", user_input)
|
|
self._udn = user_input["unique_id"]
|
|
assert self._udn
|
|
await self.async_set_unique_id(self._udn, raise_on_progress=False)
|
|
|
|
# Try to get relevant info from SSDP discovery, but don't worry if it's
|
|
# not available - the data values will just be None in that case
|
|
for dev_type in DmrDevice.DEVICE_TYPES:
|
|
discovery = await ssdp.async_get_discovery_info_by_udn_st(
|
|
self.hass, self._udn, dev_type
|
|
)
|
|
if discovery:
|
|
await self._async_set_info_from_discovery(
|
|
discovery, abort_if_configured=False
|
|
)
|
|
break
|
|
|
|
return self.async_create_entry(
|
|
title=user_input["title"],
|
|
data={
|
|
CONF_URL: self._location,
|
|
CONF_DEVICE_ID: self._udn,
|
|
CONF_TYPE: self._device_type,
|
|
CONF_MAC: self._mac,
|
|
},
|
|
)
|
|
|
|
async def async_step_unignore(self, user_input: Mapping[str, Any]) -> FlowResult:
|
|
"""Rediscover previously ignored devices by their unique_id."""
|
|
LOGGER.debug("async_step_unignore: user_input: %s", user_input)
|
|
self._udn = user_input["unique_id"]
|
|
assert self._udn
|
|
await self.async_set_unique_id(self._udn)
|
|
|
|
# Find a discovery matching the unignored unique_id for a DMR device
|
|
for dev_type in DmrDevice.DEVICE_TYPES:
|
|
discovery = await ssdp.async_get_discovery_info_by_udn_st(
|
|
self.hass, self._udn, dev_type
|
|
)
|
|
if discovery:
|
|
break
|
|
else:
|
|
return self.async_abort(reason="discovery_error")
|
|
|
|
await self._async_set_info_from_discovery(discovery, abort_if_configured=False)
|
|
|
|
self.context["title_placeholders"] = {"name": self._name}
|
|
|
|
return await self.async_step_confirm()
|
|
|
|
async def async_step_confirm(self, user_input: FlowInput = None) -> FlowResult:
|
|
"""Allow the user to confirm adding the device."""
|
|
LOGGER.debug("async_step_confirm: %s", user_input)
|
|
|
|
if user_input is not None:
|
|
return self._create_entry()
|
|
|
|
self._set_confirm_only()
|
|
return self.async_show_form(step_id="confirm")
|
|
|
|
async def _async_connect(self) -> None:
|
|
"""Connect to a device to confirm it works and gather extra information.
|
|
|
|
Updates this flow's unique ID to the device UDN if not already done.
|
|
Raises ConnectError if something goes wrong.
|
|
"""
|
|
LOGGER.debug("_async_connect: location: %s", self._location)
|
|
assert self._location, "self._location has not been set before connect"
|
|
|
|
domain_data = get_domain_data(self.hass)
|
|
try:
|
|
device = await domain_data.upnp_factory.async_create_device(self._location)
|
|
except UpnpError as err:
|
|
raise ConnectError("cannot_connect") from err
|
|
|
|
if not DmrDevice.is_profile_device(device):
|
|
raise ConnectError("not_dmr")
|
|
|
|
device = find_device_of_type(device, DmrDevice.DEVICE_TYPES)
|
|
|
|
if not self._udn:
|
|
self._udn = device.udn
|
|
await self.async_set_unique_id(self._udn)
|
|
|
|
# Abort if already configured, but update the last-known location
|
|
self._abort_if_unique_id_configured(
|
|
updates={CONF_URL: self._location}, reload_on_update=False
|
|
)
|
|
|
|
if not self._device_type:
|
|
self._device_type = device.device_type
|
|
|
|
if not self._name:
|
|
self._name = device.name
|
|
|
|
if not self._mac and (host := urlparse(self._location).hostname):
|
|
self._mac = await _async_get_mac_address(self.hass, host)
|
|
|
|
def _create_entry(self) -> FlowResult:
|
|
"""Create a config entry, assuming all required information is now known."""
|
|
LOGGER.debug(
|
|
"_async_create_entry: location: %s, UDN: %s", self._location, self._udn
|
|
)
|
|
assert self._location
|
|
assert self._udn
|
|
assert self._device_type
|
|
|
|
title = self._name or urlparse(self._location).hostname or DEFAULT_NAME
|
|
data = {
|
|
CONF_URL: self._location,
|
|
CONF_DEVICE_ID: self._udn,
|
|
CONF_TYPE: self._device_type,
|
|
CONF_MAC: self._mac,
|
|
}
|
|
return self.async_create_entry(title=title, data=data, options=self._options)
|
|
|
|
async def _async_set_info_from_discovery(
|
|
self, discovery_info: ssdp.SsdpServiceInfo, abort_if_configured: bool = True
|
|
) -> None:
|
|
"""Set information required for a config entry from the SSDP discovery."""
|
|
LOGGER.debug(
|
|
"_async_set_info_from_discovery: location: %s, UDN: %s",
|
|
discovery_info.ssdp_location,
|
|
discovery_info.ssdp_udn,
|
|
)
|
|
|
|
if not self._location:
|
|
self._location = discovery_info.ssdp_location
|
|
assert isinstance(self._location, str)
|
|
|
|
self._udn = discovery_info.ssdp_udn
|
|
await self.async_set_unique_id(self._udn, raise_on_progress=abort_if_configured)
|
|
|
|
self._device_type = discovery_info.ssdp_nt or discovery_info.ssdp_st
|
|
self._name = (
|
|
discovery_info.upnp.get(ssdp.ATTR_UPNP_FRIENDLY_NAME)
|
|
or urlparse(self._location).hostname
|
|
or DEFAULT_NAME
|
|
)
|
|
|
|
if host := discovery_info.ssdp_headers.get("_host"):
|
|
self._mac = await _async_get_mac_address(self.hass, host)
|
|
|
|
if abort_if_configured:
|
|
# Abort if already configured, but update the last-known location
|
|
updates = {CONF_URL: self._location}
|
|
# Set the MAC address for older entries
|
|
if self._mac:
|
|
updates[CONF_MAC] = self._mac
|
|
self._abort_if_unique_id_configured(updates=updates, reload_on_update=False)
|
|
|
|
async def _async_get_discoveries(self) -> list[ssdp.SsdpServiceInfo]:
|
|
"""Get list of unconfigured DLNA devices discovered by SSDP."""
|
|
LOGGER.debug("_get_discoveries")
|
|
|
|
# Get all compatible devices from ssdp's cache
|
|
discoveries: list[ssdp.SsdpServiceInfo] = []
|
|
for udn_st in DmrDevice.DEVICE_TYPES:
|
|
st_discoveries = await ssdp.async_get_discovery_info_by_st(
|
|
self.hass, udn_st
|
|
)
|
|
discoveries.extend(st_discoveries)
|
|
|
|
# Filter out devices already configured
|
|
current_unique_ids = {
|
|
entry.unique_id
|
|
for entry in self._async_current_entries(include_ignore=False)
|
|
}
|
|
discoveries = [
|
|
disc for disc in discoveries if disc.ssdp_udn not in current_unique_ids
|
|
]
|
|
|
|
return discoveries
|
|
|
|
|
|
class DlnaDmrOptionsFlowHandler(config_entries.OptionsFlow):
|
|
"""Handle a DLNA DMR options flow.
|
|
|
|
Configures the single instance and updates the existing config entry.
|
|
"""
|
|
|
|
def __init__(self, config_entry: config_entries.ConfigEntry) -> None:
|
|
"""Initialize."""
|
|
self.config_entry = config_entry
|
|
|
|
async def async_step_init(
|
|
self, user_input: dict[str, Any] | None = None
|
|
) -> FlowResult:
|
|
"""Manage the options."""
|
|
errors: dict[str, str] = {}
|
|
# Don't modify existing (read-only) options -- copy and update instead
|
|
options = dict(self.config_entry.options)
|
|
|
|
if user_input is not None:
|
|
LOGGER.debug("user_input: %s", user_input)
|
|
listen_port = user_input.get(CONF_LISTEN_PORT) or None
|
|
callback_url_override = user_input.get(CONF_CALLBACK_URL_OVERRIDE) or None
|
|
|
|
try:
|
|
# Cannot use cv.url validation in the schema itself so apply
|
|
# extra validation here
|
|
if callback_url_override:
|
|
cv.url(callback_url_override)
|
|
except vol.Invalid:
|
|
errors["base"] = "invalid_url"
|
|
|
|
options[CONF_LISTEN_PORT] = listen_port
|
|
options[CONF_CALLBACK_URL_OVERRIDE] = callback_url_override
|
|
options[CONF_POLL_AVAILABILITY] = user_input[CONF_POLL_AVAILABILITY]
|
|
options[CONF_BROWSE_UNFILTERED] = user_input[CONF_BROWSE_UNFILTERED]
|
|
|
|
# Save if there's no errors, else fall through and show the form again
|
|
if not errors:
|
|
return self.async_create_entry(title="", data=options)
|
|
|
|
fields = {}
|
|
|
|
def _add_with_suggestion(key: str, validator: Callable | type[bool]) -> None:
|
|
"""Add a field to with a suggested value.
|
|
|
|
For bools, use the existing value as default, or fallback to False.
|
|
"""
|
|
if validator is bool:
|
|
fields[vol.Required(key, default=options.get(key, False))] = validator
|
|
elif (suggested_value := options.get(key)) is None:
|
|
fields[vol.Optional(key)] = validator
|
|
else:
|
|
fields[
|
|
vol.Optional(key, description={"suggested_value": suggested_value})
|
|
] = validator
|
|
|
|
# listen_port can be blank or 0 for "bind any free port"
|
|
_add_with_suggestion(CONF_LISTEN_PORT, cv.port)
|
|
_add_with_suggestion(CONF_CALLBACK_URL_OVERRIDE, str)
|
|
_add_with_suggestion(CONF_POLL_AVAILABILITY, bool)
|
|
_add_with_suggestion(CONF_BROWSE_UNFILTERED, bool)
|
|
|
|
return self.async_show_form(
|
|
step_id="init",
|
|
data_schema=vol.Schema(fields),
|
|
errors=errors,
|
|
)
|
|
|
|
|
|
def _is_ignored_device(discovery_info: ssdp.SsdpServiceInfo) -> bool:
|
|
"""Return True if this device should be ignored for discovery.
|
|
|
|
These devices are supported better by other integrations, so don't bug
|
|
the user about them. The user can add them if desired by via the user config
|
|
flow, which will list all discovered but unconfigured devices.
|
|
"""
|
|
# Did the discovery trigger more than just this flow?
|
|
if len(discovery_info.x_homeassistant_matching_domains) > 1:
|
|
LOGGER.debug(
|
|
"Ignoring device supported by multiple integrations: %s",
|
|
discovery_info.x_homeassistant_matching_domains,
|
|
)
|
|
return True
|
|
|
|
# Is the root device not a DMR?
|
|
if (
|
|
discovery_info.upnp.get(ssdp.ATTR_UPNP_DEVICE_TYPE)
|
|
not in DmrDevice.DEVICE_TYPES
|
|
):
|
|
return True
|
|
|
|
# Special cases for devices with other discovery methods (e.g. mDNS), or
|
|
# that advertise multiple unrelated (sent in separate discovery packets)
|
|
# UPnP devices.
|
|
manufacturer = (discovery_info.upnp.get(ssdp.ATTR_UPNP_MANUFACTURER) or "").lower()
|
|
model = (discovery_info.upnp.get(ssdp.ATTR_UPNP_MODEL_NAME) or "").lower()
|
|
|
|
if manufacturer.startswith("xbmc") or model == "kodi":
|
|
# kodi
|
|
return True
|
|
if "philips" in manufacturer and "tv" in model:
|
|
# philips_js
|
|
# These TVs don't have a stable UDN, so also get discovered as a new
|
|
# device every time they are turned on.
|
|
return True
|
|
if manufacturer.startswith("samsung") and "tv" in model:
|
|
# samsungtv
|
|
return True
|
|
if manufacturer.startswith("lg") and "tv" in model:
|
|
# webostv
|
|
return True
|
|
|
|
return False
|
|
|
|
|
|
def _is_dmr_device(discovery_info: ssdp.SsdpServiceInfo) -> bool:
|
|
"""Determine if discovery is a complete DLNA DMR device.
|
|
|
|
Use the discovery_info instead of DmrDevice.is_profile_device to avoid
|
|
contacting the device again.
|
|
"""
|
|
# Abort if the device doesn't support all services required for a DmrDevice.
|
|
discovery_service_list = discovery_info.upnp.get(ssdp.ATTR_UPNP_SERVICE_LIST)
|
|
if not discovery_service_list:
|
|
return False
|
|
|
|
services = discovery_service_list.get("service")
|
|
if not services:
|
|
discovery_service_ids: set[str] = set()
|
|
elif isinstance(services, list):
|
|
discovery_service_ids = {service.get("serviceId") for service in services}
|
|
else:
|
|
# Only one service defined (etree_to_dict failed to make a list)
|
|
discovery_service_ids = {services.get("serviceId")}
|
|
|
|
if not DmrDevice.SERVICE_IDS.issubset(discovery_service_ids):
|
|
return False
|
|
|
|
return True
|
|
|
|
|
|
async def _async_get_mac_address(hass: HomeAssistant, host: str) -> str | None:
|
|
"""Get mac address from host name, IPv4 address, or IPv6 address."""
|
|
# Help mypy, which has trouble with the async_add_executor_job + partial call
|
|
mac_address: str | None
|
|
# getmac has trouble using IPv6 addresses as the "hostname" parameter so
|
|
# assume host is an IP address, then handle the case it's not.
|
|
try:
|
|
ip_addr = ip_address(host)
|
|
except ValueError:
|
|
mac_address = await hass.async_add_executor_job(
|
|
partial(get_mac_address, hostname=host)
|
|
)
|
|
else:
|
|
if ip_addr.version == 4:
|
|
mac_address = await hass.async_add_executor_job(
|
|
partial(get_mac_address, ip=host)
|
|
)
|
|
else:
|
|
# Drop scope_id from IPv6 address by converting via int
|
|
ip_addr = IPv6Address(int(ip_addr))
|
|
mac_address = await hass.async_add_executor_job(
|
|
partial(get_mac_address, ip6=str(ip_addr))
|
|
)
|
|
|
|
if not mac_address:
|
|
return None
|
|
|
|
return dr.format_mac(mac_address)
|