Added Alexa Music

custom_components/alexa_media/runtime_data.py

@@ -0,0 +1,184 @@
+"""Runtime data for Alexa Media Player integration.
+
+This module implements the Platinum architecture using entry.runtime_data
+instead of the legacy hass.data[DOMAIN] pattern.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass, field
+import logging
+from typing import TYPE_CHECKING, Any, Callable
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
+
+from .const import (
+    DEFAULT_EXTENDED_ENTITY_DISCOVERY,
+    DEFAULT_PUBLIC_URL,
+    DEFAULT_QUEUE_DELAY,
+)
+
+if TYPE_CHECKING:
+    from alexapy import AlexaLogin, HTTP2EchoClient
+
+    from .coordinator import AlexaMediaCoordinator
+
+_LOGGER = logging.getLogger(__name__)
+
+
+@dataclass
+class AlexaRuntimeData:
+    """Runtime data for Alexa Media Player.
+
+    This replaces the legacy dict-based storage in hass.data[DATA_ALEXAMEDIA]["accounts"][email].
+    All fields are type-safe and properly initialized.
+    """
+
+    # Core components (optional to support partial initialisation)
+    login_obj: AlexaLogin | None = None
+    config_entry: ConfigEntry | None = None
+    coordinator: AlexaMediaCoordinator | None = None
+
+    # HTTP2 Push connection
+    http2: HTTP2EchoClient | None = None
+    http2_error: int = 0
+    http2_lastattempt: float = 0.0
+    http2_commands: dict[str, float] = field(default_factory=dict)
+    http2_activity: dict[str, Any] = field(
+        default_factory=lambda: {"serials": {}, "refreshed": {}}
+    )
+
+    # Device storage
+    devices: dict[str, Any] = field(
+        default_factory=lambda: {
+            "media_player": {},
+            "switch": {},
+            "guard": [],
+            "light": [],
+            "binary_sensor": [],
+            "temperature": [],
+            "smart_switch": [],
+        }
+    )
+    entities: dict[str, Any] = field(
+        default_factory=lambda: {
+            "media_player": {},
+            "switch": {},
+            "sensor": {},
+            "light": [],
+            "binary_sensor": [],
+            "alarm_control_panel": {},
+            "smart_switch": [],
+        }
+    )
+    excluded: dict[str, Any] = field(default_factory=dict)
+
+    # State tracking
+    new_devices: bool = True
+    auth_info: dict[str, Any] | None = None
+    should_get_network: bool = True
+    second_account_index: int = 0
+
+    # Notifications
+    notifications: dict[str, Any] = field(default_factory=dict)
+    notifications_pending: set[str] = field(default_factory=set)
+    notifications_refresh_task: asyncio.Task | None = None
+    notifications_retry_count: int = 0
+    last_notif_poll: float = 0.0
+
+    # Last called tracking
+    last_called: dict[str, Any] | None = None
+    last_called_customer_history_ts: int = 0
+    last_called_probe_task: asyncio.Task | None = None
+    last_called_probe_lock: asyncio.Lock = field(default_factory=asyncio.Lock)
+    last_called_probe_last_run: float = 0.0
+    last_push_activity: float = 0.0
+
+    # Options (mirrored from config_entry)
+    options: dict[str, Any] = field(default_factory=dict)
+
+    # Listeners for cleanup
+    listeners: list[Callable] = field(default_factory=list)
+
+    def __post_init__(self):
+        """Initialize computed fields after dataclass creation."""
+        # Initialize options from config_entry if available
+        if self.config_entry:
+            from .const import (
+                CONF_DEBUG,
+                CONF_EXCLUDE_DEVICES,
+                CONF_EXTENDED_ENTITY_DISCOVERY,
+                CONF_INCLUDE_DEVICES,
+                CONF_PUBLIC_URL,
+                CONF_QUEUE_DELAY,
+                CONF_SCAN_INTERVAL,
+                DEFAULT_SCAN_INTERVAL,
+            )
+
+            self.options = {
+                CONF_INCLUDE_DEVICES: self.config_entry.data.get(
+                    CONF_INCLUDE_DEVICES, ""
+                ),
+                CONF_EXCLUDE_DEVICES: self.config_entry.data.get(
+                    CONF_EXCLUDE_DEVICES, ""
+                ),
+                CONF_QUEUE_DELAY: self.config_entry.data.get(
+                    CONF_QUEUE_DELAY, DEFAULT_QUEUE_DELAY
+                ),
+                CONF_SCAN_INTERVAL: self.config_entry.data.get(
+                    CONF_SCAN_INTERVAL, DEFAULT_SCAN_INTERVAL
+                ),
+                CONF_PUBLIC_URL: self.config_entry.data.get(
+                    CONF_PUBLIC_URL, DEFAULT_PUBLIC_URL
+                ),
+                CONF_EXTENDED_ENTITY_DISCOVERY: self.config_entry.data.get(
+                    CONF_EXTENDED_ENTITY_DISCOVERY, DEFAULT_EXTENDED_ENTITY_DISCOVERY
+                ),
+                CONF_DEBUG: self.config_entry.data.get(CONF_DEBUG, False),
+            }
+
+    @property
+    def email(self) -> str:
+        """Return account email."""
+        return self.login_obj.email if self.login_obj else ""
+
+    @property
+    def url(self) -> str:
+        """Return account URL."""
+        return self.login_obj.url if self.login_obj else ""
+
+    def get_device(self, device_type: str, serial: str) -> Any | None:
+        """Get a device by type and serial."""
+        devices = self.devices.get(device_type, {})
+        if isinstance(devices, dict):
+            return devices.get(serial)
+        if isinstance(devices, list):
+            for device in devices:
+                if isinstance(device, dict) and device.get("serialNumber") == serial:
+                    return device
+                if (
+                    device
+                    and hasattr(device, "serialNumber")
+                    and device.serialNumber == serial
+                ):
+                    return device
+        return None
+
+    def get_entity(self, entity_type: str, key: str) -> Any | None:
+        """Get an entity by type and key."""
+        entities = self.entities.get(entity_type, {})
+        if isinstance(entities, dict):
+            return entities.get(key)
+        if isinstance(entities, list):
+            for entity in entities:
+                if hasattr(entity, "unique_id") and entity.unique_id == key:
+                    return entity
+                if hasattr(entity, "serial") and entity.serial == key:
+                    return entity
+        return None
+
+    def add_listener(self, unsub: Callable) -> None:
+        """Add a listener for cleanup."""
+        self.listeners.append(unsub)