fix merge issues

.github/workflows/code-check.yml

@@ -29,11 +29,11 @@ jobs:
     - name: Set up Python
       uses: actions/setup-python@v3
       with:
-        python-version: ${{ matrix.python-version }}
+        python-version: '3.10'
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
-        python -m pip install ".[build,test,development,pandora]"
+        python -m pip install ".[build,test,development]"
     - name: Check
       run: |
         invoke project.pre-commit

.github/workflows/python-avatar.yml

@@ -32,7 +32,7 @@ jobs:
       - name: Install
         run: |
           python -m pip install --upgrade pip
-          python -m pip install .[avatar,pandora]
+          python -m pip install .[avatar]
       - name: Rootcanal
         run: nohup python -m rootcanal > rootcanal.log &
       - name: Test

.github/workflows/python-build-test.yml

@@ -47,7 +47,7 @@ jobs:
     strategy:
       matrix:
         python-version: [ "3.8", "3.9", "3.10", "3.11" ]
-        rust-version: [ "1.76.0", "stable" ]
+        rust-version: [ "1.70.0", "stable" ]
       fail-fast: false
     steps:
       - name: Check out from Git

.gitignore

@@ -6,14 +6,7 @@ dist/
 docs/mkdocs/site
 test-results.xml
 __pycache__
-# Vim
-.*.sw*
 # generated by setuptools_scm
 bumble/_version.py
 .vscode/launch.json
-.vscode/settings.json
 /.idea
-venv/
-.venv/
-# snoop logs
-out/

.vscode/settings.json

@@ -12,9 +12,7 @@
         "ASHA",
         "asyncio",
         "ATRAC",
-        "avctp",
         "avdtp",
-        "avrcp",
         "bitpool",
         "bitstruct",
         "BSCP",
@@ -24,7 +22,6 @@
         "cmac",
         "CONNECTIONLESS",
         "csip",
-        "csis",
         "csrcs",
         "CVSD",
         "datagram",
@@ -35,7 +32,6 @@
         "dhkey",
         "diversifier",
         "endianness",
-        "ESCO",
         "Fitbit",
         "GATTLINK",
         "HANDSFREE",
@@ -74,8 +70,6 @@
         "substates",
         "tobytes",
         "tsep",
-        "UNMUTE",
-        "unmuted",
         "usbmodem",
         "vhci",
         "websockets",

apps/console.py

@@ -777,7 +777,7 @@ class ConsoleApp:
                 if not service:
                     continue
                 values = [
-                    await attribute.read_value(connection)
+                    attribute.read_value(connection)
                     for connection in self.device.connections.values()
                 ]
                 if not values:
@@ -796,11 +796,11 @@ class ConsoleApp:
                 if not characteristic:
                     continue
                 values = [
-                    await attribute.read_value(connection)
+                    attribute.read_value(connection)
                     for connection in self.device.connections.values()
                 ]
                 if not values:
-                    values = [await attribute.read_value(None)]
+                    values = [attribute.read_value(None)]
 
                 # TODO: future optimization: convert CCCD value to human readable string
 
@@ -944,7 +944,7 @@ class ConsoleApp:
 
         # send data to any subscribers
         if isinstance(attribute, Characteristic):
-            await attribute.write_value(None, value)
+            attribute.write_value(None, value)
             if attribute.has_properties(Characteristic.NOTIFY):
                 await self.device.gatt_server.notify_subscribers(attribute)
             if attribute.has_properties(Characteristic.INDICATE):

apps/controller_info.py

@@ -18,30 +18,28 @@
 import asyncio
 import os
 import logging
-import time
-
 import click
-
 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,
-    LeFeatureMask,
     HCI_SUCCESS,
+    HCI_LE_SUPPORTED_FEATURES_NAMES,
     HCI_VERSION_NAMES,
     LMP_VERSION_NAMES,
     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,
@@ -50,7 +48,6 @@ from bumble.hci import (
     HCI_LE_Read_Maximum_Advertising_Data_Length_Command,
     HCI_LE_READ_SUGGESTED_DEFAULT_DATA_LENGTH_COMMAND,
     HCI_LE_Read_Suggested_Default_Data_Length_Command,
-    HCI_Read_Local_Version_Information_Command,
 )
 from bumble.host import Host
 from bumble.transport import open_transport_or_link
@@ -66,7 +63,37 @@ def command_succeeded(response):
 
 
 # -----------------------------------------------------------------------------
-async def get_classic_info(host: Host) -> None:
+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):
     if host.supports_command(HCI_READ_BD_ADDR_COMMAND):
         response = await host.send_command(HCI_Read_BD_ADDR_Command())
         if command_succeeded(response):
@@ -87,7 +114,7 @@ async def get_classic_info(host: Host) -> None:
 
 
 # -----------------------------------------------------------------------------
-async def get_le_info(host: Host) -> None:
+async def get_le_info(host):
     print()
 
     if host.supports_command(HCI_LE_READ_NUMBER_OF_SUPPORTED_ADVERTISING_SETS_COMMAND):
@@ -140,36 +167,11 @@ async def get_le_info(host: Host) -> None:
 
     print(color('LE Features:', 'yellow'))
     for feature in host.supported_le_features:
-        print(LeFeatureMask(feature).name)
+        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(latency_probes, transport):
+async def async_main(transport):
     print('<<< connecting to HCI...')
     async with await open_transport_or_link(transport) as (hci_source, hci_sink):
         print('<<< connected')
@@ -177,23 +179,6 @@ async def async_main(latency_probes, transport):
         host = Host(hci_source, hci_sink)
         await host.reset()
 
-        # Measure the latency if requested
-        latencies = []
-        if latency_probes:
-            for _ in range(latency_probes):
-                start = time.time()
-                await host.send_command(HCI_Read_Local_Version_Information_Command())
-                latencies.append(1000 * (time.time() - start))
-            print(
-                color('HCI Command Latency:', 'yellow'),
-                (
-                    f'min={min(latencies):.2f}, '
-                    f'max={max(latencies):.2f}, '
-                    f'average={sum(latencies)/len(latencies):.2f}'
-                ),
-                '\n',
-            )
-
         # Print version
         print(color('Version:', 'yellow'))
         print(
@@ -211,15 +196,15 @@ async def async_main(latency_probes, 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'))
@@ -229,16 +214,10 @@ async def async_main(latency_probes, transport):
 
 # -----------------------------------------------------------------------------
 @click.command()
-@click.option(
-    '--latency-probes',
-    metavar='N',
-    type=int,
-    help='Send N commands to measure HCI transport latency statistics',
-)
 @click.argument('transport')
-def main(latency_probes, transport):
+def main(transport):
     logging.basicConfig(level=os.environ.get('BUMBLE_LOGLEVEL', 'WARNING').upper())
-    asyncio.run(async_main(latency_probes, transport))
+    asyncio.run(async_main(transport))
 
 
 # -----------------------------------------------------------------------------

apps/controller_loopback.py

@@ -1,205 +0,0 @@
-# Copyright 2024 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 time
-from typing import Optional
-from bumble.colors import color
-from bumble.hci import (
-    HCI_READ_LOOPBACK_MODE_COMMAND,
-    HCI_Read_Loopback_Mode_Command,
-    HCI_WRITE_LOOPBACK_MODE_COMMAND,
-    HCI_Write_Loopback_Mode_Command,
-    LoopbackMode,
-)
-from bumble.host import Host
-from bumble.transport import open_transport_or_link
-import click
-
-
-class Loopback:
-    """Send and receive ACL data packets in local loopback mode"""
-
-    def __init__(self, packet_size: int, packet_count: int, transport: str):
-        self.transport = transport
-        self.packet_size = packet_size
-        self.packet_count = packet_count
-        self.connection_handle: Optional[int] = None
-        self.connection_event = asyncio.Event()
-        self.done = asyncio.Event()
-        self.expected_cid = 0
-        self.bytes_received = 0
-        self.start_timestamp = 0.0
-        self.last_timestamp = 0.0
-
-    def on_connection(self, connection_handle: int, *args):
-        """Retrieve connection handle from new connection event"""
-        if not self.connection_event.is_set():
-            # save first connection handle for ACL
-            # subsequent connections are SCO
-            self.connection_handle = connection_handle
-            self.connection_event.set()
-
-    def on_l2cap_pdu(self, connection_handle: int, cid: int, pdu: bytes):
-        """Calculate packet receive speed"""
-        now = time.time()
-        print(f'<<< Received packet {cid}: {len(pdu)} bytes')
-        assert connection_handle == self.connection_handle
-        assert cid == self.expected_cid
-        self.expected_cid += 1
-        if cid == 0:
-            self.start_timestamp = now
-        else:
-            elapsed_since_start = now - self.start_timestamp
-            elapsed_since_last = now - self.last_timestamp
-            self.bytes_received += len(pdu)
-            instant_rx_speed = len(pdu) / elapsed_since_last
-            average_rx_speed = self.bytes_received / elapsed_since_start
-            print(
-                color(
-                    f'@@@ RX speed: instant={instant_rx_speed:.4f},'
-                    f' average={average_rx_speed:.4f}',
-                    'cyan',
-                )
-            )
-
-        self.last_timestamp = now
-
-        if self.expected_cid == self.packet_count:
-            print(color('@@@ Received last packet', 'green'))
-            self.done.set()
-
-    async def run(self):
-        """Run a loopback throughput test"""
-        print(color('>>> Connecting to HCI...', 'green'))
-        async with await open_transport_or_link(self.transport) as (
-            hci_source,
-            hci_sink,
-        ):
-            print(color('>>> Connected', 'green'))
-
-            host = Host(hci_source, hci_sink)
-            await host.reset()
-
-            # make sure data can fit in one l2cap pdu
-            l2cap_header_size = 4
-
-            max_packet_size = (
-                host.acl_packet_queue
-                if host.acl_packet_queue
-                else host.le_acl_packet_queue
-            ).max_packet_size - l2cap_header_size
-            if self.packet_size > max_packet_size:
-                print(
-                    color(
-                        f'!!! Packet size ({self.packet_size}) larger than max supported'
-                        f' size ({max_packet_size})',
-                        'red',
-                    )
-                )
-                return
-
-            if not host.supports_command(
-                HCI_WRITE_LOOPBACK_MODE_COMMAND
-            ) or not host.supports_command(HCI_READ_LOOPBACK_MODE_COMMAND):
-                print(color('!!! Loopback mode not supported', 'red'))
-                return
-
-            # set event callbacks
-            host.on('connection', self.on_connection)
-            host.on('l2cap_pdu', self.on_l2cap_pdu)
-
-            loopback_mode = LoopbackMode.LOCAL
-
-            print(color('### Setting loopback mode', 'blue'))
-            await host.send_command(
-                HCI_Write_Loopback_Mode_Command(loopback_mode=LoopbackMode.LOCAL),
-                check_result=True,
-            )
-
-            print(color('### Checking loopback mode', 'blue'))
-            response = await host.send_command(
-                HCI_Read_Loopback_Mode_Command(), check_result=True
-            )
-            if response.return_parameters.loopback_mode != loopback_mode:
-                print(color('!!! Loopback mode mismatch', 'red'))
-                return
-
-            await self.connection_event.wait()
-            print(color('### Connected', 'cyan'))
-
-            print(color('=== Start sending', 'magenta'))
-            start_time = time.time()
-            bytes_sent = 0
-            for cid in range(0, self.packet_count):
-                # using the cid as an incremental index
-                host.send_l2cap_pdu(
-                    self.connection_handle, cid, bytes(self.packet_size)
-                )
-                print(
-                    color(
-                        f'>>> Sending packet {cid}: {self.packet_size} bytes', 'yellow'
-                    )
-                )
-                bytes_sent += self.packet_size  # don't count L2CAP or HCI header sizes
-                await asyncio.sleep(0)  # yield to allow packet receive
-
-            await self.done.wait()
-            print(color('=== Done!', 'magenta'))
-
-            elapsed = time.time() - start_time
-            average_tx_speed = bytes_sent / elapsed
-            print(
-                color(
-                    f'@@@ TX speed: average={average_tx_speed:.4f} ({bytes_sent} bytes'
-                    f' in {elapsed:.2f} seconds)',
-                    'green',
-                )
-            )
-
-
-# -----------------------------------------------------------------------------
-@click.command()
-@click.option(
-    '--packet-size',
-    '-s',
-    metavar='SIZE',
-    type=click.IntRange(8, 4096),
-    default=500,
-    help='Packet size',
-)
-@click.option(
-    '--packet-count',
-    '-c',
-    metavar='COUNT',
-    type=click.IntRange(1, 65535),
-    default=10,
-    help='Packet count',
-)
-@click.argument('transport')
-def main(packet_size, packet_count, transport):
-    logging.basicConfig(level=os.environ.get('BUMBLE_LOGLEVEL', 'WARNING').upper())
-
-    loopback = Loopback(packet_size, packet_count, transport)
-    asyncio.run(loopback.run())
-
-
-# -----------------------------------------------------------------------------
-if __name__ == '__main__':
-    main()

apps/controllers.py

@@ -17,31 +17,25 @@
 # -----------------------------------------------------------------------------
 import logging
 import asyncio
-import sys
 import os
 
-from bumble.controller import Controller
+import click
+
+from bumble.controller import Controller, Options
 from bumble.link import LocalLink
 from bumble.transport import open_transport_or_link
 
 
 # -----------------------------------------------------------------------------
-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
-
+async def async_main(extended_advertising, transport_names):
     # Create a local link to attach the controllers to
     link = LocalLink()
 
     # Create a transport and controller for all requested names
     transports = []
     controllers = []
-    for index, transport_name in enumerate(sys.argv[1:]):
+    options = Options(extended_advertising=extended_advertising)
+    for index, transport_name in enumerate(transport_names):
         transport = await open_transport_or_link(transport_name)
         transports.append(transport)
         controller = Controller(
@@ -49,6 +43,7 @@ async def async_main():
             host_source=transport.source,
             host_sink=transport.sink,
             link=link,
+            options=options,
         )
         controllers.append(controller)
 
@@ -61,9 +56,14 @@ async def async_main():
 
 
 # -----------------------------------------------------------------------------
-def main():
-    logging.basicConfig(level=os.environ.get('BUMBLE_LOGLEVEL', 'INFO').upper())
-    asyncio.run(async_main())
+@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))
 
 
 # -----------------------------------------------------------------------------

apps/l2cap_bridge.py

@@ -49,16 +49,14 @@ class ServerBridge:
         self.tcp_port = tcp_port
 
     async def start(self, device: Device) -> None:
-        # Listen for incoming L2CAP channel connections
+        # Listen for incoming L2CAP CoC connections
         device.create_l2cap_server(
             spec=l2cap.LeCreditBasedChannelSpec(
                 psm=self.psm, mtu=self.mtu, mps=self.mps, max_credits=self.max_credits
             ),
-            handler=self.on_channel,
-        )
-        print(
-            color(f'### Listening for channel connection on PSM {self.psm}', 'yellow')
+            handler=self.on_coc,
         )
+        print(color(f'### Listening for CoC connection on PSM {self.psm}', 'yellow'))
 
         def on_ble_connection(connection):
             def on_ble_disconnection(reason):
@@ -75,7 +73,7 @@ class ServerBridge:
         await device.start_advertising(auto_restart=True)
 
     # Called when a new L2CAP connection is established
-    def on_channel(self, l2cap_channel):
+    def on_coc(self, l2cap_channel):
         print(color('*** L2CAP channel:', 'cyan'), l2cap_channel)
 
         class Pipe:
@@ -85,7 +83,7 @@ class ServerBridge:
                 self.l2cap_channel = l2cap_channel
 
                 l2cap_channel.on('close', self.on_l2cap_close)
-                l2cap_channel.sink = self.on_channel_sdu
+                l2cap_channel.sink = self.on_coc_sdu
 
             async def connect_to_tcp(self):
                 # Connect to the TCP server
@@ -130,7 +128,7 @@ class ServerBridge:
                 if self.tcp_transport is not None:
                     self.tcp_transport.close()
 
-            def on_channel_sdu(self, sdu):
+            def on_coc_sdu(self, sdu):
                 print(color(f'<<< [L2CAP SDU]: {len(sdu)} bytes', 'cyan'))
                 if self.tcp_transport is None:
                     print(color('!!! TCP socket not open, dropping', 'red'))
@@ -185,7 +183,7 @@ class ClientBridge:
             peer_name = writer.get_extra_info('peer_name')
             print(color(f'<<< TCP connection from {peer_name}', 'magenta'))
 
-            def on_channel_sdu(sdu):
+            def on_coc_sdu(sdu):
                 print(color(f'<<< [L2CAP SDU]: {len(sdu)} bytes', 'cyan'))
                 l2cap_to_tcp_pipe.write(sdu)
 
@@ -211,7 +209,7 @@ class ClientBridge:
                 writer.close()
                 return
 
-            l2cap_channel.sink = on_channel_sdu
+            l2cap_channel.sink = on_coc_sdu
             l2cap_channel.on('close', on_l2cap_close)
 
             # Start a flow control pipe from L2CAP to TCP
@@ -276,29 +274,23 @@ async def run(device_config, hci_transport, bridge):
 @click.pass_context
 @click.option('--device-config', help='Device configuration file', required=True)
 @click.option('--hci-transport', help='HCI transport', required=True)
-@click.option('--psm', help='PSM for L2CAP', type=int, default=1234)
+@click.option('--psm', help='PSM for L2CAP CoC', type=int, default=1234)
 @click.option(
-    '--l2cap-max-credits',
-    help='Maximum L2CAP Credits',
+    '--l2cap-coc-max-credits',
+    help='Maximum L2CAP CoC Credits',
     type=click.IntRange(1, 65535),
     default=128,
 )
 @click.option(
-    '--l2cap-mtu',
-    help='L2CAP MTU',
-    type=click.IntRange(
-        l2cap.L2CAP_LE_CREDIT_BASED_CONNECTION_MIN_MTU,
-        l2cap.L2CAP_LE_CREDIT_BASED_CONNECTION_MAX_MTU,
-    ),
-    default=1024,
+    '--l2cap-coc-mtu',
+    help='L2CAP CoC MTU',
+    type=click.IntRange(23, 65535),
+    default=1022,
 )
 @click.option(
-    '--l2cap-mps',
-    help='L2CAP MPS',
-    type=click.IntRange(
-        l2cap.L2CAP_LE_CREDIT_BASED_CONNECTION_MIN_MPS,
-        l2cap.L2CAP_LE_CREDIT_BASED_CONNECTION_MAX_MPS,
-    ),
+    '--l2cap-coc-mps',
+    help='L2CAP CoC MPS',
+    type=click.IntRange(23, 65533),
     default=1024,
 )
 def cli(
@@ -306,17 +298,17 @@ def cli(
     device_config,
     hci_transport,
     psm,
-    l2cap_max_credits,
-    l2cap_mtu,
-    l2cap_mps,
+    l2cap_coc_max_credits,
+    l2cap_coc_mtu,
+    l2cap_coc_mps,
 ):
     context.ensure_object(dict)
     context.obj['device_config'] = device_config
     context.obj['hci_transport'] = hci_transport
     context.obj['psm'] = psm
-    context.obj['max_credits'] = l2cap_max_credits
-    context.obj['mtu'] = l2cap_mtu
-    context.obj['mps'] = l2cap_mps
+    context.obj['max_credits'] = l2cap_coc_max_credits
+    context.obj['mtu'] = l2cap_coc_mtu
+    context.obj['mps'] = l2cap_coc_mps
 
 
 # -----------------------------------------------------------------------------

apps/link_relay/link_relay.py

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

apps/scan.py

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

apps/show.py

@@ -15,11 +15,7 @@
 # -----------------------------------------------------------------------------
 # Imports
 # -----------------------------------------------------------------------------
-import datetime
-import logging
-import os
 import struct
-
 import click
 
 from bumble.colors import color
@@ -28,14 +24,6 @@ from bumble.transport.common import PacketReader
 from bumble.helpers import PacketTracer
 
 
-# -----------------------------------------------------------------------------
-# Logging
-# -----------------------------------------------------------------------------
-logger = logging.getLogger(__name__)
-
-
-# -----------------------------------------------------------------------------
-# Classes
 # -----------------------------------------------------------------------------
 class SnoopPacketReader:
     '''
@@ -48,18 +36,12 @@ class SnoopPacketReader:
     DATALINK_BSCP = 1003
     DATALINK_H5 = 1004
 
-    IDENTIFICATION_PATTERN = b'btsnoop\0'
-    TIMESTAMP_ANCHOR = datetime.datetime(2000, 1, 1)
-    TIMESTAMP_DELTA = 0x00E03AB44A676000
-    ONE_MICROSECOND = datetime.timedelta(microseconds=1)
-
     def __init__(self, source):
         self.source = source
-        self.at_end = False
 
         # Read the header
         identification_pattern = source.read(8)
-        if identification_pattern != self.IDENTIFICATION_PATTERN:
+        if identification_pattern.hex().lower() != '6274736e6f6f7000':
             raise ValueError(
                 'not a valid snoop file, unexpected identification pattern'
             )
@@ -73,32 +55,19 @@ class SnoopPacketReader:
         # Read the record header
         header = self.source.read(24)
         if len(header) < 24:
-            self.at_end = True
-            return (None, 0, None)
-
-        # Parse the header
+            return (0, None)
         (
             original_length,
             included_length,
             packet_flags,
             _cumulative_drops,
-            timestamp,
-        ) = struct.unpack('>IIIIQ', header)
+            _timestamp_seconds,
+            _timestamp_microsecond,
+        ) = struct.unpack('>IIIIII', header)
 
-        # Skip truncated packets
+        # Abort on truncated packets
         if original_length != included_length:
-            print(
-                color(
-                    f"!!! truncated packet ({included_length}/{original_length})", "red"
-                )
-            )
-            self.source.read(included_length)
-            return (None, 0, None)
-
-        # Convert the timestamp to a datetime object.
-        ts_dt = self.TIMESTAMP_ANCHOR + datetime.timedelta(
-            microseconds=timestamp - self.TIMESTAMP_DELTA
-        )
+            return (0, None)
 
         if self.data_link_type == self.DATALINK_H1:
             # The packet is un-encapsulated, look at the flags to figure out its type
@@ -120,17 +89,7 @@ class SnoopPacketReader:
                 bytes([packet_type]) + self.source.read(included_length),
             )
 
-        return (ts_dt, packet_flags & 1, self.source.read(included_length))
-
-
-# -----------------------------------------------------------------------------
-class Printer:
-    def __init__(self):
-        self.index = 0
-
-    def print(self, message: str) -> None:
-        self.index += 1
-        print(f"[{self.index:8}]{message}")
+        return (packet_flags & 1, self.source.read(included_length))
 
 
 # -----------------------------------------------------------------------------
@@ -163,28 +122,24 @@ def main(format, vendors, filename):
         packet_reader = PacketReader(input)
 
         def read_next_packet():
-            return (None, 0, packet_reader.next_packet())
+            return (0, packet_reader.next_packet())
 
     else:
         packet_reader = SnoopPacketReader(input)
         read_next_packet = packet_reader.next_packet
 
-    printer = Printer()
-    tracer = PacketTracer(emit_message=printer.print)
+    tracer = PacketTracer(emit_message=print)
 
-    while not packet_reader.at_end:
+    while True:
         try:
-            (timestamp, direction, packet) = read_next_packet()
-            if packet:
-                tracer.trace(hci.HCI_Packet.from_bytes(packet), direction, timestamp)
-            else:
-                printer.print(color("[TRUNCATED]", "red"))
+            (direction, packet) = read_next_packet()
+            if packet is None:
+                break
+            tracer.trace(hci.HCI_Packet.from_bytes(packet), direction)
         except Exception as error:
-            logger.exception()
             print(color(f'!!! {error}', 'red'))
 
 
 # -----------------------------------------------------------------------------
 if __name__ == '__main__':
-    logging.basicConfig(level=os.environ.get('BUMBLE_LOGLEVEL', 'WARNING').upper())
     main()  # pylint: disable=no-value-for-parameter

apps/speaker/speaker.py

@@ -76,7 +76,6 @@ logger = logging.getLogger(__name__)
 # -----------------------------------------------------------------------------
 DEFAULT_UI_PORT = 7654
 
-
 # -----------------------------------------------------------------------------
 class AudioExtractor:
     @staticmethod

apps/unbond.py

@@ -24,7 +24,6 @@ from bumble.device import Device
 from bumble.keys import JsonKeyStore
 from bumble.transport import open_transport
 
-
 # -----------------------------------------------------------------------------
 async def unbond_with_keystore(keystore, address):
     if address is None:

bumble/a2dp.py

@@ -184,12 +184,8 @@ def make_audio_source_service_sdp_records(service_record_handle, version=(1, 3))
             SDP_BLUETOOTH_PROFILE_DESCRIPTOR_LIST_ATTRIBUTE_ID,
             DataElement.sequence(
                 [
-                    DataElement.sequence(
-                        [
-                            DataElement.uuid(BT_ADVANCED_AUDIO_DISTRIBUTION_SERVICE),
-                            DataElement.unsigned_integer_16(version_int),
-                        ]
-                    )
+                    DataElement.uuid(BT_ADVANCED_AUDIO_DISTRIBUTION_SERVICE),
+                    DataElement.unsigned_integer_16(version_int),
                 ]
             ),
         ),
@@ -238,12 +234,8 @@ def make_audio_sink_service_sdp_records(service_record_handle, version=(1, 3)):
             SDP_BLUETOOTH_PROFILE_DESCRIPTOR_LIST_ATTRIBUTE_ID,
             DataElement.sequence(
                 [
-                    DataElement.sequence(
-                        [
-                            DataElement.uuid(BT_ADVANCED_AUDIO_DISTRIBUTION_SERVICE),
-                            DataElement.unsigned_integer_16(version_int),
-                        ]
-                    )
+                    DataElement.uuid(BT_ADVANCED_AUDIO_DISTRIBUTION_SERVICE),
+                    DataElement.unsigned_integer_16(version_int),
                 ]
             ),
         ),
@@ -652,9 +644,7 @@ class SbcPacketSource:
 
                     # Prepare for next packets
                     sequence_number += 1
-                    sequence_number &= 0xFFFF
                     timestamp += sum((frame.sample_count for frame in frames))
-                    timestamp &= 0xFFFFFFFF
                     frames = [frame]
                     frames_size = len(frame.payload)
                 else:

bumble/att.py

@@ -25,21 +25,9 @@
 from __future__ import annotations
 import enum
 import functools
-import inspect
 import struct
-from typing import (
-    Any,
-    Awaitable,
-    Callable,
-    Dict,
-    List,
-    Optional,
-    Type,
-    Union,
-    TYPE_CHECKING,
-)
-
 from pyee import EventEmitter
+from typing import Dict, Type, List, Protocol, Union, Optional, Any, TYPE_CHECKING
 
 from bumble.core import UUID, name_or_number, ProtocolError
 from bumble.hci import HCI_Object, key_with_value
@@ -655,7 +643,7 @@ class ATT_Write_Command(ATT_PDU):
 @ATT_PDU.subclass(
     [
         ('attribute_handle', HANDLE_FIELD_SPEC),
-        ('attribute_value', '*'),
+        ('attribute_value', '*')
         # ('authentication_signature', 'TODO')
     ]
 )
@@ -734,38 +722,12 @@ class ATT_Handle_Value_Confirmation(ATT_PDU):
 
 
 # -----------------------------------------------------------------------------
-class AttributeValue:
-    '''
-    Attribute value where reading and/or writing is delegated to functions
-    passed as arguments to the constructor.
-    '''
+class ConnectionValue(Protocol):
+    def read(self, connection) -> bytes:
+        ...
 
-    def __init__(
-        self,
-        read: Union[
-            Callable[[Optional[Connection]], bytes],
-            Callable[[Optional[Connection]], Awaitable[bytes]],
-            None,
-        ] = None,
-        write: Union[
-            Callable[[Optional[Connection], bytes], None],
-            Callable[[Optional[Connection], bytes], Awaitable[None]],
-            None,
-        ] = None,
-    ):
-        self._read = read
-        self._write = write
-
-    def read(self, connection: Optional[Connection]) -> Union[bytes, Awaitable[bytes]]:
-        return self._read(connection) if self._read else b''
-
-    def write(
-        self, connection: Optional[Connection], value: bytes
-    ) -> Union[Awaitable[None], None]:
-        if self._write:
-            return self._write(connection, value)
-
-        return None
+    def write(self, connection, value: bytes) -> None:
+        ...
 
 
 # -----------------------------------------------------------------------------
@@ -808,13 +770,13 @@ class Attribute(EventEmitter):
     READ_REQUIRES_AUTHORIZATION = Permissions.READ_REQUIRES_AUTHORIZATION
     WRITE_REQUIRES_AUTHORIZATION = Permissions.WRITE_REQUIRES_AUTHORIZATION
 
-    value: Union[bytes, AttributeValue]
+    value: Union[str, bytes, ConnectionValue]
 
     def __init__(
         self,
         attribute_type: Union[str, bytes, UUID],
         permissions: Union[str, Attribute.Permissions],
-        value: Union[str, bytes, AttributeValue] = b'',
+        value: Union[str, bytes, ConnectionValue] = b'',
     ) -> None:
         EventEmitter.__init__(self)
         self.handle = 0
@@ -844,7 +806,7 @@ class Attribute(EventEmitter):
     def decode_value(self, value_bytes: bytes) -> Any:
         return value_bytes
 
-    async def read_value(self, connection: Optional[Connection]) -> bytes:
+    def read_value(self, connection: Optional[Connection]) -> bytes:
         if (
             (self.permissions & self.READ_REQUIRES_ENCRYPTION)
             and connection is not None
@@ -870,8 +832,6 @@ class Attribute(EventEmitter):
         if hasattr(self.value, 'read'):
             try:
                 value = self.value.read(connection)
-                if inspect.isawaitable(value):
-                    value = await value
             except ATT_Error as error:
                 raise ATT_Error(
                     error_code=error.error_code, att_handle=self.handle
@@ -881,7 +841,7 @@ class Attribute(EventEmitter):
 
         return self.encode_value(value)
 
-    async def write_value(self, connection: Connection, value_bytes: bytes) -> None:
+    def write_value(self, connection: Connection, value_bytes: bytes) -> None:
         if (
             self.permissions & self.WRITE_REQUIRES_ENCRYPTION
         ) and not connection.encryption:
@@ -904,9 +864,7 @@ class Attribute(EventEmitter):
 
         if hasattr(self.value, 'write'):
             try:
-                result = self.value.write(connection, value)
-                if inspect.isawaitable(result):
-                    await result
+                self.value.write(connection, value)  # pylint: disable=not-callable
             except ATT_Error as error:
                 raise ATT_Error(
                     error_code=error.error_code, att_handle=self.handle

bumble/avc.py

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

bumble/avctp.py

@@ -1,291 +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 enum import IntEnum
-import logging
-import struct
-from typing import Callable, cast, Dict, Optional
-
-from bumble.colors import color
-from bumble import avc
-from bumble import l2cap
-
-# -----------------------------------------------------------------------------
-# Logging
-# -----------------------------------------------------------------------------
-logger = logging.getLogger(__name__)
-
-
-# -----------------------------------------------------------------------------
-# Constants
-# -----------------------------------------------------------------------------
-AVCTP_PSM = 0x0017
-AVCTP_BROWSING_PSM = 0x001B
-
-
-# -----------------------------------------------------------------------------
-class MessageAssembler:
-    Callback = Callable[[int, bool, bool, int, bytes], None]
-
-    transaction_label: int
-    pid: int
-    c_r: int
-    ipid: int
-    payload: bytes
-    number_of_packets: int
-    packets_received: int
-
-    def __init__(self, callback: Callback) -> None:
-        self.callback = callback
-        self.reset()
-
-    def reset(self) -> None:
-        self.packets_received = 0
-        self.transaction_label = -1
-        self.pid = -1
-        self.c_r = -1
-        self.ipid = -1
-        self.payload = b''
-        self.number_of_packets = 0
-        self.packet_count = 0
-
-    def on_pdu(self, pdu: bytes) -> None:
-        self.packets_received += 1
-
-        transaction_label = pdu[0] >> 4
-        packet_type = Protocol.PacketType((pdu[0] >> 2) & 3)
-        c_r = (pdu[0] >> 1) & 1
-        ipid = pdu[0] & 1
-
-        if c_r == 0 and ipid != 0:
-            logger.warning("invalid IPID in command frame")
-            self.reset()
-            return
-
-        pid_offset = 1
-        if packet_type in (Protocol.PacketType.SINGLE, Protocol.PacketType.START):
-            if self.transaction_label >= 0:
-                # We are already in a transaction
-                logger.warning("received START or SINGLE fragment while in transaction")
-                self.reset()
-                self.packets_received = 1
-
-            if packet_type == Protocol.PacketType.START:
-                self.number_of_packets = pdu[1]
-                pid_offset = 2
-
-        pid = struct.unpack_from(">H", pdu, pid_offset)[0]
-        self.payload += pdu[pid_offset + 2 :]
-
-        if packet_type in (Protocol.PacketType.CONTINUE, Protocol.PacketType.END):
-            if transaction_label != self.transaction_label:
-                logger.warning("transaction label does not match")
-                self.reset()
-                return
-
-            if pid != self.pid:
-                logger.warning("PID does not match")
-                self.reset()
-                return
-
-            if c_r != self.c_r:
-                logger.warning("C/R does not match")
-                self.reset()
-                return
-
-            if self.packets_received > self.number_of_packets:
-                logger.warning("too many fragments in transaction")
-                self.reset()
-                return
-
-            if packet_type == Protocol.PacketType.END:
-                if self.packets_received != self.number_of_packets:
-                    logger.warning("premature END")
-                    self.reset()
-                    return
-        else:
-            self.transaction_label = transaction_label
-            self.c_r = c_r
-            self.ipid = ipid
-            self.pid = pid
-
-        if packet_type in (Protocol.PacketType.SINGLE, Protocol.PacketType.END):
-            self.on_message_complete()
-
-    def on_message_complete(self):
-        try:
-            self.callback(
-                self.transaction_label,
-                self.c_r == 0,
-                self.ipid != 0,
-                self.pid,
-                self.payload,
-            )
-        except Exception as error:
-            logger.exception(color(f"!!! exception in callback: {error}", "red"))
-
-        self.reset()
-
-
-# -----------------------------------------------------------------------------
-class Protocol:
-    CommandHandler = Callable[[int, avc.CommandFrame], None]
-    command_handlers: Dict[int, CommandHandler]  # Command handlers, by PID
-    ResponseHandler = Callable[[int, Optional[avc.ResponseFrame]], None]
-    response_handlers: Dict[int, ResponseHandler]  # Response handlers, by PID
-    next_transaction_label: int
-    message_assembler: MessageAssembler
-
-    class PacketType(IntEnum):
-        SINGLE = 0b00
-        START = 0b01
-        CONTINUE = 0b10
-        END = 0b11
-
-    def __init__(self, l2cap_channel: l2cap.ClassicChannel) -> None:
-        self.command_handlers = {}
-        self.response_handlers = {}
-        self.l2cap_channel = l2cap_channel
-        self.message_assembler = MessageAssembler(self.on_message)
-
-        # Register to receive PDUs from the channel
-        l2cap_channel.sink = self.on_pdu
-        l2cap_channel.on("open", self.on_l2cap_channel_open)
-        l2cap_channel.on("close", self.on_l2cap_channel_close)
-
-    def on_l2cap_channel_open(self):
-        logger.debug(color("<<< AVCTP channel open", "magenta"))
-
-    def on_l2cap_channel_close(self):
-        logger.debug(color("<<< AVCTP channel closed", "magenta"))
-
-    def on_pdu(self, pdu: bytes) -> None:
-        self.message_assembler.on_pdu(pdu)
-
-    def on_message(
-        self,
-        transaction_label: int,
-        is_command: bool,
-        ipid: bool,
-        pid: int,
-        payload: bytes,
-    ) -> None:
-        logger.debug(
-            f"<<< AVCTP Message: pid={pid}, "
-            f"transaction_label={transaction_label}, "
-            f"is_command={is_command}, "
-            f"ipid={ipid}, "
-            f"payload={payload.hex()}"
-        )
-
-        # Check for invalid PID responses.
-        if ipid:
-            logger.debug(f"received IPID for PID={pid}")
-
-        # Find the appropriate handler.
-        if is_command:
-            if pid not in self.command_handlers:
-                logger.warning(f"no command handler for PID {pid}")
-                self.send_ipid(transaction_label, pid)
-                return
-
-            command_frame = cast(avc.CommandFrame, avc.Frame.from_bytes(payload))
-            self.command_handlers[pid](transaction_label, command_frame)
-        else:
-            if pid not in self.response_handlers:
-                logger.warning(f"no response handler for PID {pid}")
-                return
-
-            # By convention, for an ipid, send a None payload to the response handler.
-            if ipid:
-                response_frame = None
-            else:
-                response_frame = cast(avc.ResponseFrame, avc.Frame.from_bytes(payload))
-
-            self.response_handlers[pid](transaction_label, response_frame)
-
-    def send_message(
-        self,
-        transaction_label: int,
-        is_command: bool,
-        ipid: bool,
-        pid: int,
-        payload: bytes,
-    ):
-        # TODO: fragment large messages
-        packet_type = Protocol.PacketType.SINGLE
-        pdu = (
-            struct.pack(
-                ">BH",
-                transaction_label << 4
-                | packet_type << 2
-                | (0 if is_command else 1) << 1
-                | (1 if ipid else 0),
-                pid,
-            )
-            + payload
-        )
-        self.l2cap_channel.send_pdu(pdu)
-
-    def send_command(self, transaction_label: int, pid: int, payload: bytes) -> None:
-        logger.debug(
-            ">>> AVCTP command: "
-            f"transaction_label={transaction_label}, "
-            f"pid={pid}, "
-            f"payload={payload.hex()}"
-        )
-        self.send_message(transaction_label, True, False, pid, payload)
-
-    def send_response(self, transaction_label: int, pid: int, payload: bytes):
-        logger.debug(
-            ">>> AVCTP response: "
-            f"transaction_label={transaction_label}, "
-            f"pid={pid}, "
-            f"payload={payload.hex()}"
-        )
-        self.send_message(transaction_label, False, False, pid, payload)
-
-    def send_ipid(self, transaction_label: int, pid: int) -> None:
-        logger.debug(
-            ">>> AVCTP ipid: " f"transaction_label={transaction_label}, " f"pid={pid}"
-        )
-        self.send_message(transaction_label, False, True, pid, b'')
-
-    def register_command_handler(
-        self, pid: int, handler: Protocol.CommandHandler
-    ) -> None:
-        self.command_handlers[pid] = handler
-
-    def unregister_command_handler(
-        self, pid: int, handler: Protocol.CommandHandler
-    ) -> None:
-        if pid not in self.command_handlers or self.command_handlers[pid] != handler:
-            raise ValueError("command handler not registered")
-        del self.command_handlers[pid]
-
-    def register_response_handler(
-        self, pid: int, handler: Protocol.ResponseHandler
-    ) -> None:
-        self.response_handlers[pid] = handler
-
-    def unregister_response_handler(
-        self, pid: int, handler: Protocol.ResponseHandler
-    ) -> None:
-        if pid not in self.response_handlers or self.response_handlers[pid] != handler:
-            raise ValueError("response handler not registered")
-        del self.response_handlers[pid]

bumble/avdtp.py

@@ -241,10 +241,7 @@ async def find_avdtp_service_with_sdp_client(
         )
         if profile_descriptor_list:
             for profile_descriptor in profile_descriptor_list.value:
-                if (
-                    profile_descriptor.type == sdp.DataElement.SEQUENCE
-                    and len(profile_descriptor.value) >= 2
-                ):
+                if len(profile_descriptor.value) >= 2:
                     avdtp_version_major = profile_descriptor.value[1].value >> 8
                     avdtp_version_minor = profile_descriptor.value[1].value & 0xFF
                     return (avdtp_version_major, avdtp_version_minor)
@@ -325,8 +322,8 @@ class MediaPacket:
         self.padding = padding
         self.extension = extension
         self.marker = marker
-        self.sequence_number = sequence_number & 0xFFFF
-        self.timestamp = timestamp & 0xFFFFFFFF
+        self.sequence_number = sequence_number
+        self.timestamp = timestamp
         self.ssrc = ssrc
         self.csrc_list = csrc_list
         self.payload_type = payload_type
@@ -341,12 +338,7 @@ class MediaPacket:
                 | len(self.csrc_list),
                 self.marker << 7 | self.payload_type,
             ]
-        ) + struct.pack(
-            '>HII',
-            self.sequence_number,
-            self.timestamp,
-            self.ssrc,
-        )
+        ) + struct.pack('>HII', self.sequence_number, self.timestamp, self.ssrc)
         for csrc in self.csrc_list:
             header += struct.pack('>I', csrc)
         return header + self.payload
@@ -519,8 +511,7 @@ class MessageAssembler:
         try:
             self.callback(self.transaction_label, message)
         except Exception as error:
-            logger.exception(color(f'!!! exception in callback: {error}', 'red'))
-
+            logger.warning(color(f'!!! exception in callback: {error}'))
         self.reset()
 
 
@@ -1475,10 +1466,10 @@ class Protocol(EventEmitter):
             f'[{transaction_label}] {message}'
         )
         max_fragment_size = (
-            self.l2cap_channel.peer_mtu - 3
+            self.l2cap_channel.mtu - 3
         )  # Enough space for a 3-byte start packet header
         payload = message.payload
-        if len(payload) + 2 <= self.l2cap_channel.peer_mtu:
+        if len(payload) + 2 <= self.l2cap_channel.mtu:
             # Fits in a single packet
             packet_type = self.PacketType.SINGLE_PACKET
         else:
@@ -1550,10 +1541,9 @@ class Protocol(EventEmitter):
 
         assert False  # Should never reach this
 
-    async def get_capabilities(self, seid: int) -> Union[
-        Get_Capabilities_Response,
-        Get_All_Capabilities_Response,
-    ]:
+    async def get_capabilities(
+        self, seid: int
+    ) -> Union[Get_Capabilities_Response, Get_All_Capabilities_Response,]:
         if self.version > (1, 2):
             return await self.send_command(Get_All_Capabilities_Command(seid))
 

bumble/core.py

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

bumble/drivers/__init__.py

@@ -25,7 +25,7 @@ import pathlib
 import platform
 from typing import Dict, Iterable, Optional, Type, TYPE_CHECKING
 
-from . import rtk, intel
+from . import rtk
 from .common import Driver
 
 if TYPE_CHECKING:
@@ -45,7 +45,7 @@ async def get_driver_for_host(host: Host) -> Optional[Driver]:
     found.
     If a "driver" HCI metadata entry is present, only that driver class will be probed.
     """
-    driver_classes: Dict[str, Type[Driver]] = {"rtk": rtk.Driver, "intel": intel.Driver}
+    driver_classes: Dict[str, Type[Driver]] = {"rtk": rtk.Driver}
     probe_list: Iterable[str]
     if driver_name := host.hci_metadata.get("driver"):
         # Only probe a single driver

bumble/drivers/intel.py

@@ -1,102 +0,0 @@
-# Copyright 2024 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 logging
-
-from bumble.drivers import common
-from bumble.hci import (
-    hci_vendor_command_op_code,  # type: ignore
-    HCI_Command,
-    HCI_Reset_Command,
-)
-
-# -----------------------------------------------------------------------------
-# Logging
-# -----------------------------------------------------------------------------
-logger = logging.getLogger(__name__)
-
-# -----------------------------------------------------------------------------
-# Constant
-# -----------------------------------------------------------------------------
-
-INTEL_USB_PRODUCTS = {
-    # Intel AX210
-    (0x8087, 0x0032),
-    # Intel BE200
-    (0x8087, 0x0036),
-}
-
-# -----------------------------------------------------------------------------
-# HCI Commands
-# -----------------------------------------------------------------------------
-HCI_INTEL_DDC_CONFIG_WRITE_COMMAND = hci_vendor_command_op_code(0xFC8B)  # type: ignore
-HCI_INTEL_DDC_CONFIG_WRITE_PAYLOAD = [0x03, 0xE4, 0x02, 0x00]
-
-HCI_Command.register_commands(globals())
-
-
-@HCI_Command.command(  # type: ignore
-    fields=[("params", "*")],
-    return_parameters_fields=[
-        ("params", "*"),
-    ],
-)
-class Hci_Intel_DDC_Config_Write_Command(HCI_Command):
-    pass
-
-
-class Driver(common.Driver):
-    def __init__(self, host):
-        self.host = host
-
-    @staticmethod
-    def check(host):
-        driver = host.hci_metadata.get("driver")
-        if driver == "intel":
-            return True
-
-        vendor_id = host.hci_metadata.get("vendor_id")
-        product_id = host.hci_metadata.get("product_id")
-
-        if vendor_id is None or product_id is None:
-            logger.debug("USB metadata not sufficient")
-            return False
-
-        if (vendor_id, product_id) not in INTEL_USB_PRODUCTS:
-            logger.debug(
-                f"USB device ({vendor_id:04X}, {product_id:04X}) " "not in known list"
-            )
-            return False
-
-        return True
-
-    @classmethod
-    async def for_host(cls, host, force=False):  # type: ignore
-        # Only instantiate this driver if explicitly selected
-        if not force and not cls.check(host):
-            return None
-
-        return cls(host)
-
-    async def init_controller(self):
-        self.host.ready = True
-        await self.host.send_command(HCI_Reset_Command(), check_result=True)
-        await self.host.send_command(
-            Hci_Intel_DDC_Config_Write_Command(
-                params=HCI_INTEL_DDC_CONFIG_WRITE_PAYLOAD
-            )
-        )

bumble/gap.py

@@ -36,7 +36,6 @@ logger = logging.getLogger(__name__)
 # Classes
 # -----------------------------------------------------------------------------
 
-
 # -----------------------------------------------------------------------------
 class GenericAccessService(Service):
     def __init__(self, device_name, appearance=(0, 0)):

bumble/gatt.py

@@ -23,28 +23,16 @@
 # Imports
 # -----------------------------------------------------------------------------
 from __future__ import annotations
+import asyncio
 import enum
 import functools
 import logging
 import struct
-from typing import (
-    Callable,
-    Dict,
-    Iterable,
-    List,
-    Optional,
-    Sequence,
-    Union,
-    TYPE_CHECKING,
-)
+from typing import Optional, Sequence, Iterable, List, Union
 
-from bumble.colors import color
-from bumble.core import UUID
-from bumble.att import Attribute, AttributeValue
-
-if TYPE_CHECKING:
-    from bumble.gatt_client import AttributeProxy
-    from bumble.device import Connection
+from .colors import color
+from .core import UUID, get_dict_key_by_value
+from .att import Attribute
 
 
 # -----------------------------------------------------------------------------
@@ -342,11 +330,9 @@ class Service(Attribute):
             uuid = UUID(uuid)
 
         super().__init__(
-            (
-                GATT_PRIMARY_SERVICE_ATTRIBUTE_TYPE
-                if primary
-                else GATT_SECONDARY_SERVICE_ATTRIBUTE_TYPE
-            ),
+            GATT_PRIMARY_SERVICE_ATTRIBUTE_TYPE
+            if primary
+            else GATT_SECONDARY_SERVICE_ATTRIBUTE_TYPE,
             Attribute.READABLE,
             uuid.to_pdu_bytes(),
         )
@@ -536,43 +522,56 @@ class CharacteristicDeclaration(Attribute):
 
 
 # -----------------------------------------------------------------------------
-class CharacteristicValue(AttributeValue):
-    """Same as AttributeValue, for backward compatibility"""
+class CharacteristicValue:
+    '''
+    Characteristic value where reading and/or writing is delegated to functions
+    passed as arguments to the constructor.
+    '''
+
+    def __init__(self, read=None, write=None):
+        self._read = read
+        self._write = write
+
+    def read(self, connection):
+        return self._read(connection) if self._read else b''
+
+    def write(self, connection, value):
+        if self._write:
+            self._write(connection, value)
 
 
 # -----------------------------------------------------------------------------
 class CharacteristicAdapter:
     '''
-    An adapter that can adapt Characteristic and AttributeProxy objects
-    by wrapping their `read_value()` and `write_value()` methods with ones that
-    return/accept encoded/decoded values.
-
-    For proxies (i.e used by a GATT client), the adaptation is one where the return
-    value of `read_value()` is decoded and the value passed to `write_value()` is
-    encoded. The `subscribe()` method, is wrapped with one where the values are decoded
-    before being passed to the subscriber.
-
-    For local values (i.e hosted by a GATT server) the adaptation is one where the
-    return value of `read_value()` is encoded and the value passed to `write_value()`
-    is decoded.
+    An adapter that can adapt any object with `read_value` and `write_value`
+    methods (like Characteristic and CharacteristicProxy objects) by wrapping
+    those methods with ones that return/accept encoded/decoded values.
+    Objects with async methods are considered proxies, so the adaptation is one
+    where the return value of `read_value` is decoded and the value passed to
+    `write_value` is encoded. Other objects are considered local characteristics
+    so the adaptation is one where the return value of `read_value` is encoded
+    and the value passed to `write_value` is decoded.
+    If the characteristic has a `subscribe` method, it is wrapped with one where
+    the values are decoded before being passed to the subscriber.
     '''
 
-    read_value: Callable
-    write_value: Callable
-
-    def __init__(self, characteristic: Union[Characteristic, AttributeProxy]):
+    def __init__(self, characteristic):
         self.wrapped_characteristic = characteristic
-        self.subscribers: Dict[Callable, Callable] = (
-            {}
-        )  # Map from subscriber to proxy subscriber
+        self.subscribers = {}  # Map from subscriber to proxy subscriber
 
-        if isinstance(characteristic, Characteristic):
-            self.read_value = self.read_encoded_value
-            self.write_value = self.write_encoded_value
-        else:
+        if asyncio.iscoroutinefunction(
+            characteristic.read_value
+        ) and asyncio.iscoroutinefunction(characteristic.write_value):
             self.read_value = self.read_decoded_value
             self.write_value = self.write_decoded_value
+        else:
+            self.read_value = self.read_encoded_value
+            self.write_value = self.write_encoded_value
+
+        if hasattr(self.wrapped_characteristic, 'subscribe'):
             self.subscribe = self.wrapped_subscribe
+
+        if hasattr(self.wrapped_characteristic, 'unsubscribe'):
             self.unsubscribe = self.wrapped_unsubscribe
 
     def __getattr__(self, name):
@@ -591,13 +590,11 @@ class CharacteristicAdapter:
         else:
             setattr(self.wrapped_characteristic, name, value)
 
-    async def read_encoded_value(self, connection):
-        return self.encode_value(
-            await self.wrapped_characteristic.read_value(connection)
-        )
+    def read_encoded_value(self, connection):
+        return self.encode_value(self.wrapped_characteristic.read_value(connection))
 
-    async def write_encoded_value(self, connection, value):
-        return await self.wrapped_characteristic.write_value(
+    def write_encoded_value(self, connection, value):
+        return self.wrapped_characteristic.write_value(
             connection, self.decode_value(value)
         )
 
@@ -732,24 +729,13 @@ class Descriptor(Attribute):
     '''
 
     def __str__(self) -> str:
-        if isinstance(self.value, bytes):
-            value_str = self.value.hex()
-        elif isinstance(self.value, CharacteristicValue):
-            value = self.value.read(None)
-            if isinstance(value, bytes):
-                value_str = value.hex()
-            else:
-                value_str = '<async>'
-        else:
-            value_str = '<...>'
         return (
             f'Descriptor(handle=0x{self.handle:04X}, '
             f'type={self.type}, '
-            f'value={value_str})'
+            f'value={self.read_value(None).hex()})'
         )
 
 
-# -----------------------------------------------------------------------------
 class ClientCharacteristicConfigurationBits(enum.IntFlag):
     '''
     See Vol 3, Part G - 3.3.3.3 - Table 3.11 Client Characteristic Configuration bit

bumble/gatt_client.py

@@ -90,22 +90,6 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 
-# -----------------------------------------------------------------------------
-# Utils
-# -----------------------------------------------------------------------------
-
-
-def show_services(services: Iterable[ServiceProxy]) -> None:
-    for service in services:
-        print(color(str(service), 'cyan'))
-
-        for characteristic in service.characteristics:
-            print(color('  ' + str(characteristic), 'magenta'))
-
-            for descriptor in characteristic.descriptors:
-                print(color('    ' + str(descriptor), 'green'))
-
-
 # -----------------------------------------------------------------------------
 # Proxies
 # -----------------------------------------------------------------------------
@@ -368,7 +352,9 @@ class Client:
             if c.uuid == uuid
         ]
 
-    def get_attribute_grouping(self, attribute_handle: int) -> Optional[
+    def get_attribute_grouping(
+        self, attribute_handle: int
+    ) -> Optional[
         Union[
             ServiceProxy,
             Tuple[ServiceProxy, CharacteristicProxy],
@@ -1082,7 +1068,7 @@ class Client:
                 logger.warning('!!! unexpected response, there is no pending request')
                 return
 
-            # The response should match the pending request unless it is
+            # Sanity check: the response should match the pending request unless it is
             # an error response
             if att_pdu.op_code != ATT_ERROR_RESPONSE:
                 expected_response_name = self.pending_request.name.replace(

bumble/gatt_server.py

@@ -31,9 +31,9 @@ import struct
 from typing import List, Tuple, Optional, TypeVar, Type, Dict, Iterable, TYPE_CHECKING
 from pyee import EventEmitter
 
-from bumble.colors import color
-from bumble.core import UUID
-from bumble.att import (
+from .colors import color
+from .core import UUID
+from .att import (
     ATT_ATTRIBUTE_NOT_FOUND_ERROR,
     ATT_ATTRIBUTE_NOT_LONG_ERROR,
     ATT_CID,
@@ -60,7 +60,7 @@ from bumble.att import (
     ATT_Write_Response,
     Attribute,
 )
-from bumble.gatt import (
+from .gatt import (
     GATT_CHARACTERISTIC_ATTRIBUTE_TYPE,
     GATT_CLIENT_CHARACTERISTIC_CONFIGURATION_DESCRIPTOR,
     GATT_MAX_ATTRIBUTE_VALUE_SIZE,
@@ -74,7 +74,6 @@ from bumble.gatt import (
     Descriptor,
     Service,
 )
-from bumble.utils import AsyncRunner
 
 if TYPE_CHECKING:
     from bumble.device import Device, Connection
@@ -328,7 +327,7 @@ class Server(EventEmitter):
             f'handle=0x{characteristic.handle:04X}: {value.hex()}'
         )
 
-        # Check parameters
+        # Sanity check
         if len(value) != 2:
             logger.warning('CCCD value not 2 bytes long')
             return
@@ -380,7 +379,7 @@ class Server(EventEmitter):
 
         # Get or encode the value
         value = (
-            await attribute.read_value(connection)
+            attribute.read_value(connection)
             if value is None
             else attribute.encode_value(value)
         )
@@ -423,7 +422,7 @@ class Server(EventEmitter):
 
         # Get or encode the value
         value = (
-            await attribute.read_value(connection)
+            attribute.read_value(connection)
             if value is None
             else attribute.encode_value(value)
         )
@@ -445,9 +444,9 @@ class Server(EventEmitter):
             assert self.pending_confirmations[connection.handle] is None
 
             # Create a future value to hold the eventual response
-            pending_confirmation = self.pending_confirmations[connection.handle] = (
-                asyncio.get_running_loop().create_future()
-            )
+            pending_confirmation = self.pending_confirmations[
+                connection.handle
+            ] = asyncio.get_running_loop().create_future()
 
             try:
                 self.send_gatt_pdu(connection.handle, indication.to_bytes())
@@ -651,8 +650,7 @@ class Server(EventEmitter):
 
         self.send_response(connection, response)
 
-    @AsyncRunner.run_in_task()
-    async def on_att_find_by_type_value_request(self, connection, request):
+    def on_att_find_by_type_value_request(self, connection, request):
         '''
         See Bluetooth spec Vol 3, Part F - 3.4.3.3 Find By Type Value Request
         '''
@@ -660,13 +658,13 @@ class Server(EventEmitter):
         # Build list of returned attributes
         pdu_space_available = connection.att_mtu - 2
         attributes = []
-        async for attribute in (
+        for attribute in (
             attribute
             for attribute in self.attributes
             if attribute.handle >= request.starting_handle
             and attribute.handle <= request.ending_handle
             and attribute.type == request.attribute_type
-            and (await attribute.read_value(connection)) == request.attribute_value
+            and attribute.read_value(connection) == request.attribute_value
             and pdu_space_available >= 4
         ):
             # TODO: check permissions
@@ -704,8 +702,7 @@ class Server(EventEmitter):
 
         self.send_response(connection, response)
 
-    @AsyncRunner.run_in_task()
-    async def on_att_read_by_type_request(self, connection, request):
+    def on_att_read_by_type_request(self, connection, request):
         '''
         See Bluetooth spec Vol 3, Part F - 3.4.4.1 Read By Type Request
         '''
@@ -728,7 +725,7 @@ class Server(EventEmitter):
             and pdu_space_available
         ):
             try:
-                attribute_value = await attribute.read_value(connection)
+                attribute_value = attribute.read_value(connection)
             except ATT_Error as error:
                 # If the first attribute is unreadable, return an error
                 # Otherwise return attributes up to this point
@@ -770,15 +767,14 @@ class Server(EventEmitter):
 
         self.send_response(connection, response)
 
-    @AsyncRunner.run_in_task()
-    async def on_att_read_request(self, connection, request):
+    def on_att_read_request(self, connection, request):
         '''
         See Bluetooth spec Vol 3, Part F - 3.4.4.3 Read Request
         '''
 
         if attribute := self.get_attribute(request.attribute_handle):
             try:
-                value = await attribute.read_value(connection)
+                value = attribute.read_value(connection)
             except ATT_Error as error:
                 response = ATT_Error_Response(
                     request_opcode_in_error=request.op_code,
@@ -796,15 +792,14 @@ class Server(EventEmitter):
             )
         self.send_response(connection, response)
 
-    @AsyncRunner.run_in_task()
-    async def on_att_read_blob_request(self, connection, request):
+    def on_att_read_blob_request(self, connection, request):
         '''
         See Bluetooth spec Vol 3, Part F - 3.4.4.5 Read Blob Request
         '''
 
         if attribute := self.get_attribute(request.attribute_handle):
             try:
-                value = await attribute.read_value(connection)
+                value = attribute.read_value(connection)
             except ATT_Error as error:
                 response = ATT_Error_Response(
                     request_opcode_in_error=request.op_code,
@@ -841,8 +836,7 @@ class Server(EventEmitter):
             )
         self.send_response(connection, response)
 
-    @AsyncRunner.run_in_task()
-    async def on_att_read_by_group_type_request(self, connection, request):
+    def on_att_read_by_group_type_request(self, connection, request):
         '''
         See Bluetooth spec Vol 3, Part F - 3.4.4.9 Read by Group Type Request
         '''
@@ -870,7 +864,7 @@ class Server(EventEmitter):
         ):
             # No need to catch permission errors here, since these attributes
             # must all be world-readable
-            attribute_value = await attribute.read_value(connection)
+            attribute_value = attribute.read_value(connection)
             # Check the attribute value size
             max_attribute_size = min(connection.att_mtu - 6, 251)
             if len(attribute_value) > max_attribute_size:
@@ -909,8 +903,7 @@ class Server(EventEmitter):
 
         self.send_response(connection, response)
 
-    @AsyncRunner.run_in_task()
-    async def on_att_write_request(self, connection, request):
+    def on_att_write_request(self, connection, request):
         '''
         See Bluetooth spec Vol 3, Part F - 3.4.5.1 Write Request
         '''
@@ -943,13 +936,12 @@ class Server(EventEmitter):
             return
 
         # Accept the value
-        await attribute.write_value(connection, request.attribute_value)
+        attribute.write_value(connection, request.attribute_value)
 
         # Done
         self.send_response(connection, ATT_Write_Response())
 
-    @AsyncRunner.run_in_task()
-    async def on_att_write_command(self, connection, request):
+    def on_att_write_command(self, connection, request):
         '''
         See Bluetooth spec Vol 3, Part F - 3.4.5.3 Write Command
         '''
@@ -967,7 +959,7 @@ class Server(EventEmitter):
 
         # Accept the value
         try:
-            await attribute.write_value(connection, request.attribute_value)
+            attribute.write_value(connection, request.attribute_value)
         except Exception as error:
             logger.exception(f'!!! ignoring exception: {error}')
 

bumble/helpers.py

@@ -18,17 +18,10 @@
 from __future__ import annotations
 
 from collections.abc import Callable, MutableMapping
-import datetime
-from typing import cast, Any, Optional
+from typing import cast, Any
 import logging
 
-from bumble import avc
-from bumble import avctp
 from bumble import avdtp
-from bumble import avrcp
-from bumble import crypto
-from bumble import rfcomm
-from bumble import sdp
 from bumble.colors import color
 from bumble.att import ATT_CID, ATT_PDU
 from bumble.smp import SMP_CID, SMP_Command
@@ -54,7 +47,9 @@ from bumble.hci import (
     HCI_AclDataPacket,
     HCI_Disconnection_Complete_Event,
 )
-
+from bumble.rfcomm import RFCOMM_Frame, RFCOMM_PSM
+from bumble.sdp import SDP_PDU, SDP_PSM
+from bumble import crypto
 
 # -----------------------------------------------------------------------------
 # Logging
@@ -64,36 +59,28 @@ logger = logging.getLogger(__name__)
 
 # -----------------------------------------------------------------------------
 PSM_NAMES = {
-    rfcomm.RFCOMM_PSM: 'RFCOMM',
-    sdp.SDP_PSM: 'SDP',
+    RFCOMM_PSM: 'RFCOMM',
+    SDP_PSM: 'SDP',
     avdtp.AVDTP_PSM: 'AVDTP',
-    avctp.AVCTP_PSM: 'AVCTP',
-    # TODO: add more PSM values
 }
 
-AVCTP_PID_NAMES = {avrcp.AVRCP_PID: 'AVRCP'}
-
 
 # -----------------------------------------------------------------------------
 class PacketTracer:
     class AclStream:
         psms: MutableMapping[int, int]
-        peer: Optional[PacketTracer.AclStream]
+        peer: PacketTracer.AclStream
         avdtp_assemblers: MutableMapping[int, avdtp.MessageAssembler]
-        avctp_assemblers: MutableMapping[int, avctp.MessageAssembler]
 
         def __init__(self, analyzer: PacketTracer.Analyzer) -> None:
             self.analyzer = analyzer
             self.packet_assembler = HCI_AclDataPacketAssembler(self.on_acl_pdu)
             self.avdtp_assemblers = {}  # AVDTP assemblers, by source_cid
-            self.avctp_assemblers = {}  # AVCTP assemblers, by source_cid
             self.psms = {}  # PSM, by source_cid
-            self.peer = None
 
         # pylint: disable=too-many-nested-blocks
         def on_acl_pdu(self, pdu: bytes) -> None:
             l2cap_pdu = L2CAP_PDU.from_bytes(pdu)
-            self.analyzer.emit(l2cap_pdu)
 
             if l2cap_pdu.cid == ATT_CID:
                 att_pdu = ATT_PDU.from_bytes(l2cap_pdu.payload)
@@ -115,51 +102,42 @@ class PacketTracer:
                         connection_response.result
                         == L2CAP_Connection_Response.CONNECTION_SUCCESSFUL
                     ):
-                        if self.peer and (
-                            psm := self.peer.psms.get(connection_response.source_cid)
-                        ):
-                            # Found a pending connection
-                            self.psms[connection_response.destination_cid] = psm
+                        if self.peer:
+                            if psm := self.peer.psms.get(
+                                connection_response.source_cid
+                            ):
+                                # Found a pending connection
+                                self.psms[connection_response.destination_cid] = psm
+
+                                # For AVDTP connections, create a packet assembler for
+                                # each direction
+                                if psm == avdtp.AVDTP_PSM:
+                                    self.avdtp_assemblers[
+                                        connection_response.source_cid
+                                    ] = avdtp.MessageAssembler(self.on_avdtp_message)
+                                    self.peer.avdtp_assemblers[
+                                        connection_response.destination_cid
+                                    ] = avdtp.MessageAssembler(
+                                        self.peer.on_avdtp_message
+                                    )
 
-                            # For AVDTP connections, create a packet assembler for
-                            # each direction
-                            if psm == avdtp.AVDTP_PSM:
-                                self.avdtp_assemblers[
-                                    connection_response.source_cid
-                                ] = avdtp.MessageAssembler(self.on_avdtp_message)
-                                self.peer.avdtp_assemblers[
-                                    connection_response.destination_cid
-                                ] = avdtp.MessageAssembler(self.peer.on_avdtp_message)
-                            elif psm == avctp.AVCTP_PSM:
-                                self.avctp_assemblers[
-                                    connection_response.source_cid
-                                ] = avctp.MessageAssembler(self.on_avctp_message)
-                                self.peer.avctp_assemblers[
-                                    connection_response.destination_cid
-                                ] = avctp.MessageAssembler(self.peer.on_avctp_message)
             else:
                 # Try to find the PSM associated with this PDU
                 if self.peer and (psm := self.peer.psms.get(l2cap_pdu.cid)):
-                    if psm == sdp.SDP_PSM:
-                        sdp_pdu = sdp.SDP_PDU.from_bytes(l2cap_pdu.payload)
+                    if psm == SDP_PSM:
+                        sdp_pdu = SDP_PDU.from_bytes(l2cap_pdu.payload)
                         self.analyzer.emit(sdp_pdu)
-                    elif psm == rfcomm.RFCOMM_PSM:
-                        rfcomm_frame = rfcomm.RFCOMM_Frame.from_bytes(l2cap_pdu.payload)
+                    elif psm == RFCOMM_PSM:
+                        rfcomm_frame = RFCOMM_Frame.from_bytes(l2cap_pdu.payload)
                         self.analyzer.emit(rfcomm_frame)
                     elif psm == avdtp.AVDTP_PSM:
                         self.analyzer.emit(
                             f'{color("L2CAP", "green")} [CID={l2cap_pdu.cid}, '
                             f'PSM=AVDTP]: {l2cap_pdu.payload.hex()}'
                         )
-                        if avdtp_assembler := self.avdtp_assemblers.get(l2cap_pdu.cid):
-                            avdtp_assembler.on_pdu(l2cap_pdu.payload)
-                    elif psm == avctp.AVCTP_PSM:
-                        self.analyzer.emit(
-                            f'{color("L2CAP", "green")} [CID={l2cap_pdu.cid}, '
-                            f'PSM=AVCTP]: {l2cap_pdu.payload.hex()}'
-                        )
-                        if avctp_assembler := self.avctp_assemblers.get(l2cap_pdu.cid):
-                            avctp_assembler.on_pdu(l2cap_pdu.payload)
+                        assembler = self.avdtp_assemblers.get(l2cap_pdu.cid)
+                        if assembler:
+                            assembler.on_pdu(l2cap_pdu.payload)
                     else:
                         psm_string = name_or_number(PSM_NAMES, psm)
                         self.analyzer.emit(
@@ -176,28 +154,6 @@ class PacketTracer:
                 f'{color("AVDTP", "green")} [{transaction_label}] {message}'
             )
 
-        def on_avctp_message(
-            self,
-            transaction_label: int,
-            is_command: bool,
-            ipid: bool,
-            pid: int,
-            payload: bytes,
-        ):
-            if pid == avrcp.AVRCP_PID:
-                avc_frame = avc.Frame.from_bytes(payload)
-                details = str(avc_frame)
-            else:
-                details = payload.hex()
-
-            c_r = 'Command' if is_command else 'Response'
-            self.analyzer.emit(
-                f'{color("AVCTP", "green")} '
-                f'{c_r}[{transaction_label}][{name_or_number(AVCTP_PID_NAMES, pid)}] '
-                f'{"#" if ipid else ""}'
-                f'{details}'
-            )
-
         def feed_packet(self, packet: HCI_AclDataPacket) -> None:
             self.packet_assembler.feed_packet(packet)
 
@@ -209,7 +165,6 @@ class PacketTracer:
             self.label = label
             self.emit_message = emit_message
             self.acl_streams = {}  # ACL streams, by connection handle
-            self.packet_timestamp: Optional[datetime.datetime] = None
 
         def start_acl_stream(self, connection_handle: int) -> PacketTracer.AclStream:
             logger.info(
@@ -237,10 +192,7 @@ class PacketTracer:
                 # Let the other forwarder know so it can cleanup its stream as well
                 self.peer.end_acl_stream(connection_handle)
 
-        def on_packet(
-            self, timestamp: Optional[datetime.datetime], packet: HCI_Packet
-        ) -> None:
-            self.packet_timestamp = timestamp
+        def on_packet(self, packet: HCI_Packet) -> None:
             self.emit(packet)
 
             if packet.hci_packet_type == HCI_ACL_DATA_PACKET:
@@ -260,22 +212,13 @@ class PacketTracer:
                     )
 
         def emit(self, message: Any) -> None:
-            if self.packet_timestamp:
-                prefix = f"[{self.packet_timestamp.strftime('%Y-%m-%d %H:%M:%S.%f')}]"
-            else:
-                prefix = ""
-            self.emit_message(f'{prefix}[{self.label}] {message}')
+            self.emit_message(f'[{self.label}] {message}')
 
-    def trace(
-        self,
-        packet: HCI_Packet,
-        direction: int = 0,
-        timestamp: Optional[datetime.datetime] = None,
-    ) -> None:
+    def trace(self, packet: HCI_Packet, direction: int = 0) -> None:
         if direction == 0:
-            self.host_to_controller_analyzer.on_packet(timestamp, packet)
+            self.host_to_controller_analyzer.on_packet(packet)
         else:
-            self.controller_to_host_analyzer.on_packet(timestamp, packet)
+            self.controller_to_host_analyzer.on_packet(packet)
 
     def __init__(
         self,

bumble/hid.py

@@ -48,7 +48,6 @@ HID_INTERRUPT_PSM = 0x0013
 
 class Message:
     message_type: MessageType
-
     # Report types
     class ReportType(enum.IntEnum):
         OTHER_REPORT = 0x00
@@ -403,7 +402,7 @@ class Device(HID):
         report_type = pdu[0] & 0x03
         buffer_flag = (pdu[0] & 0x08) >> 3
         report_id = pdu[1]
-        logger.debug(f"buffer_flag: {buffer_flag}")
+        logger.debug("buffer_flag: " + str(buffer_flag))
         if buffer_flag == 1:
             buffer_size = (pdu[3] << 8) | pdu[2]
         else:
@@ -417,7 +416,7 @@ class Device(HID):
             data = bytearray()
             data.append(report_id)
             data.extend(ret.data)
-            if len(data) < self.l2cap_ctrl_channel.peer_mtu:  # type: ignore[union-attr]
+            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)

bumble/keys.py

@@ -128,10 +128,10 @@ class PairingKeys:
 
     def print(self, prefix=''):
         keys_dict = self.to_dict()
-        for container_property, value in keys_dict.items():
+        for (container_property, value) in keys_dict.items():
             if isinstance(value, dict):
                 print(f'{prefix}{color(container_property, "cyan")}:')
-                for key_property, key_value in value.items():
+                for (key_property, key_value) in value.items():
                     print(f'{prefix}  {color(key_property, "green")}: {key_value}')
             else:
                 print(f'{prefix}{color(container_property, "cyan")}: {value}')
@@ -158,7 +158,7 @@ class KeyStore:
     async def get_resolving_keys(self):
         all_keys = await self.get_all()
         resolving_keys = []
-        for name, keys in all_keys:
+        for (name, keys) in all_keys:
             if keys.irk is not None:
                 if keys.address_type is None:
                     address_type = Address.RANDOM_DEVICE_ADDRESS
@@ -171,7 +171,7 @@ class KeyStore:
     async def print(self, prefix=''):
         entries = await self.get_all()
         separator = ''
-        for name, keys in entries:
+        for (name, keys) in entries:
             print(separator + prefix + color(name, 'yellow'))
             keys.print(prefix=prefix + '  ')
             separator = '\n'

bumble/l2cap.py

@@ -149,10 +149,9 @@ L2CAP_INVALID_CID_IN_REQUEST_REASON = 0x0002
 
 L2CAP_LE_CREDIT_BASED_CONNECTION_MAX_CREDITS             = 65535
 L2CAP_LE_CREDIT_BASED_CONNECTION_MIN_MTU                 = 23
-L2CAP_LE_CREDIT_BASED_CONNECTION_MAX_MTU                 = 65535
 L2CAP_LE_CREDIT_BASED_CONNECTION_MIN_MPS                 = 23
 L2CAP_LE_CREDIT_BASED_CONNECTION_MAX_MPS                 = 65533
-L2CAP_LE_CREDIT_BASED_CONNECTION_DEFAULT_MTU             = 2048
+L2CAP_LE_CREDIT_BASED_CONNECTION_DEFAULT_MTU             = 2046
 L2CAP_LE_CREDIT_BASED_CONNECTION_DEFAULT_MPS             = 2048
 L2CAP_LE_CREDIT_BASED_CONNECTION_DEFAULT_INITIAL_CREDITS = 256
 
@@ -173,7 +172,7 @@ L2CAP_MTU_CONFIGURATION_PARAMETER_TYPE = 0x01
 @dataclasses.dataclass
 class ClassicChannelSpec:
     psm: Optional[int] = None
-    mtu: int = L2CAP_DEFAULT_MTU
+    mtu: int = L2CAP_MIN_BR_EDR_MTU
 
 
 @dataclasses.dataclass
@@ -189,11 +188,8 @@ class LeCreditBasedChannelSpec:
             or self.max_credits > L2CAP_LE_CREDIT_BASED_CONNECTION_MAX_CREDITS
         ):
             raise ValueError('max credits out of range')
-        if (
-            self.mtu < L2CAP_LE_CREDIT_BASED_CONNECTION_MIN_MTU
-            or self.mtu > L2CAP_LE_CREDIT_BASED_CONNECTION_MAX_MTU
-        ):
-            raise ValueError('MTU out of range')
+        if self.mtu < L2CAP_LE_CREDIT_BASED_CONNECTION_MIN_MTU:
+            raise ValueError('MTU too small')
         if (
             self.mps < L2CAP_LE_CREDIT_BASED_CONNECTION_MIN_MPS
             or self.mps > L2CAP_LE_CREDIT_BASED_CONNECTION_MAX_MPS
@@ -208,7 +204,7 @@ class L2CAP_PDU:
 
     @staticmethod
     def from_bytes(data: bytes) -> L2CAP_PDU:
-        # Check parameters
+        # Sanity check
         if len(data) < 4:
             raise ValueError('not enough data for L2CAP header')
 
@@ -749,8 +745,6 @@ class ClassicChannel(EventEmitter):
     sink: Optional[Callable[[bytes], Any]]
     state: State
     connection: Connection
-    mtu: int
-    peer_mtu: int
 
     def __init__(
         self,
@@ -767,7 +761,6 @@ class ClassicChannel(EventEmitter):
         self.signaling_cid = signaling_cid
         self.state = self.State.CLOSED
         self.mtu = mtu
-        self.peer_mtu = L2CAP_MIN_BR_EDR_MTU
         self.psm = psm
         self.source_cid = source_cid
         self.destination_cid = 0
@@ -864,7 +857,7 @@ class ClassicChannel(EventEmitter):
             [
                 (
                     L2CAP_MAXIMUM_TRANSMISSION_UNIT_CONFIGURATION_OPTION_TYPE,
-                    struct.pack('<H', self.mtu),
+                    struct.pack('<H', L2CAP_DEFAULT_MTU),
                 )
             ]
         )
@@ -929,8 +922,8 @@ class ClassicChannel(EventEmitter):
         options = L2CAP_Control_Frame.decode_configuration_options(request.options)
         for option in options:
             if option[0] == L2CAP_MTU_CONFIGURATION_PARAMETER_TYPE:
-                self.peer_mtu = struct.unpack('<H', option[1])[0]
-                logger.debug(f'peer MTU = {self.peer_mtu}')
+                self.mtu = struct.unpack('<H', option[1])[0]
+                logger.debug(f'MTU = {self.mtu}')
 
         self.send_control_frame(
             L2CAP_Configure_Response(
@@ -1029,7 +1022,7 @@ class ClassicChannel(EventEmitter):
         return (
             f'Channel({self.source_cid}->{self.destination_cid}, '
             f'PSM={self.psm}, '
-            f'MTU={self.mtu}/{self.peer_mtu}, '
+            f'MTU={self.mtu}, '
             f'state={self.state.name})'
         )
 
@@ -1651,13 +1644,12 @@ class ChannelManager:
 
     def send_pdu(self, connection, cid: int, pdu: Union[SupportsBytes, bytes]) -> None:
         pdu_str = pdu.hex() if isinstance(pdu, bytes) else str(pdu)
-        pdu_bytes = bytes(pdu)
         logger.debug(
             f'{color(">>> Sending L2CAP PDU", "blue")} '
             f'on connection [0x{connection.handle:04X}] (CID={cid}) '
-            f'{connection.peer_address}: {len(pdu_bytes)} bytes, {pdu_str}'
+            f'{connection.peer_address}: {pdu_str}'
         )
-        self.host.send_l2cap_pdu(connection.handle, cid, pdu_bytes)
+        self.host.send_l2cap_pdu(connection.handle, cid, bytes(pdu))
 
     def on_pdu(self, connection: Connection, cid: int, pdu: bytes) -> None:
         if cid in (L2CAP_SIGNALING_CID, L2CAP_LE_SIGNALING_CID):

bumble/link.py

@@ -26,13 +26,9 @@ from bumble.hci import (
     HCI_SUCCESS,
     HCI_CONNECTION_ACCEPT_TIMEOUT_ERROR,
     HCI_CONNECTION_TIMEOUT_ERROR,
-    HCI_UNKNOWN_CONNECTION_IDENTIFIER_ERROR,
     HCI_PAGE_TIMEOUT_ERROR,
     HCI_Connection_Complete_Event,
 )
-from bumble import controller
-
-from typing import Optional, Set
 
 # -----------------------------------------------------------------------------
 # Logging
@@ -61,8 +57,6 @@ class LocalLink:
     Link bus for controllers to communicate with each other
     '''
 
-    controllers: Set[controller.Controller]
-
     def __init__(self):
         self.controllers = set()
         self.pending_connection = None
@@ -85,9 +79,7 @@ class LocalLink:
                 return controller
         return None
 
-    def find_classic_controller(
-        self, address: Address
-    ) -> Optional[controller.Controller]:
+    def find_classic_controller(self, address):
         for controller in self.controllers:
             if controller.public_address == address:
                 return controller
@@ -103,11 +95,21 @@ class LocalLink:
     def on_address_changed(self, controller):
         pass
 
-    def send_advertising_data(self, sender_address, data):
+    def send_advertising_data(self, sender_address, 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_advertising_data(sender_address, data)
+                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
+                )
 
     def send_acl_data(self, sender_controller, destination_address, transport, data):
         # Send the data to the first controller with a matching address
@@ -159,30 +161,34 @@ class LocalLink:
         asyncio.get_running_loop().call_soon(self.on_connection_complete)
 
     def on_disconnection_complete(
-        self, central_address, peripheral_address, disconnect_command
+        self, initiator_address, peer_address, disconnect_command
     ):
         # Find the controller that initiated the disconnection
-        if not (central_controller := self.find_controller(central_address)):
+        if not (initiator_controller := self.find_controller(initiator_address)):
             logger.warning('!!! Initiating controller not found')
             return
 
         # Disconnect from the first controller with a matching address
-        if peripheral_controller := self.find_controller(peripheral_address):
-            peripheral_controller.on_link_central_disconnected(
-                central_address, disconnect_command.reason
+        if peer_controller := self.find_controller(peer_address):
+            peer_controller.on_link_peer_disconnected(
+                initiator_address, disconnect_command.reason
             )
 
-        central_controller.on_link_peripheral_disconnection_complete(
+        initiator_controller.on_link_initiated_disconnection_complete(
             disconnect_command, HCI_SUCCESS
         )
 
-    def disconnect(self, central_address, peripheral_address, disconnect_command):
+    def disconnect(self, initiator_address, peer_address, disconnect_command):
         logger.debug(
-            f'$$$ DISCONNECTION {central_address} -> '
-            f'{peripheral_address}: reason = {disconnect_command.reason}'
+            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,
         )
-        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(
@@ -196,60 +202,6 @@ class LocalLink:
         if peripheral_controller := self.find_controller(peripheral_address):
             peripheral_controller.on_link_encrypted(central_address, rand, ediv, ltk)
 
-    def create_cis(
-        self,
-        central_controller: controller.Controller,
-        peripheral_address: Address,
-        cig_id: int,
-        cis_id: int,
-    ) -> None:
-        logger.debug(
-            f'$$$ CIS Request {central_controller.random_address} -> {peripheral_address}'
-        )
-        if peripheral_controller := self.find_controller(peripheral_address):
-            asyncio.get_running_loop().call_soon(
-                peripheral_controller.on_link_cis_request,
-                central_controller.random_address,
-                cig_id,
-                cis_id,
-            )
-
-    def accept_cis(
-        self,
-        peripheral_controller: controller.Controller,
-        central_address: Address,
-        cig_id: int,
-        cis_id: int,
-    ) -> None:
-        logger.debug(
-            f'$$$ CIS Accept {peripheral_controller.random_address} -> {central_address}'
-        )
-        if central_controller := self.find_controller(central_address):
-            asyncio.get_running_loop().call_soon(
-                central_controller.on_link_cis_established, cig_id, cis_id
-            )
-            asyncio.get_running_loop().call_soon(
-                peripheral_controller.on_link_cis_established, cig_id, cis_id
-            )
-
-    def disconnect_cis(
-        self,
-        initiator_controller: controller.Controller,
-        peer_address: Address,
-        cig_id: int,
-        cis_id: int,
-    ) -> None:
-        logger.debug(
-            f'$$$ CIS Disconnect {initiator_controller.random_address} -> {peer_address}'
-        )
-        if peer_controller := self.find_controller(peer_address):
-            asyncio.get_running_loop().call_soon(
-                initiator_controller.on_link_cis_disconnected, cig_id, cis_id
-            )
-            asyncio.get_running_loop().call_soon(
-                peer_controller.on_link_cis_disconnected, cig_id, cis_id
-            )
-
     ############################################################
     # Classic handlers
     ############################################################
@@ -333,52 +285,6 @@ class LocalLink:
             initiator_controller.public_address, int(not (initiator_new_role))
         )
 
-    def classic_sco_connect(
-        self,
-        initiator_controller: controller.Controller,
-        responder_address: Address,
-        link_type: int,
-    ):
-        logger.debug(
-            f'[Classic] {initiator_controller.public_address} connects SCO to {responder_address}'
-        )
-        responder_controller = self.find_classic_controller(responder_address)
-        # Initiator controller should handle it.
-        assert responder_controller
-
-        responder_controller.on_classic_connection_request(
-            initiator_controller.public_address,
-            link_type,
-        )
-
-    def classic_accept_sco_connection(
-        self,
-        responder_controller: controller.Controller,
-        initiator_address: Address,
-        link_type: int,
-    ):
-        logger.debug(
-            f'[Classic] {responder_controller.public_address} accepts to connect SCO {initiator_address}'
-        )
-        initiator_controller = self.find_classic_controller(initiator_address)
-        if initiator_controller is None:
-            responder_controller.on_classic_sco_connection_complete(
-                responder_controller.public_address,
-                HCI_UNKNOWN_CONNECTION_IDENTIFIER_ERROR,
-                link_type,
-            )
-            return
-
-        async def task():
-            initiator_controller.on_classic_sco_connection_complete(
-                responder_controller.public_address, HCI_SUCCESS, link_type
-            )
-
-        asyncio.create_task(task())
-        responder_controller.on_classic_sco_connection_complete(
-            initiator_controller.public_address, HCI_SUCCESS, link_type
-        )
-
 
 # -----------------------------------------------------------------------------
 class RemoteLink:
@@ -468,11 +374,11 @@ class RemoteLink:
 
     async def on_left_received(self, address):
         if address in self.central_connections:
-            self.controller.on_link_peripheral_disconnected(Address(address))
+            self.controller.on_link_connection_lost(Address(address))
             self.central_connections.remove(address)
 
         if address in self.peripheral_connections:
-            self.controller.on_link_central_disconnected(
+            self.controller.on_link_peer_disconnected(
                 address, HCI_CONNECTION_TIMEOUT_ERROR
             )
             self.peripheral_connections.remove(address)
@@ -492,7 +398,7 @@ class RemoteLink:
     async def on_advertisement_message_received(self, sender, advertisement):
         try:
             self.controller.on_link_advertising_data(
-                Address(sender), bytes.fromhex(advertisement)
+                Address(sender), bytes.fromhex(advertisement), b''
             )
         except Exception:
             logger.exception('exception')
@@ -532,7 +438,7 @@ class RemoteLink:
         # Notify the controller
         params = parse_parameters(message)
         reason = int(params.get('reason', str(HCI_CONNECTION_TIMEOUT_ERROR)))
-        self.controller.on_link_central_disconnected(Address(sender), reason)
+        self.controller.on_link_peer_disconnected(Address(sender), reason)
 
         # Forget the connection
         if sender in self.peripheral_connections:
@@ -579,7 +485,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):
+    def send_advertising_data(self, _, data, scan_response):
         self.execute(partial(self.send_advertising_data_to_relay, data))
 
     async def send_acl_data_to_relay(self, peer_address, data):

bumble/pandora/host.py

@@ -34,11 +34,8 @@ from bumble.device import (
     DEVICE_DEFAULT_SCAN_INTERVAL,
     DEVICE_DEFAULT_SCAN_WINDOW,
     Advertisement,
-    AdvertisingParameters,
-    AdvertisingEventProperties,
     AdvertisingType,
     Device,
-    Phy,
 )
 from bumble.gatt import Service
 from bumble.hci import (
@@ -50,12 +47,9 @@ from bumble.hci import (
 from google.protobuf import any_pb2  # pytype: disable=pyi-error
 from google.protobuf import empty_pb2  # pytype: disable=pyi-error
 from pandora.host_grpc_aio import HostServicer
-from pandora import host_pb2
 from pandora.host_pb2 import (
     NOT_CONNECTABLE,
     NOT_DISCOVERABLE,
-    DISCOVERABLE_LIMITED,
-    DISCOVERABLE_GENERAL,
     PRIMARY_1M,
     PRIMARY_CODED,
     SECONDARY_1M,
@@ -71,7 +65,6 @@ from pandora.host_pb2 import (
     ConnectResponse,
     DataTypes,
     DisconnectRequest,
-    DiscoverabilityMode,
     InquiryResponse,
     PrimaryPhy,
     ReadLocalAddressResponse,
@@ -101,25 +94,6 @@ SECONDARY_PHY_MAP: Dict[int, SecondaryPhy] = {
     3: SECONDARY_CODED,
 }
 
-PRIMARY_PHY_TO_BUMBLE_PHY_MAP: Dict[PrimaryPhy, Phy] = {
-    PRIMARY_1M: Phy.LE_1M,
-    PRIMARY_CODED: Phy.LE_CODED,
-}
-
-SECONDARY_PHY_TO_BUMBLE_PHY_MAP: Dict[SecondaryPhy, Phy] = {
-    SECONDARY_NONE: Phy.LE_1M,
-    SECONDARY_1M: Phy.LE_1M,
-    SECONDARY_2M: Phy.LE_2M,
-    SECONDARY_CODED: Phy.LE_CODED,
-}
-
-OWN_ADDRESS_MAP: Dict[host_pb2.OwnAddressType, bumble.hci.OwnAddressType] = {
-    host_pb2.PUBLIC: bumble.hci.OwnAddressType.PUBLIC,
-    host_pb2.RANDOM: bumble.hci.OwnAddressType.RANDOM,
-    host_pb2.RESOLVABLE_OR_PUBLIC: bumble.hci.OwnAddressType.RESOLVABLE_OR_PUBLIC,
-    host_pb2.RESOLVABLE_OR_RANDOM: bumble.hci.OwnAddressType.RESOLVABLE_OR_RANDOM,
-}
-
 
 class HostService(HostServicer):
     waited_connections: Set[int]
@@ -287,9 +261,9 @@ class HostService(HostServicer):
         self.log.debug(f"WaitDisconnection: {connection_handle}")
 
         if connection := self.device.lookup_connection(connection_handle):
-            disconnection_future: asyncio.Future[None] = (
-                asyncio.get_running_loop().create_future()
-            )
+            disconnection_future: asyncio.Future[
+                None
+            ] = asyncio.get_running_loop().create_future()
 
             def on_disconnection(_: None) -> None:
                 disconnection_future.set_result(None)
@@ -307,118 +281,14 @@ class HostService(HostServicer):
     async def Advertise(
         self, request: AdvertiseRequest, context: grpc.ServicerContext
     ) -> AsyncGenerator[AdvertiseResponse, None]:
-        try:
-            if request.legacy:
-                async for rsp in self.legacy_advertise(request, context):
-                    yield rsp
-            else:
-                async for rsp in self.extended_advertise(request, context):
-                    yield rsp
-        finally:
-            pass
-
-    async def extended_advertise(
-        self, request: AdvertiseRequest, context: grpc.ServicerContext
-    ) -> AsyncGenerator[AdvertiseResponse, None]:
-        advertising_data = bytes(self.unpack_data_types(request.data))
-        scan_response_data = bytes(self.unpack_data_types(request.scan_response_data))
-        scannable = len(scan_response_data) != 0
-
-        advertising_event_properties = AdvertisingEventProperties(
-            is_connectable=request.connectable,
-            is_scannable=scannable,
-            is_directed=request.target is not None,
-            is_high_duty_cycle_directed_connectable=False,
-            is_legacy=False,
-            is_anonymous=False,
-            include_tx_power=False,
-        )
-
-        peer_address = Address.ANY
-        if request.target:
-            # Need to reverse bytes order since Bumble Address is using MSB.
-            target_bytes = bytes(reversed(request.target))
-            if request.target_variant() == "public":
-                peer_address = Address(target_bytes, Address.PUBLIC_DEVICE_ADDRESS)
-            else:
-                peer_address = Address(target_bytes, Address.RANDOM_DEVICE_ADDRESS)
-
-        advertising_parameters = AdvertisingParameters(
-            advertising_event_properties=advertising_event_properties,
-            own_address_type=OWN_ADDRESS_MAP[request.own_address_type],
-            peer_address=peer_address,
-            primary_advertising_phy=PRIMARY_PHY_TO_BUMBLE_PHY_MAP[request.primary_phy],
-            secondary_advertising_phy=SECONDARY_PHY_TO_BUMBLE_PHY_MAP[
-                request.secondary_phy
-            ],
-        )
-        if advertising_interval := request.interval:
-            advertising_parameters.primary_advertising_interval_min = int(
-                advertising_interval
+        if not request.legacy:
+            raise NotImplementedError(
+                "TODO: add support for extended advertising in Bumble"
             )
-            advertising_parameters.primary_advertising_interval_max = int(
-                advertising_interval
-            )
-        if interval_range := request.interval_range:
-            advertising_parameters.primary_advertising_interval_max += int(
-                interval_range
-            )
-
-        advertising_set = await self.device.create_advertising_set(
-            advertising_parameters=advertising_parameters,
-            advertising_data=advertising_data,
-            scan_response_data=scan_response_data,
-        )
-
-        pending_connection: asyncio.Future[bumble.device.Connection] = (
-            asyncio.get_running_loop().create_future()
-        )
-
-        if request.connectable:
-
-            def on_connection(connection: bumble.device.Connection) -> None:
-                if (
-                    connection.transport == BT_LE_TRANSPORT
-                    and connection.role == BT_PERIPHERAL_ROLE
-                ):
-                    pending_connection.set_result(connection)
-
-            self.device.on('connection', on_connection)
-
-        try:
-            # Advertise until RPC is canceled
-            while True:
-                if not advertising_set.enabled:
-                    self.log.debug('Advertise (extended)')
-                    await advertising_set.start()
-
-                if not request.connectable:
-                    await asyncio.sleep(1)
-                    continue
-
-                connection = await pending_connection
-                pending_connection = asyncio.get_running_loop().create_future()
-
-                cookie = any_pb2.Any(value=connection.handle.to_bytes(4, 'big'))
-                yield AdvertiseResponse(connection=Connection(cookie=cookie))
-
-                await asyncio.sleep(1)
-        finally:
-            try:
-                self.log.debug('Stop Advertise (extended)')
-                await advertising_set.stop()
-                await advertising_set.remove()
-            except Exception:
-                pass
-
-    async def legacy_advertise(
-        self, request: AdvertiseRequest, context: grpc.ServicerContext
-    ) -> AsyncGenerator[AdvertiseResponse, None]:
-        if advertising_interval := request.interval:
-            self.device.config.advertising_interval_min = int(advertising_interval)
-            self.device.config.advertising_interval_max = int(advertising_interval)
-        if interval_range := request.interval_range:
-            self.device.config.advertising_interval_max += int(interval_range)
+        if request.interval:
+            raise NotImplementedError("TODO: add support for `request.interval`")
+        if request.interval_range:
+            raise NotImplementedError("TODO: add support for `request.interval_range`")
         if request.primary_phy:
             raise NotImplementedError("TODO: add support for `request.primary_phy`")
         if request.secondary_phy:
@@ -486,10 +356,14 @@ class HostService(HostServicer):
             target_bytes = bytes(reversed(request.target))
             if request.target_variant() == "public":
                 target = Address(target_bytes, Address.PUBLIC_DEVICE_ADDRESS)
-                advertising_type = AdvertisingType.DIRECTED_CONNECTABLE_LOW_DUTY
+                advertising_type = (
+                    AdvertisingType.DIRECTED_CONNECTABLE_HIGH_DUTY
+                )  # FIXME: HIGH_DUTY ?
             else:
                 target = Address(target_bytes, Address.RANDOM_DEVICE_ADDRESS)
-                advertising_type = AdvertisingType.DIRECTED_CONNECTABLE_LOW_DUTY
+                advertising_type = (
+                    AdvertisingType.DIRECTED_CONNECTABLE_HIGH_DUTY
+                )  # FIXME: HIGH_DUTY ?
 
         if request.connectable:
 
@@ -516,9 +390,9 @@ class HostService(HostServicer):
                     await asyncio.sleep(1)
                     continue
 
-                pending_connection: asyncio.Future[bumble.device.Connection] = (
-                    asyncio.get_running_loop().create_future()
-                )
+                pending_connection: asyncio.Future[
+                    bumble.device.Connection
+                ] = asyncio.get_running_loop().create_future()
 
                 self.log.debug('Wait for LE connection...')
                 connection = await pending_connection
@@ -547,15 +421,10 @@ class HostService(HostServicer):
         self, request: ScanRequest, context: grpc.ServicerContext
     ) -> AsyncGenerator[ScanningResponse, None]:
         # TODO: modify `start_scanning` to accept floats instead of int for ms values
-        self.log.debug('Scan')
+        if request.phys:
+            raise NotImplementedError("TODO: add support for `request.phys`")
 
-        scanning_phys = []
-        if PRIMARY_1M in request.phys:
-            scanning_phys.append(int(Phy.LE_1M))
-        if PRIMARY_CODED in request.phys:
-            scanning_phys.append(int(Phy.LE_CODED))
-        if not scanning_phys:
-            scanning_phys = [int(Phy.LE_1M), int(Phy.LE_CODED)]
+        self.log.debug('Scan')
 
         scan_queue: asyncio.Queue[Advertisement] = asyncio.Queue()
         handler = self.device.on('advertisement', scan_queue.put_nowait)
@@ -563,15 +432,12 @@ class HostService(HostServicer):
             legacy=request.legacy,
             active=not request.passive,
             own_address_type=request.own_address_type,
-            scan_interval=(
-                int(request.interval)
-                if request.interval
-                else DEVICE_DEFAULT_SCAN_INTERVAL
-            ),
-            scan_window=(
-                int(request.window) if request.window else DEVICE_DEFAULT_SCAN_WINDOW
-            ),
-            scanning_phys=scanning_phys,
+            scan_interval=int(request.interval)
+            if request.interval
+            else DEVICE_DEFAULT_SCAN_INTERVAL,
+            scan_window=int(request.window)
+            if request.window
+            else DEVICE_DEFAULT_SCAN_WINDOW,
         )
 
         try:
@@ -784,11 +650,9 @@ class HostService(HostServicer):
                             *struct.pack('<H', dt.peripheral_connection_interval_min),
                             *struct.pack(
                                 '<H',
-                                (
-                                    dt.peripheral_connection_interval_max
-                                    if dt.peripheral_connection_interval_max
-                                    else dt.peripheral_connection_interval_min
-                                ),
+                                dt.peripheral_connection_interval_max
+                                if dt.peripheral_connection_interval_max
+                                else dt.peripheral_connection_interval_min,
                             ),
                         ]
                     ),
@@ -870,16 +734,6 @@ class HostService(HostServicer):
                 )
             )
 
-        flag_map = {
-            NOT_DISCOVERABLE: 0x00,
-            DISCOVERABLE_LIMITED: AdvertisingData.LE_LIMITED_DISCOVERABLE_MODE_FLAG,
-            DISCOVERABLE_GENERAL: AdvertisingData.LE_GENERAL_DISCOVERABLE_MODE_FLAG,
-        }
-
-        if dt.le_discoverability_mode:
-            flags = flag_map[dt.le_discoverability_mode]
-            ad_structures.append((AdvertisingData.FLAGS, flags.to_bytes(1, 'big')))
-
         return AdvertisingData(ad_structures)
 
     def pack_data_types(self, ad: AdvertisingData) -> DataTypes:

bumble/pandora/security.py

@@ -110,7 +110,7 @@ class PairingDelegate(BasePairingDelegate):
 
         event = self.add_origin(PairingEvent(just_works=empty_pb2.Empty()))
         self.service.event_queue.put_nowait(event)
-        answer = await anext(self.service.event_answer)  # type: ignore
+        answer = await anext(self.service.event_answer)  # pytype: disable=name-error
         assert answer.event == event
         assert answer.answer_variant() == 'confirm' and answer.confirm is not None
         return answer.confirm
@@ -125,7 +125,7 @@ class PairingDelegate(BasePairingDelegate):
 
         event = self.add_origin(PairingEvent(numeric_comparison=number))
         self.service.event_queue.put_nowait(event)
-        answer = await anext(self.service.event_answer)  # type: ignore
+        answer = await anext(self.service.event_answer)  # pytype: disable=name-error
         assert answer.event == event
         assert answer.answer_variant() == 'confirm' and answer.confirm is not None
         return answer.confirm
@@ -140,7 +140,7 @@ class PairingDelegate(BasePairingDelegate):
 
         event = self.add_origin(PairingEvent(passkey_entry_request=empty_pb2.Empty()))
         self.service.event_queue.put_nowait(event)
-        answer = await anext(self.service.event_answer)  # type: ignore
+        answer = await anext(self.service.event_answer)  # pytype: disable=name-error
         assert answer.event == event
         if answer.answer_variant() is None:
             return None
@@ -157,7 +157,7 @@ class PairingDelegate(BasePairingDelegate):
 
         event = self.add_origin(PairingEvent(pin_code_request=empty_pb2.Empty()))
         self.service.event_queue.put_nowait(event)
-        answer = await anext(self.service.event_answer)  # type: ignore
+        answer = await anext(self.service.event_answer)  # pytype: disable=name-error
         assert answer.event == event
         if answer.answer_variant() is None:
             return None
@@ -383,9 +383,9 @@ class SecurityService(SecurityServicer):
             connection.transport
         ] == request.level_variant()
 
-        wait_for_security: asyncio.Future[str] = (
-            asyncio.get_running_loop().create_future()
-        )
+        wait_for_security: asyncio.Future[
+            str
+        ] = asyncio.get_running_loop().create_future()
         authenticate_task: Optional[asyncio.Future[None]] = None
         pair_task: Optional[asyncio.Future[None]] = None
 

bumble/profiles/asha_service.py

@@ -18,7 +18,7 @@
 # -----------------------------------------------------------------------------
 import struct
 import logging
-from typing import List, Optional
+from typing import List
 
 from bumble import l2cap
 from ..core import AdvertisingData
@@ -67,7 +67,7 @@ class AshaService(TemplateService):
             self.emit('volume', connection, value[0])
 
         # Handler for audio control commands
-        def on_audio_control_point_write(connection: Optional[Connection], value):
+        def on_audio_control_point_write(connection: Connection, value):
             logger.info(f'--- AUDIO CONTROL POINT Write:{value.hex()}')
             opcode = value[0]
             if opcode == AshaService.OPCODE_START:

bumble/profiles/bap.py

@@ -24,9 +24,8 @@ import enum
 import struct
 import functools
 import logging
-from typing import Optional, List, Union, Type, Dict, Any, Tuple
+from typing import Optional, List, Union, Type, Dict, Any, Tuple, cast
 
-from bumble import core
 from bumble import colors
 from bumble import device
 from bumble import hci
@@ -115,7 +114,7 @@ class SamplingFrequency(enum.IntEnum):
     '''Bluetooth Assigned Numbers, Section 6.12.5.1 - Sampling Frequency'''
 
     # fmt: off
-    FREQ_8000    = 0x01
+    FREQ_8000    = 0x01 
     FREQ_11025   = 0x02
     FREQ_16000   = 0x03
     FREQ_22050   = 0x04
@@ -229,14 +228,6 @@ class SupportedFrameDuration(enum.IntFlag):
     DURATION_10000_US_PREFERRED = 0b0010
 
 
-class AnnouncementType(enum.IntEnum):
-    '''Basic Audio Profile, 3.5.3. Additional Audio Stream Control Service requirements'''
-
-    # fmt: off
-    GENERAL  = 0x00
-    TARGETED = 0x01
-
-
 # -----------------------------------------------------------------------------
 # ASE Operations
 # -----------------------------------------------------------------------------
@@ -439,7 +430,7 @@ class AseResponseCode(enum.IntEnum):
     REJECTED_METADATA                           = 0x0B
     INVALID_METADATA                            = 0x0C
     INSUFFICIENT_RESOURCES                      = 0x0D
-    UNSPECIFIED_ERROR                           = 0x0E
+    UNSPECIFIED_ERROR                           = 0x0E    
 
 
 class AseReasonCode(enum.IntEnum):
@@ -462,34 +453,6 @@ class AudioRole(enum.IntEnum):
     SOURCE = hci.HCI_LE_Setup_ISO_Data_Path_Command.Direction.HOST_TO_CONTROLLER
 
 
-@dataclasses.dataclass
-class UnicastServerAdvertisingData:
-    """Advertising Data for ASCS."""
-
-    announcement_type: AnnouncementType = AnnouncementType.TARGETED
-    available_audio_contexts: ContextType = ContextType.MEDIA
-    metadata: bytes = b''
-
-    def __bytes__(self) -> bytes:
-        return bytes(
-            core.AdvertisingData(
-                [
-                    (
-                        core.AdvertisingData.SERVICE_DATA_16_BIT_UUID,
-                        struct.pack(
-                            '<2sBIB',
-                            gatt.GATT_AUDIO_STREAM_CONTROL_SERVICE.to_bytes(),
-                            self.announcement_type,
-                            self.available_audio_contexts,
-                            len(self.metadata),
-                        )
-                        + self.metadata,
-                    )
-                ]
-            )
-        )
-
-
 # -----------------------------------------------------------------------------
 # Utils
 # -----------------------------------------------------------------------------
@@ -1103,7 +1066,7 @@ class AseStateMachine(gatt.Characteristic):
         # Readonly. Do nothing in the setter.
         pass
 
-    def on_read(self, _: Optional[device.Connection]) -> bytes:
+    def on_read(self, _: device.Connection) -> bytes:
         return self.value
 
     def __str__(self) -> str:

bumble/profiles/csip.py

@@ -19,7 +19,7 @@
 from __future__ import annotations
 import enum
 import struct
-from typing import Optional, Tuple
+from typing import Optional
 
 from bumble import core
 from bumble import crypto
@@ -31,9 +31,6 @@ from bumble import gatt_client
 # -----------------------------------------------------------------------------
 # Constants
 # -----------------------------------------------------------------------------
-SET_IDENTITY_RESOLVING_KEY_LENGTH = 16
-
-
 class SirkType(enum.IntEnum):
     '''Coordinated Set Identification Service - 5.1 Set Identity Resolving Key.'''
 
@@ -69,10 +66,6 @@ def k1(n: bytes, salt: bytes, p: bytes) -> bytes:
 def sef(k: bytes, r: bytes) -> bytes:
     '''
     Coordinated Set Identification Service - 4.5 SIRK encryption function sef.
-
-    SIRK decryption function sdf shares the same algorithm. The only difference is that argument r is:
-      * Plaintext in encryption
-      * Cipher in decryption
     '''
     return crypto.xor(k1(k, s1(b'SIRKenc'[::-1]), b'csis'[::-1]), r)
 
@@ -112,11 +105,6 @@ class CoordinatedSetIdentificationService(gatt.TemplateService):
         set_member_lock: Optional[MemberLock] = None,
         set_member_rank: Optional[int] = None,
     ) -> None:
-        if len(set_identity_resolving_key) != SET_IDENTITY_RESOLVING_KEY_LENGTH:
-            raise ValueError(
-                f'Invalid SIRK length {len(set_identity_resolving_key)}, expected {SET_IDENTITY_RESOLVING_KEY_LENGTH}'
-            )
-
         characteristics = []
 
         self.set_identity_resolving_key = set_identity_resolving_key
@@ -125,7 +113,7 @@ class CoordinatedSetIdentificationService(gatt.TemplateService):
             uuid=gatt.GATT_SET_IDENTITY_RESOLVING_KEY_CHARACTERISTIC,
             properties=gatt.Characteristic.Properties.READ
             | gatt.Characteristic.Properties.NOTIFY,
-            permissions=gatt.Characteristic.Permissions.READ_REQUIRES_ENCRYPTION,
+            permissions=gatt.Characteristic.Permissions.READABLE,
             value=gatt.CharacteristicValue(read=self.on_sirk_read),
         )
         characteristics.append(self.set_identity_resolving_key_characteristic)
@@ -135,7 +123,7 @@ class CoordinatedSetIdentificationService(gatt.TemplateService):
                 uuid=gatt.GATT_COORDINATED_SET_SIZE_CHARACTERISTIC,
                 properties=gatt.Characteristic.Properties.READ
                 | gatt.Characteristic.Properties.NOTIFY,
-                permissions=gatt.Characteristic.Permissions.READ_REQUIRES_ENCRYPTION,
+                permissions=gatt.Characteristic.Permissions.READABLE,
                 value=struct.pack('B', coordinated_set_size),
             )
             characteristics.append(self.coordinated_set_size_characteristic)
@@ -146,7 +134,7 @@ class CoordinatedSetIdentificationService(gatt.TemplateService):
                 properties=gatt.Characteristic.Properties.READ
                 | gatt.Characteristic.Properties.NOTIFY
                 | gatt.Characteristic.Properties.WRITE,
-                permissions=gatt.Characteristic.Permissions.READ_REQUIRES_ENCRYPTION
+                permissions=gatt.Characteristic.Permissions.READABLE
                 | gatt.Characteristic.Permissions.WRITEABLE,
                 value=struct.pack('B', set_member_lock),
             )
@@ -157,32 +145,18 @@ class CoordinatedSetIdentificationService(gatt.TemplateService):
                 uuid=gatt.GATT_SET_MEMBER_RANK_CHARACTERISTIC,
                 properties=gatt.Characteristic.Properties.READ
                 | gatt.Characteristic.Properties.NOTIFY,
-                permissions=gatt.Characteristic.Permissions.READ_REQUIRES_ENCRYPTION,
+                permissions=gatt.Characteristic.Permissions.READABLE,
                 value=struct.pack('B', set_member_rank),
             )
             characteristics.append(self.set_member_rank_characteristic)
 
         super().__init__(characteristics)
 
-    async def on_sirk_read(self, connection: Optional[device.Connection]) -> bytes:
+    def on_sirk_read(self, _connection: device.Connection) -> bytes:
         if self.set_identity_resolving_key_type == SirkType.PLAINTEXT:
-            sirk_bytes = self.set_identity_resolving_key
+            return bytes([SirkType.PLAINTEXT]) + self.set_identity_resolving_key
         else:
-            assert connection
-
-            if connection.transport == core.BT_LE_TRANSPORT:
-                key = await connection.device.get_long_term_key(
-                    connection_handle=connection.handle, rand=b'', ediv=0
-                )
-            else:
-                key = await connection.device.get_link_key(connection.peer_address)
-
-            if not key:
-                raise RuntimeError('LTK or LinkKey is not present')
-
-            sirk_bytes = sef(key, self.set_identity_resolving_key)
-
-        return bytes([self.set_identity_resolving_key_type]) + sirk_bytes
+            raise NotImplementedError('TODO: Pending async Characteristic read.')
 
     def get_advertising_data(self) -> bytes:
         return bytes(
@@ -229,29 +203,3 @@ class CoordinatedSetIdentificationProxy(gatt_client.ProfileServiceProxy):
             gatt.GATT_SET_MEMBER_RANK_CHARACTERISTIC
         ):
             self.set_member_rank = characteristics[0]
-
-    async def read_set_identity_resolving_key(self) -> Tuple[SirkType, bytes]:
-        '''Reads SIRK and decrypts if encrypted.'''
-        response = await self.set_identity_resolving_key.read_value()
-        if len(response) != SET_IDENTITY_RESOLVING_KEY_LENGTH + 1:
-            raise RuntimeError('Invalid SIRK value')
-
-        sirk_type = SirkType(response[0])
-        if sirk_type == SirkType.PLAINTEXT:
-            sirk = response[1:]
-        else:
-            connection = self.service_proxy.client.connection
-            device = connection.device
-            if connection.transport == core.BT_LE_TRANSPORT:
-                key = await device.get_long_term_key(
-                    connection_handle=connection.handle, rand=b'', ediv=0
-                )
-            else:
-                key = await device.get_link_key(connection.peer_address)
-
-            if not key:
-                raise RuntimeError('LTK or LinkKey is not present')
-
-            sirk = sef(key, response[1:])
-
-        return (sirk_type, sirk)

bumble/profiles/device_information_service.py

@@ -19,8 +19,8 @@
 import struct
 from typing import Optional, Tuple
 
-from bumble.gatt_client import ServiceProxy, ProfileServiceProxy, CharacteristicProxy
-from bumble.gatt import (
+from ..gatt_client import ProfileServiceProxy
+from ..gatt import (
     GATT_DEVICE_INFORMATION_SERVICE,
     GATT_FIRMWARE_REVISION_STRING_CHARACTERISTIC,
     GATT_HARDWARE_REVISION_STRING_CHARACTERISTIC,
@@ -59,7 +59,7 @@ class DeviceInformationService(TemplateService):
         firmware_revision: Optional[str] = None,
         software_revision: Optional[str] = None,
         system_id: Optional[Tuple[int, int]] = None,  # (OUI, Manufacturer ID)
-        ieee_regulatory_certification_data_list: Optional[bytes] = None,
+        ieee_regulatory_certification_data_list: Optional[bytes] = None
         # TODO: pnp_id
     ):
         characteristics = [
@@ -104,19 +104,10 @@ class DeviceInformationService(TemplateService):
 class DeviceInformationServiceProxy(ProfileServiceProxy):
     SERVICE_CLASS = DeviceInformationService
 
-    manufacturer_name: Optional[UTF8CharacteristicAdapter]
-    model_number: Optional[UTF8CharacteristicAdapter]
-    serial_number: Optional[UTF8CharacteristicAdapter]
-    hardware_revision: Optional[UTF8CharacteristicAdapter]
-    firmware_revision: Optional[UTF8CharacteristicAdapter]
-    software_revision: Optional[UTF8CharacteristicAdapter]
-    system_id: Optional[DelegatedCharacteristicAdapter]
-    ieee_regulatory_certification_data_list: Optional[CharacteristicProxy]
-
-    def __init__(self, service_proxy: ServiceProxy):
+    def __init__(self, service_proxy):
         self.service_proxy = service_proxy
 
-        for field, uuid in (
+        for (field, uuid) in (
             ('manufacturer_name', GATT_MANUFACTURER_NAME_STRING_CHARACTERISTIC),
             ('model_number', GATT_MODEL_NUMBER_STRING_CHARACTERISTIC),
             ('serial_number', GATT_SERIAL_NUMBER_STRING_CHARACTERISTIC),

bumble/profiles/vcp.py

@@ -1,228 +0,0 @@
-# Copyright 2021-2024 Google LLC
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-# -----------------------------------------------------------------------------
-# Imports
-# -----------------------------------------------------------------------------
-from __future__ import annotations
-import enum
-
-from bumble import att
-from bumble import device
-from bumble import gatt
-from bumble import gatt_client
-
-from typing import Optional
-
-# -----------------------------------------------------------------------------
-# Constants
-# -----------------------------------------------------------------------------
-
-MIN_VOLUME = 0
-MAX_VOLUME = 255
-
-
-class ErrorCode(enum.IntEnum):
-    '''
-    See Volume Control Service 1.6. Application error codes.
-    '''
-
-    INVALID_CHANGE_COUNTER = 0x80
-    OPCODE_NOT_SUPPORTED = 0x81
-
-
-class VolumeFlags(enum.IntFlag):
-    '''
-    See Volume Control Service 3.3. Volume Flags.
-    '''
-
-    VOLUME_SETTING_PERSISTED = 0x01
-    # RFU
-
-
-class VolumeControlPointOpcode(enum.IntEnum):
-    '''
-    See Volume Control Service Table 3.3: Volume Control Point procedure requirements.
-    '''
-
-    # fmt: off
-    RELATIVE_VOLUME_DOWN        = 0x00
-    RELATIVE_VOLUME_UP          = 0x01
-    UNMUTE_RELATIVE_VOLUME_DOWN = 0x02
-    UNMUTE_RELATIVE_VOLUME_UP   = 0x03
-    SET_ABSOLUTE_VOLUME         = 0x04
-    UNMUTE                      = 0x05
-    MUTE                        = 0x06
-
-
-# -----------------------------------------------------------------------------
-# Server
-# -----------------------------------------------------------------------------
-class VolumeControlService(gatt.TemplateService):
-    UUID = gatt.GATT_VOLUME_CONTROL_SERVICE
-
-    volume_state: gatt.Characteristic
-    volume_control_point: gatt.Characteristic
-    volume_flags: gatt.Characteristic
-
-    volume_setting: int
-    muted: int
-    change_counter: int
-
-    def __init__(
-        self,
-        step_size: int = 16,
-        volume_setting: int = 0,
-        muted: int = 0,
-        change_counter: int = 0,
-        volume_flags: int = 0,
-    ) -> None:
-        self.step_size = step_size
-        self.volume_setting = volume_setting
-        self.muted = muted
-        self.change_counter = change_counter
-
-        self.volume_state = gatt.Characteristic(
-            uuid=gatt.GATT_VOLUME_STATE_CHARACTERISTIC,
-            properties=(
-                gatt.Characteristic.Properties.READ
-                | gatt.Characteristic.Properties.NOTIFY
-            ),
-            permissions=gatt.Characteristic.Permissions.READ_REQUIRES_ENCRYPTION,
-            value=gatt.CharacteristicValue(read=self._on_read_volume_state),
-        )
-        self.volume_control_point = gatt.Characteristic(
-            uuid=gatt.GATT_VOLUME_CONTROL_POINT_CHARACTERISTIC,
-            properties=gatt.Characteristic.Properties.WRITE,
-            permissions=gatt.Characteristic.Permissions.WRITE_REQUIRES_ENCRYPTION,
-            value=gatt.CharacteristicValue(write=self._on_write_volume_control_point),
-        )
-        self.volume_flags = gatt.Characteristic(
-            uuid=gatt.GATT_VOLUME_FLAGS_CHARACTERISTIC,
-            properties=gatt.Characteristic.Properties.READ,
-            permissions=gatt.Characteristic.Permissions.READ_REQUIRES_ENCRYPTION,
-            value=bytes([volume_flags]),
-        )
-
-        super().__init__(
-            [
-                self.volume_state,
-                self.volume_control_point,
-                self.volume_flags,
-            ]
-        )
-
-    @property
-    def volume_state_bytes(self) -> bytes:
-        return bytes([self.volume_setting, self.muted, self.change_counter])
-
-    @volume_state_bytes.setter
-    def volume_state_bytes(self, new_value: bytes) -> None:
-        self.volume_setting, self.muted, self.change_counter = new_value
-
-    def _on_read_volume_state(self, _connection: Optional[device.Connection]) -> bytes:
-        return self.volume_state_bytes
-
-    def _on_write_volume_control_point(
-        self, connection: Optional[device.Connection], value: bytes
-    ) -> None:
-        assert connection
-
-        opcode = VolumeControlPointOpcode(value[0])
-        change_counter = value[1]
-
-        if change_counter != self.change_counter:
-            raise att.ATT_Error(ErrorCode.INVALID_CHANGE_COUNTER)
-
-        handler = getattr(self, '_on_' + opcode.name.lower())
-        if handler(*value[2:]):
-            self.change_counter = (self.change_counter + 1) % 256
-            connection.abort_on(
-                'disconnection',
-                connection.device.notify_subscribers(
-                    attribute=self.volume_state,
-                    value=self.volume_state_bytes,
-                ),
-            )
-            self.emit(
-                'volume_state', self.volume_setting, self.muted, self.change_counter
-            )
-
-    def _on_relative_volume_down(self) -> bool:
-        old_volume = self.volume_setting
-        self.volume_setting = max(self.volume_setting - self.step_size, MIN_VOLUME)
-        return self.volume_setting != old_volume
-
-    def _on_relative_volume_up(self) -> bool:
-        old_volume = self.volume_setting
-        self.volume_setting = min(self.volume_setting + self.step_size, MAX_VOLUME)
-        return self.volume_setting != old_volume
-
-    def _on_unmute_relative_volume_down(self) -> bool:
-        old_volume, old_muted_state = self.volume_setting, self.muted
-        self.volume_setting = max(self.volume_setting - self.step_size, MIN_VOLUME)
-        self.muted = 0
-        return (self.volume_setting, self.muted) != (old_volume, old_muted_state)
-
-    def _on_unmute_relative_volume_up(self) -> bool:
-        old_volume, old_muted_state = self.volume_setting, self.muted
-        self.volume_setting = min(self.volume_setting + self.step_size, MAX_VOLUME)
-        self.muted = 0
-        return (self.volume_setting, self.muted) != (old_volume, old_muted_state)
-
-    def _on_set_absolute_volume(self, volume_setting: int) -> bool:
-        old_volume_setting = self.volume_setting
-        self.volume_setting = volume_setting
-        return old_volume_setting != self.volume_setting
-
-    def _on_unmute(self) -> bool:
-        old_muted_state = self.muted
-        self.muted = 0
-        return self.muted != old_muted_state
-
-    def _on_mute(self) -> bool:
-        old_muted_state = self.muted
-        self.muted = 1
-        return self.muted != old_muted_state
-
-
-# -----------------------------------------------------------------------------
-# Client
-# -----------------------------------------------------------------------------
-class VolumeControlServiceProxy(gatt_client.ProfileServiceProxy):
-    SERVICE_CLASS = VolumeControlService
-
-    volume_control_point: gatt_client.CharacteristicProxy
-
-    def __init__(self, service_proxy: gatt_client.ServiceProxy) -> None:
-        self.service_proxy = service_proxy
-
-        self.volume_state = gatt.PackedCharacteristicAdapter(
-            service_proxy.get_characteristics_by_uuid(
-                gatt.GATT_VOLUME_STATE_CHARACTERISTIC
-            )[0],
-            'BBB',
-        )
-
-        self.volume_control_point = service_proxy.get_characteristics_by_uuid(
-            gatt.GATT_VOLUME_CONTROL_POINT_CHARACTERISTIC
-        )[0]
-
-        self.volume_flags = gatt.PackedCharacteristicAdapter(
-            service_proxy.get_characteristics_by_uuid(
-                gatt.GATT_VOLUME_FLAGS_CHARACTERISTIC
-            )[0],
-            'B',
-        )

bumble/rfcomm.py

@@ -19,16 +19,12 @@ from __future__ import annotations
 
 import logging
 import asyncio
-import dataclasses
 import enum
 from typing import Callable, Dict, List, Optional, Tuple, Union, TYPE_CHECKING
-from typing_extensions import Self
 
 from pyee import EventEmitter
 
-from bumble import core
-from bumble import l2cap
-from bumble import sdp
+from . import core, l2cap
 from .colors import color
 from .core import (
     UUID,
@@ -38,6 +34,15 @@ from .core import (
     InvalidStateError,
     ProtocolError,
 )
+from .sdp import (
+    SDP_SERVICE_RECORD_HANDLE_ATTRIBUTE_ID,
+    SDP_BROWSE_GROUP_LIST_ATTRIBUTE_ID,
+    SDP_SERVICE_CLASS_ID_LIST_ATTRIBUTE_ID,
+    SDP_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID,
+    SDP_PUBLIC_BROWSE_ROOT,
+    DataElement,
+    ServiceAttribute,
+)
 
 if TYPE_CHECKING:
     from bumble.device import Device, Connection
@@ -55,18 +60,27 @@ logger = logging.getLogger(__name__)
 
 RFCOMM_PSM = 0x0003
 
-class FrameType(enum.IntEnum):
-    SABM = 0x2F  # Control field [1,1,1,1,_,1,0,0] LSB-first
-    UA   = 0x63  # Control field [0,1,1,0,_,0,1,1] LSB-first
-    DM   = 0x0F  # Control field [1,1,1,1,_,0,0,0] LSB-first
-    DISC = 0x43  # Control field [0,1,0,_,0,0,1,1] LSB-first
-    UIH  = 0xEF  # Control field [1,1,1,_,1,1,1,1] LSB-first
-    UI   = 0x03  # Control field [0,0,0,_,0,0,1,1] LSB-first
 
-class MccType(enum.IntEnum):
-    PN  = 0x20
-    MSC = 0x38
+# Frame types
+RFCOMM_SABM_FRAME = 0x2F  # Control field [1,1,1,1,_,1,0,0] LSB-first
+RFCOMM_UA_FRAME   = 0x63  # Control field [0,1,1,0,_,0,1,1] LSB-first
+RFCOMM_DM_FRAME   = 0x0F  # Control field [1,1,1,1,_,0,0,0] LSB-first
+RFCOMM_DISC_FRAME = 0x43  # Control field [0,1,0,_,0,0,1,1] LSB-first
+RFCOMM_UIH_FRAME  = 0xEF  # Control field [1,1,1,_,1,1,1,1] LSB-first
+RFCOMM_UI_FRAME   = 0x03  # Control field [0,0,0,_,0,0,1,1] LSB-first
 
+RFCOMM_FRAME_TYPE_NAMES = {
+    RFCOMM_SABM_FRAME: 'SABM',
+    RFCOMM_UA_FRAME:   'UA',
+    RFCOMM_DM_FRAME:   'DM',
+    RFCOMM_DISC_FRAME: 'DISC',
+    RFCOMM_UIH_FRAME:  'UIH',
+    RFCOMM_UI_FRAME:   'UI'
+}
+
+# MCC Types
+RFCOMM_MCC_PN_TYPE  = 0x20
+RFCOMM_MCC_MSC_TYPE = 0x38
 
 # FCS CRC
 CRC_TABLE = bytes([
@@ -104,9 +118,8 @@ CRC_TABLE = bytes([
     0XBA, 0X2B, 0X59, 0XC8, 0XBD, 0X2C, 0X5E, 0XCF
 ])
 
-RFCOMM_DEFAULT_L2CAP_MTU      = 2048
-RFCOMM_DEFAULT_WINDOW_SIZE    = 7
-RFCOMM_DEFAULT_MAX_FRAME_SIZE = 2000
+RFCOMM_DEFAULT_INITIAL_RX_CREDITS = 7
+RFCOMM_DEFAULT_PREFERRED_MTU      = 1280
 
 RFCOMM_DYNAMIC_CHANNEL_NUMBER_START = 1
 RFCOMM_DYNAMIC_CHANNEL_NUMBER_END   = 30
@@ -117,33 +130,29 @@ RFCOMM_DYNAMIC_CHANNEL_NUMBER_END   = 30
 # -----------------------------------------------------------------------------
 def make_service_sdp_records(
     service_record_handle: int, channel: int, uuid: Optional[UUID] = None
-) -> List[sdp.ServiceAttribute]:
+) -> List[ServiceAttribute]:
     """
     Create SDP records for an RFComm service given a channel number and an
     optional UUID. A Service Class Attribute is included only if the UUID is not None.
     """
     records = [
-        sdp.ServiceAttribute(
-            sdp.SDP_SERVICE_RECORD_HANDLE_ATTRIBUTE_ID,
-            sdp.DataElement.unsigned_integer_32(service_record_handle),
+        ServiceAttribute(
+            SDP_SERVICE_RECORD_HANDLE_ATTRIBUTE_ID,
+            DataElement.unsigned_integer_32(service_record_handle),
         ),
-        sdp.ServiceAttribute(
-            sdp.SDP_BROWSE_GROUP_LIST_ATTRIBUTE_ID,
-            sdp.DataElement.sequence(
-                [sdp.DataElement.uuid(sdp.SDP_PUBLIC_BROWSE_ROOT)]
-            ),
+        ServiceAttribute(
+            SDP_BROWSE_GROUP_LIST_ATTRIBUTE_ID,
+            DataElement.sequence([DataElement.uuid(SDP_PUBLIC_BROWSE_ROOT)]),
         ),
-        sdp.ServiceAttribute(
-            sdp.SDP_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID,
-            sdp.DataElement.sequence(
+        ServiceAttribute(
+            SDP_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID,
+            DataElement.sequence(
                 [
-                    sdp.DataElement.sequence(
-                        [sdp.DataElement.uuid(BT_L2CAP_PROTOCOL_ID)]
-                    ),
-                    sdp.DataElement.sequence(
+                    DataElement.sequence([DataElement.uuid(BT_L2CAP_PROTOCOL_ID)]),
+                    DataElement.sequence(
                         [
-                            sdp.DataElement.uuid(BT_RFCOMM_PROTOCOL_ID),
-                            sdp.DataElement.unsigned_integer_8(channel),
+                            DataElement.uuid(BT_RFCOMM_PROTOCOL_ID),
+                            DataElement.unsigned_integer_8(channel),
                         ]
                     ),
                 ]
@@ -153,81 +162,15 @@ def make_service_sdp_records(
 
     if uuid:
         records.append(
-            sdp.ServiceAttribute(
-                sdp.SDP_SERVICE_CLASS_ID_LIST_ATTRIBUTE_ID,
-                sdp.DataElement.sequence([sdp.DataElement.uuid(uuid)]),
+            ServiceAttribute(
+                SDP_SERVICE_CLASS_ID_LIST_ATTRIBUTE_ID,
+                DataElement.sequence([DataElement.uuid(uuid)]),
             )
         )
 
     return records
 
 
-# -----------------------------------------------------------------------------
-async def find_rfcomm_channels(connection: Connection) -> Dict[int, List[UUID]]:
-    """Searches all RFCOMM channels and their associated UUID from SDP service records.
-
-    Args:
-        connection: ACL connection to make SDP search.
-
-    Returns:
-        Dictionary mapping from channel number to service class UUID list.
-    """
-    results = {}
-    async with sdp.Client(connection) as sdp_client:
-        search_result = await sdp_client.search_attributes(
-            uuids=[core.BT_RFCOMM_PROTOCOL_ID],
-            attribute_ids=[
-                sdp.SDP_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID,
-                sdp.SDP_SERVICE_CLASS_ID_LIST_ATTRIBUTE_ID,
-            ],
-        )
-        for attribute_lists in search_result:
-            service_classes: List[UUID] = []
-            channel: Optional[int] = None
-            for attribute in attribute_lists:
-                # The layout is [[L2CAP_PROTOCOL], [RFCOMM_PROTOCOL, RFCOMM_CHANNEL]].
-                if attribute.id == sdp.SDP_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID:
-                    protocol_descriptor_list = attribute.value.value
-                    channel = protocol_descriptor_list[1].value[1].value
-                elif attribute.id == sdp.SDP_SERVICE_CLASS_ID_LIST_ATTRIBUTE_ID:
-                    service_class_id_list = attribute.value.value
-                    service_classes = [
-                        service_class.value for service_class in service_class_id_list
-                    ]
-            if not service_classes or not channel:
-                logger.warning(f"Bad result {attribute_lists}.")
-            else:
-                results[channel] = service_classes
-    return results
-
-
-# -----------------------------------------------------------------------------
-async def find_rfcomm_channel_with_uuid(
-    connection: Connection, uuid: str | UUID
-) -> Optional[int]:
-    """Searches an RFCOMM channel associated with given UUID from service records.
-
-    Args:
-        connection: ACL connection to make SDP search.
-        uuid: UUID of service record to search for.
-
-    Returns:
-        RFCOMM channel number if found, otherwise None.
-    """
-    if isinstance(uuid, str):
-        uuid = UUID(uuid)
-    return next(
-        (
-            channel
-            for channel, class_id_list in (
-                await find_rfcomm_channels(connection)
-            ).items()
-            if uuid in class_id_list
-        ),
-        None,
-    )
-
-
 # -----------------------------------------------------------------------------
 def compute_fcs(buffer: bytes) -> int:
     result = 0xFF
@@ -240,7 +183,7 @@ def compute_fcs(buffer: bytes) -> int:
 class RFCOMM_Frame:
     def __init__(
         self,
-        frame_type: FrameType,
+        frame_type: int,
         c_r: int,
         dlci: int,
         p_f: int,
@@ -263,11 +206,14 @@ class RFCOMM_Frame:
             self.length = bytes([(length << 1) | 1])
         self.address = (dlci << 2) | (c_r << 1) | 1
         self.control = frame_type | (p_f << 4)
-        if frame_type == FrameType.UIH:
+        if frame_type == RFCOMM_UIH_FRAME:
             self.fcs = compute_fcs(bytes([self.address, self.control]))
         else:
             self.fcs = compute_fcs(bytes([self.address, self.control]) + self.length)
 
+    def type_name(self) -> str:
+        return RFCOMM_FRAME_TYPE_NAMES[self.type]
+
     @staticmethod
     def parse_mcc(data) -> Tuple[int, bool, bytes]:
         mcc_type = data[0] >> 2
@@ -291,24 +237,24 @@ class RFCOMM_Frame:
 
     @staticmethod
     def sabm(c_r: int, dlci: int):
-        return RFCOMM_Frame(FrameType.SABM, c_r, dlci, 1)
+        return RFCOMM_Frame(RFCOMM_SABM_FRAME, c_r, dlci, 1)
 
     @staticmethod
     def ua(c_r: int, dlci: int):
-        return RFCOMM_Frame(FrameType.UA, c_r, dlci, 1)
+        return RFCOMM_Frame(RFCOMM_UA_FRAME, c_r, dlci, 1)
 
     @staticmethod
     def dm(c_r: int, dlci: int):
-        return RFCOMM_Frame(FrameType.DM, c_r, dlci, 1)
+        return RFCOMM_Frame(RFCOMM_DM_FRAME, c_r, dlci, 1)
 
     @staticmethod
     def disc(c_r: int, dlci: int):
-        return RFCOMM_Frame(FrameType.DISC, c_r, dlci, 1)
+        return RFCOMM_Frame(RFCOMM_DISC_FRAME, c_r, dlci, 1)
 
     @staticmethod
     def uih(c_r: int, dlci: int, information: bytes, p_f: int = 0):
         return RFCOMM_Frame(
-            FrameType.UIH, c_r, dlci, p_f, information, with_credits=(p_f == 1)
+            RFCOMM_UIH_FRAME, c_r, dlci, p_f, information, with_credits=(p_f == 1)
         )
 
     @staticmethod
@@ -316,7 +262,7 @@ class RFCOMM_Frame:
         # Extract fields
         dlci = (data[0] >> 2) & 0x3F
         c_r = (data[0] >> 1) & 0x01
-        frame_type = FrameType(data[1] & 0xEF)
+        frame_type = data[1] & 0xEF
         p_f = (data[1] >> 4) & 0x01
         length = data[2]
         if length & 0x01:
@@ -345,7 +291,7 @@ class RFCOMM_Frame:
 
     def __str__(self) -> str:
         return (
-            f'{color(self.type.name, "yellow")}'
+            f'{color(self.type_name(), "yellow")}'
             f'(c/r={self.c_r},'
             f'dlci={self.dlci},'
             f'p/f={self.p_f},'
@@ -355,7 +301,6 @@ class RFCOMM_Frame:
 
 
 # -----------------------------------------------------------------------------
-@dataclasses.dataclass
 class RFCOMM_MCC_PN:
     dlci: int
     cl: int
@@ -365,11 +310,23 @@ class RFCOMM_MCC_PN:
     max_retransmissions: int
     window_size: int
 
-    def __post_init__(self) -> None:
-        if self.window_size < 1 or self.window_size > 7:
-            logger.warning(
-                f'Error Recovery Window size {self.window_size} is out of range [1, 7].'
-            )
+    def __init__(
+        self,
+        dlci: int,
+        cl: int,
+        priority: int,
+        ack_timer: int,
+        max_frame_size: int,
+        max_retransmissions: int,
+        window_size: int,
+    ) -> None:
+        self.dlci = dlci
+        self.cl = cl
+        self.priority = priority
+        self.ack_timer = ack_timer
+        self.max_frame_size = max_frame_size
+        self.max_retransmissions = max_retransmissions
+        self.window_size = window_size
 
     @staticmethod
     def from_bytes(data: bytes) -> RFCOMM_MCC_PN:
@@ -380,7 +337,7 @@ class RFCOMM_MCC_PN:
             ack_timer=data[3],
             max_frame_size=data[4] | data[5] << 8,
             max_retransmissions=data[6],
-            window_size=data[7] & 0x07,
+            window_size=data[7],
         )
 
     def __bytes__(self) -> bytes:
@@ -393,14 +350,23 @@ class RFCOMM_MCC_PN:
                 self.max_frame_size & 0xFF,
                 (self.max_frame_size >> 8) & 0xFF,
                 self.max_retransmissions & 0xFF,
-                # Only 3 bits are meaningful.
-                self.window_size & 0x07,
+                self.window_size & 0xFF,
             ]
         )
 
+    def __str__(self) -> str:
+        return (
+            f'PN(dlci={self.dlci},'
+            f'cl={self.cl},'
+            f'priority={self.priority},'
+            f'ack_timer={self.ack_timer},'
+            f'max_frame_size={self.max_frame_size},'
+            f'max_retransmissions={self.max_retransmissions},'
+            f'window_size={self.window_size})'
+        )
+
 
 # -----------------------------------------------------------------------------
-@dataclasses.dataclass
 class RFCOMM_MCC_MSC:
     dlci: int
     fc: int
@@ -409,6 +375,16 @@ class RFCOMM_MCC_MSC:
     ic: int
     dv: int
 
+    def __init__(
+        self, dlci: int, fc: int, rtc: int, rtr: int, ic: int, dv: int
+    ) -> None:
+        self.dlci = dlci
+        self.fc = fc
+        self.rtc = rtc
+        self.rtr = rtr
+        self.ic = ic
+        self.dv = dv
+
     @staticmethod
     def from_bytes(data: bytes) -> RFCOMM_MCC_MSC:
         return RFCOMM_MCC_MSC(
@@ -433,6 +409,16 @@ class RFCOMM_MCC_MSC:
             ]
         )
 
+    def __str__(self) -> str:
+        return (
+            f'MSC(dlci={self.dlci},'
+            f'fc={self.fc},'
+            f'rtc={self.rtc},'
+            f'rtr={self.rtr},'
+            f'ic={self.ic},'
+            f'dv={self.dv})'
+        )
+
 
 # -----------------------------------------------------------------------------
 class DLC(EventEmitter):
@@ -452,29 +438,25 @@ class DLC(EventEmitter):
         multiplexer: Multiplexer,
         dlci: int,
         max_frame_size: int,
-        window_size: int,
+        initial_tx_credits: int,
     ) -> None:
         super().__init__()
         self.multiplexer = multiplexer
         self.dlci = dlci
-        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.rx_credits = RFCOMM_DEFAULT_INITIAL_RX_CREDITS
+        self.rx_threshold = self.rx_credits // 2
+        self.tx_credits = initial_tx_credits
         self.tx_buffer = b''
         self.state = DLC.State.INIT
         self.role = multiplexer.role
         self.c_r = 1 if self.role == Multiplexer.Role.INITIATOR else 0
         self.sink = None
         self.connection_result = None
-        self.drained = asyncio.Event()
-        self.drained.set()
 
         # Compute the MTU
         max_overhead = 4 + 1  # header with 2-byte length + fcs
         self.mtu = min(
-            max_frame_size, self.multiplexer.l2cap_channel.peer_mtu - max_overhead
+            max_frame_size, self.multiplexer.l2cap_channel.mtu - max_overhead
         )
 
     def change_state(self, new_state: State) -> None:
@@ -485,7 +467,7 @@ class DLC(EventEmitter):
         self.multiplexer.send_frame(frame)
 
     def on_frame(self, frame: RFCOMM_Frame) -> None:
-        handler = getattr(self, f'on_{frame.type.name}_frame'.lower())
+        handler = getattr(self, f'on_{frame.type_name()}_frame'.lower())
         handler(frame)
 
     def on_sabm_frame(self, _frame: RFCOMM_Frame) -> None:
@@ -499,7 +481,9 @@ class DLC(EventEmitter):
 
         # Exchange the modem status with the peer
         msc = RFCOMM_MCC_MSC(dlci=self.dlci, fc=0, rtc=1, rtr=1, ic=0, dv=1)
-        mcc = RFCOMM_Frame.make_mcc(mcc_type=MccType.MSC, c_r=1, data=bytes(msc))
+        mcc = RFCOMM_Frame.make_mcc(
+            mcc_type=RFCOMM_MCC_MSC_TYPE, c_r=1, data=bytes(msc)
+        )
         logger.debug(f'>>> MCC MSC Command: {msc}')
         self.send_frame(RFCOMM_Frame.uih(c_r=self.c_r, dlci=0, information=mcc))
 
@@ -515,7 +499,9 @@ class DLC(EventEmitter):
 
         # Exchange the modem status with the peer
         msc = RFCOMM_MCC_MSC(dlci=self.dlci, fc=0, rtc=1, rtr=1, ic=0, dv=1)
-        mcc = RFCOMM_Frame.make_mcc(mcc_type=MccType.MSC, c_r=1, data=bytes(msc))
+        mcc = RFCOMM_Frame.make_mcc(
+            mcc_type=RFCOMM_MCC_MSC_TYPE, c_r=1, data=bytes(msc)
+        )
         logger.debug(f'>>> MCC MSC Command: {msc}')
         self.send_frame(RFCOMM_Frame.uih(c_r=self.c_r, dlci=0, information=mcc))
 
@@ -548,15 +534,14 @@ class DLC(EventEmitter):
             f'[{self.dlci}] {len(data)} bytes, '
             f'rx_credits={self.rx_credits}: {data.hex()}'
         )
-        if data:
-            if self.sink:
-                self.sink(data)  # pylint: disable=not-callable
+        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()
@@ -569,7 +554,9 @@ class DLC(EventEmitter):
             # Command
             logger.debug(f'<<< MCC MSC Command: {msc}')
             msc = RFCOMM_MCC_MSC(dlci=self.dlci, fc=0, rtc=1, rtr=1, ic=0, dv=1)
-            mcc = RFCOMM_Frame.make_mcc(mcc_type=MccType.MSC, c_r=0, data=bytes(msc))
+            mcc = RFCOMM_Frame.make_mcc(
+                mcc_type=RFCOMM_MCC_MSC_TYPE, c_r=0, data=bytes(msc)
+            )
             logger.debug(f'>>> MCC MSC Response: {msc}')
             self.send_frame(RFCOMM_Frame.uih(c_r=self.c_r, dlci=0, information=mcc))
         else:
@@ -593,18 +580,18 @@ class DLC(EventEmitter):
             cl=0xE0,
             priority=7,
             ack_timer=0,
-            max_frame_size=self.max_frame_size,
+            max_frame_size=RFCOMM_DEFAULT_PREFERRED_MTU,
             max_retransmissions=0,
-            window_size=self.window_size,
+            window_size=RFCOMM_DEFAULT_INITIAL_RX_CREDITS,
         )
-        mcc = RFCOMM_Frame.make_mcc(mcc_type=MccType.PN, c_r=0, data=bytes(pn))
+        mcc = RFCOMM_Frame.make_mcc(mcc_type=RFCOMM_MCC_PN_TYPE, c_r=0, data=bytes(pn))
         logger.debug(f'>>> PN Response: {pn}')
         self.send_frame(RFCOMM_Frame.uih(c_r=self.c_r, dlci=0, information=mcc))
         self.change_state(DLC.State.CONNECTING)
 
     def rx_credits_needed(self) -> int:
         if self.rx_credits <= self.rx_threshold:
-            return self.window_size - self.rx_credits
+            return RFCOMM_DEFAULT_INITIAL_RX_CREDITS - self.rx_credits
 
         return 0
 
@@ -644,8 +631,6 @@ class DLC(EventEmitter):
             )
 
             rx_credits_needed = 0
-            if not self.tx_buffer:
-                self.drained.set()
 
     # Stream protocol
     def write(self, data: Union[bytes, str]) -> None:
@@ -658,11 +643,11 @@ class DLC(EventEmitter):
                 raise ValueError('write only accept bytes or strings')
 
         self.tx_buffer += data
-        self.drained.clear()
         self.process_tx()
 
-    async def drain(self) -> None:
-        await self.drained.wait()
+    def drain(self) -> None:
+        # TODO
+        pass
 
     def __str__(self) -> str:
         return f'DLC(dlci={self.dlci},state={self.state.name})'
@@ -719,7 +704,7 @@ class Multiplexer(EventEmitter):
         if frame.dlci == 0:
             self.on_frame(frame)
         else:
-            if frame.type == FrameType.DM:
+            if frame.type == RFCOMM_DM_FRAME:
                 # DM responses are for a DLCI, but since we only create the dlc when we
                 # receive a PN response (because we need the parameters), we handle DM
                 # frames at the Multiplexer level
@@ -732,7 +717,7 @@ class Multiplexer(EventEmitter):
                 dlc.on_frame(frame)
 
     def on_frame(self, frame: RFCOMM_Frame) -> None:
-        handler = getattr(self, f'on_{frame.type.name}_frame'.lower())
+        handler = getattr(self, f'on_{frame.type_name()}_frame'.lower())
         handler(frame)
 
     def on_sabm_frame(self, _frame: RFCOMM_Frame) -> None:
@@ -780,10 +765,10 @@ class Multiplexer(EventEmitter):
     def on_uih_frame(self, frame: RFCOMM_Frame) -> None:
         (mcc_type, c_r, value) = RFCOMM_Frame.parse_mcc(frame.information)
 
-        if mcc_type == MccType.PN:
+        if mcc_type == RFCOMM_MCC_PN_TYPE:
             pn = RFCOMM_MCC_PN.from_bytes(value)
             self.on_mcc_pn(c_r, pn)
-        elif mcc_type == MccType.MSC:
+        elif mcc_type == RFCOMM_MCC_MSC_TYPE:
             mcs = RFCOMM_MCC_MSC.from_bytes(value)
             self.on_mcc_msc(c_r, mcs)
 
@@ -858,12 +843,7 @@ class Multiplexer(EventEmitter):
         )
         await self.disconnection_result
 
-    async def open_dlc(
-        self,
-        channel: int,
-        max_frame_size: int = RFCOMM_DEFAULT_MAX_FRAME_SIZE,
-        window_size: int = RFCOMM_DEFAULT_WINDOW_SIZE,
-    ) -> DLC:
+    async def open_dlc(self, channel: int) -> DLC:
         if self.state != Multiplexer.State.CONNECTED:
             if self.state == Multiplexer.State.OPENING:
                 raise InvalidStateError('open already in progress')
@@ -875,11 +855,11 @@ class Multiplexer(EventEmitter):
             cl=0xF0,
             priority=7,
             ack_timer=0,
-            max_frame_size=max_frame_size,
+            max_frame_size=RFCOMM_DEFAULT_PREFERRED_MTU,
             max_retransmissions=0,
-            window_size=window_size,
+            window_size=RFCOMM_DEFAULT_INITIAL_RX_CREDITS,
         )
-        mcc = RFCOMM_Frame.make_mcc(mcc_type=MccType.PN, c_r=1, data=bytes(pn))
+        mcc = RFCOMM_Frame.make_mcc(mcc_type=RFCOMM_MCC_PN_TYPE, c_r=1, data=bytes(pn))
         logger.debug(f'>>> Sending MCC: {pn}')
         self.open_result = asyncio.get_running_loop().create_future()
         self.change_state(Multiplexer.State.OPENING)
@@ -909,11 +889,8 @@ class Client:
     multiplexer: Optional[Multiplexer]
     l2cap_channel: Optional[l2cap.ClassicChannel]
 
-    def __init__(
-        self, connection: Connection, l2cap_mtu: int = RFCOMM_DEFAULT_L2CAP_MTU
-    ) -> None:
+    def __init__(self, connection: Connection) -> None:
         self.connection = connection
-        self.l2cap_mtu = l2cap_mtu
         self.l2cap_channel = None
         self.multiplexer = None
 
@@ -921,7 +898,7 @@ class Client:
         # Create a new L2CAP connection
         try:
             self.l2cap_channel = await self.connection.create_l2cap_channel(
-                spec=l2cap.ClassicChannelSpec(psm=RFCOMM_PSM, mtu=self.l2cap_mtu)
+                spec=l2cap.ClassicChannelSpec(RFCOMM_PSM)
             )
         except ProtocolError as error:
             logger.warning(f'L2CAP connection failed: {error}')
@@ -944,33 +921,22 @@ class Client:
         self.multiplexer = None
 
         # Close the L2CAP channel
-        if self.l2cap_channel:
-            await self.l2cap_channel.disconnect()
-            self.l2cap_channel = None
-
-    async def __aenter__(self) -> Multiplexer:
-        return await self.start()
-
-    async def __aexit__(self, *args) -> None:
-        await self.shutdown()
+        # TODO
 
 
 # -----------------------------------------------------------------------------
 class Server(EventEmitter):
     acceptors: Dict[int, Callable[[DLC], None]]
 
-    def __init__(
-        self, device: Device, l2cap_mtu: int = RFCOMM_DEFAULT_L2CAP_MTU
-    ) -> None:
+    def __init__(self, device: Device) -> None:
         super().__init__()
         self.device = device
         self.multiplexer = None
         self.acceptors = {}
 
         # Register ourselves with the L2CAP channel manager
-        self.l2cap_server = device.create_l2cap_server(
-            spec=l2cap.ClassicChannelSpec(psm=RFCOMM_PSM, mtu=l2cap_mtu),
-            handler=self.on_connection,
+        device.create_l2cap_server(
+            spec=l2cap.ClassicChannelSpec(psm=RFCOMM_PSM), handler=self.on_connection
         )
 
     def listen(self, acceptor: Callable[[DLC], None], channel: int = 0) -> int:
@@ -1020,9 +986,3 @@ class Server(EventEmitter):
         acceptor = self.acceptors.get(dlc.dlci >> 1)
         if acceptor:
             acceptor(dlc)
-
-    def __enter__(self) -> Self:
-        return self
-
-    def __exit__(self, *args) -> None:
-        self.l2cap_server.close()

bumble/sdp.py

@@ -19,7 +19,6 @@ from __future__ import annotations
 import logging
 import struct
 from typing import Dict, List, Type, Optional, Tuple, Union, NewType, TYPE_CHECKING
-from typing_extensions import Self
 
 from . import core, l2cap
 from .colors import color
@@ -98,8 +97,7 @@ SDP_CLIENT_EXECUTABLE_URL_ATTRIBUTE_ID               = 0X000B
 SDP_ICON_URL_ATTRIBUTE_ID                            = 0X000C
 SDP_ADDITIONAL_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID = 0X000D
 
-
-# Profile-specific Attribute Identifiers (cf. Assigned Numbers for Service Discovery)
+# Attribute Identifier (cf. Assigned Numbers for Service Discovery)
 # used by AVRCP, HFP and A2DP
 SDP_SUPPORTED_FEATURES_ATTRIBUTE_ID = 0x0311
 
@@ -117,8 +115,7 @@ SDP_ATTRIBUTE_ID_NAMES = {
     SDP_DOCUMENTATION_URL_ATTRIBUTE_ID:                   'SDP_DOCUMENTATION_URL_ATTRIBUTE_ID',
     SDP_CLIENT_EXECUTABLE_URL_ATTRIBUTE_ID:               'SDP_CLIENT_EXECUTABLE_URL_ATTRIBUTE_ID',
     SDP_ICON_URL_ATTRIBUTE_ID:                            'SDP_ICON_URL_ATTRIBUTE_ID',
-    SDP_ADDITIONAL_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID: 'SDP_ADDITIONAL_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID',
-    SDP_SUPPORTED_FEATURES_ATTRIBUTE_ID:                  'SDP_SUPPORTED_FEATURES_ATTRIBUTE_ID',
+    SDP_ADDITIONAL_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID: 'SDP_ADDITIONAL_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID'
 }
 
 SDP_PUBLIC_BROWSE_ROOT = core.UUID.from_16_bits(0x1002, 'PublicBrowseRoot')
@@ -825,13 +822,11 @@ class Client:
         )
         attribute_id_list = DataElement.sequence(
             [
-                (
-                    DataElement.unsigned_integer(
-                        attribute_id[0], value_size=attribute_id[1]
-                    )
-                    if isinstance(attribute_id, tuple)
-                    else DataElement.unsigned_integer_16(attribute_id)
+                DataElement.unsigned_integer(
+                    attribute_id[0], value_size=attribute_id[1]
                 )
+                if isinstance(attribute_id, tuple)
+                else DataElement.unsigned_integer_16(attribute_id)
                 for attribute_id in attribute_ids
             ]
         )
@@ -883,13 +878,11 @@ class Client:
 
         attribute_id_list = DataElement.sequence(
             [
-                (
-                    DataElement.unsigned_integer(
-                        attribute_id[0], value_size=attribute_id[1]
-                    )
-                    if isinstance(attribute_id, tuple)
-                    else DataElement.unsigned_integer_16(attribute_id)
+                DataElement.unsigned_integer(
+                    attribute_id[0], value_size=attribute_id[1]
                 )
+                if isinstance(attribute_id, tuple)
+                else DataElement.unsigned_integer_16(attribute_id)
                 for attribute_id in attribute_ids
             ]
         )
@@ -925,13 +918,6 @@ class Client:
 
         return ServiceAttribute.list_from_data_elements(attribute_list_sequence.value)
 
-    async def __aenter__(self) -> Self:
-        await self.connect()
-        return self
-
-    async def __aexit__(self, *args) -> None:
-        await self.disconnect()
-
 
 # -----------------------------------------------------------------------------
 class Server:

bumble/smp.py

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

bumble/transport/__init__.py

@@ -82,13 +82,14 @@ async def open_transport(name: str) -> Transport:
 
     scheme, *tail = name.split(':', 1)
     spec = tail[0] if tail else None
-    metadata = None
     if spec:
         # Metadata may precede the spec
         if spec.startswith('['):
             metadata_str, *tail = spec[1:].split(']')
             spec = tail[0] if tail else None
             metadata = dict([entry.split('=') for entry in metadata_str.split(',')])
+        else:
+            metadata = None
 
     transport = await _open_transport(scheme, spec)
     if metadata:
@@ -197,13 +198,12 @@ async def open_transport_or_link(name: str) -> Transport:
 
     """
     if name.startswith('link-relay:'):
-        logger.warning('Link Relay has been deprecated.')
         from ..controller import Controller
         from ..link import RemoteLink  # lazy import
 
         link = RemoteLink(name[11:])
         await link.wait_until_connected()
-        controller = Controller('remote', link=link)  # type:ignore[arg-type]
+        controller = Controller('remote', link=link)
 
         class LinkTransport(Transport):
             async def close(self):

bumble/transport/common.py

@@ -59,13 +59,15 @@ class TransportLostError(Exception):
 # Typing Protocols
 # -----------------------------------------------------------------------------
 class TransportSink(Protocol):
-    def on_packet(self, packet: bytes) -> None: ...
+    def on_packet(self, packet: bytes) -> None:
+        ...
 
 
 class TransportSource(Protocol):
     terminated: asyncio.Future[None]
 
-    def set_packet_sink(self, sink: TransportSink) -> None: ...
+    def set_packet_sink(self, sink: TransportSink) -> None:
+        ...
 
 
 # -----------------------------------------------------------------------------
@@ -166,13 +168,11 @@ class PacketReader:
 
     def __init__(self, source: io.BufferedReader) -> None:
         self.source = source
-        self.at_end = False
 
     def next_packet(self) -> Optional[bytes]:
         # Get the packet type
         packet_type = self.source.read(1)
         if len(packet_type) != 1:
-            self.at_end = True
             return None
 
         # Get the packet info based on its type

bumble/transport/pyusb.py

@@ -23,24 +23,11 @@ import time
 import usb.core
 import usb.util
 
-from typing import Optional
-from usb.core import Device as UsbDevice
-from usb.core import USBError
-from usb.util import CTRL_TYPE_CLASS, CTRL_RECIPIENT_OTHER
-from usb.legacy import REQ_SET_FEATURE, REQ_CLEAR_FEATURE, CLASS_HUB
-
 from .common import Transport, ParserSource
 from .. import hci
 from ..colors import color
 
 
-# -----------------------------------------------------------------------------
-# Constant
-# -----------------------------------------------------------------------------
-USB_PORT_FEATURE_POWER = 8
-POWER_CYCLE_DELAY = 1
-RESET_DELAY = 3
-
 # -----------------------------------------------------------------------------
 # Logging
 # -----------------------------------------------------------------------------
@@ -126,10 +113,9 @@ async def open_pyusb_transport(spec: str) -> Transport:
             self.loop.call_soon_threadsafe(self.stop_event.set)
 
     class UsbPacketSource(asyncio.Protocol, ParserSource):
-        def __init__(self, device, metadata, sco_enabled):
+        def __init__(self, device, sco_enabled):
             super().__init__()
             self.device = device
-            self.metadata = metadata
             self.loop = asyncio.get_running_loop()
             self.queue = asyncio.Queue()
             self.dequeue_task = None
@@ -227,22 +213,9 @@ async def open_pyusb_transport(spec: str) -> Transport:
         usb_find = libusb_package.find
 
     # Find the device according to the spec moniker
-    power_cycle = False
-    if spec.startswith('!'):
-        power_cycle = True
-        spec = spec[1:]
     if ':' in spec:
         vendor_id, product_id = spec.split(':')
         device = usb_find(idVendor=int(vendor_id, 16), idProduct=int(product_id, 16))
-    elif '-' in spec:
-
-        def device_path(device):
-            if device.port_numbers:
-                return f'{device.bus}-{".".join(map(str, device.port_numbers))}'
-            else:
-                return str(device.bus)
-
-        device = usb_find(custom_match=lambda device: device_path(device) == spec)
     else:
         device_index = int(spec)
         devices = list(
@@ -262,17 +235,6 @@ async def open_pyusb_transport(spec: str) -> Transport:
         raise ValueError('device not found')
     logger.debug(f'USB Device: {device}')
 
-    # Power Cycle the device
-    if power_cycle:
-        try:
-            device = await _power_cycle(device)  # type: ignore
-        except Exception as e:
-            logging.debug(e)
-            logging.info(f"Unable to power cycle {hex(device.idVendor)} {hex(device.idProduct)}")  # type: ignore
-
-    # Collect the metadata
-    device_metadata = {'vendor_id': device.idVendor, 'product_id': device.idProduct}
-
     # Detach the kernel driver if needed
     if device.is_kernel_driver_active(0):
         logger.debug("detaching kernel driver")
@@ -327,79 +289,9 @@ async def open_pyusb_transport(spec: str) -> Transport:
     #     except usb.USBError:
     #         logger.warning('failed to set alternate setting')
 
-    packet_source = UsbPacketSource(device, device_metadata, sco_enabled)
+    packet_source = UsbPacketSource(device, sco_enabled)
     packet_sink = UsbPacketSink(device)
     packet_source.start()
     packet_sink.start()
 
     return UsbTransport(device, packet_source, packet_sink)
-
-
-async def _power_cycle(device: UsbDevice) -> UsbDevice:
-    """
-    For devices connected to compatible USB hubs: Performs a power cycle on a given USB device.
-    This involves temporarily disabling its port on the hub and then re-enabling it.
-    """
-    device_path = f'{device.bus}-{".".join(map(str, device.port_numbers))}'  # type: ignore
-    hub = _find_hub_by_device_path(device_path)
-
-    if hub:
-        try:
-            device_port = device.port_numbers[-1]  # type: ignore
-            _set_port_status(hub, device_port, False)
-            await asyncio.sleep(POWER_CYCLE_DELAY)
-            _set_port_status(hub, device_port, True)
-            await asyncio.sleep(RESET_DELAY)
-
-            # Device needs to be find again otherwise it will appear as disconnected
-            return usb.core.find(idVendor=device.idVendor, idProduct=device.idProduct)  # type: ignore
-        except USBError as e:
-            logger.error(f"Adjustment needed: Please revise the udev rule for device {hex(device.idVendor)}:{hex(device.idProduct)} for proper recognition.")  # type: ignore
-            logger.error(e)
-
-    return device
-
-
-def _set_port_status(device: UsbDevice, port: int, on: bool):
-    """Sets the power status of a specific port on a USB hub."""
-    device.ctrl_transfer(
-        bmRequestType=CTRL_TYPE_CLASS | CTRL_RECIPIENT_OTHER,
-        bRequest=REQ_SET_FEATURE if on else REQ_CLEAR_FEATURE,
-        wIndex=port,
-        wValue=USB_PORT_FEATURE_POWER,
-    )
-
-
-def _find_device_by_path(sys_path: str) -> Optional[UsbDevice]:
-    """Finds a USB device based on its system path."""
-    bus_num, *port_parts = sys_path.split('-')
-    ports = [int(port) for port in port_parts[0].split('.')]
-    devices = usb.core.find(find_all=True, bus=int(bus_num))
-    if devices:
-        for device in devices:
-            if device.bus == int(bus_num) and list(device.port_numbers) == ports:  # type: ignore
-                return device
-
-    return None
-
-
-def _find_hub_by_device_path(sys_path: str) -> Optional[UsbDevice]:
-    """Finds the USB hub associated with a specific device path."""
-    hub_sys_path = sys_path.rsplit('.', 1)[0]
-    hub_device = _find_device_by_path(hub_sys_path)
-
-    if hub_device is None:
-        return None
-    else:
-        return hub_device if _is_hub(hub_device) else None
-
-
-def _is_hub(device: UsbDevice) -> bool:
-    """Checks if a USB device is a hub"""
-    if device.bDeviceClass == CLASS_HUB:  # type: ignore
-        return True
-    for config in device:
-        for interface in config:
-            if interface.bInterfaceClass == CLASS_HUB:  # type: ignore
-                return True
-    return False

bumble/transport/tcp_server.py

@@ -18,7 +18,6 @@
 from __future__ import annotations
 import asyncio
 import logging
-import socket
 
 from .common import Transport, StreamPacketSource
 
@@ -29,13 +28,6 @@ logger = logging.getLogger(__name__)
 
 
 # -----------------------------------------------------------------------------
-
-
-# A pass-through function to ease mock testing.
-async def _create_server(*args, **kw_args):
-    await asyncio.get_running_loop().create_server(*args, **kw_args)
-
-
 async def open_tcp_server_transport(spec: str) -> Transport:
     '''
     Open a TCP server transport.
@@ -46,22 +38,7 @@ async def open_tcp_server_transport(spec: str) -> Transport:
 
     Example: _:9001
     '''
-    local_host, local_port = spec.split(':')
-    return await _open_tcp_server_transport_impl(
-        host=local_host if local_host != '_' else None, port=int(local_port)
-    )
 
-
-async def open_tcp_server_transport_with_socket(sock: socket.socket) -> Transport:
-    '''
-    Open a TCP server transport with an existing socket.
-
-    One reason to use this variant is to let python pick an unused port.
-    '''
-    return await _open_tcp_server_transport_impl(sock=sock)
-
-
-async def _open_tcp_server_transport_impl(**kwargs) -> Transport:
     class TcpServerTransport(Transport):
         async def close(self):
             await super().close()
@@ -100,10 +77,13 @@ async def _open_tcp_server_transport_impl(**kwargs) -> Transport:
             else:
                 logger.debug('no client, dropping packet')
 
+    local_host, local_port = spec.split(':')
     packet_source = StreamPacketSource()
     packet_sink = TcpServerPacketSink()
-    await _create_server(
-        lambda: TcpServerProtocol(packet_source, packet_sink), **kwargs
+    await asyncio.get_running_loop().create_server(
+        lambda: TcpServerProtocol(packet_source, packet_sink),
+        host=local_host if local_host != '_' else None,
+        port=int(local_port),
     )
 
     return TcpServerTransport(packet_source, packet_sink)

bumble/transport/usb.py

@@ -108,7 +108,7 @@ async def open_usb_transport(spec: str) -> Transport:
         USB_DEVICE_PROTOCOL_BLUETOOTH_PRIMARY_CONTROLLER,
     )
 
-    READ_SIZE = 4096
+    READ_SIZE = 1024
 
     class UsbPacketSink:
         def __init__(self, device, acl_out):
@@ -396,16 +396,6 @@ async def open_usb_transport(spec: str) -> Transport:
                         break
                     device_index -= 1
                 device.close()
-        elif '-' in spec:
-
-            def device_path(device):
-                return f'{device.getBusNumber()}-{".".join(map(str, device.getPortNumberList()))}'
-
-            for device in context.getDeviceIterator(skip_on_error=True):
-                if device_path(device) == spec:
-                    found = device
-                    break
-                device.close()
         else:
             # Look for a compatible device by index
             def device_is_bluetooth_hci(device):
@@ -449,7 +439,7 @@ async def open_usb_transport(spec: str) -> Transport:
         # Look for the first interface with the right class and endpoints
         def find_endpoints(device):
             # pylint: disable-next=too-many-nested-blocks
-            for configuration_index, configuration in enumerate(device):
+            for (configuration_index, configuration) in enumerate(device):
                 interface = None
                 for interface in configuration:
                     setting = None

bumble/utils.py

@@ -17,10 +17,9 @@
 # -----------------------------------------------------------------------------
 from __future__ import annotations
 import asyncio
-import collections
-import enum
-import functools
 import logging
+import traceback
+import collections
 import sys
 import warnings
 from typing import (
@@ -35,7 +34,7 @@ from typing import (
     Union,
     overload,
 )
-
+from functools import wraps, partial
 from pyee import EventEmitter
 
 from .colors import color
@@ -117,12 +116,12 @@ class EventWatcher:
         self.handlers = []
 
     @overload
-    def on(
-        self, emitter: EventEmitter, event: str
-    ) -> Callable[[_Handler], _Handler]: ...
+    def on(self, emitter: EventEmitter, event: str) -> Callable[[_Handler], _Handler]:
+        ...
 
     @overload
-    def on(self, emitter: EventEmitter, event: str, handler: _Handler) -> _Handler: ...
+    def on(self, emitter: EventEmitter, event: str, handler: _Handler) -> _Handler:
+        ...
 
     def on(
         self, emitter: EventEmitter, event: str, handler: Optional[_Handler] = None
@@ -132,26 +131,23 @@ class EventWatcher:
         Args:
             emitter: EventEmitter to watch
             event: Event name
-            handler: (Optional) Event handler. When nothing is passed, this method
-            works as a decorator.
+            handler: (Optional) Event handler. When nothing is passed, this method works as a decorator.
         '''
 
-        def wrapper(wrapped: _Handler) -> _Handler:
-            self.handlers.append((emitter, event, wrapped))
-            emitter.on(event, wrapped)
-            return wrapped
+        def wrapper(f: _Handler) -> _Handler:
+            self.handlers.append((emitter, event, f))
+            emitter.on(event, f)
+            return f
 
         return wrapper if handler is None else wrapper(handler)
 
     @overload
-    def once(
-        self, emitter: EventEmitter, event: str
-    ) -> Callable[[_Handler], _Handler]: ...
+    def once(self, emitter: EventEmitter, event: str) -> Callable[[_Handler], _Handler]:
+        ...
 
     @overload
-    def once(
-        self, emitter: EventEmitter, event: str, handler: _Handler
-    ) -> _Handler: ...
+    def once(self, emitter: EventEmitter, event: str, handler: _Handler) -> _Handler:
+        ...
 
     def once(
         self, emitter: EventEmitter, event: str, handler: Optional[_Handler] = None
@@ -161,14 +157,13 @@ class EventWatcher:
         Args:
             emitter: EventEmitter to watch
             event: Event name
-            handler: (Optional) Event handler. When nothing passed, this method works
-            as a decorator.
+            handler: (Optional) Event handler. When nothing passed, this method works as a decorator.
         '''
 
-        def wrapper(wrapped: _Handler) -> _Handler:
-            self.handlers.append((emitter, event, wrapped))
-            emitter.once(event, wrapped)
-            return wrapped
+        def wrapper(f: _Handler) -> _Handler:
+            self.handlers.append((emitter, event, f))
+            emitter.once(event, f)
+            return f
 
         return wrapper if handler is None else wrapper(handler)
 
@@ -228,13 +223,13 @@ class CompositeEventEmitter(AbortableEventEmitter):
         if self._listener:
             # Call the deregistration methods for each base class that has them
             for cls in self._listener.__class__.mro():
-                if '_bumble_register_composite' in cls.__dict__:
-                    cls._bumble_deregister_composite(self._listener, self)
+                if hasattr(cls, '_bumble_register_composite'):
+                    cls._bumble_deregister_composite(listener, self)
         self._listener = listener
         if listener:
             # Call the registration methods for each base class that has them
             for cls in listener.__class__.mro():
-                if '_bumble_deregister_composite' in cls.__dict__:
+                if hasattr(cls, '_bumble_deregister_composite'):
                     cls._bumble_register_composite(listener, self)
 
 
@@ -281,18 +276,21 @@ class AsyncRunner:
         """
 
         def decorator(func):
-            @functools.wraps(func)
+            @wraps(func)
             def wrapper(*args, **kwargs):
                 coroutine = func(*args, **kwargs)
                 if queue is None:
-                    # Spawn the coroutine as a task
+                    # Create a task to run the coroutine
                     async def run():
                         try:
                             await coroutine
                         except Exception:
-                            logger.exception(color("!!! Exception in wrapper:", "red"))
+                            logger.warning(
+                                f'{color("!!! Exception in wrapper:", "red")} '
+                                f'{traceback.format_exc()}'
+                            )
 
-                    AsyncRunner.spawn(run())
+                    asyncio.create_task(run())
                 else:
                     # Queue the coroutine to be awaited by the work queue
                     queue.enqueue(coroutine)
@@ -415,35 +413,30 @@ class FlowControlAsyncPipe:
             self.check_pump()
 
 
-# -----------------------------------------------------------------------------
 async def async_call(function, *args, **kwargs):
     """
-    Immediately calls the function with provided args and kwargs, wrapping it in an
-    async function.
-    Rust's `pyo3_asyncio` library needs functions to be marked async to properly inject
-    a running loop.
+    Immediately calls the function with provided args and kwargs, wrapping it in an async function.
+    Rust's `pyo3_asyncio` library needs functions to be marked async to properly inject a running loop.
 
     result = await async_call(some_function, ...)
     """
     return function(*args, **kwargs)
 
 
-# -----------------------------------------------------------------------------
 def wrap_async(function):
     """
     Wraps the provided function in an async function.
     """
-    return functools.partial(async_call, function)
+    return partial(async_call, function)
 
 
-# -----------------------------------------------------------------------------
 def deprecated(msg: str):
     """
     Throw deprecation warning before execution.
     """
 
     def wrapper(function):
-        @functools.wraps(function)
+        @wraps(function)
         def inner(*args, **kwargs):
             warnings.warn(msg, DeprecationWarning)
             return function(*args, **kwargs)
@@ -453,14 +446,13 @@ def deprecated(msg: str):
     return wrapper
 
 
-# -----------------------------------------------------------------------------
 def experimental(msg: str):
     """
     Throws a future warning before execution.
     """
 
     def wrapper(function):
-        @functools.wraps(function)
+        @wraps(function)
         def inner(*args, **kwargs):
             warnings.warn(msg, FutureWarning)
             return function(*args, **kwargs)
@@ -468,22 +460,3 @@ def experimental(msg: str):
         return inner
 
     return wrapper
-
-
-# -----------------------------------------------------------------------------
-class OpenIntEnum(enum.IntEnum):
-    """
-    Subclass of enum.IntEnum that can hold integer values outside the set of
-    predefined values. This is convenient for implementing protocols where some
-    integer constants may be added over time.
-    """
-
-    @classmethod
-    def _missing_(cls, value):
-        if not isinstance(value, int):
-            return None
-
-        obj = int.__new__(cls, value)
-        obj._value_ = value
-        obj._name_ = f"{cls.__name__}[{value}]"
-        return obj

docs/mkdocs/src/apps_and_tools/bench.md

@@ -7,36 +7,16 @@ throughput and/or latency between two devices.
 # General Usage
 
 ```
-Usage: bumble-bench [OPTIONS] COMMAND [ARGS]...
+Usage: bench.py [OPTIONS] COMMAND [ARGS]...
 
 Options:
   --device-config FILENAME        Device configuration file
   --role [sender|receiver|ping|pong]
   --mode [gatt-client|gatt-server|l2cap-client|l2cap-server|rfcomm-client|rfcomm-server]
   --att-mtu MTU                   GATT MTU (gatt-client mode)  [23<=x<=517]
-  --extended-data-length TEXT     Request a data length upon connection,
-                                  specified as tx_octets/tx_time
-  --rfcomm-channel INTEGER        RFComm channel to use
-  --rfcomm-uuid TEXT              RFComm service UUID to use (ignored if
-                                  --rfcomm-channel is not 0)
-  --l2cap-psm INTEGER             L2CAP PSM to use
-  --l2cap-mtu INTEGER             L2CAP MTU to use
-  --l2cap-mps INTEGER             L2CAP MPS to use
-  --l2cap-max-credits INTEGER     L2CAP maximum number of credits allowed for
-                                  the peer
-  -s, --packet-size SIZE          Packet size (client or ping role)
-                                  [8<=x<=4096]
-  -c, --packet-count COUNT        Packet count (client or ping role)
-  -sd, --start-delay SECONDS      Start delay (client or ping role)
-  --repeat N                      Repeat the run N times (client and ping
-                                  roles)(0, which is the fault, to run just
-                                  once)
-  --repeat-delay SECONDS          Delay, in seconds, between repeats
-  --pace MILLISECONDS             Wait N milliseconds between packets (0,
-                                  which is the fault, to send as fast as
-                                  possible)
-  --linger                        Don't exit at the end of a run (server and
-                                  pong roles)
+  -s, --packet-size SIZE          Packet size (server role)  [8<=x<=4096]
+  -c, --packet-count COUNT        Packet count (server role)
+  -sd, --start-delay SECONDS      Start delay (server role)
   --help                          Show this message and exit.
 
 Commands:
@@ -55,18 +35,17 @@ Options:
   --connection-interval, --ci CONNECTION_INTERVAL
                                   Connection interval (in ms)
   --phy [1m|2m|coded]             PHY to use
-  --authenticate                  Authenticate (RFComm only)
-  --encrypt                       Encrypt the connection (RFComm only)
   --help                          Show this message and exit.
 ```
 
-To test once device against another, one of the two devices must be running
+
+To test once device against another, one of the two devices must be running 
 the ``peripheral`` command and the other the ``central`` command. The device
 running the ``peripheral`` command will accept connections from the device
 running the ``central`` command.
 When using Bluetooth LE (all modes except for ``rfcomm-server`` and ``rfcomm-client``utils),
-the default addresses configured in the tool should be sufficient. But when using
-Bluetooth Classic, the address of the Peripheral must be specified on the Central
+the default addresses configured in the tool should be sufficient. But when using 
+Bluetooth Classic, the address of the Peripheral must be specified on the Central 
 using the ``--peripheral`` option. The address will be printed by the Peripheral when
 it starts.
 
@@ -104,7 +83,7 @@ the other on `usb:1`, and two consoles/terminals. We will run a command in each.
     $ bumble-bench central usb:1
     ```
 
-    In this default configuration, the Central runs a Sender, as a GATT client,
+    In this default configuration, the Central runs a Sender, as a GATT client, 
     connecting to the Peripheral running a Receiver, as a GATT server.
 
 !!! example "L2CAP Throughput"

docs/mkdocs/src/apps_and_tools/hci_bridge.md

@@ -12,25 +12,12 @@ a host that send custom HCI commands that the controller may not understand.
     ```
     python hci_bridge.py <host-transport-spec> <controller-transport-spec> [command-short-circuit-list]
     ```
-    The command-short-circuit-list field is specified by a series of comma separated Opcode Group 
-    Field (OGF) : OpCode Command Field (OCF) pairs. The OGF/OCF values are specified in the Blutooth
-    core specification.
-
-    For the commands that are listed in the short-circuit-list, the HCI bridge will always generate
-    a Command Complete Event for the specified op code. The return parameter will be HCI_SUCCESS.
-
-    This feature can only be used for commands that return Command Complete. Other events will not be
-    generated by the HCI bridge tool.
 
 !!! example "UDP to Serial"
     ```
     python hci_bridge.py udp:0.0.0.0:9000,127.0.0.1:9001 serial:/dev/tty.usbmodem0006839912171,1000000 0x3f:0x0070,0x3f:0x0074,0x3f:0x0077,0x3f:0x0078
     ```
 
-    In this example, the short circuit list is specified to respond to the Vendor-specific Opcode Group 
-    Field (0x3f) commands 0x70, 0x74, 0x77, 0x78 with Command Complete. The short circuit list can be
-    used where the Host uses some HCI commands that are not supported/implemented by the Controller.
-
 !!! example "PTY to Link Relay"
     ```
     python hci_bridge.py serial:emulated_uart_pty,1000000 link-relay:ws://127.0.0.1:10723/test
@@ -41,4 +28,3 @@ a host that send custom HCI commands that the controller may not understand.
     (through which the communication with other virtual controllers will be mediated).
 
     NOTE: this assumes you're running a Link Relay on port `10723`.
-

docs/mkdocs/src/drivers/index.md

@@ -10,7 +10,7 @@ used with particular HCI controller.
 When the transport for an HCI controller is instantiated from a transport name,
 a driver may also be forced by specifying ``driver=<driver-name>`` in the optional
 metadata portion of the transport name. For example,
-``usb:[driver=rtk]0`` indicates that the ``rtk`` driver should be used with the
+``usb:[driver=-rtk]0`` indicates that the ``rtk`` driver should be used with the
 first USB device, even if a normal probe would not have selected it based on the
 USB vendor ID and product ID.
 

docs/mkdocs/src/transports/usb.md

@@ -10,7 +10,6 @@ The moniker for a USB transport is either:
   * `usb:<vendor>:<product>`
   * `usb:<vendor>:<product>/<serial-number>`
   * `usb:<vendor>:<product>#<index>`
-  * `usb:<bus>-<port_numbers>`
 
 with `<index>` as a 0-based index (0 being the first one) to select amongst all the matching devices when there are more than one.
 In the `usb:<index>` form, matching devices are the ones supporting Bluetooth HCI, as declared by their Class, Subclass and Protocol.
@@ -18,8 +17,6 @@ In the `usb:<vendor>:<product>#<index>` form, matching devices are the ones with
 
 `<vendor>` and `<product>` are a vendor ID and product ID in hexadecimal.
 
-with `<port_numbers>` as a list of all port numbers from root separated with dots `.`
-
 In addition, if the moniker ends with the symbol "!", the device will be used in "forced" mode:
 the first USB interface of the device will be used, regardless of the interface class/subclass.
 This may be useful for some devices that use a custom class/subclass but may nonetheless work as-is.
@@ -40,9 +37,6 @@ This may be useful for some devices that use a custom class/subclass but may non
     `usb:0B05:17CB!`
     The BT USB dongle vendor=0B05 and product=17CB, in "forced" mode.
 
-    `usb:3-3.4.1`
-    The BT USB dongle on bus 3 on port path 3, 4, 1.
-
 
 ## Alternative
 The library includes two different implementations of the USB transport, implemented using different python bindings for `libusb`.

examples/async_runner.py

@@ -25,7 +25,6 @@ from bumble.utils import AsyncRunner
 my_work_queue1 = AsyncRunner.WorkQueue()
 my_work_queue2 = AsyncRunner.WorkQueue(create_task=False)
 
-
 # -----------------------------------------------------------------------------
 @AsyncRunner.run_in_task()
 async def func1(x, y):
@@ -61,7 +60,7 @@ async def func4(x, y):
 
 
 # -----------------------------------------------------------------------------
-async def main() -> None:
+async def main():
     print("MAIN: start, loop=", asyncio.get_running_loop())
     print("MAIN: invoke func1")
     func1(1, 2)

examples/avrcp_as_sink.html

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

examples/battery_client.py

@@ -21,29 +21,23 @@ import os
 import logging
 from bumble.colors import color
 from bumble.device import Device
-from bumble.hci import Address
 from bumble.transport import open_transport
 from bumble.profiles.battery_service import BatteryServiceProxy
 
 
 # -----------------------------------------------------------------------------
-async def main() -> None:
+async def main():
     if len(sys.argv) != 3:
         print('Usage: battery_client.py <transport-spec> <bluetooth-address>')
         print('example: battery_client.py usb:0 E1:CA:72:48:C4:E8')
         return
 
     print('<<< connecting to HCI...')
-    async with await open_transport(sys.argv[1]) as hci_transport:
+    async with await open_transport(sys.argv[1]) as (hci_source, hci_sink):
         print('<<< connected')
 
         # Create and start a device
-        device = Device.with_hci(
-            'Bumble',
-            Address('F0:F1:F2:F3:F4:F5'),
-            hci_transport.source,
-            hci_transport.sink,
-        )
+        device = Device.with_hci('Bumble', 'F0:F1:F2:F3:F4:F5', hci_source, hci_sink)
         await device.power_on()
 
         # Connect to the peer

examples/battery_server.py

@@ -29,16 +29,14 @@ from bumble.profiles.battery_service import BatteryService
 
 
 # -----------------------------------------------------------------------------
-async def main() -> None:
+async def main():
     if len(sys.argv) != 3:
         print('Usage: python battery_server.py <device-config> <transport-spec>')
         print('example: python battery_server.py device1.json usb:0')
         return
 
-    async with await open_transport_or_link(sys.argv[2]) as hci_transport:
-        device = Device.from_config_file_with_hci(
-            sys.argv[1], hci_transport.source, hci_transport.sink
-        )
+    async with await open_transport_or_link(sys.argv[2]) as (hci_source, hci_sink):
+        device = Device.from_config_file_with_hci(sys.argv[1], hci_source, hci_sink)
 
         # Add a Battery Service to the GATT sever
         battery_service = BatteryService(lambda _: random.randint(0, 100))

examples/device_information_client.py

@@ -21,13 +21,12 @@ import os
 import logging
 from bumble.colors import color
 from bumble.device import Device, Peer
-from bumble.hci import Address
 from bumble.profiles.device_information_service import DeviceInformationServiceProxy
 from bumble.transport import open_transport
 
 
 # -----------------------------------------------------------------------------
-async def main() -> None:
+async def main():
     if len(sys.argv) != 3:
         print(
             'Usage: device_information_client.py <transport-spec> <bluetooth-address>'
@@ -36,16 +35,11 @@ async def main() -> None:
         return
 
     print('<<< connecting to HCI...')
-    async with await open_transport(sys.argv[1]) as hci_transport:
+    async with await open_transport(sys.argv[1]) as (hci_source, hci_sink):
         print('<<< connected')
 
         # Create and start a device
-        device = Device.with_hci(
-            'Bumble',
-            Address('F0:F1:F2:F3:F4:F5'),
-            hci_transport.source,
-            hci_transport.sink,
-        )
+        device = Device.with_hci('Bumble', 'F0:F1:F2:F3:F4:F5', hci_source, hci_sink)
         await device.power_on()
 
         # Connect to the peer

examples/device_information_server.py

@@ -28,16 +28,14 @@ from bumble.profiles.device_information_service import DeviceInformationService
 
 
 # -----------------------------------------------------------------------------
-async def main() -> None:
+async def main():
     if len(sys.argv) != 3:
         print('Usage: python device_info_server.py <device-config> <transport-spec>')
         print('example: python device_info_server.py device1.json usb:0')
         return
 
-    async with await open_transport_or_link(sys.argv[2]) as hci_transport:
-        device = Device.from_config_file_with_hci(
-            sys.argv[1], hci_transport.source, hci_transport.sink
-        )
+    async with await open_transport_or_link(sys.argv[2]) as (hci_source, hci_sink):
+        device = Device.from_config_file_with_hci(sys.argv[1], hci_source, hci_sink)
 
         # Add a Device Information Service to the GATT sever
         device_information_service = DeviceInformationService(
@@ -66,7 +64,7 @@ async def main() -> None:
         # Go!
         await device.power_on()
         await device.start_advertising(auto_restart=True)
-        await hci_transport.source.wait_for_termination()
+        await hci_source.wait_for_termination()
 
 
 # -----------------------------------------------------------------------------

examples/heart_rate_client.py

@@ -21,29 +21,23 @@ import os
 import logging
 from bumble.colors import color
 from bumble.device import Device
-from bumble.hci import Address
 from bumble.transport import open_transport
 from bumble.profiles.heart_rate_service import HeartRateServiceProxy
 
 
 # -----------------------------------------------------------------------------
-async def main() -> None:
+async def main():
     if len(sys.argv) != 3:
         print('Usage: heart_rate_client.py <transport-spec> <bluetooth-address>')
         print('example: heart_rate_client.py usb:0 E1:CA:72:48:C4:E8')
         return
 
     print('<<< connecting to HCI...')
-    async with await open_transport(sys.argv[1]) as hci_transport:
+    async with await open_transport(sys.argv[1]) as (hci_source, hci_sink):
         print('<<< connected')
 
         # Create and start a device
-        device = Device.with_hci(
-            'Bumble',
-            Address('F0:F1:F2:F3:F4:F5'),
-            hci_transport.source,
-            hci_transport.sink,
-        )
+        device = Device.with_hci('Bumble', 'F0:F1:F2:F3:F4:F5', hci_source, hci_sink)
         await device.power_on()
 
         # Connect to the peer

examples/heart_rate_server.py

@@ -33,16 +33,14 @@ from bumble.utils import AsyncRunner
 
 
 # -----------------------------------------------------------------------------
-async def main() -> None:
+async def main():
     if len(sys.argv) != 3:
         print('Usage: python heart_rate_server.py <device-config> <transport-spec>')
         print('example: python heart_rate_server.py device1.json usb:0')
         return
 
-    async with await open_transport_or_link(sys.argv[2]) as hci_transport:
-        device = Device.from_config_file_with_hci(
-            sys.argv[1], hci_transport.source, hci_transport.sink
-        )
+    async with await open_transport_or_link(sys.argv[2]) as (hci_source, hci_sink):
+        device = Device.from_config_file_with_hci(sys.argv[1], hci_source, hci_sink)
 
         # Keep track of accumulated expended energy
         energy_start_time = time.time()

examples/hfp_handsfree.html

@@ -1,132 +1,79 @@
-<html data-bs-theme="dark">
+<html>
+    <head>
+        <style>
+* {
+    font-family: sans-serif;
+}
 
-<head>
-    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.2/dist/css/bootstrap.min.css" rel="stylesheet"
-        integrity="sha384-T3c6CoIi6uLrA9TneNEoa7RxnatzjcDSCmG1MXxSR1GAsXEV/Dwwykc2MPK8M2HN" crossorigin="anonymous">
-</head>
-
-<body>
-    <nav class="navbar navbar-dark bg-primary">
-        <div class="container">
-            <span class="navbar-brand mb-0 h1">Bumble Handsfree</span>
-        </div>
-    </nav>
-    <br>
-
-    <div class="container">
-
-        <label class="form-label">Server Port</label>
-        <div class="input-group mb-3">
-            <input type="text" class="form-control" aria-label="Port Number" value="8989" id="port">
-            <button class="btn btn-primary" type="button" onclick="connect()">Connect</button>
-        </div>
-
-        <label class="form-label">Dial Phone Number</label>
-        <div class="input-group mb-3">
-            <input type="text" class="form-control" placeholder="Phone Number" aria-label="Phone Number"
-                id="dial_number">
-            <button class="btn btn-primary" type="button"
-                onclick="send_at_command(`ATD${dialNumberInput.value}`)">Dial</button>
-        </div>
-
-        <label class="form-label">Send AT Command</label>
-        <div class="input-group mb-3">
-            <input type="text" class="form-control" placeholder="AT Command" aria-label="AT command" id="at_command">
-            <button class="btn btn-primary" type="button"
-                onclick="send_at_command(document.getElementById('at_command').value)">Send</button>
-        </div>
-
-        <div class="row">
-            <div class="col-auto">
-                <label class="form-label">Battery Level</label>
-                <div class="input-group mb-3">
-                    <input type="text" class="form-control" placeholder="0 - 100" aria-label="Battery Level"
-                        id="battery_level">
-                    <button class="btn btn-primary" type="button"
-                        onclick="send_at_command(`AT+BIEV=2,${document.getElementById('battery_level').value}`)">Set</button>
-                </div>
-            </div>
-            <div class="col-auto">
-                <label class="form-label">Speaker Volume</label>
-                <div class="input-group mb-3 col-auto">
-                    <input type="text" class="form-control" placeholder="0 - 15" aria-label="Speaker Volume"
-                        id="speaker_volume">
-                    <button class="btn btn-primary" type="button"
-                        onclick="send_at_command(`AT+VGS=${document.getElementById('speaker_volume').value}`)">Set</button>
-                </div>
-            </div>
-            <div class="col-auto">
-                <label class="form-label">Mic Volume</label>
-                <div class="input-group mb-3 col-auto">
-                    <input type="text" class="form-control" placeholder="0 - 15" aria-label="Mic Volume"
-                        id="mic_volume">
-                    <button class="btn btn-primary" type="button"
-                        onclick="send_at_command(`AT+VGM=${document.getElementById('mic_volume').value}`)">Set</button>
-                </div>
-            </div>
-        </div>
-
-        <button class="btn btn-primary" onclick="send_at_command('ATA')">Answer</button>
-        <button class="btn btn-primary" onclick="send_at_command('AT+CHUP')">Hang Up</button>
-        <button class="btn btn-primary" onclick="send_at_command('AT+BLDN')">Redial</button>
-        <button class="btn btn-primary" onclick="send({ type: 'query_call'})">Get Call Status</button>
-
-        <br><br>
-
-        <button class="btn btn-primary" onclick="send_at_command('AT+BVRA=1')">Start Voice Assistant</button>
-        <button class="btn btn-primary" onclick="send_at_command('AT+BVRA=0')">Stop Voice Assistant</button>
+label {
+    display: block;
+}
 
+input, label {
+    margin: .4rem 0;
+}
+        </style>
+    </head>
+    <body>
+        Server Port <input id="port" type="text" value="8989"></input> <button onclick="connect()">Connect</button><br>
+        AT Command <input type="text" id="at_command" required size="10"> <button onclick="send_at_command()">Send</button><br>
+        Dial Phone Number <input type="text" id="dial_number" required size="10"> <button onclick="dial()">Dial</button><br>
+        <button onclick="answer()">Answer</button>
+        <button onclick="hangup()">Hang Up</button>
+        <button onclick="start_voice_assistant()">Start Voice Assistant</button>
+        <button onclick="stop_voice_assistant()">Stop Voice Assistant</button>
         <hr>
-
-        <div id="socketStateContainer" class="bg-body-tertiary p-3 rounded-2">
-            <h3>Log</h3>
-            <code id="log" style="white-space: pre-line;"></code>
-        </div>
-    </div>
-
-
-    <script>
+        <div id="socketState"></div>
+        <script>
         let portInput = document.getElementById("port")
         let atCommandInput = document.getElementById("at_command")
-        let log = document.getElementById("log")
+        let dialNumberInput = document.getElementById("dial_number")
+        let socketState = document.getElementById("socketState")
         let socket
 
         function connect() {
             socket = new WebSocket(`ws://localhost:${portInput.value}`);
             socket.onopen = _ => {
-                log.textContent += 'OPEN\n'
+                socketState.innerText = 'OPEN'
             }
             socket.onclose = _ => {
-                log.textContent += 'CLOSED\n'
+                socketState.innerText = 'CLOSED'
             }
             socket.onerror = (error) => {
-                log.textContent += 'ERROR\n'
+                socketState.innerText = 'ERROR'
                 console.log(`ERROR: ${error}`)
             }
-            socket.onmessage = (event) => {
-                log.textContent += `<-- ${event.data}\n`
-                let volume_state = JSON.parse(event.data)
-                volumeSetting.value = volume_state.volume_setting
-                changeCounter.value = volume_state.change_counter
-                muted.checked = volume_state.muted ? true : false
-            }
         }
 
         function send(message) {
             if (socket && socket.readyState == WebSocket.OPEN) {
-                let jsonMessage = JSON.stringify(message)
-                log.textContent += `--> ${jsonMessage}\n`
-                socket.send(jsonMessage)
-            } else {
-                log.textContent += 'NOT CONNECTED\n'
+                socket.send(JSON.stringify(message))
             }
         }
 
-        function send_at_command(command) {
-            send({ type: 'at_command', 'command': command })
+        function send_at_command() {
+            send({ type:'at_command', command: atCommandInput.value })
         }
-    </script>
-    </div>
-</body>
 
-</html>
+        function answer() {
+            send({ type:'at_command', command: 'ATA' })
+        }
+
+        function hangup() {
+            send({ type:'at_command', command: 'AT+CHUP' })
+        }
+
+        function dial() {
+            send({ type:'at_command', command: `ATD${dialNumberInput.value}` })
+        }
+
+        function start_voice_assistant() {
+            send(({ type:'at_command', command: 'AT+BVRA=1' }))
+        }
+
+        function stop_voice_assistant() {
+            send(({ type:'at_command', command: 'AT+BVRA=0' }))
+        }
+</script>
+    </body>
+</html>

examples/keyboard.py

@@ -416,7 +416,7 @@ async def keyboard_device(device, command):
 
 
 # -----------------------------------------------------------------------------
-async def main() -> None:
+async def main():
     if len(sys.argv) < 4:
         print(
             'Usage: python keyboard.py <device-config> <transport-spec> <command>'
@@ -434,11 +434,9 @@ async def main() -> None:
         )
         return
 
-    async with await open_transport_or_link(sys.argv[2]) as hci_transport:
+    async with await open_transport_or_link(sys.argv[2]) as (hci_source, hci_sink):
         # Create a device to manage the host
-        device = Device.from_config_file_with_hci(
-            sys.argv[1], hci_transport.source, hci_transport.sink
-        )
+        device = Device.from_config_file_with_hci(sys.argv[1], hci_source, hci_sink)
 
         command = sys.argv[3]
         if command == 'connect':

examples/leaudio.json

@@ -2,6 +2,5 @@
     "name": "Bumble-LEA",
     "keystore": "JsonKeyStore",
     "address": "F0:F1:F2:F3:F4:FA",
-    "class_of_device": 2376708,
     "advertising_interval": 100
 }

examples/leaudio_with_classic.json

@@ -1,9 +0,0 @@
-{
-    "name": "Bumble-LEA",
-    "keystore": "JsonKeyStore",
-    "address": "F0:F1:F2:F3:F4:FA",
-    "classic_enabled": true,
-    "cis_enabled": true,
-    "class_of_device": 2376708,
-    "advertising_interval": 100
-}

examples/run_a2dp_info.py

@@ -139,20 +139,18 @@ async def find_a2dp_service(connection):
 
 
 # -----------------------------------------------------------------------------
-async def main() -> None:
+async def main():
     if len(sys.argv) < 4:
         print('Usage: run_a2dp_info.py <device-config> <transport-spec> <bt-addr>')
         print('example: run_a2dp_info.py classic1.json usb:0 14:7D:DA:4E:53:A8')
         return
 
     print('<<< connecting to HCI...')
-    async with await open_transport_or_link(sys.argv[2]) as hci_transport:
+    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_transport.source, hci_transport.sink
-        )
+        device = Device.from_config_file_with_hci(sys.argv[1], hci_source, hci_sink)
         device.classic_enabled = True
 
         # Start the controller
@@ -189,7 +187,7 @@ async def main() -> None:
         client = await AVDTP_Protocol.connect(connection, avdtp_version)
 
         # Discover all endpoints on the remote device
-        endpoints = list(await client.discover_remote_endpoints())
+        endpoints = await client.discover_remote_endpoints()
         print(f'@@@ Found {len(endpoints)} endpoints')
         for endpoint in endpoints:
             print('@@@', endpoint)

examples/run_a2dp_sink.py

@@ -19,7 +19,6 @@ import asyncio
 import sys
 import os
 import logging
-from typing import Any, Dict
 
 from bumble.device import Device
 from bumble.transport import open_transport_or_link
@@ -42,7 +41,7 @@ from bumble.a2dp import (
     SbcMediaCodecInformation,
 )
 
-Context: Dict[Any, Any] = {'output': None}
+Context = {'output': None}
 
 
 # -----------------------------------------------------------------------------
@@ -105,7 +104,7 @@ def on_rtp_packet(packet):
 
 
 # -----------------------------------------------------------------------------
-async def main() -> None:
+async def main():
     if len(sys.argv) < 4:
         print(
             'Usage: run_a2dp_sink.py <device-config> <transport-spec> <sbc-file> '
@@ -115,16 +114,14 @@ async def main() -> None:
         return
 
     print('<<< connecting to HCI...')
-    async with await open_transport_or_link(sys.argv[2]) as hci_transport:
+    async with await open_transport_or_link(sys.argv[2]) as (hci_source, hci_sink):
         print('<<< connected')
 
         with open(sys.argv[3], 'wb') as sbc_file:
             Context['output'] = sbc_file
 
             # Create a device
-            device = Device.from_config_file_with_hci(
-                sys.argv[1], hci_transport.source, hci_transport.sink
-            )
+            device = Device.from_config_file_with_hci(sys.argv[1], hci_source, hci_sink)
             device.classic_enabled = True
 
             # Setup the SDP to expose the sink service
@@ -165,7 +162,7 @@ async def main() -> None:
                 await device.set_discoverable(True)
                 await device.set_connectable(True)
 
-            await hci_transport.source.wait_for_termination()
+            await hci_source.wait_for_termination()
 
 
 # -----------------------------------------------------------------------------

examples/run_a2dp_source.py

@@ -74,7 +74,7 @@ def codec_capabilities():
 # -----------------------------------------------------------------------------
 def on_avdtp_connection(read_function, protocol):
     packet_source = SbcPacketSource(
-        read_function, protocol.l2cap_channel.peer_mtu, codec_capabilities()
+        read_function, protocol.l2cap_channel.mtu, codec_capabilities()
     )
     packet_pump = MediaPacketPump(packet_source.packets)
     protocol.add_source(packet_source.codec_capabilities, packet_pump)
@@ -98,7 +98,7 @@ async def stream_packets(read_function, protocol):
 
     # Stream the packets
     packet_source = SbcPacketSource(
-        read_function, protocol.l2cap_channel.peer_mtu, codec_capabilities()
+        read_function, protocol.l2cap_channel.mtu, codec_capabilities()
     )
     packet_pump = MediaPacketPump(packet_source.packets)
     source = protocol.add_source(packet_source.codec_capabilities, packet_pump)
@@ -114,7 +114,7 @@ async def stream_packets(read_function, protocol):
 
 
 # -----------------------------------------------------------------------------
-async def main() -> None:
+async def main():
     if len(sys.argv) < 4:
         print(
             'Usage: run_a2dp_source.py <device-config> <transport-spec> <sbc-file> '
@@ -126,13 +126,11 @@ async def main() -> None:
         return
 
     print('<<< connecting to HCI...')
-    async with await open_transport_or_link(sys.argv[2]) as hci_transport:
+    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_transport.source, hci_transport.sink
-        )
+        device = Device.from_config_file_with_hci(sys.argv[1], hci_source, hci_sink)
         device.classic_enabled = True
 
         # Setup the SDP to expose the SRC service
@@ -188,7 +186,7 @@ async def main() -> None:
                 await device.set_discoverable(True)
                 await device.set_connectable(True)
 
-            await hci_transport.source.wait_for_termination()
+            await hci_source.wait_for_termination()
 
 
 # -----------------------------------------------------------------------------

examples/run_advertiser.py

@@ -19,16 +19,14 @@ import asyncio
 import logging
 import sys
 import os
-import struct
-
-from bumble.core import AdvertisingData
 from bumble.device import AdvertisingType, Device
 from bumble.hci import Address
+
 from bumble.transport import open_transport_or_link
 
 
 # -----------------------------------------------------------------------------
-async def main() -> None:
+async def main():
     if len(sys.argv) < 3:
         print(
             'Usage: run_advertiser.py <config-file> <transport-spec> [type] [address]'
@@ -50,25 +48,13 @@ async def main() -> None:
         target = None
 
     print('<<< connecting to HCI...')
-    async with await open_transport_or_link(sys.argv[2]) as hci_transport:
+    async with await open_transport_or_link(sys.argv[2]) as (hci_source, hci_sink):
         print('<<< connected')
 
-        device = Device.from_config_file_with_hci(
-            sys.argv[1], hci_transport.source, hci_transport.sink
-        )
-
-        if advertising_type.is_scannable:
-            device.scan_response_data = bytes(
-                AdvertisingData(
-                    [
-                        (AdvertisingData.APPEARANCE, struct.pack('<H', 0x0340)),
-                    ]
-                )
-            )
-
+        device = Device.from_config_file_with_hci(sys.argv[1], hci_source, hci_sink)
         await device.power_on()
         await device.start_advertising(advertising_type=advertising_type, target=target)
-        await hci_transport.source.wait_for_termination()
+        await hci_source.wait_for_termination()
 
 
 # -----------------------------------------------------------------------------

examples/run_asha_sink.py

@@ -49,7 +49,7 @@ ASHA_LE_PSM_OUT_CHARACTERISTIC = UUID(
 
 
 # -----------------------------------------------------------------------------
-async def main() -> None:
+async def main():
     if len(sys.argv) != 4:
         print(
             'Usage: python run_asha_sink.py <device-config> <transport-spec> '
@@ -60,10 +60,8 @@ async def main() -> None:
 
     audio_out = open(sys.argv[3], 'wb')
 
-    async with await open_transport_or_link(sys.argv[2]) as hci_transport:
-        device = Device.from_config_file_with_hci(
-            sys.argv[1], hci_transport.source, hci_transport.sink
-        )
+    async with await open_transport_or_link(sys.argv[2]) as (hci_source, hci_sink):
+        device = Device.from_config_file_with_hci(sys.argv[1], hci_source, hci_sink)
 
         # Handler for audio control commands
         def on_audio_control_point_write(_connection, value):
@@ -199,7 +197,7 @@ async def main() -> None:
         await device.power_on()
         await device.start_advertising(auto_restart=True)
 
-        await hci_transport.source.wait_for_termination()
+        await hci_source.wait_for_termination()
 
 
 # -----------------------------------------------------------------------------

examples/run_avrcp.py

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

examples/run_cig_setup.py

@@ -22,11 +22,10 @@ import os
 from bumble.device import (
     Device,
     Connection,
-    AdvertisingParameters,
-    AdvertisingEventProperties,
 )
 from bumble.hci import (
     OwnAddressType,
+    HCI_LE_Set_Extended_Advertising_Parameters_Command,
 )
 
 from bumble.transport import open_transport_or_link
@@ -62,7 +61,12 @@ async def main() -> None:
     devices[1].cis_enabled = True
 
     await asyncio.gather(*[device.power_on() for device in devices])
-    advertising_set = await devices[0].create_advertising_set()
+    await devices[0].start_extended_advertising(
+        advertising_properties=(
+            HCI_LE_Set_Extended_Advertising_Parameters_Command.AdvertisingProperties.CONNECTABLE_ADVERTISING
+        ),
+        own_address_type=OwnAddressType.PUBLIC,
+    )
 
     connection = await devices[1].connect(
         devices[0].public_address, own_address_type=OwnAddressType.PUBLIC

examples/run_classic_connect.py

@@ -32,7 +32,7 @@ from bumble.sdp import (
 
 
 # -----------------------------------------------------------------------------
-async def main() -> None:
+async def main():
     if len(sys.argv) < 3:
         print(
             'Usage: run_classic_connect.py <device-config> <transport-spec> '
@@ -42,13 +42,11 @@ async def main() -> None:
         return
 
     print('<<< connecting to HCI...')
-    async with await open_transport_or_link(sys.argv[2]) as hci_transport:
+    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_transport.source, hci_transport.sink
-        )
+        device = Device.from_config_file_with_hci(sys.argv[1], hci_source, hci_sink)
         device.classic_enabled = True
         device.le_enabled = False
         await device.power_on()

examples/run_classic_discoverable.py

@@ -91,20 +91,18 @@ SDP_SERVICE_RECORDS = {
 
 
 # -----------------------------------------------------------------------------
-async def main() -> None:
+async def main():
     if len(sys.argv) < 3:
         print('Usage: run_classic_discoverable.py <device-config> <transport-spec>')
         print('example: run_classic_discoverable.py classic1.json usb:04b4:f901')
         return
 
     print('<<< connecting to HCI...')
-    async with await open_transport_or_link(sys.argv[2]) as hci_transport:
+    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_transport.source, hci_transport.sink
-        )
+        device = Device.from_config_file_with_hci(sys.argv[1], hci_source, hci_sink)
         device.classic_enabled = True
         device.sdp_service_records = SDP_SERVICE_RECORDS
         await device.power_on()
@@ -113,7 +111,7 @@ async def main() -> None:
         await device.set_discoverable(True)
         await device.set_connectable(True)
 
-        await hci_transport.source.wait_for_termination()
+        await hci_source.wait_for_termination()
 
 
 # -----------------------------------------------------------------------------

examples/run_classic_discovery.py

@@ -20,8 +20,8 @@ import sys
 import os
 import logging
 from bumble.colors import color
+
 from bumble.device import Device
-from bumble.hci import Address
 from bumble.transport import open_transport_or_link
 from bumble.core import DeviceClass
 
@@ -53,27 +53,22 @@ class DiscoveryListener(Device.Listener):
 
 
 # -----------------------------------------------------------------------------
-async def main() -> None:
+async def main():
     if len(sys.argv) != 2:
         print('Usage: run_classic_discovery.py <transport-spec>')
         print('example: run_classic_discovery.py usb:04b4:f901')
         return
 
     print('<<< connecting to HCI...')
-    async with await open_transport_or_link(sys.argv[1]) as hci_transport:
+    async with await open_transport_or_link(sys.argv[1]) as (hci_source, hci_sink):
         print('<<< connected')
 
-        device = Device.with_hci(
-            'Bumble',
-            Address('F0:F1:F2:F3:F4:F5'),
-            hci_transport.source,
-            hci_transport.sink,
-        )
+        device = Device.with_hci('Bumble', 'F0:F1:F2:F3:F4:F5', hci_source, hci_sink)
         device.listener = DiscoveryListener()
         await device.power_on()
         await device.start_discovery()
 
-        await hci_transport.source.wait_for_termination()
+        await hci_source.wait_for_termination()
 
 
 # -----------------------------------------------------------------------------

examples/run_connect_and_encrypt.py

@@ -25,7 +25,7 @@ from bumble.transport import open_transport_or_link
 
 
 # -----------------------------------------------------------------------------
-async def main() -> None:
+async def main():
     if len(sys.argv) < 3:
         print(
             'Usage: run_connect_and_encrypt.py <device-config> <transport-spec> '
@@ -37,13 +37,11 @@ async def main() -> None:
         return
 
     print('<<< connecting to HCI...')
-    async with await open_transport_or_link(sys.argv[2]) as hci_transport:
+    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_transport.source, hci_transport.sink
-        )
+        device = Device.from_config_file_with_hci(sys.argv[1], hci_source, hci_sink)
         await device.power_on()
 
         # Connect to the peer
@@ -58,7 +56,7 @@ async def main() -> None:
             print(f'!!! Encryption failed: {error}')
             return
 
-        await hci_transport.source.wait_for_termination()
+        await hci_source.wait_for_termination()
 
 
 # -----------------------------------------------------------------------------

examples/run_controller.py

@@ -36,7 +36,7 @@ from bumble.transport import open_transport_or_link
 
 
 # -----------------------------------------------------------------------------
-async def main() -> None:
+async def main():
     if len(sys.argv) != 4:
         print(
             'Usage: run_controller.py <controller-address> <device-config> '
@@ -49,7 +49,7 @@ async def main() -> None:
         return
 
     print('>>> connecting to HCI...')
-    async with await open_transport_or_link(sys.argv[3]) as hci_transport:
+    async with await open_transport_or_link(sys.argv[3]) as (hci_source, hci_sink):
         print('>>> connected')
 
         # Create a local link
@@ -57,10 +57,7 @@ async def main() -> None:
 
         # Create a first controller using the packet source/sink as its host interface
         controller1 = Controller(
-            'C1',
-            host_source=hci_transport.source,
-            host_sink=hci_transport.sink,
-            link=link,
+            'C1', host_source=hci_source, host_sink=hci_sink, link=link
         )
         controller1.random_address = sys.argv[1]
 
@@ -101,7 +98,7 @@ async def main() -> None:
         await device.start_advertising()
         await device.start_scanning()
 
-        await hci_transport.source.wait_for_termination()
+        await hci_source.wait_for_termination()
 
 
 # -----------------------------------------------------------------------------

examples/run_controller_with_scanner.py

@@ -20,9 +20,9 @@ import asyncio
 import sys
 import os
 from bumble.colors import color
+
 from bumble.device import Device
 from bumble.controller import Controller
-from bumble.hci import Address
 from bumble.link import LocalLink
 from bumble.transport import open_transport_or_link
 
@@ -45,14 +45,14 @@ class ScannerListener(Device.Listener):
 
 
 # -----------------------------------------------------------------------------
-async def main() -> None:
+async def main():
     if len(sys.argv) != 2:
         print('Usage: run_controller.py <transport-spec>')
         print('example: run_controller_with_scanner.py serial:/dev/pts/14,1000000')
         return
 
     print('>>> connecting to HCI...')
-    async with await open_transport_or_link(sys.argv[1]) as hci_transport:
+    async with await open_transport_or_link(sys.argv[1]) as (hci_source, hci_sink):
         print('>>> connected')
 
         # Create a local link
@@ -60,25 +60,22 @@ async def main() -> None:
 
         # Create a first controller using the packet source/sink as its host interface
         controller1 = Controller(
-            'C1',
-            host_source=hci_transport.source,
-            host_sink=hci_transport.sink,
-            link=link,
-            public_address='E0:E1:E2:E3:E4:E5',
+            'C1', host_source=hci_source, host_sink=hci_sink, link=link
         )
+        controller1.address = 'E0:E1:E2:E3:E4:E5'
 
         # Create a second controller using the same link
         controller2 = Controller('C2', link=link)
 
         # Create a device with a scanner listener
         device = Device.with_hci(
-            'Bumble', Address('F0:F1:F2:F3:F4:F5'), controller2, controller2
+            'Bumble', 'F0:F1:F2:F3:F4:F5', controller2, controller2
         )
         device.listener = ScannerListener()
         await device.power_on()
         await device.start_scanning()
 
-        await hci_transport.source.wait_for_termination()
+        await hci_source.wait_for_termination()
 
 
 # -----------------------------------------------------------------------------

examples/run_csis_servers.py

@@ -98,7 +98,13 @@ async def main() -> None:
             )
             + csis.get_advertising_data()
         )
-        await device.create_advertising_set(advertising_data=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]

examples/run_device_with_snooper.py

@@ -20,36 +20,30 @@ import sys
 import os
 import logging
 from bumble.colors import color
-from bumble.hci import Address
+
 from bumble.device import Device
 from bumble.transport import open_transport_or_link
 from bumble.snoop import BtSnooper
 
-
 # -----------------------------------------------------------------------------
-async def main() -> None:
+async def main():
     if len(sys.argv) != 3:
         print('Usage: run_device_with_snooper.py <transport-spec> <snoop-file>')
         print('example: run_device_with_snooper.py usb:0 btsnoop.log')
         return
 
     print('<<< connecting to HCI...')
-    async with await open_transport_or_link(sys.argv[1]) as hci_transport:
+    async with await open_transport_or_link(sys.argv[1]) as (hci_source, hci_sink):
         print('<<< connected')
 
-        device = Device.with_hci(
-            'Bumble',
-            Address('F0:F1:F2:F3:F4:F5'),
-            hci_transport.source,
-            hci_transport.sink,
-        )
+        device = Device.with_hci('Bumble', 'F0:F1:F2:F3:F4:F5', hci_source, hci_sink)
 
         with open(sys.argv[2], "wb") as snoop_file:
             device.host.snooper = BtSnooper(snoop_file)
             await device.power_on()
             await device.start_scanning()
 
-            await hci_transport.source.wait_for_termination()
+            await hci_source.wait_for_termination()
 
 
 # -----------------------------------------------------------------------------

examples/run_extended_advertiser.py

@@ -19,13 +19,8 @@ import asyncio
 import logging
 import sys
 import os
-from bumble.device import (
-    AdvertisingParameters,
-    AdvertisingEventProperties,
-    AdvertisingType,
-    Device,
-)
-from bumble.hci import Address
+from bumble.device import AdvertisingType, Device
+from bumble.hci import Address, HCI_LE_Set_Extended_Advertising_Parameters_Command
 
 from bumble.transport import open_transport_or_link
 
@@ -40,16 +35,20 @@ async def main() -> None:
         return
 
     if len(sys.argv) >= 4:
-        advertising_properties = AdvertisingEventProperties.from_advertising_type(
-            AdvertisingType(int(sys.argv[3]))
+        advertising_properties = (
+            HCI_LE_Set_Extended_Advertising_Parameters_Command.AdvertisingProperties(
+                int(sys.argv[3])
+            )
         )
     else:
-        advertising_properties = AdvertisingEventProperties()
+        advertising_properties = (
+            HCI_LE_Set_Extended_Advertising_Parameters_Command.AdvertisingProperties.CONNECTABLE_ADVERTISING
+        )
 
     if len(sys.argv) >= 5:
-        peer_address = Address(sys.argv[4])
+        target = Address(sys.argv[4])
     else:
-        peer_address = Address.ANY
+        target = Address.ANY
 
     print('<<< connecting to HCI...')
     async with await open_transport_or_link(sys.argv[2]) as hci_transport:
@@ -59,11 +58,8 @@ async def main() -> None:
             sys.argv[1], hci_transport.source, hci_transport.sink
         )
         await device.power_on()
-        await device.create_advertising_set(
-            advertising_parameters=AdvertisingParameters(
-                advertising_event_properties=advertising_properties,
-                peer_address=peer_address,
-            )
+        await device.start_extended_advertising(
+            advertising_properties=advertising_properties, target=target
         )
         await hci_transport.source.terminated
 

examples/run_extended_advertiser_2.py

@@ -1,99 +0,0 @@
-# Copyright 2021-2024 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
-from bumble.device import AdvertisingParameters, AdvertisingEventProperties, Device
-from bumble.hci import Address
-from bumble.core import AdvertisingData
-from bumble.transport import open_transport_or_link
-
-
-# -----------------------------------------------------------------------------
-async def main() -> None:
-    if len(sys.argv) < 3:
-        print('Usage: run_extended_advertiser_2.py <config-file> <transport-spec>')
-        print('example: run_extended_advertiser_2.py device1.json usb:0')
-        return
-
-    print('<<< connecting to HCI...')
-    async with await open_transport_or_link(sys.argv[2]) as hci_transport:
-        print('<<< connected')
-
-        device = Device.from_config_file_with_hci(
-            sys.argv[1], hci_transport.source, hci_transport.sink
-        )
-        await device.power_on()
-
-        if not device.supports_le_extended_advertising:
-            print("Device does not support extended advertising")
-            return
-
-        print("Max advertising sets:", device.host.number_of_supported_advertising_sets)
-        print(
-            "Max advertising data length:", device.host.maximum_advertising_data_length
-        )
-
-        if device.host.number_of_supported_advertising_sets >= 1:
-            advertising_data1 = AdvertisingData(
-                [(AdvertisingData.COMPLETE_LOCAL_NAME, "Bumble 1".encode("utf-8"))]
-            )
-
-            set1 = await device.create_advertising_set(
-                advertising_data=bytes(advertising_data1),
-            )
-            print("Selected TX power 1:", set1.selected_tx_power)
-
-            advertising_data2 = AdvertisingData(
-                [(AdvertisingData.COMPLETE_LOCAL_NAME, "Bumble 2".encode("utf-8"))]
-            )
-
-        if device.host.number_of_supported_advertising_sets >= 2:
-            set2 = await device.create_advertising_set(
-                random_address=Address("F0:F0:F0:F0:F0:F1"),
-                advertising_parameters=AdvertisingParameters(),
-                advertising_data=bytes(advertising_data2),
-                auto_start=False,
-                auto_restart=True,
-            )
-            print("Selected TX power 2:", set2.selected_tx_power)
-            await set2.start()
-
-        if device.host.number_of_supported_advertising_sets >= 3:
-            scan_response_data3 = AdvertisingData(
-                [(AdvertisingData.COMPLETE_LOCAL_NAME, "Bumble 3".encode("utf-8"))]
-            )
-
-            set3 = await device.create_advertising_set(
-                random_address=Address("F0:F0:F0:F0:F0:F2"),
-                advertising_parameters=AdvertisingParameters(
-                    advertising_event_properties=AdvertisingEventProperties(
-                        is_connectable=False, is_scannable=True
-                    )
-                ),
-                scan_response_data=bytes(scan_response_data3),
-            )
-            print("Selected TX power 3:", set2.selected_tx_power)
-
-        await hci_transport.source.terminated
-
-
-# -----------------------------------------------------------------------------
-logging.basicConfig(level=os.environ.get('BUMBLE_LOGLEVEL', 'DEBUG').upper())
-asyncio.run(main())

examples/run_gatt_client.py

@@ -69,7 +69,7 @@ class Listener(Device.Listener):
 
 
 # -----------------------------------------------------------------------------
-async def main() -> None:
+async def main():
     if len(sys.argv) < 3:
         print(
             'Usage: run_gatt_client.py <device-config> <transport-spec> '
@@ -79,13 +79,11 @@ async def main() -> None:
         return
 
     print('<<< connecting to HCI...')
-    async with await open_transport_or_link(sys.argv[2]) as hci_transport:
+    async with await open_transport_or_link(sys.argv[2]) as (hci_source, hci_sink):
         print('<<< connected')
 
         # Create a device to manage the host, with a custom listener
-        device = Device.from_config_file_with_hci(
-            sys.argv[1], hci_transport.source, hci_transport.sink
-        )
+        device = Device.from_config_file_with_hci(sys.argv[1], hci_source, hci_sink)
         device.listener = Listener(device)
         await device.power_on()
 

examples/run_gatt_client_and_server.py

@@ -19,21 +19,21 @@ import asyncio
 import os
 import logging
 from bumble.colors import color
+
 from bumble.core import ProtocolError
 from bumble.controller import Controller
 from bumble.device import Device, Peer
-from bumble.hci import Address
 from bumble.host import Host
 from bumble.link import LocalLink
 from bumble.gatt import (
     Service,
     Characteristic,
     Descriptor,
+    show_services,
     GATT_CHARACTERISTIC_USER_DESCRIPTION_DESCRIPTOR,
     GATT_MANUFACTURER_NAME_STRING_CHARACTERISTIC,
     GATT_DEVICE_INFORMATION_SERVICE,
 )
-from bumble.gatt_client import show_services
 
 
 # -----------------------------------------------------------------------------
@@ -43,7 +43,7 @@ class ServerListener(Device.Listener):
 
 
 # -----------------------------------------------------------------------------
-async def main() -> None:
+async def main():
     # Create a local link
     link = LocalLink()
 
@@ -51,18 +51,14 @@ async def main() -> None:
     client_controller = Controller("client controller", link=link)
     client_host = Host()
     client_host.controller = client_controller
-    client_device = Device(
-        "client", address=Address('F0:F1:F2:F3:F4:F5'), host=client_host
-    )
+    client_device = Device("client", address='F0:F1:F2:F3:F4:F5', host=client_host)
     await client_device.power_on()
 
     # Setup a stack for the server
     server_controller = Controller("server controller", link=link)
     server_host = Host()
     server_host.controller = server_controller
-    server_device = Device(
-        "server", address=Address('F6:F7:F8:F9:FA:FB'), host=server_host
-    )
+    server_device = Device("server", address='F6:F7:F8:F9:FA:FB', host=server_host)
     server_device.listener = ServerListener()
     await server_device.power_on()
 

examples/run_gatt_server.py

@@ -71,7 +71,7 @@ def my_custom_write_with_error(connection, value):
 
 
 # -----------------------------------------------------------------------------
-async def main() -> None:
+async def main():
     if len(sys.argv) < 3:
         print(
             'Usage: run_gatt_server.py <device-config> <transport-spec> '
@@ -81,13 +81,11 @@ async def main() -> None:
         return
 
     print('<<< connecting to HCI...')
-    async with await open_transport_or_link(sys.argv[2]) as hci_transport:
+    async with await open_transport_or_link(sys.argv[2]) as (hci_source, hci_sink):
         print('<<< connected')
 
         # Create a device to manage the host
-        device = Device.from_config_file_with_hci(
-            sys.argv[1], hci_transport.source, hci_transport.sink
-        )
+        device = Device.from_config_file_with_hci(sys.argv[1], hci_source, hci_sink)
         device.listener = Listener(device)
 
         # Add a few entries to the device's GATT server
@@ -148,7 +146,7 @@ async def main() -> None:
         else:
             await device.start_advertising(auto_restart=True)
 
-        await hci_transport.source.wait_for_termination()
+        await hci_source.wait_for_termination()
 
 
 # -----------------------------------------------------------------------------

examples/run_hfp_gateway.py

@@ -20,48 +20,123 @@ import sys
 import os
 import logging
 
+from bumble.colors import color
+
 import bumble.core
 from bumble.device import Device
 from bumble.transport import open_transport_or_link
 from bumble.core import (
+    BT_HANDSFREE_SERVICE,
+    BT_RFCOMM_PROTOCOL_ID,
     BT_BR_EDR_TRANSPORT,
 )
 from bumble import rfcomm, hfp
 from bumble.hci import HCI_SynchronousDataPacket
+from bumble.sdp import (
+    Client as SDP_Client,
+    DataElement,
+    ServiceAttribute,
+    SDP_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID,
+    SDP_SERVICE_CLASS_ID_LIST_ATTRIBUTE_ID,
+    SDP_BLUETOOTH_PROFILE_DESCRIPTOR_LIST_ATTRIBUTE_ID,
+)
 
 
 logger = logging.getLogger(__name__)
 
 
-def _default_configuration() -> hfp.AgConfiguration:
-    return hfp.AgConfiguration(
-        supported_ag_features=[
-            hfp.AgFeature.HF_INDICATORS,
-            hfp.AgFeature.IN_BAND_RING_TONE_CAPABILITY,
-            hfp.AgFeature.REJECT_CALL,
-            hfp.AgFeature.CODEC_NEGOTIATION,
-            hfp.AgFeature.ESCO_S4_SETTINGS_SUPPORTED,
+# -----------------------------------------------------------------------------
+# pylint: disable-next=too-many-nested-blocks
+async def list_rfcomm_channels(device, connection):
+    # Connect to the SDP Server
+    sdp_client = SDP_Client(connection)
+    await sdp_client.connect()
+
+    # Search for services that support the Handsfree Profile
+    search_result = await sdp_client.search_attributes(
+        [BT_HANDSFREE_SERVICE],
+        [
+            SDP_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID,
+            SDP_BLUETOOTH_PROFILE_DESCRIPTOR_LIST_ATTRIBUTE_ID,
+            SDP_SERVICE_CLASS_ID_LIST_ATTRIBUTE_ID,
         ],
-        supported_ag_indicators=[
-            hfp.AgIndicatorState.call(),
-            hfp.AgIndicatorState.service(),
-            hfp.AgIndicatorState.callsetup(),
-            hfp.AgIndicatorState.callsetup(),
-            hfp.AgIndicatorState.signal(),
-            hfp.AgIndicatorState.roam(),
-            hfp.AgIndicatorState.battchg(),
-        ],
-        supported_hf_indicators=[
-            hfp.HfIndicator.ENHANCED_SAFETY,
-            hfp.HfIndicator.BATTERY_LEVEL,
-        ],
-        supported_ag_call_hold_operations=[],
-        supported_audio_codecs=[hfp.AudioCodec.CVSD, hfp.AudioCodec.MSBC],
     )
+    print(color('==================================', 'blue'))
+    print(color('Handsfree Services:', 'yellow'))
+    rfcomm_channels = []
+    # pylint: disable-next=too-many-nested-blocks
+    for attribute_list in search_result:
+        # Look for the RFCOMM Channel number
+        protocol_descriptor_list = ServiceAttribute.find_attribute_in_list(
+            attribute_list, SDP_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID
+        )
+        if protocol_descriptor_list:
+            for protocol_descriptor in protocol_descriptor_list.value:
+                if len(protocol_descriptor.value) >= 2:
+                    if protocol_descriptor.value[0].value == BT_RFCOMM_PROTOCOL_ID:
+                        print(color('SERVICE:', 'green'))
+                        print(
+                            color('  RFCOMM Channel:', 'cyan'),
+                            protocol_descriptor.value[1].value,
+                        )
+                        rfcomm_channels.append(protocol_descriptor.value[1].value)
+
+                        # List profiles
+                        bluetooth_profile_descriptor_list = (
+                            ServiceAttribute.find_attribute_in_list(
+                                attribute_list,
+                                SDP_BLUETOOTH_PROFILE_DESCRIPTOR_LIST_ATTRIBUTE_ID,
+                            )
+                        )
+                        if bluetooth_profile_descriptor_list:
+                            if bluetooth_profile_descriptor_list.value:
+                                if (
+                                    bluetooth_profile_descriptor_list.value[0].type
+                                    == DataElement.SEQUENCE
+                                ):
+                                    bluetooth_profile_descriptors = (
+                                        bluetooth_profile_descriptor_list.value
+                                    )
+                                else:
+                                    # Sometimes, instead of a list of lists, we just
+                                    # find a list. Fix that
+                                    bluetooth_profile_descriptors = [
+                                        bluetooth_profile_descriptor_list
+                                    ]
+
+                                print(color('  Profiles:', 'green'))
+                                for (
+                                    bluetooth_profile_descriptor
+                                ) in bluetooth_profile_descriptors:
+                                    version_major = (
+                                        bluetooth_profile_descriptor.value[1].value >> 8
+                                    )
+                                    version_minor = (
+                                        bluetooth_profile_descriptor.value[1].value
+                                        & 0xFF
+                                    )
+                                    print(
+                                        '    '
+                                        f'{bluetooth_profile_descriptor.value[0].value}'
+                                        f' - version {version_major}.{version_minor}'
+                                    )
+
+                        # List service classes
+                        service_class_id_list = ServiceAttribute.find_attribute_in_list(
+                            attribute_list, SDP_SERVICE_CLASS_ID_LIST_ATTRIBUTE_ID
+                        )
+                        if service_class_id_list:
+                            if service_class_id_list.value:
+                                print(color('  Service Classes:', 'green'))
+                                for service_class_id in service_class_id_list.value:
+                                    print('   ', service_class_id.value)
+
+    await sdp_client.disconnect()
+    return rfcomm_channels
 
 
 # -----------------------------------------------------------------------------
-async def main() -> None:
+async def main():
     if len(sys.argv) < 4:
         print(
             'Usage: run_hfp_gateway.py <device-config> <transport-spec> '
@@ -74,13 +149,11 @@ async def main() -> None:
         return
 
     print('<<< connecting to HCI...')
-    async with await open_transport_or_link(sys.argv[2]) as hci_transport:
+    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_transport.source, hci_transport.sink
-        )
+        device = Device.from_config_file_with_hci(sys.argv[1], hci_source, hci_sink)
         device.classic_enabled = True
         await device.power_on()
 
@@ -91,14 +164,13 @@ async def main() -> None:
         print(f'=== Connected to {connection.peer_address}!')
 
         # Get a list of all the Handsfree services (should only be 1)
-        if not (hfp_record := await hfp.find_hf_sdp_record(connection)):
+        channels = await list_rfcomm_channels(device, connection)
+        if len(channels) == 0:
             print('!!! no service found')
             return
 
         # Pick the first one
-        channel, version, hf_sdp_features = hfp_record
-        print(f'HF version: {version}')
-        print(f'HF features: {hf_sdp_features}')
+        channel = channels[0]
 
         # Request authentication
         print('*** Authenticating...')
@@ -133,9 +205,51 @@ async def main() -> None:
 
         device.host.on('sco_packet', on_sco)
 
-        ag_protocol = hfp.AgProtocol(session, _default_configuration())
+        # Protocol loop (just for testing at this point)
+        protocol = hfp.HfpProtocol(session)
+        while True:
+            line = await protocol.next_line()
 
-        await hci_transport.source.terminated
+            if line.startswith('AT+BRSF='):
+                protocol.send_response_line('+BRSF: 30')
+                protocol.send_response_line('OK')
+            elif line.startswith('AT+CIND=?'):
+                protocol.send_response_line(
+                    '+CIND: ("call",(0,1)),("callsetup",(0-3)),("service",(0-1)),'
+                    '("signal",(0-5)),("roam",(0,1)),("battchg",(0-5)),'
+                    '("callheld",(0-2))'
+                )
+                protocol.send_response_line('OK')
+            elif line.startswith('AT+CIND?'):
+                protocol.send_response_line('+CIND: 0,0,1,4,1,5,0')
+                protocol.send_response_line('OK')
+            elif line.startswith('AT+CMER='):
+                protocol.send_response_line('OK')
+            elif line.startswith('AT+CHLD=?'):
+                protocol.send_response_line('+CHLD: 0')
+                protocol.send_response_line('OK')
+            elif line.startswith('AT+BTRH?'):
+                protocol.send_response_line('+BTRH: 0')
+                protocol.send_response_line('OK')
+            elif line.startswith('AT+CLIP='):
+                protocol.send_response_line('OK')
+            elif line.startswith('AT+VGS='):
+                protocol.send_response_line('OK')
+            elif line.startswith('AT+BIA='):
+                protocol.send_response_line('OK')
+            elif line.startswith('AT+BVRA='):
+                protocol.send_response_line(
+                    '+BVRA: 1,1,12AA,1,1,"Message 1 from Janina"'
+                )
+            elif line.startswith('AT+XEVENT='):
+                protocol.send_response_line('OK')
+            elif line.startswith('AT+XAPL='):
+                protocol.send_response_line('OK')
+            else:
+                print(color('UNSUPPORTED AT COMMAND', 'red'))
+                protocol.send_response_line('ERROR')
+
+        await hci_source.wait_for_termination()
 
 
 # -----------------------------------------------------------------------------

examples/run_hfp_handsfree.py

@@ -16,87 +16,68 @@
 # Imports
 # -----------------------------------------------------------------------------
 import asyncio
-import contextlib
 import sys
 import os
 import logging
 import json
 import websockets
-import functools
 from typing import Optional
 
-from bumble import rfcomm
-from bumble import hci
-from bumble.device import Device, Connection
+from bumble.device import Device
 from bumble.transport import open_transport_or_link
+from bumble.rfcomm import Server as RfcommServer
 from bumble import hfp
 from bumble.hfp import HfProtocol
 
-ws: Optional[websockets.WebSocketServerProtocol] = None
-hf_protocol: Optional[HfProtocol] = None
+
+# -----------------------------------------------------------------------------
+class UiServer:
+    protocol: Optional[HfProtocol] = None
+
+    async def start(self):
+        """Start a Websocket server to receive events from a web page."""
+
+        async def serve(websocket, _path):
+            while True:
+                try:
+                    message = await websocket.recv()
+                    print('Received: ', str(message))
+
+                    parsed = json.loads(message)
+                    message_type = parsed['type']
+                    if message_type == 'at_command':
+                        if self.protocol is not None:
+                            await self.protocol.execute_command(parsed['command'])
+
+                except websockets.exceptions.ConnectionClosedOK:
+                    pass
+
+        # pylint: disable=no-member
+        await websockets.serve(serve, 'localhost', 8989)
 
 
 # -----------------------------------------------------------------------------
-def on_dlc(dlc: rfcomm.DLC, configuration: hfp.HfConfiguration):
+def on_dlc(dlc, configuration: hfp.Configuration):
     print('*** DLC connected', dlc)
-    global hf_protocol
-    hf_protocol = HfProtocol(dlc, configuration)
-    asyncio.create_task(hf_protocol.run())
-
-    def on_sco_request(connection: Connection, link_type: int, protocol: HfProtocol):
-        if connection == protocol.dlc.multiplexer.l2cap_channel.connection:
-            if link_type == hci.HCI_Connection_Complete_Event.SCO_LINK_TYPE:
-                esco_parameters = hfp.ESCO_PARAMETERS[
-                    hfp.DefaultCodecParameters.SCO_CVSD_D1
-                ]
-            elif protocol.active_codec == hfp.AudioCodec.MSBC:
-                esco_parameters = hfp.ESCO_PARAMETERS[
-                    hfp.DefaultCodecParameters.ESCO_MSBC_T2
-                ]
-            elif protocol.active_codec == hfp.AudioCodec.CVSD:
-                esco_parameters = hfp.ESCO_PARAMETERS[
-                    hfp.DefaultCodecParameters.ESCO_CVSD_S4
-                ]
-            connection.abort_on(
-                'disconnection',
-                connection.device.send_command(
-                    hci.HCI_Enhanced_Accept_Synchronous_Connection_Request_Command(
-                        bd_addr=connection.peer_address, **esco_parameters.asdict()
-                    )
-                ),
-            )
-
-    handler = functools.partial(on_sco_request, protocol=hf_protocol)
-    dlc.multiplexer.l2cap_channel.connection.device.on('sco_request', handler)
-    dlc.multiplexer.l2cap_channel.once(
-        'close',
-        lambda: dlc.multiplexer.l2cap_channel.connection.device.remove_listener(
-            'sco_request', handler
-        ),
-    )
-
-    def on_ag_indicator(indicator):
-        global ws
-        if ws:
-            asyncio.create_task(ws.send(str(indicator)))
-
-    hf_protocol.on('ag_indicator', on_ag_indicator)
+    protocol = HfProtocol(dlc, configuration)
+    UiServer.protocol = protocol
+    asyncio.create_task(protocol.run())
 
 
 # -----------------------------------------------------------------------------
-async def main() -> None:
+async def main():
     if len(sys.argv) < 3:
         print('Usage: run_classic_hfp.py <device-config> <transport-spec>')
         print('example: run_classic_hfp.py classic2.json usb:04b4:f901')
         return
 
     print('<<< connecting to HCI...')
-    async with await open_transport_or_link(sys.argv[2]) as hci_transport:
+    async with await open_transport_or_link(sys.argv[2]) as (hci_source, hci_sink):
         print('<<< connected')
 
         # Hands-Free profile configuration.
         # TODO: load configuration from file.
-        configuration = hfp.HfConfiguration(
+        configuration = hfp.Configuration(
             supported_hf_features=[
                 hfp.HfFeature.THREE_WAY_CALLING,
                 hfp.HfFeature.REMOTE_VOLUME_CONTROL,
@@ -116,13 +97,11 @@ async def main() -> None:
         )
 
         # Create a device
-        device = Device.from_config_file_with_hci(
-            sys.argv[1], hci_transport.source, hci_transport.sink
-        )
+        device = Device.from_config_file_with_hci(sys.argv[1], hci_source, hci_sink)
         device.classic_enabled = True
 
         # Create and register a server
-        rfcomm_server = rfcomm.Server(device)
+        rfcomm_server = RfcommServer(device)
 
         # Listen for incoming DLC connections
         channel_number = rfcomm_server.listen(lambda dlc: on_dlc(dlc, configuration))
@@ -130,9 +109,7 @@ async def main() -> None:
 
         # Advertise the HFP RFComm channel in the SDP
         device.sdp_service_records = {
-            0x00010001: hfp.make_hf_sdp_records(
-                0x00010001, channel_number, configuration
-            )
+            0x00010001: hfp.sdp_records(0x00010001, channel_number, configuration)
         }
 
         # Let's go!
@@ -143,32 +120,10 @@ async def main() -> None:
         await device.set_connectable(True)
 
         # Start the UI websocket server to offer a few buttons and input boxes
-        async def serve(websocket: websockets.WebSocketServerProtocol, _path):
-            global ws
-            ws = websocket
-            async for message in websocket:
-                with contextlib.suppress(websockets.exceptions.ConnectionClosedOK):
-                    print('Received: ', str(message))
+        ui_server = UiServer()
+        await ui_server.start()
 
-                    parsed = json.loads(message)
-                    message_type = parsed['type']
-                    if message_type == 'at_command':
-                        if hf_protocol is not None:
-                            response = str(
-                                await hf_protocol.execute_command(
-                                    parsed['command'],
-                                    response_type=hfp.AtResponseType.MULTIPLE,
-                                )
-                            )
-                            await websocket.send(response)
-                    elif message_type == 'query_call':
-                        if hf_protocol:
-                            response = str(await hf_protocol.query_current_calls())
-                            await websocket.send(response)
-
-        await websockets.serve(serve, 'localhost', 8989)
-
-        await hci_transport.source.wait_for_termination()
+        await hci_source.wait_for_termination()
 
 
 # -----------------------------------------------------------------------------

examples/run_hid_device.py

@@ -229,7 +229,6 @@ HID_REPORT_MAP = bytes(  # Text String, 50 Octet Report Descriptor
 # Default protocol mode set to report protocol
 protocol_mode = Message.ProtocolMode.REPORT_PROTOCOL
 
-
 # -----------------------------------------------------------------------------
 def sdp_records():
     service_record_handle = 0x00010002
@@ -428,7 +427,6 @@ class DeviceData:
 # Device's live data - Mouse and Keyboard will be stored in this
 deviceData = DeviceData()
 
-
 # -----------------------------------------------------------------------------
 async def keyboard_device(hid_device):
 
@@ -489,7 +487,7 @@ async def keyboard_device(hid_device):
 
 
 # -----------------------------------------------------------------------------
-async def main() -> None:
+async def main():
     if len(sys.argv) < 3:
         print(
             'Usage: python run_hid_device.py <device-config> <transport-spec> <command>'
@@ -592,22 +590,20 @@ async def main() -> None:
     def on_set_protocol_cb(protocol: int):
         retValue = hid_device.GetSetStatus()
         # We do not support SET_PROTOCOL.
-        print(f"SET_PROTOCOL report_id: {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('Received Virtual Cable Unplug')
+        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_transport:
+    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_transport.source, hci_transport.sink
-        )
+        device = Device.from_config_file_with_hci(sys.argv[1], hci_source, hci_sink)
         device.classic_enabled = True
 
         # Create and register HID device
@@ -744,7 +740,7 @@ async def main() -> None:
             print("Executing in Web mode")
             await keyboard_device(hid_device)
 
-        await hci_transport.source.wait_for_termination()
+        await hci_source.wait_for_termination()
 
 
 # -----------------------------------------------------------------------------

examples/run_hid_host.py

@@ -275,7 +275,7 @@ async def get_stream_reader(pipe) -> asyncio.StreamReader:
 
 
 # -----------------------------------------------------------------------------
-async def main() -> None:
+async def main():
     if len(sys.argv) < 4:
         print(
             'Usage: run_hid_host.py <device-config> <transport-spec> '
@@ -324,13 +324,11 @@ async def main() -> None:
         asyncio.create_task(handle_virtual_cable_unplug())
 
     print('<<< connecting to HCI...')
-    async with await open_transport_or_link(sys.argv[2]) as hci_transport:
+    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_transport.source, hci_transport.sink
-        )
+        device = Device.from_config_file_with_hci(sys.argv[1], hci_source, hci_sink)
         device.classic_enabled = True
 
         # Create HID host and start it
@@ -559,7 +557,7 @@ async def main() -> None:
             # Interrupt Channel
             await hid_host.connect_interrupt_channel()
 
-        await hci_transport.source.wait_for_termination()
+        await hci_source.wait_for_termination()
 
 
 # -----------------------------------------------------------------------------

examples/run_notifier.py

@@ -57,20 +57,18 @@ def on_my_characteristic_subscription(peer, enabled):
 
 
 # -----------------------------------------------------------------------------
-async def main() -> None:
+async def main():
     if len(sys.argv) < 3:
         print('Usage: run_notifier.py <device-config> <transport-spec>')
         print('example: run_notifier.py device1.json usb:0')
         return
 
     print('<<< connecting to HCI...')
-    async with await open_transport_or_link(sys.argv[2]) as hci_transport:
+    async with await open_transport_or_link(sys.argv[2]) as (hci_source, hci_sink):
         print('<<< connected')
 
         # Create a device to manage the host
-        device = Device.from_config_file_with_hci(
-            sys.argv[1], hci_transport.source, hci_transport.sink
-        )
+        device = Device.from_config_file_with_hci(sys.argv[1], hci_source, hci_sink)
         device.listener = Listener(device)
 
         # Add a few entries to the device's GATT server

examples/run_rfcomm_client.py

@@ -165,7 +165,7 @@ async def tcp_server(tcp_port, rfcomm_session):
 
 
 # -----------------------------------------------------------------------------
-async def main() -> None:
+async def main():
     if len(sys.argv) < 5:
         print(
             'Usage: run_rfcomm_client.py <device-config> <transport-spec> '
@@ -178,13 +178,11 @@ async def main() -> None:
         return
 
     print('<<< connecting to HCI...')
-    async with await open_transport_or_link(sys.argv[2]) as hci_transport:
+    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_transport.source, hci_transport.sink
-        )
+        device = Device.from_config_file_with_hci(sys.argv[1], hci_source, hci_sink)
         device.classic_enabled = True
         await device.power_on()
 
@@ -194,8 +192,8 @@ async def main() -> None:
         connection = await device.connect(target_address, transport=BT_BR_EDR_TRANSPORT)
         print(f'=== Connected to {connection.peer_address}!')
 
-        channel_str = sys.argv[4]
-        if channel_str == 'discover':
+        channel = sys.argv[4]
+        if channel == 'discover':
             await list_rfcomm_channels(connection)
             return
 
@@ -215,7 +213,7 @@ async def main() -> None:
         rfcomm_mux = await rfcomm_client.start()
         print('@@@ Started')
 
-        channel = int(channel_str)
+        channel = int(channel)
         print(f'### Opening session for channel {channel}...')
         try:
             session = await rfcomm_mux.open_dlc(channel)
@@ -231,7 +229,7 @@ async def main() -> None:
             tcp_port = int(sys.argv[5])
             asyncio.create_task(tcp_server(tcp_port, session))
 
-        await hci_transport.source.wait_for_termination()
+        await hci_source.wait_for_termination()
 
 
 # -----------------------------------------------------------------------------

examples/run_rfcomm_server.py

@@ -107,7 +107,7 @@ class TcpServer:
 
 
 # -----------------------------------------------------------------------------
-async def main() -> None:
+async def main():
     if len(sys.argv) < 4:
         print(
             'Usage: run_rfcomm_server.py <device-config> <transport-spec> '
@@ -124,13 +124,11 @@ async def main() -> None:
         uuid = 'E6D55659-C8B4-4B85-96BB-B1143AF6D3AE'
 
     print('<<< connecting to HCI...')
-    async with await open_transport_or_link(sys.argv[2]) as hci_transport:
+    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_transport.source, hci_transport.sink
-        )
+        device = Device.from_config_file_with_hci(sys.argv[1], hci_source, hci_sink)
         device.classic_enabled = True
 
         # Create a TCP server
@@ -155,7 +153,7 @@ async def main() -> None:
         await device.set_discoverable(True)
         await device.set_connectable(True)
 
-        await hci_transport.source.wait_for_termination()
+        await hci_source.wait_for_termination()
 
 
 # -----------------------------------------------------------------------------

examples/run_scanner.py

@@ -20,31 +20,27 @@ import sys
 import os
 import logging
 from bumble.colors import color
-from bumble.hci import Address
+
 from bumble.device import Device
 from bumble.transport import open_transport_or_link
 
 
 # -----------------------------------------------------------------------------
-async def main() -> None:
+async def main():
     if len(sys.argv) < 2:
         print('Usage: run_scanner.py <transport-spec> [filter]')
         print('example: run_scanner.py usb:0')
         return
 
     print('<<< connecting to HCI...')
-    async with await open_transport_or_link(sys.argv[1]) as hci_transport:
+    async with await open_transport_or_link(sys.argv[1]) as (hci_source, hci_sink):
         print('<<< connected')
         filter_duplicates = len(sys.argv) == 3 and sys.argv[2] == 'filter'
 
-        device = Device.with_hci(
-            'Bumble',
-            Address('F0:F1:F2:F3:F4:F5'),
-            hci_transport.source,
-            hci_transport.sink,
-        )
+        device = Device.with_hci('Bumble', 'F0:F1:F2:F3:F4:F5', hci_source, hci_sink)
 
-        def on_adv(advertisement):
+        @device.on('advertisement')
+        def _(advertisement):
             address_type_string = ('PUBLIC', 'RANDOM', 'PUBLIC_ID', 'RANDOM_ID')[
                 advertisement.address.address_type
             ]
@@ -71,11 +67,10 @@ async def main() -> None:
                 f'{advertisement.data.to_string(separator)}'
             )
 
-        device.on('advertisement', on_adv)
         await device.power_on()
         await device.start_scanning(filter_duplicates=filter_duplicates)
 
-        await hci_transport.source.wait_for_termination()
+        await hci_source.wait_for_termination()
 
 
 # -----------------------------------------------------------------------------

examples/run_unicast_server.py

@@ -26,10 +26,11 @@ from bumble.device import Device, CisLink
 from bumble.hci import (
     CodecID,
     CodingFormat,
+    OwnAddressType,
     HCI_IsoDataPacket,
+    HCI_LE_Set_Extended_Advertising_Parameters_Command,
 )
 from bumble.profiles.bap import (
-    UnicastServerAdvertisingData,
     CodecSpecificCapabilities,
     ContextType,
     AudioLocation,
@@ -98,14 +99,14 @@ async def main() -> None:
                         coding_format=CodingFormat(CodecID.LC3),
                         codec_specific_capabilities=CodecSpecificCapabilities(
                             supported_sampling_frequencies=(
-                                SupportedSamplingFrequency.FREQ_48000
+                                SupportedSamplingFrequency.FREQ_24000
                             ),
                             supported_frame_durations=(
                                 SupportedFrameDuration.DURATION_10000_US_SUPPORTED
                             ),
                             supported_audio_channel_counts=[1],
-                            min_octets_per_codec_frame=120,
-                            max_octets_per_codec_frame=120,
+                            min_octets_per_codec_frame=60,
+                            max_octets_per_codec_frame=60,
                             supported_max_codec_frames_per_sdu=1,
                         ),
                     ),
@@ -141,7 +142,6 @@ async def main() -> None:
                 )
             )
             + csis.get_advertising_data()
-            + bytes(UnicastServerAdvertisingData())
         )
         subprocess = await asyncio.create_subprocess_shell(
             f'dlc3 | ffplay pipe:0',
@@ -159,7 +159,7 @@ async def main() -> None:
             + struct.pack(
                 '<HHHHHHI',
                 18,  # Header length.
-                48000 // 100,  # Sampling Rate(/100Hz).
+                24000 // 100,  # Sampling Rate(/100Hz).
                 0,  # Bitrate(unused).
                 1,  # Channels.
                 10000 // 10,  # Frame duration(/10us).
@@ -179,7 +179,11 @@ async def main() -> None:
 
         device.once('cis_establishment', on_cis)
 
-        await device.create_advertising_set(
+        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,
         )