Fix manifest.json according to hassfest + Add rx_module implementation + Add tests for easywave

Author: =

CODEOWNERS

@@ -1,12 +1,14 @@
 """The Easywave integration."""
+
 from __future__ import annotations
 
+from dataclasses import dataclass
 import logging
 
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import Platform
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import HomeAssistantError
+from homeassistant.exceptions import ConfigEntryNotReady, HomeAssistantError
 from homeassistant.helpers import device_registry as dr, issue_registry as ir
 
 from .const import (
@@ -15,18 +17,29 @@
     get_frequency_for_pid,
     is_country_allowed_for_frequency,
 )
+from .coordinator import EasywaveCoordinator
+from .transceiver import RX11Transceiver
 
 _LOGGER = logging.getLogger(__name__)
 
-type EasywaveConfigEntry = ConfigEntry[None]
+
+@dataclass
+class EasywaveRuntimeData:
+    """Runtime data for the Easywave integration."""
+
+    coordinator: EasywaveCoordinator
+    frequency: str
+    country: str
+
+
+type EasywaveConfigEntry = ConfigEntry[EasywaveRuntimeData]
 
 PLATFORMS: list[Platform] = [Platform.SENSOR]
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: EasywaveConfigEntry) -> bool:
     """Set up Easywave from a config entry."""
-    hass.data.setdefault(DOMAIN, {})
-    
+
     # ── Regulatory compliance check (868 MHz) ──────────────────────────
     # The operating frequency is derived from the USB device's PID.
     # If the configured HA country is outside the allowed region for that
@@ -37,8 +50,9 @@ async def async_setup_entry(hass: HomeAssistant, entry: EasywaveConfigEntry) ->
 
     if frequency and not is_country_allowed_for_frequency(frequency, country_code):
         _LOGGER.warning(
-            "This hardware operates on %s, which is not permitted in your "
-            "configured region (%s). Integration disabled for regulatory compliance.",
+            "This hardware operates on %s, which is not permitted in "
+            "your configured region (%s). Integration disabled for "
+            "regulatory compliance",
             frequency,
             country_code or "unknown",
         )
@@ -55,26 +69,52 @@ async def async_setup_entry(hass: HomeAssistant, entry: EasywaveConfigEntry) ->
                 "country": country_code or "unknown",
             },
         )
+        # Return False for regulatory compliance violation (not a setup error)
         return False
 
     # If the check passed, make sure any stale repair issue is removed
     # (e.g. user changed their country setting).
     ir.async_delete_issue(hass, DOMAIN, f"frequency_not_permitted_{entry.entry_id}")
-    
+
+    # ── Initialize transceiver and coordinator ──────────────────────────
+    # Create transceiver instance (will search for USB RX11 device)
+    transceiver = RX11Transceiver(hass)
+
+    # Create coordinator for managing connection lifecycle & offline mode
+    coordinator = EasywaveCoordinator(hass, transceiver, entry)
+
+    # Attempt initial setup (may succeed in offline mode)
+    if not await coordinator.async_setup():
+        raise ConfigEntryNotReady("Failed to initialize coordinator")
+
+    # Set runtime data for the integration
+    entry.runtime_data = EasywaveRuntimeData(
+        coordinator=coordinator,
+        frequency=frequency or "unknown",
+        country=country_code or "unknown",
+    )
+
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
     return True
 
 
 async def async_unload_entry(hass: HomeAssistant, entry: EasywaveConfigEntry) -> bool:
     """Unload a config entry."""
+    # Shutdown coordinator
+    if hasattr(entry, "runtime_data") and entry.runtime_data:
+        await entry.runtime_data.coordinator.async_shutdown()
+
     return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
 
 
 async def async_remove_config_entry_device(
     hass: HomeAssistant, config_entry: ConfigEntry, device_entry: dr.DeviceEntry
 ) -> bool:
-    """Prevent removing the RX11 gateway device via the UI device menu."""
-    raise HomeAssistantError(
-        translation_domain=DOMAIN,
-        translation_key="cannot_delete_rx11",
-    )
+    """Allow removing devices except the RX11 gateway."""
+    gateway_identifier = (DOMAIN, f"{config_entry.entry_id}_gateway")
+    if gateway_identifier in device_entry.identifiers:
+        raise HomeAssistantError(
+            translation_domain=DOMAIN,
+            translation_key="cannot_delete_gateway",
+        )
+    return True

homeassistant/components/easywave/__init__.py

@@ -1,20 +1,21 @@
 """Config flow for the Easywave integration."""
+
 from __future__ import annotations
 
 import logging
 from typing import Any
 
-import voluptuous as vol
 import serial.tools.list_ports
+import voluptuous as vol
 
-from homeassistant.components import usb
 from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
 from homeassistant.helpers.selector import (
     SelectOptionDict,
     SelectSelector,
     SelectSelectorConfig,
     SelectSelectorMode,
 )
+from homeassistant.helpers.service_info.usb import UsbServiceInfo
 
 from .const import (
     CONF_DEVICE_PATH,
@@ -42,7 +43,11 @@ def _find_easywave_devices() -> list[dict[str, Any]]:
             if (port.vid, port.pid) in SUPPORTED_USB_IDS:
                 device_entry = USB_DEVICE_NAMES.get((port.vid, port.pid))
                 mfr = device_entry["manufacturer"] if device_entry else "ELDAT EaS GmbH"
-                prod = device_entry["product"] if device_entry else "Unknown Easywave Device"
+                prod = (
+                    device_entry["product"]
+                    if device_entry
+                    else "Unknown Easywave Device"
+                )
                 devices.append(
                     {
                         "device": port.device,
@@ -53,7 +58,7 @@ def _find_easywave_devices() -> list[dict[str, Any]]:
                         "product": prod,
                     }
                 )
-    except Exception:  # noqa: BLE001
+    except Exception:
         _LOGGER.exception("Error scanning for Easywave USB devices")
     return devices
 
@@ -129,9 +134,7 @@ async def async_step_detect(
     # USB auto-discovery (triggered by manifest `usb` matcher)
     # ------------------------------------------------------------------
 
-    async def async_step_usb(
-        self, discovery_info: usb.UsbServiceInfo
-    ) -> ConfigFlowResult:
+    async def async_step_usb(self, discovery_info: UsbServiceInfo) -> ConfigFlowResult:
         """Handle USB discovery."""
         vid = int(discovery_info.vid, 16)
         pid = int(discovery_info.pid, 16)
@@ -148,7 +151,7 @@ async def async_step_usb(
         device_entry = USB_DEVICE_NAMES.get((vid, pid))
         mfr = device_entry["manufacturer"] if device_entry else "ELDAT EaS GmbH"
         prod = device_entry["product"] if device_entry else "Unknown Easywave Device"
-        
+
         self._device = {
             "device": discovery_info.device,
             "vid": vid,

homeassistant/components/easywave/config_flow.py

@@ -1,6 +1,8 @@
 """Constants for the Easywave integration."""
+
 from __future__ import annotations
 
+from datetime import timedelta
 from typing import Final
 
 DOMAIN: Final = "easywave"
@@ -21,6 +23,10 @@
 
 SUPPORTED_USB_IDS: Final = frozenset(USB_DEVICE_NAMES.keys())
 
+# ── Coordinator Update Interval ──────────────────────────────────────────────
+# Periodic polling interval for USB device reconnection attempts
+DEVICE_SCAN_INTERVAL: Final = timedelta(seconds=30)
+
 
 # ── Config Entry Keys ────────────────────────────────────────────────────────
 CONF_DEVICE_PATH: Final = "device_path"
@@ -35,16 +41,46 @@
 FREQUENCY_868MHZ: Final = "868 MHz"
 
 FREQUENCY_ALLOWED_COUNTRIES: Final = {
-    FREQUENCY_868MHZ: frozenset({
-        # EU Member States (CEPT)
-        "AT", "BE", "BG", "HR", "CY", "CZ", "DK", "EE", "FI", "FR", "DE",
-        "GR", "HU", "IE", "IT", "LV", "LT", "LU", "MT", "NL", "PL", "PT",
-        "RO", "SK", "SI", "ES", "SE",
-        # CEPT Members (non-EU)
-        "CH", "NO", "IS", "LI",
-        # UK (post-Brexit)
-        "GB", "UK",
-    }),
+    FREQUENCY_868MHZ: frozenset(
+        {
+            # EU Member States (CEPT)
+            "AT",
+            "BE",
+            "BG",
+            "HR",
+            "CY",
+            "CZ",
+            "DK",
+            "EE",
+            "FI",
+            "FR",
+            "DE",
+            "GR",
+            "HU",
+            "IE",
+            "IT",
+            "LV",
+            "LT",
+            "LU",
+            "MT",
+            "NL",
+            "PL",
+            "PT",
+            "RO",
+            "SK",
+            "SI",
+            "ES",
+            "SE",
+            # CEPT Members (non-EU)
+            "CH",
+            "NO",
+            "IS",
+            "LI",
+            # UK (post-Brexit)
+            "GB",
+            "UK",
+        }
+    ),
 }
 
 # Legacy constant for backward compatibility
@@ -64,12 +100,12 @@ def is_country_allowed_for_frequency(frequency: str, country_code: str | None) -
     # No country configured — cannot enforce
     if country_code is None:
         return True
-    
+
     allowed = FREQUENCY_ALLOWED_COUNTRIES.get(frequency)
     if allowed is None:
         # Unknown frequency — conservative: allow
         return True
-    
+
     return country_code.upper() in allowed