jeans/core
jeans/core
1
0
Fork 0
mirror of https://github.com/home-assistant/core.git synced 2025-04-24 09:17:53 +00:00
Code Issues Packages Projects Releases Wiki Activity

Use new media player enums [a-d] (#77939)

Browse Source
This commit is contained in:
epenet 2022-09-08 11:03:10 +02:00 committed by GitHub
parent bfe245cc3f
commit 9a5fe950a4
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
15 changed files with 131 additions and 177 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -23,6 +23,7 @@ from homeassistant.components import persistent_notification
from homeassistant.components.media_player import (
MediaPlayerEntity,
MediaPlayerEntityFeature,
MediaPlayerState,
)
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import (
@ -33,11 +34,6 @@ from homeassistant.const import (
ATTR_SW_VERSION,
CONF_HOST,
CONF_NAME,
STATE_IDLE,
STATE_OFF,
STATE_PAUSED,
STATE_PLAYING,
STATE_STANDBY,
)
from homeassistant.core import HomeAssistant
from homeassistant.helpers import config_validation as cv, entity_platform
@ -85,11 +81,11 @@ PREFIX_FIRETV = "Fire TV"
# Translate from `AndroidTV` / `FireTV` reported state to HA state.
ANDROIDTV_STATES = {
"off": STATE_OFF,
"idle": STATE_IDLE,
"standby": STATE_STANDBY,
"playing": STATE_PLAYING,
"paused": STATE_PAUSED,
"off": MediaPlayerState.OFF,
"idle": MediaPlayerState.IDLE,
"standby": MediaPlayerState.STANDBY,
"playing": MediaPlayerState.PLAYING,
"paused": MediaPlayerState.PAUSED,
}
@ -323,7 +319,11 @@ class ADBDevice(MediaPlayerEntity):
async def async_get_media_image(self) -> tuple[bytes | None, str | None]:
"""Fetch current playing image."""
if not self._screencap or self.state in (STATE_OFF, None) or not self.available:
if (
not self._screencap
or self.state in {MediaPlayerState.OFF, None}
or not self.available
):
return None, None
media_data = await self._adb_screencap()

14
homeassistant/components/anthemav/media_player.py
View File

@ -12,16 +12,10 @@ from homeassistant.components.media_player import (
MediaPlayerDeviceClass,
MediaPlayerEntity,
MediaPlayerEntityFeature,
MediaPlayerState,
)
from homeassistant.config_entries import SOURCE_IMPORT, ConfigEntry
from homeassistant.const import (
CONF_HOST,
CONF_MAC,
CONF_NAME,
CONF_PORT,
STATE_OFF,
STATE_ON,
)
from homeassistant.const import CONF_HOST, CONF_MAC, CONF_NAME, CONF_PORT
from homeassistant.core import HomeAssistant, callback
import homeassistant.helpers.config_validation as cv
from homeassistant.helpers.dispatcher import async_dispatcher_connect
@ -163,7 +157,9 @@ class AnthemAVR(MediaPlayerEntity):
def set_states(self) -> None:
"""Set all the states from the device to the entity."""
self._attr_state = STATE_ON if self._zone.power is True else STATE_OFF
self._attr_state = (
MediaPlayerState.ON if self._zone.power else MediaPlayerState.OFF
)
self._attr_is_volume_muted = self._zone.mute
self._attr_volume_level = self._zone.volume_as_percentage
self._attr_media_title = self._zone.input_name

9
homeassistant/components/aquostv/media_player.py
View File

@ -10,6 +10,7 @@ from homeassistant.components.media_player import (
PLATFORM_SCHEMA,
MediaPlayerEntity,
MediaPlayerEntityFeature,
MediaPlayerState,
)
from homeassistant.const import (
CONF_HOST,
@ -18,8 +19,6 @@ from homeassistant.const import (
CONF_PORT,
CONF_TIMEOUT,
CONF_USERNAME,
STATE_OFF,
STATE_ON,
)
from homeassistant.core import HomeAssistant
import homeassistant.helpers.config_validation as cv
@ -93,7 +92,7 @@ def _retry(func):
except (OSError, TypeError, ValueError):
update_retries -= 1
if update_retries == 0:
obj.set_state(STATE_OFF)
obj.set_state(MediaPlayerState.OFF)
return wrapper
@ -134,9 +133,9 @@ class SharpAquosTVDevice(MediaPlayerEntity):
def update(self) -> None:
"""Retrieve the latest data."""
if self._remote.power() == 1:
self._attr_state = STATE_ON
self._attr_state = MediaPlayerState.ON
else:
self._attr_state = STATE_OFF
self._attr_state = MediaPlayerState.OFF
# Set TV to be able to remotely power on
if self._power_on_enabled:
self._remote.power_on_command_settings(2)

34
homeassistant/components/arcam_fmj/media_player.py
View File

@ -9,17 +9,15 @@ from arcam.fmj.state import State
from homeassistant.components.media_player import (
BrowseMedia,
MediaClass,
MediaPlayerEntity,
MediaPlayerEntityFeature,
)
from homeassistant.components.media_player.const import (
MEDIA_CLASS_DIRECTORY,
MEDIA_CLASS_MUSIC,
MEDIA_TYPE_MUSIC,
MediaPlayerState,
MediaType,
)
from homeassistant.components.media_player.errors import BrowseError
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import ATTR_ENTITY_ID, STATE_OFF, STATE_ON
from homeassistant.const import ATTR_ENTITY_ID
from homeassistant.core import HomeAssistant, callback
from homeassistant.helpers.dispatcher import async_dispatcher_connect
from homeassistant.helpers.entity import DeviceInfo
@ -91,11 +89,11 @@ class ArcamFmj(MediaPlayerEntity):
self._attr_entity_registry_enabled_default = state.zn == 1
@property
def state(self):
def state(self) -> MediaPlayerState:
"""Return the state of the device."""
if self._state.get_power():
return STATE_ON
return STATE_OFF
return MediaPlayerState.ON
return MediaPlayerState.OFF
@property
def device_info(self):
@ -202,7 +200,9 @@ class ArcamFmj(MediaPlayerEntity):
await self._state.set_power(False)
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."""
if media_content_id not in (None, "root"):
@ -215,9 +215,9 @@ class ArcamFmj(MediaPlayerEntity):
radio = [
BrowseMedia(
title=preset.name,
media_class=MEDIA_CLASS_MUSIC,
media_class=MediaClass.MUSIC,
media_content_id=f"preset:{preset.index}",
media_content_type=MEDIA_TYPE_MUSIC,
media_content_type=MediaType.MUSIC,
can_play=True,
can_expand=False,
)
@ -226,7 +226,7 @@ class ArcamFmj(MediaPlayerEntity):
root = BrowseMedia(
title="Arcam FMJ Receiver",
media_class=MEDIA_CLASS_DIRECTORY,
media_class=MediaClass.DIRECTORY,
media_content_id="root",
media_content_type="library",
can_play=False,
@ -237,7 +237,7 @@ class ArcamFmj(MediaPlayerEntity):
return root
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."""
@ -289,13 +289,13 @@ class ArcamFmj(MediaPlayerEntity):
return value / 99.0
@property
def media_content_type(self):
def media_content_type(self) -> MediaType | None:
"""Content type of current playing media."""
source = self._state.get_source()
if source == SourceCodes.DAB:
value = MEDIA_TYPE_MUSIC
value = MediaType.MUSIC
elif source == SourceCodes.FM:
value = MEDIA_TYPE_MUSIC
value = MediaType.MUSIC
else:
value = None
return value

5
homeassistant/components/blackbird/media_player.py
View File

@ -12,6 +12,7 @@ from homeassistant.components.media_player import (
PLATFORM_SCHEMA,
MediaPlayerEntity,
MediaPlayerEntityFeature,
MediaPlayerState,
)
from homeassistant.const import (
ATTR_ENTITY_ID,
@ -19,8 +20,6 @@ from homeassistant.const import (
CONF_NAME,
CONF_PORT,
CONF_TYPE,
STATE_OFF,
STATE_ON,
)
from homeassistant.core import HomeAssistant, ServiceCall
import homeassistant.helpers.config_validation as cv
@ -163,7 +162,7 @@ class BlackbirdZone(MediaPlayerEntity):
state = self._blackbird.zone_status(self._zone_id)
if not state:
return
self._attr_state = STATE_ON if state.power else STATE_OFF
self._attr_state = MediaPlayerState.ON if state.power else MediaPlayerState.OFF
idx = state.av
if idx in self._source_id_name:
self._attr_source = self._source_id_name[idx]

15
homeassistant/components/bluesound/media_player.py
View File

@ -21,12 +21,12 @@ from homeassistant.components.media_player import (
PLATFORM_SCHEMA,
MediaPlayerEntity,
MediaPlayerEntityFeature,
MediaType,
)
from homeassistant.components.media_player.browse_media import (
BrowseMedia,
async_process_play_media_url,
)
from homeassistant.components.media_player.const import MEDIA_TYPE_MUSIC
from homeassistant.const import (
ATTR_ENTITY_ID,
CONF_HOST,
@ -205,6 +205,8 @@ async def async_setup_platform(
class BluesoundPlayer(MediaPlayerEntity):
"""Representation of a Bluesound Player."""
_attr_media_content_type = MediaType.MUSIC
def __init__(self, hass, host, port=None, name=None, init_callback=None):
"""Initialize the media player."""
self.host = host
@ -551,11 +553,6 @@ class BluesoundPlayer(MediaPlayerEntity):
return self._services_items
@property
def media_content_type(self):
"""Content type of current playing media."""
return MEDIA_TYPE_MUSIC
@property
def state(self):
"""Return the state of the device."""
@ -1022,7 +1019,7 @@ class BluesoundPlayer(MediaPlayerEntity):
return await self.send_bluesound_command(f"Play?seek={float(position)}")
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."""
if self.is_grouped and not self.is_master:
@ -1069,7 +1066,9 @@ class BluesoundPlayer(MediaPlayerEntity):
return await self.send_bluesound_command("Volume?mute=0")
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(

11
homeassistant/components/braviatv/coordinator.py
View File

@ -16,10 +16,7 @@ from pybravia import (
)
from typing_extensions import Concatenate, ParamSpec
from homeassistant.components.media_player.const import (
MEDIA_TYPE_APP,
MEDIA_TYPE_CHANNEL,
)
from homeassistant.components.media_player import MediaType
from homeassistant.core import HomeAssistant
from homeassistant.helpers.debounce import Debouncer
from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
@ -74,7 +71,7 @@ class BraviaTVCoordinator(DataUpdateCoordinator[None]):
self.source_map: dict[str, dict] = {}
self.media_title: str | None = None
self.media_content_id: str | None = None
self.media_content_type: str | None = None
self.media_content_type: MediaType | None = None
self.media_uri: str | None = None
self.media_duration: int | None = None
self.volume_level: float | None = None
@ -182,7 +179,7 @@ class BraviaTVCoordinator(DataUpdateCoordinator[None]):
self.is_channel = self.media_uri[:2] == "tv"
if self.is_channel:
self.media_content_id = playing_info.get("dispNum")
self.media_content_type = MEDIA_TYPE_CHANNEL
self.media_content_type = MediaType.CHANNEL
else:
self.media_content_id = self.media_uri
self.media_content_type = None
@ -193,7 +190,7 @@ class BraviaTVCoordinator(DataUpdateCoordinator[None]):
self.media_content_type = None
if not playing_info:
self.media_title = "Smart TV"
self.media_content_type = MEDIA_TYPE_APP
self.media_content_type = MediaType.APP
@catch_braviatv_errors
async def async_turn_on(self) -> None:

15
homeassistant/components/braviatv/media_player.py
View File

@ -5,9 +5,10 @@ from homeassistant.components.media_player import (
MediaPlayerDeviceClass,
MediaPlayerEntity,
MediaPlayerEntityFeature,
MediaPlayerState,
MediaType,
)
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import STATE_OFF, STATE_PAUSED, STATE_PLAYING
from homeassistant.core import HomeAssistant
from homeassistant.helpers.entity_platform import AddEntitiesCallback
@ -50,11 +51,15 @@ class BraviaTVMediaPlayer(BraviaTVEntity, MediaPlayerEntity):
)
@property
def state(self) -> str | None:
def state(self) -> MediaPlayerState:
"""Return the state of the device."""
if self.coordinator.is_on:
return STATE_PLAYING if self.coordinator.playing else STATE_PAUSED
return STATE_OFF
return (
MediaPlayerState.PLAYING
if self.coordinator.playing
else MediaPlayerState.PAUSED
)
return MediaPlayerState.OFF
@property
def source(self) -> str | None:
@ -87,7 +92,7 @@ class BraviaTVMediaPlayer(BraviaTVEntity, MediaPlayerEntity):
return self.coordinator.media_content_id
@property
def media_content_type(self) -> str | None:
def media_content_type(self) -> MediaType | None:
"""Content type of current playing media."""
return self.coordinator.media_content_type

40
homeassistant/components/channels/media_player.py
View File

@ -10,22 +10,10 @@ from homeassistant.components.media_player import (
PLATFORM_SCHEMA,
MediaPlayerEntity,
MediaPlayerEntityFeature,
MediaPlayerState,
MediaType,
)
from homeassistant.components.media_player.const import (
MEDIA_TYPE_CHANNEL,
MEDIA_TYPE_EPISODE,
MEDIA_TYPE_MOVIE,
MEDIA_TYPE_TVSHOW,
)
from homeassistant.const import (
ATTR_SECONDS,
CONF_HOST,
CONF_NAME,
CONF_PORT,
STATE_IDLE,
STATE_PAUSED,
STATE_PLAYING,
)
from homeassistant.const import ATTR_SECONDS, CONF_HOST, CONF_NAME, CONF_PORT
from homeassistant.core import HomeAssistant
from homeassistant.helpers import config_validation as cv, entity_platform
from homeassistant.helpers.entity_platform import AddEntitiesCallback
@ -78,6 +66,7 @@ async def async_setup_platform(
class ChannelsPlayer(MediaPlayerEntity):
"""Representation of a Channels instance."""
_attr_media_content_type = MediaType.CHANNEL
_attr_supported_features = (
MediaPlayerEntityFeature.PLAY
| MediaPlayerEntityFeature.PAUSE
@ -156,16 +145,16 @@ class ChannelsPlayer(MediaPlayerEntity):
return self._name
@property
def state(self):
def state(self) -> MediaPlayerState | None:
"""Return the state of the player."""
if self.status == "stopped":
return STATE_IDLE
return MediaPlayerState.IDLE
if self.status == "paused":
return STATE_PAUSED
return MediaPlayerState.PAUSED
if self.status == "playing":
return STATE_PLAYING
return MediaPlayerState.PLAYING
return None
@ -190,11 +179,6 @@ class ChannelsPlayer(MediaPlayerEntity):
"""Content ID of current playing channel."""
return self.channel_number
@property
def media_content_type(self):
"""Content type of current playing media."""
return MEDIA_TYPE_CHANNEL
@property
def media_image_url(self):
"""Image url of current playing media."""
@ -253,12 +237,14 @@ class ChannelsPlayer(MediaPlayerEntity):
self.update_state(response)
break
def play_media(self, media_type: str, media_id: str, **kwargs: Any) -> None:
def play_media(
self, media_type: MediaType | str, media_id: str, **kwargs: Any
) -> None:
"""Send the play_media command to the player."""
if media_type == MEDIA_TYPE_CHANNEL:
if media_type == MediaType.CHANNEL:
response = self.client.play_channel(media_id)
self.update_state(response)
elif media_type in (MEDIA_TYPE_MOVIE, MEDIA_TYPE_EPISODE, MEDIA_TYPE_TVSHOW):
elif media_type in {MediaType.MOVIE, MediaType.EPISODE, MediaType.TVSHOW}:
response = self.client.play_recording(media_id)
self.update_state(response)

33
homeassistant/components/clementine/media_player.py
View File

@ -11,17 +11,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_ACCESS_TOKEN,
CONF_HOST,
CONF_NAME,
CONF_PORT,
STATE_OFF,
STATE_PAUSED,
STATE_PLAYING,
)
from homeassistant.const import CONF_ACCESS_TOKEN, CONF_HOST, CONF_NAME, CONF_PORT
from homeassistant.core import HomeAssistant
import homeassistant.helpers.config_validation as cv
from homeassistant.helpers.entity_platform import AddEntitiesCallback
@ -62,7 +55,7 @@ def setup_platform(
class ClementineDevice(MediaPlayerEntity):
"""Representation of Clementine Player."""
_attr_media_content_type = MEDIA_TYPE_MUSIC
_attr_media_content_type = MediaType.MUSIC
_attr_supported_features = (
MediaPlayerEntityFeature.PAUSE
| MediaPlayerEntityFeature.VOLUME_STEP
@ -84,16 +77,16 @@ class ClementineDevice(MediaPlayerEntity):
client = self._client
if client.state == "Playing":
self._attr_state = STATE_PLAYING
self._attr_state = MediaPlayerState.PLAYING
elif client.state == "Paused":
self._attr_state = STATE_PAUSED
self._attr_state = MediaPlayerState.PAUSED
elif client.state == "Disconnected":
self._attr_state = STATE_OFF
self._attr_state = MediaPlayerState.OFF
else:
self._attr_state = STATE_PAUSED
self._attr_state = MediaPlayerState.PAUSED
if client.last_update and (time.time() - client.last_update > 40):
self._attr_state = STATE_OFF
self._attr_state = MediaPlayerState.OFF
volume = float(client.volume) if client.volume else 0.0
self._attr_volume_level = volume / 100.0
@ -112,7 +105,7 @@ class ClementineDevice(MediaPlayerEntity):
self._attr_media_image_hash = None
except Exception:
self._attr_state = STATE_OFF
self._attr_state = MediaPlayerState.OFF
raise
def select_source(self, source: str) -> None:
@ -150,19 +143,19 @@ class ClementineDevice(MediaPlayerEntity):
def media_play_pause(self) -> None:
"""Simulate play pause media player."""
if self.state == STATE_PLAYING:
if self.state == MediaPlayerState.PLAYING:
self.media_pause()
else:
self.media_play()
def media_play(self) -> None:
"""Send play command."""
self._attr_state = STATE_PLAYING
self._attr_state = MediaPlayerState.PLAYING
self._client.play()
def media_pause(self) -> None:
"""Send media pause command to media player."""
self._attr_state = STATE_PAUSED
self._attr_state = MediaPlayerState.PAUSED
self._client.pause()
def media_next_track(self) -> None:

34
homeassistant/components/cmus/media_player.py
View File

@ -11,20 +11,10 @@ from homeassistant.components.media_player import (
PLATFORM_SCHEMA,
MediaPlayerEntity,
MediaPlayerEntityFeature,
MediaPlayerState,
MediaType,
)
from homeassistant.components.media_player.const import (
MEDIA_TYPE_MUSIC,
MEDIA_TYPE_PLAYLIST,
)
from homeassistant.const import (
CONF_HOST,
CONF_NAME,
CONF_PASSWORD,
CONF_PORT,
STATE_OFF,
STATE_PAUSED,
STATE_PLAYING,
)
from homeassistant.const import CONF_HOST, CONF_NAME, CONF_PASSWORD, CONF_PORT
from homeassistant.core import HomeAssistant
import homeassistant.helpers.config_validation as cv
from homeassistant.helpers.entity_platform import AddEntitiesCallback
@ -92,7 +82,7 @@ class CmusRemote:
class CmusDevice(MediaPlayerEntity):
"""Representation of a running cmus."""
_attr_media_content_type = MEDIA_TYPE_MUSIC
_attr_media_content_type = MediaType.MUSIC
_attr_supported_features = (
MediaPlayerEntityFeature.PAUSE
| MediaPlayerEntityFeature.VOLUME_SET
@ -128,11 +118,11 @@ class CmusDevice(MediaPlayerEntity):
else:
self.status = status
if self.status.get("status") == "playing":
self._attr_state = STATE_PLAYING
self._attr_state = MediaPlayerState.PLAYING
elif self.status.get("status") == "paused":
self._attr_state = STATE_PAUSED
self._attr_state = MediaPlayerState.PAUSED
else:
self._attr_state = STATE_OFF
self._attr_state = MediaPlayerState.OFF
self._attr_media_content_id = self.status.get("file")
self._attr_media_duration = self.status.get("duration")
self._attr_media_title = self.status["tag"].get("title")
@ -187,16 +177,18 @@ class CmusDevice(MediaPlayerEntity):
if current_volume <= 100:
self._remote.cmus.set_volume(int(current_volume) - 5)
def play_media(self, media_type: str, media_id: str, **kwargs: Any) -> None:
def play_media(
self, media_type: MediaType | str, media_id: str, **kwargs: Any
) -> None:
"""Send the play command."""
if media_type in [MEDIA_TYPE_MUSIC, MEDIA_TYPE_PLAYLIST]:
if media_type in {MediaType.MUSIC, MediaType.PLAYLIST}:
self._remote.cmus.player_play_file(media_id)
else:
_LOGGER.error(
"Invalid media type %s. Only %s and %s are supported",
media_type,
MEDIA_TYPE_MUSIC,
MEDIA_TYPE_PLAYLIST,
MediaType.MUSIC,
MediaType.PLAYLIST,
)
def media_pause(self) -> None:

9
homeassistant/components/denon/media_player.py
View File

@ -10,8 +10,9 @@ from homeassistant.components.media_player import (
PLATFORM_SCHEMA,
MediaPlayerEntity,
MediaPlayerEntityFeature,
MediaPlayerState,
)
from homeassistant.const import CONF_HOST, CONF_NAME, STATE_OFF, STATE_ON
from homeassistant.const import CONF_HOST, CONF_NAME
from homeassistant.core import HomeAssistant
import homeassistant.helpers.config_validation as cv
from homeassistant.helpers.entity_platform import AddEntitiesCallback
@ -214,12 +215,12 @@ class DenonDevice(MediaPlayerEntity):
return self._name
@property
def state(self):
def state(self) -> MediaPlayerState | None:
"""Return the state of the device."""
if self._pwstate == "PWSTANDBY":
return STATE_OFF
return MediaPlayerState.OFF
if self._pwstate == "PWON":
return STATE_ON
return MediaPlayerState.ON
return None

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

@ -22,19 +22,11 @@ import voluptuous as vol
from homeassistant.components.media_player import (
MediaPlayerEntity,
MediaPlayerEntityFeature,
)
from homeassistant.components.media_player.const import (
MEDIA_TYPE_CHANNEL,
MEDIA_TYPE_MUSIC,
MediaPlayerState,
MediaType,
)
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import (
ATTR_COMMAND,
CONF_HOST,
CONF_MODEL,
STATE_PAUSED,
STATE_PLAYING,
)
from homeassistant.const import ATTR_COMMAND, CONF_HOST, CONF_MODEL
from homeassistant.core import HomeAssistant
from homeassistant.helpers import config_validation as cv, entity_platform
from homeassistant.helpers.entity import DeviceInfo
@ -297,11 +289,11 @@ class DenonDevice(MediaPlayerEntity):
return None
@property
def media_content_type(self):
def media_content_type(self) -> MediaType:
"""Content type of current playing media."""
if self._receiver.state in (STATE_PLAYING, STATE_PAUSED):
return MEDIA_TYPE_MUSIC
return MEDIA_TYPE_CHANNEL
if self._receiver.state in {MediaPlayerState.PLAYING, MediaPlayerState.PAUSED}:
return MediaType.MUSIC
return MediaType.CHANNEL
@property
def media_duration(self):

31
homeassistant/components/directv/media_player.py
View File

@ -10,15 +10,10 @@ from homeassistant.components.media_player import (
MediaPlayerDeviceClass,
MediaPlayerEntity,
MediaPlayerEntityFeature,
)
from homeassistant.components.media_player.const import (
MEDIA_TYPE_CHANNEL,
MEDIA_TYPE_MOVIE,
MEDIA_TYPE_MUSIC,
MEDIA_TYPE_TVSHOW,
MediaPlayerState,
MediaType,
)
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import STATE_OFF, STATE_PAUSED, STATE_PLAYING
from homeassistant.core import HomeAssistant
from homeassistant.helpers.entity_platform import AddEntitiesCallback
from homeassistant.util import dt as dt_util
@ -34,7 +29,7 @@ from .entity import DIRECTVEntity
_LOGGER = logging.getLogger(__name__)
KNOWN_MEDIA_TYPES = [MEDIA_TYPE_MOVIE, MEDIA_TYPE_MUSIC, MEDIA_TYPE_TVSHOW]
KNOWN_MEDIA_TYPES = {MediaType.MOVIE, MediaType.MUSIC, MediaType.TVSHOW}
SUPPORT_DTV = (
MediaPlayerEntityFeature.PAUSE
@ -134,18 +129,18 @@ class DIRECTVMediaPlayer(DIRECTVEntity, MediaPlayerEntity):
# MediaPlayerEntity properties and methods
@property
def state(self):
def state(self) -> MediaPlayerState:
"""Return the state of the device."""
if self._is_standby:
return STATE_OFF
return MediaPlayerState.OFF
# For recorded media we can determine if it is paused or not.
# For live media we're unable to determine and will always return
# playing instead.
if self._paused:
return STATE_PAUSED
return MediaPlayerState.PAUSED
return STATE_PLAYING
return MediaPlayerState.PLAYING
@property
def media_content_id(self):
@ -156,7 +151,7 @@ class DIRECTVMediaPlayer(DIRECTVEntity, MediaPlayerEntity):
return self._program.program_id
@property
def media_content_type(self):
def media_content_type(self) -> MediaType | None:
"""Return the content type of current playing media."""
if self._is_standby or self._program is None:
return None
@ -164,7 +159,7 @@ class DIRECTVMediaPlayer(DIRECTVEntity, MediaPlayerEntity):
if self._program.program_type in KNOWN_MEDIA_TYPES:
return self._program.program_type
return MEDIA_TYPE_MOVIE
return MediaType.MOVIE
@property
def media_duration(self):
@ -196,7 +191,7 @@ class DIRECTVMediaPlayer(DIRECTVEntity, MediaPlayerEntity):
if self._is_standby or self._program is None:
return None
if self.media_content_type == MEDIA_TYPE_MUSIC:
if self.media_content_type == MediaType.MUSIC:
return self._program.music_title
return self._program.title
@ -320,14 +315,14 @@ class DIRECTVMediaPlayer(DIRECTVEntity, MediaPlayerEntity):
await self.dtv.remote("ffwd", self._address)
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:
"""Select input source."""
if media_type != MEDIA_TYPE_CHANNEL:
if media_type != MediaType.CHANNEL:
_LOGGER.error(
"Invalid media type %s. Only %s is supported",
media_type,
MEDIA_TYPE_CHANNEL,
MediaType.CHANNEL,
)
return

14
homeassistant/components/dunehd/media_player.py
View File

@ -8,9 +8,9 @@ from pdunehd import DuneHDPlayer
from homeassistant.components.media_player import (
MediaPlayerEntity,
MediaPlayerEntityFeature,
MediaPlayerState,
)
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import STATE_OFF, STATE_ON, STATE_PAUSED, STATE_PLAYING
from homeassistant.core import HomeAssistant
from homeassistant.helpers.entity import DeviceInfo
from homeassistant.helpers.entity_platform import AddEntitiesCallback
@ -57,17 +57,17 @@ class DuneHDPlayerEntity(MediaPlayerEntity):
self.__update_title()
@property
def state(self) -> str | None:
def state(self) -> MediaPlayerState:
"""Return player state."""
state = STATE_OFF
state = MediaPlayerState.OFF
if "playback_position" in self._state:
state = STATE_PLAYING
state = MediaPlayerState.PLAYING
if self._state.get("player_state") in ("playing", "buffering", "photo_viewer"):
state = STATE_PLAYING
state = MediaPlayerState.PLAYING
if int(self._state.get("playback_speed", 1234)) == 0:
state = STATE_PAUSED
state = MediaPlayerState.PAUSED
if self._state.get("player_state") == "navigator":
state = STATE_ON
state = MediaPlayerState.ON
return state
@property