Use attributes in ps4 media player (#82837)

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

View File

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