jeans/core
jeans/core
1
0
Fork 0
mirror of https://github.com/home-assistant/core.git synced 2025-07-19 11:17:21 +00:00
Code Issues Packages Projects Releases Wiki Activity

Use new media player enums [u-w] (#78067)

Browse Source
This commit is contained in:
epenet 2022-09-08 23:22:16 +02:00 committed by GitHub
parent 6b157921ea
commit 8bdeb3ca5b
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
8 changed files with 95 additions and 115 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
homeassistant/components/ue_smart_radio/media_player.py
View File

@ -10,16 +10,10 @@ from homeassistant.components.media_player import (
PLATFORM_SCHEMA, PLATFORM_SCHEMA,
MediaPlayerEntity, MediaPlayerEntity,
MediaPlayerEntityFeature, MediaPlayerEntityFeature,
MediaPlayerState,
MediaType,
) )
from homeassistant.components.media_player.const import MEDIA_TYPE_MUSIC from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
from homeassistant.const import (
CONF_PASSWORD,
CONF_USERNAME,
STATE_IDLE,
STATE_OFF,
STATE_PAUSED,
STATE_PLAYING,
)
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
import homeassistant.helpers.config_validation as cv import homeassistant.helpers.config_validation as cv
from homeassistant.helpers.entity_platform import AddEntitiesCallback from homeassistant.helpers.entity_platform import AddEntitiesCallback
@ -30,7 +24,11 @@ _LOGGER = logging.getLogger(__name__)
ICON = "mdi:radio" ICON = "mdi:radio"
URL = "http://decibel.logitechmusic.com/jsonrpc.js" URL = "http://decibel.logitechmusic.com/jsonrpc.js"
PLAYBACK_DICT = {"play": STATE_PLAYING, "pause": STATE_PAUSED, "stop": STATE_IDLE} PLAYBACK_DICT = {
"play": MediaPlayerState.PLAYING,
"pause": MediaPlayerState.PAUSED,
"stop": MediaPlayerState.IDLE,
}
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend( PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
{vol.Required(CONF_USERNAME): cv.string, vol.Required(CONF_PASSWORD): cv.string} {vol.Required(CONF_USERNAME): cv.string, vol.Required(CONF_PASSWORD): cv.string}
@ -84,6 +82,7 @@ def setup_platform(
class UERadioDevice(MediaPlayerEntity): class UERadioDevice(MediaPlayerEntity):
"""Representation of a Logitech UE Smart Radio device.""" """Representation of a Logitech UE Smart Radio device."""
_attr_media_content_type = MediaType.MUSIC
_attr_supported_features = ( _attr_supported_features = (
MediaPlayerEntityFeature.PLAY MediaPlayerEntityFeature.PLAY
| MediaPlayerEntityFeature.PAUSE | MediaPlayerEntityFeature.PAUSE
@ -133,7 +132,7 @@ class UERadioDevice(MediaPlayerEntity):
return return
if request["result"]["power"] == 0: if request["result"]["power"] == 0:
self._state = STATE_OFF self._state = MediaPlayerState.OFF
else: else:
self._state = PLAYBACK_DICT[request["result"]["mode"]] self._state = PLAYBACK_DICT[request["result"]["mode"]]
@ -172,11 +171,6 @@ class UERadioDevice(MediaPlayerEntity):
"""Volume level of the media player (0..1).""" """Volume level of the media player (0..1)."""
return self._volume return self._volume
@property
def media_content_type(self):
"""Return the media content type."""
return MEDIA_TYPE_MUSIC
@property @property
def media_image_url(self): def media_image_url(self):
"""Image URL of current playing media.""" """Image URL of current playing media."""

22
homeassistant/components/unifiprotect/media_player.py
View File

@ -20,13 +20,11 @@ from homeassistant.components.media_player import (
MediaPlayerEntity, MediaPlayerEntity,
MediaPlayerEntityDescription, MediaPlayerEntityDescription,
MediaPlayerEntityFeature, MediaPlayerEntityFeature,
) MediaPlayerState,
from homeassistant.components.media_player.browse_media import ( MediaType,
async_process_play_media_url, async_process_play_media_url,
) )
from homeassistant.components.media_player.const import MEDIA_TYPE_MUSIC
from homeassistant.config_entries import ConfigEntry from homeassistant.config_entries import ConfigEntry
from homeassistant.const import STATE_IDLE, STATE_PLAYING
from homeassistant.core import HomeAssistant, callback from homeassistant.core import HomeAssistant, callback
from homeassistant.exceptions import HomeAssistantError from homeassistant.exceptions import HomeAssistantError
from homeassistant.helpers.dispatcher import async_dispatcher_connect from homeassistant.helpers.dispatcher import async_dispatcher_connect
@ -95,7 +93,7 @@ class ProtectMediaPlayer(ProtectDeviceEntity, MediaPlayerEntity):
) )
self._attr_name = f"{self.device.display_name} Speaker" self._attr_name = f"{self.device.display_name} Speaker"
self._attr_media_content_type = MEDIA_TYPE_MUSIC self._attr_media_content_type = MediaType.MUSIC
@callback @callback
def _async_update_device_from_protect(self, device: ProtectModelWithId) -> None: def _async_update_device_from_protect(self, device: ProtectModelWithId) -> None:
@ -106,9 +104,9 @@ class ProtectMediaPlayer(ProtectDeviceEntity, MediaPlayerEntity):
self.device.talkback_stream is not None self.device.talkback_stream is not None
and self.device.talkback_stream.is_running and self.device.talkback_stream.is_running
): ):
self._attr_state = STATE_PLAYING self._attr_state = MediaPlayerState.PLAYING
else: else:
self._attr_state = STATE_IDLE self._attr_state = MediaPlayerState.IDLE
is_connected = self.data.last_update_success and ( is_connected = self.data.last_update_success and (
self.device.state == StateType.CONNECTED self.device.state == StateType.CONNECTED
@ -134,17 +132,17 @@ class ProtectMediaPlayer(ProtectDeviceEntity, MediaPlayerEntity):
self._async_updated_event(self.device) self._async_updated_event(self.device)
async def async_play_media( async def async_play_media(
self, media_type: str, media_id: str, **kwargs: Any self, media_type: MediaType | str, media_id: str, **kwargs: Any
) -> None: ) -> None:
"""Play a piece of media.""" """Play a piece of media."""
if media_source.is_media_source_id(media_id): if media_source.is_media_source_id(media_id):
media_type = MEDIA_TYPE_MUSIC media_type = MediaType.MUSIC
play_item = await media_source.async_resolve_media( play_item = await media_source.async_resolve_media(
self.hass, media_id, self.entity_id self.hass, media_id, self.entity_id
) )
media_id = async_process_play_media_url(self.hass, play_item.url) media_id = async_process_play_media_url(self.hass, play_item.url)
if media_type != MEDIA_TYPE_MUSIC: if media_type != MediaType.MUSIC:
raise HomeAssistantError("Only music media type is supported") raise HomeAssistantError("Only music media type is supported")
_LOGGER.debug( _LOGGER.debug(
@ -164,7 +162,9 @@ class ProtectMediaPlayer(ProtectDeviceEntity, MediaPlayerEntity):
self._async_updated_event(self.device) self._async_updated_event(self.device)
async def async_browse_media( async def async_browse_media(
self, media_content_type: str | None = None, media_content_id: str | None = None self,
media_content_type: MediaType | str | None = None,
media_content_id: str | None = None,
) -> BrowseMedia: ) -> BrowseMedia:
"""Implement the websocket media browsing helper.""" """Implement the websocket media browsing helper."""
return await media_source.async_browse_media( return await media_source.async_browse_media(

7
homeassistant/components/vizio/media_player.py
View File

@ -12,6 +12,7 @@ from homeassistant.components.media_player import (
MediaPlayerDeviceClass, MediaPlayerDeviceClass,
MediaPlayerEntity, MediaPlayerEntity,
MediaPlayerEntityFeature, MediaPlayerEntityFeature,
MediaPlayerState,
) )
from homeassistant.config_entries import ConfigEntry from homeassistant.config_entries import ConfigEntry
from homeassistant.const import ( from homeassistant.const import (
@ -21,8 +22,6 @@ from homeassistant.const import (
CONF_HOST, CONF_HOST,
CONF_INCLUDE, CONF_INCLUDE,
CONF_NAME, CONF_NAME,
STATE_OFF,
STATE_ON,
) )
from homeassistant.core import HomeAssistant, callback from homeassistant.core import HomeAssistant, callback
from homeassistant.helpers import entity_platform from homeassistant.helpers import entity_platform
@ -207,7 +206,7 @@ class VizioDevice(MediaPlayerEntity):
) )
if not is_on: if not is_on:
self._attr_state = STATE_OFF self._attr_state = MediaPlayerState.OFF
self._attr_volume_level = None self._attr_volume_level = None
self._attr_is_volume_muted = None self._attr_is_volume_muted = None
self._current_input = None self._current_input = None
@ -216,7 +215,7 @@ class VizioDevice(MediaPlayerEntity):
self._attr_sound_mode = None self._attr_sound_mode = None
return return
self._attr_state = STATE_ON self._attr_state = MediaPlayerState.ON
if audio_settings := await self._device.get_all_settings( if audio_settings := await self._device.get_all_settings(
VIZIO_AUDIO_SETTINGS, log_api_exception=False VIZIO_AUDIO_SETTINGS, log_api_exception=False

37
homeassistant/components/vlc/media_player.py
View File

@ -13,12 +13,11 @@ from homeassistant.components.media_player import (
BrowseMedia, BrowseMedia,
MediaPlayerEntity, MediaPlayerEntity,
MediaPlayerEntityFeature, MediaPlayerEntityFeature,
) MediaPlayerState,
from homeassistant.components.media_player.browse_media import ( MediaType,
async_process_play_media_url, async_process_play_media_url,
) )
from homeassistant.components.media_player.const import MEDIA_TYPE_MUSIC from homeassistant.const import CONF_NAME
from homeassistant.const import CONF_NAME, STATE_IDLE, STATE_PAUSED, STATE_PLAYING
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
import homeassistant.helpers.config_validation as cv import homeassistant.helpers.config_validation as cv
from homeassistant.helpers.entity_platform import AddEntitiesCallback from homeassistant.helpers.entity_platform import AddEntitiesCallback
@ -53,6 +52,7 @@ def setup_platform(
class VlcDevice(MediaPlayerEntity): class VlcDevice(MediaPlayerEntity):
"""Representation of a vlc player.""" """Representation of a vlc player."""
_attr_media_content_type = MediaType.MUSIC
_attr_supported_features = ( _attr_supported_features = (
MediaPlayerEntityFeature.PAUSE MediaPlayerEntityFeature.PAUSE
| MediaPlayerEntityFeature.VOLUME_SET | MediaPlayerEntityFeature.VOLUME_SET
@ -79,11 +79,11 @@ class VlcDevice(MediaPlayerEntity):
"""Get the latest details from the device.""" """Get the latest details from the device."""
status = self._vlc.get_state() status = self._vlc.get_state()
if status == vlc.State.Playing: if status == vlc.State.Playing:
self._state = STATE_PLAYING self._state = MediaPlayerState.PLAYING
elif status == vlc.State.Paused: elif status == vlc.State.Paused:
self._state = STATE_PAUSED self._state = MediaPlayerState.PAUSED
else: else:
self._state = STATE_IDLE self._state = MediaPlayerState.IDLE
self._media_duration = self._vlc.get_length() / 1000 self._media_duration = self._vlc.get_length() / 1000
position = self._vlc.get_position() * self._media_duration position = self._vlc.get_position() * self._media_duration
if position != self._media_position: if position != self._media_position:
@ -115,11 +115,6 @@ class VlcDevice(MediaPlayerEntity):
"""Boolean if volume is currently muted.""" """Boolean if volume is currently muted."""
return self._muted return self._muted
@property
def media_content_type(self):
"""Content type of current playing media."""
return MEDIA_TYPE_MUSIC
@property @property
def media_duration(self): def media_duration(self):
"""Duration of current playing media in seconds.""" """Duration of current playing media in seconds."""
@ -153,20 +148,20 @@ class VlcDevice(MediaPlayerEntity):
def media_play(self) -> None: def media_play(self) -> None:
"""Send play command.""" """Send play command."""
self._vlc.play() self._vlc.play()
self._state = STATE_PLAYING self._state = MediaPlayerState.PLAYING
def media_pause(self) -> None: def media_pause(self) -> None:
"""Send pause command.""" """Send pause command."""
self._vlc.pause() self._vlc.pause()
self._state = STATE_PAUSED self._state = MediaPlayerState.PAUSED
def media_stop(self) -> None: def media_stop(self) -> None:
"""Send stop command.""" """Send stop command."""
self._vlc.stop() self._vlc.stop()
self._state = STATE_IDLE self._state = MediaPlayerState.IDLE
async def async_play_media( async def async_play_media(
self, media_type: str, media_id: str, **kwargs: Any self, media_type: MediaType | str, media_id: str, **kwargs: Any
) -> None: ) -> None:
"""Play media from a URL or file.""" """Play media from a URL or file."""
# Handle media_source # Handle media_source
@ -176,11 +171,11 @@ class VlcDevice(MediaPlayerEntity):
) )
media_id = sourced_media.url media_id = sourced_media.url
elif media_type != MEDIA_TYPE_MUSIC: elif media_type != MediaType.MUSIC:
_LOGGER.error( _LOGGER.error(
"Invalid media type %s. Only %s is supported", "Invalid media type %s. Only %s is supported",
media_type, media_type,
MEDIA_TYPE_MUSIC, MediaType.MUSIC,
) )
return return
@ -191,10 +186,12 @@ class VlcDevice(MediaPlayerEntity):
self._vlc.play() self._vlc.play()
await self.hass.async_add_executor_job(play) await self.hass.async_add_executor_job(play)
self._state = STATE_PLAYING self._state = MediaPlayerState.PLAYING
async def async_browse_media( async def async_browse_media(
self, media_content_type: str | None = None, media_content_id: str | None = None self,
media_content_type: MediaType | str | None = None,
media_content_id: str | None = None,
) -> BrowseMedia: ) -> BrowseMedia:
"""Implement the websocket media browsing helper.""" """Implement the websocket media browsing helper."""
return await media_source.async_browse_media( return await media_source.async_browse_media(

39
homeassistant/components/vlc_telnet/media_player.py
View File

@ -15,11 +15,12 @@ from homeassistant.components.media_player import (
BrowseMedia, BrowseMedia,
MediaPlayerEntity, MediaPlayerEntity,
MediaPlayerEntityFeature, MediaPlayerEntityFeature,
MediaPlayerState,
MediaType,
async_process_play_media_url, async_process_play_media_url,
) )
from homeassistant.components.media_player.const import MEDIA_TYPE_MUSIC
from homeassistant.config_entries import SOURCE_HASSIO, ConfigEntry from homeassistant.config_entries import SOURCE_HASSIO, ConfigEntry
from homeassistant.const import CONF_NAME, STATE_IDLE, STATE_PAUSED, STATE_PLAYING from homeassistant.const import CONF_NAME
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from homeassistant.exceptions import HomeAssistantError from homeassistant.exceptions import HomeAssistantError
from homeassistant.helpers.device_registry import DeviceEntryType from homeassistant.helpers.device_registry import DeviceEntryType
@ -71,6 +72,7 @@ def catch_vlc_errors(
class VlcDevice(MediaPlayerEntity): class VlcDevice(MediaPlayerEntity):
"""Representation of a vlc player.""" """Representation of a vlc player."""
_attr_media_content_type = MediaType.MUSIC
_attr_supported_features = ( _attr_supported_features = (
MediaPlayerEntityFeature.CLEAR_PLAYLIST MediaPlayerEntityFeature.CLEAR_PLAYLIST
| MediaPlayerEntityFeature.NEXT_TRACK | MediaPlayerEntityFeature.NEXT_TRACK
@ -132,7 +134,7 @@ class VlcDevice(MediaPlayerEntity):
) )
return return
self._state = STATE_IDLE self._state = MediaPlayerState.IDLE
self._available = True self._available = True
LOGGER.info("Connected to vlc host: %s", self._vlc.host) LOGGER.info("Connected to vlc host: %s", self._vlc.host)
@ -142,13 +144,13 @@ class VlcDevice(MediaPlayerEntity):
self._volume = status.audio_volume / MAX_VOLUME self._volume = status.audio_volume / MAX_VOLUME
state = status.state state = status.state
if state == "playing": if state == "playing":
self._state = STATE_PLAYING self._state = MediaPlayerState.PLAYING
elif state == "paused": elif state == "paused":
self._state = STATE_PAUSED self._state = MediaPlayerState.PAUSED
else: else:
self._state = STATE_IDLE self._state = MediaPlayerState.IDLE
if self._state != STATE_IDLE: if self._state != MediaPlayerState.IDLE:
self._media_duration = (await self._vlc.get_length()).length self._media_duration = (await self._vlc.get_length()).length
time_output = await self._vlc.get_time() time_output = await self._vlc.get_time()
vlc_position = time_output.time vlc_position = time_output.time
@ -209,11 +211,6 @@ class VlcDevice(MediaPlayerEntity):
"""Boolean if volume is currently muted.""" """Boolean if volume is currently muted."""
return self._muted return self._muted
@property
def media_content_type(self) -> str:
"""Content type of current playing media."""
return MEDIA_TYPE_MUSIC
@property @property
def media_duration(self) -> int | None: def media_duration(self) -> int | None:
"""Duration of current playing media in seconds.""" """Duration of current playing media in seconds."""
@ -270,7 +267,7 @@ class VlcDevice(MediaPlayerEntity):
async def async_media_play(self) -> None: async def async_media_play(self) -> None:
"""Send play command.""" """Send play command."""
await self._vlc.play() await self._vlc.play()
self._state = STATE_PLAYING self._state = MediaPlayerState.PLAYING
@catch_vlc_errors @catch_vlc_errors
async def async_media_pause(self) -> None: async def async_media_pause(self) -> None:
@ -281,17 +278,17 @@ class VlcDevice(MediaPlayerEntity):
# pause. # pause.
await self._vlc.pause() await self._vlc.pause()
self._state = STATE_PAUSED self._state = MediaPlayerState.PAUSED
@catch_vlc_errors @catch_vlc_errors
async def async_media_stop(self) -> None: async def async_media_stop(self) -> None:
"""Send stop command.""" """Send stop command."""
await self._vlc.stop() await self._vlc.stop()
self._state = STATE_IDLE self._state = MediaPlayerState.IDLE
@catch_vlc_errors @catch_vlc_errors
async def async_play_media( async def async_play_media(
self, media_type: str, media_id: str, **kwargs: Any self, media_type: MediaType | str, media_id: str, **kwargs: Any
) -> None: ) -> None:
"""Play media from a URL or file.""" """Play media from a URL or file."""
# Handle media_source # Handle media_source
@ -302,9 +299,9 @@ class VlcDevice(MediaPlayerEntity):
media_type = sourced_media.mime_type media_type = sourced_media.mime_type
media_id = sourced_media.url media_id = sourced_media.url
if media_type != MEDIA_TYPE_MUSIC and not media_type.startswith("audio/"): if media_type != MediaType.MUSIC and not media_type.startswith("audio/"):
raise HomeAssistantError( raise HomeAssistantError(
f"Invalid media type {media_type}. Only {MEDIA_TYPE_MUSIC} is supported" f"Invalid media type {media_type}. Only {MediaType.MUSIC} is supported"
) )
# If media ID is a relative URL, we serve it from HA. # If media ID is a relative URL, we serve it from HA.
@ -313,7 +310,7 @@ class VlcDevice(MediaPlayerEntity):
) )
await self._vlc.add(media_id) await self._vlc.add(media_id)
self._state = STATE_PLAYING self._state = MediaPlayerState.PLAYING
@catch_vlc_errors @catch_vlc_errors
async def async_media_previous_track(self) -> None: async def async_media_previous_track(self) -> None:
@ -337,7 +334,9 @@ class VlcDevice(MediaPlayerEntity):
await self._vlc.random(shuffle_command) await self._vlc.random(shuffle_command)
async def async_browse_media( async def async_browse_media(
self, media_content_type: str | None = None, media_content_id: str | None = None self,
media_content_type: MediaType | str | None = None,
media_content_id: str | None = None,
) -> BrowseMedia: ) -> BrowseMedia:
"""Implement the websocket media browsing helper.""" """Implement the websocket media browsing helper."""
return await media_source.async_browse_media( return await media_source.async_browse_media(

50
homeassistant/components/volumio/media_player.py
View File

@ -10,23 +10,15 @@ import json
from typing import Any from typing import Any
from homeassistant.components.media_player import ( from homeassistant.components.media_player import (
BrowseMedia,
MediaPlayerEntity, MediaPlayerEntity,
MediaPlayerEntityFeature, MediaPlayerEntityFeature,
) MediaPlayerState,
from homeassistant.components.media_player.browse_media import BrowseMedia MediaType,
from homeassistant.components.media_player.const import ( RepeatMode,
MEDIA_TYPE_MUSIC,
REPEAT_MODE_ALL,
REPEAT_MODE_OFF,
) )
from homeassistant.config_entries import ConfigEntry from homeassistant.config_entries import ConfigEntry
from homeassistant.const import ( from homeassistant.const import CONF_ID, CONF_NAME
CONF_ID,
CONF_NAME,
STATE_IDLE,
STATE_PAUSED,
STATE_PLAYING,
)
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from homeassistant.helpers.entity import DeviceInfo from homeassistant.helpers.entity import DeviceInfo
from homeassistant.helpers.entity_platform import AddEntitiesCallback from homeassistant.helpers.entity_platform import AddEntitiesCallback
@ -58,6 +50,7 @@ async def async_setup_entry(
class Volumio(MediaPlayerEntity): class Volumio(MediaPlayerEntity):
"""Volumio Player Object.""" """Volumio Player Object."""
_attr_media_content_type = MediaType.MUSIC
_attr_supported_features = ( _attr_supported_features = (
MediaPlayerEntityFeature.PAUSE MediaPlayerEntityFeature.PAUSE
| MediaPlayerEntityFeature.VOLUME_SET | MediaPlayerEntityFeature.VOLUME_SET
@ -114,20 +107,15 @@ class Volumio(MediaPlayerEntity):
) )
@property @property
def media_content_type(self): def state(self) -> MediaPlayerState:
"""Content type of current playing media."""
return MEDIA_TYPE_MUSIC
@property
def state(self):
"""Return the state of the device.""" """Return the state of the device."""
status = self._state.get("status", None) status = self._state.get("status", None)
if status == "pause": if status == "pause":
return STATE_PAUSED return MediaPlayerState.PAUSED
if status == "play": if status == "play":
return STATE_PLAYING return MediaPlayerState.PLAYING
return STATE_IDLE return MediaPlayerState.IDLE
@property @property
def media_title(self): def media_title(self):
@ -179,11 +167,11 @@ class Volumio(MediaPlayerEntity):
return self._state.get("random", False) return self._state.get("random", False)
@property @property
def repeat(self): def repeat(self) -> RepeatMode:
"""Return current repeat mode.""" """Return current repeat mode."""
if self._state.get("repeat", None): if self._state.get("repeat", None):
return REPEAT_MODE_ALL return RepeatMode.ALL
return REPEAT_MODE_OFF return RepeatMode.OFF
@property @property
def source_list(self): def source_list(self):
@ -241,9 +229,9 @@ class Volumio(MediaPlayerEntity):
"""Enable/disable shuffle mode.""" """Enable/disable shuffle mode."""
await self._volumio.set_shuffle(shuffle) await self._volumio.set_shuffle(shuffle)
async def async_set_repeat(self, repeat: str) -> None: async def async_set_repeat(self, repeat: RepeatMode) -> None:
"""Set repeat mode.""" """Set repeat mode."""
if repeat == REPEAT_MODE_OFF: if repeat == RepeatMode.OFF:
await self._volumio.repeatAll("false") await self._volumio.repeatAll("false")
else: else:
await self._volumio.repeatAll("true") await self._volumio.repeatAll("true")
@ -264,13 +252,15 @@ class Volumio(MediaPlayerEntity):
self._playlists = await self._volumio.get_playlists() self._playlists = await self._volumio.get_playlists()
async def async_play_media( async def async_play_media(
self, media_type: str, media_id: str, **kwargs: Any self, media_type: MediaType | str, media_id: str, **kwargs: Any
) -> None: ) -> None:
"""Send the play_media command to the media player.""" """Send the play_media command to the media player."""
await self._volumio.replace_and_play(json.loads(media_id)) await self._volumio.replace_and_play(json.loads(media_id))
async def async_browse_media( async def async_browse_media(
self, media_content_type: str | None = None, media_content_id: str | None = None self,
media_content_type: MediaType | str | None = None,
media_content_id: str | None = None,
) -> BrowseMedia: ) -> BrowseMedia:
"""Implement the websocket media browsing helper.""" """Implement the websocket media browsing helper."""
self.thumbnail_cache = {} self.thumbnail_cache = {}
@ -283,7 +273,7 @@ class Volumio(MediaPlayerEntity):
async def async_get_browse_image( async def async_get_browse_image(
self, self,
media_content_type: str, media_content_type: MediaType | str,
media_content_id: str, media_content_id: str,
media_image_id: str | None = None, media_image_id: str | None = None,
) -> tuple[bytes | None, str | None]: ) -> tuple[bytes | None, str | None]:

25
homeassistant/components/webostv/media_player.py
View File

@ -16,16 +16,15 @@ from homeassistant.components.media_player import (
MediaPlayerDeviceClass, MediaPlayerDeviceClass,
MediaPlayerEntity, MediaPlayerEntity,
MediaPlayerEntityFeature, MediaPlayerEntityFeature,
MediaPlayerState,
MediaType,
) )
from homeassistant.components.media_player.const import MEDIA_TYPE_CHANNEL
from homeassistant.config_entries import ConfigEntry from homeassistant.config_entries import ConfigEntry
from homeassistant.const import ( from homeassistant.const import (
ATTR_ENTITY_ID, ATTR_ENTITY_ID,
ATTR_SUPPORTED_FEATURES, ATTR_SUPPORTED_FEATURES,
ENTITY_MATCH_ALL, ENTITY_MATCH_ALL,
ENTITY_MATCH_NONE, ENTITY_MATCH_NONE,
STATE_OFF,
STATE_ON,
) )
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from homeassistant.exceptions import HomeAssistantError from homeassistant.exceptions import HomeAssistantError
@ -97,7 +96,7 @@ def cmd(
try: try:
await func(self, *args, **kwargs) await func(self, *args, **kwargs)
except WEBOSTV_EXCEPTIONS as exc: except WEBOSTV_EXCEPTIONS as exc:
if self.state != STATE_OFF: if self.state != MediaPlayerState.OFF:
raise HomeAssistantError( raise HomeAssistantError(
f"Error calling {func.__name__} on entity {self.entity_id}, state:{self.state}" f"Error calling {func.__name__} on entity {self.entity_id}, state:{self.state}"
) from exc ) from exc
@ -154,7 +153,7 @@ class LgWebOSMediaPlayerEntity(RestoreEntity, MediaPlayerEntity):
) )
if ( if (
self.state == STATE_OFF self.state == MediaPlayerState.OFF
and (state := await self.async_get_last_state()) is not None and (state := await self.async_get_last_state()) is not None
): ):
self._supported_features = ( self._supported_features = (
@ -188,7 +187,9 @@ class LgWebOSMediaPlayerEntity(RestoreEntity, MediaPlayerEntity):
"""Update entity state attributes.""" """Update entity state attributes."""
self._update_sources() self._update_sources()
self._attr_state = STATE_ON if self._client.is_on else STATE_OFF self._attr_state = (
MediaPlayerState.ON if self._client.is_on else MediaPlayerState.OFF
)
self._attr_is_volume_muted = cast(bool, self._client.muted) self._attr_is_volume_muted = cast(bool, self._client.muted)
self._attr_volume_level = None self._attr_volume_level = None
@ -200,7 +201,7 @@ class LgWebOSMediaPlayerEntity(RestoreEntity, MediaPlayerEntity):
self._attr_media_content_type = None self._attr_media_content_type = None
if self._client.current_app_id == LIVE_TV_APP_ID: if self._client.current_app_id == LIVE_TV_APP_ID:
self._attr_media_content_type = MEDIA_TYPE_CHANNEL self._attr_media_content_type = MediaType.CHANNEL
self._attr_media_title = None self._attr_media_title = None
if (self._client.current_app_id == LIVE_TV_APP_ID) and ( if (self._client.current_app_id == LIVE_TV_APP_ID) and (
@ -217,7 +218,7 @@ class LgWebOSMediaPlayerEntity(RestoreEntity, MediaPlayerEntity):
icon = self._client.apps[self._client.current_app_id]["icon"] icon = self._client.apps[self._client.current_app_id]["icon"]
self._attr_media_image_url = icon self._attr_media_image_url = icon
if self.state != STATE_OFF or not self._supported_features: if self.state != MediaPlayerState.OFF or not self._supported_features:
supported = SUPPORT_WEBOSTV supported = SUPPORT_WEBOSTV
if self._client.sound_output in ("external_arc", "external_speaker"): if self._client.sound_output in ("external_arc", "external_speaker"):
supported = supported | SUPPORT_WEBOSTV_VOLUME supported = supported | SUPPORT_WEBOSTV_VOLUME
@ -236,7 +237,7 @@ class LgWebOSMediaPlayerEntity(RestoreEntity, MediaPlayerEntity):
name=self.name, name=self.name,
) )
if self._client.system_info is not None or self.state != STATE_OFF: if self._client.system_info is not None or self.state != MediaPlayerState.OFF:
maj_v = self._client.software_info.get("major_ver") maj_v = self._client.software_info.get("major_ver")
min_v = self._client.software_info.get("minor_ver") min_v = self._client.software_info.get("minor_ver")
if maj_v and min_v: if maj_v and min_v:
@ -246,7 +247,7 @@ class LgWebOSMediaPlayerEntity(RestoreEntity, MediaPlayerEntity):
self._attr_device_info["model"] = model self._attr_device_info["model"] = model
self._attr_extra_state_attributes = {} self._attr_extra_state_attributes = {}
if self._client.sound_output is not None or self.state != STATE_OFF: if self._client.sound_output is not None or self.state != MediaPlayerState.OFF:
self._attr_extra_state_attributes = { self._attr_extra_state_attributes = {
ATTR_SOUND_OUTPUT: self._client.sound_output ATTR_SOUND_OUTPUT: self._client.sound_output
} }
@ -376,12 +377,12 @@ class LgWebOSMediaPlayerEntity(RestoreEntity, MediaPlayerEntity):
@cmd @cmd
async def async_play_media( async def async_play_media(
self, media_type: str, media_id: str, **kwargs: Any self, media_type: MediaType | str, media_id: str, **kwargs: Any
) -> None: ) -> None:
"""Play a piece of media.""" """Play a piece of media."""
_LOGGER.debug("Call play media type <%s>, Id <%s>", media_type, media_id) _LOGGER.debug("Call play media type <%s>, Id <%s>", media_type, media_id)
if media_type == MEDIA_TYPE_CHANNEL: if media_type == MediaType.CHANNEL:
_LOGGER.debug("Searching channel") _LOGGER.debug("Searching channel")
partial_match_channel_id = None partial_match_channel_id = None
perfect_match_channel_id = None perfect_match_channel_id = None

4
homeassistant/components/ws66i/media_player.py
View File

@ -4,9 +4,9 @@ from pyws66i import WS66i, ZoneStatus
from homeassistant.components.media_player import ( from homeassistant.components.media_player import (
MediaPlayerEntity, MediaPlayerEntity,
MediaPlayerEntityFeature, MediaPlayerEntityFeature,
MediaPlayerState,
) )
from homeassistant.config_entries import ConfigEntry from homeassistant.config_entries import ConfigEntry
from homeassistant.const import STATE_OFF, STATE_ON
from homeassistant.core import HomeAssistant, callback from homeassistant.core import HomeAssistant, callback
from homeassistant.helpers.entity import DeviceInfo from homeassistant.helpers.entity import DeviceInfo
from homeassistant.helpers.entity_platform import AddEntitiesCallback from homeassistant.helpers.entity_platform import AddEntitiesCallback
@ -96,7 +96,7 @@ class Ws66iZone(CoordinatorEntity[Ws66iDataUpdateCoordinator], MediaPlayerEntity
def _set_attrs_from_status(self) -> None: def _set_attrs_from_status(self) -> None:
status = self._status status = self._status
sources = self._ws66i_data.sources.id_name sources = self._ws66i_data.sources.id_name
self._attr_state = STATE_ON if status.power else STATE_OFF self._attr_state = MediaPlayerState.ON if status.power else MediaPlayerState.OFF
self._attr_volume_level = status.volume / float(MAX_VOL) self._attr_volume_level = status.volume / float(MAX_VOL)
self._attr_is_volume_muted = status.mute self._attr_is_volume_muted = status.mute
self._attr_source = self._attr_media_title = sources[status.source] self._attr_source = self._attr_media_title = sources[status.source]