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

homeassistant/components/enigma2/media_player.py

@@ -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 MediaPlayerState.PLAYING
-        return STATE_OFF if self.e2_box.in_standby else STATE_ON
+        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."""

homeassistant/components/epson/media_player.py

@@ -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."""

homeassistant/components/fully_kiosk/media_player.py

@@ -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 import (
-from homeassistant.components.media_player.browse_media 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:

homeassistant/components/gstreamer/media_player.py

@@ -13,12 +13,11 @@ from homeassistant.components.media_player import (
     BrowseMedia,
     MediaPlayerEntity,
     MediaPlayerEntityFeature,
-)
+    MediaPlayerState,
-from homeassistant.components.media_player.browse_media import (
+    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
-from homeassistant.const import CONF_NAME, EVENT_HOMEASSISTANT_STOP, STATE_IDLE
 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."""

homeassistant/components/harman_kardon_avr/media_player.py

@@ -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
 

homeassistant/components/hdmi_cec/media_player.py

@@ -26,16 +26,10 @@ from pycec.const import (
 )
 
 from homeassistant.components.media_player import (
+    DOMAIN as MP_DOMAIN,
     MediaPlayerEntity,
     MediaPlayerEntityFeature,
-)
+    MediaPlayerState,
-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,
 )
 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)
 

homeassistant/components/heos/media_player.py

@@ -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,
-)
+    MediaPlayerState,
-from homeassistant.components.media_player.browse_media import (
+    MediaType,
-    BrowseMedia,
     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_PLAY: MediaPlayerState.PLAYING,
-    heos_const.PLAY_STATE_STOP: STATE_IDLE,
+    heos_const.PLAY_STATE_STOP: MediaPlayerState.IDLE,
-    heos_const.PLAY_STATE_PAUSE: STATE_PAUSED,
+    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."""

homeassistant/components/horizon/media_player.py

@@ -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
-from homeassistant.const import (
-    CONF_HOST,
-    CONF_NAME,
-    CONF_PORT,
-    STATE_OFF,
-    STATE_PAUSED,
-    STATE_PLAYING,
-)
 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:
+        if self._state == MediaPlayerState.PAUSED:
-            self._state = STATE_PLAYING
+            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):