Use new media player enums [a-d] (#77939)

homeassistant/components/androidtv/media_player.py

@@ -23,6 +23,7 @@ from homeassistant.components import persistent_notification
 from homeassistant.components.media_player import (
     MediaPlayerEntity,
     MediaPlayerEntityFeature,
+    MediaPlayerState,
 )
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import (
@@ -33,11 +34,6 @@ from homeassistant.const import (
     ATTR_SW_VERSION,
     CONF_HOST,
     CONF_NAME,
-    STATE_IDLE,
-    STATE_OFF,
-    STATE_PAUSED,
-    STATE_PLAYING,
-    STATE_STANDBY,
 )
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import config_validation as cv, entity_platform
@@ -85,11 +81,11 @@ PREFIX_FIRETV = "Fire TV"
 
 # Translate from `AndroidTV` / `FireTV` reported state to HA state.
 ANDROIDTV_STATES = {
-    "off": STATE_OFF,
+    "off": MediaPlayerState.OFF,
-    "idle": STATE_IDLE,
+    "idle": MediaPlayerState.IDLE,
-    "standby": STATE_STANDBY,
+    "standby": MediaPlayerState.STANDBY,
-    "playing": STATE_PLAYING,
+    "playing": MediaPlayerState.PLAYING,
-    "paused": STATE_PAUSED,
+    "paused": MediaPlayerState.PAUSED,
 }
 
 
@@ -323,7 +319,11 @@ class ADBDevice(MediaPlayerEntity):
 
     async def async_get_media_image(self) -> tuple[bytes | None, str | None]:
         """Fetch current playing image."""
-        if not self._screencap or self.state in (STATE_OFF, None) or not self.available:
+        if (
+            not self._screencap
+            or self.state in {MediaPlayerState.OFF, None}
+            or not self.available
+        ):
             return None, None
 
         media_data = await self._adb_screencap()

homeassistant/components/anthemav/media_player.py

@@ -12,16 +12,10 @@ from homeassistant.components.media_player import (
     MediaPlayerDeviceClass,
     MediaPlayerEntity,
     MediaPlayerEntityFeature,
+    MediaPlayerState,
 )
 from homeassistant.config_entries import SOURCE_IMPORT, ConfigEntry
-from homeassistant.const import (
+from homeassistant.const import CONF_HOST, CONF_MAC, CONF_NAME, CONF_PORT
-    CONF_HOST,
-    CONF_MAC,
-    CONF_NAME,
-    CONF_PORT,
-    STATE_OFF,
-    STATE_ON,
-)
 from homeassistant.core import HomeAssistant, callback
 import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
@@ -163,7 +157,9 @@ class AnthemAVR(MediaPlayerEntity):
 
     def set_states(self) -> None:
         """Set all the states from the device to the entity."""
-        self._attr_state = STATE_ON if self._zone.power is True else STATE_OFF
+        self._attr_state = (
+            MediaPlayerState.ON if self._zone.power else MediaPlayerState.OFF
+        )
         self._attr_is_volume_muted = self._zone.mute
         self._attr_volume_level = self._zone.volume_as_percentage
         self._attr_media_title = self._zone.input_name

homeassistant/components/aquostv/media_player.py

@@ -10,6 +10,7 @@ from homeassistant.components.media_player import (
     PLATFORM_SCHEMA,
     MediaPlayerEntity,
     MediaPlayerEntityFeature,
+    MediaPlayerState,
 )
 from homeassistant.const import (
     CONF_HOST,
@@ -18,8 +19,6 @@ from homeassistant.const import (
     CONF_PORT,
     CONF_TIMEOUT,
     CONF_USERNAME,
-    STATE_OFF,
-    STATE_ON,
 )
 from homeassistant.core import HomeAssistant
 import homeassistant.helpers.config_validation as cv
@@ -93,7 +92,7 @@ def _retry(func):
             except (OSError, TypeError, ValueError):
                 update_retries -= 1
                 if update_retries == 0:
-                    obj.set_state(STATE_OFF)
+                    obj.set_state(MediaPlayerState.OFF)
 
     return wrapper
 
@@ -134,9 +133,9 @@ class SharpAquosTVDevice(MediaPlayerEntity):
     def update(self) -> None:
         """Retrieve the latest data."""
         if self._remote.power() == 1:
-            self._attr_state = STATE_ON
+            self._attr_state = MediaPlayerState.ON
         else:
-            self._attr_state = STATE_OFF
+            self._attr_state = MediaPlayerState.OFF
         # Set TV to be able to remotely power on
         if self._power_on_enabled:
             self._remote.power_on_command_settings(2)

homeassistant/components/arcam_fmj/media_player.py

@@ -9,17 +9,15 @@ from arcam.fmj.state import State
 
 from homeassistant.components.media_player import (
     BrowseMedia,
+    MediaClass,
     MediaPlayerEntity,
     MediaPlayerEntityFeature,
-)
+    MediaPlayerState,
-from homeassistant.components.media_player.const import (
+    MediaType,
-    MEDIA_CLASS_DIRECTORY,
-    MEDIA_CLASS_MUSIC,
-    MEDIA_TYPE_MUSIC,
 )
 from homeassistant.components.media_player.errors import BrowseError
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import ATTR_ENTITY_ID, STATE_OFF, STATE_ON
+from homeassistant.const import ATTR_ENTITY_ID
 from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity import DeviceInfo
@@ -91,11 +89,11 @@ class ArcamFmj(MediaPlayerEntity):
         self._attr_entity_registry_enabled_default = state.zn == 1
 
     @property
-    def state(self):
+    def state(self) -> MediaPlayerState:
         """Return the state of the device."""
         if self._state.get_power():
-            return STATE_ON
+            return MediaPlayerState.ON
-        return STATE_OFF
+        return MediaPlayerState.OFF
 
     @property
     def device_info(self):
@@ -202,7 +200,9 @@ class ArcamFmj(MediaPlayerEntity):
         await self._state.set_power(False)
 
     async def async_browse_media(
-        self, media_content_type: str | None = None, media_content_id: str | None = None
+        self,
+        media_content_type: MediaType | str | None = None,
+        media_content_id: str | None = None,
     ) -> BrowseMedia:
         """Implement the websocket media browsing helper."""
         if media_content_id not in (None, "root"):
@@ -215,9 +215,9 @@ class ArcamFmj(MediaPlayerEntity):
         radio = [
             BrowseMedia(
                 title=preset.name,
-                media_class=MEDIA_CLASS_MUSIC,
+                media_class=MediaClass.MUSIC,
                 media_content_id=f"preset:{preset.index}",
-                media_content_type=MEDIA_TYPE_MUSIC,
+                media_content_type=MediaType.MUSIC,
                 can_play=True,
                 can_expand=False,
             )
@@ -226,7 +226,7 @@ class ArcamFmj(MediaPlayerEntity):
 
         root = BrowseMedia(
             title="Arcam FMJ Receiver",
-            media_class=MEDIA_CLASS_DIRECTORY,
+            media_class=MediaClass.DIRECTORY,
             media_content_id="root",
             media_content_type="library",
             can_play=False,
@@ -237,7 +237,7 @@ class ArcamFmj(MediaPlayerEntity):
         return root
 
     async def async_play_media(
-        self, media_type: str, media_id: str, **kwargs: Any
+        self, media_type: MediaType | str, media_id: str, **kwargs: Any
     ) -> None:
         """Play media."""
 
@@ -289,13 +289,13 @@ class ArcamFmj(MediaPlayerEntity):
         return value / 99.0
 
     @property
-    def media_content_type(self):
+    def media_content_type(self) -> MediaType | None:
         """Content type of current playing media."""
         source = self._state.get_source()
         if source == SourceCodes.DAB:
-            value = MEDIA_TYPE_MUSIC
+            value = MediaType.MUSIC
         elif source == SourceCodes.FM:
-            value = MEDIA_TYPE_MUSIC
+            value = MediaType.MUSIC
         else:
             value = None
         return value

homeassistant/components/blackbird/media_player.py

@@ -12,6 +12,7 @@ from homeassistant.components.media_player import (
     PLATFORM_SCHEMA,
     MediaPlayerEntity,
     MediaPlayerEntityFeature,
+    MediaPlayerState,
 )
 from homeassistant.const import (
     ATTR_ENTITY_ID,
@@ -19,8 +20,6 @@ from homeassistant.const import (
     CONF_NAME,
     CONF_PORT,
     CONF_TYPE,
-    STATE_OFF,
-    STATE_ON,
 )
 from homeassistant.core import HomeAssistant, ServiceCall
 import homeassistant.helpers.config_validation as cv
@@ -163,7 +162,7 @@ class BlackbirdZone(MediaPlayerEntity):
         state = self._blackbird.zone_status(self._zone_id)
         if not state:
             return
-        self._attr_state = STATE_ON if state.power else STATE_OFF
+        self._attr_state = MediaPlayerState.ON if state.power else MediaPlayerState.OFF
         idx = state.av
         if idx in self._source_id_name:
             self._attr_source = self._source_id_name[idx]

homeassistant/components/bluesound/media_player.py

@@ -21,12 +21,12 @@ from homeassistant.components.media_player import (
     PLATFORM_SCHEMA,
     MediaPlayerEntity,
     MediaPlayerEntityFeature,
+    MediaType,
 )
 from homeassistant.components.media_player.browse_media import (
     BrowseMedia,
     async_process_play_media_url,
 )
-from homeassistant.components.media_player.const import MEDIA_TYPE_MUSIC
 from homeassistant.const import (
     ATTR_ENTITY_ID,
     CONF_HOST,
@@ -205,6 +205,8 @@ async def async_setup_platform(
 class BluesoundPlayer(MediaPlayerEntity):
     """Representation of a Bluesound Player."""
 
+    _attr_media_content_type = MediaType.MUSIC
+
     def __init__(self, hass, host, port=None, name=None, init_callback=None):
         """Initialize the media player."""
         self.host = host
@@ -551,11 +553,6 @@ class BluesoundPlayer(MediaPlayerEntity):
 
         return self._services_items
 
-    @property
-    def media_content_type(self):
-        """Content type of current playing media."""
-        return MEDIA_TYPE_MUSIC
-
     @property
     def state(self):
         """Return the state of the device."""
@@ -1022,7 +1019,7 @@ class BluesoundPlayer(MediaPlayerEntity):
         return await self.send_bluesound_command(f"Play?seek={float(position)}")
 
     async def async_play_media(
-        self, media_type: str, media_id: str, **kwargs: Any
+        self, media_type: MediaType | str, media_id: str, **kwargs: Any
     ) -> None:
         """Send the play_media command to the media player."""
         if self.is_grouped and not self.is_master:
@@ -1069,7 +1066,9 @@ class BluesoundPlayer(MediaPlayerEntity):
         return await self.send_bluesound_command("Volume?mute=0")
 
     async def async_browse_media(
-        self, media_content_type: str | None = None, media_content_id: str | None = None
+        self,
+        media_content_type: MediaType | str | None = None,
+        media_content_id: str | None = None,
     ) -> BrowseMedia:
         """Implement the websocket media browsing helper."""
         return await media_source.async_browse_media(

homeassistant/components/braviatv/coordinator.py

@@ -16,10 +16,7 @@ from pybravia import (
 )
 from typing_extensions import Concatenate, ParamSpec
 
-from homeassistant.components.media_player.const import (
+from homeassistant.components.media_player import MediaType
-    MEDIA_TYPE_APP,
-    MEDIA_TYPE_CHANNEL,
-)
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.debounce import Debouncer
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
@@ -74,7 +71,7 @@ class BraviaTVCoordinator(DataUpdateCoordinator[None]):
         self.source_map: dict[str, dict] = {}
         self.media_title: str | None = None
         self.media_content_id: str | None = None
-        self.media_content_type: str | None = None
+        self.media_content_type: MediaType | None = None
         self.media_uri: str | None = None
         self.media_duration: int | None = None
         self.volume_level: float | None = None
@@ -182,7 +179,7 @@ class BraviaTVCoordinator(DataUpdateCoordinator[None]):
             self.is_channel = self.media_uri[:2] == "tv"
             if self.is_channel:
                 self.media_content_id = playing_info.get("dispNum")
-                self.media_content_type = MEDIA_TYPE_CHANNEL
+                self.media_content_type = MediaType.CHANNEL
             else:
                 self.media_content_id = self.media_uri
                 self.media_content_type = None
@@ -193,7 +190,7 @@ class BraviaTVCoordinator(DataUpdateCoordinator[None]):
             self.media_content_type = None
         if not playing_info:
             self.media_title = "Smart TV"
-            self.media_content_type = MEDIA_TYPE_APP
+            self.media_content_type = MediaType.APP
 
     @catch_braviatv_errors
     async def async_turn_on(self) -> None:

homeassistant/components/braviatv/media_player.py

@@ -5,9 +5,10 @@ from homeassistant.components.media_player import (
     MediaPlayerDeviceClass,
     MediaPlayerEntity,
     MediaPlayerEntityFeature,
+    MediaPlayerState,
+    MediaType,
 )
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import STATE_OFF, STATE_PAUSED, STATE_PLAYING
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 
@@ -50,11 +51,15 @@ class BraviaTVMediaPlayer(BraviaTVEntity, MediaPlayerEntity):
     )
 
     @property
-    def state(self) -> str | None:
+    def state(self) -> MediaPlayerState:
         """Return the state of the device."""
         if self.coordinator.is_on:
-            return STATE_PLAYING if self.coordinator.playing else STATE_PAUSED
+            return (
-        return STATE_OFF
+                MediaPlayerState.PLAYING
+                if self.coordinator.playing
+                else MediaPlayerState.PAUSED
+            )
+        return MediaPlayerState.OFF
 
     @property
     def source(self) -> str | None:
@@ -87,7 +92,7 @@ class BraviaTVMediaPlayer(BraviaTVEntity, MediaPlayerEntity):
         return self.coordinator.media_content_id
 
     @property
-    def media_content_type(self) -> str | None:
+    def media_content_type(self) -> MediaType | None:
         """Content type of current playing media."""
         return self.coordinator.media_content_type
 

homeassistant/components/channels/media_player.py

@@ -10,22 +10,10 @@ from homeassistant.components.media_player import (
     PLATFORM_SCHEMA,
     MediaPlayerEntity,
     MediaPlayerEntityFeature,
+    MediaPlayerState,
+    MediaType,
 )
-from homeassistant.components.media_player.const import (
+from homeassistant.const import ATTR_SECONDS, CONF_HOST, CONF_NAME, CONF_PORT
-    MEDIA_TYPE_CHANNEL,
-    MEDIA_TYPE_EPISODE,
-    MEDIA_TYPE_MOVIE,
-    MEDIA_TYPE_TVSHOW,
-)
-from homeassistant.const import (
-    ATTR_SECONDS,
-    CONF_HOST,
-    CONF_NAME,
-    CONF_PORT,
-    STATE_IDLE,
-    STATE_PAUSED,
-    STATE_PLAYING,
-)
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import config_validation as cv, entity_platform
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
@@ -78,6 +66,7 @@ async def async_setup_platform(
 class ChannelsPlayer(MediaPlayerEntity):
     """Representation of a Channels instance."""
 
+    _attr_media_content_type = MediaType.CHANNEL
     _attr_supported_features = (
         MediaPlayerEntityFeature.PLAY
         | MediaPlayerEntityFeature.PAUSE
@@ -156,16 +145,16 @@ class ChannelsPlayer(MediaPlayerEntity):
         return self._name
 
     @property
-    def state(self):
+    def state(self) -> MediaPlayerState | None:
         """Return the state of the player."""
         if self.status == "stopped":
-            return STATE_IDLE
+            return MediaPlayerState.IDLE
 
         if self.status == "paused":
-            return STATE_PAUSED
+            return MediaPlayerState.PAUSED
 
         if self.status == "playing":
-            return STATE_PLAYING
+            return MediaPlayerState.PLAYING
 
         return None
 
@@ -190,11 +179,6 @@ class ChannelsPlayer(MediaPlayerEntity):
         """Content ID of current playing channel."""
         return self.channel_number
 
-    @property
-    def media_content_type(self):
-        """Content type of current playing media."""
-        return MEDIA_TYPE_CHANNEL
-
     @property
     def media_image_url(self):
         """Image url of current playing media."""
@@ -253,12 +237,14 @@ class ChannelsPlayer(MediaPlayerEntity):
                 self.update_state(response)
                 break
 
-    def play_media(self, media_type: str, media_id: str, **kwargs: Any) -> None:
+    def play_media(
+        self, media_type: MediaType | str, media_id: str, **kwargs: Any
+    ) -> None:
         """Send the play_media command to the player."""
-        if media_type == MEDIA_TYPE_CHANNEL:
+        if media_type == MediaType.CHANNEL:
             response = self.client.play_channel(media_id)
             self.update_state(response)
-        elif media_type in (MEDIA_TYPE_MOVIE, MEDIA_TYPE_EPISODE, MEDIA_TYPE_TVSHOW):
+        elif media_type in {MediaType.MOVIE, MediaType.EPISODE, MediaType.TVSHOW}:
             response = self.client.play_recording(media_id)
             self.update_state(response)
 

homeassistant/components/clementine/media_player.py

@@ -11,17 +11,10 @@ from homeassistant.components.media_player import (
     PLATFORM_SCHEMA,
     MediaPlayerEntity,
     MediaPlayerEntityFeature,
+    MediaPlayerState,
+    MediaType,
 )
-from homeassistant.components.media_player.const import MEDIA_TYPE_MUSIC
+from homeassistant.const import CONF_ACCESS_TOKEN, CONF_HOST, CONF_NAME, CONF_PORT
-from homeassistant.const import (
-    CONF_ACCESS_TOKEN,
-    CONF_HOST,
-    CONF_NAME,
-    CONF_PORT,
-    STATE_OFF,
-    STATE_PAUSED,
-    STATE_PLAYING,
-)
 from homeassistant.core import HomeAssistant
 import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
@@ -62,7 +55,7 @@ def setup_platform(
 class ClementineDevice(MediaPlayerEntity):
     """Representation of Clementine Player."""
 
-    _attr_media_content_type = MEDIA_TYPE_MUSIC
+    _attr_media_content_type = MediaType.MUSIC
     _attr_supported_features = (
         MediaPlayerEntityFeature.PAUSE
         | MediaPlayerEntityFeature.VOLUME_STEP
@@ -84,16 +77,16 @@ class ClementineDevice(MediaPlayerEntity):
             client = self._client
 
             if client.state == "Playing":
-                self._attr_state = STATE_PLAYING
+                self._attr_state = MediaPlayerState.PLAYING
             elif client.state == "Paused":
-                self._attr_state = STATE_PAUSED
+                self._attr_state = MediaPlayerState.PAUSED
             elif client.state == "Disconnected":
-                self._attr_state = STATE_OFF
+                self._attr_state = MediaPlayerState.OFF
             else:
-                self._attr_state = STATE_PAUSED
+                self._attr_state = MediaPlayerState.PAUSED
 
             if client.last_update and (time.time() - client.last_update > 40):
-                self._attr_state = STATE_OFF
+                self._attr_state = MediaPlayerState.OFF
 
             volume = float(client.volume) if client.volume else 0.0
             self._attr_volume_level = volume / 100.0
@@ -112,7 +105,7 @@ class ClementineDevice(MediaPlayerEntity):
                 self._attr_media_image_hash = None
 
         except Exception:
-            self._attr_state = STATE_OFF
+            self._attr_state = MediaPlayerState.OFF
             raise
 
     def select_source(self, source: str) -> None:
@@ -150,19 +143,19 @@ class ClementineDevice(MediaPlayerEntity):
 
     def media_play_pause(self) -> None:
         """Simulate play pause media player."""
-        if self.state == STATE_PLAYING:
+        if self.state == MediaPlayerState.PLAYING:
             self.media_pause()
         else:
             self.media_play()
 
     def media_play(self) -> None:
         """Send play command."""
-        self._attr_state = STATE_PLAYING
+        self._attr_state = MediaPlayerState.PLAYING
         self._client.play()
 
     def media_pause(self) -> None:
         """Send media pause command to media player."""
-        self._attr_state = STATE_PAUSED
+        self._attr_state = MediaPlayerState.PAUSED
         self._client.pause()
 
     def media_next_track(self) -> None:

homeassistant/components/cmus/media_player.py

@@ -11,20 +11,10 @@ from homeassistant.components.media_player import (
     PLATFORM_SCHEMA,
     MediaPlayerEntity,
     MediaPlayerEntityFeature,
+    MediaPlayerState,
+    MediaType,
 )
-from homeassistant.components.media_player.const import (
+from homeassistant.const import CONF_HOST, CONF_NAME, CONF_PASSWORD, CONF_PORT
-    MEDIA_TYPE_MUSIC,
-    MEDIA_TYPE_PLAYLIST,
-)
-from homeassistant.const import (
-    CONF_HOST,
-    CONF_NAME,
-    CONF_PASSWORD,
-    CONF_PORT,
-    STATE_OFF,
-    STATE_PAUSED,
-    STATE_PLAYING,
-)
 from homeassistant.core import HomeAssistant
 import homeassistant.helpers.config_validation as cv
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
@@ -92,7 +82,7 @@ class CmusRemote:
 class CmusDevice(MediaPlayerEntity):
     """Representation of a running cmus."""
 
-    _attr_media_content_type = MEDIA_TYPE_MUSIC
+    _attr_media_content_type = MediaType.MUSIC
     _attr_supported_features = (
         MediaPlayerEntityFeature.PAUSE
         | MediaPlayerEntityFeature.VOLUME_SET
@@ -128,11 +118,11 @@ class CmusDevice(MediaPlayerEntity):
         else:
             self.status = status
             if self.status.get("status") == "playing":
-                self._attr_state = STATE_PLAYING
+                self._attr_state = MediaPlayerState.PLAYING
             elif self.status.get("status") == "paused":
-                self._attr_state = STATE_PAUSED
+                self._attr_state = MediaPlayerState.PAUSED
             else:
-                self._attr_state = STATE_OFF
+                self._attr_state = MediaPlayerState.OFF
             self._attr_media_content_id = self.status.get("file")
             self._attr_media_duration = self.status.get("duration")
             self._attr_media_title = self.status["tag"].get("title")
@@ -187,16 +177,18 @@ class CmusDevice(MediaPlayerEntity):
         if current_volume <= 100:
             self._remote.cmus.set_volume(int(current_volume) - 5)
 
-    def play_media(self, media_type: str, media_id: str, **kwargs: Any) -> None:
+    def play_media(
+        self, media_type: MediaType | str, media_id: str, **kwargs: Any
+    ) -> None:
         """Send the play command."""
-        if media_type in [MEDIA_TYPE_MUSIC, MEDIA_TYPE_PLAYLIST]:
+        if media_type in {MediaType.MUSIC, MediaType.PLAYLIST}:
             self._remote.cmus.player_play_file(media_id)
         else:
             _LOGGER.error(
                 "Invalid media type %s. Only %s and %s are supported",
                 media_type,
-                MEDIA_TYPE_MUSIC,
+                MediaType.MUSIC,
-                MEDIA_TYPE_PLAYLIST,
+                MediaType.PLAYLIST,
             )
 
     def media_pause(self) -> None:

homeassistant/components/denon/media_player.py

@@ -10,8 +10,9 @@ from homeassistant.components.media_player import (
     PLATFORM_SCHEMA,
     MediaPlayerEntity,
     MediaPlayerEntityFeature,
+    MediaPlayerState,
 )
-from homeassistant.const import CONF_HOST, CONF_NAME, STATE_OFF, STATE_ON
+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
@@ -214,12 +215,12 @@ class DenonDevice(MediaPlayerEntity):
         return self._name
 
     @property
-    def state(self):
+    def state(self) -> MediaPlayerState | None:
         """Return the state of the device."""
         if self._pwstate == "PWSTANDBY":
-            return STATE_OFF
+            return MediaPlayerState.OFF
         if self._pwstate == "PWON":
-            return STATE_ON
+            return MediaPlayerState.ON
 
         return None
 

homeassistant/components/denonavr/media_player.py

@@ -22,19 +22,11 @@ import voluptuous as vol
 from homeassistant.components.media_player import (
     MediaPlayerEntity,
     MediaPlayerEntityFeature,
-)
+    MediaPlayerState,
-from homeassistant.components.media_player.const import (
+    MediaType,
-    MEDIA_TYPE_CHANNEL,
-    MEDIA_TYPE_MUSIC,
 )
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import (
+from homeassistant.const import ATTR_COMMAND, CONF_HOST, CONF_MODEL
-    ATTR_COMMAND,
-    CONF_HOST,
-    CONF_MODEL,
-    STATE_PAUSED,
-    STATE_PLAYING,
-)
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import config_validation as cv, entity_platform
 from homeassistant.helpers.entity import DeviceInfo
@@ -297,11 +289,11 @@ class DenonDevice(MediaPlayerEntity):
         return None
 
     @property
-    def media_content_type(self):
+    def media_content_type(self) -> MediaType:
         """Content type of current playing media."""
-        if self._receiver.state in (STATE_PLAYING, STATE_PAUSED):
+        if self._receiver.state in {MediaPlayerState.PLAYING, MediaPlayerState.PAUSED}:
-            return MEDIA_TYPE_MUSIC
+            return MediaType.MUSIC
-        return MEDIA_TYPE_CHANNEL
+        return MediaType.CHANNEL
 
     @property
     def media_duration(self):

homeassistant/components/directv/media_player.py

@@ -10,15 +10,10 @@ from homeassistant.components.media_player import (
     MediaPlayerDeviceClass,
     MediaPlayerEntity,
     MediaPlayerEntityFeature,
-)
+    MediaPlayerState,
-from homeassistant.components.media_player.const import (
+    MediaType,
-    MEDIA_TYPE_CHANNEL,
-    MEDIA_TYPE_MOVIE,
-    MEDIA_TYPE_MUSIC,
-    MEDIA_TYPE_TVSHOW,
 )
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import STATE_OFF, STATE_PAUSED, STATE_PLAYING
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.util import dt as dt_util
@@ -34,7 +29,7 @@ from .entity import DIRECTVEntity
 
 _LOGGER = logging.getLogger(__name__)
 
-KNOWN_MEDIA_TYPES = [MEDIA_TYPE_MOVIE, MEDIA_TYPE_MUSIC, MEDIA_TYPE_TVSHOW]
+KNOWN_MEDIA_TYPES = {MediaType.MOVIE, MediaType.MUSIC, MediaType.TVSHOW}
 
 SUPPORT_DTV = (
     MediaPlayerEntityFeature.PAUSE
@@ -134,18 +129,18 @@ class DIRECTVMediaPlayer(DIRECTVEntity, MediaPlayerEntity):
 
     # MediaPlayerEntity properties and methods
     @property
-    def state(self):
+    def state(self) -> MediaPlayerState:
         """Return the state of the device."""
         if self._is_standby:
-            return STATE_OFF
+            return MediaPlayerState.OFF
 
         # For recorded media we can determine if it is paused or not.
         # For live media we're unable to determine and will always return
         # playing instead.
         if self._paused:
-            return STATE_PAUSED
+            return MediaPlayerState.PAUSED
 
-        return STATE_PLAYING
+        return MediaPlayerState.PLAYING
 
     @property
     def media_content_id(self):
@@ -156,7 +151,7 @@ class DIRECTVMediaPlayer(DIRECTVEntity, MediaPlayerEntity):
         return self._program.program_id
 
     @property
-    def media_content_type(self):
+    def media_content_type(self) -> MediaType | None:
         """Return the content type of current playing media."""
         if self._is_standby or self._program is None:
             return None
@@ -164,7 +159,7 @@ class DIRECTVMediaPlayer(DIRECTVEntity, MediaPlayerEntity):
         if self._program.program_type in KNOWN_MEDIA_TYPES:
             return self._program.program_type
 
-        return MEDIA_TYPE_MOVIE
+        return MediaType.MOVIE
 
     @property
     def media_duration(self):
@@ -196,7 +191,7 @@ class DIRECTVMediaPlayer(DIRECTVEntity, MediaPlayerEntity):
         if self._is_standby or self._program is None:
             return None
 
-        if self.media_content_type == MEDIA_TYPE_MUSIC:
+        if self.media_content_type == MediaType.MUSIC:
             return self._program.music_title
 
         return self._program.title
@@ -320,14 +315,14 @@ class DIRECTVMediaPlayer(DIRECTVEntity, MediaPlayerEntity):
         await self.dtv.remote("ffwd", self._address)
 
     async def async_play_media(
-        self, media_type: str, media_id: str, **kwargs: Any
+        self, media_type: MediaType | str, media_id: str, **kwargs: Any
     ) -> None:
         """Select input source."""
-        if media_type != MEDIA_TYPE_CHANNEL:
+        if media_type != MediaType.CHANNEL:
             _LOGGER.error(
                 "Invalid media type %s. Only %s is supported",
                 media_type,
-                MEDIA_TYPE_CHANNEL,
+                MediaType.CHANNEL,
             )
             return
 

homeassistant/components/dunehd/media_player.py

@@ -8,9 +8,9 @@ from pdunehd import DuneHDPlayer
 from homeassistant.components.media_player import (
     MediaPlayerEntity,
     MediaPlayerEntityFeature,
+    MediaPlayerState,
 )
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import STATE_OFF, STATE_ON, STATE_PAUSED, STATE_PLAYING
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.entity import DeviceInfo
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
@@ -57,17 +57,17 @@ class DuneHDPlayerEntity(MediaPlayerEntity):
         self.__update_title()
 
     @property
-    def state(self) -> str | None:
+    def state(self) -> MediaPlayerState:
         """Return player state."""
-        state = STATE_OFF
+        state = MediaPlayerState.OFF
         if "playback_position" in self._state:
-            state = STATE_PLAYING
+            state = MediaPlayerState.PLAYING
         if self._state.get("player_state") in ("playing", "buffering", "photo_viewer"):
-            state = STATE_PLAYING
+            state = MediaPlayerState.PLAYING
         if int(self._state.get("playback_speed", 1234)) == 0:
-            state = STATE_PAUSED
+            state = MediaPlayerState.PAUSED
         if self._state.get("player_state") == "navigator":
-            state = STATE_ON
+            state = MediaPlayerState.ON
         return state
 
     @property