bumble 0.0.222__py3-none-any.whl → 0.0.224__py3-none-any.whl

bumble/avrcp.py

@@ -26,7 +26,7 @@ from collections.abc import AsyncIterator, Awaitable, Callable, Iterable, Sequen
 from dataclasses import dataclass, field
 from typing import ClassVar, SupportsBytes, TypeVar
 
-from bumble import avc, avctp, core, hci, l2cap, utils
+from bumble import avc, avctp, core, hci, l2cap, sdp, utils
 from bumble.colors import color
 from bumble.device import Connection, Device
 from bumble.sdp import (
@@ -55,13 +55,15 @@ AVRCP_PID = 0x110E
 AVRCP_BLUETOOTH_SIG_COMPANY_ID = 0x001958
 
 
-_UINT64_BE_METADATA = {
-    'parser': lambda data, offset: (
-        offset + 8,
-        int.from_bytes(data[offset : offset + 8], byteorder='big'),
-    ),
-    'serializer': lambda x: x.to_bytes(8, byteorder='big'),
-}
+_UINT64_BE_METADATA = hci.metadata(
+    {
+        'parser': lambda data, offset: (
+            offset + 8,
+            int.from_bytes(data[offset : offset + 8], byteorder='big'),
+        ),
+        'serializer': lambda x: x.to_bytes(8, byteorder='big'),
+    }
+)
 
 
 class PduId(utils.OpenIntEnum):
@@ -92,7 +94,7 @@ class PduId(utils.OpenIntEnum):
 
 
 class CharacterSetId(hci.SpecableEnum):
-    UTF_8 = 0x06
+    UTF_8 = 0x6A
 
 
 class MediaAttributeId(hci.SpecableEnum):
@@ -192,82 +194,43 @@ class TargetFeatures(enum.IntFlag):
 
 
 # -----------------------------------------------------------------------------
-def make_controller_service_sdp_records(
-    service_record_handle: int,
-    avctp_version: tuple[int, int] = (1, 4),
-    avrcp_version: tuple[int, int] = (1, 6),
-    supported_features: int | ControllerFeatures = 1,
-) -> list[ServiceAttribute]:
-    avctp_version_int = avctp_version[0] << 8 | avctp_version[1]
-    avrcp_version_int = avrcp_version[0] << 8 | avrcp_version[1]
+@dataclass
+class ControllerServiceSdpRecord:
+    service_record_handle: int
+    avctp_version: tuple[int, int] = (1, 4)
+    avrcp_version: tuple[int, int] = (1, 6)
+    supported_features: int | ControllerFeatures = ControllerFeatures(1)
 
-    attributes = [
-        ServiceAttribute(
-            SDP_SERVICE_RECORD_HANDLE_ATTRIBUTE_ID,
-            DataElement.unsigned_integer_32(service_record_handle),
-        ),
-        ServiceAttribute(
-            SDP_BROWSE_GROUP_LIST_ATTRIBUTE_ID,
-            DataElement.sequence([DataElement.uuid(SDP_PUBLIC_BROWSE_ROOT)]),
-        ),
-        ServiceAttribute(
-            SDP_SERVICE_CLASS_ID_LIST_ATTRIBUTE_ID,
-            DataElement.sequence(
-                [
-                    DataElement.uuid(core.BT_AV_REMOTE_CONTROL_SERVICE),
-                    DataElement.uuid(core.BT_AV_REMOTE_CONTROL_CONTROLLER_SERVICE),
-                ]
+    def to_service_attributes(self) -> list[ServiceAttribute]:
+        avctp_version_int = self.avctp_version[0] << 8 | self.avctp_version[1]
+        avrcp_version_int = self.avrcp_version[0] << 8 | self.avrcp_version[1]
+
+        attributes = [
+            ServiceAttribute(
+                SDP_SERVICE_RECORD_HANDLE_ATTRIBUTE_ID,
+                DataElement.unsigned_integer_32(self.service_record_handle),
             ),
-        ),
-        ServiceAttribute(
-            SDP_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID,
-            DataElement.sequence(
-                [
-                    DataElement.sequence(
-                        [
-                            DataElement.uuid(core.BT_L2CAP_PROTOCOL_ID),
-                            DataElement.unsigned_integer_16(avctp.AVCTP_PSM),
-                        ]
-                    ),
-                    DataElement.sequence(
-                        [
-                            DataElement.uuid(core.BT_AVCTP_PROTOCOL_ID),
-                            DataElement.unsigned_integer_16(avctp_version_int),
-                        ]
-                    ),
-                ]
+            ServiceAttribute(
+                SDP_BROWSE_GROUP_LIST_ATTRIBUTE_ID,
+                DataElement.sequence([DataElement.uuid(SDP_PUBLIC_BROWSE_ROOT)]),
             ),
-        ),
-        ServiceAttribute(
-            SDP_BLUETOOTH_PROFILE_DESCRIPTOR_LIST_ATTRIBUTE_ID,
-            DataElement.sequence(
-                [
-                    DataElement.sequence(
-                        [
-                            DataElement.uuid(core.BT_AV_REMOTE_CONTROL_SERVICE),
-                            DataElement.unsigned_integer_16(avrcp_version_int),
-                        ]
-                    ),
-                ]
+            ServiceAttribute(
+                SDP_SERVICE_CLASS_ID_LIST_ATTRIBUTE_ID,
+                DataElement.sequence(
+                    [
+                        DataElement.uuid(core.BT_AV_REMOTE_CONTROL_SERVICE),
+                        DataElement.uuid(core.BT_AV_REMOTE_CONTROL_CONTROLLER_SERVICE),
+                    ]
+                ),
             ),
-        ),
-        ServiceAttribute(
-            SDP_SUPPORTED_FEATURES_ATTRIBUTE_ID,
-            DataElement.unsigned_integer_16(supported_features),
-        ),
-    ]
-    if supported_features & ControllerFeatures.SUPPORTS_BROWSING:
-        attributes.append(
             ServiceAttribute(
-                SDP_ADDITIONAL_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID,
+                SDP_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID,
                 DataElement.sequence(
                     [
                         DataElement.sequence(
                             [
                                 DataElement.uuid(core.BT_L2CAP_PROTOCOL_ID),
-                                DataElement.unsigned_integer_16(
-                                    avctp.AVCTP_BROWSING_PSM
-                                ),
+                                DataElement.unsigned_integer_16(avctp.AVCTP_PSM),
                             ]
                         ),
                         DataElement.sequence(
@@ -279,87 +242,130 @@ def make_controller_service_sdp_records(
                     ]
                 ),
             ),
-        )
-    return attributes
-
-
-# -----------------------------------------------------------------------------
-def make_target_service_sdp_records(
-    service_record_handle: int,
-    avctp_version: tuple[int, int] = (1, 4),
-    avrcp_version: tuple[int, int] = (1, 6),
-    supported_features: int | TargetFeatures = 0x23,
-) -> list[ServiceAttribute]:
-    # TODO: support a way to compute the supported features from a feature list
-    avctp_version_int = avctp_version[0] << 8 | avctp_version[1]
-    avrcp_version_int = avrcp_version[0] << 8 | avrcp_version[1]
-
-    attributes = [
-        ServiceAttribute(
-            SDP_SERVICE_RECORD_HANDLE_ATTRIBUTE_ID,
-            DataElement.unsigned_integer_32(service_record_handle),
-        ),
-        ServiceAttribute(
-            SDP_BROWSE_GROUP_LIST_ATTRIBUTE_ID,
-            DataElement.sequence([DataElement.uuid(SDP_PUBLIC_BROWSE_ROOT)]),
-        ),
-        ServiceAttribute(
-            SDP_SERVICE_CLASS_ID_LIST_ATTRIBUTE_ID,
-            DataElement.sequence(
-                [
-                    DataElement.uuid(core.BT_AV_REMOTE_CONTROL_TARGET_SERVICE),
-                ]
+            ServiceAttribute(
+                SDP_BLUETOOTH_PROFILE_DESCRIPTOR_LIST_ATTRIBUTE_ID,
+                DataElement.sequence(
+                    [
+                        DataElement.sequence(
+                            [
+                                DataElement.uuid(core.BT_AV_REMOTE_CONTROL_SERVICE),
+                                DataElement.unsigned_integer_16(avrcp_version_int),
+                            ]
+                        ),
+                    ]
+                ),
             ),
-        ),
-        ServiceAttribute(
-            SDP_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID,
-            DataElement.sequence(
-                [
-                    DataElement.sequence(
-                        [
-                            DataElement.uuid(core.BT_L2CAP_PROTOCOL_ID),
-                            DataElement.unsigned_integer_16(avctp.AVCTP_PSM),
-                        ]
-                    ),
-                    DataElement.sequence(
-                        [
-                            DataElement.uuid(core.BT_AVCTP_PROTOCOL_ID),
-                            DataElement.unsigned_integer_16(avctp_version_int),
-                        ]
-                    ),
-                ]
+            ServiceAttribute(
+                SDP_SUPPORTED_FEATURES_ATTRIBUTE_ID,
+                DataElement.unsigned_integer_16(self.supported_features),
             ),
-        ),
-        ServiceAttribute(
-            SDP_BLUETOOTH_PROFILE_DESCRIPTOR_LIST_ATTRIBUTE_ID,
-            DataElement.sequence(
-                [
+        ]
+        if self.supported_features & ControllerFeatures.SUPPORTS_BROWSING:
+            attributes.append(
+                ServiceAttribute(
+                    SDP_ADDITIONAL_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID,
                     DataElement.sequence(
                         [
-                            DataElement.uuid(core.BT_AV_REMOTE_CONTROL_SERVICE),
-                            DataElement.unsigned_integer_16(avrcp_version_int),
+                            DataElement.sequence(
+                                [
+                                    DataElement.uuid(core.BT_L2CAP_PROTOCOL_ID),
+                                    DataElement.unsigned_integer_16(
+                                        avctp.AVCTP_BROWSING_PSM
+                                    ),
+                                ]
+                            ),
+                            DataElement.sequence(
+                                [
+                                    DataElement.uuid(core.BT_AVCTP_PROTOCOL_ID),
+                                    DataElement.unsigned_integer_16(avctp_version_int),
+                                ]
+                            ),
                         ]
                     ),
-                ]
+                ),
+            )
+        return attributes
+
+    @classmethod
+    async def find(cls, connection: Connection) -> list[ControllerServiceSdpRecord]:
+        async with sdp.Client(connection) as sdp_client:
+            search_result = await sdp_client.search_attributes(
+                uuids=[core.BT_AV_REMOTE_CONTROL_CONTROLLER_SERVICE],
+                attribute_ids=[
+                    SDP_SERVICE_RECORD_HANDLE_ATTRIBUTE_ID,
+                    SDP_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID,
+                    SDP_BLUETOOTH_PROFILE_DESCRIPTOR_LIST_ATTRIBUTE_ID,
+                    SDP_SUPPORTED_FEATURES_ATTRIBUTE_ID,
+                ],
+            )
+
+            records: list[ControllerServiceSdpRecord] = []
+            for attribute_lists in search_result:
+                record = cls(0)
+                for attribute in attribute_lists:
+                    if attribute.id == SDP_SERVICE_RECORD_HANDLE_ATTRIBUTE_ID:
+                        record.service_record_handle = attribute.value.value
+                    elif attribute.id == SDP_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID:
+                        # [[L2CAP, PSM], [AVCTP, version]]
+                        record.avctp_version = (
+                            attribute.value.value[1].value[1].value >> 8,
+                            attribute.value.value[1].value[1].value & 0xFF,
+                        )
+                    elif (
+                        attribute.id
+                        == SDP_BLUETOOTH_PROFILE_DESCRIPTOR_LIST_ATTRIBUTE_ID
+                    ):
+                        # [[AV_REMOTE_CONTROL, version]]
+                        record.avrcp_version = (
+                            attribute.value.value[0].value[1].value >> 8,
+                            attribute.value.value[0].value[1].value & 0xFF,
+                        )
+                    elif attribute.id == SDP_SUPPORTED_FEATURES_ATTRIBUTE_ID:
+                        record.supported_features = ControllerFeatures(
+                            attribute.value.value
+                        )
+                records.append(record)
+            return records
+
+
+# -----------------------------------------------------------------------------
+@dataclass
+class TargetServiceSdpRecord:
+    service_record_handle: int
+    avctp_version: tuple[int, int] = (1, 4)
+    avrcp_version: tuple[int, int] = (1, 6)
+    supported_features: int | TargetFeatures = TargetFeatures(0x23)
+
+    def to_service_attributes(self) -> list[ServiceAttribute]:
+        # TODO: support a way to compute the supported features from a feature list
+        avctp_version_int = self.avctp_version[0] << 8 | self.avctp_version[1]
+        avrcp_version_int = self.avrcp_version[0] << 8 | self.avrcp_version[1]
+
+        attributes = [
+            ServiceAttribute(
+                SDP_SERVICE_RECORD_HANDLE_ATTRIBUTE_ID,
+                DataElement.unsigned_integer_32(self.service_record_handle),
+            ),
+            ServiceAttribute(
+                SDP_BROWSE_GROUP_LIST_ATTRIBUTE_ID,
+                DataElement.sequence([DataElement.uuid(SDP_PUBLIC_BROWSE_ROOT)]),
+            ),
+            ServiceAttribute(
+                SDP_SERVICE_CLASS_ID_LIST_ATTRIBUTE_ID,
+                DataElement.sequence(
+                    [
+                        DataElement.uuid(core.BT_AV_REMOTE_CONTROL_TARGET_SERVICE),
+                    ]
+                ),
             ),
-        ),
-        ServiceAttribute(
-            SDP_SUPPORTED_FEATURES_ATTRIBUTE_ID,
-            DataElement.unsigned_integer_16(supported_features),
-        ),
-    ]
-    if supported_features & TargetFeatures.SUPPORTS_BROWSING:
-        attributes.append(
             ServiceAttribute(
-                SDP_ADDITIONAL_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID,
+                SDP_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID,
                 DataElement.sequence(
                     [
                         DataElement.sequence(
                             [
                                 DataElement.uuid(core.BT_L2CAP_PROTOCOL_ID),
-                                DataElement.unsigned_integer_16(
-                                    avctp.AVCTP_BROWSING_PSM
-                                ),
+                                DataElement.unsigned_integer_16(avctp.AVCTP_PSM),
                             ]
                         ),
                         DataElement.sequence(
@@ -371,8 +377,90 @@ def make_target_service_sdp_records(
                     ]
                 ),
             ),
-        )
-    return attributes
+            ServiceAttribute(
+                SDP_BLUETOOTH_PROFILE_DESCRIPTOR_LIST_ATTRIBUTE_ID,
+                DataElement.sequence(
+                    [
+                        DataElement.sequence(
+                            [
+                                DataElement.uuid(core.BT_AV_REMOTE_CONTROL_SERVICE),
+                                DataElement.unsigned_integer_16(avrcp_version_int),
+                            ]
+                        ),
+                    ]
+                ),
+            ),
+            ServiceAttribute(
+                SDP_SUPPORTED_FEATURES_ATTRIBUTE_ID,
+                DataElement.unsigned_integer_16(self.supported_features),
+            ),
+        ]
+        if self.supported_features & TargetFeatures.SUPPORTS_BROWSING:
+            attributes.append(
+                ServiceAttribute(
+                    SDP_ADDITIONAL_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID,
+                    DataElement.sequence(
+                        [
+                            DataElement.sequence(
+                                [
+                                    DataElement.uuid(core.BT_L2CAP_PROTOCOL_ID),
+                                    DataElement.unsigned_integer_16(
+                                        avctp.AVCTP_BROWSING_PSM
+                                    ),
+                                ]
+                            ),
+                            DataElement.sequence(
+                                [
+                                    DataElement.uuid(core.BT_AVCTP_PROTOCOL_ID),
+                                    DataElement.unsigned_integer_16(avctp_version_int),
+                                ]
+                            ),
+                        ]
+                    ),
+                ),
+            )
+        return attributes
+
+    @classmethod
+    async def find(cls, connection: Connection) -> list[TargetServiceSdpRecord]:
+        async with sdp.Client(connection) as sdp_client:
+            search_result = await sdp_client.search_attributes(
+                uuids=[core.BT_AV_REMOTE_CONTROL_TARGET_SERVICE],
+                attribute_ids=[
+                    SDP_SERVICE_RECORD_HANDLE_ATTRIBUTE_ID,
+                    SDP_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID,
+                    SDP_BLUETOOTH_PROFILE_DESCRIPTOR_LIST_ATTRIBUTE_ID,
+                    SDP_SUPPORTED_FEATURES_ATTRIBUTE_ID,
+                ],
+            )
+
+            records: list[TargetServiceSdpRecord] = []
+            for attribute_lists in search_result:
+                record = cls(0)
+                for attribute in attribute_lists:
+                    if attribute.id == SDP_SERVICE_RECORD_HANDLE_ATTRIBUTE_ID:
+                        record.service_record_handle = attribute.value.value
+                    elif attribute.id == SDP_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID:
+                        # [[L2CAP, PSM], [AVCTP, version]]
+                        record.avctp_version = (
+                            attribute.value.value[1].value[1].value >> 8,
+                            attribute.value.value[1].value[1].value & 0xFF,
+                        )
+                    elif (
+                        attribute.id
+                        == SDP_BLUETOOTH_PROFILE_DESCRIPTOR_LIST_ATTRIBUTE_ID
+                    ):
+                        # [[AV_REMOTE_CONTROL, version]]
+                        record.avrcp_version = (
+                            attribute.value.value[0].value[1].value >> 8,
+                            attribute.value.value[0].value[1].value & 0xFF,
+                        )
+                    elif attribute.id == SDP_SUPPORTED_FEATURES_ATTRIBUTE_ID:
+                        record.supported_features = TargetFeatures(
+                            attribute.value.value
+                        )
+                records.append(record)
+            return records
 
 
 # -----------------------------------------------------------------------------
@@ -491,14 +579,12 @@ class BrowseableItem:
             **hci.HCI_Object.dict_from_bytes(data, offset + 3, subclass.fields)
         )
         instance._payload = data[3:]
-        return offset + length, instance
+        return offset + length + 3, instance
 
     def __bytes__(self) -> bytes:
         if self._payload is None:
             self._payload = hci.HCI_Object.dict_to_bytes(self.__dict__, self.fields)
-        return (
-            struct.pack('>BH', self.item_type, len(self._payload) + 3) + self._payload
-        )
+        return struct.pack('>BH', self.item_type, len(self._payload)) + self._payload
 
     _Item = TypeVar('_Item', bound='BrowseableItem')
 
@@ -601,11 +687,11 @@ class MediaPlayerItem(BrowseableItem):
         metadata=MajorPlayerType.type_metadata(1)
     )
     player_sub_type: PlayerSubType = field(
-        metadata=PlayerSubType.type_metadata(4, byteorder='big')
+        metadata=PlayerSubType.type_metadata(4, byteorder='little')
     )
     play_status: PlayStatus = field(metadata=PlayStatus.type_metadata(1))
     feature_bitmask: Features = field(
-        metadata=Features.type_metadata(16, byteorder='big')
+        metadata=Features.type_metadata(16, byteorder='little')
     )
     character_set_id: CharacterSetId = field(
         metadata=CharacterSetId.type_metadata(2, byteorder='big')
@@ -634,7 +720,7 @@ class FolderItem(BrowseableItem):
 
     folder_uid: int = field(metadata=_UINT64_BE_METADATA)
     folder_type: FolderType = field(metadata=FolderType.type_metadata(1))
-    is_playable: FolderType = field(metadata=Playable.type_metadata(1))
+    is_playable: Playable = field(metadata=Playable.type_metadata(1))
     character_set_id: CharacterSetId = field(
         metadata=CharacterSetId.type_metadata(2, byteorder='big')
     )
@@ -876,7 +962,7 @@ class GetPlayStatusCommand(Command):
 class GetElementAttributesCommand(Command):
     pdu_id = PduId.GET_ELEMENT_ATTRIBUTES
 
-    identifier: int = field(metadata=hci.metadata(_UINT64_BE_METADATA))
+    identifier: int = field(metadata=_UINT64_BE_METADATA)
     attribute_ids: Sequence[MediaAttributeId] = field(
         metadata=MediaAttributeId.type_metadata(
             4, list_begin=True, list_end=True, byteorder='big'
@@ -951,7 +1037,7 @@ class ChangePathCommand(Command):
 
     uid_counter: int = field(metadata=hci.metadata('>2'))
     direction: Direction = field(metadata=Direction.type_metadata(1))
-    folder_uid: int = field(metadata=hci.metadata(_UINT64_BE_METADATA))
+    folder_uid: int = field(metadata=_UINT64_BE_METADATA)
 
 
 # -----------------------------------------------------------------------------
@@ -961,7 +1047,7 @@ class GetItemAttributesCommand(Command):
     pdu_id = PduId.GET_ITEM_ATTRIBUTES
 
     scope: Scope = field(metadata=Scope.type_metadata(1))
-    uid: int = field(metadata=hci.metadata(_UINT64_BE_METADATA))
+    uid: int = field(metadata=_UINT64_BE_METADATA)
     uid_counter: int = field(metadata=hci.metadata('>2'))
     start_item: int = field(metadata=hci.metadata('>4'))
     end_item: int = field(metadata=hci.metadata('>4'))
@@ -999,7 +1085,7 @@ class PlayItemCommand(Command):
     pdu_id = PduId.PLAY_ITEM
 
     scope: Scope = field(metadata=Scope.type_metadata(1))
-    uid: int = field(metadata=hci.metadata(_UINT64_BE_METADATA))
+    uid: int = field(metadata=_UINT64_BE_METADATA)
     uid_counter: int = field(metadata=hci.metadata('>2'))
 
 
@@ -1010,7 +1096,7 @@ class AddToNowPlayingCommand(Command):
     pdu_id = PduId.ADD_TO_NOW_PLAYING
 
     scope: Scope = field(metadata=Scope.type_metadata(1))
-    uid: int = field(metadata=hci.metadata(_UINT64_BE_METADATA))
+    uid: int = field(metadata=_UINT64_BE_METADATA)
     uid_counter: int = field(metadata=hci.metadata('>2'))
 
 
@@ -1204,6 +1290,10 @@ class InformBatteryStatusOfCtResponse(Response):
 @dataclass
 class GetPlayStatusResponse(Response):
     pdu_id = PduId.GET_PLAY_STATUS
+
+    # TG doesn't support Song Length or Position.
+    UNAVAILABLE = 0xFFFFFFFF
+
     song_length: int = field(metadata=hci.metadata(">4"))
     song_position: int = field(metadata=hci.metadata(">4"))
     play_status: PlayStatus = field(metadata=PlayStatus.type_metadata(1))
@@ -1521,16 +1611,33 @@ class Delegate:
         def __init__(self, status_code: StatusCode) -> None:
             self.status_code = status_code
 
+    class AvcError(Exception):
+        """The delegate AVC method failed, with a specified status code."""
+
+        def __init__(self, status_code: avc.ResponseFrame.ResponseCode) -> None:
+            self.status_code = status_code
+
     supported_events: list[EventId]
+    supported_company_ids: list[int]
     volume: int
+    playback_status: PlayStatus
 
-    def __init__(self, supported_events: Iterable[EventId] = ()) -> None:
+    def __init__(
+        self,
+        supported_events: Iterable[EventId] = (),
+        supported_company_ids: Iterable[int] = (AVRCP_BLUETOOTH_SIG_COMPANY_ID,),
+    ) -> None:
+        self.supported_company_ids = list(supported_company_ids)
         self.supported_events = list(supported_events)
         self.volume = 0
+        self.playback_status = PlayStatus.STOPPED
 
     async def get_supported_events(self) -> list[EventId]:
         return self.supported_events
 
+    async def get_supported_company_ids(self) -> list[int]:
+        return self.supported_company_ids
+
     async def set_absolute_volume(self, volume: int) -> None:
         """
         Set the absolute volume.
@@ -1543,6 +1650,19 @@ class Delegate:
     async def get_absolute_volume(self) -> int:
         return self.volume
 
+    async def on_key_event(
+        self,
+        key: avc.PassThroughFrame.OperationId,
+        pressed: bool,
+        data: bytes,
+    ) -> None:
+        logger.debug(
+            "@@@ on_key_event: key=%s, pressed=%s, data=%s", key, pressed, data.hex()
+        )
+
+    async def get_playback_status(self) -> PlayStatus:
+        return self.playback_status
+
     # TODO add other delegate methods
 
 
@@ -1756,6 +1876,19 @@ class Protocol(utils.EventEmitter):
             if isinstance(capability, EventId)
         )
 
+    async def get_supported_company_ids(self) -> list[int]:
+        """Get the list of events supported by the connected peer."""
+        response_context = await self.send_avrcp_command(
+            avc.CommandFrame.CommandType.STATUS,
+            GetCapabilitiesCommand(GetCapabilitiesCommand.CapabilityId.COMPANY_ID),
+        )
+        response = self._check_response(response_context, GetCapabilitiesResponse)
+        return list(
+            int.from_bytes(capability, 'big')
+            for capability in response.capabilities
+            if isinstance(capability, bytes)
+        )
+
     async def get_play_status(self) -> SongAndPlayStatus:
         """Get the play status of the connected peer."""
         response_context = await self.send_avrcp_command(
@@ -2052,16 +2185,28 @@ class Protocol(utils.EventEmitter):
             return
 
         if isinstance(command, avc.PassThroughCommandFrame):
-            # TODO: delegate
-            response = avc.PassThroughResponseFrame(
-                avc.ResponseFrame.ResponseCode.ACCEPTED,
-                command.subunit_type,
-                command.subunit_id,
-                command.state_flag,
-                command.operation_id,
-                command.operation_data,
-            )
-            self.send_response(transaction_label, response)
+
+            async def dispatch_key_event() -> None:
+                try:
+                    await self.delegate.on_key_event(
+                        command.operation_id,
+                        command.state_flag == avc.PassThroughFrame.StateFlag.PRESSED,
+                        command.operation_data,
+                    )
+                    response_code = avc.ResponseFrame.ResponseCode.ACCEPTED
+                except Delegate.AvcError as error:
+                    logger.exception("delegate method raised exception")
+                    response_code = error.status_code
+                except Exception:
+                    logger.exception("delegate method raised exception")
+                    response_code = avc.ResponseFrame.ResponseCode.REJECTED
+                self.send_passthrough_response(
+                    transaction_label=transaction_label,
+                    command=command,
+                    response_code=response_code,
+                )
+
+            utils.AsyncRunner.spawn(dispatch_key_event())
             return
 
         # TODO handle other types
@@ -2141,6 +2286,8 @@ class Protocol(utils.EventEmitter):
                 self._on_set_absolute_volume_command(transaction_label, command)
             elif isinstance(command, RegisterNotificationCommand):
                 self._on_register_notification_command(transaction_label, command)
+            elif isinstance(command, GetPlayStatusCommand):
+                self._on_get_play_status_command(transaction_label, command)
             else:
                 # Not supported.
                 # TODO: check that this is the right way to respond in this case.
@@ -2364,17 +2511,27 @@ class Protocol(utils.EventEmitter):
         logger.debug(f"<<< AVRCP command PDU: {command}")
 
         async def get_supported_events() -> None:
+            capabilities: Sequence[bytes | SupportsBytes]
             if (
                 command.capability_id
-                != GetCapabilitiesCommand.CapabilityId.EVENTS_SUPPORTED
+                == GetCapabilitiesCommand.CapabilityId.EVENTS_SUPPORTED
             ):
-                raise core.InvalidArgumentError()
-
-            supported_events = await self.delegate.get_supported_events()
+                capabilities = await self.delegate.get_supported_events()
+            elif (
+                command.capability_id == GetCapabilitiesCommand.CapabilityId.COMPANY_ID
+            ):
+                company_ids = await self.delegate.get_supported_company_ids()
+                capabilities = [
+                    company_id.to_bytes(3, 'big') for company_id in company_ids
+                ]
+            else:
+                raise core.InvalidArgumentError(
+                    f"Unsupported capability: {command.capability_id}"
+                )
             self.send_avrcp_response(
                 transaction_label,
                 avc.ResponseFrame.ResponseCode.IMPLEMENTED_OR_STABLE,
-                GetCapabilitiesResponse(command.capability_id, supported_events),
+                GetCapabilitiesResponse(command.capability_id, capabilities),
             )
 
         self._delegate_command(transaction_label, command, get_supported_events())
@@ -2395,6 +2552,26 @@ class Protocol(utils.EventEmitter):
 
         self._delegate_command(transaction_label, command, set_absolute_volume())
 
+    def _on_get_play_status_command(
+        self, transaction_label: int, command: GetPlayStatusCommand
+    ) -> None:
+        logger.debug("<<< AVRCP command PDU: %s", command)
+
+        async def get_playback_status() -> None:
+            play_status: PlayStatus = await self.delegate.get_playback_status()
+            self.send_avrcp_response(
+                transaction_label,
+                avc.ResponseFrame.ResponseCode.IMPLEMENTED_OR_STABLE,
+                GetPlayStatusResponse(
+                    # TODO: Delegate this.
+                    song_length=GetPlayStatusResponse.UNAVAILABLE,
+                    song_position=GetPlayStatusResponse.UNAVAILABLE,
+                    play_status=play_status,
+                ),
+            )
+
+        self._delegate_command(transaction_label, command, get_playback_status())
+
     def _on_register_notification_command(
         self, transaction_label: int, command: RegisterNotificationCommand
     ) -> None:
@@ -2410,28 +2587,27 @@ class Protocol(utils.EventEmitter):
                 )
                 return
 
+            response: Response
             if command.event_id == EventId.VOLUME_CHANGED:
                 volume = await self.delegate.get_absolute_volume()
                 response = RegisterNotificationResponse(VolumeChangedEvent(volume))
-                self.send_avrcp_response(
-                    transaction_label,
-                    avc.ResponseFrame.ResponseCode.INTERIM,
-                    response,
-                )
-                self._register_notification_listener(transaction_label, command)
-                return
-
-            if command.event_id == EventId.PLAYBACK_STATUS_CHANGED:
-                # TODO: testing only, use delegate
+            elif command.event_id == EventId.PLAYBACK_STATUS_CHANGED:
+                playback_status = await self.delegate.get_playback_status()
                 response = RegisterNotificationResponse(
-                    PlaybackStatusChangedEvent(play_status=PlayStatus.PLAYING)
-                )
-                self.send_avrcp_response(
-                    transaction_label,
-                    avc.ResponseFrame.ResponseCode.INTERIM,
-                    response,
+                    PlaybackStatusChangedEvent(play_status=playback_status)
                 )
-                self._register_notification_listener(transaction_label, command)
+            elif command.event_id == EventId.NOW_PLAYING_CONTENT_CHANGED:
+                playback_status = await self.delegate.get_playback_status()
+                response = RegisterNotificationResponse(NowPlayingContentChangedEvent())
+            else:
+                logger.warning("Event supported but not handled %s", command.event_id)
                 return
 
+            self.send_avrcp_response(
+                transaction_label,
+                avc.ResponseFrame.ResponseCode.INTERIM,
+                response,
+            )
+            self._register_notification_listener(transaction_label, command)
+
         self._delegate_command(transaction_label, command, register_notification())