evlli/hass-core
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

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,
MediaPlayerEntity,
MediaPlayerEntityFeature,
MediaPlayerState,
MediaType,
)
from homeassistant.components.media_player.const import MEDIA_TYPE_MUSIC
from homeassistant.const import (
CONF_PASSWORD,
CONF_USERNAME,
STATE_IDLE,
STATE_OFF,
STATE_PAUSED,
STATE_PLAYING,
)
from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
from homeassistant.core import HomeAssistant
import homeassistant.helpers.config_validation as cv
from homeassistant.helpers.entity_platform import AddEntitiesCallback
@ -30,7 +24,11 @@ _LOGGER = logging.getLogger(__name__)
ICON = "mdi:radio"
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(
{vol.Required(CONF_USERNAME): cv.string, vol.Required(CONF_PASSWORD): cv.string}
@ -84,6 +82,7 @@ def setup_platform(
class UERadioDevice(MediaPlayerEntity):
"""Representation of a Logitech UE Smart Radio device."""
_attr_media_content_type = MediaType.MUSIC
_attr_supported_features = (
MediaPlayerEntityFeature.PLAY
| MediaPlayerEntityFeature.PAUSE
@ -133,7 +132,7 @@ class UERadioDevice(MediaPlayerEntity):
return
if request["result"]["power"] == 0:
self._state = STATE_OFF
self._state = MediaPlayerState.OFF
else:
self._state = PLAYBACK_DICT[request["result"]["mode"]]
@ -172,11 +171,6 @@ class UERadioDevice(MediaPlayerEntity):
"""Volume level of the media player (0..1)."""
return self._volume
@property
def media_content_type(self):
"""Return the media content type."""
return MEDIA_TYPE_MUSIC
@property
def media_image_url(self):
"""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,
MediaPlayerEntityDescription,
MediaPlayerEntityFeature,
)
from homeassistant.components.media_player.browse_media import (
MediaPlayerState,
MediaType,
async_process_play_media_url,
)
from homeassistant.components.media_player.const import MEDIA_TYPE_MUSIC
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import STATE_IDLE, STATE_PLAYING
from homeassistant.core import HomeAssistant, callback
from homeassistant.exceptions import HomeAssistantError
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_media_content_type = MEDIA_TYPE_MUSIC
self._attr_media_content_type = MediaType.MUSIC
@callback
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
and self.device.talkback_stream.is_running
):
self._attr_state = STATE_PLAYING
self._attr_state = MediaPlayerState.PLAYING
else:
self._attr_state = STATE_IDLE
self._attr_state = MediaPlayerState.IDLE
is_connected = self.data.last_update_success and (
self.device.state == StateType.CONNECTED
@ -134,17 +132,17 @@ class ProtectMediaPlayer(ProtectDeviceEntity, MediaPlayerEntity):
self._async_updated_event(self.device)
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:
"""Play a piece of media."""
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(
self.hass, media_id, self.entity_id
)
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")
_LOGGER.debug(
@ -164,7 +162,9 @@ class ProtectMediaPlayer(ProtectDeviceEntity, MediaPlayerEntity):
self._async_updated_event(self.device)
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:
"""Implement the websocket media browsing helper."""
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,
MediaPlayerEntity,
MediaPlayerEntityFeature,
MediaPlayerState,
)
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import (
@ -21,8 +22,6 @@ from homeassistant.const import (
CONF_HOST,
CONF_INCLUDE,
CONF_NAME,
STATE_OFF,
STATE_ON,
)
from homeassistant.core import HomeAssistant, callback
from homeassistant.helpers import entity_platform
@ -207,7 +206,7 @@ class VizioDevice(MediaPlayerEntity):
)
if not is_on:
self._attr_state = STATE_OFF
self._attr_state = MediaPlayerState.OFF
self._attr_volume_level = None
self._attr_is_volume_muted = None
self._current_input = None
@ -216,7 +215,7 @@ class VizioDevice(MediaPlayerEntity):
self._attr_sound_mode = None
return
self._attr_state = STATE_ON
self._attr_state = MediaPlayerState.ON
if audio_settings := await self._device.get_all_settings(
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,
MediaPlayerEntity,
MediaPlayerEntityFeature,
)
from homeassistant.components.media_player.browse_media import (
MediaPlayerState,
MediaType,
async_process_play_media_url,
)
from homeassistant.components.media_player.const import MEDIA_TYPE_MUSIC
from homeassistant.const import CONF_NAME, STATE_IDLE, STATE_PAUSED, STATE_PLAYING
from homeassistant.const import CONF_NAME
from homeassistant.core import HomeAssistant
import homeassistant.helpers.config_validation as cv
from homeassistant.helpers.entity_platform import AddEntitiesCallback
@ -53,6 +52,7 @@ def setup_platform(
class VlcDevice(MediaPlayerEntity):
"""Representation of a vlc player."""
_attr_media_content_type = MediaType.MUSIC
_attr_supported_features = (
MediaPlayerEntityFeature.PAUSE
| MediaPlayerEntityFeature.VOLUME_SET
@ -79,11 +79,11 @@ class VlcDevice(MediaPlayerEntity):
"""Get the latest details from the device."""
status = self._vlc.get_state()
if status == vlc.State.Playing:
self._state = STATE_PLAYING
self._state = MediaPlayerState.PLAYING
elif status == vlc.State.Paused:
self._state = STATE_PAUSED
self._state = MediaPlayerState.PAUSED
else:
self._state = STATE_IDLE
self._state = MediaPlayerState.IDLE
self._media_duration = self._vlc.get_length() / 1000
position = self._vlc.get_position() * self._media_duration
if position != self._media_position:
@ -115,11 +115,6 @@ class VlcDevice(MediaPlayerEntity):
"""Boolean if volume is currently muted."""
return self._muted
@property
def media_content_type(self):
"""Content type of current playing media."""
return MEDIA_TYPE_MUSIC
@property
def media_duration(self):
"""Duration of current playing media in seconds."""
@ -153,20 +148,20 @@ class VlcDevice(MediaPlayerEntity):
def media_play(self) -> None:
"""Send play command."""
self._vlc.play()
self._state = STATE_PLAYING
self._state = MediaPlayerState.PLAYING
def media_pause(self) -> None:
"""Send pause command."""
self._vlc.pause()
self._state = STATE_PAUSED
self._state = MediaPlayerState.PAUSED
def media_stop(self) -> None:
"""Send stop command."""
self._vlc.stop()
self._state = STATE_IDLE
self._state = MediaPlayerState.IDLE
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:
"""Play media from a URL or file."""
# Handle media_source
@ -176,11 +171,11 @@ class VlcDevice(MediaPlayerEntity):
)
media_id = sourced_media.url
elif media_type != MEDIA_TYPE_MUSIC:
elif media_type != MediaType.MUSIC:
_LOGGER.error(
"Invalid media type %s. Only %s is supported",
media_type,
MEDIA_TYPE_MUSIC,
MediaType.MUSIC,
)
return
@ -191,10 +186,12 @@ class VlcDevice(MediaPlayerEntity):
self._vlc.play()
await self.hass.async_add_executor_job(play)
self._state = STATE_PLAYING
self._state = MediaPlayerState.PLAYING
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:
"""Implement the websocket media browsing helper."""
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,
MediaPlayerEntity,
MediaPlayerEntityFeature,
MediaPlayerState,
MediaType,
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.const import CONF_NAME, STATE_IDLE, STATE_PAUSED, STATE_PLAYING
from homeassistant.const import CONF_NAME
from homeassistant.core import HomeAssistant
from homeassistant.exceptions import HomeAssistantError
from homeassistant.helpers.device_registry import DeviceEntryType
@ -71,6 +72,7 @@ def catch_vlc_errors(
class VlcDevice(MediaPlayerEntity):
"""Representation of a vlc player."""
_attr_media_content_type = MediaType.MUSIC
_attr_supported_features = (
MediaPlayerEntityFeature.CLEAR_PLAYLIST
| MediaPlayerEntityFeature.NEXT_TRACK
@ -132,7 +134,7 @@ class VlcDevice(MediaPlayerEntity):
)
return
self._state = STATE_IDLE
self._state = MediaPlayerState.IDLE
self._available = True
LOGGER.info("Connected to vlc host: %s", self._vlc.host)
@ -142,13 +144,13 @@ class VlcDevice(MediaPlayerEntity):
self._volume = status.audio_volume / MAX_VOLUME
state = status.state
if state == "playing":
self._state = STATE_PLAYING
self._state = MediaPlayerState.PLAYING
elif state == "paused":
self._state = STATE_PAUSED
self._state = MediaPlayerState.PAUSED
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
time_output = await self._vlc.get_time()
vlc_position = time_output.time
@ -209,11 +211,6 @@ class VlcDevice(MediaPlayerEntity):
"""Boolean if volume is currently muted."""
return self._muted
@property
def media_content_type(self) -> str:
"""Content type of current playing media."""
return MEDIA_TYPE_MUSIC
@property
def media_duration(self) -> int | None:
"""Duration of current playing media in seconds."""
@ -270,7 +267,7 @@ class VlcDevice(MediaPlayerEntity):
async def async_media_play(self) -> None:
"""Send play command."""
await self._vlc.play()
self._state = STATE_PLAYING
self._state = MediaPlayerState.PLAYING
@catch_vlc_errors
async def async_media_pause(self) -> None:
@ -281,17 +278,17 @@ class VlcDevice(MediaPlayerEntity):
# pause.
await self._vlc.pause()
self._state = STATE_PAUSED
self._state = MediaPlayerState.PAUSED
@catch_vlc_errors
async def async_media_stop(self) -> None:
"""Send stop command."""
await self._vlc.stop()
self._state = STATE_IDLE
self._state = MediaPlayerState.IDLE
@catch_vlc_errors
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:
"""Play media from a URL or file."""
# Handle media_source
@ -302,9 +299,9 @@ class VlcDevice(MediaPlayerEntity):
media_type = sourced_media.mime_type
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(
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.
@ -313,7 +310,7 @@ class VlcDevice(MediaPlayerEntity):
)
await self._vlc.add(media_id)
self._state = STATE_PLAYING
self._state = MediaPlayerState.PLAYING
@catch_vlc_errors
async def async_media_previous_track(self) -> None:
@ -337,7 +334,9 @@ class VlcDevice(MediaPlayerEntity):
await self._vlc.random(shuffle_command)
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:
"""Implement the websocket media browsing helper."""
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 homeassistant.components.media_player import (
BrowseMedia,
MediaPlayerEntity,
MediaPlayerEntityFeature,
)
from homeassistant.components.media_player.browse_media import BrowseMedia
from homeassistant.components.media_player.const import (
MEDIA_TYPE_MUSIC,
REPEAT_MODE_ALL,
REPEAT_MODE_OFF,
MediaPlayerState,
MediaType,
RepeatMode,
)
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import (
CONF_ID,
CONF_NAME,
STATE_IDLE,
STATE_PAUSED,
STATE_PLAYING,
)
from homeassistant.const import CONF_ID, CONF_NAME
from homeassistant.core import HomeAssistant
from homeassistant.helpers.entity import DeviceInfo
from homeassistant.helpers.entity_platform import AddEntitiesCallback
@ -58,6 +50,7 @@ async def async_setup_entry(
class Volumio(MediaPlayerEntity):
"""Volumio Player Object."""
_attr_media_content_type = MediaType.MUSIC
_attr_supported_features = (
MediaPlayerEntityFeature.PAUSE
| MediaPlayerEntityFeature.VOLUME_SET
@ -114,20 +107,15 @@ class Volumio(MediaPlayerEntity):
)
@property
def media_content_type(self):
"""Content type of current playing media."""
return MEDIA_TYPE_MUSIC
@property
def state(self):
def state(self) -> MediaPlayerState:
"""Return the state of the device."""
status = self._state.get("status", None)
if status == "pause":
return STATE_PAUSED
return MediaPlayerState.PAUSED
if status == "play":
return STATE_PLAYING
return MediaPlayerState.PLAYING
return STATE_IDLE
return MediaPlayerState.IDLE
@property
def media_title(self):
@ -179,11 +167,11 @@ class Volumio(MediaPlayerEntity):
return self._state.get("random", False)
@property
def repeat(self):
def repeat(self) -> RepeatMode:
"""Return current repeat mode."""
if self._state.get("repeat", None):
return REPEAT_MODE_ALL
return REPEAT_MODE_OFF
return RepeatMode.ALL
return RepeatMode.OFF
@property
def source_list(self):
@ -241,9 +229,9 @@ class Volumio(MediaPlayerEntity):
"""Enable/disable shuffle mode."""
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."""
if repeat == REPEAT_MODE_OFF:
if repeat == RepeatMode.OFF:
await self._volumio.repeatAll("false")
else:
await self._volumio.repeatAll("true")
@ -264,13 +252,15 @@ class Volumio(MediaPlayerEntity):
self._playlists = await self._volumio.get_playlists()
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:
"""Send the play_media command to the media player."""
await self._volumio.replace_and_play(json.loads(media_id))
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:
"""Implement the websocket media browsing helper."""
self.thumbnail_cache = {}
@ -283,7 +273,7 @@ class Volumio(MediaPlayerEntity):
async def async_get_browse_image(
self,
media_content_type: str,
media_content_type: MediaType | str,
media_content_id: str,
media_image_id: str | None = 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,
MediaPlayerEntity,
MediaPlayerEntityFeature,
MediaPlayerState,
MediaType,
)
from homeassistant.components.media_player.const import MEDIA_TYPE_CHANNEL
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import (
ATTR_ENTITY_ID,
ATTR_SUPPORTED_FEATURES,
ENTITY_MATCH_ALL,
ENTITY_MATCH_NONE,
STATE_OFF,
STATE_ON,
)
from homeassistant.core import HomeAssistant
from homeassistant.exceptions import HomeAssistantError
@ -97,7 +96,7 @@ def cmd(
try:
await func(self, *args, **kwargs)
except WEBOSTV_EXCEPTIONS as exc:
if self.state != STATE_OFF:
if self.state != MediaPlayerState.OFF:
raise HomeAssistantError(
f"Error calling {func.__name__} on entity {self.entity_id}, state:{self.state}"
) from exc
@ -154,7 +153,7 @@ class LgWebOSMediaPlayerEntity(RestoreEntity, MediaPlayerEntity):
)
if (
self.state == STATE_OFF
self.state == MediaPlayerState.OFF
and (state := await self.async_get_last_state()) is not None
):
self._supported_features = (
@ -188,7 +187,9 @@ class LgWebOSMediaPlayerEntity(RestoreEntity, MediaPlayerEntity):
"""Update entity state attributes."""
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_volume_level = None
@ -200,7 +201,7 @@ class LgWebOSMediaPlayerEntity(RestoreEntity, MediaPlayerEntity):
self._attr_media_content_type = None
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
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"]
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
if self._client.sound_output in ("external_arc", "external_speaker"):
supported = supported | SUPPORT_WEBOSTV_VOLUME
@ -236,7 +237,7 @@ class LgWebOSMediaPlayerEntity(RestoreEntity, MediaPlayerEntity):
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")
min_v = self._client.software_info.get("minor_ver")
if maj_v and min_v:
@ -246,7 +247,7 @@ class LgWebOSMediaPlayerEntity(RestoreEntity, MediaPlayerEntity):
self._attr_device_info["model"] = model
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 = {
ATTR_SOUND_OUTPUT: self._client.sound_output
}
@ -376,12 +377,12 @@ class LgWebOSMediaPlayerEntity(RestoreEntity, MediaPlayerEntity):
@cmd
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:
"""Play a piece of media."""
_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")
partial_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 (
MediaPlayerEntity,
MediaPlayerEntityFeature,
MediaPlayerState,
)
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import STATE_OFF, STATE_ON
from homeassistant.core import HomeAssistant, callback
from homeassistant.helpers.entity import DeviceInfo
from homeassistant.helpers.entity_platform import AddEntitiesCallback
@ -96,7 +96,7 @@ class Ws66iZone(CoordinatorEntity[Ws66iDataUpdateCoordinator], MediaPlayerEntity
def _set_attrs_from_status(self) -> None:
status = self._status
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_is_volume_muted = status.mute
self._attr_source = self._attr_media_title = sources[status.source]