device_tracker.py

Go to the documentation of this file.

"""Support for ASUSWRT routers."""
 
from __future__ import annotations
 
from homeassistant.components.device_tracker import ScannerEntity
from homeassistant.core import HomeAssistant, callback
from homeassistant.helpers.dispatcher import async_dispatcher_connect
from homeassistant.helpers.entity_platform import AddEntitiesCallback
 
from . import AsusWrtConfigEntry
from .router import AsusWrtDevInfo, AsusWrtRouter
 
ATTR_LAST_TIME_REACHABLE = "last_time_reachable"
 
DEFAULT_DEVICE_NAME = "Unknown device"
 
 
async def async_setup_entry(
    hass: HomeAssistant,
    entry: AsusWrtConfigEntry,
    async_add_entities: AddEntitiesCallback,
) -> None:
    """Set up device tracker for AsusWrt component."""
    router = entry.runtime_data
    tracked: set = set()
 
    @callback
    def update_router() -> None:
        """Update the values of the router."""
        add_entities(router, async_add_entities, tracked)
 
    router.async_on_close(
        async_dispatcher_connect(hass, router.signal_device_new, update_router)
    )
 
    update_router()
 
 
@callback
def add_entities(
    router: AsusWrtRouter, async_add_entities: AddEntitiesCallback, tracked: set[str]
) -> None:
    """Add new tracker entities from the router."""
    new_tracked = []
 
    for mac, device in router.devices.items():
        if mac in tracked:
            continue
 
        new_tracked.append(AsusWrtDevice(router, device))
        tracked.add(mac)
 
    async_add_entities(new_tracked)
 
 
class AsusWrtDevice(ScannerEntity):
    """Representation of a AsusWrt device."""
 
    _unrecorded_attributes = frozenset({ATTR_LAST_TIME_REACHABLE})
 
    _attr_should_poll = False
 
    def __init__(self, router: AsusWrtRouter, device: AsusWrtDevInfo) -> None:
        """Initialize a AsusWrt device."""
        self._router_router = router
        self._device_device = device
        self._attr_name_attr_name = device.name or DEFAULT_DEVICE_NAME
 
    @property
    def is_connected(self) -> bool:
        """Return true if the device is connected to the network."""
        return self._device_device.is_connected
 
    @property
    def hostname(self) -> str | None:
        """Return the hostname of device."""
        return self._device_device.name
 
    @property
    def icon(self) -> str:
        """Return device icon."""
        return "mdi:lan-connect" if self._device_device.is_connected else "mdi:lan-disconnect"
 
    @property
    def ip_address(self) -> str | None:
        """Return the primary ip address of the device."""
        return self._device_device.ip_address
 
    @property
    def mac_address(self) -> str:
        """Return the mac address of the device."""
        return self._device_device.mac
 
    @callback
    def async_on_demand_update(self) -> None:
        """Update state."""
        self._device_device = self._router_router.devices[self._device_device.mac]
        self._attr_extra_state_attributes_attr_extra_state_attributes = {}
        if self._device_device.last_activity:
            self._attr_extra_state_attributes_attr_extra_state_attributes[ATTR_LAST_TIME_REACHABLE] = (
                self._device_device.last_activity.isoformat(timespec="seconds")
            )
        self.async_write_ha_state()
 
    async def async_added_to_hass(self) -> None:
        """Register state update callback."""
        self.async_on_remove(
            async_dispatcher_connect(
                self.hass,
                self._router_router.signal_device_update,
                self.async_on_demand_updateasync_on_demand_update,
            )
        )