Implement Google Assistant media traits

homeassistant/components/google_assistant/trait.py

@@ -42,17 +42,21 @@
     STATE_ALARM_DISARMED,
     STATE_ALARM_PENDING,
     STATE_ALARM_TRIGGERED,
+    STATE_IDLE,
     STATE_LOCKED,
     STATE_OFF,
     STATE_ON,
+    STATE_PAUSED,
+    STATE_PLAYING,
+    STATE_STANDBY,
     STATE_UNAVAILABLE,
     STATE_UNKNOWN,
     TEMP_CELSIUS,
     TEMP_FAHRENHEIT,
 )
 from homeassistant.core import DOMAIN as HA_DOMAIN
 from homeassistant.helpers.network import get_url
-from homeassistant.util import color as color_util, temperature as temp_util
+from homeassistant.util import color as color_util, dt, temperature as temp_util
 
 from .const import (
     CHALLENGE_ACK_NEEDED,
@@ -85,6 +89,8 @@
 TRAIT_VOLUME = f"{PREFIX_TRAITS}Volume"
 TRAIT_ARMDISARM = f"{PREFIX_TRAITS}ArmDisarm"
 TRAIT_HUMIDITY_SETTING = f"{PREFIX_TRAITS}HumiditySetting"
+TRAIT_TRANSPORT_CONTROL = f"{PREFIX_TRAITS}TransportControl"
+TRAIT_MEDIA_STATE = f"{PREFIX_TRAITS}MediaState"
 
 PREFIX_COMMANDS = "action.devices.commands."
 COMMAND_ONOFF = f"{PREFIX_COMMANDS}OnOff"
@@ -109,6 +115,15 @@
 COMMAND_SET_VOLUME = f"{PREFIX_COMMANDS}setVolume"
 COMMAND_VOLUME_RELATIVE = f"{PREFIX_COMMANDS}volumeRelative"
 COMMAND_ARMDISARM = f"{PREFIX_COMMANDS}ArmDisarm"
+COMMAND_MEDIA_NEXT = f"{PREFIX_COMMANDS}mediaNext"
+COMMAND_MEDIA_PAUSE = f"{PREFIX_COMMANDS}mediaPause"
+COMMAND_MEDIA_PREVIOUS = f"{PREFIX_COMMANDS}mediaPrevious"
+COMMAND_MEDIA_RESUME = f"{PREFIX_COMMANDS}mediaResume"
+COMMAND_MEDIA_SEEK_RELATIVE = f"{PREFIX_COMMANDS}mediaSeekRelative"
+COMMAND_MEDIA_SEEK_TO_POSITION = f"{PREFIX_COMMANDS}mediaSeekToPosition"
+COMMAND_MEDIA_SHUFFLE = f"{PREFIX_COMMANDS}mediaShuffle"
+COMMAND_MEDIA_STOP = f"{PREFIX_COMMANDS}mediaStop"
+
 
 TRAITS = []
 
@@ -1500,3 +1515,183 @@ def _verify_ack_challenge(data, state, challenge):
         return
     if not challenge or not challenge.get("ack"):
         raise ChallengeNeeded(CHALLENGE_ACK_NEEDED)
+
+
+MEDIA_COMMAND_SUPPORT_MAPPING = {
+    COMMAND_MEDIA_NEXT: media_player.SUPPORT_NEXT_TRACK,
+    COMMAND_MEDIA_PAUSE: media_player.SUPPORT_PAUSE,
+    COMMAND_MEDIA_PREVIOUS: media_player.SUPPORT_PREVIOUS_TRACK,
+    COMMAND_MEDIA_RESUME: media_player.SUPPORT_PLAY,
+    COMMAND_MEDIA_SEEK_RELATIVE: media_player.SUPPORT_SEEK,
+    COMMAND_MEDIA_SEEK_TO_POSITION: media_player.SUPPORT_SEEK,
+    COMMAND_MEDIA_SHUFFLE: media_player.SUPPORT_SHUFFLE_SET,
+    COMMAND_MEDIA_STOP: media_player.SUPPORT_STOP,
+}
+
+MEDIA_COMMAND_ATTRIBUTES = {
+    COMMAND_MEDIA_NEXT: "NEXT",
+    COMMAND_MEDIA_PAUSE: "PAUSE",
+    COMMAND_MEDIA_PREVIOUS: "PREVIOUS",
+    COMMAND_MEDIA_RESUME: "RESUME",
+    COMMAND_MEDIA_SEEK_RELATIVE: "SEEK_RELATIVE",
+    COMMAND_MEDIA_SEEK_TO_POSITION: "SEEK_TO_POSITION",
+    COMMAND_MEDIA_SHUFFLE: "SHUFFLE",
+    COMMAND_MEDIA_STOP: "STOP",
+}
+
+
+@register_trait
+class TransportControlTrait(_Trait):
+    """Trait to control media playback.
+
+    https://developers.google.com/actions/smarthome/traits/transportcontrol
+    """
+
+    name = TRAIT_TRANSPORT_CONTROL
+    commands = [
+        COMMAND_MEDIA_NEXT,
+        COMMAND_MEDIA_PAUSE,
+        COMMAND_MEDIA_PREVIOUS,
+        COMMAND_MEDIA_RESUME,
+        COMMAND_MEDIA_SEEK_RELATIVE,
+        COMMAND_MEDIA_SEEK_TO_POSITION,
+        COMMAND_MEDIA_SHUFFLE,
+        COMMAND_MEDIA_STOP,
+    ]
+
+    @staticmethod
+    def supported(domain, features, device_class):
+        """Test if state is supported."""
+        if domain == media_player.DOMAIN:
+            for feature in MEDIA_COMMAND_SUPPORT_MAPPING.values():
+                if features & feature:
+                    return True
+
+        return False
+
+    def sync_attributes(self):
+        """Return opening direction."""
+        response = {}
+
+        if self.state.domain == media_player.DOMAIN:
+            features = self.state.attributes.get(ATTR_SUPPORTED_FEATURES, 0)
+
+            support = []
+            for command, feature in MEDIA_COMMAND_SUPPORT_MAPPING.items():
+                if features & feature:
+                    support.append(MEDIA_COMMAND_ATTRIBUTES[command])
+            response["transportControlSupportedCommands"] = support
+
+        return response
+
+    def query_attributes(self):
+        """Return the attributes of this trait for this entity."""
+
+        return {}
+
+    async def execute(self, command, data, params, challenge):
+        """Execute a media command."""
+
+        service_attrs = {ATTR_ENTITY_ID: self.state.entity_id}
+
+        if command == COMMAND_MEDIA_SEEK_RELATIVE:
+            service = media_player.SERVICE_MEDIA_SEEK
+
+            rel_position = params["relativePositionMs"] / 1000
+            seconds_since = 0  # Default to 0 seconds
+            if self.state.state == STATE_PLAYING:
+                now = dt.utcnow()
+                upd_at = self.state.attributes.get(
+                    media_player.ATTR_MEDIA_POSITION_UPDATED_AT, now
+                )
+                seconds_since = (now - upd_at).total_seconds()
+            position = self.state.attributes.get(media_player.ATTR_MEDIA_POSITION, 0)
+            max_position = self.state.attributes.get(
+                media_player.ATTR_MEDIA_DURATION, 0
+            )
+            service_attrs[media_player.ATTR_MEDIA_SEEK_POSITION] = min(
+                max(position + seconds_since + rel_position, 0), max_position
+            )
+        elif command == COMMAND_MEDIA_SEEK_TO_POSITION:
+            service = media_player.SERVICE_MEDIA_SEEK
+
+            max_position = self.state.attributes.get(
+                media_player.ATTR_MEDIA_DURATION, 0
+            )
+            service_attrs[media_player.ATTR_MEDIA_SEEK_POSITION] = min(
+                max(params["absPositionMs"] / 1000, 0), max_position
+            )
+        elif command == COMMAND_MEDIA_NEXT:
+            service = media_player.SERVICE_MEDIA_NEXT_TRACK
+        elif command == COMMAND_MEDIA_PAUSE:
+            service = media_player.SERVICE_MEDIA_PAUSE
+        elif command == COMMAND_MEDIA_PREVIOUS:
+            service = media_player.SERVICE_MEDIA_PREVIOUS_TRACK
+        elif command == COMMAND_MEDIA_RESUME:
+            service = media_player.SERVICE_MEDIA_PLAY
+        elif command == COMMAND_MEDIA_SHUFFLE:
+            service = media_player.SERVICE_SHUFFLE_SET
+
+            # Google Assistant only supports enabling shuffle
+            service_attrs[media_player.ATTR_MEDIA_SHUFFLE] = True
+        elif command == COMMAND_MEDIA_STOP:
+            service = media_player.SERVICE_MEDIA_STOP
+        else:
+            raise SmartHomeError(ERR_NOT_SUPPORTED, "Command not supported")
+
+        await self.hass.services.async_call(
+            media_player.DOMAIN,
+            service,
+            service_attrs,
+            blocking=True,
+            context=data.context,
+        )
+
+
+@register_trait
+class MediaStateTrait(_Trait):
+    """Trait to get media playback state.
+
+    https://developers.google.com/actions/smarthome/traits/mediastate
+    """
+
+    name = TRAIT_MEDIA_STATE
+    commands = []
+
+    activity_lookup = {
+        STATE_OFF: "INACTIVE",
+        STATE_IDLE: "STANDBY",
+        STATE_PLAYING: "ACTIVE",
+        STATE_ON: "STANDBY",
+        STATE_PAUSED: "STANDBY",
+        STATE_STANDBY: "STANDBY",
+        STATE_UNAVAILABLE: "INACTIVE",
+        STATE_UNKNOWN: "INACTIVE",
+    }
+
+    playback_lookup = {
+        STATE_OFF: "STOPPED",
+        STATE_IDLE: "STOPPED",
+        STATE_PLAYING: "PLAYING",
+        STATE_ON: "STOPPED",
+        STATE_PAUSED: "PAUSED",
+        STATE_STANDBY: "STOPPED",
+        STATE_UNAVAILABLE: "STOPPED",
+        STATE_UNKNOWN: "STOPPED",
+    }
+
+    @staticmethod
+    def supported(domain, features, device_class):
+        """Test if state is supported."""
+        return domain == media_player.DOMAIN
+
+    def sync_attributes(self):
+        """Return attributes for a sync request."""
+        return {"supportActivityState": True, "supportPlaybackState": True}
+
+    def query_attributes(self):
+        """Return the attributes of this trait for this entity."""
+        return {
+            "activityState": self.activity_lookup.get(self.state.state, "INACTIVE"),
+            "playbackState": self.playback_lookup.get(self.state.state, "STOPPED"),
+        }

tests/components/google_assistant/__init__.py

@@ -167,6 +167,8 @@ def should_2fa(self, state):
             "action.devices.traits.OnOff",
             "action.devices.traits.Volume",
             "action.devices.traits.Modes",
+            "action.devices.traits.TransportControl",
+            "action.devices.traits.MediaState",
         ],
         "type": "action.devices.types.SETTOP",
         "willReportState": False,
@@ -178,14 +180,21 @@ def should_2fa(self, state):
             "action.devices.traits.OnOff",
             "action.devices.traits.Volume",
             "action.devices.traits.Modes",
+            "action.devices.traits.TransportControl",
+            "action.devices.traits.MediaState",
         ],
         "type": "action.devices.types.SETTOP",
         "willReportState": False,
     },
     {
         "id": "media_player.lounge_room",
         "name": {"name": "Lounge room"},
-        "traits": ["action.devices.traits.OnOff", "action.devices.traits.Modes"],
+        "traits": [
+            "action.devices.traits.OnOff",
+            "action.devices.traits.Modes",
+            "action.devices.traits.TransportControl",
+            "action.devices.traits.MediaState",
+        ],
         "type": "action.devices.types.SETTOP",
         "willReportState": False,
     },
@@ -196,6 +205,8 @@ def should_2fa(self, state):
             "action.devices.traits.OnOff",
             "action.devices.traits.Volume",
             "action.devices.traits.Modes",
+            "action.devices.traits.TransportControl",
+            "action.devices.traits.MediaState",
         ],
         "type": "action.devices.types.SETTOP",
         "willReportState": False,

tests/components/google_assistant/test_smart_home.py

@@ -769,10 +769,16 @@ async def test_device_media_player(hass, device_class, google_type):
             "agentUserId": "test-agent",
             "devices": [
                 {
-                    "attributes": {},
+                    "attributes": {
+                        "supportActivityState": True,
+                        "supportPlaybackState": True,
+                    },
                     "id": sensor.entity_id,
                     "name": {"name": sensor.name},
-                    "traits": ["action.devices.traits.OnOff"],
+                    "traits": [
+                        "action.devices.traits.OnOff",
+                        "action.devices.traits.MediaState",
+                    ],
                     "type": google_type,
                     "willReportState": False,
                 }