Merge pull request #418 from zxzxwu/rfc

RFCOMM: Slightly refactor and correct constants

.github/workflows/code-check.yml

@@ -29,7 +29,7 @@ jobs:
     - name: Set up Python
       uses: actions/setup-python@v3
       with:
-        python-version: '3.10'
+        python-version: ${{ matrix.python-version }}
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip

.vscode/settings.json

@@ -12,7 +12,9 @@
         "ASHA",
         "asyncio",
         "ATRAC",
+        "avctp",
         "avdtp",
+        "avrcp",
         "bitpool",
         "bitstruct",
         "BSCP",

apps/scan.py

@@ -26,7 +26,7 @@ from bumble.transport import open_transport_or_link
 from bumble.keys import JsonKeyStore
 from bumble.smp import AddressResolver
 from bumble.device import Advertisement
-from bumble.hci import HCI_Constant, HCI_LE_1M_PHY, HCI_LE_CODED_PHY
+from bumble.hci import Address, HCI_Constant, HCI_LE_1M_PHY, HCI_LE_CODED_PHY
 
 
 # -----------------------------------------------------------------------------
@@ -66,10 +66,15 @@ class AdvertisementPrinter:
         address_type_string = ('PUBLIC', 'RANDOM', 'PUBLIC_ID', 'RANDOM_ID')[
             address.address_type
         ]
-        if address.is_public:
-            type_color = 'cyan'
+        if address.address_type in (
+            Address.RANDOM_IDENTITY_ADDRESS,
+            Address.PUBLIC_IDENTITY_ADDRESS,
+        ):
+            type_color = 'yellow'
         else:
-            if address.is_static:
+            if address.is_public:
+                type_color = 'cyan'
+            elif address.is_static:
                 type_color = 'green'
                 address_qualifier = '(static)'
             elif address.is_resolvable:
@@ -116,6 +121,7 @@ async def scan(
     phy,
     filter_duplicates,
     raw,
+    irks,
     keystore_file,
     device_config,
     transport,
@@ -140,9 +146,21 @@ async def scan(
 
         if device.keystore:
             resolving_keys = await device.keystore.get_resolving_keys()
-            resolver = AddressResolver(resolving_keys)
         else:
-            resolver = None
+            resolving_keys = []
+
+        for irk_and_address in irks:
+            if ':' not in irk_and_address:
+                raise ValueError('invalid IRK:ADDRESS value')
+            irk_hex, address_str = irk_and_address.split(':', 1)
+            resolving_keys.append(
+                (
+                    bytes.fromhex(irk_hex),
+                    Address(address_str, Address.RANDOM_DEVICE_ADDRESS),
+                )
+            )
+
+        resolver = AddressResolver(resolving_keys) if resolving_keys else None
 
         printer = AdvertisementPrinter(min_rssi, resolver)
         if raw:
@@ -187,8 +205,24 @@ async def scan(
     default=False,
     help='Listen for raw advertising reports instead of processed ones',
 )
-@click.option('--keystore-file', help='Keystore file to use when resolving addresses')
-@click.option('--device-config', help='Device config file for the scanning device')
+@click.option(
+    '--irk',
+    metavar='<IRK_HEX>:<ADDRESS>',
+    help=(
+        'Use this IRK for resolving private addresses ' '(may be used more than once)'
+    ),
+    multiple=True,
+)
+@click.option(
+    '--keystore-file',
+    metavar='FILE_PATH',
+    help='Keystore file to use when resolving addresses',
+)
+@click.option(
+    '--device-config',
+    metavar='FILE_PATH',
+    help='Device config file for the scanning device',
+)
 @click.argument('transport')
 def main(
     min_rssi,
@@ -198,6 +232,7 @@ def main(
     phy,
     filter_duplicates,
     raw,
+    irk,
     keystore_file,
     device_config,
     transport,
@@ -212,6 +247,7 @@ def main(
             phy,
             filter_duplicates,
             raw,
+            irk,
             keystore_file,
             device_config,
             transport,

bumble/a2dp.py

@@ -184,8 +184,12 @@ def make_audio_source_service_sdp_records(service_record_handle, version=(1, 3))
             SDP_BLUETOOTH_PROFILE_DESCRIPTOR_LIST_ATTRIBUTE_ID,
             DataElement.sequence(
                 [
-                    DataElement.uuid(BT_ADVANCED_AUDIO_DISTRIBUTION_SERVICE),
-                    DataElement.unsigned_integer_16(version_int),
+                    DataElement.sequence(
+                        [
+                            DataElement.uuid(BT_ADVANCED_AUDIO_DISTRIBUTION_SERVICE),
+                            DataElement.unsigned_integer_16(version_int),
+                        ]
+                    )
                 ]
             ),
         ),
@@ -234,8 +238,12 @@ def make_audio_sink_service_sdp_records(service_record_handle, version=(1, 3)):
             SDP_BLUETOOTH_PROFILE_DESCRIPTOR_LIST_ATTRIBUTE_ID,
             DataElement.sequence(
                 [
-                    DataElement.uuid(BT_ADVANCED_AUDIO_DISTRIBUTION_SERVICE),
-                    DataElement.unsigned_integer_16(version_int),
+                    DataElement.sequence(
+                        [
+                            DataElement.uuid(BT_ADVANCED_AUDIO_DISTRIBUTION_SERVICE),
+                            DataElement.unsigned_integer_16(version_int),
+                        ]
+                    )
                 ]
             ),
         ),

bumble/avc.py

@@ -0,0 +1,520 @@
+# Copyright 2021-2023 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+from __future__ import annotations
+import enum
+import struct
+from typing import Dict, Type, Union, Tuple
+
+from bumble.utils import OpenIntEnum
+
+
+# -----------------------------------------------------------------------------
+class Frame:
+    class SubunitType(enum.IntEnum):
+        # AV/C Digital Interface Command Set General Specification Version 4.1
+        # Table 7.4
+        MONITOR = 0x00
+        AUDIO = 0x01
+        PRINTER = 0x02
+        DISC = 0x03
+        TAPE_RECORDER_OR_PLAYER = 0x04
+        TUNER = 0x05
+        CA = 0x06
+        CAMERA = 0x07
+        PANEL = 0x09
+        BULLETIN_BOARD = 0x0A
+        VENDOR_UNIQUE = 0x1C
+        EXTENDED = 0x1E
+        UNIT = 0x1F
+
+    class OperationCode(OpenIntEnum):
+        # 0x00 - 0x0F: Unit and subunit commands
+        VENDOR_DEPENDENT = 0x00
+        RESERVE = 0x01
+        PLUG_INFO = 0x02
+
+        # 0x10 - 0x3F: Unit commands
+        DIGITAL_OUTPUT = 0x10
+        DIGITAL_INPUT = 0x11
+        CHANNEL_USAGE = 0x12
+        OUTPUT_PLUG_SIGNAL_FORMAT = 0x18
+        INPUT_PLUG_SIGNAL_FORMAT = 0x19
+        GENERAL_BUS_SETUP = 0x1F
+        CONNECT_AV = 0x20
+        DISCONNECT_AV = 0x21
+        CONNECTIONS = 0x22
+        CONNECT = 0x24
+        DISCONNECT = 0x25
+        UNIT_INFO = 0x30
+        SUBUNIT_INFO = 0x31
+
+        # 0x40 - 0x7F: Subunit commands
+        PASS_THROUGH = 0x7C
+        GUI_UPDATE = 0x7D
+        PUSH_GUI_DATA = 0x7E
+        USER_ACTION = 0x7F
+
+        # 0xA0 - 0xBF: Unit and subunit commands
+        VERSION = 0xB0
+        POWER = 0xB2
+
+    subunit_type: SubunitType
+    subunit_id: int
+    opcode: OperationCode
+    operands: bytes
+
+    @staticmethod
+    def subclass(subclass):
+        # Infer the opcode from the class name
+        if subclass.__name__.endswith("CommandFrame"):
+            short_name = subclass.__name__.replace("CommandFrame", "")
+            category_class = CommandFrame
+        elif subclass.__name__.endswith("ResponseFrame"):
+            short_name = subclass.__name__.replace("ResponseFrame", "")
+            category_class = ResponseFrame
+        else:
+            raise ValueError(f"invalid subclass name {subclass.__name__}")
+
+        uppercase_indexes = [
+            i for i in range(len(short_name)) if short_name[i].isupper()
+        ]
+        uppercase_indexes.append(len(short_name))
+        words = [
+            short_name[uppercase_indexes[i] : uppercase_indexes[i + 1]].upper()
+            for i in range(len(uppercase_indexes) - 1)
+        ]
+        opcode_name = "_".join(words)
+        opcode = Frame.OperationCode[opcode_name]
+        category_class.subclasses[opcode] = subclass
+        return subclass
+
+    @staticmethod
+    def from_bytes(data: bytes) -> Frame:
+        if data[0] >> 4 != 0:
+            raise ValueError("first 4 bits must be 0s")
+
+        ctype_or_response = data[0] & 0xF
+        subunit_type = Frame.SubunitType(data[1] >> 3)
+        subunit_id = data[1] & 7
+
+        if subunit_type == Frame.SubunitType.EXTENDED:
+            # Not supported
+            raise NotImplementedError("extended subunit types not supported")
+
+        if subunit_id < 5:
+            opcode_offset = 2
+        elif subunit_id == 5:
+            # Extended to the next byte
+            extension = data[2]
+            if extension == 0:
+                raise ValueError("extended subunit ID value reserved")
+            if extension == 0xFF:
+                subunit_id = 5 + 254 + data[3]
+                opcode_offset = 4
+            else:
+                subunit_id = 5 + extension
+                opcode_offset = 3
+
+        elif subunit_id == 6:
+            raise ValueError("reserved subunit ID")
+
+        opcode = Frame.OperationCode(data[opcode_offset])
+        operands = data[opcode_offset + 1 :]
+
+        # Look for a registered subclass
+        if ctype_or_response < 8:
+            # Command
+            ctype = CommandFrame.CommandType(ctype_or_response)
+            if c_subclass := CommandFrame.subclasses.get(opcode):
+                return c_subclass(
+                    ctype,
+                    subunit_type,
+                    subunit_id,
+                    *c_subclass.parse_operands(operands),
+                )
+            return CommandFrame(ctype, subunit_type, subunit_id, opcode, operands)
+        else:
+            # Response
+            response = ResponseFrame.ResponseCode(ctype_or_response)
+            if r_subclass := ResponseFrame.subclasses.get(opcode):
+                return r_subclass(
+                    response,
+                    subunit_type,
+                    subunit_id,
+                    *r_subclass.parse_operands(operands),
+                )
+            return ResponseFrame(response, subunit_type, subunit_id, opcode, operands)
+
+    def to_bytes(
+        self,
+        ctype_or_response: Union[CommandFrame.CommandType, ResponseFrame.ResponseCode],
+    ) -> bytes:
+        # TODO: support extended subunit types and ids.
+        return (
+            bytes(
+                [
+                    ctype_or_response,
+                    self.subunit_type << 3 | self.subunit_id,
+                    self.opcode,
+                ]
+            )
+            + self.operands
+        )
+
+    def to_string(self, extra: str) -> str:
+        return (
+            f"{self.__class__.__name__}({extra}"
+            f"subunit_type={self.subunit_type.name}, "
+            f"subunit_id=0x{self.subunit_id:02X}, "
+            f"opcode={self.opcode.name}, "
+            f"operands={self.operands.hex()})"
+        )
+
+    def __init__(
+        self,
+        subunit_type: SubunitType,
+        subunit_id: int,
+        opcode: OperationCode,
+        operands: bytes,
+    ) -> None:
+        self.subunit_type = subunit_type
+        self.subunit_id = subunit_id
+        self.opcode = opcode
+        self.operands = operands
+
+
+# -----------------------------------------------------------------------------
+class CommandFrame(Frame):
+    class CommandType(OpenIntEnum):
+        # AV/C Digital Interface Command Set General Specification Version 4.1
+        # Table 7.1
+        CONTROL = 0x00
+        STATUS = 0x01
+        SPECIFIC_INQUIRY = 0x02
+        NOTIFY = 0x03
+        GENERAL_INQUIRY = 0x04
+
+    subclasses: Dict[Frame.OperationCode, Type[CommandFrame]] = {}
+    ctype: CommandType
+
+    @staticmethod
+    def parse_operands(operands: bytes) -> Tuple:
+        raise NotImplementedError
+
+    def __init__(
+        self,
+        ctype: CommandType,
+        subunit_type: Frame.SubunitType,
+        subunit_id: int,
+        opcode: Frame.OperationCode,
+        operands: bytes,
+    ) -> None:
+        super().__init__(subunit_type, subunit_id, opcode, operands)
+        self.ctype = ctype
+
+    def __bytes__(self):
+        return self.to_bytes(self.ctype)
+
+    def __str__(self):
+        return self.to_string(f"ctype={self.ctype.name}, ")
+
+
+# -----------------------------------------------------------------------------
+class ResponseFrame(Frame):
+    class ResponseCode(OpenIntEnum):
+        # AV/C Digital Interface Command Set General Specification Version 4.1
+        # Table 7.2
+        NOT_IMPLEMENTED = 0x08
+        ACCEPTED = 0x09
+        REJECTED = 0x0A
+        IN_TRANSITION = 0x0B
+        IMPLEMENTED_OR_STABLE = 0x0C
+        CHANGED = 0x0D
+        INTERIM = 0x0F
+
+    subclasses: Dict[Frame.OperationCode, Type[ResponseFrame]] = {}
+    response: ResponseCode
+
+    @staticmethod
+    def parse_operands(operands: bytes) -> Tuple:
+        raise NotImplementedError
+
+    def __init__(
+        self,
+        response: ResponseCode,
+        subunit_type: Frame.SubunitType,
+        subunit_id: int,
+        opcode: Frame.OperationCode,
+        operands: bytes,
+    ) -> None:
+        super().__init__(subunit_type, subunit_id, opcode, operands)
+        self.response = response
+
+    def __bytes__(self):
+        return self.to_bytes(self.response)
+
+    def __str__(self):
+        return self.to_string(f"response={self.response.name}, ")
+
+
+# -----------------------------------------------------------------------------
+class VendorDependentFrame:
+    company_id: int
+    vendor_dependent_data: bytes
+
+    @staticmethod
+    def parse_operands(operands: bytes) -> Tuple:
+        return (
+            struct.unpack(">I", b"\x00" + operands[:3])[0],
+            operands[3:],
+        )
+
+    def make_operands(self) -> bytes:
+        return struct.pack(">I", self.company_id)[1:] + self.vendor_dependent_data
+
+    def __init__(self, company_id: int, vendor_dependent_data: bytes):
+        self.company_id = company_id
+        self.vendor_dependent_data = vendor_dependent_data
+
+
+# -----------------------------------------------------------------------------
+@Frame.subclass
+class VendorDependentCommandFrame(VendorDependentFrame, CommandFrame):
+    def __init__(
+        self,
+        ctype: CommandFrame.CommandType,
+        subunit_type: Frame.SubunitType,
+        subunit_id: int,
+        company_id: int,
+        vendor_dependent_data: bytes,
+    ) -> None:
+        VendorDependentFrame.__init__(self, company_id, vendor_dependent_data)
+        CommandFrame.__init__(
+            self,
+            ctype,
+            subunit_type,
+            subunit_id,
+            Frame.OperationCode.VENDOR_DEPENDENT,
+            self.make_operands(),
+        )
+
+    def __str__(self):
+        return (
+            f"VendorDependentCommandFrame(ctype={self.ctype.name}, "
+            f"subunit_type={self.subunit_type.name}, "
+            f"subunit_id=0x{self.subunit_id:02X}, "
+            f"company_id=0x{self.company_id:06X}, "
+            f"vendor_dependent_data={self.vendor_dependent_data.hex()})"
+        )
+
+
+# -----------------------------------------------------------------------------
+@Frame.subclass
+class VendorDependentResponseFrame(VendorDependentFrame, ResponseFrame):
+    def __init__(
+        self,
+        response: ResponseFrame.ResponseCode,
+        subunit_type: Frame.SubunitType,
+        subunit_id: int,
+        company_id: int,
+        vendor_dependent_data: bytes,
+    ) -> None:
+        VendorDependentFrame.__init__(self, company_id, vendor_dependent_data)
+        ResponseFrame.__init__(
+            self,
+            response,
+            subunit_type,
+            subunit_id,
+            Frame.OperationCode.VENDOR_DEPENDENT,
+            self.make_operands(),
+        )
+
+    def __str__(self):
+        return (
+            f"VendorDependentResponseFrame(response={self.response.name}, "
+            f"subunit_type={self.subunit_type.name}, "
+            f"subunit_id=0x{self.subunit_id:02X}, "
+            f"company_id=0x{self.company_id:06X}, "
+            f"vendor_dependent_data={self.vendor_dependent_data.hex()})"
+        )
+
+
+# -----------------------------------------------------------------------------
+class PassThroughFrame:
+    """
+    See AV/C Panel Subunit Specification 1.1 - 9.4 PASS THROUGH control command
+    """
+
+    class StateFlag(enum.IntEnum):
+        PRESSED = 0
+        RELEASED = 1
+
+    class OperationId(OpenIntEnum):
+        SELECT = 0x00
+        UP = 0x01
+        DOWN = 0x01
+        LEFT = 0x03
+        RIGHT = 0x04
+        RIGHT_UP = 0x05
+        RIGHT_DOWN = 0x06
+        LEFT_UP = 0x07
+        LEFT_DOWN = 0x08
+        ROOT_MENU = 0x09
+        SETUP_MENU = 0x0A
+        CONTENTS_MENU = 0x0B
+        FAVORITE_MENU = 0x0C
+        EXIT = 0x0D
+        NUMBER_0 = 0x20
+        NUMBER_1 = 0x21
+        NUMBER_2 = 0x22
+        NUMBER_3 = 0x23
+        NUMBER_4 = 0x24
+        NUMBER_5 = 0x25
+        NUMBER_6 = 0x26
+        NUMBER_7 = 0x27
+        NUMBER_8 = 0x28
+        NUMBER_9 = 0x29
+        DOT = 0x2A
+        ENTER = 0x2B
+        CLEAR = 0x2C
+        CHANNEL_UP = 0x30
+        CHANNEL_DOWN = 0x31
+        PREVIOUS_CHANNEL = 0x32
+        SOUND_SELECT = 0x33
+        INPUT_SELECT = 0x34
+        DISPLAY_INFORMATION = 0x35
+        HELP = 0x36
+        PAGE_UP = 0x37
+        PAGE_DOWN = 0x38
+        POWER = 0x40
+        VOLUME_UP = 0x41
+        VOLUME_DOWN = 0x42
+        MUTE = 0x43
+        PLAY = 0x44
+        STOP = 0x45
+        PAUSE = 0x46
+        RECORD = 0x47
+        REWIND = 0x48
+        FAST_FORWARD = 0x49
+        EJECT = 0x4A
+        FORWARD = 0x4B
+        BACKWARD = 0x4C
+        ANGLE = 0x50
+        SUBPICTURE = 0x51
+        F1 = 0x71
+        F2 = 0x72
+        F3 = 0x73
+        F4 = 0x74
+        F5 = 0x75
+        VENDOR_UNIQUE = 0x7E
+
+    state_flag: StateFlag
+    operation_id: OperationId
+    operation_data: bytes
+
+    @staticmethod
+    def parse_operands(operands: bytes) -> Tuple:
+        return (
+            PassThroughFrame.StateFlag(operands[0] >> 7),
+            PassThroughFrame.OperationId(operands[0] & 0x7F),
+            operands[1 : 1 + operands[1]],
+        )
+
+    def make_operands(self):
+        return (
+            bytes([self.state_flag << 7 | self.operation_id, len(self.operation_data)])
+            + self.operation_data
+        )
+
+    def __init__(
+        self,
+        state_flag: StateFlag,
+        operation_id: OperationId,
+        operation_data: bytes,
+    ) -> None:
+        if len(operation_data) > 255:
+            raise ValueError("operation data must be <= 255 bytes")
+        self.state_flag = state_flag
+        self.operation_id = operation_id
+        self.operation_data = operation_data
+
+
+# -----------------------------------------------------------------------------
+@Frame.subclass
+class PassThroughCommandFrame(PassThroughFrame, CommandFrame):
+    def __init__(
+        self,
+        ctype: CommandFrame.CommandType,
+        subunit_type: Frame.SubunitType,
+        subunit_id: int,
+        state_flag: PassThroughFrame.StateFlag,
+        operation_id: PassThroughFrame.OperationId,
+        operation_data: bytes,
+    ) -> None:
+        PassThroughFrame.__init__(self, state_flag, operation_id, operation_data)
+        CommandFrame.__init__(
+            self,
+            ctype,
+            subunit_type,
+            subunit_id,
+            Frame.OperationCode.PASS_THROUGH,
+            self.make_operands(),
+        )
+
+    def __str__(self):
+        return (
+            f"PassThroughCommandFrame(ctype={self.ctype.name}, "
+            f"subunit_type={self.subunit_type.name}, "
+            f"subunit_id=0x{self.subunit_id:02X}, "
+            f"state_flag={self.state_flag.name}, "
+            f"operation_id={self.operation_id.name}, "
+            f"operation_data={self.operation_data.hex()})"
+        )
+
+
+# -----------------------------------------------------------------------------
+@Frame.subclass
+class PassThroughResponseFrame(PassThroughFrame, ResponseFrame):
+    def __init__(
+        self,
+        response: ResponseFrame.ResponseCode,
+        subunit_type: Frame.SubunitType,
+        subunit_id: int,
+        state_flag: PassThroughFrame.StateFlag,
+        operation_id: PassThroughFrame.OperationId,
+        operation_data: bytes,
+    ) -> None:
+        PassThroughFrame.__init__(self, state_flag, operation_id, operation_data)
+        ResponseFrame.__init__(
+            self,
+            response,
+            subunit_type,
+            subunit_id,
+            Frame.OperationCode.PASS_THROUGH,
+            self.make_operands(),
+        )
+
+    def __str__(self):
+        return (
+            f"PassThroughResponseFrame(response={self.response.name}, "
+            f"subunit_type={self.subunit_type.name}, "
+            f"subunit_id=0x{self.subunit_id:02X}, "
+            f"state_flag={self.state_flag.name}, "
+            f"operation_id={self.operation_id.name}, "
+            f"operation_data={self.operation_data.hex()})"
+        )

bumble/avctp.py

@@ -0,0 +1,291 @@
+# Copyright 2021-2023 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+from __future__ import annotations
+from enum import IntEnum
+import logging
+import struct
+from typing import Callable, cast, Dict, Optional
+
+from bumble.colors import color
+from bumble import avc
+from bumble import l2cap
+
+# -----------------------------------------------------------------------------
+# Logging
+# -----------------------------------------------------------------------------
+logger = logging.getLogger(__name__)
+
+
+# -----------------------------------------------------------------------------
+# Constants
+# -----------------------------------------------------------------------------
+AVCTP_PSM = 0x0017
+AVCTP_BROWSING_PSM = 0x001B
+
+
+# -----------------------------------------------------------------------------
+class MessageAssembler:
+    Callback = Callable[[int, bool, bool, int, bytes], None]
+
+    transaction_label: int
+    pid: int
+    c_r: int
+    ipid: int
+    payload: bytes
+    number_of_packets: int
+    packets_received: int
+
+    def __init__(self, callback: Callback) -> None:
+        self.callback = callback
+        self.reset()
+
+    def reset(self) -> None:
+        self.packets_received = 0
+        self.transaction_label = -1
+        self.pid = -1
+        self.c_r = -1
+        self.ipid = -1
+        self.payload = b''
+        self.number_of_packets = 0
+        self.packet_count = 0
+
+    def on_pdu(self, pdu: bytes) -> None:
+        self.packets_received += 1
+
+        transaction_label = pdu[0] >> 4
+        packet_type = Protocol.PacketType((pdu[0] >> 2) & 3)
+        c_r = (pdu[0] >> 1) & 1
+        ipid = pdu[0] & 1
+
+        if c_r == 0 and ipid != 0:
+            logger.warning("invalid IPID in command frame")
+            self.reset()
+            return
+
+        pid_offset = 1
+        if packet_type in (Protocol.PacketType.SINGLE, Protocol.PacketType.START):
+            if self.transaction_label >= 0:
+                # We are already in a transaction
+                logger.warning("received START or SINGLE fragment while in transaction")
+                self.reset()
+                self.packets_received = 1
+
+            if packet_type == Protocol.PacketType.START:
+                self.number_of_packets = pdu[1]
+                pid_offset = 2
+
+        pid = struct.unpack_from(">H", pdu, pid_offset)[0]
+        self.payload += pdu[pid_offset + 2 :]
+
+        if packet_type in (Protocol.PacketType.CONTINUE, Protocol.PacketType.END):
+            if transaction_label != self.transaction_label:
+                logger.warning("transaction label does not match")
+                self.reset()
+                return
+
+            if pid != self.pid:
+                logger.warning("PID does not match")
+                self.reset()
+                return
+
+            if c_r != self.c_r:
+                logger.warning("C/R does not match")
+                self.reset()
+                return
+
+            if self.packets_received > self.number_of_packets:
+                logger.warning("too many fragments in transaction")
+                self.reset()
+                return
+
+            if packet_type == Protocol.PacketType.END:
+                if self.packets_received != self.number_of_packets:
+                    logger.warning("premature END")
+                    self.reset()
+                    return
+        else:
+            self.transaction_label = transaction_label
+            self.c_r = c_r
+            self.ipid = ipid
+            self.pid = pid
+
+        if packet_type in (Protocol.PacketType.SINGLE, Protocol.PacketType.END):
+            self.on_message_complete()
+
+    def on_message_complete(self):
+        try:
+            self.callback(
+                self.transaction_label,
+                self.c_r == 0,
+                self.ipid != 0,
+                self.pid,
+                self.payload,
+            )
+        except Exception as error:
+            logger.exception(color(f"!!! exception in callback: {error}", "red"))
+
+        self.reset()
+
+
+# -----------------------------------------------------------------------------
+class Protocol:
+    CommandHandler = Callable[[int, avc.CommandFrame], None]
+    command_handlers: Dict[int, CommandHandler]  # Command handlers, by PID
+    ResponseHandler = Callable[[int, Optional[avc.ResponseFrame]], None]
+    response_handlers: Dict[int, ResponseHandler]  # Response handlers, by PID
+    next_transaction_label: int
+    message_assembler: MessageAssembler
+
+    class PacketType(IntEnum):
+        SINGLE = 0b00
+        START = 0b01
+        CONTINUE = 0b10
+        END = 0b11
+
+    def __init__(self, l2cap_channel: l2cap.ClassicChannel) -> None:
+        self.command_handlers = {}
+        self.response_handlers = {}
+        self.l2cap_channel = l2cap_channel
+        self.message_assembler = MessageAssembler(self.on_message)
+
+        # Register to receive PDUs from the channel
+        l2cap_channel.sink = self.on_pdu
+        l2cap_channel.on("open", self.on_l2cap_channel_open)
+        l2cap_channel.on("close", self.on_l2cap_channel_close)
+
+    def on_l2cap_channel_open(self):
+        logger.debug(color("<<< AVCTP channel open", "magenta"))
+
+    def on_l2cap_channel_close(self):
+        logger.debug(color("<<< AVCTP channel closed", "magenta"))
+
+    def on_pdu(self, pdu: bytes) -> None:
+        self.message_assembler.on_pdu(pdu)
+
+    def on_message(
+        self,
+        transaction_label: int,
+        is_command: bool,
+        ipid: bool,
+        pid: int,
+        payload: bytes,
+    ) -> None:
+        logger.debug(
+            f"<<< AVCTP Message: pid={pid}, "
+            f"transaction_label={transaction_label}, "
+            f"is_command={is_command}, "
+            f"ipid={ipid}, "
+            f"payload={payload.hex()}"
+        )
+
+        # Check for invalid PID responses.
+        if ipid:
+            logger.debug(f"received IPID for PID={pid}")
+
+        # Find the appropriate handler.
+        if is_command:
+            if pid not in self.command_handlers:
+                logger.warning(f"no command handler for PID {pid}")
+                self.send_ipid(transaction_label, pid)
+                return
+
+            command_frame = cast(avc.CommandFrame, avc.Frame.from_bytes(payload))
+            self.command_handlers[pid](transaction_label, command_frame)
+        else:
+            if pid not in self.response_handlers:
+                logger.warning(f"no response handler for PID {pid}")
+                return
+
+            # By convention, for an ipid, send a None payload to the response handler.
+            if ipid:
+                response_frame = None
+            else:
+                response_frame = cast(avc.ResponseFrame, avc.Frame.from_bytes(payload))
+
+            self.response_handlers[pid](transaction_label, response_frame)
+
+    def send_message(
+        self,
+        transaction_label: int,
+        is_command: bool,
+        ipid: bool,
+        pid: int,
+        payload: bytes,
+    ):
+        # TODO: fragment large messages
+        packet_type = Protocol.PacketType.SINGLE
+        pdu = (
+            struct.pack(
+                ">BH",
+                transaction_label << 4
+                | packet_type << 2
+                | (0 if is_command else 1) << 1
+                | (1 if ipid else 0),
+                pid,
+            )
+            + payload
+        )
+        self.l2cap_channel.send_pdu(pdu)
+
+    def send_command(self, transaction_label: int, pid: int, payload: bytes) -> None:
+        logger.debug(
+            ">>> AVCTP command: "
+            f"transaction_label={transaction_label}, "
+            f"pid={pid}, "
+            f"payload={payload.hex()}"
+        )
+        self.send_message(transaction_label, True, False, pid, payload)
+
+    def send_response(self, transaction_label: int, pid: int, payload: bytes):
+        logger.debug(
+            ">>> AVCTP response: "
+            f"transaction_label={transaction_label}, "
+            f"pid={pid}, "
+            f"payload={payload.hex()}"
+        )
+        self.send_message(transaction_label, False, False, pid, payload)
+
+    def send_ipid(self, transaction_label: int, pid: int) -> None:
+        logger.debug(
+            ">>> AVCTP ipid: " f"transaction_label={transaction_label}, " f"pid={pid}"
+        )
+        self.send_message(transaction_label, False, True, pid, b'')
+
+    def register_command_handler(
+        self, pid: int, handler: Protocol.CommandHandler
+    ) -> None:
+        self.command_handlers[pid] = handler
+
+    def unregister_command_handler(
+        self, pid: int, handler: Protocol.CommandHandler
+    ) -> None:
+        if pid not in self.command_handlers or self.command_handlers[pid] != handler:
+            raise ValueError("command handler not registered")
+        del self.command_handlers[pid]
+
+    def register_response_handler(
+        self, pid: int, handler: Protocol.ResponseHandler
+    ) -> None:
+        self.response_handlers[pid] = handler
+
+    def unregister_response_handler(
+        self, pid: int, handler: Protocol.ResponseHandler
+    ) -> None:
+        if pid not in self.response_handlers or self.response_handlers[pid] != handler:
+            raise ValueError("response handler not registered")
+        del self.response_handlers[pid]

bumble/avdtp.py

@@ -241,7 +241,10 @@ async def find_avdtp_service_with_sdp_client(
         )
         if profile_descriptor_list:
             for profile_descriptor in profile_descriptor_list.value:
-                if len(profile_descriptor.value) >= 2:
+                if (
+                    profile_descriptor.type == sdp.DataElement.SEQUENCE
+                    and len(profile_descriptor.value) >= 2
+                ):
                     avdtp_version_major = profile_descriptor.value[1].value >> 8
                     avdtp_version_minor = profile_descriptor.value[1].value & 0xFF
                     return (avdtp_version_major, avdtp_version_minor)
@@ -511,7 +514,8 @@ class MessageAssembler:
         try:
             self.callback(self.transaction_label, message)
         except Exception as error:
-            logger.warning(color(f'!!! exception in callback: {error}'))
+            logger.exception(color(f'!!! exception in callback: {error}', 'red'))
+
         self.reset()
 
 

bumble/controller.py

@@ -57,6 +57,8 @@ from bumble.hci import (
     HCI_Encryption_Change_Event,
     HCI_Synchronous_Connection_Complete_Event,
     HCI_LE_Advertising_Report_Event,
+    HCI_LE_CIS_Established_Event,
+    HCI_LE_CIS_Request_Event,
     HCI_LE_Connection_Complete_Event,
     HCI_LE_Read_Remote_Features_Complete_Event,
     HCI_Number_Of_Completed_Packets_Event,
@@ -82,6 +84,15 @@ class DataObject:
     pass
 
 
+# -----------------------------------------------------------------------------
+@dataclasses.dataclass
+class CisLink:
+    handle: int
+    cis_id: int
+    cig_id: int
+    acl_connection: Optional[Connection] = None
+
+
 # -----------------------------------------------------------------------------
 @dataclasses.dataclass
 class Connection:
@@ -132,6 +143,8 @@ class Controller:
         self.classic_connections: Dict[
             Address, Connection
         ] = {}  # Connections in BR/EDR
+        self.central_cis_links: Dict[int, CisLink] = {}  # CIS links by handle
+        self.peripheral_cis_links: Dict[int, CisLink] = {}  # CIS links by handle
 
         self.hci_version = HCI_VERSION_BLUETOOTH_CORE_5_0
         self.hci_revision = 0
@@ -310,7 +323,7 @@ class Controller:
     ############################################################
     # Link connections
     ############################################################
-    def allocate_connection_handle(self):
+    def allocate_connection_handle(self) -> int:
         handle = 0
         max_handle = 0
         for connection in itertools.chain(
@@ -322,6 +335,13 @@ class Controller:
             if connection.handle == handle:
                 # Already used, continue searching after the current max
                 handle = max_handle + 1
+        for cis_handle in itertools.chain(
+            self.central_cis_links.keys(), self.peripheral_cis_links.keys()
+        ):
+            max_handle = max(max_handle, cis_handle)
+            if cis_handle == handle:
+                # Already used, continue searching after the current max
+                handle = max_handle + 1
         return handle
 
     def find_le_connection_by_address(self, address):
@@ -549,6 +569,104 @@ class Controller:
         )
         self.send_hci_packet(HCI_LE_Advertising_Report_Event([report]))
 
+    def on_link_cis_request(
+        self, central_address: Address, cig_id: int, cis_id: int
+    ) -> None:
+        '''
+        Called when an incoming CIS request occurs from a central on the link
+        '''
+
+        connection = self.peripheral_connections.get(central_address)
+        assert connection
+
+        pending_cis_link = CisLink(
+            handle=self.allocate_connection_handle(),
+            cis_id=cis_id,
+            cig_id=cig_id,
+            acl_connection=connection,
+        )
+        self.peripheral_cis_links[pending_cis_link.handle] = pending_cis_link
+
+        self.send_hci_packet(
+            HCI_LE_CIS_Request_Event(
+                acl_connection_handle=connection.handle,
+                cis_connection_handle=pending_cis_link.handle,
+                cig_id=cig_id,
+                cis_id=cis_id,
+            )
+        )
+
+    def on_link_cis_established(self, cig_id: int, cis_id: int) -> None:
+        '''
+        Called when an incoming CIS established.
+        '''
+
+        cis_link = next(
+            cis_link
+            for cis_link in itertools.chain(
+                self.central_cis_links.values(), self.peripheral_cis_links.values()
+            )
+            if cis_link.cis_id == cis_id and cis_link.cig_id == cig_id
+        )
+
+        self.send_hci_packet(
+            HCI_LE_CIS_Established_Event(
+                status=HCI_SUCCESS,
+                connection_handle=cis_link.handle,
+                # CIS parameters are ignored.
+                cig_sync_delay=0,
+                cis_sync_delay=0,
+                transport_latency_c_to_p=0,
+                transport_latency_p_to_c=0,
+                phy_c_to_p=0,
+                phy_p_to_c=0,
+                nse=0,
+                bn_c_to_p=0,
+                bn_p_to_c=0,
+                ft_c_to_p=0,
+                ft_p_to_c=0,
+                max_pdu_c_to_p=0,
+                max_pdu_p_to_c=0,
+                iso_interval=0,
+            )
+        )
+
+    def on_link_cis_disconnected(self, cig_id: int, cis_id: int) -> None:
+        '''
+        Called when a CIS disconnected.
+        '''
+
+        if cis_link := next(
+            (
+                cis_link
+                for cis_link in self.peripheral_cis_links.values()
+                if cis_link.cis_id == cis_id and cis_link.cig_id == cig_id
+            ),
+            None,
+        ):
+            # Remove peripheral CIS on disconnection.
+            self.peripheral_cis_links.pop(cis_link.handle)
+        elif cis_link := next(
+            (
+                cis_link
+                for cis_link in self.central_cis_links.values()
+                if cis_link.cis_id == cis_id and cis_link.cig_id == cig_id
+            ),
+            None,
+        ):
+            # Keep central CIS on disconnection. They should be removed by HCI_LE_Remove_CIG_Command.
+            cis_link.acl_connection = None
+        else:
+            return
+
+        self.send_hci_packet(
+            HCI_Disconnection_Complete_Event(
+                status=HCI_SUCCESS,
+                connection_handle=cis_link.handle,
+                reason=HCI_REMOTE_USER_TERMINATED_CONNECTION_ERROR,
+            )
+        )
+
     ############################################################
     # Classic link connections
     ############################################################
@@ -769,6 +887,17 @@ class Controller:
             else:
                 # Remove the connection
                 del self.classic_connections[connection.peer_address]
+        elif cis_link := (
+            self.central_cis_links.get(handle) or self.peripheral_cis_links.get(handle)
+        ):
+            if self.link:
+                self.link.disconnect_cis(
+                    initiator_controller=self,
+                    peer_address=cis_link.acl_connection.peer_address,
+                    cig_id=cis_link.cig_id,
+                    cis_id=cis_link.cis_id,
+                )
+            # Spec requires handle to be kept after disconnection.
 
     def on_hci_accept_connection_request_command(self, command):
         '''
@@ -1399,6 +1528,107 @@ class Controller:
         '''
         return struct.pack('<BBB', HCI_SUCCESS, 0, 0)
 
+    def on_hci_le_set_cig_parameters_command(self, command):
+        '''
+        See Bluetooth spec Vol 4, Part E - 7.8.97 LE Set CIG Parameter Command
+        '''
+
+        # Remove old CIG implicitly.
+        for handle, cis_link in self.central_cis_links.items():
+            if cis_link.cig_id == command.cig_id:
+                self.central_cis_links.pop(handle)
+
+        handles = []
+        for cis_id in command.cis_id:
+            handle = self.allocate_connection_handle()
+            handles.append(handle)
+            self.central_cis_links[handle] = CisLink(
+                cis_id=cis_id,
+                cig_id=command.cig_id,
+                handle=handle,
+            )
+        return struct.pack(
+            '<BBB', HCI_SUCCESS, command.cig_id, len(handles)
+        ) + b''.join([struct.pack('<H', handle) for handle in handles])
+
+    def on_hci_le_create_cis_command(self, command):
+        '''
+        See Bluetooth spec Vol 4, Part E - 7.8.99 LE Create CIS Command
+        '''
+        if not self.link:
+            return
+
+        for cis_handle, acl_handle in zip(
+            command.cis_connection_handle, command.acl_connection_handle
+        ):
+            if not (connection := self.find_connection_by_handle(acl_handle)):
+                logger.error(f'Cannot find connection with handle={acl_handle}')
+                return bytes([HCI_INVALID_HCI_COMMAND_PARAMETERS_ERROR])
+
+            if not (cis_link := self.central_cis_links.get(cis_handle)):
+                logger.error(f'Cannot find CIS with handle={cis_handle}')
+                return bytes([HCI_INVALID_HCI_COMMAND_PARAMETERS_ERROR])
+
+            cis_link.acl_connection = connection
+
+            self.link.create_cis(
+                self,
+                peripheral_address=connection.peer_address,
+                cig_id=cis_link.cig_id,
+                cis_id=cis_link.cis_id,
+            )
+
+        self.send_hci_packet(
+            HCI_Command_Status_Event(
+                status=HCI_COMMAND_STATUS_PENDING,
+                num_hci_command_packets=1,
+                command_opcode=command.op_code,
+            )
+        )
+
+    def on_hci_le_remove_cig_command(self, command):
+        '''
+        See Bluetooth spec Vol 4, Part E - 7.8.100 LE Remove CIG Command
+        '''
+
+        status = HCI_UNKNOWN_CONNECTION_IDENTIFIER_ERROR
+
+        for cis_handle, cis_link in self.central_cis_links.items():
+            if cis_link.cig_id == command.cig_id:
+                self.central_cis_links.pop(cis_handle)
+                status = HCI_SUCCESS
+
+        return struct.pack('<BH', status, command.cig_id)
+
+    def on_hci_le_accept_cis_request_command(self, command):
+        '''
+        See Bluetooth spec Vol 4, Part E - 7.8.101 LE Accept CIS Request Command
+        '''
+        if not self.link:
+            return
+
+        if not (
+            pending_cis_link := self.peripheral_cis_links.get(command.connection_handle)
+        ):
+            logger.error(f'Cannot find CIS with handle={command.connection_handle}')
+            return bytes([HCI_INVALID_HCI_COMMAND_PARAMETERS_ERROR])
+
+        assert pending_cis_link.acl_connection
+        self.link.accept_cis(
+            peripheral_controller=self,
+            central_address=pending_cis_link.acl_connection.peer_address,
+            cig_id=pending_cis_link.cig_id,
+            cis_id=pending_cis_link.cis_id,
+        )
+
+        self.send_hci_packet(
+            HCI_Command_Status_Event(
+                status=HCI_COMMAND_STATUS_PENDING,
+                num_hci_command_packets=1,
+                command_opcode=command.op_code,
+            )
+        )
+
     def on_hci_le_setup_iso_data_path_command(self, command):
         '''
         See Bluetooth spec Vol 4, Part E - 7.8.109 LE Setup ISO Data Path Command

bumble/core.py

@@ -97,12 +97,16 @@ class BaseError(Exception):
             namespace = f'{self.error_namespace}/'
         else:
             namespace = ''
-        error_text = {
-            (True, True): f'{self.error_name} [0x{self.error_code:X}]',
-            (True, False): self.error_name,
-            (False, True): f'0x{self.error_code:X}',
-            (False, False): '',
-        }[(self.error_name != '', self.error_code is not None)]
+        have_name = self.error_name != ''
+        have_code = self.error_code is not None
+        if have_name and have_code:
+            error_text = f'{self.error_name} [0x{self.error_code:X}]'
+        elif have_name and not have_code:
+            error_text = self.error_name
+        elif not have_name and have_code:
+            error_text = f'0x{self.error_code:X}'
+        else:
+            error_text = '<unspecified>'
 
         return f'{type(self).__name__}({namespace}{error_text})'
 
@@ -319,7 +323,7 @@ BT_HIDP_PROTOCOL_ID                     = UUID.from_16_bits(0x0011, 'HIDP')
 BT_HARDCOPY_CONTROL_CHANNEL_PROTOCOL_ID = UUID.from_16_bits(0x0012, 'HardcopyControlChannel')
 BT_HARDCOPY_DATA_CHANNEL_PROTOCOL_ID    = UUID.from_16_bits(0x0014, 'HardcopyDataChannel')
 BT_HARDCOPY_NOTIFICATION_PROTOCOL_ID    = UUID.from_16_bits(0x0016, 'HardcopyNotification')
-BT_AVTCP_PROTOCOL_ID                    = UUID.from_16_bits(0x0017, 'AVCTP')
+BT_AVCTP_PROTOCOL_ID                    = UUID.from_16_bits(0x0017, 'AVCTP')
 BT_AVDTP_PROTOCOL_ID                    = UUID.from_16_bits(0x0019, 'AVDTP')
 BT_CMTP_PROTOCOL_ID                     = UUID.from_16_bits(0x001B, 'CMTP')
 BT_MCAP_CONTROL_CHANNEL_PROTOCOL_ID     = UUID.from_16_bits(0x001E, 'MCAPControlChannel')
@@ -821,8 +825,8 @@ class AdvertisingData:
             ad_structures = []
         self.ad_structures = ad_structures[:]
 
-    @staticmethod
-    def from_bytes(data):
+    @classmethod
+    def from_bytes(cls, data: bytes) -> AdvertisingData:
         instance = AdvertisingData()
         instance.append(data)
         return instance
@@ -978,7 +982,7 @@ class AdvertisingData:
 
         return ad_data
 
-    def append(self, data):
+    def append(self, data: bytes) -> None:
         offset = 0
         while offset + 1 < len(data):
             length = data[offset]

bumble/device.py

@@ -21,6 +21,7 @@ import functools
 import json
 import asyncio
 import logging
+import secrets
 from contextlib import asynccontextmanager, AsyncExitStack, closing
 from dataclasses import dataclass
 from collections.abc import Iterable
@@ -34,7 +35,6 @@ from typing import (
     Tuple,
     Type,
     TypeVar,
-    Set,
     Union,
     cast,
     overload,
@@ -148,6 +148,7 @@ from .hci import (
     HCI_Write_Secure_Connections_Host_Support_Command,
     HCI_Write_Simple_Pairing_Mode_Command,
     OwnAddressType,
+    LeFeature,
     LeFeatureMask,
     phy_list_to_bits,
 )
@@ -242,16 +243,40 @@ DEVICE_DEFAULT_L2CAP_COC_MAX_CREDITS          = l2cap.L2CAP_LE_CREDIT_BASED_CONN
 
 
 # -----------------------------------------------------------------------------
+@dataclass
 class Advertisement:
+    # Attributes
     address: Address
-
-    TX_POWER_NOT_AVAILABLE = (
+    rssi: int = HCI_LE_Extended_Advertising_Report_Event.RSSI_NOT_AVAILABLE
+    is_legacy: bool = False
+    is_anonymous: bool = False
+    is_connectable: bool = False
+    is_directed: bool = False
+    is_scannable: bool = False
+    is_scan_response: bool = False
+    is_complete: bool = True
+    is_truncated: bool = False
+    primary_phy: int = 0
+    secondary_phy: int = 0
+    tx_power: int = (
         HCI_LE_Extended_Advertising_Report_Event.TX_POWER_INFORMATION_NOT_AVAILABLE
     )
-    RSSI_NOT_AVAILABLE = HCI_LE_Extended_Advertising_Report_Event.RSSI_NOT_AVAILABLE
+    sid: int = 0
+    data_bytes: bytes = b''
+
+    # Constants
+    TX_POWER_NOT_AVAILABLE: ClassVar[
+        int
+    ] = HCI_LE_Extended_Advertising_Report_Event.TX_POWER_INFORMATION_NOT_AVAILABLE
+    RSSI_NOT_AVAILABLE: ClassVar[
+        int
+    ] = HCI_LE_Extended_Advertising_Report_Event.RSSI_NOT_AVAILABLE
+
+    def __post_init__(self) -> None:
+        self.data = AdvertisingData.from_bytes(self.data_bytes)
 
     @classmethod
-    def from_advertising_report(cls, report):
+    def from_advertising_report(cls, report) -> Optional[Advertisement]:
         if isinstance(report, HCI_LE_Advertising_Report_Event.Report):
             return LegacyAdvertisement.from_advertising_report(report)
 
@@ -260,41 +285,6 @@ class Advertisement:
 
         return None
 
-    # pylint: disable=line-too-long
-    def __init__(
-        self,
-        address,
-        rssi=HCI_LE_Extended_Advertising_Report_Event.RSSI_NOT_AVAILABLE,
-        is_legacy=False,
-        is_anonymous=False,
-        is_connectable=False,
-        is_directed=False,
-        is_scannable=False,
-        is_scan_response=False,
-        is_complete=True,
-        is_truncated=False,
-        primary_phy=0,
-        secondary_phy=0,
-        tx_power=HCI_LE_Extended_Advertising_Report_Event.TX_POWER_INFORMATION_NOT_AVAILABLE,
-        sid=0,
-        data=b'',
-    ):
-        self.address = address
-        self.rssi = rssi
-        self.is_legacy = is_legacy
-        self.is_anonymous = is_anonymous
-        self.is_connectable = is_connectable
-        self.is_directed = is_directed
-        self.is_scannable = is_scannable
-        self.is_scan_response = is_scan_response
-        self.is_complete = is_complete
-        self.is_truncated = is_truncated
-        self.primary_phy = primary_phy
-        self.secondary_phy = secondary_phy
-        self.tx_power = tx_power
-        self.sid = sid
-        self.data = AdvertisingData.from_bytes(data)
-
 
 # -----------------------------------------------------------------------------
 class LegacyAdvertisement(Advertisement):
@@ -318,7 +308,7 @@ class LegacyAdvertisement(Advertisement):
             ),
             is_scan_response=report.event_type
             == HCI_LE_Advertising_Report_Event.SCAN_RSP,
-            data=report.data,
+            data_bytes=report.data,
         )
 
 
@@ -343,7 +333,7 @@ class ExtendedAdvertisement(Advertisement):
             secondary_phy    = report.secondary_phy,
             tx_power         = report.tx_power,
             sid              = report.advertising_sid,
-            data             = report.data
+            data_bytes       = report.data
         )
         # fmt: on
 
@@ -404,7 +394,7 @@ class AdvertisingType(IntEnum):
     # fmt: on
 
     @property
-    def has_data(self):
+    def has_data(self) -> bool:
         return self in (
             AdvertisingType.UNDIRECTED_CONNECTABLE_SCANNABLE,
             AdvertisingType.UNDIRECTED_SCANNABLE,
@@ -412,7 +402,7 @@ class AdvertisingType(IntEnum):
         )
 
     @property
-    def is_connectable(self):
+    def is_connectable(self) -> bool:
         return self in (
             AdvertisingType.UNDIRECTED_CONNECTABLE_SCANNABLE,
             AdvertisingType.DIRECTED_CONNECTABLE_HIGH_DUTY,
@@ -420,14 +410,14 @@ class AdvertisingType(IntEnum):
         )
 
     @property
-    def is_scannable(self):
+    def is_scannable(self) -> bool:
         return self in (
             AdvertisingType.UNDIRECTED_CONNECTABLE_SCANNABLE,
             AdvertisingType.UNDIRECTED_SCANNABLE,
         )
 
     @property
-    def is_directed(self):
+    def is_directed(self) -> bool:
         return self in (
             AdvertisingType.DIRECTED_CONNECTABLE_HIGH_DUTY,
             AdvertisingType.DIRECTED_CONNECTABLE_LOW_DUTY,
@@ -1005,12 +995,15 @@ class DeviceConfiguration:
         irk = config.get('irk')
         if irk:
             self.irk = bytes.fromhex(irk)
-        else:
+        elif self.address != Address(DEVICE_DEFAULT_ADDRESS):
             # Construct an IRK from the address bytes
             # NOTE: this is not secure, but will always give the same IRK for the same
             # address
             address_bytes = bytes(self.address)
             self.irk = (address_bytes * 3)[:16]
+        else:
+            # Fallback - when both IRK and address are not set, randomly generate an IRK.
+            self.irk = secrets.token_bytes(16)
 
         # Load advertising data
         advertising_data = config.get('advertising_data')
@@ -1546,7 +1539,7 @@ class Device(CompositeEventEmitter):
             if self.cis_enabled:
                 await self.send_command(
                     HCI_LE_Set_Host_Feature_Command(
-                        bit_number=LeFeatureMask.CONNECTED_ISOCHRONOUS_STREAM,
+                        bit_number=LeFeature.CONNECTED_ISOCHRONOUS_STREAM,
                         bit_value=1,
                     )
                 )
@@ -1592,6 +1585,16 @@ class Device(CompositeEventEmitter):
         if self.address_resolution_offload:
             await self.send_command(HCI_LE_Clear_Resolving_List_Command())
 
+            # Add an empty entry for non-directed address generation.
+            await self.send_command(
+                HCI_LE_Add_Device_To_Resolving_List_Command(
+                    peer_identity_address_type=Address.ANY.address_type,
+                    peer_identity_address=Address.ANY,
+                    peer_irk=bytes(16),
+                    local_irk=self.irk,
+                )
+            )
+
             for irk, address in resolving_keys:
                 await self.send_command(
                     HCI_LE_Add_Device_To_Resolving_List_Command(
@@ -1692,8 +1695,8 @@ class Device(CompositeEventEmitter):
             peer_address = target
             peer_address_type = target.address_type
         else:
-            peer_address = Address('00:00:00:00:00:00')
-            peer_address_type = Address.PUBLIC_DEVICE_ADDRESS
+            peer_address = Address.ANY
+            peer_address_type = Address.ANY.address_type
 
         # Set the advertising parameters
         await self.send_command(
@@ -3077,34 +3080,30 @@ class Device(CompositeEventEmitter):
                 cig_id=cig_id,
             )
 
-        result = await self.send_command(
-            HCI_LE_Create_CIS_Command(
-                cis_connection_handle=[p[0] for p in cis_acl_pairs],
-                acl_connection_handle=[p[1] for p in cis_acl_pairs],
-            ),
-        )
-        if result.status != HCI_COMMAND_STATUS_PENDING:
-            logger.warning(
-                'HCI_LE_Create_CIS_Command failed: '
-                f'{HCI_Constant.error_name(result.status)}'
-            )
-            raise HCI_StatusError(result)
-
-        pending_cis_establishments: Dict[int, asyncio.Future[CisLink]] = {}
-        for cis_handle, _ in cis_acl_pairs:
-            pending_cis_establishments[
-                cis_handle
-            ] = asyncio.get_running_loop().create_future()
-
         with closing(EventWatcher()) as watcher:
+            pending_cis_establishments = {
+                cis_handle: asyncio.get_running_loop().create_future()
+                for cis_handle, _ in cis_acl_pairs
+            }
 
             @watcher.on(self, 'cis_establishment')
             def on_cis_establishment(cis_link: CisLink) -> None:
-                if pending_future := pending_cis_establishments.get(
-                    cis_link.handle, None
-                ):
+                if pending_future := pending_cis_establishments.get(cis_link.handle):
                     pending_future.set_result(cis_link)
 
+            result = await self.send_command(
+                HCI_LE_Create_CIS_Command(
+                    cis_connection_handle=[p[0] for p in cis_acl_pairs],
+                    acl_connection_handle=[p[1] for p in cis_acl_pairs],
+                ),
+            )
+            if result.status != HCI_COMMAND_STATUS_PENDING:
+                logger.warning(
+                    'HCI_LE_Create_CIS_Command failed: '
+                    f'{HCI_Constant.error_name(result.status)}'
+                )
+                raise HCI_StatusError(result)
+
             return await asyncio.gather(*pending_cis_establishments.values())
 
     # [LE only]
@@ -3752,7 +3751,7 @@ class Device(CompositeEventEmitter):
     @host_event_handler
     @experimental('Only for testing')
     def on_sco_packet(self, sco_handle: int, packet: HCI_SynchronousDataPacket) -> None:
-        if sco_link := self.sco_links.get(sco_handle, None):
+        if sco_link := self.sco_links.get(sco_handle):
             sco_link.emit('pdu', packet)
 
     # [LE only]
@@ -3832,7 +3831,7 @@ class Device(CompositeEventEmitter):
     @experimental('Only for testing')
     def on_cis_establishment_failure(self, cis_handle: int, status: int) -> None:
         logger.debug(f'*** CIS Establishment Failure: cis=[0x{cis_handle:04X}] ***')
-        if cis_link := self.cis_links.pop(cis_handle, None):
+        if cis_link := self.cis_links.pop(cis_handle):
             cis_link.emit('establishment_failure')
         self.emit('cis_establishment_failure', cis_handle, status)
 
@@ -3840,7 +3839,7 @@ class Device(CompositeEventEmitter):
     @host_event_handler
     @experimental('Only for testing')
     def on_iso_packet(self, handle: int, packet: HCI_IsoDataPacket) -> None:
-        if cis_link := self.cis_links.get(handle, None):
+        if cis_link := self.cis_links.get(handle):
             cis_link.emit('pdu', packet)
 
     @host_event_handler

bumble/hci.py

@@ -1360,51 +1360,97 @@ HCI_SUPPORTED_COMMANDS_FLAGS = (
 
 # LE Supported Features
 # See Bluetooth spec @ Vol 6, Part B, 4.6 FEATURE SUPPORT
+class LeFeature(enum.IntEnum):
+    LE_ENCRYPTION                                  = 0
+    CONNECTION_PARAMETERS_REQUEST_PROCEDURE        = 1
+    EXTENDED_REJECT_INDICATION                     = 2
+    PERIPHERAL_INITIATED_FEATURE_EXCHANGE          = 3
+    LE_PING                                        = 4
+    LE_DATA_PACKET_LENGTH_EXTENSION                = 5
+    LL_PRIVACY                                     = 6
+    EXTENDED_SCANNER_FILTER_POLICIES               = 7
+    LE_2M_PHY                                      = 8
+    STABLE_MODULATION_INDEX_TRANSMITTER            = 9
+    STABLE_MODULATION_INDEX_RECEIVER               = 10
+    LE_CODED_PHY                                   = 11
+    LE_EXTENDED_ADVERTISING                        = 12
+    LE_PERIODIC_ADVERTISING                        = 13
+    CHANNEL_SELECTION_ALGORITHM_2                  = 14
+    LE_POWER_CLASS_1                               = 15
+    MINIMUM_NUMBER_OF_USED_CHANNELS_PROCEDURE      = 16
+    CONNECTION_CTE_REQUEST                         = 17
+    CONNECTION_CTE_RESPONSE                        = 18
+    CONNECTIONLESS_CTE_TRANSMITTER                 = 19
+    CONNECTIONLESS_CTR_RECEIVER                    = 20
+    ANTENNA_SWITCHING_DURING_CTE_TRANSMISSION      = 21
+    ANTENNA_SWITCHING_DURING_CTE_RECEPTION         = 22
+    RECEIVING_CONSTANT_TONE_EXTENSIONS             = 23
+    PERIODIC_ADVERTISING_SYNC_TRANSFER_SENDER      = 24
+    PERIODIC_ADVERTISING_SYNC_TRANSFER_RECIPIENT   = 25
+    SLEEP_CLOCK_ACCURACY_UPDATES                   = 26
+    REMOTE_PUBLIC_KEY_VALIDATION                   = 27
+    CONNECTED_ISOCHRONOUS_STREAM_CENTRAL           = 28
+    CONNECTED_ISOCHRONOUS_STREAM_PERIPHERAL        = 29
+    ISOCHRONOUS_BROADCASTER                        = 30
+    SYNCHRONIZED_RECEIVER                          = 31
+    CONNECTED_ISOCHRONOUS_STREAM                   = 32
+    LE_POWER_CONTROL_REQUEST                       = 33
+    LE_POWER_CONTROL_REQUEST_DUP                   = 34
+    LE_PATH_LOSS_MONITORING                        = 35
+    PERIODIC_ADVERTISING_ADI_SUPPORT               = 36
+    CONNECTION_SUBRATING                           = 37
+    CONNECTION_SUBRATING_HOST_SUPPORT              = 38
+    CHANNEL_CLASSIFICATION                         = 39
+    ADVERTISING_CODING_SELECTION                   = 40
+    ADVERTISING_CODING_SELECTION_HOST_SUPPORT      = 41
+    PERIODIC_ADVERTISING_WITH_RESPONSES_ADVERTISER = 43
+    PERIODIC_ADVERTISING_WITH_RESPONSES_SCANNER    = 44
+
 class LeFeatureMask(enum.IntFlag):
-    LE_ENCRYPTION                                  = 1 << 0
-    CONNECTION_PARAMETERS_REQUEST_PROCEDURE        = 1 << 1
-    EXTENDED_REJECT_INDICATION                     = 1 << 2
-    PERIPHERAL_INITIATED_FEATURE_EXCHANGE          = 1 << 3
-    LE_PING                                        = 1 << 4
-    LE_DATA_PACKET_LENGTH_EXTENSION                = 1 << 5
-    LL_PRIVACY                                     = 1 << 6
-    EXTENDED_SCANNER_FILTER_POLICIES               = 1 << 7
-    LE_2M_PHY                                      = 1 << 8
-    STABLE_MODULATION_INDEX_TRANSMITTER            = 1 << 9
-    STABLE_MODULATION_INDEX_RECEIVER               = 1 << 10
-    LE_CODED_PHY                                   = 1 << 11
-    LE_EXTENDED_ADVERTISING                        = 1 << 12
-    LE_PERIODIC_ADVERTISING                        = 1 << 13
-    CHANNEL_SELECTION_ALGORITHM_2                  = 1 << 14
-    LE_POWER_CLASS_1                               = 1 << 15
-    MINIMUM_NUMBER_OF_USED_CHANNELS_PROCEDURE      = 1 << 16
-    CONNECTION_CTE_REQUEST                         = 1 << 17
-    CONNECTION_CTE_RESPONSE                        = 1 << 18
-    CONNECTIONLESS_CTE_TRANSMITTER                 = 1 << 19
-    CONNECTIONLESS_CTR_RECEIVER                    = 1 << 20
-    ANTENNA_SWITCHING_DURING_CTE_TRANSMISSION      = 1 << 21
-    ANTENNA_SWITCHING_DURING_CTE_RECEPTION         = 1 << 22
-    RECEIVING_CONSTANT_TONE_EXTENSIONS             = 1 << 23
-    PERIODIC_ADVERTISING_SYNC_TRANSFER_SENDER      = 1 << 24
-    PERIODIC_ADVERTISING_SYNC_TRANSFER_RECIPIENT   = 1 << 25
-    SLEEP_CLOCK_ACCURACY_UPDATES                   = 1 << 26
-    REMOTE_PUBLIC_KEY_VALIDATION                   = 1 << 27
-    CONNECTED_ISOCHRONOUS_STREAM_CENTRAL           = 1 << 28
-    CONNECTED_ISOCHRONOUS_STREAM_PERIPHERAL        = 1 << 29
-    ISOCHRONOUS_BROADCASTER                        = 1 << 30
-    SYNCHRONIZED_RECEIVER                          = 1 << 31
-    CONNECTED_ISOCHRONOUS_STREAM                   = 1 << 32
-    LE_POWER_CONTROL_REQUEST                       = 1 << 33
-    LE_POWER_CONTROL_REQUEST_DUP                   = 1 << 34
-    LE_PATH_LOSS_MONITORING                        = 1 << 35
-    PERIODIC_ADVERTISING_ADI_SUPPORT               = 1 << 36
-    CONNECTION_SUBRATING                           = 1 << 37
-    CONNECTION_SUBRATING_HOST_SUPPORT              = 1 << 38
-    CHANNEL_CLASSIFICATION                         = 1 << 39
-    ADVERTISING_CODING_SELECTION                   = 1 << 40
-    ADVERTISING_CODING_SELECTION_HOST_SUPPORT      = 1 << 41
-    PERIODIC_ADVERTISING_WITH_RESPONSES_ADVERTISER = 1 << 43
-    PERIODIC_ADVERTISING_WITH_RESPONSES_SCANNER    = 1 << 44
+    LE_ENCRYPTION                                  = 1 << LeFeature.LE_ENCRYPTION
+    CONNECTION_PARAMETERS_REQUEST_PROCEDURE        = 1 << LeFeature.CONNECTION_PARAMETERS_REQUEST_PROCEDURE
+    EXTENDED_REJECT_INDICATION                     = 1 << LeFeature.EXTENDED_REJECT_INDICATION
+    PERIPHERAL_INITIATED_FEATURE_EXCHANGE          = 1 << LeFeature.PERIPHERAL_INITIATED_FEATURE_EXCHANGE
+    LE_PING                                        = 1 << LeFeature.LE_PING
+    LE_DATA_PACKET_LENGTH_EXTENSION                = 1 << LeFeature.LE_DATA_PACKET_LENGTH_EXTENSION
+    LL_PRIVACY                                     = 1 << LeFeature.LL_PRIVACY
+    EXTENDED_SCANNER_FILTER_POLICIES               = 1 << LeFeature.EXTENDED_SCANNER_FILTER_POLICIES
+    LE_2M_PHY                                      = 1 << LeFeature.LE_2M_PHY
+    STABLE_MODULATION_INDEX_TRANSMITTER            = 1 << LeFeature.STABLE_MODULATION_INDEX_TRANSMITTER
+    STABLE_MODULATION_INDEX_RECEIVER               = 1 << LeFeature.STABLE_MODULATION_INDEX_RECEIVER
+    LE_CODED_PHY                                   = 1 << LeFeature.LE_CODED_PHY
+    LE_EXTENDED_ADVERTISING                        = 1 << LeFeature.LE_EXTENDED_ADVERTISING
+    LE_PERIODIC_ADVERTISING                        = 1 << LeFeature.LE_PERIODIC_ADVERTISING
+    CHANNEL_SELECTION_ALGORITHM_2                  = 1 << LeFeature.CHANNEL_SELECTION_ALGORITHM_2
+    LE_POWER_CLASS_1                               = 1 << LeFeature.LE_POWER_CLASS_1
+    MINIMUM_NUMBER_OF_USED_CHANNELS_PROCEDURE      = 1 << LeFeature.MINIMUM_NUMBER_OF_USED_CHANNELS_PROCEDURE
+    CONNECTION_CTE_REQUEST                         = 1 << LeFeature.CONNECTION_CTE_REQUEST
+    CONNECTION_CTE_RESPONSE                        = 1 << LeFeature.CONNECTION_CTE_RESPONSE
+    CONNECTIONLESS_CTE_TRANSMITTER                 = 1 << LeFeature.CONNECTIONLESS_CTE_TRANSMITTER
+    CONNECTIONLESS_CTR_RECEIVER                    = 1 << LeFeature.CONNECTIONLESS_CTR_RECEIVER
+    ANTENNA_SWITCHING_DURING_CTE_TRANSMISSION      = 1 << LeFeature.ANTENNA_SWITCHING_DURING_CTE_TRANSMISSION
+    ANTENNA_SWITCHING_DURING_CTE_RECEPTION         = 1 << LeFeature.ANTENNA_SWITCHING_DURING_CTE_RECEPTION
+    RECEIVING_CONSTANT_TONE_EXTENSIONS             = 1 << LeFeature.RECEIVING_CONSTANT_TONE_EXTENSIONS
+    PERIODIC_ADVERTISING_SYNC_TRANSFER_SENDER      = 1 << LeFeature.PERIODIC_ADVERTISING_SYNC_TRANSFER_SENDER
+    PERIODIC_ADVERTISING_SYNC_TRANSFER_RECIPIENT   = 1 << LeFeature.PERIODIC_ADVERTISING_SYNC_TRANSFER_RECIPIENT
+    SLEEP_CLOCK_ACCURACY_UPDATES                   = 1 << LeFeature.SLEEP_CLOCK_ACCURACY_UPDATES
+    REMOTE_PUBLIC_KEY_VALIDATION                   = 1 << LeFeature.REMOTE_PUBLIC_KEY_VALIDATION
+    CONNECTED_ISOCHRONOUS_STREAM_CENTRAL           = 1 << LeFeature.CONNECTED_ISOCHRONOUS_STREAM_CENTRAL
+    CONNECTED_ISOCHRONOUS_STREAM_PERIPHERAL        = 1 << LeFeature.CONNECTED_ISOCHRONOUS_STREAM_PERIPHERAL
+    ISOCHRONOUS_BROADCASTER                        = 1 << LeFeature.ISOCHRONOUS_BROADCASTER
+    SYNCHRONIZED_RECEIVER                          = 1 << LeFeature.SYNCHRONIZED_RECEIVER
+    CONNECTED_ISOCHRONOUS_STREAM                   = 1 << LeFeature.CONNECTED_ISOCHRONOUS_STREAM
+    LE_POWER_CONTROL_REQUEST                       = 1 << LeFeature.LE_POWER_CONTROL_REQUEST
+    LE_POWER_CONTROL_REQUEST_DUP                   = 1 << LeFeature.LE_POWER_CONTROL_REQUEST_DUP
+    LE_PATH_LOSS_MONITORING                        = 1 << LeFeature.LE_PATH_LOSS_MONITORING
+    PERIODIC_ADVERTISING_ADI_SUPPORT               = 1 << LeFeature.PERIODIC_ADVERTISING_ADI_SUPPORT
+    CONNECTION_SUBRATING                           = 1 << LeFeature.CONNECTION_SUBRATING
+    CONNECTION_SUBRATING_HOST_SUPPORT              = 1 << LeFeature.CONNECTION_SUBRATING_HOST_SUPPORT
+    CHANNEL_CLASSIFICATION                         = 1 << LeFeature.CHANNEL_CLASSIFICATION
+    ADVERTISING_CODING_SELECTION                   = 1 << LeFeature.ADVERTISING_CODING_SELECTION
+    ADVERTISING_CODING_SELECTION_HOST_SUPPORT      = 1 << LeFeature.ADVERTISING_CODING_SELECTION_HOST_SUPPORT
+    PERIODIC_ADVERTISING_WITH_RESPONSES_ADVERTISER = 1 << LeFeature.PERIODIC_ADVERTISING_WITH_RESPONSES_ADVERTISER
+    PERIODIC_ADVERTISING_WITH_RESPONSES_SCANNER    = 1 << LeFeature.PERIODIC_ADVERTISING_WITH_RESPONSES_SCANNER
 
 
 # fmt: on
@@ -4859,7 +4905,8 @@ class HCI_Extended_Event(HCI_Event):
             HCI_Object.init_from_bytes(self, parameters, 1, fields)
         return self
 
-    def __init__(self, subevent_code, parameters, **kwargs):
+    def __init__(self, subevent_code=None, parameters=None, **kwargs):
+        assert subevent_code is not None
         self.subevent_code = subevent_code
         if parameters is None and (fields := getattr(self, 'fields', None)) and kwargs:
             parameters = bytes([subevent_code]) + HCI_Object.dict_to_bytes(

bumble/helpers.py

@@ -21,7 +21,13 @@ from collections.abc import Callable, MutableMapping
 from typing import cast, Any, Optional
 import logging
 
+from bumble import avc
+from bumble import avctp
 from bumble import avdtp
+from bumble import avrcp
+from bumble import crypto
+from bumble import rfcomm
+from bumble import sdp
 from bumble.colors import color
 from bumble.att import ATT_CID, ATT_PDU
 from bumble.smp import SMP_CID, SMP_Command
@@ -47,9 +53,7 @@ from bumble.hci import (
     HCI_AclDataPacket,
     HCI_Disconnection_Complete_Event,
 )
-from bumble.rfcomm import RFCOMM_Frame, RFCOMM_PSM
-from bumble.sdp import SDP_PDU, SDP_PSM
-from bumble import crypto
+
 
 # -----------------------------------------------------------------------------
 # Logging
@@ -59,11 +63,14 @@ logger = logging.getLogger(__name__)
 
 # -----------------------------------------------------------------------------
 PSM_NAMES = {
-    RFCOMM_PSM: 'RFCOMM',
-    SDP_PSM: 'SDP',
+    rfcomm.RFCOMM_PSM: 'RFCOMM',
+    sdp.SDP_PSM: 'SDP',
     avdtp.AVDTP_PSM: 'AVDTP',
+    avctp.AVCTP_PSM: 'AVCTP'
+    # TODO: add more PSM values
 }
 
+AVCTP_PID_NAMES = {avrcp.AVRCP_PID: 'AVRCP'}
 
 # -----------------------------------------------------------------------------
 class PacketTracer:
@@ -71,17 +78,20 @@ class PacketTracer:
         psms: MutableMapping[int, int]
         peer: Optional[PacketTracer.AclStream]
         avdtp_assemblers: MutableMapping[int, avdtp.MessageAssembler]
+        avctp_assemblers: MutableMapping[int, avctp.MessageAssembler]
 
         def __init__(self, analyzer: PacketTracer.Analyzer) -> None:
             self.analyzer = analyzer
             self.packet_assembler = HCI_AclDataPacketAssembler(self.on_acl_pdu)
             self.avdtp_assemblers = {}  # AVDTP assemblers, by source_cid
+            self.avctp_assemblers = {}  # AVCTP assemblers, by source_cid
             self.psms = {}  # PSM, by source_cid
             self.peer = None
 
         # pylint: disable=too-many-nested-blocks
         def on_acl_pdu(self, pdu: bytes) -> None:
             l2cap_pdu = L2CAP_PDU.from_bytes(pdu)
+            self.analyzer.emit(l2cap_pdu)
 
             if l2cap_pdu.cid == ATT_CID:
                 att_pdu = ATT_PDU.from_bytes(l2cap_pdu.payload)
@@ -103,42 +113,51 @@ class PacketTracer:
                         connection_response.result
                         == L2CAP_Connection_Response.CONNECTION_SUCCESSFUL
                     ):
-                        if self.peer:
-                            if psm := self.peer.psms.get(
-                                connection_response.source_cid
-                            ):
-                                # Found a pending connection
-                                self.psms[connection_response.destination_cid] = psm
-
-                                # For AVDTP connections, create a packet assembler for
-                                # each direction
-                                if psm == avdtp.AVDTP_PSM:
-                                    self.avdtp_assemblers[
-                                        connection_response.source_cid
-                                    ] = avdtp.MessageAssembler(self.on_avdtp_message)
-                                    self.peer.avdtp_assemblers[
-                                        connection_response.destination_cid
-                                    ] = avdtp.MessageAssembler(
-                                        self.peer.on_avdtp_message
-                                    )
+                        if self.peer and (
+                            psm := self.peer.psms.get(connection_response.source_cid)
+                        ):
+                            # Found a pending connection
+                            self.psms[connection_response.destination_cid] = psm
 
+                            # For AVDTP connections, create a packet assembler for
+                            # each direction
+                            if psm == avdtp.AVDTP_PSM:
+                                self.avdtp_assemblers[
+                                    connection_response.source_cid
+                                ] = avdtp.MessageAssembler(self.on_avdtp_message)
+                                self.peer.avdtp_assemblers[
+                                    connection_response.destination_cid
+                                ] = avdtp.MessageAssembler(self.peer.on_avdtp_message)
+                            elif psm == avctp.AVCTP_PSM:
+                                self.avctp_assemblers[
+                                    connection_response.source_cid
+                                ] = avctp.MessageAssembler(self.on_avctp_message)
+                                self.peer.avctp_assemblers[
+                                    connection_response.destination_cid
+                                ] = avctp.MessageAssembler(self.peer.on_avctp_message)
             else:
                 # Try to find the PSM associated with this PDU
                 if self.peer and (psm := self.peer.psms.get(l2cap_pdu.cid)):
-                    if psm == SDP_PSM:
-                        sdp_pdu = SDP_PDU.from_bytes(l2cap_pdu.payload)
+                    if psm == sdp.SDP_PSM:
+                        sdp_pdu = sdp.SDP_PDU.from_bytes(l2cap_pdu.payload)
                         self.analyzer.emit(sdp_pdu)
-                    elif psm == RFCOMM_PSM:
-                        rfcomm_frame = RFCOMM_Frame.from_bytes(l2cap_pdu.payload)
+                    elif psm == rfcomm.RFCOMM_PSM:
+                        rfcomm_frame = rfcomm.RFCOMM_Frame.from_bytes(l2cap_pdu.payload)
                         self.analyzer.emit(rfcomm_frame)
                     elif psm == avdtp.AVDTP_PSM:
                         self.analyzer.emit(
                             f'{color("L2CAP", "green")} [CID={l2cap_pdu.cid}, '
                             f'PSM=AVDTP]: {l2cap_pdu.payload.hex()}'
                         )
-                        assembler = self.avdtp_assemblers.get(l2cap_pdu.cid)
-                        if assembler:
-                            assembler.on_pdu(l2cap_pdu.payload)
+                        if avdtp_assembler := self.avdtp_assemblers.get(l2cap_pdu.cid):
+                            avdtp_assembler.on_pdu(l2cap_pdu.payload)
+                    elif psm == avctp.AVCTP_PSM:
+                        self.analyzer.emit(
+                            f'{color("L2CAP", "green")} [CID={l2cap_pdu.cid}, '
+                            f'PSM=AVCTP]: {l2cap_pdu.payload.hex()}'
+                        )
+                        if avctp_assembler := self.avctp_assemblers.get(l2cap_pdu.cid):
+                            avctp_assembler.on_pdu(l2cap_pdu.payload)
                     else:
                         psm_string = name_or_number(PSM_NAMES, psm)
                         self.analyzer.emit(
@@ -155,6 +174,28 @@ class PacketTracer:
                 f'{color("AVDTP", "green")} [{transaction_label}] {message}'
             )
 
+        def on_avctp_message(
+            self,
+            transaction_label: int,
+            is_command: bool,
+            ipid: bool,
+            pid: int,
+            payload: bytes,
+        ):
+            if pid == avrcp.AVRCP_PID:
+                avc_frame = avc.Frame.from_bytes(payload)
+                details = str(avc_frame)
+            else:
+                details = payload.hex()
+
+            c_r = 'Command' if is_command else 'Response'
+            self.analyzer.emit(
+                f'{color("AVCTP", "green")} '
+                f'{c_r}[{transaction_label}][{name_or_number(AVCTP_PID_NAMES, pid)}] '
+                f'{"#" if ipid else ""}'
+                f'{details}'
+            )
+
         def feed_packet(self, packet: HCI_AclDataPacket) -> None:
             self.packet_assembler.feed_packet(packet)
 

bumble/host.py

@@ -18,6 +18,7 @@
 from __future__ import annotations
 import asyncio
 import collections
+import dataclasses
 import logging
 import struct
 
@@ -161,9 +162,25 @@ class Connection:
         self.host.on_l2cap_pdu(self, l2cap_pdu.cid, l2cap_pdu.payload)
 
 
+# -----------------------------------------------------------------------------
+@dataclasses.dataclass
+class ScoLink:
+    peer_address: Address
+    handle: int
+
+
+# -----------------------------------------------------------------------------
+@dataclasses.dataclass
+class CisLink:
+    peer_address: Address
+    handle: int
+
+
 # -----------------------------------------------------------------------------
 class Host(AbortableEventEmitter):
     connections: Dict[int, Connection]
+    cis_links: Dict[int, CisLink]
+    sco_links: Dict[int, ScoLink]
     acl_packet_queue: Optional[AclPacketQueue] = None
     le_acl_packet_queue: Optional[AclPacketQueue] = None
     hci_sink: Optional[TransportSink] = None
@@ -183,6 +200,8 @@ class Host(AbortableEventEmitter):
         self.hci_metadata = {}
         self.ready = False  # True when we can accept incoming packets
         self.connections = {}  # Connections, by connection handle
+        self.cis_links = {}  # CIS links, by connection handle
+        self.sco_links = {}  # SCO links, by connection handle
         self.pending_command = None
         self.pending_response = None
         self.local_version = None
@@ -696,25 +715,36 @@ class Host(AbortableEventEmitter):
 
     def on_hci_disconnection_complete_event(self, event):
         # Find the connection
-        if (connection := self.connections.get(event.connection_handle)) is None:
+        handle = event.connection_handle
+        if (
+            connection := (
+                self.connections.get(handle)
+                or self.cis_links.get(handle)
+                or self.sco_links.get(handle)
+            )
+        ) is None:
             logger.warning('!!! DISCONNECTION COMPLETE: unknown handle')
             return
 
         if event.status == HCI_SUCCESS:
             logger.debug(
-                f'### DISCONNECTION: [0x{event.connection_handle:04X}] '
+                f'### DISCONNECTION: [0x{handle:04X}] '
                 f'{connection.peer_address} '
                 f'reason={event.reason}'
             )
-            del self.connections[event.connection_handle]
 
             # Notify the listeners
-            self.emit('disconnection', event.connection_handle, event.reason)
+            self.emit('disconnection', handle, event.reason)
+            (
+                self.connections.pop(handle, 0)
+                or self.cis_links.pop(handle, 0)
+                or self.sco_links.pop(handle, 0)
+            )
         else:
             logger.debug(f'### DISCONNECTION FAILED: {event.status}')
 
             # Notify the listeners
-            self.emit('disconnection_failure', event.connection_handle, event.status)
+            self.emit('disconnection_failure', handle, event.status)
 
     def on_hci_le_connection_update_complete_event(self, event):
         if (connection := self.connections.get(event.connection_handle)) is None:
@@ -775,6 +805,10 @@ class Host(AbortableEventEmitter):
     def on_hci_le_cis_established_event(self, event):
         # The remaining parameters are unused for now.
         if event.status == HCI_SUCCESS:
+            self.cis_links[event.connection_handle] = CisLink(
+                handle=event.connection_handle,
+                peer_address=Address.ANY,
+            )
             self.emit('cis_establishment', event.connection_handle)
         else:
             self.emit(
@@ -841,6 +875,11 @@ class Host(AbortableEventEmitter):
                 f'{event.bd_addr}'
             )
 
+            self.sco_links[event.connection_handle] = ScoLink(
+                peer_address=event.bd_addr,
+                handle=event.connection_handle,
+            )
+
             # Notify the client
             self.emit(
                 'sco_connection',

bumble/link.py

@@ -196,6 +196,60 @@ class LocalLink:
         if peripheral_controller := self.find_controller(peripheral_address):
             peripheral_controller.on_link_encrypted(central_address, rand, ediv, ltk)
 
+    def create_cis(
+        self,
+        central_controller: controller.Controller,
+        peripheral_address: Address,
+        cig_id: int,
+        cis_id: int,
+    ) -> None:
+        logger.debug(
+            f'$$$ CIS Request {central_controller.random_address} -> {peripheral_address}'
+        )
+        if peripheral_controller := self.find_controller(peripheral_address):
+            asyncio.get_running_loop().call_soon(
+                peripheral_controller.on_link_cis_request,
+                central_controller.random_address,
+                cig_id,
+                cis_id,
+            )
+
+    def accept_cis(
+        self,
+        peripheral_controller: controller.Controller,
+        central_address: Address,
+        cig_id: int,
+        cis_id: int,
+    ) -> None:
+        logger.debug(
+            f'$$$ CIS Accept {peripheral_controller.random_address} -> {central_address}'
+        )
+        if central_controller := self.find_controller(central_address):
+            asyncio.get_running_loop().call_soon(
+                central_controller.on_link_cis_established, cig_id, cis_id
+            )
+            asyncio.get_running_loop().call_soon(
+                peripheral_controller.on_link_cis_established, cig_id, cis_id
+            )
+
+    def disconnect_cis(
+        self,
+        initiator_controller: controller.Controller,
+        peer_address: Address,
+        cig_id: int,
+        cis_id: int,
+    ) -> None:
+        logger.debug(
+            f'$$$ CIS Disconnect {initiator_controller.random_address} -> {peer_address}'
+        )
+        if peer_controller := self.find_controller(peer_address):
+            asyncio.get_running_loop().call_soon(
+                initiator_controller.on_link_cis_disconnected, cig_id, cis_id
+            )
+            asyncio.get_running_loop().call_soon(
+                peer_controller.on_link_cis_disconnected, cig_id, cis_id
+            )
+
     ############################################################
     # Classic handlers
     ############################################################

bumble/pandora/security.py

@@ -110,7 +110,7 @@ class PairingDelegate(BasePairingDelegate):
 
         event = self.add_origin(PairingEvent(just_works=empty_pb2.Empty()))
         self.service.event_queue.put_nowait(event)
-        answer = await anext(self.service.event_answer)  # pytype: disable=name-error
+        answer = await anext(self.service.event_answer)  # type: ignore
         assert answer.event == event
         assert answer.answer_variant() == 'confirm' and answer.confirm is not None
         return answer.confirm
@@ -125,7 +125,7 @@ class PairingDelegate(BasePairingDelegate):
 
         event = self.add_origin(PairingEvent(numeric_comparison=number))
         self.service.event_queue.put_nowait(event)
-        answer = await anext(self.service.event_answer)  # pytype: disable=name-error
+        answer = await anext(self.service.event_answer)  # type: ignore
         assert answer.event == event
         assert answer.answer_variant() == 'confirm' and answer.confirm is not None
         return answer.confirm
@@ -140,7 +140,7 @@ class PairingDelegate(BasePairingDelegate):
 
         event = self.add_origin(PairingEvent(passkey_entry_request=empty_pb2.Empty()))
         self.service.event_queue.put_nowait(event)
-        answer = await anext(self.service.event_answer)  # pytype: disable=name-error
+        answer = await anext(self.service.event_answer)  # type: ignore
         assert answer.event == event
         if answer.answer_variant() is None:
             return None
@@ -157,7 +157,7 @@ class PairingDelegate(BasePairingDelegate):
 
         event = self.add_origin(PairingEvent(pin_code_request=empty_pb2.Empty()))
         self.service.event_queue.put_nowait(event)
-        answer = await anext(self.service.event_answer)  # pytype: disable=name-error
+        answer = await anext(self.service.event_answer)  # type: ignore
         assert answer.event == event
         if answer.answer_variant() is None:
             return None

bumble/rfcomm.py

@@ -19,6 +19,7 @@ from __future__ import annotations
 
 import logging
 import asyncio
+import dataclasses
 import enum
 from typing import Callable, Dict, List, Optional, Tuple, Union, TYPE_CHECKING
 
@@ -60,27 +61,18 @@ logger = logging.getLogger(__name__)
 
 RFCOMM_PSM = 0x0003
 
+class FrameType(enum.IntEnum):
+    SABM = 0x2F  # Control field [1,1,1,1,_,1,0,0] LSB-first
+    UA   = 0x63  # Control field [0,1,1,0,_,0,1,1] LSB-first
+    DM   = 0x0F  # Control field [1,1,1,1,_,0,0,0] LSB-first
+    DISC = 0x43  # Control field [0,1,0,_,0,0,1,1] LSB-first
+    UIH  = 0xEF  # Control field [1,1,1,_,1,1,1,1] LSB-first
+    UI   = 0x03  # Control field [0,0,0,_,0,0,1,1] LSB-first
 
-# Frame types
-RFCOMM_SABM_FRAME = 0x2F  # Control field [1,1,1,1,_,1,0,0] LSB-first
-RFCOMM_UA_FRAME   = 0x63  # Control field [0,1,1,0,_,0,1,1] LSB-first
-RFCOMM_DM_FRAME   = 0x0F  # Control field [1,1,1,1,_,0,0,0] LSB-first
-RFCOMM_DISC_FRAME = 0x43  # Control field [0,1,0,_,0,0,1,1] LSB-first
-RFCOMM_UIH_FRAME  = 0xEF  # Control field [1,1,1,_,1,1,1,1] LSB-first
-RFCOMM_UI_FRAME   = 0x03  # Control field [0,0,0,_,0,0,1,1] LSB-first
+class MccType(enum.IntEnum):
+    PN  = 0x20
+    MSC = 0x38
 
-RFCOMM_FRAME_TYPE_NAMES = {
-    RFCOMM_SABM_FRAME: 'SABM',
-    RFCOMM_UA_FRAME:   'UA',
-    RFCOMM_DM_FRAME:   'DM',
-    RFCOMM_DISC_FRAME: 'DISC',
-    RFCOMM_UIH_FRAME:  'UIH',
-    RFCOMM_UI_FRAME:   'UI'
-}
-
-# MCC Types
-RFCOMM_MCC_PN_TYPE  = 0x20
-RFCOMM_MCC_MSC_TYPE = 0x38
 
 # FCS CRC
 CRC_TABLE = bytes([
@@ -118,7 +110,7 @@ CRC_TABLE = bytes([
     0XBA, 0X2B, 0X59, 0XC8, 0XBD, 0X2C, 0X5E, 0XCF
 ])
 
-RFCOMM_DEFAULT_WINDOW_SIZE    = 16
+RFCOMM_DEFAULT_WINDOW_SIZE    = 7
 RFCOMM_DEFAULT_MAX_FRAME_SIZE = 2000
 
 RFCOMM_DYNAMIC_CHANNEL_NUMBER_START = 1
@@ -183,7 +175,7 @@ def compute_fcs(buffer: bytes) -> int:
 class RFCOMM_Frame:
     def __init__(
         self,
-        frame_type: int,
+        frame_type: FrameType,
         c_r: int,
         dlci: int,
         p_f: int,
@@ -206,14 +198,11 @@ class RFCOMM_Frame:
             self.length = bytes([(length << 1) | 1])
         self.address = (dlci << 2) | (c_r << 1) | 1
         self.control = frame_type | (p_f << 4)
-        if frame_type == RFCOMM_UIH_FRAME:
+        if frame_type == FrameType.UIH:
             self.fcs = compute_fcs(bytes([self.address, self.control]))
         else:
             self.fcs = compute_fcs(bytes([self.address, self.control]) + self.length)
 
-    def type_name(self) -> str:
-        return RFCOMM_FRAME_TYPE_NAMES[self.type]
-
     @staticmethod
     def parse_mcc(data) -> Tuple[int, bool, bytes]:
         mcc_type = data[0] >> 2
@@ -237,24 +226,24 @@ class RFCOMM_Frame:
 
     @staticmethod
     def sabm(c_r: int, dlci: int):
-        return RFCOMM_Frame(RFCOMM_SABM_FRAME, c_r, dlci, 1)
+        return RFCOMM_Frame(FrameType.SABM, c_r, dlci, 1)
 
     @staticmethod
     def ua(c_r: int, dlci: int):
-        return RFCOMM_Frame(RFCOMM_UA_FRAME, c_r, dlci, 1)
+        return RFCOMM_Frame(FrameType.UA, c_r, dlci, 1)
 
     @staticmethod
     def dm(c_r: int, dlci: int):
-        return RFCOMM_Frame(RFCOMM_DM_FRAME, c_r, dlci, 1)
+        return RFCOMM_Frame(FrameType.DM, c_r, dlci, 1)
 
     @staticmethod
     def disc(c_r: int, dlci: int):
-        return RFCOMM_Frame(RFCOMM_DISC_FRAME, c_r, dlci, 1)
+        return RFCOMM_Frame(FrameType.DISC, c_r, dlci, 1)
 
     @staticmethod
     def uih(c_r: int, dlci: int, information: bytes, p_f: int = 0):
         return RFCOMM_Frame(
-            RFCOMM_UIH_FRAME, c_r, dlci, p_f, information, with_credits=(p_f == 1)
+            FrameType.UIH, c_r, dlci, p_f, information, with_credits=(p_f == 1)
         )
 
     @staticmethod
@@ -262,7 +251,7 @@ class RFCOMM_Frame:
         # Extract fields
         dlci = (data[0] >> 2) & 0x3F
         c_r = (data[0] >> 1) & 0x01
-        frame_type = data[1] & 0xEF
+        frame_type = FrameType(data[1] & 0xEF)
         p_f = (data[1] >> 4) & 0x01
         length = data[2]
         if length & 0x01:
@@ -291,7 +280,7 @@ class RFCOMM_Frame:
 
     def __str__(self) -> str:
         return (
-            f'{color(self.type_name(), "yellow")}'
+            f'{color(self.type.name, "yellow")}'
             f'(c/r={self.c_r},'
             f'dlci={self.dlci},'
             f'p/f={self.p_f},'
@@ -301,6 +290,7 @@ class RFCOMM_Frame:
 
 
 # -----------------------------------------------------------------------------
+@dataclasses.dataclass
 class RFCOMM_MCC_PN:
     dlci: int
     cl: int
@@ -310,23 +300,11 @@ class RFCOMM_MCC_PN:
     max_retransmissions: int
     window_size: int
 
-    def __init__(
-        self,
-        dlci: int,
-        cl: int,
-        priority: int,
-        ack_timer: int,
-        max_frame_size: int,
-        max_retransmissions: int,
-        window_size: int,
-    ) -> None:
-        self.dlci = dlci
-        self.cl = cl
-        self.priority = priority
-        self.ack_timer = ack_timer
-        self.max_frame_size = max_frame_size
-        self.max_retransmissions = max_retransmissions
-        self.window_size = window_size
+    def __post_init__(self) -> None:
+        if self.window_size < 1 or self.window_size > 7:
+            logger.warning(
+                f'Error Recovery Window size {self.window_size} is out of range [1, 7].'
+            )
 
     @staticmethod
     def from_bytes(data: bytes) -> RFCOMM_MCC_PN:
@@ -337,7 +315,7 @@ class RFCOMM_MCC_PN:
             ack_timer=data[3],
             max_frame_size=data[4] | data[5] << 8,
             max_retransmissions=data[6],
-            window_size=data[7],
+            window_size=data[7] & 0x07,
         )
 
     def __bytes__(self) -> bytes:
@@ -350,23 +328,14 @@ class RFCOMM_MCC_PN:
                 self.max_frame_size & 0xFF,
                 (self.max_frame_size >> 8) & 0xFF,
                 self.max_retransmissions & 0xFF,
-                self.window_size & 0xFF,
+                # Only 3 bits are meaningful.
+                self.window_size & 0x07,
             ]
         )
 
-    def __str__(self) -> str:
-        return (
-            f'PN(dlci={self.dlci},'
-            f'cl={self.cl},'
-            f'priority={self.priority},'
-            f'ack_timer={self.ack_timer},'
-            f'max_frame_size={self.max_frame_size},'
-            f'max_retransmissions={self.max_retransmissions},'
-            f'window_size={self.window_size})'
-        )
-
 
 # -----------------------------------------------------------------------------
+@dataclasses.dataclass
 class RFCOMM_MCC_MSC:
     dlci: int
     fc: int
@@ -375,16 +344,6 @@ class RFCOMM_MCC_MSC:
     ic: int
     dv: int
 
-    def __init__(
-        self, dlci: int, fc: int, rtc: int, rtr: int, ic: int, dv: int
-    ) -> None:
-        self.dlci = dlci
-        self.fc = fc
-        self.rtc = rtc
-        self.rtr = rtr
-        self.ic = ic
-        self.dv = dv
-
     @staticmethod
     def from_bytes(data: bytes) -> RFCOMM_MCC_MSC:
         return RFCOMM_MCC_MSC(
@@ -409,16 +368,6 @@ class RFCOMM_MCC_MSC:
             ]
         )
 
-    def __str__(self) -> str:
-        return (
-            f'MSC(dlci={self.dlci},'
-            f'fc={self.fc},'
-            f'rtc={self.rtc},'
-            f'rtr={self.rtr},'
-            f'ic={self.ic},'
-            f'dv={self.dv})'
-        )
-
 
 # -----------------------------------------------------------------------------
 class DLC(EventEmitter):
@@ -471,7 +420,7 @@ class DLC(EventEmitter):
         self.multiplexer.send_frame(frame)
 
     def on_frame(self, frame: RFCOMM_Frame) -> None:
-        handler = getattr(self, f'on_{frame.type_name()}_frame'.lower())
+        handler = getattr(self, f'on_{frame.type.name}_frame'.lower())
         handler(frame)
 
     def on_sabm_frame(self, _frame: RFCOMM_Frame) -> None:
@@ -485,9 +434,7 @@ class DLC(EventEmitter):
 
         # Exchange the modem status with the peer
         msc = RFCOMM_MCC_MSC(dlci=self.dlci, fc=0, rtc=1, rtr=1, ic=0, dv=1)
-        mcc = RFCOMM_Frame.make_mcc(
-            mcc_type=RFCOMM_MCC_MSC_TYPE, c_r=1, data=bytes(msc)
-        )
+        mcc = RFCOMM_Frame.make_mcc(mcc_type=MccType.MSC, c_r=1, data=bytes(msc))
         logger.debug(f'>>> MCC MSC Command: {msc}')
         self.send_frame(RFCOMM_Frame.uih(c_r=self.c_r, dlci=0, information=mcc))
 
@@ -503,9 +450,7 @@ class DLC(EventEmitter):
 
         # Exchange the modem status with the peer
         msc = RFCOMM_MCC_MSC(dlci=self.dlci, fc=0, rtc=1, rtr=1, ic=0, dv=1)
-        mcc = RFCOMM_Frame.make_mcc(
-            mcc_type=RFCOMM_MCC_MSC_TYPE, c_r=1, data=bytes(msc)
-        )
+        mcc = RFCOMM_Frame.make_mcc(mcc_type=MccType.MSC, c_r=1, data=bytes(msc))
         logger.debug(f'>>> MCC MSC Command: {msc}')
         self.send_frame(RFCOMM_Frame.uih(c_r=self.c_r, dlci=0, information=mcc))
 
@@ -559,9 +504,7 @@ class DLC(EventEmitter):
             # Command
             logger.debug(f'<<< MCC MSC Command: {msc}')
             msc = RFCOMM_MCC_MSC(dlci=self.dlci, fc=0, rtc=1, rtr=1, ic=0, dv=1)
-            mcc = RFCOMM_Frame.make_mcc(
-                mcc_type=RFCOMM_MCC_MSC_TYPE, c_r=0, data=bytes(msc)
-            )
+            mcc = RFCOMM_Frame.make_mcc(mcc_type=MccType.MSC, c_r=0, data=bytes(msc))
             logger.debug(f'>>> MCC MSC Response: {msc}')
             self.send_frame(RFCOMM_Frame.uih(c_r=self.c_r, dlci=0, information=mcc))
         else:
@@ -589,7 +532,7 @@ class DLC(EventEmitter):
             max_retransmissions=0,
             window_size=self.window_size,
         )
-        mcc = RFCOMM_Frame.make_mcc(mcc_type=RFCOMM_MCC_PN_TYPE, c_r=0, data=bytes(pn))
+        mcc = RFCOMM_Frame.make_mcc(mcc_type=MccType.PN, c_r=0, data=bytes(pn))
         logger.debug(f'>>> PN Response: {pn}')
         self.send_frame(RFCOMM_Frame.uih(c_r=self.c_r, dlci=0, information=mcc))
         self.change_state(DLC.State.CONNECTING)
@@ -711,7 +654,7 @@ class Multiplexer(EventEmitter):
         if frame.dlci == 0:
             self.on_frame(frame)
         else:
-            if frame.type == RFCOMM_DM_FRAME:
+            if frame.type == FrameType.DM:
                 # DM responses are for a DLCI, but since we only create the dlc when we
                 # receive a PN response (because we need the parameters), we handle DM
                 # frames at the Multiplexer level
@@ -724,7 +667,7 @@ class Multiplexer(EventEmitter):
                 dlc.on_frame(frame)
 
     def on_frame(self, frame: RFCOMM_Frame) -> None:
-        handler = getattr(self, f'on_{frame.type_name()}_frame'.lower())
+        handler = getattr(self, f'on_{frame.type.name}_frame'.lower())
         handler(frame)
 
     def on_sabm_frame(self, _frame: RFCOMM_Frame) -> None:
@@ -772,10 +715,10 @@ class Multiplexer(EventEmitter):
     def on_uih_frame(self, frame: RFCOMM_Frame) -> None:
         (mcc_type, c_r, value) = RFCOMM_Frame.parse_mcc(frame.information)
 
-        if mcc_type == RFCOMM_MCC_PN_TYPE:
+        if mcc_type == MccType.PN:
             pn = RFCOMM_MCC_PN.from_bytes(value)
             self.on_mcc_pn(c_r, pn)
-        elif mcc_type == RFCOMM_MCC_MSC_TYPE:
+        elif mcc_type == MccType.MSC:
             mcs = RFCOMM_MCC_MSC.from_bytes(value)
             self.on_mcc_msc(c_r, mcs)
 
@@ -871,7 +814,7 @@ class Multiplexer(EventEmitter):
             max_retransmissions=0,
             window_size=window_size,
         )
-        mcc = RFCOMM_Frame.make_mcc(mcc_type=RFCOMM_MCC_PN_TYPE, c_r=1, data=bytes(pn))
+        mcc = RFCOMM_Frame.make_mcc(mcc_type=MccType.PN, c_r=1, data=bytes(pn))
         logger.debug(f'>>> Sending MCC: {pn}')
         self.open_result = asyncio.get_running_loop().create_future()
         self.change_state(Multiplexer.State.OPENING)

bumble/sdp.py

@@ -97,7 +97,8 @@ SDP_CLIENT_EXECUTABLE_URL_ATTRIBUTE_ID               = 0X000B
 SDP_ICON_URL_ATTRIBUTE_ID                            = 0X000C
 SDP_ADDITIONAL_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID = 0X000D
 
-# Attribute Identifier (cf. Assigned Numbers for Service Discovery)
+
+# Profile-specific Attribute Identifiers (cf. Assigned Numbers for Service Discovery)
 # used by AVRCP, HFP and A2DP
 SDP_SUPPORTED_FEATURES_ATTRIBUTE_ID = 0x0311
 
@@ -115,7 +116,8 @@ SDP_ATTRIBUTE_ID_NAMES = {
     SDP_DOCUMENTATION_URL_ATTRIBUTE_ID:                   'SDP_DOCUMENTATION_URL_ATTRIBUTE_ID',
     SDP_CLIENT_EXECUTABLE_URL_ATTRIBUTE_ID:               'SDP_CLIENT_EXECUTABLE_URL_ATTRIBUTE_ID',
     SDP_ICON_URL_ATTRIBUTE_ID:                            'SDP_ICON_URL_ATTRIBUTE_ID',
-    SDP_ADDITIONAL_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID: 'SDP_ADDITIONAL_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID'
+    SDP_ADDITIONAL_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID: 'SDP_ADDITIONAL_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID',
+    SDP_SUPPORTED_FEATURES_ATTRIBUTE_ID:                  'SDP_SUPPORTED_FEATURES_ATTRIBUTE_ID',
 }
 
 SDP_PUBLIC_BROWSE_ROOT = core.UUID.from_16_bits(0x1002, 'PublicBrowseRoot')

bumble/smp.py

@@ -1134,8 +1134,10 @@ class Session:
 
     async def get_link_key_and_derive_ltk(self) -> None:
         '''Retrieves BR/EDR Link Key from storage and derive it to LE LTK.'''
-        link_key = await self.manager.device.get_link_key(self.connection.peer_address)
-        if link_key is None:
+        self.link_key = await self.manager.device.get_link_key(
+            self.connection.peer_address
+        )
+        if self.link_key is None:
             logging.warning(
                 'Try to derive LTK but host does not have the LK. Send a SMP_PAIRING_FAILED but the procedure will not be paused!'
             )
@@ -1143,7 +1145,7 @@ class Session:
                 SMP_CROSS_TRANSPORT_KEY_DERIVATION_NOT_ALLOWED_ERROR
             )
         else:
-            self.ltk = self.derive_ltk(link_key, self.ct2)
+            self.ltk = self.derive_ltk(self.link_key, self.ct2)
 
     def distribute_keys(self) -> None:
         # Distribute the keys as required
@@ -1991,10 +1993,8 @@ class Manager(EventEmitter):
     ) -> None:
         # Store the keys in the key store
         if self.device.keystore and identity_address is not None:
-            self.device.abort_on(
-                'flush', self.device.update_keys(str(identity_address), keys)
-            )
-
+            # Make sure on_pairing emits after key update.
+            await self.device.update_keys(str(identity_address), keys)
         # Notify the device
         self.device.on_pairing(session.connection, identity_address, keys, session.sc)
 

bumble/utils.py

@@ -17,9 +17,10 @@
 # -----------------------------------------------------------------------------
 from __future__ import annotations
 import asyncio
-import logging
-import traceback
 import collections
+import enum
+import functools
+import logging
 import sys
 import warnings
 from typing import (
@@ -34,7 +35,7 @@ from typing import (
     Union,
     overload,
 )
-from functools import wraps, partial
+
 from pyee import EventEmitter
 
 from .colors import color
@@ -131,13 +132,14 @@ class EventWatcher:
         Args:
             emitter: EventEmitter to watch
             event: Event name
-            handler: (Optional) Event handler. When nothing is passed, this method works as a decorator.
+            handler: (Optional) Event handler. When nothing is passed, this method
+            works as a decorator.
         '''
 
-        def wrapper(f: _Handler) -> _Handler:
-            self.handlers.append((emitter, event, f))
-            emitter.on(event, f)
-            return f
+        def wrapper(wrapped: _Handler) -> _Handler:
+            self.handlers.append((emitter, event, wrapped))
+            emitter.on(event, wrapped)
+            return wrapped
 
         return wrapper if handler is None else wrapper(handler)
 
@@ -157,13 +159,14 @@ class EventWatcher:
         Args:
             emitter: EventEmitter to watch
             event: Event name
-            handler: (Optional) Event handler. When nothing passed, this method works as a decorator.
+            handler: (Optional) Event handler. When nothing passed, this method works
+            as a decorator.
         '''
 
-        def wrapper(f: _Handler) -> _Handler:
-            self.handlers.append((emitter, event, f))
-            emitter.once(event, f)
-            return f
+        def wrapper(wrapped: _Handler) -> _Handler:
+            self.handlers.append((emitter, event, wrapped))
+            emitter.once(event, wrapped)
+            return wrapped
 
         return wrapper if handler is None else wrapper(handler)
 
@@ -276,7 +279,7 @@ class AsyncRunner:
         """
 
         def decorator(func):
-            @wraps(func)
+            @functools.wraps(func)
             def wrapper(*args, **kwargs):
                 coroutine = func(*args, **kwargs)
                 if queue is None:
@@ -410,30 +413,35 @@ class FlowControlAsyncPipe:
             self.check_pump()
 
 
+# -----------------------------------------------------------------------------
 async def async_call(function, *args, **kwargs):
     """
-    Immediately calls the function with provided args and kwargs, wrapping it in an async function.
-    Rust's `pyo3_asyncio` library needs functions to be marked async to properly inject a running loop.
+    Immediately calls the function with provided args and kwargs, wrapping it in an
+    async function.
+    Rust's `pyo3_asyncio` library needs functions to be marked async to properly inject
+    a running loop.
 
     result = await async_call(some_function, ...)
     """
     return function(*args, **kwargs)
 
 
+# -----------------------------------------------------------------------------
 def wrap_async(function):
     """
     Wraps the provided function in an async function.
     """
-    return partial(async_call, function)
+    return functools.partial(async_call, function)
 
 
+# -----------------------------------------------------------------------------
 def deprecated(msg: str):
     """
     Throw deprecation warning before execution.
     """
 
     def wrapper(function):
-        @wraps(function)
+        @functools.wraps(function)
         def inner(*args, **kwargs):
             warnings.warn(msg, DeprecationWarning)
             return function(*args, **kwargs)
@@ -443,13 +451,14 @@ def deprecated(msg: str):
     return wrapper
 
 
+# -----------------------------------------------------------------------------
 def experimental(msg: str):
     """
     Throws a future warning before execution.
     """
 
     def wrapper(function):
-        @wraps(function)
+        @functools.wraps(function)
         def inner(*args, **kwargs):
             warnings.warn(msg, FutureWarning)
             return function(*args, **kwargs)
@@ -457,3 +466,22 @@ def experimental(msg: str):
         return inner
 
     return wrapper
+
+
+# -----------------------------------------------------------------------------
+class OpenIntEnum(enum.IntEnum):
+    """
+    Subclass of enum.IntEnum that can hold integer values outside the set of
+    predefined values. This is convenient for implementing protocols where some
+    integer constants may be added over time.
+    """
+
+    @classmethod
+    def _missing_(cls, value):
+        if not isinstance(value, int):
+            return None
+
+        obj = int.__new__(cls, value)
+        obj._value_ = value
+        obj._name_ = f"{cls.__name__}[{value}]"
+        return obj

examples/avrcp_as_sink.html

@@ -0,0 +1,274 @@
+<html>
+
+<head>
+    <style>
+        * {
+            font-family: sans-serif;
+        }
+    </style>
+</head>
+<body>
+    Server Port <input id="port" type="text" value="8989"></input> <button id="connectButton" onclick="connect()">Connect</button><br>
+    <div id="socketState"></div>
+    <br>
+    <div id="buttons"></div><br>
+    <hr>
+    <button onclick="onGetPlayStatusButtonClicked()">Get Play Status</button><br>
+    <div id="getPlayStatusResponseTable"></div>
+    <hr>
+    <button onclick="onGetElementAttributesButtonClicked()">Get Element Attributes</button><br>
+    <div id="getElementAttributesResponseTable"></div>
+    <hr>
+    <table>
+        <tr>
+            <b>VOLUME</b>:
+            <button onclick="onVolumeDownButtonClicked()">-</button>
+            <button onclick="onVolumeUpButtonClicked()">+</button>&nbsp;
+            <span id="volumeText"></span><br>
+        </tr>
+        <tr>
+            <td><b>PLAYBACK STATUS</b></td><td><span id="playbackStatusText"></span></td>
+        </tr>
+        <tr>
+            <td><b>POSITION</b></td><td><span id="positionText"></span></td>
+        </tr>
+        <tr>
+            <td><b>TRACK</b></td><td><span id="trackText"></span></td>
+        </tr>
+        <tr>
+            <td><b>ADDRESSED PLAYER</b></td><td><span id="addressedPlayerText"></span></td>
+        </tr>
+        <tr>
+            <td><b>UID COUNTER</b></td><td><span id="uidCounterText"></span></td>
+        </tr>
+        <tr>
+            <td><b>SUPPORTED EVENTS</b></td><td><span id="supportedEventsText"></span></td>
+        </tr>
+        <tr>
+            <td><b>PLAYER SETTINGS</b></td><td><div id="playerSettingsTable"></div></td>
+        </tr>
+    </table>
+    <script>
+        const portInput = document.getElementById("port")
+        const connectButton = document.getElementById("connectButton")
+        const socketState = document.getElementById("socketState")
+        const volumeText = document.getElementById("volumeText")
+        const positionText = document.getElementById("positionText")
+        const trackText = document.getElementById("trackText")
+        const playbackStatusText = document.getElementById("playbackStatusText")
+        const addressedPlayerText = document.getElementById("addressedPlayerText")
+        const uidCounterText = document.getElementById("uidCounterText")
+        const supportedEventsText = document.getElementById("supportedEventsText")
+        const playerSettingsTable = document.getElementById("playerSettingsTable")
+        const getPlayStatusResponseTable = document.getElementById("getPlayStatusResponseTable")
+        const getElementAttributesResponseTable = document.getElementById("getElementAttributesResponseTable")
+        let socket
+        let volume = 0
+
+        const keyNames = [
+            "SELECT",
+            "UP",
+            "DOWN",
+            "LEFT",
+            "RIGHT",
+            "RIGHT_UP",
+            "RIGHT_DOWN",
+            "LEFT_UP",
+            "LEFT_DOWN",
+            "ROOT_MENU",
+            "SETUP_MENU",
+            "CONTENTS_MENU",
+            "FAVORITE_MENU",
+            "EXIT",
+            "NUMBER_0",
+            "NUMBER_1",
+            "NUMBER_2",
+            "NUMBER_3",
+            "NUMBER_4",
+            "NUMBER_5",
+            "NUMBER_6",
+            "NUMBER_7",
+            "NUMBER_8",
+            "NUMBER_9",
+            "DOT",
+            "ENTER",
+            "CLEAR",
+            "CHANNEL_UP",
+            "CHANNEL_DOWN",
+            "PREVIOUS_CHANNEL",
+            "SOUND_SELECT",
+            "INPUT_SELECT",
+            "DISPLAY_INFORMATION",
+            "HELP",
+            "PAGE_UP",
+            "PAGE_DOWN",
+            "POWER",
+            "VOLUME_UP",
+            "VOLUME_DOWN",
+            "MUTE",
+            "PLAY",
+            "STOP",
+            "PAUSE",
+            "RECORD",
+            "REWIND",
+            "FAST_FORWARD",
+            "EJECT",
+            "FORWARD",
+            "BACKWARD",
+            "ANGLE",
+            "SUBPICTURE",
+            "F1",
+            "F2",
+            "F3",
+            "F4",
+            "F5",
+        ]
+
+        document.addEventListener('keydown', onKeyDown)
+        document.addEventListener('keyup', onKeyUp)
+
+        const buttons = document.getElementById("buttons")
+        keyNames.forEach(name => {
+            const button = document.createElement("BUTTON")
+            button.appendChild(document.createTextNode(name))
+            button.addEventListener("mousedown", event => {
+                send({type: 'send-key-down', key: name})
+            })
+            button.addEventListener("mouseup", event => {
+                send({type: 'send-key-up', key: name})
+            })
+            buttons.appendChild(button)
+        })
+
+        updateVolume(0)
+
+        function connect() {
+            socket = new WebSocket(`ws://localhost:${portInput.value}`);
+            socket.onopen = _ => {
+                socketState.innerText = 'OPEN'
+                connectButton.disabled = true
+            }
+            socket.onclose = _ => {
+                socketState.innerText = 'CLOSED'
+                connectButton.disabled = false
+            }
+            socket.onerror = (error) => {
+                socketState.innerText = 'ERROR'
+                console.log(`ERROR: ${error}`)
+                connectButton.disabled = false
+            }
+            socket.onmessage = (message) => {
+                onMessage(JSON.parse(message.data))
+            }
+        }
+
+        function send(message) {
+            if (socket && socket.readyState == WebSocket.OPEN) {
+                socket.send(JSON.stringify(message))
+            }
+        }
+
+        function hmsText(position) {
+            const h_1 = 1000 * 60 * 60
+            const h = Math.floor(position / h_1)
+            position -= h * h_1
+            const m_1 = 1000 * 60
+            const m = Math.floor(position / m_1)
+            position -= m * m_1
+            const s_1 = 1000
+            const s = Math.floor(position / s_1)
+            position -= s * s_1
+
+            return `${h}:${m.toString().padStart(2, "0")}:${s.toString().padStart(2, "0")}:${position}`
+        }
+
+        function setTableHead(table, columns) {
+            let thead = table.createTHead()
+            let row = thead.insertRow()
+            for (let column of columns) {
+                let th = document.createElement("th")
+                let text = document.createTextNode(column)
+                th.appendChild(text)
+                row.appendChild(th)
+            }
+        }
+
+        function createTable(rows) {
+            const table = document.createElement("table")
+
+            if (rows.length != 0) {
+                columns = Object.keys(rows[0])
+                setTableHead(table, columns)
+            }
+            for (let element of rows) {
+                let row = table.insertRow()
+                for (key in element) {
+                    let cell = row.insertCell()
+                    let text = document.createTextNode(element[key])
+                    cell.appendChild(text)
+                }
+            }
+            return table
+        }
+
+        function onMessage(message) {
+            console.log(message)
+            if (message.type == "set-volume") {
+                updateVolume(message.params.volume)
+            } else if (message.type == "supported-events") {
+                supportedEventsText.innerText = JSON.stringify(message.params.events)
+            } else if (message.type == "playback-position-changed") {
+                positionText.innerText = hmsText(message.params.position)
+            } else if (message.type == "playback-status-changed") {
+                playbackStatusText.innerText = message.params.status
+            } else if (message.type == "player-settings-changed") {
+                playerSettingsTable.replaceChildren(message.params.settings)
+            } else if (message.type == "track-changed") {
+                trackText.innerText = message.params.identifier
+            } else if (message.type == "addressed-player-changed") {
+                addressedPlayerText.innerText = JSON.stringify(message.params.player)
+            } else if (message.type == "uids-changed") {
+                uidCounterText.innerText = message.params.uid_counter
+            } else if (message.type == "get-play-status-response") {
+                getPlayStatusResponseTable.replaceChildren(message.params)
+            } else if (message.type == "get-element-attributes-response") {
+                getElementAttributesResponseTable.replaceChildren(createTable(message.params))
+            }
+        }
+
+        function updateVolume(newVolume) {
+            volume = newVolume
+            volumeText.innerText = `${volume} (${Math.round(100*volume/0x7F)}%)`
+        }
+
+        function onKeyDown(event) {
+            console.log(event)
+            send({ type: 'send-key-down', key: event.key })
+        }
+
+        function onKeyUp(event) {
+            console.log(event)
+            send({ type: 'send-key-up', key: event.key })
+        }
+
+        function onVolumeUpButtonClicked() {
+            updateVolume(Math.min(volume + 5, 0x7F))
+            send({ type: 'set-volume', volume })
+        }
+
+        function onVolumeDownButtonClicked() {
+            updateVolume(Math.max(volume - 5, 0))
+            send({ type: 'set-volume', volume })
+        }
+
+        function onGetPlayStatusButtonClicked() {
+            send({ type: 'get-play-status', volume })
+        }
+
+        function onGetElementAttributesButtonClicked() {
+            send({ type: 'get-element-attributes' })
+        }
+</script>
+</body>
+
+</html>

examples/run_avrcp.py

@@ -0,0 +1,408 @@
+# Copyright 2023 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+from __future__ import annotations
+import asyncio
+import json
+import sys
+import os
+import logging
+import websockets
+
+from bumble.device import Device
+from bumble.transport import open_transport_or_link
+from bumble.core import BT_BR_EDR_TRANSPORT
+from bumble import avc
+from bumble import avrcp
+from bumble import avdtp
+from bumble import a2dp
+from bumble import utils
+
+
+logger = logging.getLogger(__name__)
+
+
+# -----------------------------------------------------------------------------
+def sdp_records():
+    a2dp_sink_service_record_handle = 0x00010001
+    avrcp_controller_service_record_handle = 0x00010002
+    avrcp_target_service_record_handle = 0x00010003
+    # pylint: disable=line-too-long
+    return {
+        a2dp_sink_service_record_handle: a2dp.make_audio_sink_service_sdp_records(
+            a2dp_sink_service_record_handle
+        ),
+        avrcp_controller_service_record_handle: avrcp.make_controller_service_sdp_records(
+            avrcp_controller_service_record_handle
+        ),
+        avrcp_target_service_record_handle: avrcp.make_target_service_sdp_records(
+            avrcp_controller_service_record_handle
+        ),
+    }
+
+
+# -----------------------------------------------------------------------------
+def codec_capabilities():
+    return avdtp.MediaCodecCapabilities(
+        media_type=avdtp.AVDTP_AUDIO_MEDIA_TYPE,
+        media_codec_type=a2dp.A2DP_SBC_CODEC_TYPE,
+        media_codec_information=a2dp.SbcMediaCodecInformation.from_lists(
+            sampling_frequencies=[48000, 44100, 32000, 16000],
+            channel_modes=[
+                a2dp.SBC_MONO_CHANNEL_MODE,
+                a2dp.SBC_DUAL_CHANNEL_MODE,
+                a2dp.SBC_STEREO_CHANNEL_MODE,
+                a2dp.SBC_JOINT_STEREO_CHANNEL_MODE,
+            ],
+            block_lengths=[4, 8, 12, 16],
+            subbands=[4, 8],
+            allocation_methods=[
+                a2dp.SBC_LOUDNESS_ALLOCATION_METHOD,
+                a2dp.SBC_SNR_ALLOCATION_METHOD,
+            ],
+            minimum_bitpool_value=2,
+            maximum_bitpool_value=53,
+        ),
+    )
+
+
+# -----------------------------------------------------------------------------
+def on_avdtp_connection(server):
+    # Add a sink endpoint to the server
+    sink = server.add_sink(codec_capabilities())
+    sink.on('rtp_packet', on_rtp_packet)
+
+
+# -----------------------------------------------------------------------------
+def on_rtp_packet(packet):
+    print(f'RTP: {packet}')
+
+
+# -----------------------------------------------------------------------------
+def on_avrcp_start(avrcp_protocol: avrcp.Protocol, websocket_server: WebSocketServer):
+    async def get_supported_events():
+        events = await avrcp_protocol.get_supported_events()
+        print("SUPPORTED EVENTS:", events)
+        websocket_server.send_message(
+            {
+                "type": "supported-events",
+                "params": {"events": [event.name for event in events]},
+            }
+        )
+
+        if avrcp.EventId.TRACK_CHANGED in events:
+            utils.AsyncRunner.spawn(monitor_track_changed())
+
+        if avrcp.EventId.PLAYBACK_STATUS_CHANGED in events:
+            utils.AsyncRunner.spawn(monitor_playback_status())
+
+        if avrcp.EventId.PLAYBACK_POS_CHANGED in events:
+            utils.AsyncRunner.spawn(monitor_playback_position())
+
+        if avrcp.EventId.PLAYER_APPLICATION_SETTING_CHANGED in events:
+            utils.AsyncRunner.spawn(monitor_player_application_settings())
+
+        if avrcp.EventId.AVAILABLE_PLAYERS_CHANGED in events:
+            utils.AsyncRunner.spawn(monitor_available_players())
+
+        if avrcp.EventId.ADDRESSED_PLAYER_CHANGED in events:
+            utils.AsyncRunner.spawn(monitor_addressed_player())
+
+        if avrcp.EventId.UIDS_CHANGED in events:
+            utils.AsyncRunner.spawn(monitor_uids())
+
+        if avrcp.EventId.VOLUME_CHANGED in events:
+            utils.AsyncRunner.spawn(monitor_volume())
+
+    utils.AsyncRunner.spawn(get_supported_events())
+
+    async def monitor_track_changed():
+        async for identifier in avrcp_protocol.monitor_track_changed():
+            print("TRACK CHANGED:", identifier.hex())
+            websocket_server.send_message(
+                {"type": "track-changed", "params": {"identifier": identifier.hex()}}
+            )
+
+    async def monitor_playback_status():
+        async for playback_status in avrcp_protocol.monitor_playback_status():
+            print("PLAYBACK STATUS CHANGED:", playback_status.name)
+            websocket_server.send_message(
+                {
+                    "type": "playback-status-changed",
+                    "params": {"status": playback_status.name},
+                }
+            )
+
+    async def monitor_playback_position():
+        async for playback_position in avrcp_protocol.monitor_playback_position(
+            playback_interval=1
+        ):
+            print("PLAYBACK POSITION CHANGED:", playback_position)
+            websocket_server.send_message(
+                {
+                    "type": "playback-position-changed",
+                    "params": {"position": playback_position},
+                }
+            )
+
+    async def monitor_player_application_settings():
+        async for settings in avrcp_protocol.monitor_player_application_settings():
+            print("PLAYER APPLICATION SETTINGS:", settings)
+            settings_as_dict = [
+                {"attribute": setting.attribute_id.name, "value": setting.value_id.name}
+                for setting in settings
+            ]
+            websocket_server.send_message(
+                {
+                    "type": "player-settings-changed",
+                    "params": {"settings": settings_as_dict},
+                }
+            )
+
+    async def monitor_available_players():
+        async for _ in avrcp_protocol.monitor_available_players():
+            print("AVAILABLE PLAYERS CHANGED")
+            websocket_server.send_message(
+                {"type": "available-players-changed", "params": {}}
+            )
+
+    async def monitor_addressed_player():
+        async for player in avrcp_protocol.monitor_addressed_player():
+            print("ADDRESSED PLAYER CHANGED")
+            websocket_server.send_message(
+                {
+                    "type": "addressed-player-changed",
+                    "params": {
+                        "player": {
+                            "player_id": player.player_id,
+                            "uid_counter": player.uid_counter,
+                        }
+                    },
+                }
+            )
+
+    async def monitor_uids():
+        async for uid_counter in avrcp_protocol.monitor_uids():
+            print("UIDS CHANGED")
+            websocket_server.send_message(
+                {
+                    "type": "uids-changed",
+                    "params": {
+                        "uid_counter": uid_counter,
+                    },
+                }
+            )
+
+    async def monitor_volume():
+        async for volume in avrcp_protocol.monitor_volume():
+            print("VOLUME CHANGED:", volume)
+            websocket_server.send_message(
+                {"type": "volume-changed", "params": {"volume": volume}}
+            )
+
+
+# -----------------------------------------------------------------------------
+class WebSocketServer:
+    def __init__(
+        self, avrcp_protocol: avrcp.Protocol, avrcp_delegate: Delegate
+    ) -> None:
+        self.socket = None
+        self.delegate = None
+        self.avrcp_protocol = avrcp_protocol
+        self.avrcp_delegate = avrcp_delegate
+
+    async def start(self) -> None:
+        # pylint: disable-next=no-member
+        await websockets.serve(self.serve, 'localhost', 8989)  # type: ignore
+
+    async def serve(self, socket, _path) -> None:
+        print('### WebSocket connected')
+        self.socket = socket
+        while True:
+            try:
+                message = await socket.recv()
+                print('Received: ', str(message))
+
+                parsed = json.loads(message)
+                message_type = parsed['type']
+                if message_type == 'send-key-down':
+                    await self.on_send_key_down(parsed)
+                elif message_type == 'send-key-up':
+                    await self.on_send_key_up(parsed)
+                elif message_type == 'set-volume':
+                    await self.on_set_volume(parsed)
+                elif message_type == 'get-play-status':
+                    await self.on_get_play_status()
+                elif message_type == 'get-element-attributes':
+                    await self.on_get_element_attributes()
+            except websockets.exceptions.ConnectionClosedOK:
+                self.socket = None
+                break
+
+    async def on_send_key_down(self, message: dict) -> None:
+        key = avc.PassThroughFrame.OperationId[message["key"]]
+        await self.avrcp_protocol.send_key_event(key, True)
+
+    async def on_send_key_up(self, message: dict) -> None:
+        key = avc.PassThroughFrame.OperationId[message["key"]]
+        await self.avrcp_protocol.send_key_event(key, False)
+
+    async def on_set_volume(self, message: dict) -> None:
+        volume = message["volume"]
+        self.avrcp_delegate.volume = volume
+        self.avrcp_protocol.notify_volume_changed(volume)
+
+    async def on_get_play_status(self) -> None:
+        play_status = await self.avrcp_protocol.get_play_status()
+        self.send_message(
+            {
+                "type": "get-play-status-response",
+                "params": {
+                    "song_length": play_status.song_length,
+                    "song_position": play_status.song_position,
+                    "play_status": play_status.play_status.name,
+                },
+            }
+        )
+
+    async def on_get_element_attributes(self) -> None:
+        attributes = await self.avrcp_protocol.get_element_attributes(
+            0,
+            [
+                avrcp.MediaAttributeId.TITLE,
+                avrcp.MediaAttributeId.ARTIST_NAME,
+                avrcp.MediaAttributeId.ALBUM_NAME,
+                avrcp.MediaAttributeId.TRACK_NUMBER,
+                avrcp.MediaAttributeId.TOTAL_NUMBER_OF_TRACKS,
+                avrcp.MediaAttributeId.GENRE,
+                avrcp.MediaAttributeId.PLAYING_TIME,
+                avrcp.MediaAttributeId.DEFAULT_COVER_ART,
+            ],
+        )
+        self.send_message(
+            {
+                "type": "get-element-attributes-response",
+                "params": [
+                    {
+                        "attribute_id": attribute.attribute_id.name,
+                        "attribute_value": attribute.attribute_value,
+                    }
+                    for attribute in attributes
+                ],
+            }
+        )
+
+    def send_message(self, message: dict) -> None:
+        if self.socket is None:
+            print("no socket, dropping message")
+            return
+        serialized = json.dumps(message)
+        utils.AsyncRunner.spawn(self.socket.send(serialized))
+
+
+# -----------------------------------------------------------------------------
+class Delegate(avrcp.Delegate):
+    def __init__(self):
+        super().__init__(
+            [avrcp.EventId.VOLUME_CHANGED, avrcp.EventId.PLAYBACK_STATUS_CHANGED]
+        )
+        self.websocket_server = None
+
+    async def set_absolute_volume(self, volume: int) -> None:
+        await super().set_absolute_volume(volume)
+        if self.websocket_server is not None:
+            self.websocket_server.send_message(
+                {"type": "set-volume", "params": {"volume": volume}}
+            )
+
+
+# -----------------------------------------------------------------------------
+async def main():
+    if len(sys.argv) < 3:
+        print(
+            'Usage: run_avrcp_controller.py <device-config> <transport-spec> '
+            '<sbc-file> [<bt-addr>]'
+        )
+        print('example: run_avrcp_controller.py classic1.json usb:0')
+        return
+
+    print('<<< connecting to HCI...')
+    async with await open_transport_or_link(sys.argv[2]) as (hci_source, hci_sink):
+        print('<<< connected')
+
+        # Create a device
+        device = Device.from_config_file_with_hci(sys.argv[1], hci_source, hci_sink)
+        device.classic_enabled = True
+
+        # Setup the SDP to expose the sink service
+        device.sdp_service_records = sdp_records()
+
+        # Start the controller
+        await device.power_on()
+
+        # Create a listener to wait for AVDTP connections
+        listener = avdtp.Listener(avdtp.Listener.create_registrar(device))
+        listener.on('connection', on_avdtp_connection)
+
+        avrcp_delegate = Delegate()
+        avrcp_protocol = avrcp.Protocol(avrcp_delegate)
+        avrcp_protocol.listen(device)
+
+        websocket_server = WebSocketServer(avrcp_protocol, avrcp_delegate)
+        avrcp_delegate.websocket_server = websocket_server
+        avrcp_protocol.on(
+            "start", lambda: on_avrcp_start(avrcp_protocol, websocket_server)
+        )
+        await websocket_server.start()
+
+        if len(sys.argv) >= 5:
+            # Connect to the peer
+            target_address = sys.argv[4]
+            print(f'=== Connecting to {target_address}...')
+            connection = await device.connect(
+                target_address, transport=BT_BR_EDR_TRANSPORT
+            )
+            print(f'=== Connected to {connection.peer_address}!')
+
+            # Request authentication
+            print('*** Authenticating...')
+            await connection.authenticate()
+            print('*** Authenticated')
+
+            # Enable encryption
+            print('*** Enabling encryption...')
+            await connection.encrypt()
+            print('*** Encryption on')
+
+            server = await avdtp.Protocol.connect(connection)
+            listener.set_server(connection, server)
+            sink = server.add_sink(codec_capabilities())
+            sink.on('rtp_packet', on_rtp_packet)
+
+            await avrcp_protocol.connect(connection)
+
+        else:
+            # Start being discoverable and connectable
+            await device.set_discoverable(True)
+            await device.set_connectable(True)
+
+        await asyncio.get_event_loop().create_future()
+
+
+# -----------------------------------------------------------------------------
+logging.basicConfig(level=os.environ.get('BUMBLE_LOGLEVEL', 'DEBUG').upper())
+asyncio.run(main())

extras/android/BtBench/app/src/main/AndroidManifest.xml

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:tools="http://schemas.android.com/tools">
-
+    package="com.github.google.bumble.btbench">
+     <uses-sdk android:minSdkVersion="30" android:targetSdkVersion="34" />
     <!-- Request legacy Bluetooth permissions on older devices. -->
     <uses-permission android:name="android.permission.BLUETOOTH" android:maxSdkVersion="30" />
     <uses-permission android:name="android.permission.BLUETOOTH_ADMIN" android:maxSdkVersion="30" />
@@ -22,11 +22,10 @@
         android:roundIcon="@mipmap/ic_launcher_round"
         android:supportsRtl="true"
         android:theme="@style/Theme.BTBench"
-        tools:targetApi="31">
+        >
         <activity
             android:name=".MainActivity"
             android:exported="true"
-            android:label="@string/app_name"
             android:theme="@style/Theme.BTBench">
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />

setup.cfg

@@ -59,6 +59,7 @@ console_scripts =
     bumble-ble-rpa-tool = bumble.apps.ble_rpa_tool:main
     bumble-console = bumble.apps.console:main
     bumble-controller-info = bumble.apps.controller_info:main
+    bumble-controller-loopback = bumble.apps.controller_loopback:main
     bumble-gatt-dump = bumble.apps.gatt_dump:main
     bumble-hci-bridge = bumble.apps.hci_bridge:main
     bumble-l2cap-bridge = bumble.apps.l2cap_bridge:main
@@ -81,15 +82,15 @@ console_scripts =
 build =
     build >= 0.7
 test =
-    pytest >= 6.2
-    pytest-asyncio >= 0.17
+    pytest >= 8.0
+    pytest-asyncio == 0.21.1
     pytest-html >= 3.2.0
     coverage >= 6.4
 development =
     black == 22.10
     grpcio-tools >= 1.57.0
     invoke >= 1.7.3
-    mypy == 1.5.0
+    mypy == 1.8.0
     nox >= 2022
     pylint == 2.15.8
     pyyaml >= 6.0
@@ -98,7 +99,7 @@ development =
     types-protobuf >= 4.21.0
 avatar =
     pandora-avatar == 0.0.5
-    rootcanal == 1.3.0 ; python_version>='3.10'
+    rootcanal == 1.6.0 ; python_version>='3.10'
 documentation =
     mkdocs >= 1.4.0
     mkdocs-material >= 8.5.6

tests/avrcp_test.py

@@ -0,0 +1,246 @@
+# Copyright 2023 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import asyncio
+import struct
+
+import pytest
+
+from bumble import core
+from bumble import device
+from bumble import host
+from bumble import controller
+from bumble import link
+from bumble import avc
+from bumble import avrcp
+from bumble import avctp
+from bumble.transport import common
+
+
+# -----------------------------------------------------------------------------
+class TwoDevices:
+    def __init__(self):
+        self.connections = [None, None]
+
+        addresses = ['F0:F1:F2:F3:F4:F5', 'F5:F4:F3:F2:F1:F0']
+        self.link = link.LocalLink()
+        self.controllers = [
+            controller.Controller('C1', link=self.link, public_address=addresses[0]),
+            controller.Controller('C2', link=self.link, public_address=addresses[1]),
+        ]
+        self.devices = [
+            device.Device(
+                address=addresses[0],
+                host=host.Host(
+                    self.controllers[0], common.AsyncPipeSink(self.controllers[0])
+                ),
+            ),
+            device.Device(
+                address=addresses[1],
+                host=host.Host(
+                    self.controllers[1], common.AsyncPipeSink(self.controllers[1])
+                ),
+            ),
+        ]
+        self.devices[0].classic_enabled = True
+        self.devices[1].classic_enabled = True
+        self.connections = [None, None]
+        self.protocols = [None, None]
+
+    def on_connection(self, which, connection):
+        self.connections[which] = connection
+
+    async def setup_connections(self):
+        await self.devices[0].power_on()
+        await self.devices[1].power_on()
+
+        self.connections = await asyncio.gather(
+            self.devices[0].connect(
+                self.devices[1].public_address, core.BT_BR_EDR_TRANSPORT
+            ),
+            self.devices[1].accept(self.devices[0].public_address),
+        )
+
+        self.protocols = [avrcp.Protocol(), avrcp.Protocol()]
+        self.protocols[0].listen(self.devices[1])
+        await self.protocols[1].connect(self.connections[0])
+
+
+# -----------------------------------------------------------------------------
+def test_frame_parser():
+    with pytest.raises(ValueError) as error:
+        avc.Frame.from_bytes(bytes.fromhex("11480000"))
+
+    x = bytes.fromhex("014D0208")
+    frame = avc.Frame.from_bytes(x)
+    assert frame.subunit_type == avc.Frame.SubunitType.PANEL
+    assert frame.subunit_id == 7
+    assert frame.opcode == 8
+
+    x = bytes.fromhex("014DFF0108")
+    frame = avc.Frame.from_bytes(x)
+    assert frame.subunit_type == avc.Frame.SubunitType.PANEL
+    assert frame.subunit_id == 260
+    assert frame.opcode == 8
+
+    x = bytes.fromhex("0148000019581000000103")
+
+    frame = avc.Frame.from_bytes(x)
+
+    assert isinstance(frame, avc.CommandFrame)
+    assert frame.ctype == avc.CommandFrame.CommandType.STATUS
+    assert frame.subunit_type == avc.Frame.SubunitType.PANEL
+    assert frame.subunit_id == 0
+    assert frame.opcode == 0
+
+
+# -----------------------------------------------------------------------------
+def test_vendor_dependent_command():
+    x = bytes.fromhex("0148000019581000000103")
+    frame = avc.Frame.from_bytes(x)
+    assert isinstance(frame, avc.VendorDependentCommandFrame)
+    assert frame.company_id == 0x1958
+    assert frame.vendor_dependent_data == bytes.fromhex("1000000103")
+
+    frame = avc.VendorDependentCommandFrame(
+        avc.CommandFrame.CommandType.STATUS,
+        avc.Frame.SubunitType.PANEL,
+        0,
+        0x1958,
+        bytes.fromhex("1000000103"),
+    )
+    assert bytes(frame) == x
+
+
+# -----------------------------------------------------------------------------
+def test_avctp_message_assembler():
+    received_message = []
+
+    def on_message(transaction_label, is_response, ipid, pid, payload):
+        received_message.append((transaction_label, is_response, ipid, pid, payload))
+
+    assembler = avctp.MessageAssembler(on_message)
+
+    payload = bytes.fromhex("01")
+    assembler.on_pdu(bytes([1 << 4 | 0b00 << 2 | 1 << 1 | 0, 0x11, 0x22]) + payload)
+    assert received_message
+    assert received_message[0] == (1, False, False, 0x1122, payload)
+
+    received_message = []
+    payload = bytes.fromhex("010203")
+    assembler.on_pdu(bytes([1 << 4 | 0b01 << 2 | 1 << 1 | 0, 0x11, 0x22]) + payload)
+    assert len(received_message) == 0
+    assembler.on_pdu(bytes([1 << 4 | 0b00 << 2 | 1 << 1 | 0, 0x11, 0x22]) + payload)
+    assert received_message
+    assert received_message[0] == (1, False, False, 0x1122, payload)
+
+    received_message = []
+    payload = bytes.fromhex("010203")
+    assembler.on_pdu(
+        bytes([1 << 4 | 0b01 << 2 | 1 << 1 | 0, 3, 0x11, 0x22]) + payload[0:1]
+    )
+    assembler.on_pdu(
+        bytes([1 << 4 | 0b10 << 2 | 1 << 1 | 0, 0x11, 0x22]) + payload[1:2]
+    )
+    assembler.on_pdu(
+        bytes([1 << 4 | 0b11 << 2 | 1 << 1 | 0, 0x11, 0x22]) + payload[2:3]
+    )
+    assert received_message
+    assert received_message[0] == (1, False, False, 0x1122, payload)
+
+    # received_message = []
+    # parameter = bytes.fromhex("010203")
+    # assembler.on_pdu(struct.pack(">BBH", 0x10, 0b11, len(parameter)) + parameter)
+    # assert len(received_message) == 0
+
+
+# -----------------------------------------------------------------------------
+def test_avrcp_pdu_assembler():
+    received_pdus = []
+
+    def on_pdu(pdu_id, parameter):
+        received_pdus.append((pdu_id, parameter))
+
+    assembler = avrcp.PduAssembler(on_pdu)
+
+    parameter = bytes.fromhex("01")
+    assembler.on_pdu(struct.pack(">BBH", 0x10, 0b00, len(parameter)) + parameter)
+    assert received_pdus
+    assert received_pdus[0] == (0x10, parameter)
+
+    received_pdus = []
+    parameter = bytes.fromhex("010203")
+    assembler.on_pdu(struct.pack(">BBH", 0x10, 0b01, len(parameter)) + parameter)
+    assert len(received_pdus) == 0
+    assembler.on_pdu(struct.pack(">BBH", 0x10, 0b00, len(parameter)) + parameter)
+    assert received_pdus
+    assert received_pdus[0] == (0x10, parameter)
+
+    received_pdus = []
+    parameter = bytes.fromhex("010203")
+    assembler.on_pdu(struct.pack(">BBH", 0x10, 0b01, 1) + parameter[0:1])
+    assembler.on_pdu(struct.pack(">BBH", 0x10, 0b10, 1) + parameter[1:2])
+    assembler.on_pdu(struct.pack(">BBH", 0x10, 0b11, 1) + parameter[2:3])
+    assert received_pdus
+    assert received_pdus[0] == (0x10, parameter)
+
+    received_pdus = []
+    parameter = bytes.fromhex("010203")
+    assembler.on_pdu(struct.pack(">BBH", 0x10, 0b11, len(parameter)) + parameter)
+    assert len(received_pdus) == 0
+
+
+def test_passthrough_commands():
+    play_pressed = avc.PassThroughCommandFrame(
+        avc.CommandFrame.CommandType.CONTROL,
+        avc.CommandFrame.SubunitType.PANEL,
+        0,
+        avc.PassThroughCommandFrame.StateFlag.PRESSED,
+        avc.PassThroughCommandFrame.OperationId.PLAY,
+        b'',
+    )
+
+    play_pressed_bytes = bytes(play_pressed)
+    parsed = avc.Frame.from_bytes(play_pressed_bytes)
+    assert isinstance(parsed, avc.PassThroughCommandFrame)
+    assert parsed.operation_id == avc.PassThroughCommandFrame.OperationId.PLAY
+    assert bytes(parsed) == play_pressed_bytes
+
+
+# -----------------------------------------------------------------------------
+@pytest.mark.asyncio
+async def test_get_supported_events():
+    two_devices = TwoDevices()
+    await two_devices.setup_connections()
+
+    supported_events = await two_devices.protocols[0].get_supported_events()
+    assert supported_events == []
+
+    delegate1 = avrcp.Delegate([avrcp.EventId.VOLUME_CHANGED])
+    two_devices.protocols[0].delegate = delegate1
+    supported_events = await two_devices.protocols[1].get_supported_events()
+    assert supported_events == [avrcp.EventId.VOLUME_CHANGED]
+
+
+# -----------------------------------------------------------------------------
+if __name__ == '__main__':
+    test_frame_parser()
+    test_vendor_dependent_command()
+    test_avctp_message_assembler()
+    test_avrcp_pdu_assembler()
+    test_passthrough_commands()
+    test_get_supported_events()

tests/device_test.py

@@ -423,6 +423,54 @@ async def test_get_remote_le_features():
     assert (await devices.connections[0].get_remote_le_features()) is not None
 
 
+# -----------------------------------------------------------------------------
+@pytest.mark.asyncio
+async def test_cis():
+    devices = TwoDevices()
+    await devices.setup_connection()
+
+    peripheral_cis_futures = {}
+
+    def on_cis_request(
+        acl_connection: Connection,
+        cis_handle: int,
+        _cig_id: int,
+        _cis_id: int,
+    ):
+        acl_connection.abort_on(
+            'disconnection', devices[1].accept_cis_request(cis_handle)
+        )
+        peripheral_cis_futures[cis_handle] = asyncio.get_running_loop().create_future()
+
+    devices[1].on('cis_request', on_cis_request)
+    devices[1].on(
+        'cis_establishment',
+        lambda cis_link: peripheral_cis_futures[cis_link.handle].set_result(None),
+    )
+
+    cis_handles = await devices[0].setup_cig(
+        cig_id=1,
+        cis_id=[2, 3],
+        sdu_interval=(0, 0),
+        framing=0,
+        max_sdu=(0, 0),
+        retransmission_number=0,
+        max_transport_latency=(0, 0),
+    )
+    assert len(cis_handles) == 2
+    cis_links = await devices[0].create_cis(
+        [
+            (cis_handles[0], devices.connections[0].handle),
+            (cis_handles[1], devices.connections[0].handle),
+        ]
+    )
+    await asyncio.gather(*peripheral_cis_futures.values())
+    assert len(cis_links) == 2
+
+    await cis_links[0].disconnect()
+    await cis_links[1].disconnect()
+
+
 # -----------------------------------------------------------------------------
 def test_gatt_services_with_gas():
     device = Device(host=Host(None, None))

tests/hfp_test.py

@@ -24,11 +24,11 @@ from typing import Tuple
 
 from .test_utils import TwoDevices
 from bumble import core
-from bumble import device
 from bumble import hfp
 from bumble import rfcomm
 from bumble import hci
 
+
 # -----------------------------------------------------------------------------
 # Logging
 # -----------------------------------------------------------------------------
@@ -109,7 +109,7 @@ async def test_sco_setup():
         devices[1].accept(devices[0].public_address),
     )
 
-    def on_sco_request(_connection: device.Connection, _link_type: int):
+    def on_sco_request(_connection, _link_type: int):
         connections[1].abort_on(
             'disconnection',
             devices[1].send_command(
@@ -124,17 +124,13 @@ async def test_sco_setup():
 
     devices[1].on('sco_request', on_sco_request)
 
-    sco_connections = [
+    sco_connection_futures = [
         asyncio.get_running_loop().create_future(),
         asyncio.get_running_loop().create_future(),
     ]
 
-    devices[0].on(
-        'sco_connection', lambda sco_link: sco_connections[0].set_result(sco_link)
-    )
-    devices[1].on(
-        'sco_connection', lambda sco_link: sco_connections[1].set_result(sco_link)
-    )
+    for device, future in zip(devices, sco_connection_futures):
+        device.on('sco_connection', future.set_result)
 
     await devices[0].send_command(
         hci.HCI_Enhanced_Setup_Synchronous_Connection_Command(
@@ -142,8 +138,17 @@ async def test_sco_setup():
             **hfp.ESCO_PARAMETERS[hfp.DefaultCodecParameters.ESCO_CVSD_S1].asdict(),
         )
     )
+    sco_connections = await asyncio.gather(*sco_connection_futures)
 
-    await asyncio.gather(*sco_connections)
+    sco_disconnection_futures = [
+        asyncio.get_running_loop().create_future(),
+        asyncio.get_running_loop().create_future(),
+    ]
+    for future, sco_connection in zip(sco_disconnection_futures, sco_connections):
+        sco_connection.on('disconnection', future.set_result)
+
+    await sco_connections[0].disconnect()
+    await asyncio.gather(*sco_disconnection_futures)
 
 
 # -----------------------------------------------------------------------------

tests/rfcomm_test.py

@@ -15,7 +15,11 @@
 # -----------------------------------------------------------------------------
 # Imports
 # -----------------------------------------------------------------------------
-from bumble.rfcomm import RFCOMM_Frame
+import asyncio
+import pytest
+
+from . import test_utils
+from bumble.rfcomm import RFCOMM_Frame, Server, Client, DLC
 
 
 # -----------------------------------------------------------------------------
@@ -43,6 +47,29 @@ def test_frames():
     basic_frame_check(frame)
 
 
+# -----------------------------------------------------------------------------
+@pytest.mark.asyncio
+async def test_basic_connection():
+    devices = test_utils.TwoDevices()
+    await devices.setup_connection()
+
+    accept_future: asyncio.Future[DLC] = asyncio.get_running_loop().create_future()
+    channel = Server(devices[0]).listen(acceptor=accept_future.set_result)
+
+    multiplexer = await Client(devices.connections[1]).start()
+    dlcs = await asyncio.gather(accept_future, multiplexer.open_dlc(channel))
+
+    queues = [asyncio.Queue(), asyncio.Queue()]
+    for dlc, queue in zip(dlcs, queues):
+        dlc.sink = queue.put_nowait
+
+    dlcs[0].write(b'The quick brown fox jumps over the lazy dog')
+    assert await queues[1].get() == b'The quick brown fox jumps over the lazy dog'
+
+    dlcs[1].write(b'Lorem ipsum dolor sit amet')
+    assert await queues[0].get() == b'Lorem ipsum dolor sit amet'
+
+
 # -----------------------------------------------------------------------------
 if __name__ == '__main__':
     test_frames()

tests/self_test.py

@@ -547,6 +547,13 @@ async def test_self_smp_over_classic():
         MockSmpSession.send_public_key_command.assert_not_called()
         MockSmpSession.send_pairing_random_command.assert_not_called()
 
+    for i in range(2):
+        assert (
+            await two_devices.devices[i].keystore.get(
+                str(two_devices.connections[i].peer_address)
+            )
+        ).link_key
+
 
 # -----------------------------------------------------------------------------
 @pytest.mark.asyncio

tests/utils_test.py

@@ -12,15 +12,20 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
 import contextlib
 import logging
 import os
-
-from bumble import utils
-from pyee import EventEmitter
 from unittest.mock import MagicMock
 
+from pyee import EventEmitter
 
+from bumble import utils
+
+
+# -----------------------------------------------------------------------------
 def test_on() -> None:
     emitter = EventEmitter()
     with contextlib.closing(utils.EventWatcher()) as context:
@@ -33,6 +38,7 @@ def test_on() -> None:
     assert mock.call_count == 1
 
 
+# -----------------------------------------------------------------------------
 def test_on_decorator() -> None:
     emitter = EventEmitter()
     with contextlib.closing(utils.EventWatcher()) as context:
@@ -48,6 +54,7 @@ def test_on_decorator() -> None:
     assert mock.call_count == 1
 
 
+# -----------------------------------------------------------------------------
 def test_multiple_handlers() -> None:
     emitter = EventEmitter()
     with contextlib.closing(utils.EventWatcher()) as context:
@@ -64,6 +71,30 @@ def test_multiple_handlers() -> None:
     mock.assert_called_once_with('b')
 
 
+# -----------------------------------------------------------------------------
+def test_open_int_enums():
+    class Foo(utils.OpenIntEnum):
+        FOO = 1
+        BAR = 2
+        BLA = 3
+
+    x = Foo(1)
+    assert x.name == "FOO"
+    assert x.value == 1
+    assert int(x) == 1
+    assert x == 1
+    assert x + 1 == 2
+
+    x = Foo(4)
+    assert x.name == "Foo[4]"
+    assert x.value == 4
+    assert int(x) == 4
+    assert x == 4
+    assert x + 1 == 5
+
+    print(list(Foo))
+
+
 # -----------------------------------------------------------------------------
 def run_tests():
     test_on()
@@ -75,3 +106,4 @@ def run_tests():
 if __name__ == '__main__':
     logging.basicConfig(level=os.environ.get('BUMBLE_LOGLEVEL', 'INFO').upper())
     run_tests()
+    test_open_int_enums()