alexei.dolgolyov
e66f2f3b36
- Add API_TURN_ON, API_TURN_OFF, API_TOGGLE constants - Add turn_on(), turn_off(), toggle() methods to MediaServerClient - Implement async_turn_on, async_turn_off, async_toggle in media player - Add TURN_ON and TURN_OFF to supported features - Update README with turn on/off/toggle documentation Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
476 lines
16 KiB
Python
476 lines
16 KiB
Python
"""Media player platform for Remote Media Player integration."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import asyncio
|
|
import logging
|
|
from datetime import datetime, timedelta
|
|
from typing import Any
|
|
|
|
from homeassistant.components.media_player import (
|
|
MediaPlayerEntity,
|
|
MediaPlayerEntityFeature,
|
|
MediaPlayerState,
|
|
MediaType,
|
|
)
|
|
from homeassistant.config_entries import ConfigEntry
|
|
from homeassistant.const import CONF_NAME
|
|
from homeassistant.core import HomeAssistant, callback
|
|
from homeassistant.helpers.entity import DeviceInfo
|
|
from homeassistant.helpers.entity_platform import AddEntitiesCallback
|
|
from homeassistant.helpers.update_coordinator import (
|
|
CoordinatorEntity,
|
|
DataUpdateCoordinator,
|
|
UpdateFailed,
|
|
)
|
|
|
|
from .api_client import MediaServerClient, MediaServerError, MediaServerWebSocket
|
|
from .const import (
|
|
DOMAIN,
|
|
CONF_HOST,
|
|
CONF_PORT,
|
|
CONF_TOKEN,
|
|
CONF_POLL_INTERVAL,
|
|
CONF_USE_WEBSOCKET,
|
|
DEFAULT_POLL_INTERVAL,
|
|
DEFAULT_NAME,
|
|
DEFAULT_USE_WEBSOCKET,
|
|
DEFAULT_RECONNECT_INTERVAL,
|
|
)
|
|
|
|
_LOGGER = logging.getLogger(__name__)
|
|
|
|
|
|
async def async_setup_entry(
|
|
hass: HomeAssistant,
|
|
entry: ConfigEntry,
|
|
async_add_entities: AddEntitiesCallback,
|
|
) -> None:
|
|
"""Set up the media player platform.
|
|
|
|
Args:
|
|
hass: Home Assistant instance
|
|
entry: Config entry
|
|
async_add_entities: Callback to add entities
|
|
"""
|
|
_LOGGER.debug("Setting up media player platform for %s", entry.entry_id)
|
|
|
|
try:
|
|
client: MediaServerClient = hass.data[DOMAIN][entry.entry_id]["client"]
|
|
except KeyError:
|
|
_LOGGER.error("Client not found in hass.data for entry %s", entry.entry_id)
|
|
return
|
|
|
|
# Get poll interval from options or data
|
|
poll_interval = entry.options.get(
|
|
CONF_POLL_INTERVAL,
|
|
entry.data.get(CONF_POLL_INTERVAL, DEFAULT_POLL_INTERVAL),
|
|
)
|
|
|
|
# Get WebSocket setting from options or data
|
|
use_websocket = entry.options.get(
|
|
CONF_USE_WEBSOCKET,
|
|
entry.data.get(CONF_USE_WEBSOCKET, DEFAULT_USE_WEBSOCKET),
|
|
)
|
|
|
|
# Create update coordinator with WebSocket support
|
|
coordinator = MediaPlayerCoordinator(
|
|
hass,
|
|
client,
|
|
poll_interval,
|
|
host=entry.data[CONF_HOST],
|
|
port=entry.data[CONF_PORT],
|
|
token=entry.data[CONF_TOKEN],
|
|
use_websocket=use_websocket,
|
|
)
|
|
|
|
# Set up WebSocket connection if enabled
|
|
await coordinator.async_setup()
|
|
|
|
# Fetch initial data - don't fail setup if this fails
|
|
try:
|
|
await coordinator.async_config_entry_first_refresh()
|
|
except Exception as err:
|
|
_LOGGER.warning("Initial data fetch failed, will retry: %s", err)
|
|
# Continue anyway - the coordinator will retry
|
|
|
|
# Store coordinator for cleanup
|
|
hass.data[DOMAIN][entry.entry_id]["coordinator"] = coordinator
|
|
|
|
# Create and add entity
|
|
entity = RemoteMediaPlayerEntity(
|
|
coordinator,
|
|
entry,
|
|
)
|
|
_LOGGER.info("Adding media player entity: %s", entity.unique_id)
|
|
async_add_entities([entity])
|
|
|
|
|
|
class MediaPlayerCoordinator(DataUpdateCoordinator[dict[str, Any]]):
|
|
"""Coordinator for fetching media player data with WebSocket support."""
|
|
|
|
def __init__(
|
|
self,
|
|
hass: HomeAssistant,
|
|
client: MediaServerClient,
|
|
poll_interval: int,
|
|
host: str,
|
|
port: int,
|
|
token: str,
|
|
use_websocket: bool = True,
|
|
) -> None:
|
|
"""Initialize the coordinator.
|
|
|
|
Args:
|
|
hass: Home Assistant instance
|
|
client: Media Server API client
|
|
poll_interval: Update interval in seconds
|
|
host: Server hostname
|
|
port: Server port
|
|
token: API token
|
|
use_websocket: Whether to use WebSocket for updates
|
|
"""
|
|
super().__init__(
|
|
hass,
|
|
_LOGGER,
|
|
name="Remote Media Player",
|
|
update_interval=timedelta(seconds=poll_interval),
|
|
)
|
|
self.client = client
|
|
self._host = host
|
|
self._port = port
|
|
self._token = token
|
|
self._use_websocket = use_websocket
|
|
self._ws_client: MediaServerWebSocket | None = None
|
|
self._ws_connected = False
|
|
self._reconnect_task: asyncio.Task | None = None
|
|
self._poll_interval = poll_interval
|
|
|
|
async def async_setup(self) -> None:
|
|
"""Set up the coordinator with WebSocket if enabled."""
|
|
if self._use_websocket:
|
|
await self._connect_websocket()
|
|
|
|
async def _connect_websocket(self) -> None:
|
|
"""Establish WebSocket connection."""
|
|
if self._ws_client:
|
|
await self._ws_client.disconnect()
|
|
|
|
self._ws_client = MediaServerWebSocket(
|
|
host=self._host,
|
|
port=self._port,
|
|
token=self._token,
|
|
on_status_update=self._handle_ws_status_update,
|
|
on_disconnect=self._handle_ws_disconnect,
|
|
)
|
|
|
|
if await self._ws_client.connect():
|
|
self._ws_connected = True
|
|
# Disable polling - WebSocket handles all updates including position
|
|
self.update_interval = None
|
|
_LOGGER.info("WebSocket connected, polling disabled")
|
|
else:
|
|
self._ws_connected = False
|
|
# Keep polling as fallback
|
|
self.update_interval = timedelta(seconds=self._poll_interval)
|
|
_LOGGER.warning("WebSocket failed, falling back to polling")
|
|
# Schedule reconnect attempt
|
|
self._schedule_reconnect()
|
|
|
|
@callback
|
|
def _handle_ws_status_update(self, status_data: dict[str, Any]) -> None:
|
|
"""Handle status update from WebSocket."""
|
|
self.async_set_updated_data(status_data)
|
|
|
|
@callback
|
|
def _handle_ws_disconnect(self) -> None:
|
|
"""Handle WebSocket disconnection."""
|
|
self._ws_connected = False
|
|
# Re-enable polling as fallback
|
|
self.update_interval = timedelta(seconds=self._poll_interval)
|
|
_LOGGER.warning("WebSocket disconnected, falling back to polling")
|
|
# Schedule reconnect attempt
|
|
self._schedule_reconnect()
|
|
|
|
def _schedule_reconnect(self) -> None:
|
|
"""Schedule a WebSocket reconnection attempt."""
|
|
if self._reconnect_task and not self._reconnect_task.done():
|
|
return # Already scheduled
|
|
|
|
async def reconnect() -> None:
|
|
await asyncio.sleep(DEFAULT_RECONNECT_INTERVAL)
|
|
if self._use_websocket and not self._ws_connected:
|
|
_LOGGER.info("Attempting WebSocket reconnect...")
|
|
await self._connect_websocket()
|
|
|
|
self._reconnect_task = self.hass.async_create_task(reconnect())
|
|
|
|
async def _async_update_data(self) -> dict[str, Any]:
|
|
"""Fetch data from the API (fallback when WebSocket unavailable).
|
|
|
|
Returns:
|
|
Media status data
|
|
|
|
Raises:
|
|
UpdateFailed: On API errors
|
|
"""
|
|
try:
|
|
data = await self.client.get_status()
|
|
_LOGGER.debug("HTTP poll received status: %s", data.get("state"))
|
|
return data
|
|
except MediaServerError as err:
|
|
raise UpdateFailed(f"Error communicating with server: {err}") from err
|
|
except Exception as err:
|
|
_LOGGER.exception("Unexpected error fetching media status")
|
|
raise UpdateFailed(f"Unexpected error: {err}") from err
|
|
|
|
async def async_shutdown(self) -> None:
|
|
"""Clean up resources."""
|
|
if self._reconnect_task:
|
|
self._reconnect_task.cancel()
|
|
try:
|
|
await self._reconnect_task
|
|
except asyncio.CancelledError:
|
|
pass
|
|
if self._ws_client:
|
|
await self._ws_client.disconnect()
|
|
|
|
|
|
class RemoteMediaPlayerEntity(CoordinatorEntity[MediaPlayerCoordinator], MediaPlayerEntity):
|
|
"""Representation of a Remote Media Player."""
|
|
|
|
_attr_has_entity_name = True
|
|
_attr_name = None
|
|
|
|
@property
|
|
def available(self) -> bool:
|
|
"""Return True if entity is available."""
|
|
# Use the coordinator's last_update_success to detect server availability
|
|
return self.coordinator.last_update_success
|
|
|
|
def __init__(
|
|
self,
|
|
coordinator: MediaPlayerCoordinator,
|
|
entry: ConfigEntry,
|
|
) -> None:
|
|
"""Initialize the media player entity.
|
|
|
|
Args:
|
|
coordinator: Data update coordinator
|
|
entry: Config entry
|
|
"""
|
|
super().__init__(coordinator)
|
|
self._entry = entry
|
|
self._attr_unique_id = f"{entry.entry_id}_media_player"
|
|
|
|
# Device info - must match button.py identifiers
|
|
self._attr_device_info = DeviceInfo(
|
|
identifiers={(DOMAIN, entry.entry_id)},
|
|
name=entry.title,
|
|
manufacturer="Remote Media Player",
|
|
model="Media Server",
|
|
sw_version="1.0.0",
|
|
configuration_url=f"http://{entry.data[CONF_HOST]}:{int(entry.data[CONF_PORT])}/docs",
|
|
)
|
|
|
|
@property
|
|
def supported_features(self) -> MediaPlayerEntityFeature:
|
|
"""Return the supported features."""
|
|
return (
|
|
MediaPlayerEntityFeature.PAUSE
|
|
| MediaPlayerEntityFeature.PLAY
|
|
| MediaPlayerEntityFeature.STOP
|
|
| MediaPlayerEntityFeature.VOLUME_SET
|
|
| MediaPlayerEntityFeature.VOLUME_MUTE
|
|
| MediaPlayerEntityFeature.PREVIOUS_TRACK
|
|
| MediaPlayerEntityFeature.NEXT_TRACK
|
|
| MediaPlayerEntityFeature.SEEK
|
|
| MediaPlayerEntityFeature.TURN_ON
|
|
| MediaPlayerEntityFeature.TURN_OFF
|
|
)
|
|
|
|
@property
|
|
def state(self) -> MediaPlayerState | None:
|
|
"""Return the state of the player."""
|
|
if self.coordinator.data is None:
|
|
return MediaPlayerState.OFF
|
|
|
|
state = self.coordinator.data.get("state", "idle")
|
|
state_map = {
|
|
"playing": MediaPlayerState.PLAYING,
|
|
"paused": MediaPlayerState.PAUSED,
|
|
"stopped": MediaPlayerState.IDLE,
|
|
"idle": MediaPlayerState.IDLE,
|
|
}
|
|
return state_map.get(state, MediaPlayerState.IDLE)
|
|
|
|
@property
|
|
def volume_level(self) -> float | None:
|
|
"""Return the volume level (0..1)."""
|
|
if self.coordinator.data is None:
|
|
return None
|
|
volume = self.coordinator.data.get("volume", 0)
|
|
return volume / 100.0
|
|
|
|
@property
|
|
def is_volume_muted(self) -> bool | None:
|
|
"""Return True if volume is muted."""
|
|
if self.coordinator.data is None:
|
|
return None
|
|
return self.coordinator.data.get("muted", False)
|
|
|
|
@property
|
|
def media_content_type(self) -> MediaType | None:
|
|
"""Return the content type of current playing media."""
|
|
return MediaType.MUSIC
|
|
|
|
@property
|
|
def media_title(self) -> str | None:
|
|
"""Return the title of current playing media."""
|
|
if self.coordinator.data is None:
|
|
return None
|
|
return self.coordinator.data.get("title")
|
|
|
|
@property
|
|
def media_artist(self) -> str | None:
|
|
"""Return the artist of current playing media."""
|
|
if self.coordinator.data is None:
|
|
return None
|
|
return self.coordinator.data.get("artist")
|
|
|
|
@property
|
|
def media_album_name(self) -> str | None:
|
|
"""Return the album name of current playing media."""
|
|
if self.coordinator.data is None:
|
|
return None
|
|
return self.coordinator.data.get("album")
|
|
|
|
@property
|
|
def media_image_url(self) -> str | None:
|
|
"""Return the image URL of current playing media."""
|
|
if self.coordinator.data is None:
|
|
return None
|
|
return self.coordinator.data.get("album_art_url")
|
|
|
|
@property
|
|
def media_duration(self) -> int | None:
|
|
"""Return the duration of current playing media in seconds."""
|
|
if self.coordinator.data is None:
|
|
return None
|
|
duration = self.coordinator.data.get("duration")
|
|
return int(duration) if duration is not None else None
|
|
|
|
@property
|
|
def media_position(self) -> int | None:
|
|
"""Return the position of current playing media in seconds."""
|
|
if self.coordinator.data is None:
|
|
return None
|
|
position = self.coordinator.data.get("position")
|
|
return int(position) if position is not None else None
|
|
|
|
@property
|
|
def media_position_updated_at(self) -> datetime | None:
|
|
"""Return when the position was last updated."""
|
|
if self.coordinator.data is None:
|
|
return None
|
|
if self.coordinator.data.get("position") is not None:
|
|
# Use last_update_success_time if available, otherwise use current time
|
|
if hasattr(self.coordinator, 'last_update_success_time'):
|
|
return self.coordinator.last_update_success_time
|
|
return datetime.now()
|
|
return None
|
|
|
|
@property
|
|
def source(self) -> str | None:
|
|
"""Return the current media source."""
|
|
if self.coordinator.data is None:
|
|
return None
|
|
return self.coordinator.data.get("source")
|
|
|
|
async def async_media_play(self) -> None:
|
|
"""Send play command."""
|
|
try:
|
|
await self.coordinator.client.play()
|
|
await self.coordinator.async_request_refresh()
|
|
except MediaServerError as err:
|
|
_LOGGER.error("Failed to play: %s", err)
|
|
|
|
async def async_media_pause(self) -> None:
|
|
"""Send pause command."""
|
|
try:
|
|
await self.coordinator.client.pause()
|
|
await self.coordinator.async_request_refresh()
|
|
except MediaServerError as err:
|
|
_LOGGER.error("Failed to pause: %s", err)
|
|
|
|
async def async_media_stop(self) -> None:
|
|
"""Send stop command."""
|
|
try:
|
|
await self.coordinator.client.stop()
|
|
await self.coordinator.async_request_refresh()
|
|
except MediaServerError as err:
|
|
_LOGGER.error("Failed to stop: %s", err)
|
|
|
|
async def async_media_next_track(self) -> None:
|
|
"""Send next track command."""
|
|
try:
|
|
await self.coordinator.client.next_track()
|
|
await self.coordinator.async_request_refresh()
|
|
except MediaServerError as err:
|
|
_LOGGER.error("Failed to skip to next track: %s", err)
|
|
|
|
async def async_media_previous_track(self) -> None:
|
|
"""Send previous track command."""
|
|
try:
|
|
await self.coordinator.client.previous_track()
|
|
await self.coordinator.async_request_refresh()
|
|
except MediaServerError as err:
|
|
_LOGGER.error("Failed to go to previous track: %s", err)
|
|
|
|
async def async_set_volume_level(self, volume: float) -> None:
|
|
"""Set volume level, range 0..1."""
|
|
try:
|
|
await self.coordinator.client.set_volume(int(volume * 100))
|
|
await self.coordinator.async_request_refresh()
|
|
except MediaServerError as err:
|
|
_LOGGER.error("Failed to set volume: %s", err)
|
|
|
|
async def async_mute_volume(self, mute: bool) -> None:
|
|
"""Mute/unmute the volume."""
|
|
try:
|
|
# Toggle mute (API toggles, so call it if state differs)
|
|
if self.is_volume_muted != mute:
|
|
await self.coordinator.client.toggle_mute()
|
|
await self.coordinator.async_request_refresh()
|
|
except MediaServerError as err:
|
|
_LOGGER.error("Failed to toggle mute: %s", err)
|
|
|
|
async def async_media_seek(self, position: float) -> None:
|
|
"""Seek to a position."""
|
|
try:
|
|
await self.coordinator.client.seek(position)
|
|
await self.coordinator.async_request_refresh()
|
|
except MediaServerError as err:
|
|
_LOGGER.error("Failed to seek: %s", err)
|
|
|
|
async def async_turn_on(self) -> None:
|
|
"""Send turn on command."""
|
|
try:
|
|
await self.coordinator.client.turn_on()
|
|
except MediaServerError as err:
|
|
_LOGGER.error("Failed to turn on: %s", err)
|
|
|
|
async def async_turn_off(self) -> None:
|
|
"""Send turn off command."""
|
|
try:
|
|
await self.coordinator.client.turn_off()
|
|
except MediaServerError as err:
|
|
_LOGGER.error("Failed to turn off: %s", err)
|
|
|
|
async def async_toggle(self) -> None:
|
|
"""Send toggle command."""
|
|
try:
|
|
await self.coordinator.client.toggle()
|
|
except MediaServerError as err:
|
|
_LOGGER.error("Failed to toggle: %s", err)
|