Add hivi speaker integration

homeassistant/components/hivi_speaker/__init__.py

@@ -0,0 +1,154 @@
+"""The hivi_speaker integration."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers import device_registry as dr
+from homeassistant.helpers.device_registry import DeviceEntry
+from homeassistant.helpers.storage import Store
+
+from .const import DOMAIN
+from .device import HIVIDevice
+from .device_manager import HIVIDeviceManager
+
+_LOGGER = logging.getLogger(__name__)
+
+
+PLATFORMS = ["switch"]
+
+
+async def async_setup_entry(hass: HomeAssistant, config_entry: ConfigEntry) -> bool:
+    """Set up the config entry."""
+    device_manager = HIVIDeviceManager(hass, config_entry)
+    await device_manager.async_setup()
+
+    hass.data.setdefault(DOMAIN, {})
+    hass.data[DOMAIN].setdefault(config_entry.entry_id, {})
+    hass.data[DOMAIN][config_entry.entry_id]["device_manager"] = device_manager
+
+    await hass.config_entries.async_forward_entry_setups(config_entry, PLATFORMS)
+
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+    """Unload config entry and clean up related resources."""
+    _LOGGER.debug("Starting to unload config entry %s", entry.entry_id)
+
+    data = hass.data.get(DOMAIN, {}).get(entry.entry_id, {})
+
+    device_manager = data.get("device_manager")
+    if device_manager:
+        try:
+            await device_manager.async_cleanup()
+        except Exception:
+            _LOGGER.exception("Exception occurred while cleaning up device_manager")
+
+    try:
+        unload_ok = await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
+    except Exception:
+        _LOGGER.exception("Failed to call async_unload_platforms")
+        unload_ok = False
+
+    try:
+        if DOMAIN in hass.data and entry.entry_id in hass.data[DOMAIN]:
+            hass.data[DOMAIN].pop(entry.entry_id, None)
+            if not hass.data[DOMAIN]:
+                hass.data.pop(DOMAIN, None)
+    except Exception:
+        _LOGGER.exception("Exception occurred while cleaning up hass.data")
+
+    if not unload_ok:
+        _LOGGER.error(
+            "Platform unloading partially failed (unload_ok=False), there may be residual entities or platforms"
+        )
+    else:
+        _LOGGER.debug("Config entry %s unloaded successfully", entry.entry_id)
+
+    return unload_ok
+
+
+async def async_remove_entry(hass: HomeAssistant, entry: ConfigEntry) -> None:
+    """Remove config entry and clean up devices and persistent storage."""
+    _LOGGER.debug("Removing config entry %s – cleaning up devices", entry.entry_id)
+
+    try:
+        dev_reg = dr.async_get(hass)
+        for device in list(dev_reg.devices.values()):
+            config_entries = getattr(device, "config_entries", None)
+            if (config_entries and entry.entry_id in config_entries) or getattr(
+                device, "config_entry_id", None
+            ) == entry.entry_id:
+                dev_reg.async_remove_device(device.id)
+    except Exception:
+        _LOGGER.exception("Error cleaning up device registry on entry removal")
+
+    try:
+        store: Store[Any] = Store(hass, 1, "hivi_speaker_device_data")
+        await store.async_remove()
+        _LOGGER.debug("Persistent device data storage removed")
+    except Exception:
+        _LOGGER.exception("Error removing persistent storage on entry removal")
+
+
+async def async_remove_config_entry_device(
+    hass: HomeAssistant, config_entry: ConfigEntry, device_entry: DeviceEntry
+) -> bool:
+    """Handle removal of a device from the UI/device registry.
+
+    Return True to allow Home Assistant to remove the device entry.
+    Only devices belonging to this integration (DOMAIN in identifiers) are cleaned up.
+    """
+    if not any(identifier[0] == DOMAIN for identifier in device_entry.identifiers):
+        return False
+
+    try:
+        domain_data = hass.data.get(DOMAIN, {}).get(config_entry.entry_id, {})
+        device_manager = domain_data.get("device_manager")
+        if device_manager is None:
+            _LOGGER.debug(
+                "Device manager not found for entry %s, allowing device deletion %s",
+                config_entry.entry_id,
+                device_entry.id,
+            )
+            return True
+
+        ha_device_id = device_entry.id
+        speaker_device_id = None
+        device_dict = (
+            device_manager.device_data_registry.get_device_dict_by_ha_device_id(
+                ha_device_id
+            )
+        )
+        if device_dict is not None:
+            device_obj = HIVIDevice(**device_dict)
+            speaker_device_id = device_obj.speaker_device_id
+
+        await device_manager.async_remove_entities_for_device(ha_device_id)
+        await device_manager.device_data_registry.async_remove_device_data(ha_device_id)
+        _LOGGER.debug(
+            "Cleaned up entities and data for device %s, HA will remove the device entry",
+            ha_device_id,
+        )
+
+        if speaker_device_id:
+            await device_manager.remove_control_entities_by_speaker_device_id(
+                speaker_device_id
+            )
+            _LOGGER.debug(
+                "Requested device manager to delete control entities for speaker device ID %s",
+                speaker_device_id,
+            )
+
+    except Exception:
+        _LOGGER.exception(
+            "Error in async_remove_config_entry_device for device %s",
+            device_entry.id,
+        )
+        return True
+    else:
+        return True

homeassistant/components/hivi_speaker/config_flow.py

@@ -0,0 +1,92 @@
+"""Config flow for HiVi Speaker integration."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+import voluptuous as vol
+
+from homeassistant import config_entries
+from homeassistant.config_entries import (
+    ConfigEntry,
+    ConfigFlow,
+    ConfigFlowResult,
+    OptionsFlow,
+)
+from homeassistant.core import callback
+
+from .const import DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class HIVISpeakerConfigFlow(ConfigFlow, domain=DOMAIN):
+    """HIVI speaker configuration flow."""
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """User step - configure integration."""
+        await self.async_set_unique_id(DOMAIN)
+        self._abort_if_unique_id_configured()
+        return self.async_create_entry(title="HiVi Speaker", data={})
+
+    @staticmethod
+    @callback
+    def async_get_options_flow(config_entry: ConfigEntry) -> OptionsFlow:
+        """Get options flow."""
+        return HIVISpeakerOptionsFlow()
+
+
+class HIVISpeakerOptionsFlow(config_entries.OptionsFlow):
+    """Options flow - using confirmation switch."""
+
+    def __init__(self) -> None:
+        """Initialize the options flow."""
+        super().__init__()
+        self.open_num = 0
+
+    async def async_step_init(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Show initial step of the options flow."""
+        _LOGGER.debug("Entering initial step of options flow")
+        self.open_num = 0
+        if user_input is not None:
+            if user_input.get("confirm_refresh"):
+                domain_data = self.hass.data.get(DOMAIN, {}).get(
+                    self.config_entry.entry_id, {}
+                )
+                device_manager = domain_data.get("device_manager")
+                if device_manager is not None:
+                    await device_manager.refresh_discovery()
+                else:
+                    _LOGGER.warning(
+                        "Device manager not available; skipping refresh from options"
+                    )
+                return await self.async_step_success()
+
+            return self.async_create_entry(title="", data={})
+
+        return self.async_show_form(
+            step_id="init",
+            data_schema=vol.Schema(
+                {
+                    vol.Required("confirm_refresh", default=True): bool,
+                }
+            ),
+        )
+
+    async def async_step_success(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Success page."""
+        _LOGGER.debug("Displaying success page")
+        if self.open_num == 0:
+            self.open_num += 1
+            return self.async_show_form(
+                step_id="success",
+                data_schema=vol.Schema({}),
+            )
+        return self.async_create_entry(title="", data={})

homeassistant/components/hivi_speaker/const.py

@@ -0,0 +1,13 @@
+"""Constants for the HiVi Speaker integration."""
+
+from __future__ import annotations
+
+DOMAIN = "hivi_speaker"
+
+DISCOVERY_UPDATED = "hivi_speaker_discovery_updated"
+DEVICE_RELATION_CHANGED = "hivi_speaker_device_relation_changed"
+SIGNAL_DEVICE_DISCOVERED = "hivi_speaker_signal_device_discovered"
+SIGNAL_DEVICE_STATUS_UPDATED = "hivi_speaker_signal_device_status_updated"
+
+DISCOVERY_BASE_INTERVAL = 300  # seconds
+DEVICE_OFFLINE_THRESHOLD = 180  # seconds

homeassistant/components/hivi_speaker/device.py

@@ -0,0 +1,115 @@
+"""Device models for the HiVi Speaker integration."""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime
+from enum import Enum
+
+from pydantic import BaseModel, Field
+
+
+class SyncGroupStatus(Enum):
+    """Sync group status or master/slave relationship status of a device."""
+
+    UNKNOWN = "unknown"
+    MASTER = "master"
+    SLAVE = "slave"
+    STANDALONE = "standalone"
+
+
+class ConnectionStatus(Enum):
+    """Device status."""
+
+    ONLINE = "online"
+    OFFLINE = "offline"
+    UNAVAILABLE = "unavailable"
+
+
+class SlaveDeviceInfo(BaseModel):
+    """Slave speaker information class."""
+
+    friendly_name: str
+    ssid: str
+    mask: int | None
+    volume: int
+    mute: bool
+    channel: int
+    battery: int | None
+    ip_addr: str
+    version: str
+    uuid: str
+
+
+class HIVIDevice(BaseModel):
+    """HIVI speaker device base class."""
+
+    speaker_device_id: str = ""
+    unique_id: str = ""
+    friendly_name: str = ""
+    model: str = ""
+    manufacturer: str = ""
+    ha_device_id: str = ""
+    hardware: str = ""
+
+    ip_addr: str = ""
+    mac_address: str = ""
+    hostname: str = ""
+
+    supports_dlna: bool = True
+    supports_private_protocol: bool = True
+    sync_group_status: SyncGroupStatus = SyncGroupStatus.STANDALONE
+
+    connection_status: ConnectionStatus = ConnectionStatus.ONLINE
+    last_seen: datetime = Field(default_factory=lambda: datetime.now(tz=UTC))
+
+    master_speaker_device_id: str | None = None
+    slave_device_num: int = 0
+    slave_device_list: list[SlaveDeviceInfo] = Field(default_factory=list)
+
+    dlna_udn: str | None = None
+    dlna_location: str | None = None
+
+    private_protocol_version: str | None = None
+    private_port: int = 9527
+
+    entity_id: str | None = None
+    config_entry_id: str | None = None
+
+    wifi_channel: str = "0"
+    ssid: str | None = None
+    auth_mode: str | None = None
+    encryption_mode: str | None = None
+    psk: str | None = None
+    uuid: str | None = None
+
+    def model_post_init(self, __context, /) -> None:
+        """Auto-generate unique_id from mac_address if not provided."""
+        if not self.unique_id:
+            mac_address = self.mac_address.replace(":", "")
+            if mac_address:
+                self.unique_id = f"hivi_{mac_address}"
+
+    @property
+    def is_available_for_media(self) -> bool:
+        """Whether available as media player (non-slave speaker)."""
+        return (
+            self.sync_group_status != SyncGroupStatus.SLAVE
+            and self.connection_status == ConnectionStatus.ONLINE
+        )
+
+    @property
+    def can_be_master(self) -> bool:
+        """Whether can be set as master speaker."""
+        return (
+            self.sync_group_status
+            in {SyncGroupStatus.MASTER, SyncGroupStatus.STANDALONE}
+            and self.connection_status == ConnectionStatus.ONLINE
+        )
+
+    @property
+    def can_be_slave(self) -> bool:
+        """Whether can be set as slave speaker."""
+        return (
+            self.sync_group_status == SyncGroupStatus.STANDALONE
+            and self.connection_status == ConnectionStatus.ONLINE
+        )