github/ha-core
1
Fork 0
mirror of https://github.com/home-assistant/core synced 2024-10-01 05:30:36 +02:00
Code Releases Activity

Use new media player enums [e-h] (#78049)

Browse Source
This commit is contained in:
epenet 2022-09-08 22:44:30 +02:00 committed by GitHub
parent 9fc9d50e07
commit 56c4e0391d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
8 changed files with 72 additions and 104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -7,8 +7,9 @@ import voluptuous as vol
from homeassistant.components.media_player import (
MediaPlayerEntity,
MediaPlayerEntityFeature,
MediaPlayerState,
MediaType,
)
from homeassistant.components.media_player.const import MEDIA_TYPE_TVSHOW
from homeassistant.const import (
CONF_HOST,
CONF_NAME,
@ -16,9 +17,6 @@ from homeassistant.const import (
CONF_PORT,
CONF_SSL,
CONF_USERNAME,
STATE_OFF,
STATE_ON,
STATE_PLAYING,
)
from homeassistant.core import HomeAssistant
import homeassistant.helpers.config_validation as cv
@ -104,6 +102,7 @@ def setup_platform(
class Enigma2Device(MediaPlayerEntity):
"""Representation of an Enigma2 box."""
_attr_media_content_type = MediaType.TVSHOW
_attr_supported_features = (
MediaPlayerEntityFeature.VOLUME_SET
| MediaPlayerEntityFeature.VOLUME_MUTE
@ -133,11 +132,11 @@ class Enigma2Device(MediaPlayerEntity):
return self.e2_box.mac_address
@property
def state(self):
def state(self) -> MediaPlayerState:
"""Return the state of the device."""
if self.e2_box.is_recording_playback:
return STATE_PLAYING
return STATE_OFF if self.e2_box.in_standby else STATE_ON
return MediaPlayerState.PLAYING
return MediaPlayerState.OFF if self.e2_box.in_standby else MediaPlayerState.ON
@property
def available(self) -> bool:
@ -172,11 +171,6 @@ class Enigma2Device(MediaPlayerEntity):
"""Service Ref of current playing media."""
return self.e2_box.current_service_ref
@property
def media_content_type(self):
"""Type of video currently playing."""
return MEDIA_TYPE_TVSHOW
@property
def is_volume_muted(self):
"""Boolean if volume is currently muted."""

16
homeassistant/components/epson/media_player.py
View File

@ -31,9 +31,9 @@ import voluptuous as vol
from homeassistant.components.media_player import (
MediaPlayerEntity,
MediaPlayerEntityFeature,
MediaPlayerState,
)
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import STATE_OFF, STATE_ON
from homeassistant.core import HomeAssistant
from homeassistant.helpers import entity_platform
import homeassistant.helpers.config_validation as cv
@ -134,7 +134,7 @@ class EpsonProjectorMediaPlayer(MediaPlayerEntity):
_LOGGER.debug("Projector status: %s", power_state)
self._attr_available = True
if power_state == EPSON_CODES[POWER]:
self._attr_state = STATE_ON
self._attr_state = MediaPlayerState.ON
if await self.set_unique_id():
return
self._attr_source_list = list(DEFAULT_SOURCES.values())
@ -148,21 +148,21 @@ class EpsonProjectorMediaPlayer(MediaPlayerEntity):
except ValueError:
self._attr_volume_level = None
elif power_state == BUSY:
self._attr_state = STATE_ON
self._attr_state = MediaPlayerState.ON
else:
self._attr_state = STATE_OFF
self._attr_state = MediaPlayerState.OFF
async def async_turn_on(self) -> None:
"""Turn on epson."""
if self.state == STATE_OFF:
if self.state == MediaPlayerState.OFF:
await self._projector.send_command(TURN_ON)
self._attr_state = STATE_ON
self._attr_state = MediaPlayerState.ON
async def async_turn_off(self) -> None:
"""Turn off epson."""
if self.state == STATE_ON:
if self.state == MediaPlayerState.ON:
await self._projector.send_command(TURN_OFF)
self._attr_state = STATE_OFF
self._attr_state = MediaPlayerState.OFF
async def select_cmode(self, cmode: str) -> None:
"""Set color mode in Epson."""

12
homeassistant/components/fully_kiosk/media_player.py
View File

@ -4,13 +4,13 @@ from __future__ import annotations
from typing import Any
from homeassistant.components import media_source
from homeassistant.components.media_player import MediaPlayerEntity
from homeassistant.components.media_player.browse_media import (
from homeassistant.components.media_player import (
BrowseMedia,
MediaPlayerEntity,
MediaPlayerState,
async_process_play_media_url,
)
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import STATE_IDLE, STATE_PLAYING
from homeassistant.core import HomeAssistant
from homeassistant.helpers.entity_platform import AddEntitiesCallback
@ -34,12 +34,12 @@ class FullyMediaPlayer(FullyKioskEntity, MediaPlayerEntity):
_attr_supported_features = MEDIA_SUPPORT_FULLYKIOSK
_attr_assumed_state = True
_attr_state = STATE_IDLE
def __init__(self, coordinator: FullyKioskDataUpdateCoordinator) -> None:
"""Initialize the media player entity."""
super().__init__(coordinator)
self._attr_unique_id = f"{coordinator.data['deviceID']}-mediaplayer"
self._attr_state = MediaPlayerState.IDLE
async def async_play_media(
self, media_type: str, media_id: str, **kwargs: Any
@ -52,13 +52,13 @@ class FullyMediaPlayer(FullyKioskEntity, MediaPlayerEntity):
media_id = async_process_play_media_url(self.hass, play_item.url)
await self.coordinator.fully.playSound(media_id, AUDIOMANAGER_STREAM_MUSIC)
self._attr_state = STATE_PLAYING
self._attr_state = MediaPlayerState.PLAYING
self.async_write_ha_state()
async def async_media_stop(self) -> None:
"""Stop playing media."""
await self.coordinator.fully.stopSound()
self._attr_state = STATE_IDLE
self._attr_state = MediaPlayerState.IDLE
self.async_write_ha_state()
async def async_set_volume_level(self, volume: float) -> None:

17
homeassistant/components/gstreamer/media_player.py
View File

@ -13,12 +13,11 @@ from homeassistant.components.media_player import (
BrowseMedia,
MediaPlayerEntity,
MediaPlayerEntityFeature,
)
from homeassistant.components.media_player.browse_media import (
MediaPlayerState,
MediaType,
async_process_play_media_url,
)
from homeassistant.components.media_player.const import MEDIA_TYPE_MUSIC
from homeassistant.const import CONF_NAME, EVENT_HOMEASSISTANT_STOP, STATE_IDLE
from homeassistant.const import CONF_NAME, EVENT_HOMEASSISTANT_STOP
from homeassistant.core import HomeAssistant
import homeassistant.helpers.config_validation as cv
from homeassistant.helpers.entity_platform import AddEntitiesCallback
@ -58,6 +57,7 @@ def setup_platform(
class GstreamerDevice(MediaPlayerEntity):
"""Representation of a Gstreamer device."""
_attr_media_content_type = MediaType.MUSIC
_attr_supported_features = (
MediaPlayerEntityFeature.VOLUME_SET
| MediaPlayerEntityFeature.PLAY
@ -71,7 +71,7 @@ class GstreamerDevice(MediaPlayerEntity):
"""Initialize the Gstreamer device."""
self._player = player
self._name = name or DOMAIN
self._state = STATE_IDLE
self._state = MediaPlayerState.IDLE
self._volume = None
self._duration = None
self._uri = None
@ -104,7 +104,7 @@ class GstreamerDevice(MediaPlayerEntity):
)
media_id = sourced_media.url
elif media_type != MEDIA_TYPE_MUSIC:
elif media_type != MediaType.MUSIC:
_LOGGER.error("Invalid media type")
return
@ -129,11 +129,6 @@ class GstreamerDevice(MediaPlayerEntity):
"""Content ID of currently playing media."""
return self._uri
@property
def content_type(self):
"""Content type of currently playing media."""
return MEDIA_TYPE_MUSIC
@property
def name(self):
"""Return the name of the device."""

7
homeassistant/components/harman_kardon_avr/media_player.py
View File

@ -8,8 +8,9 @@ from homeassistant.components.media_player import (
PLATFORM_SCHEMA,
MediaPlayerEntity,
MediaPlayerEntityFeature,
MediaPlayerState,
)
from homeassistant.const import CONF_HOST, CONF_NAME, CONF_PORT, STATE_OFF, STATE_ON
from homeassistant.const import 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
@ -72,9 +73,9 @@ class HkAvrDevice(MediaPlayerEntity):
def update(self) -> None:
"""Update the state of this media_player."""
if self._avr.is_on():
self._state = STATE_ON
self._state = MediaPlayerState.ON
elif self._avr.is_off():
self._state = STATE_OFF
self._state = MediaPlayerState.OFF
else:
self._state = None

30
homeassistant/components/hdmi_cec/media_player.py
View File

@ -26,16 +26,10 @@ from pycec.const import (
)
from homeassistant.components.media_player import (
DOMAIN as MP_DOMAIN,
MediaPlayerEntity,
MediaPlayerEntityFeature,
)
from homeassistant.components.media_player.const import DOMAIN as MP_DOMAIN
from homeassistant.const import (
STATE_IDLE,
STATE_OFF,
STATE_ON,
STATE_PAUSED,
STATE_PLAYING,
MediaPlayerState,
)
from homeassistant.core import HomeAssistant
from homeassistant.helpers.entity_platform import AddEntitiesCallback
@ -95,7 +89,7 @@ class CecPlayerEntity(CecEntity, MediaPlayerEntity):
def turn_on(self) -> None:
"""Turn device on."""
self._device.turn_on()
self._state = STATE_ON
self._state = MediaPlayerState.ON
def clear_playlist(self) -> None:
"""Clear players playlist."""
@ -104,12 +98,12 @@ class CecPlayerEntity(CecEntity, MediaPlayerEntity):
def turn_off(self) -> None:
"""Turn device off."""
self._device.turn_off()
self._state = STATE_OFF
self._state = MediaPlayerState.OFF
def media_stop(self) -> None:
"""Stop playback."""
self.send_keypress(KEY_STOP)
self._state = STATE_IDLE
self._state = MediaPlayerState.IDLE
def play_media(self, media_type: str, media_id: str, **kwargs: Any) -> None:
"""Not supported."""
@ -130,7 +124,7 @@ class CecPlayerEntity(CecEntity, MediaPlayerEntity):
def media_pause(self) -> None:
"""Pause playback."""
self.send_keypress(KEY_PAUSE)
self._state = STATE_PAUSED
self._state = MediaPlayerState.PAUSED
def select_source(self, source: str) -> None:
"""Not supported."""
@ -139,7 +133,7 @@ class CecPlayerEntity(CecEntity, MediaPlayerEntity):
def media_play(self) -> None:
"""Start playback."""
self.send_keypress(KEY_PLAY)
self._state = STATE_PLAYING
self._state = MediaPlayerState.PLAYING
def volume_up(self) -> None:
"""Increase volume."""
@ -160,16 +154,16 @@ class CecPlayerEntity(CecEntity, MediaPlayerEntity):
"""Update device status."""
device = self._device
if device.power_status in [POWER_OFF, 3]:
self._state = STATE_OFF
self._state = MediaPlayerState.OFF
elif not self.support_pause:
if device.power_status in [POWER_ON, 4]:
self._state = STATE_ON
self._state = MediaPlayerState.ON
elif device.status == STATUS_PLAY:
self._state = STATE_PLAYING
self._state = MediaPlayerState.PLAYING
elif device.status == STATUS_STOP:
self._state = STATE_IDLE
self._state = MediaPlayerState.IDLE
elif device.status == STATUS_STILL:
self._state = STATE_PAUSED
self._state = MediaPlayerState.PAUSED
else:
_LOGGER.warning("Unknown state: %s", device.status)

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

@ -12,23 +12,17 @@ from typing_extensions import ParamSpec
from homeassistant.components import media_source
from homeassistant.components.media_player import (
ATTR_MEDIA_ENQUEUE,
DOMAIN,
BrowseMedia,
MediaPlayerEnqueue,
MediaPlayerEntity,
MediaPlayerEntityFeature,
)
from homeassistant.components.media_player.browse_media import (
BrowseMedia,
MediaPlayerState,
MediaType,
async_process_play_media_url,
)
from homeassistant.components.media_player.const import (
ATTR_MEDIA_ENQUEUE,
DOMAIN,
MEDIA_TYPE_MUSIC,
MEDIA_TYPE_PLAYLIST,
MEDIA_TYPE_URL,
)
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import STATE_IDLE, STATE_PAUSED, STATE_PLAYING
from homeassistant.core import HomeAssistant
from homeassistant.helpers.dispatcher import (
async_dispatcher_connect,
@ -62,9 +56,9 @@ BASE_SUPPORTED_FEATURES = (
)
PLAY_STATE_TO_STATE = {
heos_const.PLAY_STATE_PLAY: STATE_PLAYING,
heos_const.PLAY_STATE_STOP: STATE_IDLE,
heos_const.PLAY_STATE_PAUSE: STATE_PAUSED,
heos_const.PLAY_STATE_PLAY: MediaPlayerState.PLAYING,
heos_const.PLAY_STATE_STOP: MediaPlayerState.IDLE,
heos_const.PLAY_STATE_PAUSE: MediaPlayerState.PAUSED,
}
CONTROL_TO_SUPPORT = {
@ -118,6 +112,7 @@ def log_command_error(
class HeosMediaPlayer(MediaPlayerEntity):
"""The HEOS player."""
_attr_media_content_type = MediaType.MUSIC
_attr_should_poll = False
def __init__(self, player):
@ -205,13 +200,13 @@ class HeosMediaPlayer(MediaPlayerEntity):
) -> None:
"""Play a piece of 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 in (MEDIA_TYPE_URL, MEDIA_TYPE_MUSIC):
if media_type in {MediaType.URL, MediaType.MUSIC}:
media_id = async_process_play_media_url(self.hass, media_id)
await self._player.play_url(media_id)
@ -233,7 +228,7 @@ class HeosMediaPlayer(MediaPlayerEntity):
await self._player.play_quick_select(index)
return
if media_type == MEDIA_TYPE_PLAYLIST:
if media_type == MediaType.PLAYLIST:
playlists = await self._player.heos.get_playlists()
playlist = next((p for p in playlists if p.name == media_id), None)
if not playlist:
@ -356,11 +351,6 @@ class HeosMediaPlayer(MediaPlayerEntity):
"""Content ID of current playing media."""
return self._player.now_playing_media.media_id
@property
def media_content_type(self) -> str:
"""Content type of current playing media."""
return MEDIA_TYPE_MUSIC
@property
def media_duration(self):
"""Duration of current playing media in seconds."""

42
homeassistant/components/horizon/media_player.py
View File

@ -14,16 +14,10 @@ from homeassistant.components.media_player import (
PLATFORM_SCHEMA,
MediaPlayerEntity,
MediaPlayerEntityFeature,
MediaPlayerState,
MediaType,
)
from homeassistant.components.media_player.const import MEDIA_TYPE_CHANNEL
from homeassistant.const import (
CONF_HOST,
CONF_NAME,
CONF_PORT,
STATE_OFF,
STATE_PAUSED,
STATE_PLAYING,
)
from homeassistant.const import CONF_HOST, CONF_NAME, CONF_PORT
from homeassistant.core import HomeAssistant
from homeassistant.exceptions import PlatformNotReady
import homeassistant.helpers.config_validation as cv
@ -110,63 +104,63 @@ class HorizonDevice(MediaPlayerEntity):
"""Update State using the media server running on the Horizon."""
try:
if self._client.is_powered_on():
self._state = STATE_PLAYING
self._state = MediaPlayerState.PLAYING
else:
self._state = STATE_OFF
self._state = MediaPlayerState.OFF
except OSError:
self._state = STATE_OFF
self._state = MediaPlayerState.OFF
def turn_on(self) -> None:
"""Turn the device on."""
if self._state == STATE_OFF:
if self._state == MediaPlayerState.OFF:
self._send_key(self._keys.POWER)
def turn_off(self) -> None:
"""Turn the device off."""
if self._state != STATE_OFF:
if self._state != MediaPlayerState.OFF:
self._send_key(self._keys.POWER)
def media_previous_track(self) -> None:
"""Channel down."""
self._send_key(self._keys.CHAN_DOWN)
self._state = STATE_PLAYING
self._state = MediaPlayerState.PLAYING
def media_next_track(self) -> None:
"""Channel up."""
self._send_key(self._keys.CHAN_UP)
self._state = STATE_PLAYING
self._state = MediaPlayerState.PLAYING
def media_play(self) -> None:
"""Send play command."""
self._send_key(self._keys.PAUSE)
self._state = STATE_PLAYING
self._state = MediaPlayerState.PLAYING
def media_pause(self) -> None:
"""Send pause command."""
self._send_key(self._keys.PAUSE)
self._state = STATE_PAUSED
self._state = MediaPlayerState.PAUSED
def media_play_pause(self) -> None:
"""Send play/pause command."""
self._send_key(self._keys.PAUSE)
if self._state == STATE_PAUSED:
self._state = STATE_PLAYING
if self._state == MediaPlayerState.PAUSED:
self._state = MediaPlayerState.PLAYING
else:
self._state = STATE_PAUSED
self._state = MediaPlayerState.PAUSED
def play_media(self, media_type: str, media_id: str, **kwargs: Any) -> None:
"""Play media / switch to channel."""
if MEDIA_TYPE_CHANNEL == media_type:
if MediaType.CHANNEL == media_type:
try:
self._select_channel(int(media_id))
self._state = STATE_PLAYING
self._state = MediaPlayerState.PLAYING
except ValueError:
_LOGGER.error("Invalid channel: %s", media_id)
else:
_LOGGER.error(
"Invalid media type %s. Supported type: %s",
media_type,
MEDIA_TYPE_CHANNEL,
MediaType.CHANNEL,
)
def _select_channel(self, channel):