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

Use new media player enums [p] (#78058)

Browse Source
This commit is contained in:
epenet 2022-09-08 22:54:43 +02:00 committed by GitHub
parent 9c192dea9c
commit 52b5e1779f
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
8 changed files with 105 additions and 143 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -10,14 +10,9 @@ from homeassistant.components.media_player import (
PLATFORM_SCHEMA, PLATFORM_SCHEMA,
MediaPlayerEntity, MediaPlayerEntity,
MediaPlayerEntityFeature, MediaPlayerEntityFeature,
MediaPlayerState,
) )
from homeassistant.const import ( from homeassistant.const import CONF_HOST, CONF_NAME
CONF_HOST,
CONF_NAME,
STATE_IDLE,
STATE_OFF,
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
@ -65,7 +60,7 @@ class PanasonicBluRay(MediaPlayerEntity):
"""Initialize the Panasonic Blue-ray device.""" """Initialize the Panasonic Blue-ray device."""
self._device = PanasonicBD(ip) self._device = PanasonicBD(ip)
self._name = name self._name = name
self._state = STATE_OFF self._state = MediaPlayerState.OFF
self._position = 0 self._position = 0
self._duration = 0 self._duration = 0
self._position_valid = 0 self._position_valid = 0
@ -111,11 +106,11 @@ class PanasonicBluRay(MediaPlayerEntity):
# We map both of these to off. If it's really off we can't # We map both of these to off. If it's really off we can't
# turn it on, but from standby we can go to idle by pressing # turn it on, but from standby we can go to idle by pressing
# POWER. # POWER.
self._state = STATE_OFF self._state = MediaPlayerState.OFF
elif state[0] in ["paused", "stopped"]: elif state[0] in ["paused", "stopped"]:
self._state = STATE_IDLE self._state = MediaPlayerState.IDLE
elif state[0] == "playing": elif state[0] == "playing":
self._state = STATE_PLAYING self._state = MediaPlayerState.PLAYING
# Update our current media position + length # Update our current media position + length
if state[1] >= 0: if state[1] >= 0:
@ -134,17 +129,17 @@ class PanasonicBluRay(MediaPlayerEntity):
our favour as it means the device is still accepting commands and we our favour as it means the device is still accepting commands and we
can thus turn it back on when desired. can thus turn it back on when desired.
""" """
if self._state != STATE_OFF: if self._state != MediaPlayerState.OFF:
self._device.send_key("POWER") self._device.send_key("POWER")
self._state = STATE_OFF self._state = MediaPlayerState.OFF
def turn_on(self) -> None: def turn_on(self) -> None:
"""Wake the device back up from standby.""" """Wake the device back up from standby."""
if self._state == STATE_OFF: if self._state == MediaPlayerState.OFF:
self._device.send_key("POWER") self._device.send_key("POWER")
self._state = STATE_IDLE self._state = MediaPlayerState.IDLE
def media_play(self) -> None: def media_play(self) -> None:
"""Send play command.""" """Send play command."""

10
homeassistant/components/panasonic_viera/media_player.py
View File

@ -8,15 +8,13 @@ from panasonic_viera import Keys
from homeassistant.components import media_source from homeassistant.components import media_source
from homeassistant.components.media_player import ( from homeassistant.components.media_player import (
BrowseMedia,
MediaPlayerDeviceClass, MediaPlayerDeviceClass,
MediaPlayerEntity, MediaPlayerEntity,
MediaPlayerEntityFeature, MediaPlayerEntityFeature,
) MediaType,
from homeassistant.components.media_player.browse_media import (
BrowseMedia,
async_process_play_media_url, async_process_play_media_url,
) )
from homeassistant.components.media_player.const import MEDIA_TYPE_URL
from homeassistant.config_entries import ConfigEntry from homeassistant.config_entries import ConfigEntry
from homeassistant.const import CONF_NAME from homeassistant.const import CONF_NAME
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
@ -191,13 +189,13 @@ class PanasonicVieraTVEntity(MediaPlayerEntity):
) -> None: ) -> None:
"""Play media.""" """Play media."""
if media_source.is_media_source_id(media_id): if media_source.is_media_source_id(media_id):
media_type = MEDIA_TYPE_URL media_type = MediaType.URL
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 = play_item.url media_id = play_item.url
if media_type != MEDIA_TYPE_URL: if media_type != MediaType.URL:
_LOGGER.warning("Unsupported media_type: %s", media_type) _LOGGER.warning("Unsupported media_type: %s", media_type)
return return

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

@ -14,8 +14,9 @@ from homeassistant import util
from homeassistant.components.media_player import ( from homeassistant.components.media_player import (
MediaPlayerEntity, MediaPlayerEntity,
MediaPlayerEntityFeature, MediaPlayerEntityFeature,
MediaPlayerState,
MediaType,
) )
from homeassistant.components.media_player.const import MEDIA_TYPE_MUSIC
from homeassistant.const import ( from homeassistant.const import (
EVENT_HOMEASSISTANT_STOP, EVENT_HOMEASSISTANT_STOP,
SERVICE_MEDIA_NEXT_TRACK, SERVICE_MEDIA_NEXT_TRACK,
@ -23,10 +24,6 @@ from homeassistant.const import (
SERVICE_MEDIA_PLAY_PAUSE, SERVICE_MEDIA_PLAY_PAUSE,
SERVICE_VOLUME_DOWN, SERVICE_VOLUME_DOWN,
SERVICE_VOLUME_UP, SERVICE_VOLUME_UP,
STATE_IDLE,
STATE_OFF,
STATE_PAUSED,
STATE_PLAYING,
) )
from homeassistant.core import HomeAssistant from homeassistant.core import HomeAssistant
from homeassistant.helpers.entity_platform import AddEntitiesCallback from homeassistant.helpers.entity_platform import AddEntitiesCallback
@ -70,6 +67,7 @@ def setup_platform(
class PandoraMediaPlayer(MediaPlayerEntity): class PandoraMediaPlayer(MediaPlayerEntity):
"""A media player that uses the Pianobar interface to Pandora.""" """A media player that uses the Pianobar interface to Pandora."""
_attr_media_content_type = MediaType.MUSIC
# MediaPlayerEntityFeature.VOLUME_SET is close to available but we need volume up/down # MediaPlayerEntityFeature.VOLUME_SET is close to available but we need volume up/down
# controls in the GUI. # controls in the GUI.
_attr_supported_features = ( _attr_supported_features = (
@ -84,7 +82,7 @@ class PandoraMediaPlayer(MediaPlayerEntity):
def __init__(self, name): def __init__(self, name):
"""Initialize the Pandora device.""" """Initialize the Pandora device."""
self._name = name self._name = name
self._player_state = STATE_OFF self._player_state = MediaPlayerState.OFF
self._station = "" self._station = ""
self._media_title = "" self._media_title = ""
self._media_artist = "" self._media_artist = ""
@ -106,7 +104,7 @@ class PandoraMediaPlayer(MediaPlayerEntity):
def turn_on(self) -> None: def turn_on(self) -> None:
"""Turn the media player on.""" """Turn the media player on."""
if self._player_state != STATE_OFF: if self._player_state != MediaPlayerState.OFF:
return return
self._pianobar = pexpect.spawn("pianobar") self._pianobar = pexpect.spawn("pianobar")
_LOGGER.info("Started pianobar subprocess") _LOGGER.info("Started pianobar subprocess")
@ -131,7 +129,7 @@ class PandoraMediaPlayer(MediaPlayerEntity):
self._update_stations() self._update_stations()
self.update_playing_status() self.update_playing_status()
self._player_state = STATE_IDLE self._player_state = MediaPlayerState.IDLE
self.schedule_update_ha_state() self.schedule_update_ha_state()
def turn_off(self) -> None: def turn_off(self) -> None:
@ -148,19 +146,19 @@ class PandoraMediaPlayer(MediaPlayerEntity):
os.killpg(os.getpgid(self._pianobar.pid), signal.SIGTERM) os.killpg(os.getpgid(self._pianobar.pid), signal.SIGTERM)
_LOGGER.debug("Killed Pianobar subprocess") _LOGGER.debug("Killed Pianobar subprocess")
self._pianobar = None self._pianobar = None
self._player_state = STATE_OFF self._player_state = MediaPlayerState.OFF
self.schedule_update_ha_state() self.schedule_update_ha_state()
def media_play(self) -> None: def media_play(self) -> None:
"""Send play command.""" """Send play command."""
self._send_pianobar_command(SERVICE_MEDIA_PLAY_PAUSE) self._send_pianobar_command(SERVICE_MEDIA_PLAY_PAUSE)
self._player_state = STATE_PLAYING self._player_state = MediaPlayerState.PLAYING
self.schedule_update_ha_state() self.schedule_update_ha_state()
def media_pause(self) -> None: def media_pause(self) -> None:
"""Send pause command.""" """Send pause command."""
self._send_pianobar_command(SERVICE_MEDIA_PLAY_PAUSE) self._send_pianobar_command(SERVICE_MEDIA_PLAY_PAUSE)
self._player_state = STATE_PAUSED self._player_state = MediaPlayerState.PAUSED
self.schedule_update_ha_state() self.schedule_update_ha_state()
def media_next_track(self) -> None: def media_next_track(self) -> None:
@ -184,11 +182,6 @@ class PandoraMediaPlayer(MediaPlayerEntity):
self.update_playing_status() self.update_playing_status()
return self._media_title return self._media_title
@property
def media_content_type(self):
"""Content type of current playing media."""
return MEDIA_TYPE_MUSIC
@property @property
def media_artist(self): def media_artist(self):
"""Artist of current playing media, music track only.""" """Artist of current playing media, music track only."""
@ -215,7 +208,7 @@ class PandoraMediaPlayer(MediaPlayerEntity):
self._send_station_list_command() self._send_station_list_command()
self._pianobar.sendline(f"{station_index}") self._pianobar.sendline(f"{station_index}")
self._pianobar.expect("\r\n") self._pianobar.expect("\r\n")
self._player_state = STATE_PLAYING self._player_state = MediaPlayerState.PLAYING
def _send_station_list_command(self): def _send_station_list_command(self):
"""Send a station list command.""" """Send a station list command."""
@ -312,9 +305,9 @@ class PandoraMediaPlayer(MediaPlayerEntity):
self._media_duration = int(total_minutes) * 60 + int(total_seconds) self._media_duration = int(total_minutes) * 60 + int(total_seconds)
if time_remaining not in (self._time_remaining, self._media_duration): if time_remaining not in (self._time_remaining, self._media_duration):
self._player_state = STATE_PLAYING self._player_state = MediaPlayerState.PLAYING
elif self._player_state == STATE_PLAYING: elif self._player_state == MediaPlayerState.PLAYING:
self._player_state = STATE_PAUSED self._player_state = MediaPlayerState.PAUSED
self._time_remaining = time_remaining self._time_remaining = time_remaining
def _log_match(self): def _log_match(self):

91
homeassistant/components/philips_js/media_player.py
View File

@ -6,23 +6,16 @@ from typing import Any
from haphilipsjs import ConnectionFailure from haphilipsjs import ConnectionFailure
from homeassistant.components.media_player import ( from homeassistant.components.media_player import (
BrowseError,
BrowseMedia, BrowseMedia,
MediaClass,
MediaPlayerDeviceClass, MediaPlayerDeviceClass,
MediaPlayerEntity, MediaPlayerEntity,
MediaPlayerEntityFeature, MediaPlayerEntityFeature,
MediaPlayerState,
MediaType,
) )
from homeassistant.components.media_player.const import (
MEDIA_CLASS_APP,
MEDIA_CLASS_CHANNEL,
MEDIA_CLASS_DIRECTORY,
MEDIA_TYPE_APP,
MEDIA_TYPE_APPS,
MEDIA_TYPE_CHANNEL,
MEDIA_TYPE_CHANNELS,
)
from homeassistant.components.media_player.errors import BrowseError
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 +89,7 @@ class PhilipsTVMediaPlayer(
sw_version=coordinator.system.get("softwareversion"), sw_version=coordinator.system.get("softwareversion"),
name=coordinator.system["name"], name=coordinator.system["name"],
) )
self._state = STATE_OFF self._state = MediaPlayerState.OFF
self._media_content_type: str | None = None self._media_content_type: str | None = None
self._media_content_id: str | None = None self._media_content_id: str | None = None
self._media_title: str | None = None self._media_title: str | None = None
@ -121,11 +114,11 @@ class PhilipsTVMediaPlayer(
return supports return supports
@property @property
def state(self): def state(self) -> MediaPlayerState:
"""Get the device state. An exception means OFF state.""" """Get the device state. An exception means OFF state."""
if self._tv.on and (self._tv.powerstate == "On" or self._tv.powerstate is None): if self._tv.on and (self._tv.powerstate == "On" or self._tv.powerstate is None):
return STATE_ON return MediaPlayerState.ON
return STATE_OFF return MediaPlayerState.OFF
@property @property
def source(self): def source(self):
@ -157,16 +150,16 @@ class PhilipsTVMediaPlayer(
"""Turn on the device.""" """Turn on the device."""
if self._tv.on and self._tv.powerstate: if self._tv.on and self._tv.powerstate:
await self._tv.setPowerState("On") await self._tv.setPowerState("On")
self._state = STATE_ON self._state = MediaPlayerState.ON
else: else:
await self.coordinator.turn_on.async_run(self.hass, self._context) await self.coordinator.turn_on.async_run(self.hass, self._context)
await self._async_update_soon() await self._async_update_soon()
async def async_turn_off(self) -> None: async def async_turn_off(self) -> None:
"""Turn off the device.""" """Turn off the device."""
if self._state == STATE_ON: if self._state == MediaPlayerState.ON:
await self._tv.sendKey("Standby") await self._tv.sendKey("Standby")
self._state = STATE_OFF self._state = MediaPlayerState.OFF
await self._async_update_soon() await self._async_update_soon()
else: else:
_LOGGER.debug("Ignoring turn off when already in expected state") _LOGGER.debug("Ignoring turn off when already in expected state")
@ -251,8 +244,8 @@ class PhilipsTVMediaPlayer(
def media_image_url(self): def media_image_url(self):
"""Image url of current playing media.""" """Image url of current playing media."""
if self._media_content_id and self._media_content_type in ( if self._media_content_id and self._media_content_type in (
MEDIA_TYPE_APP, MediaType.APP,
MEDIA_TYPE_CHANNEL, MediaType.CHANNEL,
): ):
return self.get_browse_image_url( return self.get_browse_image_url(
self._media_content_type, self._media_content_id, media_image_id=None self._media_content_type, self._media_content_id, media_image_id=None
@ -276,14 +269,14 @@ class PhilipsTVMediaPlayer(
"""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:
list_id, _, channel_id = media_id.partition("/") list_id, _, channel_id = media_id.partition("/")
if channel_id: if channel_id:
await self._tv.setChannel(channel_id, list_id) await self._tv.setChannel(channel_id, list_id)
await self._async_update_soon() await self._async_update_soon()
else: else:
_LOGGER.error("Unable to find channel <%s>", media_id) _LOGGER.error("Unable to find channel <%s>", media_id)
elif media_type == MEDIA_TYPE_APP: elif media_type == MediaType.APP:
if app := self._tv.applications.get(media_id): if app := self._tv.applications.get(media_id):
await self._tv.setApplication(app["intent"]) await self._tv.setApplication(app["intent"])
await self._async_update_soon() await self._async_update_soon()
@ -298,9 +291,9 @@ class PhilipsTVMediaPlayer(
children = [ children = [
BrowseMedia( BrowseMedia(
title=channel.get("name", f"Channel: {channel_id}"), title=channel.get("name", f"Channel: {channel_id}"),
media_class=MEDIA_CLASS_CHANNEL, media_class=MediaClass.CHANNEL,
media_content_id=f"alltv/{channel_id}", media_content_id=f"alltv/{channel_id}",
media_content_type=MEDIA_TYPE_CHANNEL, media_content_type=MediaType.CHANNEL,
can_play=True, can_play=True,
can_expand=False, can_expand=False,
) )
@ -311,10 +304,10 @@ class PhilipsTVMediaPlayer(
return BrowseMedia( return BrowseMedia(
title="Channels", title="Channels",
media_class=MEDIA_CLASS_DIRECTORY, media_class=MediaClass.DIRECTORY,
media_content_id="channels", media_content_id="channels",
media_content_type=MEDIA_TYPE_CHANNELS, media_content_type=MediaType.CHANNELS,
children_media_class=MEDIA_CLASS_CHANNEL, children_media_class=MediaClass.CHANNEL,
can_play=False, can_play=False,
can_expand=True, can_expand=True,
children=children, children=children,
@ -335,9 +328,9 @@ class PhilipsTVMediaPlayer(
children = [ children = [
BrowseMedia( BrowseMedia(
title=get_name(channel), title=get_name(channel),
media_class=MEDIA_CLASS_CHANNEL, media_class=MediaClass.CHANNEL,
media_content_id=f"{list_id}/{channel['ccid']}", media_content_id=f"{list_id}/{channel['ccid']}",
media_content_type=MEDIA_TYPE_CHANNEL, media_content_type=MediaType.CHANNEL,
can_play=True, can_play=True,
can_expand=False, can_expand=False,
) )
@ -351,10 +344,10 @@ class PhilipsTVMediaPlayer(
favorite = self._tv.favorite_lists[list_id] favorite = self._tv.favorite_lists[list_id]
return BrowseMedia( return BrowseMedia(
title=favorite.get("name", f"Favorites {list_id}"), title=favorite.get("name", f"Favorites {list_id}"),
media_class=MEDIA_CLASS_DIRECTORY, media_class=MediaClass.DIRECTORY,
media_content_id=f"favorites/{list_id}", media_content_id=f"favorites/{list_id}",
media_content_type=MEDIA_TYPE_CHANNELS, media_content_type=MediaType.CHANNELS,
children_media_class=MEDIA_CLASS_CHANNEL, children_media_class=MediaClass.CHANNEL,
can_play=False, can_play=False,
can_expand=True, can_expand=True,
children=children, children=children,
@ -366,13 +359,13 @@ class PhilipsTVMediaPlayer(
children = [ children = [
BrowseMedia( BrowseMedia(
title=application["label"], title=application["label"],
media_class=MEDIA_CLASS_APP, media_class=MediaClass.APP,
media_content_id=application_id, media_content_id=application_id,
media_content_type=MEDIA_TYPE_APP, media_content_type=MediaType.APP,
can_play=True, can_play=True,
can_expand=False, can_expand=False,
thumbnail=self.get_browse_image_url( thumbnail=self.get_browse_image_url(
MEDIA_TYPE_APP, application_id, media_image_id=None MediaType.APP, application_id, media_image_id=None
), ),
) )
for application_id, application in self._tv.applications.items() for application_id, application in self._tv.applications.items()
@ -382,10 +375,10 @@ class PhilipsTVMediaPlayer(
return BrowseMedia( return BrowseMedia(
title="Applications", title="Applications",
media_class=MEDIA_CLASS_DIRECTORY, media_class=MediaClass.DIRECTORY,
media_content_id="applications", media_content_id="applications",
media_content_type=MEDIA_TYPE_APPS, media_content_type=MediaType.APPS,
children_media_class=MEDIA_CLASS_APP, children_media_class=MediaClass.APP,
can_play=False, can_play=False,
can_expand=True, can_expand=True,
children=children, children=children,
@ -403,10 +396,10 @@ class PhilipsTVMediaPlayer(
return BrowseMedia( return BrowseMedia(
title="Favorites", title="Favorites",
media_class=MEDIA_CLASS_DIRECTORY, media_class=MediaClass.DIRECTORY,
media_content_id="favorite_lists", media_content_id="favorite_lists",
media_content_type=MEDIA_TYPE_CHANNELS, media_content_type=MediaType.CHANNELS,
children_media_class=MEDIA_CLASS_CHANNEL, children_media_class=MediaClass.CHANNEL,
can_play=False, can_play=False,
can_expand=True, can_expand=True,
children=children, children=children,
@ -417,7 +410,7 @@ class PhilipsTVMediaPlayer(
return BrowseMedia( return BrowseMedia(
title="Philips TV", title="Philips TV",
media_class=MEDIA_CLASS_DIRECTORY, media_class=MediaClass.DIRECTORY,
media_content_id="", media_content_id="",
media_content_type="", media_content_type="",
can_play=False, can_play=False,
@ -456,9 +449,9 @@ class PhilipsTVMediaPlayer(
) -> tuple[bytes | None, str | None]: ) -> tuple[bytes | None, str | None]:
"""Serve album art. Returns (content, content_type).""" """Serve album art. Returns (content, content_type)."""
try: try:
if media_content_type == MEDIA_TYPE_APP and media_content_id: if media_content_type == MediaType.APP and media_content_id:
return await self._tv.getApplicationIcon(media_content_id) return await self._tv.getApplicationIcon(media_content_id)
if media_content_type == MEDIA_TYPE_CHANNEL and media_content_id: if media_content_type == MediaType.CHANNEL and media_content_id:
return await self._tv.getChannelLogo(media_content_id) return await self._tv.getChannelLogo(media_content_id)
except ConnectionFailure: except ConnectionFailure:
_LOGGER.warning("Failed to fetch image") _LOGGER.warning("Failed to fetch image")
@ -475,11 +468,11 @@ class PhilipsTVMediaPlayer(
if self._tv.on: if self._tv.on:
if self._tv.powerstate in ("Standby", "StandbyKeep"): if self._tv.powerstate in ("Standby", "StandbyKeep"):
self._state = STATE_OFF self._state = MediaPlayerState.OFF
else: else:
self._state = STATE_ON self._state = MediaPlayerState.ON
else: else:
self._state = STATE_OFF self._state = MediaPlayerState.OFF
self._sources = { self._sources = {
srcid: source.get("name") or f"Source {srcid}" srcid: source.get("name") or f"Source {srcid}"
@ -487,14 +480,14 @@ class PhilipsTVMediaPlayer(
} }
if self._tv.channel_active: if self._tv.channel_active:
self._media_content_type = MEDIA_TYPE_CHANNEL self._media_content_type = MediaType.CHANNEL
self._media_content_id = f"all/{self._tv.channel_id}" self._media_content_id = f"all/{self._tv.channel_id}"
self._media_title = self._tv.channels.get(self._tv.channel_id, {}).get( self._media_title = self._tv.channels.get(self._tv.channel_id, {}).get(
"name" "name"
) )
self._media_channel = self._media_title self._media_channel = self._media_title
elif self._tv.application_id: elif self._tv.application_id:
self._media_content_type = MEDIA_TYPE_APP self._media_content_type = MediaType.APP
self._media_content_id = self._tv.application_id self._media_content_id = self._tv.application_id
self._media_title = self._tv.applications.get( self._media_title = self._tv.applications.get(
self._tv.application_id, {} self._tv.application_id, {}

18
homeassistant/components/pioneer/media_player.py
View File

@ -10,15 +10,9 @@ from homeassistant.components.media_player import (
PLATFORM_SCHEMA, PLATFORM_SCHEMA,
MediaPlayerEntity, MediaPlayerEntity,
MediaPlayerEntityFeature, MediaPlayerEntityFeature,
MediaPlayerState,
) )
from homeassistant.const import ( from homeassistant.const import CONF_HOST, CONF_NAME, CONF_PORT, CONF_TIMEOUT
CONF_HOST,
CONF_NAME,
CONF_PORT,
CONF_TIMEOUT,
STATE_OFF,
STATE_ON,
)
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
@ -174,14 +168,14 @@ class PioneerDevice(MediaPlayerEntity):
return self._name return self._name
@property @property
def state(self): def state(self) -> MediaPlayerState | None:
"""Return the state of the device.""" """Return the state of the device."""
if self._pwstate == "PWR2": if self._pwstate == "PWR2":
return STATE_OFF return MediaPlayerState.OFF
if self._pwstate == "PWR1": if self._pwstate == "PWR1":
return STATE_OFF return MediaPlayerState.OFF
if self._pwstate == "PWR0": if self._pwstate == "PWR0":
return STATE_ON return MediaPlayerState.ON
return None return None

20
homeassistant/components/pjlink/media_player.py
View File

@ -9,15 +9,9 @@ from homeassistant.components.media_player import (
PLATFORM_SCHEMA, PLATFORM_SCHEMA,
MediaPlayerEntity, MediaPlayerEntity,
MediaPlayerEntityFeature, MediaPlayerEntityFeature,
MediaPlayerState,
) )
from homeassistant.const import ( from homeassistant.const import CONF_HOST, CONF_NAME, CONF_PASSWORD, CONF_PORT
CONF_HOST,
CONF_NAME,
CONF_PASSWORD,
CONF_PORT,
STATE_OFF,
STATE_ON,
)
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
@ -89,7 +83,7 @@ class PjLinkDevice(MediaPlayerEntity):
self._password = password self._password = password
self._encoding = encoding self._encoding = encoding
self._muted = False self._muted = False
self._pwstate = STATE_OFF self._pwstate = MediaPlayerState.OFF
self._current_source = None self._current_source = None
with self.projector() as projector: with self.projector() as projector:
if not self._name: if not self._name:
@ -114,23 +108,23 @@ class PjLinkDevice(MediaPlayerEntity):
try: try:
pwstate = projector.get_power() pwstate = projector.get_power()
if pwstate in ("on", "warm-up"): if pwstate in ("on", "warm-up"):
self._pwstate = STATE_ON self._pwstate = MediaPlayerState.ON
self._muted = projector.get_mute()[1] self._muted = projector.get_mute()[1]
self._current_source = format_input_source(*projector.get_input()) self._current_source = format_input_source(*projector.get_input())
else: else:
self._pwstate = STATE_OFF self._pwstate = MediaPlayerState.OFF
self._muted = False self._muted = False
self._current_source = None self._current_source = None
except KeyError as err: except KeyError as err:
if str(err) == "'OK'": if str(err) == "'OK'":
self._pwstate = STATE_OFF self._pwstate = MediaPlayerState.OFF
self._muted = False self._muted = False
self._current_source = None self._current_source = None
else: else:
raise raise
except ProjectorError as err: except ProjectorError as err:
if str(err) == "unavailable time": if str(err) == "unavailable time":
self._pwstate = STATE_OFF self._pwstate = MediaPlayerState.OFF
self._muted = False self._muted = False
self._current_source = None self._current_source = None
else: else:

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

@ -12,13 +12,13 @@ from typing_extensions import Concatenate, ParamSpec
from homeassistant.components.media_player import ( from homeassistant.components.media_player import (
DOMAIN as MP_DOMAIN, DOMAIN as MP_DOMAIN,
BrowseMedia,
MediaPlayerEntity, MediaPlayerEntity,
MediaPlayerEntityFeature, MediaPlayerEntityFeature,
MediaPlayerState,
MediaType,
) )
from homeassistant.components.media_player.browse_media import BrowseMedia
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_PAUSED, 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 import entity_registry as er from homeassistant.helpers import entity_registry as er
@ -140,7 +140,7 @@ class PlexMediaPlayer(MediaPlayerEntity):
self._attr_available = False self._attr_available = False
self._attr_should_poll = False self._attr_should_poll = False
self._attr_state = STATE_IDLE self._attr_state = MediaPlayerState.IDLE
self._attr_unique_id = ( self._attr_unique_id = (
f"{self.plex_server.machine_identifier}:{self.machine_identifier}" f"{self.plex_server.machine_identifier}:{self.machine_identifier}"
) )
@ -229,7 +229,7 @@ class PlexMediaPlayer(MediaPlayerEntity):
def force_idle(self): def force_idle(self):
"""Force client to idle.""" """Force client to idle."""
self._attr_state = STATE_IDLE self._attr_state = MediaPlayerState.IDLE
if self.player_source == "session": if self.player_source == "session":
self.device = None self.device = None
self.session_device = None self.session_device = None
@ -247,7 +247,7 @@ class PlexMediaPlayer(MediaPlayerEntity):
self.session_device = self.session.player self.session_device = self.session.player
self.update_state(self.session.state) self.update_state(self.session.state)
else: else:
self._attr_state = STATE_IDLE self._attr_state = MediaPlayerState.IDLE
@property # type: ignore[misc] @property # type: ignore[misc]
@needs_session @needs_session
@ -258,24 +258,24 @@ class PlexMediaPlayer(MediaPlayerEntity):
def update_state(self, state): def update_state(self, state):
"""Set the state of the device, handle session termination.""" """Set the state of the device, handle session termination."""
if state == "playing": if state == "playing":
self._attr_state = STATE_PLAYING self._attr_state = MediaPlayerState.PLAYING
elif state == "paused": elif state == "paused":
self._attr_state = STATE_PAUSED self._attr_state = MediaPlayerState.PAUSED
elif state == "stopped": elif state == "stopped":
self.session = None self.session = None
self.force_idle() self.force_idle()
else: else:
self._attr_state = STATE_IDLE self._attr_state = MediaPlayerState.IDLE
@property @property
def _is_player_active(self): def _is_player_active(self):
"""Report if the client is playing media.""" """Report if the client is playing media."""
return self.state in (STATE_PLAYING, STATE_PAUSED) return self.state in {MediaPlayerState.PLAYING, MediaPlayerState.PAUSED}
@property @property
def _active_media_plexapi_type(self): def _active_media_plexapi_type(self):
"""Get the active media type required by PlexAPI commands.""" """Get the active media type required by PlexAPI commands."""
if self.media_content_type is MEDIA_TYPE_MUSIC: if self.media_content_type == MediaType.MUSIC:
return "music" return "music"
return "video" return "video"

29
homeassistant/components/ps4/media_player.py
View File

@ -8,14 +8,12 @@ from pyps4_2ndscreen.media_art import TYPE_APP as PS_TYPE_APP
import pyps4_2ndscreen.ps4 as pyps4 import pyps4_2ndscreen.ps4 as pyps4
from homeassistant.components.media_player import ( from homeassistant.components.media_player import (
MediaPlayerEntity,
MediaPlayerEntityFeature,
)
from homeassistant.components.media_player.const import (
ATTR_MEDIA_CONTENT_TYPE, ATTR_MEDIA_CONTENT_TYPE,
ATTR_MEDIA_TITLE, ATTR_MEDIA_TITLE,
MEDIA_TYPE_APP, MediaPlayerEntity,
MEDIA_TYPE_GAME, MediaPlayerEntityFeature,
MediaPlayerState,
MediaType,
) )
from homeassistant.config_entries import ConfigEntry from homeassistant.config_entries import ConfigEntry
from homeassistant.const import ( from homeassistant.const import (
@ -24,9 +22,6 @@ from homeassistant.const import (
CONF_NAME, CONF_NAME,
CONF_REGION, CONF_REGION,
CONF_TOKEN, CONF_TOKEN,
STATE_IDLE,
STATE_PLAYING,
STATE_STANDBY,
) )
from homeassistant.core import HomeAssistant, callback from homeassistant.core import HomeAssistant, callback
from homeassistant.helpers import device_registry, entity_registry from homeassistant.helpers import device_registry, entity_registry
@ -177,7 +172,7 @@ class PS4Device(MediaPlayerEntity):
name = status.get("running-app-name") name = status.get("running-app-name")
if title_id and name is not None: if title_id and name is not None:
self._state = STATE_PLAYING self._state = MediaPlayerState.PLAYING
if self._media_content_id != title_id: if self._media_content_id != title_id:
self._media_content_id = title_id self._media_content_id = title_id
@ -191,10 +186,10 @@ class PS4Device(MediaPlayerEntity):
# Get data from PS Store. # Get data from PS Store.
asyncio.ensure_future(self.async_get_title_data(title_id, name)) asyncio.ensure_future(self.async_get_title_data(title_id, name))
else: else:
if self._state != STATE_IDLE: if self._state != MediaPlayerState.IDLE:
self.idle() self.idle()
else: else:
if self._state != STATE_STANDBY: if self._state != MediaPlayerState.STANDBY:
self.state_standby() self.state_standby()
elif self._retry > DEFAULT_RETRIES: elif self._retry > DEFAULT_RETRIES:
@ -219,12 +214,12 @@ class PS4Device(MediaPlayerEntity):
def idle(self): def idle(self):
"""Set states for state idle.""" """Set states for state idle."""
self.reset_title() self.reset_title()
self._state = STATE_IDLE self._state = MediaPlayerState.IDLE
def state_standby(self): def state_standby(self):
"""Set states for state standby.""" """Set states for state standby."""
self.reset_title() self.reset_title()
self._state = STATE_STANDBY self._state = MediaPlayerState.STANDBY
def state_unknown(self): def state_unknown(self):
"""Set states for state unknown.""" """Set states for state unknown."""
@ -265,9 +260,9 @@ class PS4Device(MediaPlayerEntity):
art = title.cover_art art = title.cover_art
# Assume media type is game if not app. # Assume media type is game if not app.
if title.game_type != PS_TYPE_APP: if title.game_type != PS_TYPE_APP:
media_type = MEDIA_TYPE_GAME media_type = MediaType.GAME
else: else:
media_type = MEDIA_TYPE_APP media_type = MediaType.APP
else: else:
_LOGGER.error( _LOGGER.error(
"Could not find data in region: %s for PS ID: %s", "Could not find data in region: %s for PS ID: %s",
@ -382,7 +377,7 @@ class PS4Device(MediaPlayerEntity):
def entity_picture(self): def entity_picture(self):
"""Return picture.""" """Return picture."""
if ( if (
self._state == STATE_PLAYING self._state == MediaPlayerState.PLAYING
and self._media_content_id is not None and self._media_content_id is not None
and (image_hash := self.media_image_hash) is not None and (image_hash := self.media_image_hash) is not None
): ):