jeans/core
jeans/core
1
0
Fork 0
mirror of https://github.com/home-assistant/core.git synced 2025-07-23 05:07:41 +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,
MediaPlayerEntity,
MediaPlayerEntityFeature,
MediaPlayerState,
)
from homeassistant.const import (
CONF_HOST,
CONF_NAME,
STATE_IDLE,
STATE_OFF,
STATE_PLAYING,
)
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
@ -65,7 +60,7 @@ class PanasonicBluRay(MediaPlayerEntity):
"""Initialize the Panasonic Blue-ray device."""
self._device = PanasonicBD(ip)
self._name = name
self._state = STATE_OFF
self._state = MediaPlayerState.OFF
self._position = 0
self._duration = 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
# turn it on, but from standby we can go to idle by pressing
# POWER.
self._state = STATE_OFF
self._state = MediaPlayerState.OFF
elif state[0] in ["paused", "stopped"]:
self._state = STATE_IDLE
self._state = MediaPlayerState.IDLE
elif state[0] == "playing":
self._state = STATE_PLAYING
self._state = MediaPlayerState.PLAYING
# Update our current media position + length
if state[1] >= 0:
@ -134,17 +129,17 @@ class PanasonicBluRay(MediaPlayerEntity):
our favour as it means the device is still accepting commands and we
can thus turn it back on when desired.
"""
if self._state != STATE_OFF:
if self._state != MediaPlayerState.OFF:
self._device.send_key("POWER")
self._state = STATE_OFF
self._state = MediaPlayerState.OFF
def turn_on(self) -> None:
"""Wake the device back up from standby."""
if self._state == STATE_OFF:
if self._state == MediaPlayerState.OFF:
self._device.send_key("POWER")
self._state = STATE_IDLE
self._state = MediaPlayerState.IDLE
def media_play(self) -> None:
"""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.media_player import (
BrowseMedia,
MediaPlayerDeviceClass,
MediaPlayerEntity,
MediaPlayerEntityFeature,
)
from homeassistant.components.media_player.browse_media import (
BrowseMedia,
MediaType,
async_process_play_media_url,
)
from homeassistant.components.media_player.const import MEDIA_TYPE_URL
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import CONF_NAME
from homeassistant.core import HomeAssistant
@ -191,13 +189,13 @@ class PanasonicVieraTVEntity(MediaPlayerEntity):
) -> None:
"""Play media."""
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(
self.hass, media_id, self.entity_id
)
media_id = play_item.url
if media_type != MEDIA_TYPE_URL:
if media_type != MediaType.URL:
_LOGGER.warning("Unsupported media_type: %s", media_type)
return

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

@ -14,8 +14,9 @@ from homeassistant import util
from homeassistant.components.media_player import (
MediaPlayerEntity,
MediaPlayerEntityFeature,
MediaPlayerState,
MediaType,
)
from homeassistant.components.media_player.const import MEDIA_TYPE_MUSIC
from homeassistant.const import (
EVENT_HOMEASSISTANT_STOP,
SERVICE_MEDIA_NEXT_TRACK,
@ -23,10 +24,6 @@ from homeassistant.const import (
SERVICE_MEDIA_PLAY_PAUSE,
SERVICE_VOLUME_DOWN,
SERVICE_VOLUME_UP,
STATE_IDLE,
STATE_OFF,
STATE_PAUSED,
STATE_PLAYING,
)
from homeassistant.core import HomeAssistant
from homeassistant.helpers.entity_platform import AddEntitiesCallback
@ -70,6 +67,7 @@ def setup_platform(
class PandoraMediaPlayer(MediaPlayerEntity):
"""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
# controls in the GUI.
_attr_supported_features = (
@ -84,7 +82,7 @@ class PandoraMediaPlayer(MediaPlayerEntity):
def __init__(self, name):
"""Initialize the Pandora device."""
self._name = name
self._player_state = STATE_OFF
self._player_state = MediaPlayerState.OFF
self._station = ""
self._media_title = ""
self._media_artist = ""
@ -106,7 +104,7 @@ class PandoraMediaPlayer(MediaPlayerEntity):
def turn_on(self) -> None:
"""Turn the media player on."""
if self._player_state != STATE_OFF:
if self._player_state != MediaPlayerState.OFF:
return
self._pianobar = pexpect.spawn("pianobar")
_LOGGER.info("Started pianobar subprocess")
@ -131,7 +129,7 @@ class PandoraMediaPlayer(MediaPlayerEntity):
self._update_stations()
self.update_playing_status()
self._player_state = STATE_IDLE
self._player_state = MediaPlayerState.IDLE
self.schedule_update_ha_state()
def turn_off(self) -> None:
@ -148,19 +146,19 @@ class PandoraMediaPlayer(MediaPlayerEntity):
os.killpg(os.getpgid(self._pianobar.pid), signal.SIGTERM)
_LOGGER.debug("Killed Pianobar subprocess")
self._pianobar = None
self._player_state = STATE_OFF
self._player_state = MediaPlayerState.OFF
self.schedule_update_ha_state()
def media_play(self) -> None:
"""Send play command."""
self._send_pianobar_command(SERVICE_MEDIA_PLAY_PAUSE)
self._player_state = STATE_PLAYING
self._player_state = MediaPlayerState.PLAYING
self.schedule_update_ha_state()
def media_pause(self) -> None:
"""Send pause command."""
self._send_pianobar_command(SERVICE_MEDIA_PLAY_PAUSE)
self._player_state = STATE_PAUSED
self._player_state = MediaPlayerState.PAUSED
self.schedule_update_ha_state()
def media_next_track(self) -> None:
@ -184,11 +182,6 @@ class PandoraMediaPlayer(MediaPlayerEntity):
self.update_playing_status()
return self._media_title
@property
def media_content_type(self):
"""Content type of current playing media."""
return MEDIA_TYPE_MUSIC
@property
def media_artist(self):
"""Artist of current playing media, music track only."""
@ -215,7 +208,7 @@ class PandoraMediaPlayer(MediaPlayerEntity):
self._send_station_list_command()
self._pianobar.sendline(f"{station_index}")
self._pianobar.expect("\r\n")
self._player_state = STATE_PLAYING
self._player_state = MediaPlayerState.PLAYING
def _send_station_list_command(self):
"""Send a station list command."""
@ -312,9 +305,9 @@ class PandoraMediaPlayer(MediaPlayerEntity):
self._media_duration = int(total_minutes) * 60 + int(total_seconds)
if time_remaining not in (self._time_remaining, self._media_duration):
self._player_state = STATE_PLAYING
elif self._player_state == STATE_PLAYING:
self._player_state = STATE_PAUSED
self._player_state = MediaPlayerState.PLAYING
elif self._player_state == MediaPlayerState.PLAYING:
self._player_state = MediaPlayerState.PAUSED
self._time_remaining = time_remaining
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 homeassistant.components.media_player import (
BrowseError,
BrowseMedia,
MediaClass,
MediaPlayerDeviceClass,
MediaPlayerEntity,
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.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 +89,7 @@ class PhilipsTVMediaPlayer(
sw_version=coordinator.system.get("softwareversion"),
name=coordinator.system["name"],
)
self._state = STATE_OFF
self._state = MediaPlayerState.OFF
self._media_content_type: str | None = None
self._media_content_id: str | None = None
self._media_title: str | None = None
@ -121,11 +114,11 @@ class PhilipsTVMediaPlayer(
return supports
@property
def state(self):
def state(self) -> MediaPlayerState:
"""Get the device state. An exception means OFF state."""
if self._tv.on and (self._tv.powerstate == "On" or self._tv.powerstate is None):
return STATE_ON
return STATE_OFF
return MediaPlayerState.ON
return MediaPlayerState.OFF
@property
def source(self):
@ -157,16 +150,16 @@ class PhilipsTVMediaPlayer(
"""Turn on the device."""
if self._tv.on and self._tv.powerstate:
await self._tv.setPowerState("On")
self._state = STATE_ON
self._state = MediaPlayerState.ON
else:
await self.coordinator.turn_on.async_run(self.hass, self._context)
await self._async_update_soon()
async def async_turn_off(self) -> None:
"""Turn off the device."""
if self._state == STATE_ON:
if self._state == MediaPlayerState.ON:
await self._tv.sendKey("Standby")
self._state = STATE_OFF
self._state = MediaPlayerState.OFF
await self._async_update_soon()
else:
_LOGGER.debug("Ignoring turn off when already in expected state")
@ -251,8 +244,8 @@ class PhilipsTVMediaPlayer(
def media_image_url(self):
"""Image url of current playing media."""
if self._media_content_id and self._media_content_type in (
MEDIA_TYPE_APP,
MEDIA_TYPE_CHANNEL,
MediaType.APP,
MediaType.CHANNEL,
):
return self.get_browse_image_url(
self._media_content_type, self._media_content_id, media_image_id=None
@ -276,14 +269,14 @@ class PhilipsTVMediaPlayer(
"""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:
list_id, _, channel_id = media_id.partition("/")
if channel_id:
await self._tv.setChannel(channel_id, list_id)
await self._async_update_soon()
else:
_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):
await self._tv.setApplication(app["intent"])
await self._async_update_soon()
@ -298,9 +291,9 @@ class PhilipsTVMediaPlayer(
children = [
BrowseMedia(
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_type=MEDIA_TYPE_CHANNEL,
media_content_type=MediaType.CHANNEL,
can_play=True,
can_expand=False,
)
@ -311,10 +304,10 @@ class PhilipsTVMediaPlayer(
return BrowseMedia(
title="Channels",
media_class=MEDIA_CLASS_DIRECTORY,
media_class=MediaClass.DIRECTORY,
media_content_id="channels",
media_content_type=MEDIA_TYPE_CHANNELS,
children_media_class=MEDIA_CLASS_CHANNEL,
media_content_type=MediaType.CHANNELS,
children_media_class=MediaClass.CHANNEL,
can_play=False,
can_expand=True,
children=children,
@ -335,9 +328,9 @@ class PhilipsTVMediaPlayer(
children = [
BrowseMedia(
title=get_name(channel),
media_class=MEDIA_CLASS_CHANNEL,
media_class=MediaClass.CHANNEL,
media_content_id=f"{list_id}/{channel['ccid']}",
media_content_type=MEDIA_TYPE_CHANNEL,
media_content_type=MediaType.CHANNEL,
can_play=True,
can_expand=False,
)
@ -351,10 +344,10 @@ class PhilipsTVMediaPlayer(
favorite = self._tv.favorite_lists[list_id]
return BrowseMedia(
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_type=MEDIA_TYPE_CHANNELS,
children_media_class=MEDIA_CLASS_CHANNEL,
media_content_type=MediaType.CHANNELS,
children_media_class=MediaClass.CHANNEL,
can_play=False,
can_expand=True,
children=children,
@ -366,13 +359,13 @@ class PhilipsTVMediaPlayer(
children = [
BrowseMedia(
title=application["label"],
media_class=MEDIA_CLASS_APP,
media_class=MediaClass.APP,
media_content_id=application_id,
media_content_type=MEDIA_TYPE_APP,
media_content_type=MediaType.APP,
can_play=True,
can_expand=False,
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()
@ -382,10 +375,10 @@ class PhilipsTVMediaPlayer(
return BrowseMedia(
title="Applications",
media_class=MEDIA_CLASS_DIRECTORY,
media_class=MediaClass.DIRECTORY,
media_content_id="applications",
media_content_type=MEDIA_TYPE_APPS,
children_media_class=MEDIA_CLASS_APP,
media_content_type=MediaType.APPS,
children_media_class=MediaClass.APP,
can_play=False,
can_expand=True,
children=children,
@ -403,10 +396,10 @@ class PhilipsTVMediaPlayer(
return BrowseMedia(
title="Favorites",
media_class=MEDIA_CLASS_DIRECTORY,
media_class=MediaClass.DIRECTORY,
media_content_id="favorite_lists",
media_content_type=MEDIA_TYPE_CHANNELS,
children_media_class=MEDIA_CLASS_CHANNEL,
media_content_type=MediaType.CHANNELS,
children_media_class=MediaClass.CHANNEL,
can_play=False,
can_expand=True,
children=children,
@ -417,7 +410,7 @@ class PhilipsTVMediaPlayer(
return BrowseMedia(
title="Philips TV",
media_class=MEDIA_CLASS_DIRECTORY,
media_class=MediaClass.DIRECTORY,
media_content_id="",
media_content_type="",
can_play=False,
@ -456,9 +449,9 @@ class PhilipsTVMediaPlayer(
) -> tuple[bytes | None, str | None]:
"""Serve album art. Returns (content, content_type)."""
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)
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)
except ConnectionFailure:
_LOGGER.warning("Failed to fetch image")
@ -475,11 +468,11 @@ class PhilipsTVMediaPlayer(
if self._tv.on:
if self._tv.powerstate in ("Standby", "StandbyKeep"):
self._state = STATE_OFF
self._state = MediaPlayerState.OFF
else:
self._state = STATE_ON
self._state = MediaPlayerState.ON
else:
self._state = STATE_OFF
self._state = MediaPlayerState.OFF
self._sources = {
srcid: source.get("name") or f"Source {srcid}"
@ -487,14 +480,14 @@ class PhilipsTVMediaPlayer(
}
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_title = self._tv.channels.get(self._tv.channel_id, {}).get(
"name"
)
self._media_channel = self._media_title
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_title = self._tv.applications.get(
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,
MediaPlayerEntity,
MediaPlayerEntityFeature,
MediaPlayerState,
)
from homeassistant.const import (
CONF_HOST,
CONF_NAME,
CONF_PORT,
CONF_TIMEOUT,
STATE_OFF,
STATE_ON,
)
from homeassistant.const import CONF_HOST, CONF_NAME, CONF_PORT, CONF_TIMEOUT
from homeassistant.core import HomeAssistant
import homeassistant.helpers.config_validation as cv
from homeassistant.helpers.entity_platform import AddEntitiesCallback
@ -174,14 +168,14 @@ class PioneerDevice(MediaPlayerEntity):
return self._name
@property
def state(self):
def state(self) -> MediaPlayerState | None:
"""Return the state of the device."""
if self._pwstate == "PWR2":
return STATE_OFF
return MediaPlayerState.OFF
if self._pwstate == "PWR1":
return STATE_OFF
return MediaPlayerState.OFF
if self._pwstate == "PWR0":
return STATE_ON
return MediaPlayerState.ON
return None

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

@ -9,15 +9,9 @@ from homeassistant.components.media_player import (
PLATFORM_SCHEMA,
MediaPlayerEntity,
MediaPlayerEntityFeature,
MediaPlayerState,
)
from homeassistant.const import (
CONF_HOST,
CONF_NAME,
CONF_PASSWORD,
CONF_PORT,
STATE_OFF,
STATE_ON,
)
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
@ -89,7 +83,7 @@ class PjLinkDevice(MediaPlayerEntity):
self._password = password
self._encoding = encoding
self._muted = False
self._pwstate = STATE_OFF
self._pwstate = MediaPlayerState.OFF
self._current_source = None
with self.projector() as projector:
if not self._name:
@ -114,23 +108,23 @@ class PjLinkDevice(MediaPlayerEntity):
try:
pwstate = projector.get_power()
if pwstate in ("on", "warm-up"):
self._pwstate = STATE_ON
self._pwstate = MediaPlayerState.ON
self._muted = projector.get_mute()[1]
self._current_source = format_input_source(*projector.get_input())
else:
self._pwstate = STATE_OFF
self._pwstate = MediaPlayerState.OFF
self._muted = False
self._current_source = None
except KeyError as err:
if str(err) == "'OK'":
self._pwstate = STATE_OFF
self._pwstate = MediaPlayerState.OFF
self._muted = False
self._current_source = None
else:
raise
except ProjectorError as err:
if str(err) == "unavailable time":
self._pwstate = STATE_OFF
self._pwstate = MediaPlayerState.OFF
self._muted = False
self._current_source = None
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 (
DOMAIN as MP_DOMAIN,
BrowseMedia,
MediaPlayerEntity,
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.const import STATE_IDLE, STATE_PAUSED, STATE_PLAYING
from homeassistant.core import HomeAssistant, callback
from homeassistant.exceptions import HomeAssistantError
from homeassistant.helpers import entity_registry as er
@ -140,7 +140,7 @@ class PlexMediaPlayer(MediaPlayerEntity):
self._attr_available = False
self._attr_should_poll = False
self._attr_state = STATE_IDLE
self._attr_state = MediaPlayerState.IDLE
self._attr_unique_id = (
f"{self.plex_server.machine_identifier}:{self.machine_identifier}"
)
@ -229,7 +229,7 @@ class PlexMediaPlayer(MediaPlayerEntity):
def force_idle(self):
"""Force client to idle."""
self._attr_state = STATE_IDLE
self._attr_state = MediaPlayerState.IDLE
if self.player_source == "session":
self.device = None
self.session_device = None
@ -247,7 +247,7 @@ class PlexMediaPlayer(MediaPlayerEntity):
self.session_device = self.session.player
self.update_state(self.session.state)
else:
self._attr_state = STATE_IDLE
self._attr_state = MediaPlayerState.IDLE
@property # type: ignore[misc]
@needs_session
@ -258,24 +258,24 @@ class PlexMediaPlayer(MediaPlayerEntity):
def update_state(self, state):
"""Set the state of the device, handle session termination."""
if state == "playing":
self._attr_state = STATE_PLAYING
self._attr_state = MediaPlayerState.PLAYING
elif state == "paused":
self._attr_state = STATE_PAUSED
self._attr_state = MediaPlayerState.PAUSED
elif state == "stopped":
self.session = None
self.force_idle()
else:
self._attr_state = STATE_IDLE
self._attr_state = MediaPlayerState.IDLE
@property
def _is_player_active(self):
"""Report if the client is playing media."""
return self.state in (STATE_PLAYING, STATE_PAUSED)
return self.state in {MediaPlayerState.PLAYING, MediaPlayerState.PAUSED}
@property
def _active_media_plexapi_type(self):
"""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 "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
from homeassistant.components.media_player import (
MediaPlayerEntity,
MediaPlayerEntityFeature,
)
from homeassistant.components.media_player.const import (
ATTR_MEDIA_CONTENT_TYPE,
ATTR_MEDIA_TITLE,
MEDIA_TYPE_APP,
MEDIA_TYPE_GAME,
MediaPlayerEntity,
MediaPlayerEntityFeature,
MediaPlayerState,
MediaType,
)
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import (
@ -24,9 +22,6 @@ from homeassistant.const import (
CONF_NAME,
CONF_REGION,
CONF_TOKEN,
STATE_IDLE,
STATE_PLAYING,
STATE_STANDBY,
)
from homeassistant.core import HomeAssistant, callback
from homeassistant.helpers import device_registry, entity_registry
@ -177,7 +172,7 @@ class PS4Device(MediaPlayerEntity):
name = status.get("running-app-name")
if title_id and name is not None:
self._state = STATE_PLAYING
self._state = MediaPlayerState.PLAYING
if self._media_content_id != title_id:
self._media_content_id = title_id
@ -191,10 +186,10 @@ class PS4Device(MediaPlayerEntity):
# Get data from PS Store.
asyncio.ensure_future(self.async_get_title_data(title_id, name))
else:
if self._state != STATE_IDLE:
if self._state != MediaPlayerState.IDLE:
self.idle()
else:
if self._state != STATE_STANDBY:
if self._state != MediaPlayerState.STANDBY:
self.state_standby()
elif self._retry > DEFAULT_RETRIES:
@ -219,12 +214,12 @@ class PS4Device(MediaPlayerEntity):
def idle(self):
"""Set states for state idle."""
self.reset_title()
self._state = STATE_IDLE
self._state = MediaPlayerState.IDLE
def state_standby(self):
"""Set states for state standby."""
self.reset_title()
self._state = STATE_STANDBY
self._state = MediaPlayerState.STANDBY
def state_unknown(self):
"""Set states for state unknown."""
@ -265,9 +260,9 @@ class PS4Device(MediaPlayerEntity):
art = title.cover_art
# Assume media type is game if not app.
if title.game_type != PS_TYPE_APP:
media_type = MEDIA_TYPE_GAME
media_type = MediaType.GAME
else:
media_type = MEDIA_TYPE_APP
media_type = MediaType.APP
else:
_LOGGER.error(
"Could not find data in region: %s for PS ID: %s",
@ -382,7 +377,7 @@ class PS4Device(MediaPlayerEntity):
def entity_picture(self):
"""Return picture."""
if (
self._state == STATE_PLAYING
self._state == MediaPlayerState.PLAYING
and self._media_content_id is not None
and (image_hash := self.media_image_hash) is not None
):