use TCP_NODELAY on socket

Co-authored-by: zxzxwu <92432172+zxzxwu@users.noreply.github.com>

apps/bench.py

@@ -82,10 +82,11 @@ SPEED_RX_UUID = '016A2CC7-E14B-4819-935F-1F56EAE4098D'
 DEFAULT_RFCOMM_UUID = 'E6D55659-C8B4-4B85-96BB-B1143AF6D3AE'
 DEFAULT_L2CAP_PSM = 1234
 DEFAULT_L2CAP_MAX_CREDITS = 128
-DEFAULT_L2CAP_MTU = 1022
-DEFAULT_L2CAP_MPS = 1024
+DEFAULT_L2CAP_MTU = 1024
+DEFAULT_L2CAP_MPS = 1022
 
 DEFAULT_LINGER_TIME = 1.0
+DEFAULT_POST_CONNECTION_WAIT_TIME = 1.0
 
 DEFAULT_RFCOMM_CHANNEL = 8
 
@@ -952,6 +953,10 @@ class Central(Connection.Listener):
 
             await self.device.power_on()
 
+            if self.classic:
+                await self.device.set_discoverable(False)
+                await self.device.set_connectable(False)
+
             print(color(f'### Connecting to {self.peripheral_address}...', 'cyan'))
             try:
                 self.connection = await self.device.connect(
@@ -972,6 +977,11 @@ class Central(Connection.Listener):
             self.connection.listener = self
             print_connection(self.connection)
 
+            # Wait a bit after the connection, some controllers aren't very good when
+            # we start sending data right away while some connection parameters are
+            # updated post connection
+            await asyncio.sleep(DEFAULT_POST_CONNECTION_WAIT_TIME)
+
             # Request a new data length if requested
             if self.extended_data_length:
                 print(color('+++ Requesting extended data length', 'cyan'))
@@ -1098,6 +1108,15 @@ class Peripheral(Device.Listener, Connection.Listener):
         self.connection = connection
         self.connected.set()
 
+        # Stop being discoverable and connectable
+        if self.classic:
+
+            async def stop_being_discoverable_connectable():
+                await self.device.set_discoverable(False)
+                await self.device.set_connectable(False)
+
+            AsyncRunner.spawn(stop_being_discoverable_connectable())
+
         # Request a new data length if needed
         if self.extended_data_length:
             print("+++ Requesting extended data length")

apps/ble_rpa_tool.py

@@ -1,63 +0,0 @@
-# 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.
-
-import click
-from bumble.colors import color
-from bumble.hci import Address
-from bumble.helpers import generate_irk, verify_rpa_with_irk
-
-
-@click.group()
-def cli():
-    '''
-    This is a tool for generating IRK, RPA,
-    and verifying IRK/RPA pairs
-    '''
-
-
-@click.command()
-def gen_irk() -> None:
-    print(generate_irk().hex())
-
-
-@click.command()
-@click.argument("irk", type=str)
-def gen_rpa(irk: str) -> None:
-    irk_bytes = bytes.fromhex(irk)
-    rpa = Address.generate_private_address(irk_bytes)
-    print(rpa.to_string(with_type_qualifier=False))
-
-
-@click.command()
-@click.argument("irk", type=str)
-@click.argument("rpa", type=str)
-def verify_rpa(irk: str, rpa: str) -> None:
-    address = Address(rpa)
-    irk_bytes = bytes.fromhex(irk)
-    if verify_rpa_with_irk(address, irk_bytes):
-        print(color("Verified", "green"))
-    else:
-        print(color("Not Verified", "red"))
-
-
-def main():
-    cli.add_command(gen_irk)
-    cli.add_command(gen_rpa)
-    cli.add_command(verify_rpa)
-    cli()
-
-
-# -----------------------------------------------------------------------------
-if __name__ == '__main__':
-    main()

apps/controller_info.py

@@ -24,10 +24,6 @@ from bumble.company_ids import COMPANY_IDENTIFIERS
 from bumble.colors import color
 from bumble.core import name_or_number
 from bumble.hci import (
-    HCI_READ_LOCAL_EXTENDED_FEATURES_COMMAND,
-    HCI_READ_LOCAL_SUPPORTED_FEATURES_COMMAND,
-    HCI_Read_Local_Extended_Features_Command,
-    HCI_Read_Local_Supported_Features_Command,
     map_null_terminated_utf8_string,
     HCI_SUCCESS,
     HCI_LE_SUPPORTED_FEATURES_NAMES,
@@ -36,10 +32,14 @@ from bumble.hci import (
     HCI_Command,
     HCI_Command_Complete_Event,
     HCI_Command_Status_Event,
+    HCI_READ_BUFFER_SIZE_COMMAND,
+    HCI_Read_Buffer_Size_Command,
     HCI_READ_BD_ADDR_COMMAND,
     HCI_Read_BD_ADDR_Command,
     HCI_READ_LOCAL_NAME_COMMAND,
     HCI_Read_Local_Name_Command,
+    HCI_LE_READ_BUFFER_SIZE_COMMAND,
+    HCI_LE_Read_Buffer_Size_Command,
     HCI_LE_READ_MAXIMUM_DATA_LENGTH_COMMAND,
     HCI_LE_Read_Maximum_Data_Length_Command,
     HCI_LE_READ_NUMBER_OF_SUPPORTED_ADVERTISING_SETS_COMMAND,
@@ -63,37 +63,7 @@ def command_succeeded(response):
 
 
 # -----------------------------------------------------------------------------
-async def get_common_info(host):
-    if host.supports_command(HCI_READ_LOCAL_SUPPORTED_FEATURES_COMMAND):
-        response = await host.send_command(HCI_Read_Local_Supported_Features_Command())
-        if response.return_parameters.status == HCI_SUCCESS:
-            print()
-            print(color('LMP Features:', 'yellow'))
-            # TODO: support printing discrete enum values
-            print('  ', response.return_parameters.lmp_features.hex())
-
-    if host.supports_command(HCI_READ_LOCAL_EXTENDED_FEATURES_COMMAND):
-        response = await host.send_command(
-            HCI_Read_Local_Extended_Features_Command(page_number=0)
-        )
-        if response.return_parameters.status == HCI_SUCCESS:
-            if response.return_parameters.max_page_number > 0:
-                print()
-                print(color('Extended LMP Features:', 'yellow'))
-
-            for page in range(1, response.return_parameters.max_page_number + 1):
-                response = await host.send_command(
-                    HCI_Read_Local_Extended_Features_Command(page_number=page)
-                )
-
-                if response.return_parameters.status == HCI_SUCCESS:
-                    # TODO: support printing discrete enum values
-                    print(f'  Page {page}:')
-                    print('  ', response.return_parameters.extended_lmp_features.hex())
-
-
-# -----------------------------------------------------------------------------
-async def get_classic_info(host):
+async def get_classic_info(host: Host) -> None:
     if host.supports_command(HCI_READ_BD_ADDR_COMMAND):
         response = await host.send_command(HCI_Read_BD_ADDR_Command())
         if command_succeeded(response):
@@ -114,7 +84,7 @@ async def get_classic_info(host):
 
 
 # -----------------------------------------------------------------------------
-async def get_le_info(host):
+async def get_le_info(host: Host) -> None:
     print()
 
     if host.supports_command(HCI_LE_READ_NUMBER_OF_SUPPORTED_ADVERTISING_SETS_COMMAND):
@@ -170,6 +140,31 @@ async def get_le_info(host):
         print('  ', name_or_number(HCI_LE_SUPPORTED_FEATURES_NAMES, feature))
 
 
+# -----------------------------------------------------------------------------
+async def get_acl_flow_control_info(host: Host) -> None:
+    print()
+
+    if host.supports_command(HCI_READ_BUFFER_SIZE_COMMAND):
+        response = await host.send_command(
+            HCI_Read_Buffer_Size_Command(), check_result=True
+        )
+        print(
+            color('ACL Flow Control:', 'yellow'),
+            f'{response.return_parameters.hc_total_num_acl_data_packets} '
+            f'packets of size {response.return_parameters.hc_acl_data_packet_length}',
+        )
+
+    if host.supports_command(HCI_LE_READ_BUFFER_SIZE_COMMAND):
+        response = await host.send_command(
+            HCI_LE_Read_Buffer_Size_Command(), check_result=True
+        )
+        print(
+            color('LE ACL Flow Control:', 'yellow'),
+            f'{response.return_parameters.hc_total_num_le_acl_data_packets} '
+            f'packets of size {response.return_parameters.hc_le_acl_data_packet_length}',
+        )
+
+
 # -----------------------------------------------------------------------------
 async def async_main(transport):
     print('<<< connecting to HCI...')
@@ -196,15 +191,15 @@ async def async_main(transport):
         )
         print(color('  LMP Subversion:', 'green'), host.local_version.lmp_subversion)
 
-        # Get the common info
-        await get_common_info(host)
-
         # Get the Classic info
         await get_classic_info(host)
 
         # Get the LE info
         await get_le_info(host)
 
+        # Print the ACL flow control info
+        await get_acl_flow_control_info(host)
+
         # Print the list of commands supported by the controller
         print()
         print(color('Supported Commands:', 'yellow'))

apps/controllers.py

@@ -17,25 +17,31 @@
 # -----------------------------------------------------------------------------
 import logging
 import asyncio
+import sys
 import os
 
-import click
-
-from bumble.controller import Controller, Options
+from bumble.controller import Controller
 from bumble.link import LocalLink
 from bumble.transport import open_transport_or_link
 
 
 # -----------------------------------------------------------------------------
-async def async_main(extended_advertising, transport_names):
+async def async_main():
+    if len(sys.argv) != 3:
+        print(
+            'Usage: controllers.py <hci-transport-1> <hci-transport-2> '
+            '[<hci-transport-3> ...]'
+        )
+        print('example: python controllers.py pty:ble1 pty:ble2')
+        return
+
     # Create a local link to attach the controllers to
     link = LocalLink()
 
     # Create a transport and controller for all requested names
     transports = []
     controllers = []
-    options = Options(extended_advertising=extended_advertising)
-    for index, transport_name in enumerate(transport_names):
+    for index, transport_name in enumerate(sys.argv[1:]):
         transport = await open_transport_or_link(transport_name)
         transports.append(transport)
         controller = Controller(
@@ -43,7 +49,6 @@ async def async_main(extended_advertising, transport_names):
             host_source=transport.source,
             host_sink=transport.sink,
             link=link,
-            options=options,
         )
         controllers.append(controller)
 
@@ -56,14 +61,9 @@ async def async_main(extended_advertising, transport_names):
 
 
 # -----------------------------------------------------------------------------
-@click.command()
-@click.option(
-    '--extended-advertising', is_flag=True, help="Enable extended advertising"
-)
-@click.argument('transports', nargs=-1, required=True)
-def main(extended_advertising, transports):
-    logging.basicConfig(level=os.environ.get('BUMBLE_LOGLEVEL', 'WARNING').upper())
-    asyncio.run(async_main(extended_advertising, transports))
+def main():
+    logging.basicConfig(level=os.environ.get('BUMBLE_LOGLEVEL', 'INFO').upper())
+    asyncio.run(async_main())
 
 
 # -----------------------------------------------------------------------------

apps/link_relay/link_relay.py

@@ -253,7 +253,7 @@ class Relay:
 
 
 # ----------------------------------------------------------------------------
-async def async_main():
+def main():
     # Check the Python version
     if sys.version_info < (3, 6, 1):
         print('ERROR: Python 3.6.1 or higher is required')
@@ -280,13 +280,8 @@ async def async_main():
 
     # Start a relay
     relay = Relay(args.port)
-    async with relay.start():
-        await asyncio.Future()
-
-
-# ----------------------------------------------------------------------------
-def main():
-    asyncio.run(async_main())
+    asyncio.get_event_loop().run_until_complete(relay.start())
+    asyncio.get_event_loop().run_forever()
 
 
 # ----------------------------------------------------------------------------

apps/pair.py

@@ -52,13 +52,11 @@ from bumble.att import (
 class Waiter:
     instance = None
 
-    def __init__(self, linger=False):
+    def __init__(self):
         self.done = asyncio.get_running_loop().create_future()
-        self.linger = linger
 
     def terminate(self):
-        if not self.linger:
-            self.done.set_result(None)
+        self.done.set_result(None)
 
     async def wait_until_terminated(self):
         return await self.done
@@ -304,7 +302,7 @@ async def pair(
     hci_transport,
     address_or_name,
 ):
-    Waiter.instance = Waiter(linger=linger)
+    Waiter.instance = Waiter()
 
     print('<<< connecting to HCI...')
     async with await open_transport_or_link(hci_transport) as (hci_source, hci_sink):
@@ -398,6 +396,7 @@ async def pair(
                 address_or_name,
                 transport=BT_LE_TRANSPORT if mode == 'le' else BT_BR_EDR_TRANSPORT,
             )
+            pairing_failure = False
 
             if not request:
                 try:
@@ -406,8 +405,11 @@ async def pair(
                     else:
                         await connection.authenticate()
                 except ProtocolError as error:
+                    pairing_failure = True
                     print(color(f'Pairing failed: {error}', 'red'))
 
+            if not linger or pairing_failure:
+                return
         else:
             if mode == 'le':
                 # Advertise so that peers can find us and connect
@@ -457,7 +459,7 @@ class LogHandler(logging.Handler):
     help='Enable CTKD',
     show_default=True,
 )
-@click.option('--linger', default=False, is_flag=True, help='Linger after pairing')
+@click.option('--linger', default=True, is_flag=True, help='Linger after pairing')
 @click.option(
     '--io',
     type=click.Choice(

bumble/crypto.py

@@ -100,16 +100,6 @@ class EccKey:
 # -----------------------------------------------------------------------------
 
 
-# -----------------------------------------------------------------------------
-def generate_prand() -> bytes:
-    '''Generates random 3 bytes, with the 2 most significant bits of 0b01.
-
-    See Bluetooth spec, Vol 6, Part E - Table 1.2.
-    '''
-    prand_bytes = secrets.token_bytes(6)
-    return prand_bytes[:2] + bytes([(prand_bytes[2] & 0b01111111) | 0b01000000])
-
-
 # -----------------------------------------------------------------------------
 def xor(x: bytes, y: bytes) -> bytes:
     assert len(x) == len(y)

bumble/gatt.py

@@ -368,12 +368,9 @@ class TemplateService(Service):
     UUID: UUID
 
     def __init__(
-        self,
-        characteristics: List[Characteristic],
-        primary: bool = True,
-        included_services: List[Service] = [],
+        self, characteristics: List[Characteristic], primary: bool = True
     ) -> None:
-        super().__init__(self.UUID, characteristics, primary, included_services)
+        super().__init__(self.UUID, characteristics, primary)
 
 
 # -----------------------------------------------------------------------------

bumble/hci.py

@@ -21,11 +21,9 @@ import dataclasses
 import enum
 import functools
 import logging
-import secrets
 import struct
 from typing import Any, Dict, Callable, Optional, Type, Union, List
 
-from bumble import crypto
 from .colors import color
 from .core import (
     BT_BR_EDR_TRANSPORT,
@@ -1883,43 +1881,6 @@ class Address:
         address_type = data[offset - 1]
         return Address.parse_address_with_type(data, offset, address_type)
 
-    @classmethod
-    def generate_static_address(cls) -> Address:
-        '''Generates Random Static Address, with the 2 most significant bits of 0b11.
-
-        See Bluetooth spec, Vol 6, Part B - Table 1.2.
-        '''
-        address_bytes = secrets.token_bytes(6)
-        address_bytes = address_bytes[:5] + bytes([address_bytes[5] | 0b11000000])
-        return Address(
-            address=address_bytes, address_type=Address.RANDOM_DEVICE_ADDRESS
-        )
-
-    @classmethod
-    def generate_private_address(cls, irk: bytes = b'') -> Address:
-        '''Generates Random Private MAC Address.
-
-        If IRK is present, a Resolvable Private Address, with the 2 most significant
-        bits of 0b01 will be generated. Otherwise, a Non-resolvable Private Address,
-        with the 2 most significant bits of 0b00 will be generated.
-
-        See Bluetooth spec, Vol 6, Part B - Table 1.2.
-
-        Args:
-            irk: Local Identity Resolving Key(IRK), in little-endian. If not set, a
-            non-resolvable address will be generated.
-        '''
-        if irk:
-            prand = crypto.generate_prand()
-            address_bytes = crypto.ah(irk, prand) + prand
-        else:
-            address_bytes = secrets.token_bytes(6)
-            address_bytes = address_bytes[:5] + bytes([address_bytes[5] & 0b00111111])
-
-        return Address(
-            address=address_bytes, address_type=Address.RANDOM_DEVICE_ADDRESS
-        )
-
     def __init__(
         self, address: Union[bytes, str], address_type: int = RANDOM_DEVICE_ADDRESS
     ):
@@ -3266,9 +3227,7 @@ class HCI_Read_Local_Supported_Commands_Command(HCI_Command):
 
 
 # -----------------------------------------------------------------------------
-@HCI_Command.command(
-    return_parameters_fields=[('status', STATUS_SPEC), ('lmp_features', 8)]
-)
+@HCI_Command.command()
 class HCI_Read_Local_Supported_Features_Command(HCI_Command):
     '''
     See Bluetooth spec @ 7.4.3 Read Local Supported Features Command
@@ -3281,7 +3240,7 @@ class HCI_Read_Local_Supported_Features_Command(HCI_Command):
     return_parameters_fields=[
         ('status', STATUS_SPEC),
         ('page_number', 1),
-        ('max_page_number', 1),
+        ('maximum_page_number', 1),
         ('extended_lmp_features', 8),
     ],
 )
@@ -3450,9 +3409,7 @@ class HCI_LE_Set_Advertising_Parameters_Command(HCI_Command):
 
 
 # -----------------------------------------------------------------------------
-@HCI_Command.command(
-    return_parameters_fields=[('status', STATUS_SPEC), ('tx_power_level', 1)]
-)
+@HCI_Command.command()
 class HCI_LE_Read_Advertising_Physical_Channel_Tx_Power_Command(HCI_Command):
     '''
     See Bluetooth spec @ 7.8.6 LE Read Advertising Physical Channel Tx Power Command
@@ -5833,7 +5790,7 @@ class HCI_Inquiry_Result_With_RSSI_Event(HCI_Event):
         ('status', STATUS_SPEC),
         ('connection_handle', 2),
         ('page_number', 1),
-        ('max_page_number', 1),
+        ('maximum_page_number', 1),
         ('extended_lmp_features', 8),
     ]
 )

bumble/helpers.py

@@ -37,7 +37,6 @@ from bumble.l2cap import (
     L2CAP_Connection_Response,
 )
 from bumble.hci import (
-    Address,
     HCI_EVENT_PACKET,
     HCI_ACL_DATA_PACKET,
     HCI_DISCONNECTION_COMPLETE_EVENT,
@@ -49,7 +48,6 @@ from bumble.hci import (
 )
 from bumble.rfcomm import RFCOMM_Frame, RFCOMM_PSM
 from bumble.sdp import SDP_PDU, SDP_PSM
-from bumble import crypto
 
 # -----------------------------------------------------------------------------
 # Logging
@@ -234,15 +232,3 @@ class PacketTracer:
         )
         self.host_to_controller_analyzer.peer = self.controller_to_host_analyzer
         self.controller_to_host_analyzer.peer = self.host_to_controller_analyzer
-
-
-def generate_irk() -> bytes:
-    return crypto.r()
-
-
-def verify_rpa_with_irk(rpa: Address, irk: bytes) -> bool:
-    rpa_bytes = bytes(rpa)
-    prand_given = rpa_bytes[3:]
-    hash_given = rpa_bytes[:3]
-    hash_local = crypto.ah(irk, prand_given)
-    return hash_local[:3] == hash_given

bumble/hid.py

@@ -19,17 +19,16 @@ from __future__ import annotations
 from dataclasses import dataclass
 import logging
 import enum
-import struct
 
-from abc import ABC, abstractmethod
 from pyee import EventEmitter
-from typing import Optional, Callable, TYPE_CHECKING
-from typing_extensions import override
+from typing import Optional, TYPE_CHECKING
 
-from bumble import l2cap, device
+from bumble import l2cap
 from bumble.colors import color
 from bumble.core import InvalidStateError, ProtocolError
-from .hci import Address
+
+if TYPE_CHECKING:
+    from bumble.device import Device, Connection
 
 
 # -----------------------------------------------------------------------------
@@ -61,7 +60,6 @@ class Message:
         NOT_READY = 0x01
         ERR_INVALID_REPORT_ID = 0x02
         ERR_UNSUPPORTED_REQUEST = 0x03
-        ERR_INVALID_PARAMETER = 0x04
         ERR_UNKNOWN = 0x0E
         ERR_FATAL = 0x0F
 
@@ -103,14 +101,13 @@ class GetReportMessage(Message):
     def __bytes__(self) -> bytes:
         packet_bytes = bytearray()
         packet_bytes.append(self.report_id)
-        if self.buffer_size == 0:
+        packet_bytes.extend(
+            [(self.buffer_size & 0xFF), ((self.buffer_size >> 8) & 0xFF)]
+        )
+        if self.report_type == Message.ReportType.OTHER_REPORT:
             return self.header(self.report_type) + packet_bytes
         else:
-            return (
-                self.header(0x08 | self.report_type)
-                + packet_bytes
-                + struct.pack("<H", self.buffer_size)
-            )
+            return self.header(0x08 | self.report_type) + packet_bytes
 
 
 @dataclass
@@ -123,16 +120,6 @@ class SetReportMessage(Message):
         return self.header(self.report_type) + self.data
 
 
-@dataclass
-class SendControlData(Message):
-    report_type: int
-    data: bytes
-    message_type = Message.MessageType.DATA
-
-    def __bytes__(self) -> bytes:
-        return self.header(self.report_type) + self.data
-
-
 @dataclass
 class GetProtocolMessage(Message):
     message_type = Message.MessageType.GET_PROTOCOL
@@ -174,47 +161,31 @@ class VirtualCableUnplug(Message):
         return self.header(Message.ControlCommand.VIRTUAL_CABLE_UNPLUG)
 
 
-# Device sends input report, host sends output report.
 @dataclass
 class SendData(Message):
     data: bytes
-    report_type: int
     message_type = Message.MessageType.DATA
 
     def __bytes__(self) -> bytes:
-        return self.header(self.report_type) + self.data
-
-
-@dataclass
-class SendHandshakeMessage(Message):
-    result_code: int
-    message_type = Message.MessageType.HANDSHAKE
-
-    def __bytes__(self) -> bytes:
-        return self.header(self.result_code)
+        return self.header(Message.ReportType.OUTPUT_REPORT) + self.data
 
 
 # -----------------------------------------------------------------------------
-class HID(ABC, EventEmitter):
-    l2cap_ctrl_channel: Optional[l2cap.ClassicChannel] = None
-    l2cap_intr_channel: Optional[l2cap.ClassicChannel] = None
-    connection: Optional[device.Connection] = None
+class Host(EventEmitter):
+    l2cap_ctrl_channel: Optional[l2cap.ClassicChannel]
+    l2cap_intr_channel: Optional[l2cap.ClassicChannel]
 
-    class Role(enum.IntEnum):
-        HOST = 0x00
-        DEVICE = 0x01
-
-    def __init__(self, device: device.Device, role: Role) -> None:
+    def __init__(self, device: Device, connection: Connection) -> None:
         super().__init__()
-        self.remote_device_bd_address: Optional[Address] = None
         self.device = device
-        self.role = role
+        self.connection = connection
+
+        self.l2cap_ctrl_channel = None
+        self.l2cap_intr_channel = None
 
         # Register ourselves with the L2CAP channel manager
-        device.register_l2cap_server(HID_CONTROL_PSM, self.on_l2cap_connection)
-        device.register_l2cap_server(HID_INTERRUPT_PSM, self.on_l2cap_connection)
-
-        device.on('connection', self.on_device_connection)
+        device.register_l2cap_server(HID_CONTROL_PSM, self.on_connection)
+        device.register_l2cap_server(HID_INTERRUPT_PSM, self.on_connection)
 
     async def connect_control_channel(self) -> None:
         # Create a new L2CAP connection - control channel
@@ -258,18 +229,9 @@ class HID(ABC, EventEmitter):
         self.l2cap_ctrl_channel = None
         await channel.disconnect()
 
-    def on_device_connection(self, connection: device.Connection) -> None:
-        self.connection = connection
-        self.remote_device_bd_address = connection.peer_address
-        connection.on('disconnection', self.on_device_disconnection)
-
-    def on_device_disconnection(self, reason: int) -> None:
-        self.connection = None
-
-    def on_l2cap_connection(self, l2cap_channel: l2cap.ClassicChannel) -> None:
+    def on_connection(self, l2cap_channel: l2cap.ClassicChannel) -> None:
         logger.debug(f'+++ New L2CAP connection: {l2cap_channel}')
         l2cap_channel.on('open', lambda: self.on_l2cap_channel_open(l2cap_channel))
-        l2cap_channel.on('close', lambda: self.on_l2cap_channel_close(l2cap_channel))
 
     def on_l2cap_channel_open(self, l2cap_channel: l2cap.ClassicChannel) -> None:
         if l2cap_channel.psm == HID_CONTROL_PSM:
@@ -280,220 +242,37 @@ class HID(ABC, EventEmitter):
             self.l2cap_intr_channel.sink = self.on_intr_pdu
         logger.debug(f'$$$ L2CAP channel open: {l2cap_channel}')
 
-    def on_l2cap_channel_close(self, l2cap_channel: l2cap.ClassicChannel) -> None:
-        if l2cap_channel.psm == HID_CONTROL_PSM:
-            self.l2cap_ctrl_channel = None
-        else:
-            self.l2cap_intr_channel = None
-        logger.debug(f'$$$ L2CAP channel close: {l2cap_channel}')
-
-    @abstractmethod
-    def on_ctrl_pdu(self, pdu: bytes) -> None:
-        pass
-
-    def on_intr_pdu(self, pdu: bytes) -> None:
-        logger.debug(f'<<< HID INTERRUPT PDU: {pdu.hex()}')
-        self.emit("interrupt_data", pdu)
-
-    def send_pdu_on_ctrl(self, msg: bytes) -> None:
-        assert self.l2cap_ctrl_channel
-        self.l2cap_ctrl_channel.send_pdu(msg)
-
-    def send_pdu_on_intr(self, msg: bytes) -> None:
-        assert self.l2cap_intr_channel
-        self.l2cap_intr_channel.send_pdu(msg)
-
-    def send_data(self, data: bytes) -> None:
-        if self.role == HID.Role.HOST:
-            report_type = Message.ReportType.OUTPUT_REPORT
-        else:
-            report_type = Message.ReportType.INPUT_REPORT
-        msg = SendData(data, report_type)
-        hid_message = bytes(msg)
-        if self.l2cap_intr_channel is not None:
-            logger.debug(f'>>> HID INTERRUPT SEND DATA, PDU: {hid_message.hex()}')
-            self.send_pdu_on_intr(hid_message)
-
-    def virtual_cable_unplug(self) -> None:
-        msg = VirtualCableUnplug()
-        hid_message = bytes(msg)
-        logger.debug(f'>>> HID CONTROL VIRTUAL CABLE UNPLUG, PDU: {hid_message.hex()}')
-        self.send_pdu_on_ctrl(hid_message)
-
-
-# -----------------------------------------------------------------------------
-
-
-class Device(HID):
-    class GetSetReturn(enum.IntEnum):
-        FAILURE = 0x00
-        REPORT_ID_NOT_FOUND = 0x01
-        ERR_UNSUPPORTED_REQUEST = 0x02
-        ERR_UNKNOWN = 0x03
-        ERR_INVALID_PARAMETER = 0x04
-        SUCCESS = 0xFF
-
-    class GetSetStatus:
-        def __init__(self) -> None:
-            self.data = bytearray()
-            self.status = 0
-
-    def __init__(self, device: device.Device) -> None:
-        super().__init__(device, HID.Role.DEVICE)
-        get_report_cb: Optional[Callable[[int, int, int], None]] = None
-        set_report_cb: Optional[Callable[[int, int, int, bytes], None]] = None
-        get_protocol_cb: Optional[Callable[[], None]] = None
-        set_protocol_cb: Optional[Callable[[int], None]] = None
-
-    @override
     def on_ctrl_pdu(self, pdu: bytes) -> None:
         logger.debug(f'<<< HID CONTROL PDU: {pdu.hex()}')
-        param = pdu[0] & 0x0F
+        # Here we will receive all kinds of packets, parse and then call respective callbacks
         message_type = pdu[0] >> 4
+        param = pdu[0] & 0x0F
 
-        if message_type == Message.MessageType.GET_REPORT:
-            logger.debug('<<< HID GET REPORT')
-            self.handle_get_report(pdu)
-        elif message_type == Message.MessageType.SET_REPORT:
-            logger.debug('<<< HID SET REPORT')
-            self.handle_set_report(pdu)
-        elif message_type == Message.MessageType.GET_PROTOCOL:
-            logger.debug('<<< HID GET PROTOCOL')
-            self.handle_get_protocol(pdu)
-        elif message_type == Message.MessageType.SET_PROTOCOL:
-            logger.debug('<<< HID SET PROTOCOL')
-            self.handle_set_protocol(pdu)
+        if message_type == Message.MessageType.HANDSHAKE:
+            logger.debug(f'<<< HID HANDSHAKE: {Message.Handshake(param).name}')
+            self.emit('handshake', Message.Handshake(param))
         elif message_type == Message.MessageType.DATA:
             logger.debug('<<< HID CONTROL DATA')
-            self.emit('control_data', pdu)
+            self.emit('data', pdu)
         elif message_type == Message.MessageType.CONTROL:
             if param == Message.ControlCommand.SUSPEND:
                 logger.debug('<<< HID SUSPEND')
-                self.emit('suspend')
+                self.emit('suspend', pdu)
             elif param == Message.ControlCommand.EXIT_SUSPEND:
                 logger.debug('<<< HID EXIT SUSPEND')
-                self.emit('exit_suspend')
+                self.emit('exit_suspend', pdu)
             elif param == Message.ControlCommand.VIRTUAL_CABLE_UNPLUG:
                 logger.debug('<<< HID VIRTUAL CABLE UNPLUG')
                 self.emit('virtual_cable_unplug')
             else:
                 logger.debug('<<< HID CONTROL OPERATION UNSUPPORTED')
         else:
-            logger.debug('<<< HID MESSAGE TYPE UNSUPPORTED')
-            self.send_handshake_message(Message.Handshake.ERR_UNSUPPORTED_REQUEST)
+            logger.debug('<<< HID CONTROL DATA')
+            self.emit('data', pdu)
 
-    def send_handshake_message(self, result_code: int) -> None:
-        msg = SendHandshakeMessage(result_code)
-        hid_message = bytes(msg)
-        logger.debug(f'>>> HID HANDSHAKE MESSAGE, PDU: {hid_message.hex()}')
-        self.send_pdu_on_ctrl(hid_message)
-
-    def send_control_data(self, report_type: int, data: bytes):
-        msg = SendControlData(report_type=report_type, data=data)
-        hid_message = bytes(msg)
-        logger.debug(f'>>> HID CONTROL DATA: {hid_message.hex()}')
-        self.send_pdu_on_ctrl(hid_message)
-
-    def handle_get_report(self, pdu: bytes):
-        if self.get_report_cb is None:
-            logger.debug("GetReport callback not registered !!")
-            self.send_handshake_message(Message.Handshake.ERR_UNSUPPORTED_REQUEST)
-            return
-        report_type = pdu[0] & 0x03
-        buffer_flag = (pdu[0] & 0x08) >> 3
-        report_id = pdu[1]
-        logger.debug("buffer_flag: " + str(buffer_flag))
-        if buffer_flag == 1:
-            buffer_size = (pdu[3] << 8) | pdu[2]
-        else:
-            buffer_size = 0
-
-        ret = self.get_report_cb(report_id, report_type, buffer_size)
-        assert ret is not None
-        if ret.status == self.GetSetReturn.FAILURE:
-            self.send_handshake_message(Message.Handshake.ERR_UNKNOWN)
-        elif ret.status == self.GetSetReturn.SUCCESS:
-            data = bytearray()
-            data.append(report_id)
-            data.extend(ret.data)
-            if len(data) < self.l2cap_ctrl_channel.mtu:  # type: ignore[union-attr]
-                self.send_control_data(report_type=report_type, data=data)
-            else:
-                self.send_handshake_message(Message.Handshake.ERR_INVALID_PARAMETER)
-        elif ret.status == self.GetSetReturn.REPORT_ID_NOT_FOUND:
-            self.send_handshake_message(Message.Handshake.ERR_INVALID_REPORT_ID)
-        elif ret.status == self.GetSetReturn.ERR_INVALID_PARAMETER:
-            self.send_handshake_message(Message.Handshake.ERR_INVALID_PARAMETER)
-        elif ret.status == self.GetSetReturn.ERR_UNSUPPORTED_REQUEST:
-            self.send_handshake_message(Message.Handshake.ERR_UNSUPPORTED_REQUEST)
-
-    def register_get_report_cb(self, cb: Callable[[int, int, int], None]) -> None:
-        self.get_report_cb = cb
-        logger.debug("GetReport callback registered successfully")
-
-    def handle_set_report(self, pdu: bytes):
-        if self.set_report_cb is None:
-            logger.debug("SetReport callback not registered !!")
-            self.send_handshake_message(Message.Handshake.ERR_UNSUPPORTED_REQUEST)
-            return
-        report_type = pdu[0] & 0x03
-        report_id = pdu[1]
-        report_data = pdu[2:]
-        report_size = len(report_data) + 1
-        ret = self.set_report_cb(report_id, report_type, report_size, report_data)
-        assert ret is not None
-        if ret.status == self.GetSetReturn.SUCCESS:
-            self.send_handshake_message(Message.Handshake.SUCCESSFUL)
-        elif ret.status == self.GetSetReturn.ERR_INVALID_PARAMETER:
-            self.send_handshake_message(Message.Handshake.ERR_INVALID_PARAMETER)
-        elif ret.status == self.GetSetReturn.REPORT_ID_NOT_FOUND:
-            self.send_handshake_message(Message.Handshake.ERR_INVALID_REPORT_ID)
-        else:
-            self.send_handshake_message(Message.Handshake.ERR_UNSUPPORTED_REQUEST)
-
-    def register_set_report_cb(
-        self, cb: Callable[[int, int, int, bytes], None]
-    ) -> None:
-        self.set_report_cb = cb
-        logger.debug("SetReport callback registered successfully")
-
-    def handle_get_protocol(self, pdu: bytes):
-        if self.get_protocol_cb is None:
-            logger.debug("GetProtocol callback not registered !!")
-            self.send_handshake_message(Message.Handshake.ERR_UNSUPPORTED_REQUEST)
-            return
-        ret = self.get_protocol_cb()
-        assert ret is not None
-        if ret.status == self.GetSetReturn.SUCCESS:
-            self.send_control_data(Message.ReportType.OTHER_REPORT, ret.data)
-        else:
-            self.send_handshake_message(Message.Handshake.ERR_UNSUPPORTED_REQUEST)
-
-    def register_get_protocol_cb(self, cb: Callable[[], None]) -> None:
-        self.get_protocol_cb = cb
-        logger.debug("GetProtocol callback registered successfully")
-
-    def handle_set_protocol(self, pdu: bytes):
-        if self.set_protocol_cb is None:
-            logger.debug("SetProtocol callback not registered !!")
-            self.send_handshake_message(Message.Handshake.ERR_UNSUPPORTED_REQUEST)
-            return
-        ret = self.set_protocol_cb(pdu[0] & 0x01)
-        assert ret is not None
-        if ret.status == self.GetSetReturn.SUCCESS:
-            self.send_handshake_message(Message.Handshake.SUCCESSFUL)
-        else:
-            self.send_handshake_message(Message.Handshake.ERR_UNSUPPORTED_REQUEST)
-
-    def register_set_protocol_cb(self, cb: Callable[[int], None]) -> None:
-        self.set_protocol_cb = cb
-        logger.debug("SetProtocol callback registered successfully")
-
-
-# -----------------------------------------------------------------------------
-class Host(HID):
-    def __init__(self, device: device.Device) -> None:
-        super().__init__(device, HID.Role.HOST)
+    def on_intr_pdu(self, pdu: bytes) -> None:
+        logger.debug(f'<<< HID INTERRUPT PDU: {pdu.hex()}')
+        self.emit("data", pdu)
 
     def get_report(self, report_type: int, report_id: int, buffer_size: int) -> None:
         msg = GetReportMessage(
@@ -503,52 +282,52 @@ class Host(HID):
         logger.debug(f'>>> HID CONTROL GET REPORT, PDU: {hid_message.hex()}')
         self.send_pdu_on_ctrl(hid_message)
 
-    def set_report(self, report_type: int, data: bytes) -> None:
+    def set_report(self, report_type: int, data: bytes):
         msg = SetReportMessage(report_type=report_type, data=data)
         hid_message = bytes(msg)
         logger.debug(f'>>> HID CONTROL SET REPORT, PDU:{hid_message.hex()}')
         self.send_pdu_on_ctrl(hid_message)
 
-    def get_protocol(self) -> None:
+    def get_protocol(self):
         msg = GetProtocolMessage()
         hid_message = bytes(msg)
         logger.debug(f'>>> HID CONTROL GET PROTOCOL, PDU: {hid_message.hex()}')
         self.send_pdu_on_ctrl(hid_message)
 
-    def set_protocol(self, protocol_mode: int) -> None:
+    def set_protocol(self, protocol_mode: int):
         msg = SetProtocolMessage(protocol_mode=protocol_mode)
         hid_message = bytes(msg)
         logger.debug(f'>>> HID CONTROL SET PROTOCOL, PDU: {hid_message.hex()}')
         self.send_pdu_on_ctrl(hid_message)
 
-    def suspend(self) -> None:
+    def send_pdu_on_ctrl(self, msg: bytes) -> None:
+        assert self.l2cap_ctrl_channel
+        self.l2cap_ctrl_channel.send_pdu(msg)
+
+    def send_pdu_on_intr(self, msg: bytes) -> None:
+        assert self.l2cap_intr_channel
+        self.l2cap_intr_channel.send_pdu(msg)
+
+    def send_data(self, data):
+        msg = SendData(data)
+        hid_message = bytes(msg)
+        logger.debug(f'>>> HID INTERRUPT SEND DATA, PDU: {hid_message.hex()}')
+        self.send_pdu_on_intr(hid_message)
+
+    def suspend(self):
         msg = Suspend()
         hid_message = bytes(msg)
         logger.debug(f'>>> HID CONTROL SUSPEND, PDU:{hid_message.hex()}')
-        self.send_pdu_on_ctrl(hid_message)
+        self.send_pdu_on_ctrl(msg)
 
-    def exit_suspend(self) -> None:
+    def exit_suspend(self):
         msg = ExitSuspend()
         hid_message = bytes(msg)
         logger.debug(f'>>> HID CONTROL EXIT SUSPEND, PDU:{hid_message.hex()}')
-        self.send_pdu_on_ctrl(hid_message)
+        self.send_pdu_on_ctrl(msg)
 
-    @override
-    def on_ctrl_pdu(self, pdu: bytes) -> None:
-        logger.debug(f'<<< HID CONTROL PDU: {pdu.hex()}')
-        param = pdu[0] & 0x0F
-        message_type = pdu[0] >> 4
-        if message_type == Message.MessageType.HANDSHAKE:
-            logger.debug(f'<<< HID HANDSHAKE: {Message.Handshake(param).name}')
-            self.emit('handshake', Message.Handshake(param))
-        elif message_type == Message.MessageType.DATA:
-            logger.debug('<<< HID CONTROL DATA')
-            self.emit('control_data', pdu)
-        elif message_type == Message.MessageType.CONTROL:
-            if param == Message.ControlCommand.VIRTUAL_CABLE_UNPLUG:
-                logger.debug('<<< HID VIRTUAL CABLE UNPLUG')
-                self.emit('virtual_cable_unplug')
-            else:
-                logger.debug('<<< HID CONTROL OPERATION UNSUPPORTED')
-        else:
-            logger.debug('<<< HID MESSAGE TYPE UNSUPPORTED')
+    def virtual_cable_unplug(self):
+        msg = VirtualCableUnplug()
+        hid_message = bytes(msg)
+        logger.debug(f'>>> HID CONTROL VIRTUAL CABLE UNPLUG, PDU: {hid_message.hex()}')
+        self.send_pdu_on_ctrl(msg)

bumble/host.py

@@ -21,7 +21,7 @@ import collections
 import logging
 import struct
 
-from typing import Any, Awaitable, Callable, Dict, Optional, Union, cast, TYPE_CHECKING
+from typing import Any, Awaitable, Callable, Deque, Dict, Optional, cast, TYPE_CHECKING
 
 from bumble.colors import color
 from bumble.l2cap import L2CAP_PDU
@@ -91,16 +91,49 @@ logger = logging.getLogger(__name__)
 
 
 # -----------------------------------------------------------------------------
-# Constants
-# -----------------------------------------------------------------------------
-# fmt: off
+class AclPacketQueue:
+    max_packet_size: int
 
-HOST_DEFAULT_HC_LE_ACL_DATA_PACKET_LENGTH = 27
-HOST_HC_TOTAL_NUM_LE_ACL_DATA_PACKETS     = 1
-HOST_DEFAULT_HC_ACL_DATA_PACKET_LENGTH    = 27
-HOST_HC_TOTAL_NUM_ACL_DATA_PACKETS        = 1
+    def __init__(
+        self,
+        max_packet_size: int,
+        max_in_flight: int,
+        send: Callable[[HCI_Packet], None],
+    ) -> None:
+        self.max_packet_size = max_packet_size
+        self.max_in_flight = max_in_flight
+        self.in_flight = 0
+        self.send = send
+        self.packets: Deque[HCI_AclDataPacket] = collections.deque()
 
-# fmt: on
+    def enqueue(self, packet: HCI_AclDataPacket) -> None:
+        self.packets.appendleft(packet)
+        self.check_queue()
+
+        if self.packets:
+            logger.debug(
+                f'{self.in_flight} ACL packets in flight, '
+                f'{len(self.packets)} in queue'
+            )
+
+    def check_queue(self) -> None:
+        while self.packets and self.in_flight < self.max_in_flight:
+            packet = self.packets.pop()
+            self.send(packet)
+            self.in_flight += 1
+
+    def on_packets_completed(self, packet_count: int) -> None:
+        if packet_count > self.in_flight:
+            logger.warning(
+                color(
+                    '!!! {packet_count} completed but only '
+                    f'{self.in_flight} in flight'
+                )
+            )
+            packet_count = self.in_flight
+
+        self.in_flight -= packet_count
+        self.check_queue()
 
 
 # -----------------------------------------------------------------------------
@@ -111,6 +144,13 @@ class Connection:
         self.peer_address = peer_address
         self.assembler = HCI_AclDataPacketAssembler(self.on_acl_pdu)
         self.transport = transport
+        acl_packet_queue: Optional[AclPacketQueue] = (
+            host.le_acl_packet_queue
+            if transport == BT_LE_TRANSPORT
+            else host.acl_packet_queue
+        )
+        assert acl_packet_queue
+        self.acl_packet_queue = acl_packet_queue
 
     def on_hci_acl_data_packet(self, packet: HCI_AclDataPacket) -> None:
         self.assembler.feed_packet(packet)
@@ -123,7 +163,8 @@ class Connection:
 # -----------------------------------------------------------------------------
 class Host(AbortableEventEmitter):
     connections: Dict[int, Connection]
-    acl_packet_queue: collections.deque[HCI_AclDataPacket]
+    acl_packet_queue: Optional[AclPacketQueue] = None
+    le_acl_packet_queue: Optional[AclPacketQueue] = None
     hci_sink: Optional[TransportSink] = None
     hci_metadata: Dict[str, Any]
     long_term_key_provider: Optional[
@@ -143,12 +184,6 @@ class Host(AbortableEventEmitter):
         self.connections = {}  # Connections, by connection handle
         self.pending_command = None
         self.pending_response = None
-        self.hc_le_acl_data_packet_length = HOST_DEFAULT_HC_LE_ACL_DATA_PACKET_LENGTH
-        self.hc_total_num_le_acl_data_packets = HOST_HC_TOTAL_NUM_LE_ACL_DATA_PACKETS
-        self.hc_acl_data_packet_length = HOST_DEFAULT_HC_ACL_DATA_PACKET_LENGTH
-        self.hc_total_num_acl_data_packets = HOST_HC_TOTAL_NUM_ACL_DATA_PACKETS
-        self.acl_packet_queue = collections.deque()
-        self.acl_packets_in_flight = 0
         self.local_version = None
         self.local_supported_commands = bytes(64)
         self.local_le_features = 0
@@ -254,46 +289,54 @@ class Host(AbortableEventEmitter):
             response = await self.send_command(
                 HCI_Read_Buffer_Size_Command(), check_result=True
             )
-            self.hc_acl_data_packet_length = (
+            hc_acl_data_packet_length = (
                 response.return_parameters.hc_acl_data_packet_length
             )
-            self.hc_total_num_acl_data_packets = (
+            hc_total_num_acl_data_packets = (
                 response.return_parameters.hc_total_num_acl_data_packets
             )
 
             logger.debug(
                 'HCI ACL flow control: '
-                f'hc_acl_data_packet_length={self.hc_acl_data_packet_length},'
-                f'hc_total_num_acl_data_packets={self.hc_total_num_acl_data_packets}'
+                f'hc_acl_data_packet_length={hc_acl_data_packet_length},'
+                f'hc_total_num_acl_data_packets={hc_total_num_acl_data_packets}'
             )
 
+            self.acl_packet_queue = AclPacketQueue(
+                max_packet_size=hc_acl_data_packet_length,
+                max_in_flight=hc_total_num_acl_data_packets,
+                send=self.send_hci_packet,
+            )
+
+        hc_le_acl_data_packet_length = 0
+        hc_total_num_le_acl_data_packets = 0
         if self.supports_command(HCI_LE_READ_BUFFER_SIZE_COMMAND):
             response = await self.send_command(
                 HCI_LE_Read_Buffer_Size_Command(), check_result=True
             )
-            self.hc_le_acl_data_packet_length = (
+            hc_le_acl_data_packet_length = (
                 response.return_parameters.hc_le_acl_data_packet_length
             )
-            self.hc_total_num_le_acl_data_packets = (
+            hc_total_num_le_acl_data_packets = (
                 response.return_parameters.hc_total_num_le_acl_data_packets
             )
 
             logger.debug(
                 'HCI LE ACL flow control: '
-                f'hc_le_acl_data_packet_length={self.hc_le_acl_data_packet_length},'
-                'hc_total_num_le_acl_data_packets='
-                f'{self.hc_total_num_le_acl_data_packets}'
+                f'hc_le_acl_data_packet_length={hc_le_acl_data_packet_length},'
+                f'hc_total_num_le_acl_data_packets={hc_total_num_le_acl_data_packets}'
             )
 
-            if (
-                response.return_parameters.hc_le_acl_data_packet_length == 0
-                or response.return_parameters.hc_total_num_le_acl_data_packets == 0
-            ):
-                # LE and Classic share the same values
-                self.hc_le_acl_data_packet_length = self.hc_acl_data_packet_length
-                self.hc_total_num_le_acl_data_packets = (
-                    self.hc_total_num_acl_data_packets
-                )
+        if hc_le_acl_data_packet_length == 0 or hc_total_num_le_acl_data_packets == 0:
+            # LE and Classic share the same queue
+            self.le_acl_packet_queue = self.acl_packet_queue
+        else:
+            # Create a separate queue for LE
+            self.le_acl_packet_queue = AclPacketQueue(
+                max_packet_size=hc_le_acl_data_packet_length,
+                max_in_flight=hc_total_num_le_acl_data_packets,
+                send=self.send_hci_packet,
+            )
 
         if self.supports_command(
             HCI_LE_READ_SUGGESTED_DEFAULT_DATA_LENGTH_COMMAND
@@ -332,14 +375,13 @@ class Host(AbortableEventEmitter):
         self.hci_metadata = getattr(source, 'metadata', self.hci_metadata)
 
     def send_hci_packet(self, packet: HCI_Packet) -> None:
+        logger.debug(f'{color("### HOST -> CONTROLLER", "blue")}: {packet}')
         if self.snooper:
             self.snooper.snoop(bytes(packet), Snooper.Direction.HOST_TO_CONTROLLER)
         if self.hci_sink:
             self.hci_sink.on_packet(bytes(packet))
 
     async def send_command(self, command, check_result=False):
-        logger.debug(f'{color("### HOST -> CONTROLLER", "blue")}: {command}')
-
         # Wait until we can send (only one pending command at a time)
         async with self.command_semaphore:
             assert self.pending_command is None
@@ -387,6 +429,17 @@ class Host(AbortableEventEmitter):
         asyncio.create_task(send_command(command))
 
     def send_l2cap_pdu(self, connection_handle: int, cid: int, pdu: bytes) -> None:
+        if not (connection := self.connections.get(connection_handle)):
+            logger.warning(f'connection 0x{connection_handle:04X} not found')
+            return
+        packet_queue = connection.acl_packet_queue
+        if packet_queue is None:
+            logger.warning(
+                f'no ACL packet queue for connection 0x{connection_handle:04X}'
+            )
+            return
+
+        # Create a PDU
         l2cap_pdu = bytes(L2CAP_PDU(cid, pdu))
 
         # Send the data to the controller via ACL packets
@@ -394,8 +447,7 @@ class Host(AbortableEventEmitter):
         offset = 0
         pb_flag = 0
         while bytes_remaining:
-            # TODO: support different LE/Classic lengths
-            data_total_length = min(bytes_remaining, self.hc_le_acl_data_packet_length)
+            data_total_length = min(bytes_remaining, packet_queue.max_packet_size)
             acl_packet = HCI_AclDataPacket(
                 connection_handle=connection_handle,
                 pb_flag=pb_flag,
@@ -403,34 +455,12 @@ class Host(AbortableEventEmitter):
                 data_total_length=data_total_length,
                 data=l2cap_pdu[offset : offset + data_total_length],
             )
-            logger.debug(
-                f'{color("### HOST -> CONTROLLER", "blue")}: (CID={cid}) {acl_packet}'
-            )
-            self.queue_acl_packet(acl_packet)
+            logger.debug(f'>>> ACL packet enqueue: (CID={cid}) {acl_packet}')
+            packet_queue.enqueue(acl_packet)
             pb_flag = 1
             offset += data_total_length
             bytes_remaining -= data_total_length
 
-    def queue_acl_packet(self, acl_packet: HCI_AclDataPacket) -> None:
-        self.acl_packet_queue.appendleft(acl_packet)
-        self.check_acl_packet_queue()
-
-        if len(self.acl_packet_queue):
-            logger.debug(
-                f'{self.acl_packets_in_flight} ACL packets in flight, '
-                f'{len(self.acl_packet_queue)} in queue'
-            )
-
-    def check_acl_packet_queue(self) -> None:
-        # Send all we can (TODO: support different LE/Classic limits)
-        while (
-            len(self.acl_packet_queue) > 0
-            and self.acl_packets_in_flight < self.hc_total_num_le_acl_data_packets
-        ):
-            packet = self.acl_packet_queue.pop()
-            self.acl_packets_in_flight += 1
-            self.send_hci_packet(packet)
-
     def supports_command(self, command):
         # Find the support flag position for this command
         for octet, flags in enumerate(HCI_SUPPORTED_COMMANDS_FLAGS):
@@ -553,7 +583,7 @@ class Host(AbortableEventEmitter):
             # This is used just for the Num_HCI_Command_Packets field, not related to
             # an actual command
             logger.debug('no-command event')
-            return None
+            return
 
         return self.on_command_processed(event)
 
@@ -561,18 +591,17 @@ class Host(AbortableEventEmitter):
         return self.on_command_processed(event)
 
     def on_hci_number_of_completed_packets_event(self, event):
-        total_packets = sum(event.num_completed_packets)
-        if total_packets <= self.acl_packets_in_flight:
-            self.acl_packets_in_flight -= total_packets
-            self.check_acl_packet_queue()
-        else:
-            logger.warning(
-                color(
-                    f'!!! {total_packets} completed but only '
-                    f'{self.acl_packets_in_flight} in flight'
+        for connection_handle, num_completed_packets in zip(
+            event.connection_handles, event.num_completed_packets
+        ):
+            if not (connection := self.connections.get(connection_handle)):
+                logger.warning(
+                    'received packet completion event for unknown handle '
+                    f'0x{connection_handle:04X}'
                 )
-            )
-            self.acl_packets_in_flight = 0
+                continue
+
+            connection.acl_packet_queue.on_packets_completed(num_completed_packets)
 
     # Classic only
     def on_hci_connection_request_event(self, event):

bumble/l2cap.py

@@ -151,8 +151,8 @@ L2CAP_LE_CREDIT_BASED_CONNECTION_MAX_CREDITS             = 65535
 L2CAP_LE_CREDIT_BASED_CONNECTION_MIN_MTU                 = 23
 L2CAP_LE_CREDIT_BASED_CONNECTION_MIN_MPS                 = 23
 L2CAP_LE_CREDIT_BASED_CONNECTION_MAX_MPS                 = 65533
-L2CAP_LE_CREDIT_BASED_CONNECTION_DEFAULT_MTU             = 2046
-L2CAP_LE_CREDIT_BASED_CONNECTION_DEFAULT_MPS             = 2048
+L2CAP_LE_CREDIT_BASED_CONNECTION_DEFAULT_MTU             = 2048
+L2CAP_LE_CREDIT_BASED_CONNECTION_DEFAULT_MPS             = 2046
 L2CAP_LE_CREDIT_BASED_CONNECTION_DEFAULT_INITIAL_CREDITS = 256
 
 L2CAP_MAXIMUM_TRANSMISSION_UNIT_CONFIGURATION_OPTION_TYPE = 0x01

bumble/link.py

@@ -95,21 +95,11 @@ class LocalLink:
     def on_address_changed(self, controller):
         pass
 
-    def send_advertising_data(self, sender_address, data, scan_response):
+    def send_advertising_data(self, sender_address, data):
         # Send the advertising data to all controllers, except the sender
         for controller in self.controllers:
             if controller.random_address != sender_address:
-                controller.on_link_advertising_data(sender_address, data, scan_response)
-
-    def send_extended_advertising_data(
-        self, sender_address, event_type, data, scan_response
-    ):
-        # Send the advertising data to all controllers, except the sender
-        for controller in self.controllers:
-            if controller.random_address != sender_address:
-                controller.on_link_extended_advertising_data(
-                    sender_address, event_type, data, scan_response
-                )
+                controller.on_link_advertising_data(sender_address, data)
 
     def send_acl_data(self, sender_controller, destination_address, transport, data):
         # Send the data to the first controller with a matching address
@@ -161,34 +151,30 @@ class LocalLink:
         asyncio.get_running_loop().call_soon(self.on_connection_complete)
 
     def on_disconnection_complete(
-        self, initiator_address, peer_address, disconnect_command
+        self, central_address, peripheral_address, disconnect_command
     ):
         # Find the controller that initiated the disconnection
-        if not (initiator_controller := self.find_controller(initiator_address)):
+        if not (central_controller := self.find_controller(central_address)):
             logger.warning('!!! Initiating controller not found')
             return
 
         # Disconnect from the first controller with a matching address
-        if peer_controller := self.find_controller(peer_address):
-            peer_controller.on_link_peer_disconnected(
-                initiator_address, disconnect_command.reason
+        if peripheral_controller := self.find_controller(peripheral_address):
+            peripheral_controller.on_link_central_disconnected(
+                central_address, disconnect_command.reason
             )
 
-        initiator_controller.on_link_initiated_disconnection_complete(
+        central_controller.on_link_peripheral_disconnection_complete(
             disconnect_command, HCI_SUCCESS
         )
 
-    def disconnect(self, initiator_address, peer_address, disconnect_command):
+    def disconnect(self, central_address, peripheral_address, disconnect_command):
         logger.debug(
-            f'$$$ DISCONNECTION {initiator_address} -> '
-            f'{peer_address}: reason = {disconnect_command.reason}'
-        )
-        asyncio.get_running_loop().call_soon(
-            self.on_disconnection_complete,
-            initiator_address,
-            peer_address,
-            disconnect_command,
+            f'$$$ DISCONNECTION {central_address} -> '
+            f'{peripheral_address}: reason = {disconnect_command.reason}'
         )
+        args = [central_address, peripheral_address, disconnect_command]
+        asyncio.get_running_loop().call_soon(self.on_disconnection_complete, *args)
 
     # pylint: disable=too-many-arguments
     def on_connection_encrypted(
@@ -374,11 +360,11 @@ class RemoteLink:
 
     async def on_left_received(self, address):
         if address in self.central_connections:
-            self.controller.on_link_connection_lost(Address(address))
+            self.controller.on_link_peripheral_disconnected(Address(address))
             self.central_connections.remove(address)
 
         if address in self.peripheral_connections:
-            self.controller.on_link_peer_disconnected(
+            self.controller.on_link_central_disconnected(
                 address, HCI_CONNECTION_TIMEOUT_ERROR
             )
             self.peripheral_connections.remove(address)
@@ -398,7 +384,7 @@ class RemoteLink:
     async def on_advertisement_message_received(self, sender, advertisement):
         try:
             self.controller.on_link_advertising_data(
-                Address(sender), bytes.fromhex(advertisement), b''
+                Address(sender), bytes.fromhex(advertisement)
             )
         except Exception:
             logger.exception('exception')
@@ -438,7 +424,7 @@ class RemoteLink:
         # Notify the controller
         params = parse_parameters(message)
         reason = int(params.get('reason', str(HCI_CONNECTION_TIMEOUT_ERROR)))
-        self.controller.on_link_peer_disconnected(Address(sender), reason)
+        self.controller.on_link_central_disconnected(Address(sender), reason)
 
         # Forget the connection
         if sender in self.peripheral_connections:
@@ -485,7 +471,7 @@ class RemoteLink:
     async def send_advertising_data_to_relay(self, data):
         await self.send_targeted_message('*', f'advertisement:{data.hex()}')
 
-    def send_advertising_data(self, _, data, scan_response):
+    def send_advertising_data(self, _, data):
         self.execute(partial(self.send_advertising_data_to_relay, data))
 
     async def send_acl_data_to_relay(self, peer_address, data):

bumble/profiles/cap.py

@@ -1,52 +0,0 @@
-# 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 bumble import gatt
-from bumble import gatt_client
-from bumble.profiles import csip
-
-
-# -----------------------------------------------------------------------------
-# Server
-# -----------------------------------------------------------------------------
-class CommonAudioServiceService(gatt.TemplateService):
-    UUID = gatt.GATT_COMMON_AUDIO_SERVICE
-
-    def __init__(
-        self,
-        coordinated_set_identification_service: csip.CoordinatedSetIdentificationService,
-    ) -> None:
-        self.coordinated_set_identification_service = (
-            coordinated_set_identification_service
-        )
-        super().__init__(
-            characteristics=[],
-            included_services=[coordinated_set_identification_service],
-        )
-
-
-# -----------------------------------------------------------------------------
-# Client
-# -----------------------------------------------------------------------------
-class CommonAudioServiceServiceProxy(gatt_client.ProfileServiceProxy):
-    SERVICE_CLASS = CommonAudioServiceService
-
-    def __init__(self, service_proxy: gatt_client.ServiceProxy) -> None:
-        self.service_proxy = service_proxy

bumble/profiles/csip.py

@@ -21,9 +21,6 @@ import enum
 import struct
 from typing import Optional
 
-from bumble import core
-from bumble import crypto
-from bumble import device
 from bumble import gatt
 from bumble import gatt_client
 
@@ -46,43 +43,9 @@ class MemberLock(enum.IntEnum):
 
 
 # -----------------------------------------------------------------------------
-# Crypto Toolbox
+# Utils
 # -----------------------------------------------------------------------------
-def s1(m: bytes) -> bytes:
-    '''
-    Coordinated Set Identification Service - 4.3 s1 SALT generation function.
-    '''
-    return crypto.aes_cmac(m[::-1], bytes(16))[::-1]
-
-
-def k1(n: bytes, salt: bytes, p: bytes) -> bytes:
-    '''
-    Coordinated Set Identification Service - 4.4 k1 derivation function.
-    '''
-    t = crypto.aes_cmac(n[::-1], salt[::-1])
-    return crypto.aes_cmac(p[::-1], t)[::-1]
-
-
-def sef(k: bytes, r: bytes) -> bytes:
-    '''
-    Coordinated Set Identification Service - 4.5 SIRK encryption function sef.
-    '''
-    return crypto.xor(k1(k, s1(b'SIRKenc'[::-1]), b'csis'[::-1]), r)
-
-
-def sih(k: bytes, r: bytes) -> bytes:
-    '''
-    Coordinated Set Identification Service - 4.7 Resolvable Set Identifier hash function sih.
-    '''
-    return crypto.e(k, r + bytes(13))[:3]
-
-
-def generate_rsi(sirk: bytes) -> bytes:
-    '''
-    Coordinated Set Identification Service - 4.8 Resolvable Set Identifier generation operation.
-    '''
-    prand = crypto.generate_prand()
-    return sih(sirk, prand) + prand
+# TODO: Implement RSI Generator
 
 
 # -----------------------------------------------------------------------------
@@ -91,7 +54,6 @@ def generate_rsi(sirk: bytes) -> bytes:
 class CoordinatedSetIdentificationService(gatt.TemplateService):
     UUID = gatt.GATT_COORDINATED_SET_IDENTIFICATION_SERVICE
 
-    set_identity_resolving_key: bytes
     set_identity_resolving_key_characteristic: gatt.Characteristic
     coordinated_set_size_characteristic: Optional[gatt.Characteristic] = None
     set_member_lock_characteristic: Optional[gatt.Characteristic] = None
@@ -100,21 +62,19 @@ class CoordinatedSetIdentificationService(gatt.TemplateService):
     def __init__(
         self,
         set_identity_resolving_key: bytes,
-        set_identity_resolving_key_type: SirkType,
         coordinated_set_size: Optional[int] = None,
         set_member_lock: Optional[MemberLock] = None,
         set_member_rank: Optional[int] = None,
     ) -> None:
         characteristics = []
 
-        self.set_identity_resolving_key = set_identity_resolving_key
-        self.set_identity_resolving_key_type = set_identity_resolving_key_type
         self.set_identity_resolving_key_characteristic = gatt.Characteristic(
             uuid=gatt.GATT_SET_IDENTITY_RESOLVING_KEY_CHARACTERISTIC,
             properties=gatt.Characteristic.Properties.READ
             | gatt.Characteristic.Properties.NOTIFY,
             permissions=gatt.Characteristic.Permissions.READABLE,
-            value=gatt.CharacteristicValue(read=self.on_sirk_read),
+            # TODO: Implement encrypted SIRK reader.
+            value=struct.pack('B', SirkType.PLAINTEXT) + set_identity_resolving_key,
         )
         characteristics.append(self.set_identity_resolving_key_characteristic)
 
@@ -152,24 +112,6 @@ class CoordinatedSetIdentificationService(gatt.TemplateService):
 
         super().__init__(characteristics)
 
-    def on_sirk_read(self, _connection: device.Connection) -> bytes:
-        if self.set_identity_resolving_key_type == SirkType.PLAINTEXT:
-            return bytes([SirkType.PLAINTEXT]) + self.set_identity_resolving_key
-        else:
-            raise NotImplementedError('TODO: Pending async Characteristic read.')
-
-    def get_advertising_data(self) -> bytes:
-        return bytes(
-            core.AdvertisingData(
-                [
-                    (
-                        core.AdvertisingData.RESOLVABLE_SET_IDENTIFIER,
-                        generate_rsi(self.set_identity_resolving_key),
-                    ),
-                ]
-            )
-        )
-
 
 # -----------------------------------------------------------------------------
 # Client

bumble/rfcomm.py

@@ -118,8 +118,8 @@ CRC_TABLE = bytes([
     0XBA, 0X2B, 0X59, 0XC8, 0XBD, 0X2C, 0X5E, 0XCF
 ])
 
-RFCOMM_DEFAULT_INITIAL_RX_CREDITS = 7
-RFCOMM_DEFAULT_PREFERRED_MTU      = 1280
+RFCOMM_DEFAULT_WINDOW_SIZE    = 16
+RFCOMM_DEFAULT_MAX_FRAME_SIZE = 2000
 
 RFCOMM_DYNAMIC_CHANNEL_NUMBER_START = 1
 RFCOMM_DYNAMIC_CHANNEL_NUMBER_END   = 30
@@ -438,14 +438,16 @@ class DLC(EventEmitter):
         multiplexer: Multiplexer,
         dlci: int,
         max_frame_size: int,
-        initial_tx_credits: int,
+        window_size: int,
     ) -> None:
         super().__init__()
         self.multiplexer = multiplexer
         self.dlci = dlci
-        self.rx_credits = RFCOMM_DEFAULT_INITIAL_RX_CREDITS
-        self.rx_threshold = self.rx_credits // 2
-        self.tx_credits = initial_tx_credits
+        self.max_frame_size = max_frame_size
+        self.window_size = window_size
+        self.rx_credits = window_size
+        self.rx_threshold = window_size // 2
+        self.tx_credits = window_size
         self.tx_buffer = b''
         self.state = DLC.State.INIT
         self.role = multiplexer.role
@@ -537,11 +539,11 @@ class DLC(EventEmitter):
         if len(data) and self.sink:
             self.sink(data)  # pylint: disable=not-callable
 
-        # Update the credits
-        if self.rx_credits > 0:
-            self.rx_credits -= 1
-        else:
-            logger.warning(color('!!! received frame with no rx credits', 'red'))
+            # Update the credits
+            if self.rx_credits > 0:
+                self.rx_credits -= 1
+            else:
+                logger.warning(color('!!! received frame with no rx credits', 'red'))
 
         # Check if there's anything to send (including credits)
         self.process_tx()
@@ -580,9 +582,9 @@ class DLC(EventEmitter):
             cl=0xE0,
             priority=7,
             ack_timer=0,
-            max_frame_size=RFCOMM_DEFAULT_PREFERRED_MTU,
+            max_frame_size=self.max_frame_size,
             max_retransmissions=0,
-            window_size=RFCOMM_DEFAULT_INITIAL_RX_CREDITS,
+            window_size=self.window_size,
         )
         mcc = RFCOMM_Frame.make_mcc(mcc_type=RFCOMM_MCC_PN_TYPE, c_r=0, data=bytes(pn))
         logger.debug(f'>>> PN Response: {pn}')
@@ -591,7 +593,7 @@ class DLC(EventEmitter):
 
     def rx_credits_needed(self) -> int:
         if self.rx_credits <= self.rx_threshold:
-            return RFCOMM_DEFAULT_INITIAL_RX_CREDITS - self.rx_credits
+            return self.window_size - self.rx_credits
 
         return 0
 
@@ -843,7 +845,12 @@ class Multiplexer(EventEmitter):
         )
         await self.disconnection_result
 
-    async def open_dlc(self, channel: int) -> DLC:
+    async def open_dlc(
+        self,
+        channel: int,
+        max_frame_size: int = RFCOMM_DEFAULT_MAX_FRAME_SIZE,
+        window_size: int = RFCOMM_DEFAULT_WINDOW_SIZE,
+    ) -> DLC:
         if self.state != Multiplexer.State.CONNECTED:
             if self.state == Multiplexer.State.OPENING:
                 raise InvalidStateError('open already in progress')
@@ -855,9 +862,9 @@ class Multiplexer(EventEmitter):
             cl=0xF0,
             priority=7,
             ack_timer=0,
-            max_frame_size=RFCOMM_DEFAULT_PREFERRED_MTU,
+            max_frame_size=max_frame_size,
             max_retransmissions=0,
-            window_size=RFCOMM_DEFAULT_INITIAL_RX_CREDITS,
+            window_size=window_size,
         )
         mcc = RFCOMM_Frame.make_mcc(mcc_type=RFCOMM_MCC_PN_TYPE, c_r=1, data=bytes(pn))
         logger.debug(f'>>> Sending MCC: {pn}')

bumble/transport/usb.py

@@ -108,7 +108,7 @@ async def open_usb_transport(spec: str) -> Transport:
         USB_DEVICE_PROTOCOL_BLUETOOTH_PRIMARY_CONTROLLER,
     )
 
-    READ_SIZE = 1024
+    READ_SIZE = 4096
 
     class UsbPacketSink:
         def __init__(self, device, acl_out):

examples/hid_keyboard.json

@@ -1,5 +0,0 @@
-{
-    "name": "Bumble HID Keyboard",
-    "class_of_device": 9664,
-    "keystore": "JsonKeyStore"
-}

examples/keyboard.html

@@ -40,9 +40,9 @@
                 }
             }
             function onMouseMove(event) {
-                //console.log(event.movementX, event.movementY)
-                mouseInfo.innerText = `MOUSE: x=${event.movementX}, y=${event.movementY}`
-                send({ type:'mousemove', x: event.movementX, y: event.movementY })
+                //console.log(event.clientX, event.clientY)
+                mouseInfo.innerText = `MOUSE: x=${event.clientX}, y=${event.clientY}`
+                send({ type:'mousemove', x: event.clientX, y: event.clientY })
             }
 
             function onKeyDown(event) {

examples/run_csis_servers.py

@@ -1,116 +0,0 @@
-# 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
-# -----------------------------------------------------------------------------
-import asyncio
-import logging
-import sys
-import os
-import secrets
-
-from bumble.core import AdvertisingData
-from bumble.device import Device
-from bumble.hci import (
-    Address,
-    OwnAddressType,
-    HCI_LE_Set_Extended_Advertising_Parameters_Command,
-)
-from bumble.profiles.cap import CommonAudioServiceService
-from bumble.profiles.csip import CoordinatedSetIdentificationService, SirkType
-
-from bumble.transport import open_transport_or_link
-
-
-# -----------------------------------------------------------------------------
-async def main() -> None:
-    if len(sys.argv) < 3:
-        print(
-            'Usage: run_cig_setup.py <config-file>'
-            '<transport-spec-for-device-1> <transport-spec-for-device-2>'
-        )
-        print(
-            'example: run_cig_setup.py device1.json'
-            'tcp-client:127.0.0.1:6402 tcp-client:127.0.0.1:6402'
-        )
-        return
-
-    print('<<< connecting to HCI...')
-    hci_transports = await asyncio.gather(
-        open_transport_or_link(sys.argv[2]), open_transport_or_link(sys.argv[3])
-    )
-    print('<<< connected')
-
-    devices = [
-        Device.from_config_file_with_hci(
-            sys.argv[1], hci_transport.source, hci_transport.sink
-        )
-        for hci_transport in hci_transports
-    ]
-
-    sirk = secrets.token_bytes(16)
-
-    for i, device in enumerate(devices):
-        device.random_address = Address(secrets.token_bytes(6))
-        await device.power_on()
-        csis = CoordinatedSetIdentificationService(
-            set_identity_resolving_key=sirk,
-            set_identity_resolving_key_type=SirkType.PLAINTEXT,
-            coordinated_set_size=2,
-        )
-        device.add_service(CommonAudioServiceService(csis))
-        advertising_data = (
-            bytes(
-                AdvertisingData(
-                    [
-                        (
-                            AdvertisingData.COMPLETE_LOCAL_NAME,
-                            bytes(f'Bumble LE Audio-{i}', 'utf-8'),
-                        ),
-                        (
-                            AdvertisingData.FLAGS,
-                            bytes(
-                                [
-                                    AdvertisingData.LE_GENERAL_DISCOVERABLE_MODE_FLAG
-                                    | AdvertisingData.BR_EDR_HOST_FLAG
-                                    | AdvertisingData.BR_EDR_CONTROLLER_FLAG
-                                ]
-                            ),
-                        ),
-                        (
-                            AdvertisingData.INCOMPLETE_LIST_OF_16_BIT_SERVICE_CLASS_UUIDS,
-                            bytes(CoordinatedSetIdentificationService.UUID),
-                        ),
-                    ]
-                )
-            )
-            + csis.get_advertising_data()
-        )
-        await device.start_extended_advertising(
-            advertising_properties=(
-                HCI_LE_Set_Extended_Advertising_Parameters_Command.AdvertisingProperties.CONNECTABLE_ADVERTISING
-            ),
-            own_address_type=OwnAddressType.RANDOM,
-            advertising_data=advertising_data,
-        )
-
-    await asyncio.gather(
-        *[hci_transport.source.terminated for hci_transport in hci_transports]
-    )
-
-
-# -----------------------------------------------------------------------------
-logging.basicConfig(level=os.environ.get('BUMBLE_LOGLEVEL', 'DEBUG').upper())
-asyncio.run(main())

examples/run_hid_device.py

@@ -1,748 +0,0 @@
-# Copyright 2021-2022 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 sys
-import os
-import logging
-import json
-import websockets
-from bumble.colors import color
-
-from bumble.device import Device
-from bumble.transport import open_transport_or_link
-from bumble.core import (
-    BT_BR_EDR_TRANSPORT,
-    BT_L2CAP_PROTOCOL_ID,
-    BT_HUMAN_INTERFACE_DEVICE_SERVICE,
-    BT_HIDP_PROTOCOL_ID,
-    UUID,
-)
-from bumble.hci import Address
-from bumble.hid import (
-    Device as HID_Device,
-    HID_CONTROL_PSM,
-    HID_INTERRUPT_PSM,
-    Message,
-)
-from bumble.sdp import (
-    Client as SDP_Client,
-    DataElement,
-    ServiceAttribute,
-    SDP_PUBLIC_BROWSE_ROOT,
-    SDP_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID,
-    SDP_SERVICE_CLASS_ID_LIST_ATTRIBUTE_ID,
-    SDP_BLUETOOTH_PROFILE_DESCRIPTOR_LIST_ATTRIBUTE_ID,
-    SDP_ALL_ATTRIBUTES_RANGE,
-    SDP_LANGUAGE_BASE_ATTRIBUTE_ID_LIST_ATTRIBUTE_ID,
-    SDP_ADDITIONAL_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID,
-    SDP_SERVICE_RECORD_HANDLE_ATTRIBUTE_ID,
-    SDP_BROWSE_GROUP_LIST_ATTRIBUTE_ID,
-)
-from bumble.utils import AsyncRunner
-
-# -----------------------------------------------------------------------------
-# SDP attributes for Bluetooth HID devices
-SDP_HID_SERVICE_NAME_ATTRIBUTE_ID = 0x0100
-SDP_HID_SERVICE_DESCRIPTION_ATTRIBUTE_ID = 0x0101
-SDP_HID_PROVIDER_NAME_ATTRIBUTE_ID = 0x0102
-SDP_HID_DEVICE_RELEASE_NUMBER_ATTRIBUTE_ID = 0x0200  # [DEPRECATED]
-SDP_HID_PARSER_VERSION_ATTRIBUTE_ID = 0x0201
-SDP_HID_DEVICE_SUBCLASS_ATTRIBUTE_ID = 0x0202
-SDP_HID_COUNTRY_CODE_ATTRIBUTE_ID = 0x0203
-SDP_HID_VIRTUAL_CABLE_ATTRIBUTE_ID = 0x0204
-SDP_HID_RECONNECT_INITIATE_ATTRIBUTE_ID = 0x0205
-SDP_HID_DESCRIPTOR_LIST_ATTRIBUTE_ID = 0x0206
-SDP_HID_LANGID_BASE_LIST_ATTRIBUTE_ID = 0x0207
-SDP_HID_SDP_DISABLE_ATTRIBUTE_ID = 0x0208  # [DEPRECATED]
-SDP_HID_BATTERY_POWER_ATTRIBUTE_ID = 0x0209
-SDP_HID_REMOTE_WAKE_ATTRIBUTE_ID = 0x020A
-SDP_HID_PROFILE_VERSION_ATTRIBUTE_ID = 0x020B  # DEPRECATED]
-SDP_HID_SUPERVISION_TIMEOUT_ATTRIBUTE_ID = 0x020C
-SDP_HID_NORMALLY_CONNECTABLE_ATTRIBUTE_ID = 0x020D
-SDP_HID_BOOT_DEVICE_ATTRIBUTE_ID = 0x020E
-SDP_HID_SSR_HOST_MAX_LATENCY_ATTRIBUTE_ID = 0x020F
-SDP_HID_SSR_HOST_MIN_TIMEOUT_ATTRIBUTE_ID = 0x0210
-
-# Refer to HID profile specification v1.1.1, "5.3 Service Discovery Protocol (SDP)" for details
-# HID SDP attribute values
-LANGUAGE = 0x656E  # 0x656E uint16 “en” (English)
-ENCODING = 0x6A  # 0x006A uint16 UTF-8 encoding
-PRIMARY_LANGUAGE_BASE_ID = 0x100  # 0x0100 uint16 PrimaryLanguageBaseID
-VERSION_NUMBER = 0x0101  # 0x0101 uint16 version number (v1.1)
-SERVICE_NAME = b'Bumble HID'
-SERVICE_DESCRIPTION = b'Bumble'
-PROVIDER_NAME = b'Bumble'
-HID_PARSER_VERSION = 0x0111  # uint16 0x0111 (v1.1.1)
-HID_DEVICE_SUBCLASS = 0xC0  # Combo keyboard/pointing device
-HID_COUNTRY_CODE = 0x21  # 0x21 Uint8, USA
-HID_VIRTUAL_CABLE = True  # Virtual cable enabled
-HID_RECONNECT_INITIATE = True  #  Reconnect initiate enabled
-REPORT_DESCRIPTOR_TYPE = 0x22  # 0x22 Type = Report Descriptor
-HID_LANGID_BASE_LANGUAGE = 0x0409  # 0x0409 Language = English (United States)
-HID_LANGID_BASE_BLUETOOTH_STRING_OFFSET = 0x100  # 0x0100 Default
-HID_BATTERY_POWER = True  #  Battery power enabled
-HID_REMOTE_WAKE = True  #  Remote wake enabled
-HID_SUPERVISION_TIMEOUT = 0xC80  # uint16 0xC80 (2s)
-HID_NORMALLY_CONNECTABLE = True  #  Normally connectable enabled
-HID_BOOT_DEVICE = True  #  Boot device support enabled
-HID_SSR_HOST_MAX_LATENCY = 0x640  # uint16 0x640 (1s)
-HID_SSR_HOST_MIN_TIMEOUT = 0xC80  # uint16 0xC80 (2s)
-HID_REPORT_MAP = bytes(  # Text String, 50 Octet Report Descriptor
-    # pylint: disable=line-too-long
-    [
-        0x05,
-        0x01,  # Usage Page (Generic Desktop Ctrls)
-        0x09,
-        0x06,  # Usage (Keyboard)
-        0xA1,
-        0x01,  # Collection (Application)
-        0x85,
-        0x01,  # . Report ID (1)
-        0x05,
-        0x07,  # . Usage Page (Kbrd/Keypad)
-        0x19,
-        0xE0,  # . Usage Minimum (0xE0)
-        0x29,
-        0xE7,  # . Usage Maximum (0xE7)
-        0x15,
-        0x00,  # . Logical Minimum (0)
-        0x25,
-        0x01,  # . Logical Maximum (1)
-        0x75,
-        0x01,  # . Report Size (1)
-        0x95,
-        0x08,  # . Report Count (8)
-        0x81,
-        0x02,  # . Input (Data,Var,Abs,No Wrap,Linear,Preferred State,No Null Position)
-        0x95,
-        0x01,  # . Report Count (1)
-        0x75,
-        0x08,  # . Report Size (8)
-        0x81,
-        0x03,  # . Input (Const,Var,Abs,No Wrap,Linear,Preferred State,No Null Position)
-        0x95,
-        0x05,  # . Report Count (5)
-        0x75,
-        0x01,  # . Report Size (1)
-        0x05,
-        0x08,  # . Usage Page (LEDs)
-        0x19,
-        0x01,  # . Usage Minimum (Num Lock)
-        0x29,
-        0x05,  # . Usage Maximum (Kana)
-        0x91,
-        0x02,  # . Output (Data,Var,Abs,No Wrap,Linear,Preferred State,No Null Position,Non-volatile)
-        0x95,
-        0x01,  # . Report Count (1)
-        0x75,
-        0x03,  # . Report Size (3)
-        0x91,
-        0x03,  # . Output (Const,Var,Abs,No Wrap,Linear,Preferred State,No Null Position,Non-volatile)
-        0x95,
-        0x06,  # . Report Count (6)
-        0x75,
-        0x08,  # . Report Size (8)
-        0x15,
-        0x00,  # . Logical Minimum (0)
-        0x25,
-        0x65,  # . Logical Maximum (101)
-        0x05,
-        0x07,  # . Usage Page (Kbrd/Keypad)
-        0x19,
-        0x00,  # . Usage Minimum (0x00)
-        0x29,
-        0x65,  # . Usage Maximum (0x65)
-        0x81,
-        0x00,  # . Input (Data,Array,Abs,No Wrap,Linear,Preferred State,No Null Position)
-        0xC0,  # End Collection
-        0x05,
-        0x01,  # Usage Page (Generic Desktop Ctrls)
-        0x09,
-        0x02,  # Usage (Mouse)
-        0xA1,
-        0x01,  # Collection (Application)
-        0x85,
-        0x02,  # . Report ID (2)
-        0x09,
-        0x01,  # . Usage (Pointer)
-        0xA1,
-        0x00,  # . Collection (Physical)
-        0x05,
-        0x09,  # .   Usage Page (Button)
-        0x19,
-        0x01,  # .   Usage Minimum (0x01)
-        0x29,
-        0x03,  # .   Usage Maximum (0x03)
-        0x15,
-        0x00,  # .   Logical Minimum (0)
-        0x25,
-        0x01,  # .   Logical Maximum (1)
-        0x95,
-        0x03,  # .   Report Count (3)
-        0x75,
-        0x01,  # .   Report Size (1)
-        0x81,
-        0x02,  # .   Input (Data,Var,Abs,No Wrap,Linear,Preferred State,No Null Position)
-        0x95,
-        0x01,  # .   Report Count (1)
-        0x75,
-        0x05,  # .   Report Size (5)
-        0x81,
-        0x03,  # .   Input (Const,Var,Abs,No Wrap,Linear,Preferred State,No Null Position)
-        0x05,
-        0x01,  # .   Usage Page (Generic Desktop Ctrls)
-        0x09,
-        0x30,  # .   Usage (X)
-        0x09,
-        0x31,  # .   Usage (Y)
-        0x15,
-        0x81,  # .   Logical Minimum (-127)
-        0x25,
-        0x7F,  # .   Logical Maximum (127)
-        0x75,
-        0x08,  # .   Report Size (8)
-        0x95,
-        0x02,  # .   Report Count (2)
-        0x81,
-        0x06,  # .   Input (Data,Var,Rel,No Wrap,Linear,Preferred State,No Null Position)
-        0xC0,  # . End Collection
-        0xC0,  # End Collection
-    ]
-)
-
-
-# Default protocol mode set to report protocol
-protocol_mode = Message.ProtocolMode.REPORT_PROTOCOL
-
-# -----------------------------------------------------------------------------
-def sdp_records():
-    service_record_handle = 0x00010002
-    return {
-        service_record_handle: [
-            ServiceAttribute(
-                SDP_SERVICE_RECORD_HANDLE_ATTRIBUTE_ID,
-                DataElement.unsigned_integer_32(service_record_handle),
-            ),
-            ServiceAttribute(
-                SDP_BROWSE_GROUP_LIST_ATTRIBUTE_ID,
-                DataElement.sequence([DataElement.uuid(SDP_PUBLIC_BROWSE_ROOT)]),
-            ),
-            ServiceAttribute(
-                SDP_SERVICE_CLASS_ID_LIST_ATTRIBUTE_ID,
-                DataElement.sequence(
-                    [DataElement.uuid(BT_HUMAN_INTERFACE_DEVICE_SERVICE)]
-                ),
-            ),
-            ServiceAttribute(
-                SDP_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID,
-                DataElement.sequence(
-                    [
-                        DataElement.sequence(
-                            [
-                                DataElement.uuid(BT_L2CAP_PROTOCOL_ID),
-                                DataElement.unsigned_integer_16(HID_CONTROL_PSM),
-                            ]
-                        ),
-                        DataElement.sequence(
-                            [
-                                DataElement.uuid(BT_HIDP_PROTOCOL_ID),
-                            ]
-                        ),
-                    ]
-                ),
-            ),
-            ServiceAttribute(
-                SDP_LANGUAGE_BASE_ATTRIBUTE_ID_LIST_ATTRIBUTE_ID,
-                DataElement.sequence(
-                    [
-                        DataElement.unsigned_integer_16(LANGUAGE),
-                        DataElement.unsigned_integer_16(ENCODING),
-                        DataElement.unsigned_integer_16(PRIMARY_LANGUAGE_BASE_ID),
-                    ]
-                ),
-            ),
-            ServiceAttribute(
-                SDP_BLUETOOTH_PROFILE_DESCRIPTOR_LIST_ATTRIBUTE_ID,
-                DataElement.sequence(
-                    [
-                        DataElement.sequence(
-                            [
-                                DataElement.uuid(BT_HUMAN_INTERFACE_DEVICE_SERVICE),
-                                DataElement.unsigned_integer_16(VERSION_NUMBER),
-                            ]
-                        ),
-                    ]
-                ),
-            ),
-            ServiceAttribute(
-                SDP_ADDITIONAL_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID,
-                DataElement.sequence(
-                    [
-                        DataElement.sequence(
-                            [
-                                DataElement.sequence(
-                                    [
-                                        DataElement.uuid(BT_L2CAP_PROTOCOL_ID),
-                                        DataElement.unsigned_integer_16(
-                                            HID_INTERRUPT_PSM
-                                        ),
-                                    ]
-                                ),
-                                DataElement.sequence(
-                                    [
-                                        DataElement.uuid(BT_HIDP_PROTOCOL_ID),
-                                    ]
-                                ),
-                            ]
-                        ),
-                    ]
-                ),
-            ),
-            ServiceAttribute(
-                SDP_HID_SERVICE_NAME_ATTRIBUTE_ID,
-                DataElement(DataElement.TEXT_STRING, SERVICE_NAME),
-            ),
-            ServiceAttribute(
-                SDP_HID_SERVICE_DESCRIPTION_ATTRIBUTE_ID,
-                DataElement(DataElement.TEXT_STRING, SERVICE_DESCRIPTION),
-            ),
-            ServiceAttribute(
-                SDP_HID_PROVIDER_NAME_ATTRIBUTE_ID,
-                DataElement(DataElement.TEXT_STRING, PROVIDER_NAME),
-            ),
-            ServiceAttribute(
-                SDP_HID_PARSER_VERSION_ATTRIBUTE_ID,
-                DataElement.unsigned_integer_32(HID_PARSER_VERSION),
-            ),
-            ServiceAttribute(
-                SDP_HID_DEVICE_SUBCLASS_ATTRIBUTE_ID,
-                DataElement.unsigned_integer_32(HID_DEVICE_SUBCLASS),
-            ),
-            ServiceAttribute(
-                SDP_HID_COUNTRY_CODE_ATTRIBUTE_ID,
-                DataElement.unsigned_integer_32(HID_COUNTRY_CODE),
-            ),
-            ServiceAttribute(
-                SDP_HID_VIRTUAL_CABLE_ATTRIBUTE_ID,
-                DataElement.boolean(HID_VIRTUAL_CABLE),
-            ),
-            ServiceAttribute(
-                SDP_HID_RECONNECT_INITIATE_ATTRIBUTE_ID,
-                DataElement.boolean(HID_RECONNECT_INITIATE),
-            ),
-            ServiceAttribute(
-                SDP_HID_DESCRIPTOR_LIST_ATTRIBUTE_ID,
-                DataElement.sequence(
-                    [
-                        DataElement.sequence(
-                            [
-                                DataElement.unsigned_integer_16(REPORT_DESCRIPTOR_TYPE),
-                                DataElement(DataElement.TEXT_STRING, HID_REPORT_MAP),
-                            ]
-                        ),
-                    ]
-                ),
-            ),
-            ServiceAttribute(
-                SDP_HID_LANGID_BASE_LIST_ATTRIBUTE_ID,
-                DataElement.sequence(
-                    [
-                        DataElement.sequence(
-                            [
-                                DataElement.unsigned_integer_16(
-                                    HID_LANGID_BASE_LANGUAGE
-                                ),
-                                DataElement.unsigned_integer_16(
-                                    HID_LANGID_BASE_BLUETOOTH_STRING_OFFSET
-                                ),
-                            ]
-                        ),
-                    ]
-                ),
-            ),
-            ServiceAttribute(
-                SDP_HID_BATTERY_POWER_ATTRIBUTE_ID,
-                DataElement.boolean(HID_BATTERY_POWER),
-            ),
-            ServiceAttribute(
-                SDP_HID_REMOTE_WAKE_ATTRIBUTE_ID,
-                DataElement.boolean(HID_REMOTE_WAKE),
-            ),
-            ServiceAttribute(
-                SDP_HID_SUPERVISION_TIMEOUT_ATTRIBUTE_ID,
-                DataElement.unsigned_integer_16(HID_SUPERVISION_TIMEOUT),
-            ),
-            ServiceAttribute(
-                SDP_HID_NORMALLY_CONNECTABLE_ATTRIBUTE_ID,
-                DataElement.boolean(HID_NORMALLY_CONNECTABLE),
-            ),
-            ServiceAttribute(
-                SDP_HID_BOOT_DEVICE_ATTRIBUTE_ID,
-                DataElement.boolean(HID_BOOT_DEVICE),
-            ),
-            ServiceAttribute(
-                SDP_HID_SSR_HOST_MAX_LATENCY_ATTRIBUTE_ID,
-                DataElement.unsigned_integer_16(HID_SSR_HOST_MAX_LATENCY),
-            ),
-            ServiceAttribute(
-                SDP_HID_SSR_HOST_MIN_TIMEOUT_ATTRIBUTE_ID,
-                DataElement.unsigned_integer_16(HID_SSR_HOST_MIN_TIMEOUT),
-            ),
-        ]
-    }
-
-
-# -----------------------------------------------------------------------------
-async def get_stream_reader(pipe) -> asyncio.StreamReader:
-    loop = asyncio.get_event_loop()
-    reader = asyncio.StreamReader(loop=loop)
-    protocol = asyncio.StreamReaderProtocol(reader)
-    await loop.connect_read_pipe(lambda: protocol, pipe)
-    return reader
-
-
-class DeviceData:
-    def __init__(self) -> None:
-        self.keyboardData = bytearray(
-            [0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]
-        )
-        self.mouseData = bytearray([0x02, 0x00, 0x00, 0x00])
-
-
-# Device's live data - Mouse and Keyboard will be stored in this
-deviceData = DeviceData()
-
-# -----------------------------------------------------------------------------
-async def keyboard_device(hid_device):
-
-    # Start a Websocket server to receive events from a web page
-    async def serve(websocket, _path):
-        global deviceData
-        while True:
-            try:
-                message = await websocket.recv()
-                print('Received: ', str(message))
-                parsed = json.loads(message)
-                message_type = parsed['type']
-                if message_type == 'keydown':
-                    # Only deal with keys a to z for now
-                    key = parsed['key']
-                    if len(key) == 1:
-                        code = ord(key)
-                        if ord('a') <= code <= ord('z'):
-                            hid_code = 0x04 + code - ord('a')
-                            deviceData.keyboardData = bytearray(
-                                [
-                                    0x01,
-                                    0x00,
-                                    0x00,
-                                    hid_code,
-                                    0x00,
-                                    0x00,
-                                    0x00,
-                                    0x00,
-                                    0x00,
-                                ]
-                            )
-                            hid_device.send_data(deviceData.keyboardData)
-                elif message_type == 'keyup':
-                    deviceData.keyboardData = bytearray(
-                        [0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]
-                    )
-                    hid_device.send_data(deviceData.keyboardData)
-                elif message_type == "mousemove":
-                    # logical min and max values
-                    log_min = -127
-                    log_max = 127
-                    x = parsed['x']
-                    y = parsed['y']
-                    # limiting x and y values within logical max and min range
-                    x = max(log_min, min(log_max, x))
-                    y = max(log_min, min(log_max, y))
-                    x_cord = x.to_bytes(signed=True)
-                    y_cord = y.to_bytes(signed=True)
-                    deviceData.mouseData = bytearray([0x02, 0x00]) + x_cord + y_cord
-                    hid_device.send_data(deviceData.mouseData)
-            except websockets.exceptions.ConnectionClosedOK:
-                pass
-
-    # pylint: disable-next=no-member
-    await websockets.serve(serve, 'localhost', 8989)
-    await asyncio.get_event_loop().create_future()
-
-
-# -----------------------------------------------------------------------------
-async def main():
-    if len(sys.argv) < 3:
-        print(
-            'Usage: python run_hid_device.py <device-config> <transport-spec> <command>'
-            '  where <command> is one of:\n'
-            '  test-mode (run with menu enabled for testing)\n'
-            '  web (run a keyboard with keypress input from a web page, '
-            'see keyboard.html'
-        )
-        print('example: python run_hid_device.py hid_keyboard.json usb:0 web')
-        print('example: python run_hid_device.py hid_keyboard.json usb:0 test-mode')
-
-        return
-
-    async def handle_virtual_cable_unplug():
-        hid_host_bd_addr = str(hid_device.remote_device_bd_address)
-        await hid_device.disconnect_interrupt_channel()
-        await hid_device.disconnect_control_channel()
-        await device.keystore.delete(hid_host_bd_addr)  # type: ignore
-        connection = hid_device.connection
-        if connection is not None:
-            await connection.disconnect()
-
-    def on_hid_data_cb(pdu: bytes):
-        print(f'Received Data, PDU: {pdu.hex()}')
-
-    def on_get_report_cb(report_id: int, report_type: int, buffer_size: int):
-        retValue = hid_device.GetSetStatus()
-        print(
-            "GET_REPORT report_id: "
-            + str(report_id)
-            + "report_type: "
-            + str(report_type)
-            + "buffer_size:"
-            + str(buffer_size)
-        )
-        if report_type == Message.ReportType.INPUT_REPORT:
-            if report_id == 1:
-                retValue.data = deviceData.keyboardData[1:]
-                retValue.status = hid_device.GetSetReturn.SUCCESS
-            elif report_id == 2:
-                retValue.data = deviceData.mouseData[1:]
-                retValue.status = hid_device.GetSetReturn.SUCCESS
-            else:
-                retValue.status = hid_device.GetSetReturn.REPORT_ID_NOT_FOUND
-
-            if buffer_size:
-                data_len = buffer_size - 1
-                retValue.data = retValue.data[:data_len]
-        elif report_type == Message.ReportType.OUTPUT_REPORT:
-            # This sample app has nothing to do with the report received, to enable PTS
-            # testing, we will return single byte random data.
-            retValue.data = bytearray([0x11])
-            retValue.status = hid_device.GetSetReturn.SUCCESS
-        elif report_type == Message.ReportType.FEATURE_REPORT:
-            retValue.status = hid_device.GetSetReturn.ERR_INVALID_PARAMETER
-        elif report_type == Message.ReportType.OTHER_REPORT:
-            if report_id == 3:
-                retValue.status = hid_device.GetSetReturn.REPORT_ID_NOT_FOUND
-        else:
-            retValue.status = hid_device.GetSetReturn.FAILURE
-
-        return retValue
-
-    def on_set_report_cb(
-        report_id: int, report_type: int, report_size: int, data: bytes
-    ):
-        retValue = hid_device.GetSetStatus()
-        print(
-            "SET_REPORT report_id: "
-            + str(report_id)
-            + "report_type: "
-            + str(report_type)
-            + "report_size "
-            + str(report_size)
-            + "data:"
-            + str(data)
-        )
-        if report_type == Message.ReportType.FEATURE_REPORT:
-            retValue.status = hid_device.GetSetReturn.ERR_INVALID_PARAMETER
-        elif report_type == Message.ReportType.INPUT_REPORT:
-            if report_id == 1 and report_size != len(deviceData.keyboardData):
-                retValue.status = hid_device.GetSetReturn.ERR_INVALID_PARAMETER
-            elif report_id == 2 and report_size != len(deviceData.mouseData):
-                retValue.status = hid_device.GetSetReturn.ERR_INVALID_PARAMETER
-            elif report_id == 3:
-                retValue.status = hid_device.GetSetReturn.REPORT_ID_NOT_FOUND
-            else:
-                retValue.status = hid_device.GetSetReturn.SUCCESS
-        else:
-            retValue.status = hid_device.GetSetReturn.SUCCESS
-
-        return retValue
-
-    def on_get_protocol_cb():
-        retValue = hid_device.GetSetStatus()
-        retValue.data = protocol_mode.to_bytes()
-        retValue.status = hid_device.GetSetReturn.SUCCESS
-        return retValue
-
-    def on_set_protocol_cb(protocol: int):
-        retValue = hid_device.GetSetStatus()
-        # We do not support SET_PROTOCOL.
-        print("SET_PROTOCOL report_id: " + str(protocol))
-        retValue.status = hid_device.GetSetReturn.ERR_UNSUPPORTED_REQUEST
-        return retValue
-
-    def on_virtual_cable_unplug_cb():
-        print(f'Received Virtual Cable Unplug')
-        asyncio.create_task(handle_virtual_cable_unplug())
-
-    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
-
-        # Create and register HID device
-        hid_device = HID_Device(device)
-
-        # Register for  call backs
-        hid_device.on('interrupt_data', on_hid_data_cb)
-
-        hid_device.register_get_report_cb(on_get_report_cb)
-        hid_device.register_set_report_cb(on_set_report_cb)
-        hid_device.register_get_protocol_cb(on_get_protocol_cb)
-        hid_device.register_set_protocol_cb(on_set_protocol_cb)
-
-        # Register for virtual cable unplug call back
-        hid_device.on('virtual_cable_unplug', on_virtual_cable_unplug_cb)
-
-        # Setup the SDP to advertise HID Device service
-        device.sdp_service_records = sdp_records()
-
-        # Start the controller
-        await device.power_on()
-
-        # Start being discoverable and connectable
-        await device.set_discoverable(True)
-        await device.set_connectable(True)
-
-        async def menu():
-            reader = await get_stream_reader(sys.stdin)
-            while True:
-                print(
-                    "\n************************ HID Device Menu *****************************\n"
-                )
-                print(" 1. Connect Control Channel")
-                print(" 2. Connect Interrupt Channel")
-                print(" 3. Disconnect Control Channel")
-                print(" 4. Disconnect Interrupt Channel")
-                print(" 5. Send Report on Interrupt Channel")
-                print(" 6. Virtual Cable Unplug")
-                print(" 7. Disconnect device")
-                print(" 8. Delete Bonding")
-                print(" 9. Re-connect to device")
-                print("10. Exit ")
-                print("\nEnter your choice : \n")
-
-                choice = await reader.readline()
-                choice = choice.decode('utf-8').strip()
-
-                if choice == '1':
-                    await hid_device.connect_control_channel()
-
-                elif choice == '2':
-                    await hid_device.connect_interrupt_channel()
-
-                elif choice == '3':
-                    await hid_device.disconnect_control_channel()
-
-                elif choice == '4':
-                    await hid_device.disconnect_interrupt_channel()
-
-                elif choice == '5':
-                    print(" 1. Report ID 0x01")
-                    print(" 2. Report ID 0x02")
-                    print(" 3. Invalid Report ID")
-
-                    choice1 = await reader.readline()
-                    choice1 = choice1.decode('utf-8').strip()
-
-                    if choice1 == '1':
-                        data = bytearray(
-                            [0x01, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00]
-                        )
-                        hid_device.send_data(data)
-                        data = bytearray(
-                            [0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]
-                        )
-                        hid_device.send_data(data)
-
-                    elif choice1 == '2':
-                        data = bytearray([0x02, 0x00, 0x00, 0xF6])
-                        hid_device.send_data(data)
-                        data = bytearray([0x02, 0x00, 0x00, 0x00])
-                        hid_device.send_data(data)
-
-                    elif choice1 == '3':
-                        data = bytearray([0x00, 0x00, 0x00, 0x00])
-                        hid_device.send_data(data)
-                        data = bytearray([0x00, 0x00, 0x00, 0x00])
-                        hid_device.send_data(data)
-
-                    else:
-                        print('Incorrect option selected')
-
-                elif choice == '6':
-                    hid_device.virtual_cable_unplug()
-                    try:
-                        hid_host_bd_addr = str(hid_device.remote_device_bd_address)
-                        await device.keystore.delete(hid_host_bd_addr)
-                    except KeyError:
-                        print('Device not found or Device already unpaired.')
-
-                elif choice == '7':
-                    connection = hid_device.connection
-                    if connection is not None:
-                        await connection.disconnect()
-                    else:
-                        print("Already disconnected from device")
-
-                elif choice == '8':
-                    try:
-                        hid_host_bd_addr = str(hid_device.remote_device_bd_address)
-                        await device.keystore.delete(hid_host_bd_addr)
-                    except KeyError:
-                        print('Device NOT found or Device already unpaired.')
-
-                elif choice == '9':
-                    hid_host_bd_addr = str(hid_device.remote_device_bd_address)
-                    connection = await device.connect(
-                        hid_host_bd_addr, transport=BT_BR_EDR_TRANSPORT
-                    )
-                    await connection.authenticate()
-                    await connection.encrypt()
-
-                elif choice == '10':
-                    sys.exit("Exit successful")
-
-                else:
-                    print("Invalid option selected.")
-
-        if (len(sys.argv) > 3) and (sys.argv[3] == 'test-mode'):
-            # Test mode for PTS/Unit testing
-            await menu()
-        else:
-            # default option is using keyboard.html (web)
-            print("Executing in Web mode")
-            await keyboard_device(hid_device)
-
-        await hci_source.wait_for_termination()
-
-
-# -----------------------------------------------------------------------------
-logging.basicConfig(level=os.environ.get('BUMBLE_LOGLEVEL', 'DEBUG').upper())
-asyncio.run(main())

examples/run_hid_host.py

@@ -285,10 +285,7 @@ async def main():
         print('example: run_hid_host.py classic1.json usb:0 E1:CA:72:48:C4:E8/P')
         return
 
-    def on_hid_control_data_cb(pdu: bytes):
-        print(f'Received Control Data, PDU: {pdu.hex()}')
-
-    def on_hid_interrupt_data_cb(pdu: bytes):
+    def on_hid_data_cb(pdu):
         report_type = pdu[0] & 0x0F
         if len(pdu) == 1:
             print(color(f'Warning: No report received', 'yellow'))
@@ -308,7 +305,7 @@ async def main():
 
         if (report_length <= 1) or (report_id == 0):
             return
-        # Parse report over interrupt channel
+
         if report_type == Message.ReportType.INPUT_REPORT:
             ReportParser.parse_input_report(pdu[1:])  # type: ignore
 
@@ -316,9 +313,7 @@ async def main():
         await hid_host.disconnect_interrupt_channel()
         await hid_host.disconnect_control_channel()
         await device.keystore.delete(target_address)  # type: ignore
-        connection = hid_host.connection
-        if connection is not None:
-            await connection.disconnect()
+        await connection.disconnect()
 
     def on_hid_virtual_cable_unplug_cb():
         asyncio.create_task(handle_virtual_cable_unplug())
@@ -330,18 +325,6 @@ async def main():
         # Create a device
         device = Device.from_config_file_with_hci(sys.argv[1], hci_source, hci_sink)
         device.classic_enabled = True
-
-        # Create HID host and start it
-        print('@@@ Starting HID Host...')
-        hid_host = Host(device)
-
-        # Register for HID data call back
-        hid_host.on('interrupt_data', on_hid_interrupt_data_cb)
-        hid_host.on('control_data', on_hid_control_data_cb)
-
-        # Register for virtual cable unplug call back
-        hid_host.on('virtual_cable_unplug', on_hid_virtual_cable_unplug_cb)
-
         await device.power_on()
 
         # Connect to a peer
@@ -362,6 +345,16 @@ async def main():
 
         await get_hid_device_sdp_record(connection)
 
+        # Create HID host and start it
+        print('@@@ Starting HID Host...')
+        hid_host = Host(device, connection)
+
+        # Register for HID data call back
+        hid_host.on('data', on_hid_data_cb)
+
+        # Register for virtual cable unplug call back
+        hid_host.on('virtual_cable_unplug', on_hid_virtual_cable_unplug_cb)
+
         async def menu():
             reader = await get_stream_reader(sys.stdin)
             while True:
@@ -376,14 +369,13 @@ async def main():
                 print(" 6. Set Report")
                 print(" 7. Set Protocol Mode")
                 print(" 8. Get Protocol Mode")
-                print(" 9. Send Report on Interrupt Channel")
+                print(" 9. Send Report")
                 print("10. Suspend")
                 print("11. Exit Suspend")
                 print("12. Virtual Cable Unplug")
                 print("13. Disconnect device")
                 print("14. Delete Bonding")
                 print("15. Re-connect to device")
-                print("16. Exit")
                 print("\nEnter your choice : \n")
 
                 choice = await reader.readline()
@@ -402,40 +394,21 @@ async def main():
                     await hid_host.disconnect_interrupt_channel()
 
                 elif choice == '5':
-                    print(" 1. Input Report with ID 0x01")
-                    print(" 2. Input Report with ID 0x02")
-                    print(" 3. Input Report with ID 0x0F - Invalid ReportId")
-                    print(" 4. Output Report with ID 0x02")
-                    print(" 5. Feature Report with ID 0x05 - Unsupported Request")
-                    print(" 6. Input Report with ID 0x02, BufferSize 3")
-                    print(" 7. Output Report with ID 0x03, BufferSize 2")
-                    print(" 8. Feature Report with ID 0x05,  BufferSize 3")
+                    print(" 1. Report ID 0x02")
+                    print(" 2. Report ID 0x03")
+                    print(" 3. Report ID 0x05")
                     choice1 = await reader.readline()
                     choice1 = choice1.decode('utf-8').strip()
 
                     if choice1 == '1':
-                        hid_host.get_report(1, 1, 0)
-
-                    elif choice1 == '2':
-                        hid_host.get_report(1, 2, 0)
-
-                    elif choice1 == '3':
-                        hid_host.get_report(1, 5, 0)
-
-                    elif choice1 == '4':
-                        hid_host.get_report(2, 2, 0)
-
-                    elif choice1 == '5':
-                        hid_host.get_report(3, 15, 0)
-
-                    elif choice1 == '6':
                         hid_host.get_report(1, 2, 3)
 
-                    elif choice1 == '7':
+                    elif choice1 == '2':
                         hid_host.get_report(2, 3, 2)
 
-                    elif choice1 == '8':
+                    elif choice1 == '3':
                         hid_host.get_report(3, 5, 3)
+
                     else:
                         print('Incorrect option selected')
 
@@ -511,7 +484,6 @@ async def main():
                     hid_host.virtual_cable_unplug()
                     try:
                         await device.keystore.delete(target_address)
-                        print("Unpair successful")
                     except KeyError:
                         print('Device not found or Device already unpaired.')
 
@@ -541,9 +513,6 @@ async def main():
                     await connection.authenticate()
                     await connection.encrypt()
 
-                elif choice == '16':
-                    sys.exit("Exit successful")
-
                 else:
                     print("Invalid option selected.")
 

examples/run_unicast_server.py

@@ -20,7 +20,6 @@ import logging
 import sys
 import os
 import struct
-import secrets
 from bumble.core import AdvertisingData
 from bumble.device import Device, CisLink
 from bumble.hci import (
@@ -40,8 +39,6 @@ from bumble.profiles.bap import (
     PublishedAudioCapabilitiesService,
     AudioStreamControlService,
 )
-from bumble.profiles.cap import CommonAudioServiceService
-from bumble.profiles.csip import CoordinatedSetIdentificationService, SirkType
 
 from bumble.transport import open_transport_or_link
 
@@ -63,11 +60,6 @@ async def main() -> None:
 
         await device.power_on()
 
-        csis = CoordinatedSetIdentificationService(
-            set_identity_resolving_key=secrets.token_bytes(16),
-            set_identity_resolving_key_type=SirkType.PLAINTEXT,
-        )
-        device.add_service(CommonAudioServiceService(csis))
         device.add_service(
             PublishedAudioCapabilitiesService(
                 supported_source_context=ContextType.PROHIBITED,
@@ -116,32 +108,29 @@ async def main() -> None:
 
         device.add_service(AudioStreamControlService(device, sink_ase_id=[1, 2]))
 
-        advertising_data = (
-            bytes(
-                AdvertisingData(
-                    [
-                        (
-                            AdvertisingData.COMPLETE_LOCAL_NAME,
-                            bytes('Bumble LE Audio', 'utf-8'),
+        advertising_data = bytes(
+            AdvertisingData(
+                [
+                    (
+                        AdvertisingData.COMPLETE_LOCAL_NAME,
+                        bytes('Bumble LE Audio', 'utf-8'),
+                    ),
+                    (
+                        AdvertisingData.FLAGS,
+                        bytes(
+                            [
+                                AdvertisingData.LE_GENERAL_DISCOVERABLE_MODE_FLAG
+                                | AdvertisingData.BR_EDR_HOST_FLAG
+                                | AdvertisingData.BR_EDR_CONTROLLER_FLAG
+                            ]
                         ),
-                        (
-                            AdvertisingData.FLAGS,
-                            bytes(
-                                [
-                                    AdvertisingData.LE_GENERAL_DISCOVERABLE_MODE_FLAG
-                                    | AdvertisingData.BR_EDR_HOST_FLAG
-                                    | AdvertisingData.BR_EDR_CONTROLLER_FLAG
-                                ]
-                            ),
-                        ),
-                        (
-                            AdvertisingData.INCOMPLETE_LIST_OF_16_BIT_SERVICE_CLASS_UUIDS,
-                            bytes(PublishedAudioCapabilitiesService.UUID),
-                        ),
-                    ]
-                )
+                    ),
+                    (
+                        AdvertisingData.INCOMPLETE_LIST_OF_16_BIT_SERVICE_CLASS_UUIDS,
+                        bytes(PublishedAudioCapabilitiesService.UUID),
+                    ),
+                ]
             )
-            + csis.get_advertising_data()
         )
         subprocess = await asyncio.create_subprocess_shell(
             f'dlc3 | ffplay pipe:0',

extras/android/RemoteHCI/app/src/main/java/com/github/google/bumble/remotehci/HciServer.java

@@ -42,6 +42,7 @@ public class HciServer {
         try (ServerSocket serverSocket = new ServerSocket(mPort)) {
             mListener.onMessage("Waiting for connection on port " + serverSocket.getLocalPort());
             try (Socket clientSocket = serverSocket.accept()) {
+                clientSocket.setTcpNoDelay(true);
                 mListener.onHostConnectionState(true);
                 mListener.onMessage("Connected");
                 HciParser parser = new HciParser(mListener);

setup.cfg

@@ -56,7 +56,6 @@ install_requires =
 
 [options.entry_points]
 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-gatt-dump = bumble.apps.gatt_dump:main

tests/cap_test.py

@@ -1,71 +0,0 @@
-# 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
-# -----------------------------------------------------------------------------
-import asyncio
-import os
-import pytest
-import logging
-
-from bumble import device
-from bumble import gatt
-from bumble.profiles import cap
-from bumble.profiles import csip
-from .test_utils import TwoDevices
-
-# -----------------------------------------------------------------------------
-# Logging
-# -----------------------------------------------------------------------------
-logger = logging.getLogger(__name__)
-
-
-# -----------------------------------------------------------------------------
-@pytest.mark.asyncio
-async def test_cas():
-    SIRK = bytes.fromhex('2f62c8ae41867d1bb619e788a2605faa')
-
-    devices = TwoDevices()
-    devices[0].add_service(
-        cap.CommonAudioServiceService(
-            csip.CoordinatedSetIdentificationService(
-                set_identity_resolving_key=SIRK,
-                set_identity_resolving_key_type=csip.SirkType.PLAINTEXT,
-            )
-        )
-    )
-
-    await devices.setup_connection()
-    peer = device.Peer(devices.connections[1])
-    cas_client = await peer.discover_service_and_create_proxy(
-        cap.CommonAudioServiceServiceProxy
-    )
-
-    included_services = await peer.discover_included_services(cas_client.service_proxy)
-    assert any(
-        service.uuid == gatt.GATT_COORDINATED_SET_IDENTIFICATION_SERVICE
-        for service in included_services
-    )
-
-
-# -----------------------------------------------------------------------------
-async def run():
-    await test_cas()
-
-
-# -----------------------------------------------------------------------------
-if __name__ == '__main__':
-    logging.basicConfig(level=os.environ.get('BUMBLE_LOGLEVEL', 'INFO').upper())
-    asyncio.run(run())

tests/controller_test.py

@@ -1,138 +0,0 @@
-# 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 logging
-import os
-import pytest
-from typing import List, Optional
-from unittest.mock import MagicMock
-
-from bumble.device import Connection, Device
-from bumble.host import Host
-from bumble.link import LocalLink
-from bumble.controller import Controller
-from bumble.hci import (
-    Address,
-    HCI_CONNECTION_TERMINATED_BY_LOCAL_HOST_ERROR,
-    HCI_REMOTE_DEVICE_TERMINATED_CONNECTION_DUE_TO_LOW_RESOURCES_ERROR,
-)
-from bumble.transport import AsyncPipeSink
-
-
-# -----------------------------------------------------------------------------
-class TwoDevices:
-    connections: List[Optional[Connection]]
-
-    def __init__(self) -> None:
-        self.connections = [None, None]
-
-        self.link = LocalLink()
-        self.controllers = [
-            Controller('C1', link=self.link),
-            Controller('C2', link=self.link),
-        ]
-        self.devices = [
-            Device(
-                address=Address('F0:F1:F2:F3:F4:F5'),
-                host=Host(self.controllers[0], AsyncPipeSink(self.controllers[0])),
-            ),
-            Device(
-                address=Address('F5:F4:F3:F2:F1:F0'),
-                host=Host(self.controllers[1], AsyncPipeSink(self.controllers[1])),
-            ),
-        ]
-
-        self.paired = [None, None]
-
-    def on_connection(self, which, connection):
-        self.connections[which] = connection
-        connection.on(
-            'disconnection', lambda reason: self.on_disconnection(which, reason)
-        )
-
-    def on_disconnection(self, which, _):
-        self.connections[which] = None
-
-    async def setup(self):
-        self.devices[0].on(
-            'connection', lambda connection: self.on_connection(0, connection)
-        )
-        self.devices[1].on(
-            'connection', lambda connection: self.on_connection(1, connection)
-        )
-
-        await self.devices[0].power_on()
-        await self.devices[1].power_on()
-
-
-# -----------------------------------------------------------------------------
-@pytest.mark.asyncio
-async def test_self_connection():
-    two_devices = TwoDevices()
-    await two_devices.setup()
-
-    await two_devices.devices[0].connect(two_devices.devices[1].random_address)
-
-    assert two_devices.connections[0] is not None
-    assert two_devices.connections[1] is not None
-
-    mock0 = MagicMock()
-    mock1 = MagicMock()
-    two_devices.connections[0].once('disconnection', mock0)
-    two_devices.connections[1].once('disconnection', mock1)
-    await two_devices.connections[0].disconnect(
-        HCI_REMOTE_DEVICE_TERMINATED_CONNECTION_DUE_TO_LOW_RESOURCES_ERROR
-    )
-    mock0.assert_called_once_with(HCI_CONNECTION_TERMINATED_BY_LOCAL_HOST_ERROR)
-    mock1.assert_called_once_with(
-        HCI_REMOTE_DEVICE_TERMINATED_CONNECTION_DUE_TO_LOW_RESOURCES_ERROR
-    )
-
-    assert two_devices.connections[0] is None
-    assert two_devices.connections[1] is None
-
-    await two_devices.devices[0].connect(two_devices.devices[1].random_address)
-
-    assert two_devices.connections[0] is not None
-    assert two_devices.connections[1] is not None
-
-    mock0 = MagicMock()
-    mock1 = MagicMock()
-    two_devices.connections[0].once('disconnection', mock0)
-    two_devices.connections[1].once('disconnection', mock1)
-    await two_devices.connections[1].disconnect(
-        HCI_REMOTE_DEVICE_TERMINATED_CONNECTION_DUE_TO_LOW_RESOURCES_ERROR
-    )
-    mock1.assert_called_once_with(HCI_CONNECTION_TERMINATED_BY_LOCAL_HOST_ERROR)
-    mock0.assert_called_once_with(
-        HCI_REMOTE_DEVICE_TERMINATED_CONNECTION_DUE_TO_LOW_RESOURCES_ERROR
-    )
-
-    assert two_devices.connections[0] is None
-    assert two_devices.connections[1] is None
-
-
-# -----------------------------------------------------------------------------
-async def run_test_controller():
-    await test_self_connection()
-
-
-# -----------------------------------------------------------------------------
-if __name__ == '__main__':
-    logging.basicConfig(level=os.environ.get('BUMBLE_LOGLEVEL', 'INFO').upper())
-    asyncio.run(run_test_controller())

tests/csip_test.py

@@ -31,41 +31,6 @@ from .test_utils import TwoDevices
 logger = logging.getLogger(__name__)
 
 
-# -----------------------------------------------------------------------------
-def test_s1():
-    assert (
-        csip.s1(b'SIRKenc'[::-1])
-        == bytes.fromhex('6901983f 18149e82 3c7d133a 7d774572')[::-1]
-    )
-
-
-# -----------------------------------------------------------------------------
-def test_k1():
-    K = bytes.fromhex('676e1b9b d448696f 061ec622 3ce5ced9')[::-1]
-    SALT = csip.s1(b'SIRKenc'[::-1])
-    P = b'csis'[::-1]
-    assert (
-        csip.k1(K, SALT, P)
-        == bytes.fromhex('5277453c c094d982 b0e8ee53 2f2d1f8b')[::-1]
-    )
-
-
-# -----------------------------------------------------------------------------
-def test_sih():
-    SIRK = bytes.fromhex('457d7d09 21a1fd22 cecd8c86 dd72cccd')[::-1]
-    PRAND = bytes.fromhex('69f563')[::-1]
-    assert csip.sih(SIRK, PRAND) == bytes.fromhex('1948da')[::-1]
-
-
-# -----------------------------------------------------------------------------
-def test_sef():
-    SIRK = bytes.fromhex('457d7d09 21a1fd22 cecd8c86 dd72cccd')[::-1]
-    K = bytes.fromhex('676e1b9b d448696f 061ec622 3ce5ced9')[::-1]
-    assert (
-        csip.sef(K, SIRK) == bytes.fromhex('170a3835 e13524a0 7e2562d5 f25fd346')[::-1]
-    )
-
-
 # -----------------------------------------------------------------------------
 @pytest.mark.asyncio
 async def test_csis():
@@ -75,7 +40,6 @@ async def test_csis():
     devices[0].add_service(
         csip.CoordinatedSetIdentificationService(
             set_identity_resolving_key=SIRK,
-            set_identity_resolving_key_type=csip.SirkType.PLAINTEXT,
             coordinated_set_size=2,
             set_member_lock=csip.MemberLock.UNLOCKED,
             set_member_rank=0,
@@ -101,7 +65,6 @@ async def test_csis():
 
 # -----------------------------------------------------------------------------
 async def run():
-    test_sih()
     await test_csis()
 
 

tests/device_test.py

@@ -29,7 +29,7 @@ from bumble.core import (
     ConnectionParameters,
 )
 from bumble.device import Connection, Device
-from bumble.host import Host
+from bumble.host import AclPacketQueue, Host
 from bumble.hci import (
     HCI_ACCEPT_CONNECTION_REQUEST_COMMAND,
     HCI_COMMAND_STATUS_PENDING,
@@ -73,6 +73,13 @@ async def test_device_connect_parallel():
     d1 = Device(host=Host(None, None))
     d2 = Device(host=Host(None, None))
 
+    def _send(packet):
+        pass
+
+    d0.host.acl_packet_queue = AclPacketQueue(0, 0, _send)
+    d1.host.acl_packet_queue = AclPacketQueue(0, 0, _send)
+    d2.host.acl_packet_queue = AclPacketQueue(0, 0, _send)
+
     # enable classic
     d0.classic_enabled = True
     d1.classic_enabled = True