bumble 0.0.213__py3-none-any.whl → 0.0.215__py3-none-any.whl

bumble/avrcp.py

@@ -16,16 +16,18 @@
 # Imports
 # -----------------------------------------------------------------------------
 from __future__ import annotations
+
 import asyncio
-from dataclasses import dataclass
 import enum
+import functools
 import logging
 import struct
+from dataclasses import dataclass, field
 from typing import (
     AsyncIterator,
     Awaitable,
     Callable,
-    cast,
+    ClassVar,
     Iterable,
     List,
     Optional,
@@ -33,28 +35,24 @@ from typing import (
     SupportsBytes,
     TypeVar,
     Union,
+    cast,
 )
 
-
+from bumble import avc, avctp, core, hci, l2cap, utils
 from bumble.colors import color
-from bumble.device import Device, Connection
+from bumble.device import Connection, Device
 from bumble.sdp import (
-    SDP_SERVICE_RECORD_HANDLE_ATTRIBUTE_ID,
+    SDP_ADDITIONAL_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID,
+    SDP_BLUETOOTH_PROFILE_DESCRIPTOR_LIST_ATTRIBUTE_ID,
     SDP_BROWSE_GROUP_LIST_ATTRIBUTE_ID,
-    SDP_PUBLIC_BROWSE_ROOT,
     SDP_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID,
+    SDP_PUBLIC_BROWSE_ROOT,
     SDP_SERVICE_CLASS_ID_LIST_ATTRIBUTE_ID,
-    SDP_BLUETOOTH_PROFILE_DESCRIPTOR_LIST_ATTRIBUTE_ID,
+    SDP_SERVICE_RECORD_HANDLE_ATTRIBUTE_ID,
     SDP_SUPPORTED_FEATURES_ATTRIBUTE_ID,
     DataElement,
     ServiceAttribute,
 )
-from bumble import utils
-from bumble import core
-from bumble import l2cap
-from bumble import avc
-from bumble import avctp
-
 
 # -----------------------------------------------------------------------------
 # Logging
@@ -69,18 +67,153 @@ 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'),
+}
+
+
+class PduId(utils.OpenIntEnum):
+    GET_CAPABILITIES = 0x10
+    LIST_PLAYER_APPLICATION_SETTING_ATTRIBUTES = 0x11
+    LIST_PLAYER_APPLICATION_SETTING_VALUES = 0x12
+    GET_CURRENT_PLAYER_APPLICATION_SETTING_VALUE = 0x13
+    SET_PLAYER_APPLICATION_SETTING_VALUE = 0x14
+    GET_PLAYER_APPLICATION_SETTING_ATTRIBUTE_TEXT = 0x15
+    GET_PLAYER_APPLICATION_SETTING_VALUE_TEXT = 0x16
+    INFORM_DISPLAYABLE_CHARACTER_SET = 0x17
+    INFORM_BATTERY_STATUS_OF_CT = 0x18
+    GET_ELEMENT_ATTRIBUTES = 0x20
+    GET_PLAY_STATUS = 0x30
+    REGISTER_NOTIFICATION = 0x31
+    REQUEST_CONTINUING_RESPONSE = 0x40
+    ABORT_CONTINUING_RESPONSE = 0x41
+    SET_ABSOLUTE_VOLUME = 0x50
+    SET_ADDRESSED_PLAYER = 0x60
+    SET_BROWSED_PLAYER = 0x70
+    GET_FOLDER_ITEMS = 0x71
+    CHANGE_PATH = 0x72
+    GET_ITEM_ATTRIBUTES = 0x73
+    PLAY_ITEM = 0x74
+    GET_TOTAL_NUMBER_OF_ITEMS = 0x75
+    SEARCH = 0x80
+    ADD_TO_NOW_PLAYING = 0x90
+
+
+class CharacterSetId(hci.SpecableEnum):
+    UTF_8 = 0x06
+
+
+class MediaAttributeId(hci.SpecableEnum):
+    TITLE = 0x01
+    ARTIST_NAME = 0x02
+    ALBUM_NAME = 0x03
+    TRACK_NUMBER = 0x04
+    TOTAL_NUMBER_OF_TRACKS = 0x05
+    GENRE = 0x06
+    PLAYING_TIME = 0x07
+    DEFAULT_COVER_ART = 0x08
+
+
+class PlayStatus(hci.SpecableEnum):
+    STOPPED = 0x00
+    PLAYING = 0x01
+    PAUSED = 0x02
+    FWD_SEEK = 0x03
+    REV_SEEK = 0x04
+    ERROR = 0xFF
+
+
+class EventId(hci.SpecableEnum):
+    PLAYBACK_STATUS_CHANGED = 0x01
+    TRACK_CHANGED = 0x02
+    TRACK_REACHED_END = 0x03
+    TRACK_REACHED_START = 0x04
+    PLAYBACK_POS_CHANGED = 0x05
+    BATT_STATUS_CHANGED = 0x06
+    SYSTEM_STATUS_CHANGED = 0x07
+    PLAYER_APPLICATION_SETTING_CHANGED = 0x08
+    NOW_PLAYING_CONTENT_CHANGED = 0x09
+    AVAILABLE_PLAYERS_CHANGED = 0x0A
+    ADDRESSED_PLAYER_CHANGED = 0x0B
+    UIDS_CHANGED = 0x0C
+    VOLUME_CHANGED = 0x0D
+
+    def __bytes__(self) -> bytes:
+        return bytes([int(self)])
+
+
+class StatusCode(hci.SpecableEnum):
+    INVALID_COMMAND = 0x00
+    INVALID_PARAMETER = 0x01
+    PARAMETER_CONTENT_ERROR = 0x02
+    INTERNAL_ERROR = 0x03
+    OPERATION_COMPLETED = 0x04
+    UID_CHANGED = 0x05
+    INVALID_DIRECTION = 0x07
+    NOT_A_DIRECTORY = 0x08
+    DOES_NOT_EXIST = 0x09
+    INVALID_SCOPE = 0x0A
+    RANGE_OUT_OF_BOUNDS = 0x0B
+    FOLDER_ITEM_IS_NOT_PLAYABLE = 0x0C
+    MEDIA_IN_USE = 0x0D
+    NOW_PLAYING_LIST_FULL = 0x0E
+    SEARCH_NOT_SUPPORTED = 0x0F
+    SEARCH_IN_PROGRESS = 0x10
+    INVALID_PLAYER_ID = 0x11
+    PLAYER_NOT_BROWSABLE = 0x12
+    PLAYER_NOT_ADDRESSED = 0x13
+    NO_VALID_SEARCH_RESULTS = 0x14
+    NO_AVAILABLE_PLAYERS = 0x15
+    ADDRESSED_PLAYER_CHANGED = 0x16
+
+
+class Scope(hci.SpecableEnum):
+    MEDIA_PLAYER_LIST = 0x00
+    MEDIA_PLAYER_VIRTUAL_FILESYSTEM = 0x01
+    SEARCH = 0x02
+    NOW_PLAYING = 0x03
+
+
+class ControllerFeatures(enum.IntFlag):
+    # fmt: off
+    CATEGORY_1                                      = 1 << 0
+    CATEGORY_2                                      = 1 << 1
+    CATEGORY_3                                      = 1 << 2
+    CATEGORY_4                                      = 1 << 3
+    SUPPORTS_BROWSING                               = 1 << 6
+    SUPPORTS_COVER_ART_GET_IMAGE_PROPERTIES_FEATURE = 1 << 7
+    SUPPORTS_COVER_ART_GET_IMAGE_FEATURE            = 1 << 8
+    SUPPORTS_COVER_ART_GET_LINKED_THUMBNAIL_FEATURE = 1 << 9
+
+
+class TargetFeatures(enum.IntFlag):
+    # fmt: off
+    CATEGORY_1                                  = 1 << 0
+    CATEGORY_2                                  = 1 << 1
+    CATEGORY_3                                  = 1 << 2
+    CATEGORY_4                                  = 1 << 3
+    PLAYER_APPLICATION_SETTINGS                 = 1 << 4
+    GROUP_NAVIGATION                            = 1 << 5
+    SUPPORTS_BROWSING                           = 1 << 6
+    SUPPORTS_MULTIPLE_MEDIA_PLAYER_APPLICATIONS = 1 << 7
+    SUPPORTS_COVER_ART                          = 1 << 8
+
+
 # -----------------------------------------------------------------------------
 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 = 1,
+    supported_features: Union[int, ControllerFeatures] = 1,
 ) -> 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]
 
-    return [
+    attributes = [
         ServiceAttribute(
             SDP_SERVICE_RECORD_HANDLE_ATTRIBUTE_ID,
             DataElement.unsigned_integer_32(service_record_handle),
@@ -135,6 +268,31 @@ def make_controller_service_sdp_records(
             DataElement.unsigned_integer_16(supported_features),
         ),
     ]
+    if supported_features & ControllerFeatures.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
 
 
 # -----------------------------------------------------------------------------
@@ -142,13 +300,13 @@ 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 = 0x23,
+    supported_features: Union[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]
 
-    return [
+    attributes = [
         ServiceAttribute(
             SDP_SERVICE_RECORD_HANDLE_ATTRIBUTE_ID,
             DataElement.unsigned_integer_32(service_record_handle),
@@ -202,17 +360,320 @@ def make_target_service_sdp_records(
             DataElement.unsigned_integer_16(supported_features),
         ),
     ]
+    if 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
 
 
 # -----------------------------------------------------------------------------
-def _decode_attribute_value(value: bytes, character_set: CharacterSetId) -> str:
+def _parse_string(data: bytes, offset: int, length_size: int) -> tuple[int, str]:
+    length = int.from_bytes(
+        data[offset : offset + length_size], byteorder='big', signed=False
+    )
+    offset += length_size
+    encoded = data[offset : offset + length]
     try:
-        if character_set == CharacterSetId.UTF_8:
-            return value.decode("utf-8")
-        return value.decode("ascii")
+        decoded = encoded.decode("utf-8")
     except UnicodeDecodeError:
-        logger.warning(f"cannot decode string with bytes: {value.hex()}")
-        return ""
+        # This can decode anything.
+        decoded = encoded.decode("latin1")
+    return offset + length, decoded
+
+
+# -----------------------------------------------------------------------------
+def _serialize_string(value: str, length_size: int) -> bytes:
+    encoded = value.encode("utf-8")
+    return len(encoded).to_bytes(length_size, byteorder='big', signed=False) + encoded
+
+
+# -----------------------------------------------------------------------------
+def _string_spec(length_size: int):
+    return {
+        'parser': functools.partial(_parse_string, length_size=length_size),
+        'serializer': functools.partial(_serialize_string, length_size=length_size),
+    }
+
+
+# -----------------------------------------------------------------------------
+@dataclass
+class MediaAttribute(hci.HCI_Dataclass_Object):
+    attribute_id: MediaAttributeId = field(
+        metadata=MediaAttributeId.type_metadata(4, byteorder='big')
+    )
+    character_set_id: CharacterSetId = field(
+        metadata=CharacterSetId.type_metadata(2, byteorder='big')
+    )
+    attribute_value: str = field(metadata=hci.metadata(_string_spec(2)))
+
+
+# -----------------------------------------------------------------------------
+@dataclass
+class SongAndPlayStatus:
+    song_length: int
+    song_position: int
+    play_status: PlayStatus
+
+
+# -----------------------------------------------------------------------------
+class ApplicationSetting:
+    class AttributeId(hci.SpecableEnum):
+        EQUALIZER_ON_OFF = 0x01
+        REPEAT_MODE = 0x02
+        SHUFFLE_ON_OFF = 0x03
+        SCAN_ON_OFF = 0x04
+
+    class EqualizerOnOffStatus(hci.SpecableEnum):
+        OFF = 0x01
+        ON = 0x02
+
+    class RepeatModeStatus(hci.SpecableEnum):
+        OFF = 0x01
+        SINGLE_TRACK_REPEAT = 0x02
+        ALL_TRACK_REPEAT = 0x03
+        GROUP_REPEAT = 0x04
+
+    class ShuffleOnOffStatus(hci.SpecableEnum):
+        OFF = 0x01
+        ALL_TRACKS_SHUFFLE = 0x02
+        GROUP_SHUFFLE = 0x03
+
+    class ScanOnOffStatus(hci.SpecableEnum):
+        OFF = 0x01
+        ALL_TRACKS_SCAN = 0x02
+        GROUP_SCAN = 0x03
+
+    class GenericValue(hci.SpecableEnum):
+        pass
+
+
+# -----------------------------------------------------------------------------
+@dataclass
+class AttributeValueEntry(hci.HCI_Dataclass_Object):
+    attribute_id: MediaAttributeId = field(
+        metadata=MediaAttributeId.type_metadata(4, byteorder='big')
+    )
+    character_set_id: CharacterSetId = field(
+        metadata=CharacterSetId.type_metadata(2, byteorder='big')
+    )
+    attribute_value: str = field(metadata=hci.metadata(_string_spec(2)))
+
+
+# -----------------------------------------------------------------------------
+class BrowseableItem:
+    """6.10.2 Browseable items."""
+
+    class Type(hci.SpecableEnum):
+        MEDIA_PLAYER = 0x01
+        FOLDER = 0x02
+        MEDIA_ELEMENT = 0x03
+
+    item_type: ClassVar[Type]
+    _payload: Optional[bytes] = None
+
+    subclasses: ClassVar[dict[Type, type[BrowseableItem]]] = {}
+    fields: ClassVar[hci.Fields] = ()
+
+    @classmethod
+    def parse_from_bytes(cls, data: bytes, offset: int) -> tuple[int, BrowseableItem]:
+        item_type, length = struct.unpack_from('>BH', data, offset)
+        subclass = cls.subclasses[BrowseableItem.Type(item_type)]
+        instance = subclass(
+            **hci.HCI_Object.dict_from_bytes(data, offset + 3, subclass.fields)
+        )
+        instance._payload = data[3:]
+        return offset + length, 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
+        )
+
+    _Item = TypeVar('_Item', bound='BrowseableItem')
+
+    @classmethod
+    def item(cls, subclass: type[_Item]) -> type[_Item]:
+        cls.subclasses[subclass.item_type] = subclass
+        subclass.fields = hci.HCI_Object.fields_from_dataclass(subclass)
+        return subclass
+
+
+# -----------------------------------------------------------------------------
+@BrowseableItem.item
+@dataclass
+class MediaPlayerItem(BrowseableItem):
+    item_type = BrowseableItem.Type.MEDIA_PLAYER
+
+    class MajorPlayerType(hci.SpecableFlag):
+        AUDIO = 0x01
+        VIDEO = 0x02
+        BROADCASTING_AUDIO = 0x04
+        BROADCASTING_VIDEO = 0x08
+
+    class PlayerSubType(hci.SpecableFlag):
+        AUDIO_BOOK = 0x01
+        PODCAST = 0x02
+
+    class Features(hci.SpecableFlag):
+        SELECT = 1 << 0
+        UP = 1 << 1
+        DOWN = 1 << 2
+        LEFT = 1 << 3
+        RIGHT = 1 << 4
+        RIGHT_UP = 1 << 5
+        RIGHT_DOWN = 1 << 6
+        LEFT_UP = 1 << 7
+        LEFT_DOWN = 1 << 8
+        ROOT_MENU = 1 << 9
+        SETUP_MENU = 1 << 10
+        CONTENTS_MENU = 1 << 11
+        FAVORITE_MENU = 1 << 12
+        EXIT = 1 << 13
+        NUM_0 = 1 << 14
+        NUM_1 = 1 << 15
+        NUM_2 = 1 << 16
+        NUM_3 = 1 << 17
+        NUM_4 = 1 << 18
+        NUM_5 = 1 << 19
+        NUM_6 = 1 << 20
+        NUM_7 = 1 << 21
+        NUM_8 = 1 << 22
+        NUM_9 = 1 << 23
+        DOT = 1 << 24
+        ENTER = 1 << 25
+        CLEAR = 1 << 26
+        CHANNEL_UP = 1 << 27
+        CHANNEL_DOWN = 1 << 28
+        PREVIOUS_CHANNEL = 1 << 29
+        SOUND_SELECT = 1 << 30
+        INPUT_SELECT = 1 << 31
+        DISPLAY_INFORMATION = 1 << 32
+        HELP = 1 << 33
+        PAGE_UP = 1 << 34
+        PAGE_DOWN = 1 << 35
+        POWER = 1 << 36
+        VOLUME_UP = 1 << 37
+        VOLUME_DOWN = 1 << 38
+        MUTE = 1 << 39
+        PLAY = 1 << 40
+        STOP = 1 << 41
+        PAUSE = 1 << 42
+        RECORD = 1 << 43
+        REWIND = 1 << 44
+        FAST_FORWARD = 1 << 45
+        EJECT = 1 << 46
+        FORWARD = 1 << 47
+        BACKWARD = 1 << 48
+        ANGLE = 1 << 49
+        SUBPICTURE = 1 << 50
+        F1 = 1 << 51
+        F2 = 1 << 52
+        F3 = 1 << 53
+        F4 = 1 << 54
+        F5 = 1 << 55
+        VENDOR_UNIQUE = 1 << 56
+        BASIC_GROUP_NAVIGATION = 1 << 57
+        ADVANCED_CONTROL_PLAYER = 1 << 58
+        BROWSING = 1 << 59
+        SEARCHING = 1 << 60
+        ADD_TO_NOW_PLAYING = 1 << 61
+        UI_DS_UNIQUE_IN_PLAYER_BROWSE_TREE = 1 << 62
+        ONLY_BROWSABLE_WHEN_ADDRESSED = 1 << 63
+        ONLY_SEARCHABLE_WHEN_ADDRESSED = 1 << 64
+        NOW_PLAYING = 1 << 65
+        UID_PERSISTENCY = 1 << 66
+        NUMBER_OF_ITEMS = 1 << 67
+        COVER_ART = 1 << 68
+
+    player_id: int = field(metadata=hci.metadata('>2'))
+    major_player_type: MajorPlayerType = field(
+        metadata=MajorPlayerType.type_metadata(1)
+    )
+    player_sub_type: PlayerSubType = field(
+        metadata=PlayerSubType.type_metadata(4, byteorder='big')
+    )
+    play_status: PlayStatus = field(metadata=PlayStatus.type_metadata(1))
+    feature_bitmask: Features = field(
+        metadata=Features.type_metadata(16, byteorder='big')
+    )
+    character_set_id: CharacterSetId = field(
+        metadata=CharacterSetId.type_metadata(2, byteorder='big')
+    )
+    displayable_name: str = field(metadata=hci.metadata(_string_spec(2)))
+
+
+# -----------------------------------------------------------------------------
+@BrowseableItem.item
+@dataclass
+class FolderItem(BrowseableItem):
+    item_type = BrowseableItem.Type.FOLDER
+
+    class FolderType(hci.SpecableEnum):
+        MIXED = 0x00
+        TITLES = 0x01
+        ALBUMS = 0x02
+        ARTISTS = 0x03
+        GENRES = 0x04
+        PLAYLISTS = 0x05
+        YEARS = 0x06
+
+    class Playable(hci.SpecableEnum):
+        NOT_PLAYABLE = 0x00
+        PLAYABLE = 0x01
+
+    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))
+    character_set_id: CharacterSetId = field(
+        metadata=CharacterSetId.type_metadata(2, byteorder='big')
+    )
+    displayable_name: str = field(metadata=hci.metadata(_string_spec(2)))
+
+
+# -----------------------------------------------------------------------------
+@BrowseableItem.item
+@dataclass
+class MediaElementItem(BrowseableItem):
+    item_type = BrowseableItem.Type.MEDIA_ELEMENT
+
+    class MediaType(hci.SpecableEnum):
+        AUDIO = 0x00
+        VIDEO = 0x01
+
+    media_element_uid: int = field(metadata=_UINT64_BE_METADATA)
+    media_type: MediaType = field(metadata=MediaType.type_metadata(1))
+    character_set_id: CharacterSetId = field(
+        metadata=CharacterSetId.type_metadata(2, byteorder='big')
+    )
+    displayable_name: str = field(metadata=hci.metadata(_string_spec(2)))
+    attribute_value_entry_list: Sequence[AttributeValueEntry] = field(
+        metadata=hci.metadata(
+            AttributeValueEntry.parse_from_bytes, list_begin=True, list_end=True
+        )
+    )
 
 
 # -----------------------------------------------------------------------------
@@ -223,10 +684,10 @@ class PduAssembler:
     6.3.1 AVRCP specific AV//C commands
     """
 
-    pdu_id: Optional[Protocol.PduId]
+    pdu_id: Optional[PduId]
     payload: bytes
 
-    def __init__(self, callback: Callable[[Protocol.PduId, bytes], None]) -> None:
+    def __init__(self, callback: Callable[[PduId, bytes], None]) -> None:
         self.callback = callback
         self.reset()
 
@@ -235,7 +696,7 @@ class PduAssembler:
         self.parameter = b''
 
     def on_pdu(self, pdu: bytes) -> None:
-        pdu_id = Protocol.PduId(pdu[0])
+        pdu_id = PduId(pdu[0])
         packet_type = Protocol.PacketType(pdu[1] & 3)
         parameter_length = struct.unpack_from('>H', pdu, 2)[0]
         parameter = pdu[4 : 4 + parameter_length]
@@ -267,677 +728,794 @@ class PduAssembler:
         assert self.pdu_id is not None
         try:
             self.callback(self.pdu_id, self.parameter)
-        except Exception as error:
-            logger.exception(color(f'!!! exception in callback: {error}', 'red'))
+        except Exception:
+            logger.exception(color('!!! exception in callback', 'red'))
 
         self.reset()
 
 
 # -----------------------------------------------------------------------------
-@dataclass
 class Command:
-    pdu_id: Protocol.PduId
-    parameter: bytes
+    pdu_id: ClassVar[PduId]
+    _payload: Optional[bytes] = None
 
-    def to_string(self, properties: dict[str, str]) -> str:
-        properties_str = ",".join(
-            [f"{name}={value}" for name, value in properties.items()]
-        )
-        return f"Command[{self.pdu_id.name}]({properties_str})"
+    _Command = TypeVar('_Command', bound='Command')
+    subclasses: ClassVar[dict[int, type[Command]]] = {}
+    fields: ClassVar[hci.Fields] = ()
 
-    def __str__(self) -> str:
-        return self.to_string({"parameters": self.parameter.hex()})
+    @classmethod
+    def command(cls, subclass: type[_Command]) -> type[_Command]:
+        cls.subclasses[subclass.pdu_id] = subclass
+        subclass.fields = hci.HCI_Object.fields_from_dataclass(subclass)
+        return subclass
 
-    def __repr__(self) -> str:
-        return str(self)
+    @classmethod
+    def from_bytes(cls, pdu_id: int, pdu: bytes) -> Command:
+        if not (subclass := cls.subclasses.get(pdu_id)):
+            raise core.InvalidPacketError(f"Unimplemented PDU {pdu_id}")
+        instance = subclass(**hci.HCI_Object.dict_from_bytes(pdu, 0, subclass.fields))
+        instance._payload = pdu[0:]
+        return instance
+
+    def __bytes__(self) -> bytes:
+        if self._payload is None:
+            self._payload = hci.HCI_Object.dict_to_bytes(self.__dict__, self.fields)
+        return self._payload
 
 
 # -----------------------------------------------------------------------------
+@Command.command
+@dataclass
 class GetCapabilitiesCommand(Command):
-    class CapabilityId(utils.OpenIntEnum):
+    pdu_id = PduId.GET_CAPABILITIES
+
+    class CapabilityId(hci.SpecableEnum):
         COMPANY_ID = 0x02
         EVENTS_SUPPORTED = 0x03
 
-    capability_id: CapabilityId
+    capability_id: CapabilityId = field(metadata=CapabilityId.type_metadata(1))
 
-    @classmethod
-    def from_bytes(cls, pdu: bytes) -> GetCapabilitiesCommand:
-        return cls(cls.CapabilityId(pdu[0]))
 
-    def __init__(self, capability_id: CapabilityId) -> None:
-        super().__init__(Protocol.PduId.GET_CAPABILITIES, bytes([capability_id]))
-        self.capability_id = capability_id
+# -----------------------------------------------------------------------------
+@Command.command
+@dataclass
+class ListPlayerApplicationSettingAttributesCommand(Command):
+    pdu_id = PduId.LIST_PLAYER_APPLICATION_SETTING_ATTRIBUTES
+
 
-    def __str__(self) -> str:
-        return self.to_string({"capability_id": self.capability_id.name})
+# -----------------------------------------------------------------------------
+@Command.command
+@dataclass
+class ListPlayerApplicationSettingValuesCommand(Command):
+    pdu_id = PduId.LIST_PLAYER_APPLICATION_SETTING_VALUES
+
+    attribute: ApplicationSetting.AttributeId = field(
+        metadata=ApplicationSetting.AttributeId.type_metadata(1)
+    )
 
 
 # -----------------------------------------------------------------------------
-class GetPlayStatusCommand(Command):
-    @classmethod
-    def from_bytes(cls, _: bytes) -> GetPlayStatusCommand:
-        return cls()
+@Command.command
+@dataclass
+class GetCurrentPlayerApplicationSettingValueCommand(Command):
+    pdu_id = PduId.GET_CURRENT_PLAYER_APPLICATION_SETTING_VALUE
+
+    attribute: Sequence[ApplicationSetting.AttributeId] = field(
+        metadata=ApplicationSetting.AttributeId.type_metadata(
+            1, list_begin=True, list_end=True
+        )
+    )
+
+
+# -----------------------------------------------------------------------------
+@Command.command
+@dataclass
+class SetPlayerApplicationSettingValueCommand(Command):
+    pdu_id = PduId.SET_PLAYER_APPLICATION_SETTING_VALUE
+
+    attribute: Sequence[ApplicationSetting.AttributeId] = field(
+        metadata=ApplicationSetting.AttributeId.type_metadata(1, list_begin=True)
+    )
+    value: Sequence[int] = field(metadata=hci.metadata(1, list_end=True))
+
+
+# -----------------------------------------------------------------------------
+@Command.command
+@dataclass
+class GetPlayerApplicationSettingAttributeTextCommand(Command):
+    pdu_id = PduId.GET_PLAYER_APPLICATION_SETTING_ATTRIBUTE_TEXT
+
+    attribute: Sequence[ApplicationSetting.AttributeId] = field(
+        metadata=ApplicationSetting.AttributeId.type_metadata(
+            1, list_begin=True, list_end=True
+        )
+    )
+
+
+# -----------------------------------------------------------------------------
+@Command.command
+@dataclass
+class GetPlayerApplicationSettingValueTextCommand(Command):
+    pdu_id = PduId.GET_PLAYER_APPLICATION_SETTING_VALUE_TEXT
 
-    def __init__(self) -> None:
-        super().__init__(Protocol.PduId.GET_PLAY_STATUS, b'')
+    attribute: ApplicationSetting.AttributeId = field(
+        metadata=ApplicationSetting.AttributeId.type_metadata(1)
+    )
+    value: Sequence[int] = field(
+        metadata=hci.metadata(1, list_begin=True, list_end=True)
+    )
 
 
 # -----------------------------------------------------------------------------
+@Command.command
+@dataclass
+class InformDisplayableCharacterSetCommand(Command):
+    pdu_id = PduId.INFORM_DISPLAYABLE_CHARACTER_SET
+
+    character_set_id: Sequence[CharacterSetId] = field(
+        metadata=CharacterSetId.type_metadata(
+            2, list_begin=True, list_end=True, byteorder='big'
+        )
+    )
+
+
+# -----------------------------------------------------------------------------
+@Command.command
+@dataclass
+class InformBatteryStatusOfCtCommand(Command):
+    pdu_id = PduId.INFORM_BATTERY_STATUS_OF_CT
+
+    class BatteryStatus(hci.SpecableEnum):
+        NORMAL = 0x00
+        WARNING = 0x01
+        CRITICAL = 0x02
+        EXTERNAL = 0x03
+        FULL_CHARGE = 0x04
+
+    battery_status: BatteryStatus = field(metadata=BatteryStatus.type_metadata(1))
+
+
+# -----------------------------------------------------------------------------
+@Command.command
+@dataclass
+class GetPlayStatusCommand(Command):
+    pdu_id = PduId.GET_PLAY_STATUS
+
+
+# -----------------------------------------------------------------------------
+@Command.command
+@dataclass
 class GetElementAttributesCommand(Command):
-    identifier: int
-    attribute_ids: list[MediaAttributeId]
+    pdu_id = PduId.GET_ELEMENT_ATTRIBUTES
 
-    @classmethod
-    def from_bytes(cls, pdu: bytes) -> GetElementAttributesCommand:
-        identifier = struct.unpack_from(">Q", pdu)[0]
-        num_attributes = pdu[8]
-        attribute_ids = [MediaAttributeId(pdu[9 + i]) for i in range(num_attributes)]
-        return cls(identifier, attribute_ids)
-
-    def __init__(
-        self, identifier: int, attribute_ids: Sequence[MediaAttributeId]
-    ) -> None:
-        parameter = struct.pack(">QB", identifier, len(attribute_ids)) + b''.join(
-            [struct.pack(">I", int(attribute_id)) for attribute_id in attribute_ids]
+    identifier: int = field(metadata=hci.metadata(_UINT64_BE_METADATA))
+    attribute_ids: Sequence[MediaAttributeId] = field(
+        metadata=MediaAttributeId.type_metadata(
+            4, list_begin=True, list_end=True, byteorder='big'
         )
-        super().__init__(Protocol.PduId.GET_ELEMENT_ATTRIBUTES, parameter)
-        self.identifier = identifier
-        self.attribute_ids = list(attribute_ids)
+    )
 
 
 # -----------------------------------------------------------------------------
+@Command.command
+@dataclass
 class SetAbsoluteVolumeCommand(Command):
+    pdu_id = PduId.SET_ABSOLUTE_VOLUME
     MAXIMUM_VOLUME = 0x7F
 
-    volume: int
+    volume: int = field(metadata=hci.metadata(1))
 
-    @classmethod
-    def from_bytes(cls, pdu: bytes) -> SetAbsoluteVolumeCommand:
-        return cls(pdu[0])
 
-    def __init__(self, volume: int) -> None:
-        super().__init__(Protocol.PduId.SET_ABSOLUTE_VOLUME, bytes([volume]))
-        self.volume = volume
+# -----------------------------------------------------------------------------
+@Command.command
+@dataclass
+class RegisterNotificationCommand(Command):
+    pdu_id = PduId.REGISTER_NOTIFICATION
 
-    def __str__(self) -> str:
-        return self.to_string({"volume": str(self.volume)})
+    event_id: EventId = field(metadata=EventId.type_metadata(1))
+    playback_interval: int = field(metadata=hci.metadata('>4'))
 
 
 # -----------------------------------------------------------------------------
-class RegisterNotificationCommand(Command):
-    event_id: EventId
-    playback_interval: int
+@Command.command
+@dataclass
+class SetAddressedPlayerCommand(Command):
+    pdu_id = PduId.SET_ADDRESSED_PLAYER
 
-    @classmethod
-    def from_bytes(cls, pdu: bytes) -> RegisterNotificationCommand:
-        event_id = EventId(pdu[0])
-        playback_interval = struct.unpack_from(">I", pdu, 1)[0]
-        return cls(event_id, playback_interval)
-
-    def __init__(self, event_id: EventId, playback_interval: int) -> None:
-        super().__init__(
-            Protocol.PduId.REGISTER_NOTIFICATION,
-            struct.pack(">BI", int(event_id), playback_interval),
-        )
-        self.event_id = event_id
-        self.playback_interval = playback_interval
-
-    def __str__(self) -> str:
-        return self.to_string(
-            {
-                "event_id": self.event_id.name,
-                "playback_interval": str(self.playback_interval),
-            }
+    player_id: int = field(metadata=hci.metadata('>2'))
+
+
+# -----------------------------------------------------------------------------
+@Command.command
+@dataclass
+class SetBrowsedPlayerCommand(Command):
+    pdu_id = PduId.SET_BROWSED_PLAYER
+
+    player_id: int = field(metadata=hci.metadata('>2'))
+
+
+# -----------------------------------------------------------------------------
+@Command.command
+@dataclass
+class GetFolderItemsCommand(Command):
+    pdu_id = PduId.GET_FOLDER_ITEMS
+
+    scope: Scope = field(metadata=Scope.type_metadata(1))
+    start_item: int = field(metadata=hci.metadata('>4'))
+    end_item: int = field(metadata=hci.metadata('>4'))
+    # When attributes is empty, all attributes will be requested.
+    attributes: Sequence[MediaAttributeId] = field(
+        metadata=MediaAttributeId.type_metadata(
+            4, list_begin=True, list_end=True, byteorder='big'
         )
+    )
+
+
+# -----------------------------------------------------------------------------
+@Command.command
+@dataclass
+class ChangePathCommand(Command):
+    pdu_id = PduId.CHANGE_PATH
+
+    class Direction(hci.SpecableEnum):
+        UP = 0
+        DOWN = 1
+
+    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))
+
+
+# -----------------------------------------------------------------------------
+@Command.command
+@dataclass
+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_counter: int = field(metadata=hci.metadata('>2'))
+    start_item: int = field(metadata=hci.metadata('>4'))
+    end_item: int = field(metadata=hci.metadata('>4'))
+    # When attributes is empty, all attributes will be requested.
+    attributes: Sequence[MediaAttributeId] = field(
+        metadata=MediaAttributeId.type_metadata(1, list_begin=True, list_end=True)
+    )
+
+
+# -----------------------------------------------------------------------------
+@Command.command
+@dataclass
+class GetTotalNumberOfItemsCommand(Command):
+    pdu_id = PduId.GET_TOTAL_NUMBER_OF_ITEMS
+
+    scope: Scope = field(metadata=Scope.type_metadata(1))
+
+
+# -----------------------------------------------------------------------------
+@Command.command
+@dataclass
+class SearchCommand(Command):
+    pdu_id = PduId.SEARCH
+
+    character_set_id: CharacterSetId = field(
+        metadata=CharacterSetId.type_metadata(2, byteorder='big')
+    )
+    search_string: str = field(metadata=hci.metadata(_string_spec(2)))
 
 
 # -----------------------------------------------------------------------------
+@Command.command
 @dataclass
+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_counter: int = field(metadata=hci.metadata('>2'))
+
+
+# -----------------------------------------------------------------------------
+@Command.command
+@dataclass
+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_counter: int = field(metadata=hci.metadata('>2'))
+
+
+# -----------------------------------------------------------------------------
 class Response:
-    pdu_id: Protocol.PduId
-    parameter: bytes
+    pdu_id: PduId
+    _payload: Optional[bytes] = None
 
-    def to_string(self, properties: dict[str, str]) -> str:
-        properties_str = ",".join(
-            [f"{name}={value}" for name, value in properties.items()]
-        )
-        return f"Response[{self.pdu_id.name}]({properties_str})"
+    fields: ClassVar[hci.Fields] = ()
+    subclasses: ClassVar[dict[PduId, type[Response]]] = {}
 
-    def __str__(self) -> str:
-        return self.to_string({"parameter": self.parameter.hex()})
+    _Response = TypeVar('_Response', bound='Response')
 
-    def __repr__(self) -> str:
-        return str(self)
+    @classmethod
+    def response(cls, subclass: type[_Response]) -> type[_Response]:
+        subclass.fields = hci.HCI_Object.fields_from_dataclass(subclass)
+        if pdu_id := getattr(subclass, 'pdu_id', None):
+            cls.subclasses[pdu_id] = subclass
+        return subclass
+
+    def __bytes__(self) -> bytes:
+        if self._payload is None:
+            self._payload = hci.HCI_Object.dict_to_bytes(self.__dict__, self.fields)
+        return self._payload
+
+    @classmethod
+    def from_bytes(cls, pdu: bytes, pdu_id: PduId) -> Response:
+        if not (subclass := cls.subclasses.get(pdu_id)):
+            raise core.InvalidArgumentError(f"Unimplemented packet {pdu_id.name}")
+        return subclass.from_parameters(pdu)
+
+    @classmethod
+    def from_parameters(cls, parameters: bytes) -> Response:
+        instance = cls(**hci.HCI_Object.dict_from_bytes(parameters, 0, cls.fields))
+        instance._payload = parameters
+        return instance
 
 
 # -----------------------------------------------------------------------------
+@Response.response
+@dataclass
 class RejectedResponse(Response):
-    status_code: Protocol.StatusCode
+    pdu_id: PduId
+    status_code: StatusCode = field(metadata=StatusCode.type_metadata(1))
 
     @classmethod
-    def from_bytes(cls, pdu_id: Protocol.PduId, pdu: bytes) -> RejectedResponse:
-        return cls(pdu_id, Protocol.StatusCode(pdu[0]))
-
-    def __init__(
-        self, pdu_id: Protocol.PduId, status_code: Protocol.StatusCode
-    ) -> None:
-        super().__init__(pdu_id, bytes([int(status_code)]))
-        self.status_code = status_code
-
-    def __str__(self) -> str:
-        return self.to_string(
-            {
-                "status_code": self.status_code.name,
-            }
-        )
+    def from_bytes(cls, pdu: bytes, pdu_id: PduId) -> Response:
+        return cls(pdu_id=pdu_id, status_code=StatusCode(pdu[0]))
 
 
 # -----------------------------------------------------------------------------
+@Response.response
+@dataclass
 class NotImplementedResponse(Response):
+    pdu_id: PduId
+    parameters: bytes = field(metadata=hci.metadata('*'))
+
     @classmethod
-    def from_bytes(cls, pdu_id: Protocol.PduId, pdu: bytes) -> NotImplementedResponse:
-        return cls(pdu_id, pdu[1:])
+    def from_bytes(cls, pdu: bytes, pdu_id: PduId) -> Response:
+        return cls(pdu_id=pdu_id, parameters=pdu)
 
 
 # -----------------------------------------------------------------------------
+@Response.response
+@dataclass
 class GetCapabilitiesResponse(Response):
+    pdu_id = PduId.GET_CAPABILITIES
     capability_id: GetCapabilitiesCommand.CapabilityId
-    capabilities: list[Union[SupportsBytes, bytes]]
+    capabilities: Sequence[Union[SupportsBytes, bytes]]
 
     @classmethod
-    def from_bytes(cls, pdu: bytes) -> GetCapabilitiesResponse:
-        if len(pdu) < 2:
+    def from_parameters(cls, parameters: bytes) -> Response:
+        if len(parameters) < 2:
             # Possibly a reject response.
             return cls(GetCapabilitiesCommand.CapabilityId(0), [])
 
         # Assume that the payloads all follow the same pattern:
         #  <CapabilityID><CapabilityCount><Capability*>
-        capability_id = GetCapabilitiesCommand.CapabilityId(pdu[0])
-        capability_count = pdu[1]
+        capability_id = GetCapabilitiesCommand.CapabilityId(parameters[0])
+        capability_count = parameters[1]
 
         capabilities: list[Union[SupportsBytes, bytes]]
         if capability_id == GetCapabilitiesCommand.CapabilityId.EVENTS_SUPPORTED:
-            capabilities = [EventId(pdu[2 + x]) for x in range(capability_count)]
+            capabilities = [EventId(parameters[2 + x]) for x in range(capability_count)]
         else:
-            capability_size = (len(pdu) - 2) // capability_count
+            capability_size = (len(parameters) - 2) // capability_count
             capabilities = [
-                pdu[x : x + capability_size]
-                for x in range(2, len(pdu), capability_size)
+                parameters[x : x + capability_size]
+                for x in range(2, len(parameters), capability_size)
             ]
 
         return cls(capability_id, capabilities)
 
-    def __init__(
-        self,
-        capability_id: GetCapabilitiesCommand.CapabilityId,
-        capabilities: Sequence[Union[SupportsBytes, bytes]],
-    ) -> None:
-        super().__init__(
-            Protocol.PduId.GET_CAPABILITIES,
-            bytes([capability_id, len(capabilities)])
-            + b''.join(bytes(capability) for capability in capabilities),
-        )
-        self.capability_id = capability_id
-        self.capabilities = list(capabilities)
-
-    def __str__(self) -> str:
-        return self.to_string(
-            {
-                "capability_id": self.capability_id.name,
-                "capabilities": str(self.capabilities),
-            }
+    def __post_init__(self) -> None:
+        self._payload = bytes([self.capability_id, len(self.capabilities)]) + b''.join(
+            bytes(capability) for capability in self.capabilities
         )
 
 
 # -----------------------------------------------------------------------------
-class GetPlayStatusResponse(Response):
-    song_length: int
-    song_position: int
-    play_status: PlayStatus
-
-    @classmethod
-    def from_bytes(cls, pdu: bytes) -> GetPlayStatusResponse:
-        (song_length, song_position) = struct.unpack_from(">II", pdu, 0)
-        play_status = PlayStatus(pdu[8])
-
-        return cls(song_length, song_position, play_status)
+@Response.response
+@dataclass
+class ListPlayerApplicationSettingAttributesResponse(Response):
+    pdu_id = PduId.LIST_PLAYER_APPLICATION_SETTING_ATTRIBUTES
 
-    def __init__(
-        self,
-        song_length: int,
-        song_position: int,
-        play_status: PlayStatus,
-    ) -> None:
-        super().__init__(
-            Protocol.PduId.GET_PLAY_STATUS,
-            struct.pack(">IIB", song_length, song_position, int(play_status)),
-        )
-        self.song_length = song_length
-        self.song_position = song_position
-        self.play_status = play_status
-
-    def __str__(self) -> str:
-        return self.to_string(
-            {
-                "song_length": str(self.song_length),
-                "song_position": str(self.song_position),
-                "play_status": self.play_status.name,
-            }
+    attribute: Sequence[ApplicationSetting.AttributeId] = field(
+        metadata=ApplicationSetting.AttributeId.type_metadata(
+            1, list_begin=True, list_end=True
         )
+    )
 
 
 # -----------------------------------------------------------------------------
-class GetElementAttributesResponse(Response):
-    attributes: list[MediaAttribute]
+@Response.response
+@dataclass
+class ListPlayerApplicationSettingValuesResponse(Response):
+    pdu_id = PduId.LIST_PLAYER_APPLICATION_SETTING_VALUES
 
-    @classmethod
-    def from_bytes(cls, pdu: bytes) -> GetElementAttributesResponse:
-        num_attributes = pdu[0]
-        offset = 1
-        attributes: list[MediaAttribute] = []
-        for _ in range(num_attributes):
-            (
-                attribute_id_int,
-                character_set_id_int,
-                attribute_value_length,
-            ) = struct.unpack_from(">IHH", pdu, offset)
-            attribute_value_bytes = pdu[
-                offset + 8 : offset + 8 + attribute_value_length
-            ]
-            attribute_id = MediaAttributeId(attribute_id_int)
-            character_set_id = CharacterSetId(character_set_id_int)
-            attribute_value = _decode_attribute_value(
-                attribute_value_bytes, character_set_id
-            )
-            attributes.append(
-                MediaAttribute(attribute_id, character_set_id, attribute_value)
-            )
-            offset += 8 + attribute_value_length
-
-        return cls(attributes)
-
-    def __init__(self, attributes: Sequence[MediaAttribute]) -> None:
-        parameter = bytes([len(attributes)])
-        for attribute in attributes:
-            attribute_value_bytes = attribute.attribute_value.encode("utf-8")
-            parameter += (
-                struct.pack(
-                    ">IHH",
-                    int(attribute.attribute_id),
-                    int(CharacterSetId.UTF_8),
-                    len(attribute_value_bytes),
-                )
-                + attribute_value_bytes
-            )
-        super().__init__(
-            Protocol.PduId.GET_ELEMENT_ATTRIBUTES,
-            parameter,
-        )
-        self.attributes = list(attributes)
-
-    def __str__(self) -> str:
-        attribute_strs = [str(attribute) for attribute in self.attributes]
-        return self.to_string(
-            {
-                "attributes": f"[{', '.join(attribute_strs)}]",
-            }
-        )
+    value: Sequence[int] = field(
+        metadata=hci.metadata(1, list_begin=True, list_end=True)
+    )
 
 
 # -----------------------------------------------------------------------------
-class SetAbsoluteVolumeResponse(Response):
-    volume: int
-
-    @classmethod
-    def from_bytes(cls, pdu: bytes) -> SetAbsoluteVolumeResponse:
-        return cls(pdu[0])
-
-    def __init__(self, volume: int) -> None:
-        super().__init__(Protocol.PduId.SET_ABSOLUTE_VOLUME, bytes([volume]))
-        self.volume = volume
+@Response.response
+@dataclass
+class GetCurrentPlayerApplicationSettingValueResponse(Response):
+    pdu_id = PduId.GET_CURRENT_PLAYER_APPLICATION_SETTING_VALUE
 
-    def __str__(self) -> str:
-        return self.to_string({"volume": str(self.volume)})
+    attribute: Sequence[ApplicationSetting.AttributeId] = field(
+        metadata=ApplicationSetting.AttributeId.type_metadata(1, list_begin=True)
+    )
+    value: Sequence[int] = field(metadata=hci.metadata(1, list_end=True))
 
 
 # -----------------------------------------------------------------------------
-class RegisterNotificationResponse(Response):
-    event: Event
+@Response.response
+@dataclass
+class SetPlayerApplicationSettingValueResponse(Response):
+    pdu_id = PduId.SET_PLAYER_APPLICATION_SETTING_VALUE
 
-    @classmethod
-    def from_bytes(cls, pdu: bytes) -> RegisterNotificationResponse:
-        return cls(Event.from_bytes(pdu))
 
-    def __init__(self, event: Event) -> None:
-        super().__init__(
-            Protocol.PduId.REGISTER_NOTIFICATION,
-            bytes(event),
-        )
-        self.event = event
+# -----------------------------------------------------------------------------
+@Response.response
+@dataclass
+class GetPlayerApplicationSettingAttributeTextResponse(Response):
+    pdu_id = PduId.GET_PLAYER_APPLICATION_SETTING_ATTRIBUTE_TEXT
 
-    def __str__(self) -> str:
-        return self.to_string(
-            {
-                "event": str(self.event),
-            }
-        )
+    attribute: Sequence[ApplicationSetting.AttributeId] = field(
+        metadata=ApplicationSetting.AttributeId.type_metadata(1, list_begin=True)
+    )
+    character_set_id: Sequence[CharacterSetId] = field(
+        metadata=CharacterSetId.type_metadata(2, byteorder='big')
+    )
+    attribute_string: Sequence[str] = field(
+        metadata=hci.metadata(_string_spec(1), list_end=True)
+    )
 
 
 # -----------------------------------------------------------------------------
-class EventId(utils.OpenIntEnum):
-    PLAYBACK_STATUS_CHANGED = 0x01
-    TRACK_CHANGED = 0x02
-    TRACK_REACHED_END = 0x03
-    TRACK_REACHED_START = 0x04
-    PLAYBACK_POS_CHANGED = 0x05
-    BATT_STATUS_CHANGED = 0x06
-    SYSTEM_STATUS_CHANGED = 0x07
-    PLAYER_APPLICATION_SETTING_CHANGED = 0x08
-    NOW_PLAYING_CONTENT_CHANGED = 0x09
-    AVAILABLE_PLAYERS_CHANGED = 0x0A
-    ADDRESSED_PLAYER_CHANGED = 0x0B
-    UIDS_CHANGED = 0x0C
-    VOLUME_CHANGED = 0x0D
+@Response.response
+@dataclass
+class GetPlayerApplicationSettingValueTextResponse(Response):
+    pdu_id = PduId.GET_PLAYER_APPLICATION_SETTING_VALUE_TEXT
 
-    def __bytes__(self) -> bytes:
-        return bytes([int(self)])
+    value: Sequence[int] = field(metadata=hci.metadata(1, list_begin=True))
+    character_set_id: Sequence[CharacterSetId] = field(
+        metadata=CharacterSetId.type_metadata(2, byteorder='big')
+    )
+    attribute_string: Sequence[str] = field(
+        metadata=hci.metadata(_string_spec(1), list_end=True)
+    )
 
 
 # -----------------------------------------------------------------------------
-class CharacterSetId(utils.OpenIntEnum):
-    UTF_8 = 0x06
+@Response.response
+@dataclass
+class InformDisplayableCharacterSetResponse(Response):
+    pdu_id = PduId.INFORM_DISPLAYABLE_CHARACTER_SET
 
 
 # -----------------------------------------------------------------------------
-class MediaAttributeId(utils.OpenIntEnum):
-    TITLE = 0x01
-    ARTIST_NAME = 0x02
-    ALBUM_NAME = 0x03
-    TRACK_NUMBER = 0x04
-    TOTAL_NUMBER_OF_TRACKS = 0x05
-    GENRE = 0x06
-    PLAYING_TIME = 0x07
-    DEFAULT_COVER_ART = 0x08
+@Response.response
+@dataclass
+class InformBatteryStatusOfCtResponse(Response):
+    pdu_id = PduId.INFORM_BATTERY_STATUS_OF_CT
 
 
 # -----------------------------------------------------------------------------
+@Response.response
 @dataclass
-class MediaAttribute:
-    attribute_id: MediaAttributeId
-    character_set_id: CharacterSetId
-    attribute_value: str
+class GetPlayStatusResponse(Response):
+    pdu_id = PduId.GET_PLAY_STATUS
+    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))
 
 
 # -----------------------------------------------------------------------------
-class PlayStatus(utils.OpenIntEnum):
-    STOPPED = 0x00
-    PLAYING = 0x01
-    PAUSED = 0x02
-    FWD_SEEK = 0x03
-    REV_SEEK = 0x04
-    ERROR = 0xFF
+@Response.response
+@dataclass
+class GetElementAttributesResponse(Response):
+    pdu_id = PduId.GET_ELEMENT_ATTRIBUTES
+    attributes: Sequence[MediaAttribute] = field(
+        metadata=hci.metadata(
+            MediaAttribute.parse_from_bytes, list_begin=True, list_end=True
+        )
+    )
 
 
 # -----------------------------------------------------------------------------
+@Response.response
 @dataclass
-class SongAndPlayStatus:
-    song_length: int
-    song_position: int
-    play_status: PlayStatus
+class SetAbsoluteVolumeResponse(Response):
+    pdu_id = PduId.SET_ABSOLUTE_VOLUME
+    volume: int = field(metadata=hci.metadata(1))
 
 
 # -----------------------------------------------------------------------------
-class ApplicationSetting:
-    class AttributeId(utils.OpenIntEnum):
-        EQUALIZER_ON_OFF = 0x01
-        REPEAT_MODE = 0x02
-        SHUFFLE_ON_OFF = 0x03
-        SCAN_ON_OFF = 0x04
-
-    class EqualizerOnOffStatus(utils.OpenIntEnum):
-        OFF = 0x01
-        ON = 0x02
+@Response.response
+@dataclass
+class RegisterNotificationResponse(Response):
+    pdu_id = PduId.REGISTER_NOTIFICATION
+    event: Event = field(
+        metadata=hci.metadata(
+            lambda data, offset: (len(data), Event.from_bytes(data[offset:]))
+        )
+    )
 
-    class RepeatModeStatus(utils.OpenIntEnum):
-        OFF = 0x01
-        SINGLE_TRACK_REPEAT = 0x02
-        ALL_TRACK_REPEAT = 0x03
-        GROUP_REPEAT = 0x04
 
-    class ShuffleOnOffStatus(utils.OpenIntEnum):
-        OFF = 0x01
-        ALL_TRACKS_SHUFFLE = 0x02
-        GROUP_SHUFFLE = 0x03
-
-    class ScanOnOffStatus(utils.OpenIntEnum):
-        OFF = 0x01
-        ALL_TRACKS_SCAN = 0x02
-        GROUP_SCAN = 0x03
+# -----------------------------------------------------------------------------
+@Response.response
+@dataclass
+class SetAddressedPlayerResponse(Response):
+    pdu_id = PduId.SET_ADDRESSED_PLAYER
 
-    class GenericValue(utils.OpenIntEnum):
-        pass
+    status: StatusCode = field(metadata=StatusCode.type_metadata(1))
 
 
 # -----------------------------------------------------------------------------
+@Response.response
 @dataclass
-class Event:
-    event_id: EventId
-
-    @classmethod
-    def from_bytes(cls, pdu: bytes) -> Event:
-        event_id = EventId(pdu[0])
-        subclass = EVENT_SUBCLASSES.get(event_id, GenericEvent)
-        return subclass.from_bytes(pdu)
+class SetBrowsedPlayerResponse(Response):
+    pdu_id = PduId.SET_BROWSED_PLAYER
 
-    def __bytes__(self) -> bytes:
-        return bytes([self.event_id])
+    status: StatusCode = field(metadata=StatusCode.type_metadata(1))
+    uid_counter: int = field(metadata=hci.metadata('>2'))
+    numbers_of_items: int = field(metadata=hci.metadata('>4'))
+    character_set_id: CharacterSetId = field(
+        metadata=CharacterSetId.type_metadata(2, byteorder='big')
+    )
+    folder_names: Sequence[str] = field(
+        metadata=hci.metadata(_string_spec(2), list_begin=True, list_end=True)
+    )
 
 
 # -----------------------------------------------------------------------------
+@Response.response
 @dataclass
-class GenericEvent(Event):
-    data: bytes
+class GetFolderItemsResponse(Response):
+    pdu_id = PduId.GET_FOLDER_ITEMS
 
-    @classmethod
-    def from_bytes(cls, pdu: bytes) -> GenericEvent:
-        return cls(event_id=EventId(pdu[0]), data=pdu[1:])
+    status: StatusCode
+    uid_counter: int
+    items: Sequence[BrowseableItem]
 
-    def __bytes__(self) -> bytes:
-        return bytes([self.event_id]) + self.data
+    @classmethod
+    def from_parameters(cls, parameters: bytes) -> Response:
+        status, uid_counter, count = struct.unpack_from('>BHH', parameters)
+        items: list[BrowseableItem] = []
+        offset = 5
+        for _ in range(count):
+            offset, item = BrowseableItem.parse_from_bytes(parameters, offset)
+            items.append(item)
+        instance = cls(status=StatusCode(status), uid_counter=uid_counter, items=items)
+        instance._payload = parameters
+        return instance
+
+    def __post_init__(self) -> None:
+        if self._payload is None:
+            self._payload = struct.pack(
+                '>BHH', self.status, self.uid_counter, len(self.items)
+            ) + b''.join(map(bytes, self.items))
 
 
 # -----------------------------------------------------------------------------
+@Response.response
 @dataclass
-class PlaybackStatusChangedEvent(Event):
-    play_status: PlayStatus
-
-    @classmethod
-    def from_bytes(cls, pdu: bytes) -> PlaybackStatusChangedEvent:
-        return cls(play_status=PlayStatus(pdu[1]))
-
-    def __init__(self, play_status: PlayStatus) -> None:
-        super().__init__(EventId.PLAYBACK_STATUS_CHANGED)
-        self.play_status = play_status
+class ChangePathResponse(Response):
+    pdu_id = PduId.CHANGE_PATH
 
-    def __bytes__(self) -> bytes:
-        return bytes([self.event_id]) + bytes([self.play_status])
+    status: StatusCode = field(metadata=StatusCode.type_metadata(1))
+    number_of_items: int = field(metadata=hci.metadata('>4'))
 
 
 # -----------------------------------------------------------------------------
+@Response.response
 @dataclass
-class PlaybackPositionChangedEvent(Event):
-    playback_position: int
+class GetItemAttributesResponse(Response):
+    pdu_id = PduId.GET_ITEM_ATTRIBUTES
 
-    @classmethod
-    def from_bytes(cls, pdu: bytes) -> PlaybackPositionChangedEvent:
-        return cls(playback_position=struct.unpack_from(">I", pdu, 1)[0])
+    status: StatusCode = field(metadata=StatusCode.type_metadata(1))
+    attribute_value_entry_list: Sequence[AttributeValueEntry] = field(
+        metadata=hci.metadata(
+            AttributeValueEntry.parse_from_bytes, list_begin=True, list_end=True
+        )
+    )
 
-    def __init__(self, playback_position: int) -> None:
-        super().__init__(EventId.PLAYBACK_POS_CHANGED)
-        self.playback_position = playback_position
 
-    def __bytes__(self) -> bytes:
-        return bytes([self.event_id]) + struct.pack(">I", self.playback_position)
+# -----------------------------------------------------------------------------
+@Response.response
+@dataclass
+class GetTotalNumberOfItemsResponse(Response):
+    pdu_id = PduId.GET_TOTAL_NUMBER_OF_ITEMS
+
+    status: StatusCode = field(metadata=StatusCode.type_metadata(1))
+    uid_counter: int = field(metadata=hci.metadata('>2'))
+    number_of_items: int = field(metadata=hci.metadata('>4'))
 
 
 # -----------------------------------------------------------------------------
+@Response.response
 @dataclass
-class TrackChangedEvent(Event):
-    identifier: bytes
+class SearchResponse(Response):
+    pdu_id = PduId.SEARCH
 
-    @classmethod
-    def from_bytes(cls, pdu: bytes) -> TrackChangedEvent:
-        return cls(identifier=pdu[1:])
+    status: StatusCode = field(metadata=StatusCode.type_metadata(1))
+    uid_counter: int = field(metadata=hci.metadata('>2'))
+    number_of_items: int = field(metadata=hci.metadata('>4'))
 
-    def __init__(self, identifier: bytes) -> None:
-        super().__init__(EventId.TRACK_CHANGED)
-        self.identifier = identifier
 
-    def __bytes__(self) -> bytes:
-        return bytes([self.event_id]) + self.identifier
+# -----------------------------------------------------------------------------
+@Response.response
+@dataclass
+class PlayItemResponse(Response):
+    pdu_id = PduId.PLAY_ITEM
+
+    status: StatusCode = field(metadata=StatusCode.type_metadata(1))
 
 
 # -----------------------------------------------------------------------------
+@Response.response
 @dataclass
-class PlayerApplicationSettingChangedEvent(Event):
-    @dataclass
-    class Setting:
-        attribute_id: ApplicationSetting.AttributeId
-        value_id: utils.OpenIntEnum
+class AddToNowPlayingResponse(Response):
+    pdu_id = PduId.ADD_TO_NOW_PLAYING
 
-    player_application_settings: list[Setting]
+    status: StatusCode = field(metadata=StatusCode.type_metadata(1))
 
-    @classmethod
-    def from_bytes(cls, pdu: bytes) -> PlayerApplicationSettingChangedEvent:
-        def setting(attribute_id_int: int, value_id_int: int):
-            attribute_id = ApplicationSetting.AttributeId(attribute_id_int)
-            value_id: utils.OpenIntEnum
-            if attribute_id == ApplicationSetting.AttributeId.EQUALIZER_ON_OFF:
-                value_id = ApplicationSetting.EqualizerOnOffStatus(value_id_int)
-            elif attribute_id == ApplicationSetting.AttributeId.REPEAT_MODE:
-                value_id = ApplicationSetting.RepeatModeStatus(value_id_int)
-            elif attribute_id == ApplicationSetting.AttributeId.SHUFFLE_ON_OFF:
-                value_id = ApplicationSetting.ShuffleOnOffStatus(value_id_int)
-            elif attribute_id == ApplicationSetting.AttributeId.SCAN_ON_OFF:
-                value_id = ApplicationSetting.ScanOnOffStatus(value_id_int)
-            else:
-                value_id = ApplicationSetting.GenericValue(value_id_int)
 
-            return cls.Setting(attribute_id, value_id)
+# -----------------------------------------------------------------------------
+class Event:
+    event_id: EventId
+    _pdu: Optional[bytes] = None
 
-        settings = [
-            setting(pdu[2 + (i * 2)], pdu[2 + (i * 2) + 1]) for i in range(pdu[1])
-        ]
-        return cls(player_application_settings=settings)
+    _Event = TypeVar('_Event', bound='Event')
+    subclasses: ClassVar[dict[int, type[Event]]] = {}
+    fields: ClassVar[hci.Fields] = ()
 
-    def __init__(self, player_application_settings: Sequence[Setting]) -> None:
-        super().__init__(EventId.PLAYER_APPLICATION_SETTING_CHANGED)
-        self.player_application_settings = list(player_application_settings)
+    @classmethod
+    def event(cls, subclass: type[_Event]) -> type[_Event]:
+        cls.subclasses[subclass.event_id] = subclass
+        subclass.fields = hci.HCI_Object.fields_from_dataclass(subclass)
+        return subclass
+
+    @classmethod
+    def from_bytes(cls, pdu: bytes) -> Event:
+        if not (subclass := cls.subclasses.get(pdu[0])):
+            raise core.InvalidPacketError(f"Unimplemented Event {pdu[0]}")
+        instance = subclass(**hci.HCI_Object.dict_from_bytes(pdu, 1, subclass.fields))
+        instance._pdu = pdu
+        return instance
 
     def __bytes__(self) -> bytes:
-        return (
-            bytes([self.event_id])
-            + bytes([len(self.player_application_settings)])
-            + b''.join(
-                [
-                    bytes([setting.attribute_id, setting.value_id])
-                    for setting in self.player_application_settings
-                ]
+        if self._pdu is None:
+            self._pdu = bytes([self.event_id]) + hci.HCI_Object.dict_to_bytes(
+                self.__dict__, self.fields
             )
-        )
+        return self._pdu
 
 
 # -----------------------------------------------------------------------------
 @dataclass
-class NowPlayingContentChangedEvent(Event):
-    @classmethod
-    def from_bytes(cls, pdu: bytes) -> NowPlayingContentChangedEvent:
-        return cls()
+class GenericEvent(Event):
+    event_id: EventId = field(metadata=EventId.type_metadata(1))
+    data: bytes = field(metadata=hci.metadata('*'))
+
 
-    def __init__(self) -> None:
-        super().__init__(EventId.NOW_PLAYING_CONTENT_CHANGED)
+GenericEvent.fields = hci.HCI_Object.fields_from_dataclass(GenericEvent)
 
 
 # -----------------------------------------------------------------------------
+@Event.event
 @dataclass
-class AvailablePlayersChangedEvent(Event):
-    @classmethod
-    def from_bytes(cls, pdu: bytes) -> AvailablePlayersChangedEvent:
-        return cls()
+class PlaybackStatusChangedEvent(Event):
+    event_id = EventId.PLAYBACK_STATUS_CHANGED
+    play_status: PlayStatus = field(metadata=PlayStatus.type_metadata(1))
+
 
-    def __init__(self) -> None:
-        super().__init__(EventId.AVAILABLE_PLAYERS_CHANGED)
+# -----------------------------------------------------------------------------
+@Event.event
+@dataclass
+class PlaybackPositionChangedEvent(Event):
+    event_id = EventId.PLAYBACK_POS_CHANGED
+    playback_position: int = field(metadata=hci.metadata('>4'))
 
 
 # -----------------------------------------------------------------------------
+@Event.event
 @dataclass
-class AddressedPlayerChangedEvent(Event):
-    @dataclass
-    class Player:
-        player_id: int
-        uid_counter: int
+class TrackChangedEvent(Event):
+    event_id = EventId.TRACK_CHANGED
+    identifier: bytes = field(metadata=hci.metadata('*'))
 
-    @classmethod
-    def from_bytes(cls, pdu: bytes) -> AddressedPlayerChangedEvent:
-        player_id, uid_counter = struct.unpack_from("<HH", pdu, 1)
-        return cls(cls.Player(player_id, uid_counter))
 
-    def __init__(self, player: Player) -> None:
-        super().__init__(EventId.ADDRESSED_PLAYER_CHANGED)
-        self.player = player
+# -----------------------------------------------------------------------------
+@Event.event
+@dataclass
+class PlayerApplicationSettingChangedEvent(Event):
+    event_id = EventId.PLAYER_APPLICATION_SETTING_CHANGED
 
-    def __bytes__(self) -> bytes:
-        return bytes([self.event_id]) + struct.pack(
-            ">HH", self.player.player_id, self.player.uid_counter
+    @dataclass
+    class Setting(hci.HCI_Dataclass_Object):
+        attribute_id: ApplicationSetting.AttributeId = field(
+            metadata=ApplicationSetting.AttributeId.type_metadata(1)
         )
+        value_id: Union[
+            ApplicationSetting.EqualizerOnOffStatus,
+            ApplicationSetting.RepeatModeStatus,
+            ApplicationSetting.ShuffleOnOffStatus,
+            ApplicationSetting.ScanOnOffStatus,
+            ApplicationSetting.GenericValue,
+        ] = field(metadata=hci.metadata(1))
+
+        def __post_init__(self) -> None:
+            super().__post_init__()
+            if self.attribute_id == ApplicationSetting.AttributeId.EQUALIZER_ON_OFF:
+                self.value_id = ApplicationSetting.EqualizerOnOffStatus(self.value_id)
+            elif self.attribute_id == ApplicationSetting.AttributeId.REPEAT_MODE:
+                self.value_id = ApplicationSetting.RepeatModeStatus(self.value_id)
+            elif self.attribute_id == ApplicationSetting.AttributeId.SHUFFLE_ON_OFF:
+                self.value_id = ApplicationSetting.ShuffleOnOffStatus(self.value_id)
+            elif self.attribute_id == ApplicationSetting.AttributeId.SCAN_ON_OFF:
+                self.value_id = ApplicationSetting.ScanOnOffStatus(self.value_id)
+            else:
+                self.value_id = ApplicationSetting.GenericValue(self.value_id)
+
+    player_application_settings: Sequence[Setting] = field(
+        metadata=hci.metadata(Setting.parse_from_bytes, list_begin=True, list_end=True)
+    )
 
 
 # -----------------------------------------------------------------------------
+@Event.event
 @dataclass
-class UidsChangedEvent(Event):
-    uid_counter: int
-
-    @classmethod
-    def from_bytes(cls, pdu: bytes) -> UidsChangedEvent:
-        return cls(uid_counter=struct.unpack_from(">H", pdu, 1)[0])
+class NowPlayingContentChangedEvent(Event):
+    event_id = EventId.NOW_PLAYING_CONTENT_CHANGED
 
-    def __init__(self, uid_counter: int) -> None:
-        super().__init__(EventId.UIDS_CHANGED)
-        self.uid_counter = uid_counter
 
-    def __bytes__(self) -> bytes:
-        return bytes([self.event_id]) + struct.pack(">H", self.uid_counter)
+# -----------------------------------------------------------------------------
+@Event.event
+@dataclass
+class AvailablePlayersChangedEvent(Event):
+    event_id = EventId.AVAILABLE_PLAYERS_CHANGED
 
 
 # -----------------------------------------------------------------------------
+@Event.event
 @dataclass
-class VolumeChangedEvent(Event):
-    volume: int
+class AddressedPlayerChangedEvent(Event):
+    event_id = EventId.ADDRESSED_PLAYER_CHANGED
 
-    @classmethod
-    def from_bytes(cls, pdu: bytes) -> VolumeChangedEvent:
-        return cls(volume=pdu[1])
+    @dataclass
+    class Player(hci.HCI_Dataclass_Object):
+        player_id: int = field(metadata=hci.metadata('>2'))
+        uid_counter: int = field(metadata=hci.metadata('>2'))
 
-    def __init__(self, volume: int) -> None:
-        super().__init__(EventId.VOLUME_CHANGED)
-        self.volume = volume
+    player: Player = field(metadata=hci.metadata(Player.parse_from_bytes))
 
-    def __bytes__(self) -> bytes:
-        return bytes([self.event_id]) + bytes([self.volume])
+
+# -----------------------------------------------------------------------------
+@Event.event
+@dataclass
+class UidsChangedEvent(Event):
+    event_id = EventId.UIDS_CHANGED
+    uid_counter: int = field(metadata=hci.metadata('>2'))
 
 
 # -----------------------------------------------------------------------------
-EVENT_SUBCLASSES: dict[EventId, type[Event]] = {
-    EventId.PLAYBACK_STATUS_CHANGED: PlaybackStatusChangedEvent,
-    EventId.PLAYBACK_POS_CHANGED: PlaybackPositionChangedEvent,
-    EventId.TRACK_CHANGED: TrackChangedEvent,
-    EventId.PLAYER_APPLICATION_SETTING_CHANGED: PlayerApplicationSettingChangedEvent,
-    EventId.NOW_PLAYING_CONTENT_CHANGED: NowPlayingContentChangedEvent,
-    EventId.AVAILABLE_PLAYERS_CHANGED: AvailablePlayersChangedEvent,
-    EventId.ADDRESSED_PLAYER_CHANGED: AddressedPlayerChangedEvent,
-    EventId.UIDS_CHANGED: UidsChangedEvent,
-    EventId.VOLUME_CHANGED: VolumeChangedEvent,
-}
+@Event.event
+@dataclass
+class VolumeChangedEvent(Event):
+    event_id = EventId.VOLUME_CHANGED
+    volume: int = field(metadata=hci.metadata(1))
 
 
 # -----------------------------------------------------------------------------
@@ -952,7 +1530,7 @@ class Delegate:
     class Error(Exception):
         """The delegate method failed, with a specified status code."""
 
-        def __init__(self, status_code: Protocol.StatusCode) -> None:
+        def __init__(self, status_code: StatusCode) -> None:
             self.status_code = status_code
 
     supported_events: list[EventId]
@@ -994,51 +1572,6 @@ class Protocol(utils.EventEmitter):
         CONTINUE = 0b10
         END = 0b11
 
-    class PduId(utils.OpenIntEnum):
-        GET_CAPABILITIES = 0x10
-        LIST_PLAYER_APPLICATION_SETTING_ATTRIBUTES = 0x11
-        LIST_PLAYER_APPLICATION_SETTING_VALUES = 0x12
-        GET_CURRENT_PLAYER_APPLICATION_SETTING_VALUE = 0x13
-        SET_PLAYER_APPLICATION_SETTING_VALUE = 0x14
-        GET_PLAYER_APPLICATION_SETTING_ATTRIBUTE_TEXT = 0x15
-        GET_PLAYER_APPLICATION_SETTING_VALUE_TEXT = 0x16
-        INFORM_DISPLAYABLE_CHARACTER_SET = 0x17
-        INFORM_BATTERY_STATUS_OF_CT = 0x18
-        GET_ELEMENT_ATTRIBUTES = 0x20
-        GET_PLAY_STATUS = 0x30
-        REGISTER_NOTIFICATION = 0x31
-        REQUEST_CONTINUING_RESPONSE = 0x40
-        ABORT_CONTINUING_RESPONSE = 0x41
-        SET_ABSOLUTE_VOLUME = 0x50
-        SET_ADDRESSED_PLAYER = 0x60
-        SET_BROWSED_PLAYER = 0x70
-        GET_FOLDER_ITEMS = 0x71
-        GET_TOTAL_NUMBER_OF_ITEMS = 0x75
-
-    class StatusCode(utils.OpenIntEnum):
-        INVALID_COMMAND = 0x00
-        INVALID_PARAMETER = 0x01
-        PARAMETER_CONTENT_ERROR = 0x02
-        INTERNAL_ERROR = 0x03
-        OPERATION_COMPLETED = 0x04
-        UID_CHANGED = 0x05
-        INVALID_DIRECTION = 0x07
-        NOT_A_DIRECTORY = 0x08
-        DOES_NOT_EXIST = 0x09
-        INVALID_SCOPE = 0x0A
-        RANGE_OUT_OF_BOUNDS = 0x0B
-        FOLDER_ITEM_IS_NOT_PLAYABLE = 0x0C
-        MEDIA_IN_USE = 0x0D
-        NOW_PLAYING_LIST_FULL = 0x0E
-        SEARCH_NOT_SUPPORTED = 0x0F
-        SEARCH_IN_PROGRESS = 0x10
-        INVALID_PLAYER_ID = 0x11
-        PLAYER_NOT_BROWSABLE = 0x12
-        PLAYER_NOT_ADDRESSED = 0x13
-        NO_VALID_SEARCH_RESULTS = 0x14
-        NO_AVAILABLE_PLAYERS = 0x15
-        ADDRESSED_PLAYER_CHANGED = 0x16
-
     class InvalidPidError(Exception):
         """A response frame with ipid==1 was received."""
 
@@ -1117,7 +1650,7 @@ class Protocol(utils.EventEmitter):
 
     @staticmethod
     def _check_vendor_dependent_frame(
-        frame: Union[avc.VendorDependentCommandFrame, avc.VendorDependentResponseFrame]
+        frame: Union[avc.VendorDependentCommandFrame, avc.VendorDependentResponseFrame],
     ) -> bool:
         if frame.company_id != AVRCP_BLUETOOTH_SIG_COMPANY_ID:
             logger.debug("unsupported company id, ignoring")
@@ -1152,7 +1685,9 @@ class Protocol(utils.EventEmitter):
         A 'connection' event will be emitted when a connection is made, and a 'start'
         event will be emitted when the protocol is ready to be used on that connection.
         """
-        device.register_l2cap_server(avctp.AVCTP_PSM, self._on_avctp_connection)
+        device.create_l2cap_server(
+            l2cap.ClassicChannelSpec(avctp.AVCTP_PSM), self._on_avctp_connection
+        )
 
     async def connect(self, connection: Connection) -> None:
         """
@@ -1213,7 +1748,7 @@ class Protocol(utils.EventEmitter):
                 self.send_rejected_avrcp_response(
                     transaction_label,
                     command.pdu_id,
-                    Protocol.StatusCode.INTERNAL_ERROR,
+                    StatusCode.INTERNAL_ERROR,
                 )
 
         utils.AsyncRunner.spawn(call())
@@ -1248,7 +1783,7 @@ class Protocol(utils.EventEmitter):
             GetElementAttributesCommand(element_identifier, attribute_ids),
         )
         response = self._check_response(response_context, GetElementAttributesResponse)
-        return response.attributes
+        return list(response.attributes)
 
     async def monitor_events(
         self, event_id: EventId, playback_interval: int = 0
@@ -1331,7 +1866,7 @@ class Protocol(utils.EventEmitter):
             if not isinstance(event, PlayerApplicationSettingChangedEvent):
                 logger.warning("unexpected event class")
                 continue
-            yield event.player_application_settings
+            yield list(event.player_application_settings)
 
     async def monitor_now_playing_content(self) -> AsyncIterator[None]:
         """Monitor Now Playing changes from the connected peer."""
@@ -1601,29 +2136,24 @@ class Protocol(utils.EventEmitter):
             avc.CommandFrame.CommandType.NOTIFY,
         ):
             # TODO: catch exceptions from delegates
-            if pdu_id == self.PduId.GET_CAPABILITIES:
-                self._on_get_capabilities_command(
-                    transaction_label, GetCapabilitiesCommand.from_bytes(pdu)
-                )
-            elif pdu_id == self.PduId.SET_ABSOLUTE_VOLUME:
-                self._on_set_absolute_volume_command(
-                    transaction_label, SetAbsoluteVolumeCommand.from_bytes(pdu)
-                )
-            elif pdu_id == self.PduId.REGISTER_NOTIFICATION:
-                self._on_register_notification_command(
-                    transaction_label, RegisterNotificationCommand.from_bytes(pdu)
-                )
+            command = Command.from_bytes(pdu_id, pdu)
+            if isinstance(command, GetCapabilitiesCommand):
+                self._on_get_capabilities_command(transaction_label, command)
+            elif isinstance(command, SetAbsoluteVolumeCommand):
+                self._on_set_absolute_volume_command(transaction_label, command)
+            elif isinstance(command, RegisterNotificationCommand):
+                self._on_register_notification_command(transaction_label, command)
             else:
                 # Not supported.
                 # TODO: check that this is the right way to respond in this case.
                 logger.debug("unsupported PDU ID")
                 self.send_rejected_avrcp_response(
-                    transaction_label, pdu_id, self.StatusCode.INVALID_PARAMETER
+                    transaction_label, pdu_id, StatusCode.INVALID_PARAMETER
                 )
         else:
             logger.debug("unsupported command type")
             self.send_rejected_avrcp_response(
-                transaction_label, pdu_id, self.StatusCode.INVALID_COMMAND
+                transaction_label, pdu_id, StatusCode.INVALID_COMMAND
             )
 
         self.receive_command_state = None
@@ -1648,34 +2178,16 @@ class Protocol(utils.EventEmitter):
         # more appropriate.
         response: Optional[Response] = None
         if response_code == avc.ResponseFrame.ResponseCode.REJECTED:
-            response = RejectedResponse.from_bytes(pdu_id, pdu)
+            response = RejectedResponse(pdu_id=pdu_id, status_code=StatusCode(pdu[0]))
         elif response_code == avc.ResponseFrame.ResponseCode.NOT_IMPLEMENTED:
-            response = NotImplementedResponse.from_bytes(pdu_id, pdu)
+            response = NotImplementedResponse(pdu_id=pdu_id, parameters=pdu)
         elif response_code in (
             avc.ResponseFrame.ResponseCode.IMPLEMENTED_OR_STABLE,
             avc.ResponseFrame.ResponseCode.INTERIM,
             avc.ResponseFrame.ResponseCode.CHANGED,
             avc.ResponseFrame.ResponseCode.ACCEPTED,
         ):
-            if pdu_id == self.PduId.GET_CAPABILITIES:
-                response = GetCapabilitiesResponse.from_bytes(pdu)
-            elif pdu_id == self.PduId.GET_PLAY_STATUS:
-                response = GetPlayStatusResponse.from_bytes(pdu)
-            elif pdu_id == self.PduId.GET_ELEMENT_ATTRIBUTES:
-                response = GetElementAttributesResponse.from_bytes(pdu)
-            elif pdu_id == self.PduId.SET_ABSOLUTE_VOLUME:
-                response = SetAbsoluteVolumeResponse.from_bytes(pdu)
-            elif pdu_id == self.PduId.REGISTER_NOTIFICATION:
-                response = RegisterNotificationResponse.from_bytes(pdu)
-            else:
-                logger.debug("unexpected PDU ID")
-                pending_command.response.set_exception(
-                    core.ProtocolError(
-                        error_code=None,
-                        error_namespace="avrcp",
-                        details="unexpected PDU ID",
-                    )
-                )
+            response = Response.from_bytes(pdu=pdu, pdu_id=PduId(pdu_id))
         else:
             logger.debug("unexpected response code")
             pending_command.response.set_exception(
@@ -1762,10 +2274,8 @@ class Protocol(utils.EventEmitter):
         # TODO: fragmentation
         # Send the command.
         logger.debug(f">>> AVRCP command PDU: {command}")
-        pdu = (
-            struct.pack(">BBH", command.pdu_id, 0, len(command.parameter))
-            + command.parameter
-        )
+        payload = bytes(command)
+        pdu = struct.pack(">BBH", command.pdu_id, 0, len(payload)) + payload
         command_frame = avc.VendorDependentCommandFrame(
             command_type,
             avc.Frame.SubunitType.PANEL,
@@ -1809,10 +2319,8 @@ class Protocol(utils.EventEmitter):
     ) -> None:
         # TODO: fragmentation
         logger.debug(f">>> AVRCP response PDU: {response}")
-        pdu = (
-            struct.pack(">BBH", response.pdu_id, 0, len(response.parameter))
-            + response.parameter
-        )
+        payload = bytes(response)
+        pdu = struct.pack(">BBH", response.pdu_id, 0, len(payload)) + payload
         response_frame = avc.VendorDependentResponseFrame(
             response_code,
             avc.Frame.SubunitType.PANEL,
@@ -1835,7 +2343,7 @@ class Protocol(utils.EventEmitter):
         self.send_response(transaction_label, response)
 
     def send_rejected_avrcp_response(
-        self, transaction_label: int, pdu_id: Protocol.PduId, status_code: StatusCode
+        self, transaction_label: int, pdu_id: PduId, status_code: StatusCode
     ) -> None:
         self.send_avrcp_response(
             transaction_label,
@@ -1844,7 +2352,7 @@ class Protocol(utils.EventEmitter):
         )
 
     def send_not_implemented_avrcp_response(
-        self, transaction_label: int, pdu_id: Protocol.PduId
+        self, transaction_label: int, pdu_id: PduId
     ) -> None:
         self.send_avrcp_response(
             transaction_label,
@@ -1900,7 +2408,7 @@ class Protocol(utils.EventEmitter):
             if command.event_id not in supported_events:
                 logger.debug("event not supported")
                 self.send_not_implemented_avrcp_response(
-                    transaction_label, self.PduId.REGISTER_NOTIFICATION
+                    transaction_label, PduId.REGISTER_NOTIFICATION
                 )
                 return