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

Use attributes in ps4 media player (#82837)

Browse Source
This commit is contained in:
epenet 2022-11-28 12:23:20 +01:00 committed by GitHub
parent 7ba234a7ad
commit 4bf1475c95
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 44 additions and 95 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -67,6 +67,7 @@ async def async_setup_entry(
class PS4Device(MediaPlayerEntity): class PS4Device(MediaPlayerEntity):
"""Representation of a PS4.""" """Representation of a PS4."""
_attr_icon = ICON
_attr_supported_features = ( _attr_supported_features = (
MediaPlayerEntityFeature.TURN_OFF MediaPlayerEntityFeature.TURN_OFF
| MediaPlayerEntityFeature.TURN_ON | MediaPlayerEntityFeature.TURN_ON
@ -80,20 +81,13 @@ class PS4Device(MediaPlayerEntity):
self._entry_id = config.entry_id self._entry_id = config.entry_id
self._ps4 = ps4 self._ps4 = ps4
self._host = host self._host = host
self._name = name self._attr_name = name
self._region = region self._region = region
self._creds = creds self._creds = creds
self._state = None
self._media_content_id = None
self._media_title = None
self._media_image = None self._media_image = None
self._media_type = None
self._source = None
self._games = {} self._games = {}
self._source_list = []
self._retry = 0 self._retry = 0
self._disconnected = False self._disconnected = False
self._unique_id = None
@callback @callback
def status_callback(self): def status_callback(self):
@ -161,7 +155,7 @@ class PS4Device(MediaPlayerEntity):
def _parse_status(self): def _parse_status(self):
"""Parse status.""" """Parse status."""
if (status := self._ps4.status) is not None: if (status := self._ps4.status) is not None:
self._games = load_games(self.hass, self._unique_id) self._games = load_games(self.hass, self.unique_id)
if self._games: if self._games:
self.get_source_list() self.get_source_list()
@ -172,24 +166,24 @@ 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 = MediaPlayerState.PLAYING self._attr_state = MediaPlayerState.PLAYING
if self._media_content_id != title_id: if self.media_content_id != title_id:
self._media_content_id = title_id self._attr_media_content_id = title_id
if self._use_saved(): if self._use_saved():
_LOGGER.debug("Using saved data for media: %s", title_id) _LOGGER.debug("Using saved data for media: %s", title_id)
return return
self._media_title = name self._attr_media_title = name
self._source = self._media_title self._attr_source = self._attr_media_title
self._media_type = None self._attr_media_content_type = None
# 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 != MediaPlayerState.IDLE: if self.state != MediaPlayerState.IDLE:
self.idle() self.idle()
else: else:
if self._state != MediaPlayerState.STANDBY: if self.state != MediaPlayerState.STANDBY:
self.state_standby() self.state_standby()
elif self._retry > DEFAULT_RETRIES: elif self._retry > DEFAULT_RETRIES:
@ -199,32 +193,32 @@ class PS4Device(MediaPlayerEntity):
def _use_saved(self) -> bool: def _use_saved(self) -> bool:
"""Return True, Set media attrs if data is locked.""" """Return True, Set media attrs if data is locked."""
if self._media_content_id in self._games: if self.media_content_id in self._games:
store = self._games[self._media_content_id] store = self._games[self.media_content_id]
# If locked get attributes from file. # If locked get attributes from file.
if store.get(ATTR_LOCKED): if store.get(ATTR_LOCKED):
self._media_title = store.get(ATTR_MEDIA_TITLE) self._attr_media_title = store.get(ATTR_MEDIA_TITLE)
self._source = self._media_title self._attr_source = self._attr_media_title
self._media_image = store.get(ATTR_MEDIA_IMAGE_URL) self._media_image = store.get(ATTR_MEDIA_IMAGE_URL)
self._media_type = store.get(ATTR_MEDIA_CONTENT_TYPE) self._attr_media_content_type = store.get(ATTR_MEDIA_CONTENT_TYPE)
return True return True
return False return False
def idle(self): def idle(self):
"""Set states for state idle.""" """Set states for state idle."""
self.reset_title() self.reset_title()
self._state = MediaPlayerState.IDLE self._attr_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 = MediaPlayerState.STANDBY self._attr_state = MediaPlayerState.STANDBY
def state_unknown(self): def state_unknown(self):
"""Set states for state unknown.""" """Set states for state unknown."""
self.reset_title() self.reset_title()
self._state = None self._attr_state = None
if self._disconnected is False: if self._disconnected is False:
_LOGGER.warning("PS4 could not be reached") _LOGGER.warning("PS4 could not be reached")
self._disconnected = True self._disconnected = True
@ -232,10 +226,10 @@ class PS4Device(MediaPlayerEntity):
def reset_title(self): def reset_title(self):
"""Update if there is no title.""" """Update if there is no title."""
self._media_title = None self._attr_media_title = None
self._media_content_id = None self._attr_media_content_id = None
self._media_type = None self._attr_media_content_type = None
self._source = None self._attr_source = None
async def async_get_title_data(self, title_id, name): async def async_get_title_data(self, title_id, name):
"""Get PS Store Data.""" """Get PS Store Data."""
@ -271,42 +265,42 @@ class PS4Device(MediaPlayerEntity):
) )
finally: finally:
self._media_title = app_name or name self._attr_media_title = app_name or name
self._source = self._media_title self._attr_source = self._attr_media_title
self._media_image = art or None self._media_image = art or None
self._media_type = media_type self._attr_media_content_type = media_type
await self.hass.async_add_executor_job(self.update_list) await self.hass.async_add_executor_job(self.update_list)
self.async_write_ha_state() self.async_write_ha_state()
def update_list(self): def update_list(self):
"""Update Game List, Correct data if different.""" """Update Game List, Correct data if different."""
if self._media_content_id in self._games: if self.media_content_id in self._games:
store = self._games[self._media_content_id] store = self._games[self.media_content_id]
if ( if (
store.get(ATTR_MEDIA_TITLE) != self._media_title store.get(ATTR_MEDIA_TITLE) != self.media_title
or store.get(ATTR_MEDIA_IMAGE_URL) != self._media_image or store.get(ATTR_MEDIA_IMAGE_URL) != self._media_image
): ):
self._games.pop(self._media_content_id) self._games.pop(self.media_content_id)
if self._media_content_id not in self._games: if self.media_content_id not in self._games:
self.add_games( self.add_games(
self._media_content_id, self.media_content_id,
self._media_title, self._attr_media_title,
self._media_image, self._media_image,
self._media_type, self._attr_media_content_type,
) )
self._games = load_games(self.hass, self._unique_id) self._games = load_games(self.hass, self.unique_id)
self.get_source_list() self.get_source_list()
def get_source_list(self): def get_source_list(self) -> None:
"""Parse data entry and update source list.""" """Parse data entry and update source list."""
games = [] games = []
for data in self._games.values(): for data in self._games.values():
games.append(data[ATTR_MEDIA_TITLE]) games.append(data[ATTR_MEDIA_TITLE])
self._source_list = sorted(games) self._attr_source_list = sorted(games)
def add_games(self, title_id, app_name, image, g_type, is_locked=False): def add_games(self, title_id, app_name, image, g_type, is_locked=False):
"""Add games to list.""" """Add games to list."""
@ -321,7 +315,7 @@ class PS4Device(MediaPlayerEntity):
} }
} }
games.update(game) games.update(game)
save_games(self.hass, games, self._unique_id) save_games(self.hass, games, self.unique_id)
async def async_get_device_info(self, status): async def async_get_device_info(self, status):
"""Set device info for registry.""" """Set device info for registry."""
@ -332,7 +326,7 @@ class PS4Device(MediaPlayerEntity):
d_registry = device_registry.async_get(self.hass) d_registry = device_registry.async_get(self.hass)
for entity_id, entry in e_registry.entities.items(): for entity_id, entry in e_registry.entities.items():
if entry.config_entry_id == self._entry_id: if entry.config_entry_id == self._entry_id:
self._unique_id = entry.unique_id self._attr_unique_id = entry.unique_id
self.entity_id = entity_id self.entity_id = entity_id
break break
for device in d_registry.devices.values(): for device in d_registry.devices.values():
@ -358,7 +352,7 @@ class PS4Device(MediaPlayerEntity):
sw_version=sw_version, sw_version=sw_version,
) )
self._unique_id = format_unique_id(self._creds, status["host-id"]) self._attr_unique_id = format_unique_id(self._creds, status["host-id"])
async def async_will_remove_from_hass(self) -> None: async def async_will_remove_from_hass(self) -> None:
"""Remove Entity from Home Assistant.""" """Remove Entity from Home Assistant."""
@ -368,17 +362,12 @@ class PS4Device(MediaPlayerEntity):
self.unsubscribe_to_protocol() self.unsubscribe_to_protocol()
self.hass.data[PS4_DATA].devices.remove(self) self.hass.data[PS4_DATA].devices.remove(self)
@property
def unique_id(self):
"""Return Unique ID for entity."""
return self._unique_id
@property @property
def entity_picture(self): def entity_picture(self):
"""Return picture.""" """Return picture."""
if ( if (
self._state == MediaPlayerState.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
): ):
return ( return (
@ -387,53 +376,13 @@ class PS4Device(MediaPlayerEntity):
) )
return MEDIA_IMAGE_DEFAULT return MEDIA_IMAGE_DEFAULT
@property
def name(self):
"""Return the name of the device."""
return self._name
@property
def state(self):
"""Return the state of the device."""
return self._state
@property
def icon(self):
"""Icon."""
return ICON
@property
def media_content_id(self):
"""Content ID of current playing media."""
return self._media_content_id
@property
def media_content_type(self):
"""Content type of current playing media."""
return self._media_type
@property @property
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 is None: if self.media_content_id is None:
return MEDIA_IMAGE_DEFAULT return MEDIA_IMAGE_DEFAULT
return self._media_image return self._media_image
@property
def media_title(self):
"""Title of current playing media."""
return self._media_title
@property
def source(self):
"""Return the current input source."""
return self._source
@property
def source_list(self):
"""List of available input sources."""
return self._source_list
async def async_turn_off(self) -> None: async def async_turn_off(self) -> None:
"""Turn off media player.""" """Turn off media player."""
await self._ps4.standby() await self._ps4.standby()
@ -468,7 +417,7 @@ class PS4Device(MediaPlayerEntity):
"Starting PS4 game %s (%s) using source %s", game, title_id, source "Starting PS4 game %s (%s) using source %s", game, title_id, source
) )
await self._ps4.start_title(title_id, self._media_content_id) await self._ps4.start_title(title_id, self.media_content_id)
return return
_LOGGER.warning("Could not start title. '%s' is not in source list", source) _LOGGER.warning("Could not start title. '%s' is not in source list", source)