use type object instead of type strings

.github/workflows/code-check.yml

@@ -14,10 +14,6 @@ jobs:
   check:
     name: Check Code
     runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        python-version: ["3.8", "3.9", "3.10", "3.11"]
-      fail-fast: false
 
     steps:
     - name: Check out from Git

.github/workflows/python-avatar.yml

@@ -1,43 +0,0 @@
-name: Python Avatar
-
-on:
-  push:
-    branches: [ main ]
-  pull_request:
-    branches: [ main ]
-
-permissions:
-  contents: read
-
-jobs:
-  test:
-    name: Avatar [${{ matrix.shard }}]
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        shard: [
-           1/24,  2/24,  3/24,  4/24,
-           5/24,  6/24,  7/24,  8/24,
-           9/24, 10/24, 11/24, 12/24,
-          13/24, 14/24, 15/24, 16/24,
-          17/24, 18/24, 19/24, 20/24,
-          21/24, 22/24, 23/24, 24/24,
-        ]
-    steps:
-      - uses: actions/checkout@v3
-      - name: Set Up Python 3.11
-        uses: actions/setup-python@v4
-        with:
-          python-version: 3.11
-      - name: Install
-        run: |
-          python -m pip install --upgrade pip
-          python -m pip install .[avatar]
-      - name: Rootcanal
-        run: nohup python -m rootcanal > rootcanal.log &
-      - name: Test
-        run: |
-          avatar --list | grep -Ev '^=' > test-names.txt
-          timeout 5m avatar --test-beds bumble.bumbles --tests $(split test-names.txt -n l/${{ matrix.shard }})
-      - name: Rootcanal Logs
-        run: cat rootcanal.log

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

@@ -12,11 +12,11 @@ permissions:
 
 jobs:
   build:
-    runs-on: ${{ matrix.os }}
+
+    runs-on: ubuntu-latest
     strategy:
       matrix:
-        os: ['ubuntu-latest', 'macos-latest', 'windows-latest']
-        python-version: ["3.8", "3.9", "3.10", "3.11"]
+        python-version: ["3.8", "3.9", "3.10"]
       fail-fast: false
 
     steps:
@@ -41,42 +41,3 @@ jobs:
       run: |
         inv build
         inv build.mkdocs
-
-  build-rust:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        python-version: [ "3.8", "3.9", "3.10", "3.11" ]
-        rust-version: [ "1.70.0", "stable" ]
-      fail-fast: false
-    steps:
-      - name: Check out from Git
-        uses: actions/checkout@v3
-      - name: Set up Python ${{ matrix.python-version }}
-        uses: actions/setup-python@v4
-        with:
-          python-version: ${{ matrix.python-version }}
-      - name: Install Python dependencies
-        run: |
-          python -m pip install --upgrade pip
-          python -m pip install ".[build,test,development,documentation]"
-      - name: Install Rust toolchain
-        uses: actions-rust-lang/setup-rust-toolchain@v1
-        with:
-          components: clippy,rustfmt
-          toolchain: ${{ matrix.rust-version }}
-      - name: Install Rust dependencies
-        run: cargo install cargo-all-features # allows building/testing combinations of features
-      - name: Check License Headers
-        run: cd rust && cargo run --features dev-tools --bin file-header check-all
-      - name: Rust Build
-        run: cd rust && cargo build --all-targets && cargo build-all-features --all-targets
-      # Lints after build so what clippy needs is already built
-      - name: Rust Lints
-        run: cd rust && cargo fmt --check && cargo clippy --all-targets -- --deny warnings && cargo clippy --all-features --all-targets -- --deny warnings
-      - name: Rust Tests
-        run: cd rust && cargo test-all-features
-      # At some point, hook up publishing the binary. For now, just make sure it builds.
-      # Once we're ready to publish binaries, this should be built with `--release`.
-      - name: Build Bumble CLI
-        run: cd rust && cargo build --features bumble-tools --bin bumble

.gitignore

@@ -9,6 +9,3 @@ __pycache__
 # generated by setuptools_scm
 bumble/_version.py
 .vscode/launch.json
-/.idea
-venv/
-.venv/

.vscode/settings.json

@@ -21,10 +21,7 @@
         "cccds",
         "cmac",
         "CONNECTIONLESS",
-        "csip",
-        "csis",
         "csrcs",
-        "CVSD",
         "datagram",
         "DATALINK",
         "delayreport",
@@ -32,7 +29,6 @@
         "deregistration",
         "dhkey",
         "diversifier",
-        "endianness",
         "Fitbit",
         "GATTLINK",
         "HANDSFREE",
@@ -42,18 +38,13 @@
         "libc",
         "libusb",
         "MITM",
-        "MSBC",
         "NDIS",
-        "netsim",
         "NONBLOCK",
         "NONCONN",
         "OXIMETER",
         "popleft",
-        "PRAND",
-        "protobuf",
         "psms",
         "pyee",
-        "Pyodide",
         "pyusb",
         "rfcomm",
         "ROHC",
@@ -61,7 +52,6 @@
         "SEID",
         "seids",
         "SERV",
-        "SIRK",
         "ssrc",
         "strerror",
         "subband",

apps/ble_rpa_tool.py

@@ -1,63 +0,0 @@
-# Copyright 2023 Google LLC
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import click
-from bumble.colors import color
-from bumble.hci import Address
-from bumble.helpers import generate_irk, verify_rpa_with_irk
-
-
-@click.group()
-def cli():
-    '''
-    This is a tool for generating IRK, RPA,
-    and verifying IRK/RPA pairs
-    '''
-
-
-@click.command()
-def gen_irk() -> None:
-    print(generate_irk().hex())
-
-
-@click.command()
-@click.argument("irk", type=str)
-def gen_rpa(irk: str) -> None:
-    irk_bytes = bytes.fromhex(irk)
-    rpa = Address.generate_private_address(irk_bytes)
-    print(rpa.to_string(with_type_qualifier=False))
-
-
-@click.command()
-@click.argument("irk", type=str)
-@click.argument("rpa", type=str)
-def verify_rpa(irk: str, rpa: str) -> None:
-    address = Address(rpa)
-    irk_bytes = bytes.fromhex(irk)
-    if verify_rpa_with_irk(address, irk_bytes):
-        print(color("Verified", "green"))
-    else:
-        print(color("Not Verified", "red"))
-
-
-def main():
-    cli.add_command(gen_irk)
-    cli.add_command(gen_rpa)
-    cli.add_command(verify_rpa)
-    cli()
-
-
-# -----------------------------------------------------------------------------
-if __name__ == '__main__':
-    main()

apps/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):
@@ -1172,7 +1172,7 @@ class ScanResult:
             name = ''
 
         # Remove any '/P' qualifier suffix from the address string
-        address_str = self.address.to_string(with_type_qualifier=False)
+        address_str = str(self.address).replace('/P', '')
 
         # RSSI bar
         bar_string = rssi_bar(self.rssi)

apps/controller_info.py

@@ -32,22 +32,16 @@ from bumble.hci import (
     HCI_Command,
     HCI_Command_Complete_Event,
     HCI_Command_Status_Event,
-    HCI_READ_BUFFER_SIZE_COMMAND,
-    HCI_Read_Buffer_Size_Command,
     HCI_READ_BD_ADDR_COMMAND,
     HCI_Read_BD_ADDR_Command,
     HCI_READ_LOCAL_NAME_COMMAND,
     HCI_Read_Local_Name_Command,
-    HCI_LE_READ_BUFFER_SIZE_COMMAND,
-    HCI_LE_Read_Buffer_Size_Command,
     HCI_LE_READ_MAXIMUM_DATA_LENGTH_COMMAND,
     HCI_LE_Read_Maximum_Data_Length_Command,
     HCI_LE_READ_NUMBER_OF_SUPPORTED_ADVERTISING_SETS_COMMAND,
     HCI_LE_Read_Number_Of_Supported_Advertising_Sets_Command,
     HCI_LE_READ_MAXIMUM_ADVERTISING_DATA_LENGTH_COMMAND,
     HCI_LE_Read_Maximum_Advertising_Data_Length_Command,
-    HCI_LE_READ_SUGGESTED_DEFAULT_DATA_LENGTH_COMMAND,
-    HCI_LE_Read_Suggested_Default_Data_Length_Command,
 )
 from bumble.host import Host
 from bumble.transport import open_transport_or_link
@@ -63,14 +57,13 @@ def command_succeeded(response):
 
 
 # -----------------------------------------------------------------------------
-async def get_classic_info(host: Host) -> None:
+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):
             print()
             print(
-                color('Classic Address:', 'yellow'),
-                response.return_parameters.bd_addr.to_string(False),
+                color('Classic Address:', 'yellow'), response.return_parameters.bd_addr
             )
 
     if host.supports_command(HCI_READ_LOCAL_NAME_COMMAND):
@@ -84,7 +77,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):
@@ -123,48 +116,11 @@ async def get_le_info(host: Host) -> None:
                 '\n',
             )
 
-    if host.supports_command(HCI_LE_READ_SUGGESTED_DEFAULT_DATA_LENGTH_COMMAND):
-        response = await host.send_command(
-            HCI_LE_Read_Suggested_Default_Data_Length_Command()
-        )
-        if command_succeeded(response):
-            print(
-                color('Suggested Default Data Length:', 'yellow'),
-                f'{response.return_parameters.suggested_max_tx_octets}/'
-                f'{response.return_parameters.suggested_max_tx_time}',
-                '\n',
-            )
-
     print(color('LE Features:', 'yellow'))
     for feature in host.supported_le_features:
         print('  ', name_or_number(HCI_LE_SUPPORTED_FEATURES_NAMES, feature))
 
 
-# -----------------------------------------------------------------------------
-async def get_acl_flow_control_info(host: Host) -> None:
-    print()
-
-    if host.supports_command(HCI_READ_BUFFER_SIZE_COMMAND):
-        response = await host.send_command(
-            HCI_Read_Buffer_Size_Command(), check_result=True
-        )
-        print(
-            color('ACL Flow Control:', 'yellow'),
-            f'{response.return_parameters.hc_total_num_acl_data_packets} '
-            f'packets of size {response.return_parameters.hc_acl_data_packet_length}',
-        )
-
-    if host.supports_command(HCI_LE_READ_BUFFER_SIZE_COMMAND):
-        response = await host.send_command(
-            HCI_LE_Read_Buffer_Size_Command(), check_result=True
-        )
-        print(
-            color('LE ACL Flow Control:', 'yellow'),
-            f'{response.return_parameters.hc_total_num_le_acl_data_packets} '
-            f'packets of size {response.return_parameters.hc_le_acl_data_packet_length}',
-        )
-
-
 # -----------------------------------------------------------------------------
 async def async_main(transport):
     print('<<< connecting to HCI...')
@@ -197,9 +153,6 @@ async def async_main(transport):
         # Get the LE info
         await get_le_info(host)
 
-        # Print the ACL flow control info
-        await get_acl_flow_control_info(host)
-
         # Print the list of commands supported by the controller
         print()
         print(color('Supported Commands:', 'yellow'))

apps/controller_loopback.py

@@ -1,200 +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.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=int,
-    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/gg_bridge.py

@@ -21,7 +21,6 @@ import struct
 import logging
 import click
 
-from bumble import l2cap
 from bumble.colors import color
 from bumble.device import Device, Peer
 from bumble.core import AdvertisingData
@@ -205,7 +204,7 @@ class GattlinkHubBridge(GattlinkL2capEndpoint, Device.Listener):
 
 # -----------------------------------------------------------------------------
 class GattlinkNodeBridge(GattlinkL2capEndpoint, Device.Listener):
-    def __init__(self, device: Device):
+    def __init__(self, device):
         super().__init__()
         self.device = device
         self.peer = None
@@ -219,12 +218,7 @@ class GattlinkNodeBridge(GattlinkL2capEndpoint, Device.Listener):
 
         # Listen for incoming L2CAP CoC connections
         psm = 0xFB
-        device.create_l2cap_server(
-            spec=l2cap.LeCreditBasedChannelSpec(
-                psm=0xFB,
-            ),
-            handler=self.on_coc,
-        )
+        device.register_l2cap_channel_server(0xFB, self.on_coc)
         print(f'### Listening for CoC connection on PSM {psm}')
 
         # Setup the Gattlink service

apps/l2cap_bridge.py

@@ -20,7 +20,6 @@ import logging
 import os
 import click
 
-from bumble import l2cap
 from bumble.colors import color
 from bumble.transport import open_transport_or_link
 from bumble.device import Device
@@ -48,17 +47,16 @@ class ServerBridge:
         self.tcp_host = tcp_host
         self.tcp_port = tcp_port
 
-    async def start(self, device: Device) -> None:
-        # Listen for incoming L2CAP channel 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')
+    async def start(self, device):
+        # Listen for incoming L2CAP CoC connections
+        device.register_l2cap_channel_server(
+            psm=self.psm,
+            server=self.on_coc,
+            max_credits=self.max_credits,
+            mtu=self.mtu,
+            mps=self.mps,
         )
+        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
@@ -107,7 +105,7 @@ class ServerBridge:
                             asyncio.create_task(self.pipe.l2cap_channel.disconnect())
 
                     def data_received(self, data):
-                        print(color(f'<<< [TCP DATA]: {len(data)} bytes', 'blue'))
+                        print(f'<<< Received on TCP: {len(data)}')
                         self.pipe.l2cap_channel.write(data)
 
                 try:
@@ -125,12 +123,11 @@ class ServerBridge:
                     await self.l2cap_channel.disconnect()
 
             def on_l2cap_close(self):
-                print(color('*** L2CAP channel closed', 'red'))
                 self.l2cap_channel = None
                 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 +182,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)
 
@@ -197,13 +194,11 @@ class ClientBridge:
             # Connect a new L2CAP channel
             print(color(f'>>> Opening L2CAP channel on PSM = {self.psm}', 'yellow'))
             try:
-                l2cap_channel = await connection.create_l2cap_channel(
-                    spec=l2cap.LeCreditBasedChannelSpec(
-                        psm=self.psm,
-                        max_credits=self.max_credits,
-                        mtu=self.mtu,
-                        mps=self.mps,
-                    )
+                l2cap_channel = await connection.open_l2cap_channel(
+                    psm=self.psm,
+                    max_credits=self.max_credits,
+                    mtu=self.mtu,
+                    mps=self.mps,
                 )
                 print(color('*** L2CAP channel:', 'cyan'), l2cap_channel)
             except Exception as error:
@@ -211,7 +206,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 +271,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 +295,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/pair.py

@@ -24,16 +24,10 @@ from prompt_toolkit.shortcuts import PromptSession
 from bumble.colors import color
 from bumble.device import Device, Peer
 from bumble.transport import open_transport_or_link
-from bumble.pairing import OobData, PairingDelegate, PairingConfig
-from bumble.smp import OobContext, OobLegacyContext
+from bumble.pairing import PairingDelegate, PairingConfig
 from bumble.smp import error_name as smp_error_name
 from bumble.keys import JsonKeyStore
-from bumble.core import (
-    AdvertisingData,
-    ProtocolError,
-    BT_LE_TRANSPORT,
-    BT_BR_EDR_TRANSPORT,
-)
+from bumble.core import ProtocolError
 from bumble.gatt import (
     GATT_DEVICE_NAME_CHARACTERISTIC,
     GATT_GENERIC_ACCESS_SERVICE,
@@ -52,13 +46,11 @@ from bumble.att import (
 class Waiter:
     instance = None
 
-    def __init__(self, linger=False):
+    def __init__(self):
         self.done = asyncio.get_running_loop().create_future()
-        self.linger = linger
 
     def terminate(self):
-        if not self.linger:
-            self.done.set_result(None)
+        self.done.set_result(None)
 
     async def wait_until_terminated(self):
         return await self.done
@@ -68,7 +60,7 @@ class Waiter:
 class Delegate(PairingDelegate):
     def __init__(self, mode, connection, capability_string, do_prompt):
         super().__init__(
-            io_capability={
+            {
                 'keyboard': PairingDelegate.KEYBOARD_INPUT_ONLY,
                 'display': PairingDelegate.DISPLAY_OUTPUT_ONLY,
                 'display+keyboard': PairingDelegate.DISPLAY_OUTPUT_AND_KEYBOARD_INPUT,
@@ -293,9 +285,7 @@ async def pair(
     mitm,
     bond,
     ctkd,
-    linger,
     io,
-    oob,
     prompt,
     request,
     print_keys,
@@ -304,7 +294,7 @@ async def pair(
     hci_transport,
     address_or_name,
 ):
-    Waiter.instance = Waiter(linger=linger)
+    Waiter.instance = Waiter()
 
     print('<<< connecting to HCI...')
     async with await open_transport_or_link(hci_transport) as (hci_source, hci_sink):
@@ -316,7 +306,6 @@ async def pair(
         # Expose a GATT characteristic that can be used to trigger pairing by
         # responding with an authentication error when read
         if mode == 'le':
-            device.le_enabled = True
             device.add_service(
                 Service(
                     '50DB505C-8AC4-4738-8448-3B1D9CC09CC5',
@@ -337,6 +326,7 @@ async def pair(
         # Select LE or Classic
         if mode == 'classic':
             device.classic_enabled = True
+            device.le_enabled = False
             device.classic_smp_enabled = ctkd
 
         # Get things going
@@ -353,51 +343,16 @@ async def pair(
             await device.keystore.print(prefix=color('@@@ ', 'blue'))
             print(color('@@@-----------------------------------', 'blue'))
 
-        # Create an OOB context if needed
-        if oob:
-            our_oob_context = OobContext()
-            shared_data = (
-                None
-                if oob == '-'
-                else OobData.from_ad(AdvertisingData.from_bytes(bytes.fromhex(oob)))
-            )
-            legacy_context = OobLegacyContext()
-            oob_contexts = PairingConfig.OobConfig(
-                our_context=our_oob_context,
-                peer_data=shared_data,
-                legacy_context=legacy_context,
-            )
-            oob_data = OobData(
-                address=device.random_address,
-                shared_data=shared_data,
-                legacy_context=legacy_context,
-            )
-            print(color('@@@-----------------------------------', 'yellow'))
-            print(color('@@@ OOB Data:', 'yellow'))
-            print(color(f'@@@   {our_oob_context.share()}', 'yellow'))
-            print(color(f'@@@   TK={legacy_context.tk.hex()}', 'yellow'))
-            print(color(f'@@@   HEX: ({bytes(oob_data.to_ad()).hex()})', 'yellow'))
-            print(color('@@@-----------------------------------', 'yellow'))
-        else:
-            oob_contexts = None
-
         # Set up a pairing config factory
         device.pairing_config_factory = lambda connection: PairingConfig(
-            sc=sc,
-            mitm=mitm,
-            bonding=bond,
-            oob=oob_contexts,
-            delegate=Delegate(mode, connection, io, prompt),
+            sc, mitm, bond, Delegate(mode, connection, io, prompt)
         )
 
         # Connect to a peer or wait for a connection
         device.on('connection', lambda connection: on_connection(connection, request))
         if address_or_name is not None:
             print(color(f'=== Connecting to {address_or_name}...', 'green'))
-            connection = await device.connect(
-                address_or_name,
-                transport=BT_LE_TRANSPORT if mode == 'le' else BT_BR_EDR_TRANSPORT,
-            )
+            connection = await device.connect(address_or_name)
 
             if not request:
                 try:
@@ -405,9 +360,10 @@ async def pair(
                         await connection.pair()
                     else:
                         await connection.authenticate()
+                    return
                 except ProtocolError as error:
                     print(color(f'Pairing failed: {error}', 'red'))
-
+                    return
         else:
             if mode == 'le':
                 # Advertise so that peers can find us and connect
@@ -457,7 +413,6 @@ class LogHandler(logging.Handler):
     help='Enable CTKD',
     show_default=True,
 )
-@click.option('--linger', default=False, is_flag=True, help='Linger after pairing')
 @click.option(
     '--io',
     type=click.Choice(
@@ -466,14 +421,6 @@ class LogHandler(logging.Handler):
     default='display+keyboard',
     show_default=True,
 )
-@click.option(
-    '--oob',
-    metavar='<oob-data-hex>',
-    help=(
-        'Use OOB pairing with this data from the peer '
-        '(use "-" to enable OOB without peer data)'
-    ),
-)
 @click.option('--prompt', is_flag=True, help='Prompt to accept/reject pairing request')
 @click.option(
     '--request', is_flag=True, help='Request that the connecting peer initiate pairing'
@@ -493,9 +440,7 @@ def main(
     mitm,
     bond,
     ctkd,
-    linger,
     io,
-    oob,
     prompt,
     request,
     print_keys,
@@ -518,9 +463,7 @@ def main(
             mitm,
             bond,
             ctkd,
-            linger,
             io,
-            oob,
             prompt,
             request,
             print_keys,

apps/pandora_server.py

@@ -1,10 +1,8 @@
 import asyncio
 import click
 import logging
-import json
 
-from bumble.pandora import PandoraDevice, Config, serve
-from typing import Dict, Any
+from bumble.pandora import PandoraDevice, serve
 
 BUMBLE_SERVER_GRPC_PORT = 7999
 ROOTCANAL_PORT_CUTTLEFISH = 7300
@@ -20,31 +18,12 @@ ROOTCANAL_PORT_CUTTLEFISH = 7300
     help='HCI transport',
     default=f'tcp-client:127.0.0.1:<rootcanal-port>',
 )
-@click.option(
-    '--config',
-    help='Bumble json configuration file',
-)
-def main(grpc_port: int, rootcanal_port: int, transport: str, config: str) -> None:
+def main(grpc_port: int, rootcanal_port: int, transport: str) -> None:
     if '<rootcanal-port>' in transport:
         transport = transport.replace('<rootcanal-port>', str(rootcanal_port))
-
-    bumble_config = retrieve_config(config)
-    bumble_config.setdefault('transport', transport)
-    device = PandoraDevice(bumble_config)
-
-    server_config = Config()
-    server_config.load_from_dict(bumble_config.get('server', {}))
-
+    device = PandoraDevice({'transport': transport})
     logging.basicConfig(level=logging.DEBUG)
-    asyncio.run(serve(device, config=server_config, port=grpc_port))
-
-
-def retrieve_config(config: str) -> Dict[str, Any]:
-    if not config:
-        return {}
-
-    with open(config, 'r') as f:
-        return json.load(f)
+    asyncio.run(serve(device, port=grpc_port))
 
 
 if __name__ == '__main__':

apps/show.py

@@ -102,21 +102,9 @@ class SnoopPacketReader:
     default='h4',
     help='Format of the input file',
 )
-@click.option(
-    '--vendors',
-    type=click.Choice(['android', 'zephyr']),
-    multiple=True,
-    help='Support vendor-specific commands (list one or more)',
-)
 @click.argument('filename')
 # pylint: disable=redefined-builtin
-def main(format, vendors, filename):
-    for vendor in vendors:
-        if vendor == 'android':
-            import bumble.vendor.android.hci
-        elif vendor == 'zephyr':
-            import bumble.vendor.zephyr.hci
-
+def main(format, filename):
     input = open(filename, 'rb')
     if format == 'h4':
         packet_reader = PacketReader(input)
@@ -136,6 +124,7 @@ def main(format, vendors, filename):
             if packet is None:
                 break
             tracer.trace(hci.HCI_Packet.from_bytes(packet), direction)
+
         except Exception as error:
             print(color(f'!!! {error}', 'red'))
 

apps/speaker/speaker.css

@@ -56,7 +56,7 @@ body, h1, h2, h3, h4, h5, h6 {
     border-radius: 4px;
     padding: 4px;
     margin: 6px;
-    margin-left: 0;
+    margin-left: 0px;
 }
 
 th, td {
@@ -65,7 +65,7 @@ th, td {
 }
 
 .properties td:nth-child(even) {
-    background-color: #d6eeee;
+    background-color: #D6EEEE;
     font-family: monospace;
 }
 

apps/speaker/speaker.html

@@ -2,7 +2,7 @@
 <html>
 <head>
   <title>Bumble Speaker</title>
-  <script src="speaker.js"></script>
+  <script type="text/javascript" src="speaker.js"></script>
   <link rel="stylesheet" href="speaker.css">
 </head>
 <body>

apps/speaker/speaker.py

@@ -195,7 +195,7 @@ class WebSocketOutput(QueuedOutput):
         except HCI_StatusError:
             pass
         peer_name = '' if connection.peer_name is None else connection.peer_name
-        peer_address = connection.peer_address.to_string(False)
+        peer_address = str(connection.peer_address).replace('/P', '')
         await self.send_message(
             'connection',
             peer_address=peer_address,
@@ -228,11 +228,10 @@ class FfplayOutput(QueuedOutput):
     subprocess: Optional[asyncio.subprocess.Process]
     ffplay_task: Optional[asyncio.Task]
 
-    def __init__(self, codec: str) -> None:
-        super().__init__(AudioExtractor.create(codec))
+    def __init__(self) -> None:
+        super().__init__(AacAudioExtractor())
         self.subprocess = None
         self.ffplay_task = None
-        self.codec = codec
 
     async def start(self):
         if self.started:
@@ -241,7 +240,7 @@ class FfplayOutput(QueuedOutput):
         await super().start()
 
         self.subprocess = await asyncio.create_subprocess_shell(
-            f'ffplay -f {self.codec} pipe:0',
+            'ffplay -acodec aac pipe:0',
             stdin=asyncio.subprocess.PIPE,
             stdout=asyncio.subprocess.PIPE,
             stderr=asyncio.subprocess.PIPE,
@@ -376,7 +375,7 @@ class UiServer:
         if connection := self.speaker().connection:
             await self.send_message(
                 'connection',
-                peer_address=connection.peer_address.to_string(False),
+                peer_address=str(connection.peer_address).replace('/P', ''),
                 peer_name=connection.peer_name,
             )
 
@@ -420,7 +419,7 @@ class Speaker:
         self.outputs = []
         for output in outputs:
             if output == '@ffplay':
-                self.outputs.append(FfplayOutput(codec))
+                self.outputs.append(FfplayOutput())
                 continue
 
             # Default to FileOutput
@@ -641,7 +640,7 @@ class Speaker:
             self.device.on('connection', self.on_bluetooth_connection)
 
             # Create a listener to wait for AVDTP connections
-            self.listener = Listener.for_device(self.device)
+            self.listener = Listener(Listener.create_registrar(self.device))
             self.listener.on('connection', self.on_avdtp_connection)
 
             print(f'Speaker ready to play, codec={color(self.codec, "cyan")}')
@@ -709,6 +708,17 @@ def speaker(
 ):
     """Run the speaker."""
 
+    # ffplay only works with AAC for now
+    if codec != 'aac' and '@ffplay' in output:
+        print(
+            color(
+                f'{codec} not supported with @ffplay output, '
+                '@ffplay output will be skipped',
+                'yellow',
+            )
+        )
+        output = list(filter(lambda x: x != '@ffplay', output))
+
     if '@ffplay' in output:
         # Check if ffplay is installed
         try:

bumble/a2dp.py

@@ -15,13 +15,9 @@
 # -----------------------------------------------------------------------------
 # Imports
 # -----------------------------------------------------------------------------
-from __future__ import annotations
-
-import dataclasses
 import struct
 import logging
-from collections.abc import AsyncGenerator
-from typing import List, Callable, Awaitable
+from collections import namedtuple
 
 from .company_ids import COMPANY_IDENTIFIERS
 from .sdp import (
@@ -243,20 +239,24 @@ def make_audio_sink_service_sdp_records(service_record_handle, version=(1, 3)):
 
 
 # -----------------------------------------------------------------------------
-@dataclasses.dataclass
-class SbcMediaCodecInformation:
+class SbcMediaCodecInformation(
+    namedtuple(
+        'SbcMediaCodecInformation',
+        [
+            'sampling_frequency',
+            'channel_mode',
+            'block_length',
+            'subbands',
+            'allocation_method',
+            'minimum_bitpool_value',
+            'maximum_bitpool_value',
+        ],
+    )
+):
     '''
     A2DP spec - 4.3.2 Codec Specific Information Elements
     '''
 
-    sampling_frequency: int
-    channel_mode: int
-    block_length: int
-    subbands: int
-    allocation_method: int
-    minimum_bitpool_value: int
-    maximum_bitpool_value: int
-
     SAMPLING_FREQUENCY_BITS = {16000: 1 << 3, 32000: 1 << 2, 44100: 1 << 1, 48000: 1}
     CHANNEL_MODE_BITS = {
         SBC_MONO_CHANNEL_MODE: 1 << 3,
@@ -272,7 +272,7 @@ class SbcMediaCodecInformation:
     }
 
     @staticmethod
-    def from_bytes(data: bytes) -> SbcMediaCodecInformation:
+    def from_bytes(data: bytes) -> 'SbcMediaCodecInformation':
         sampling_frequency = (data[0] >> 4) & 0x0F
         channel_mode = (data[0] >> 0) & 0x0F
         block_length = (data[1] >> 4) & 0x0F
@@ -293,14 +293,14 @@ class SbcMediaCodecInformation:
     @classmethod
     def from_discrete_values(
         cls,
-        sampling_frequency: int,
-        channel_mode: int,
-        block_length: int,
-        subbands: int,
-        allocation_method: int,
-        minimum_bitpool_value: int,
-        maximum_bitpool_value: int,
-    ) -> SbcMediaCodecInformation:
+        sampling_frequency,
+        channel_mode,
+        block_length,
+        subbands,
+        allocation_method,
+        minimum_bitpool_value,
+        maximum_bitpool_value,
+    ):
         return SbcMediaCodecInformation(
             sampling_frequency=cls.SAMPLING_FREQUENCY_BITS[sampling_frequency],
             channel_mode=cls.CHANNEL_MODE_BITS[channel_mode],
@@ -314,14 +314,14 @@ class SbcMediaCodecInformation:
     @classmethod
     def from_lists(
         cls,
-        sampling_frequencies: List[int],
-        channel_modes: List[int],
-        block_lengths: List[int],
-        subbands: List[int],
-        allocation_methods: List[int],
-        minimum_bitpool_value: int,
-        maximum_bitpool_value: int,
-    ) -> SbcMediaCodecInformation:
+        sampling_frequencies,
+        channel_modes,
+        block_lengths,
+        subbands,
+        allocation_methods,
+        minimum_bitpool_value,
+        maximum_bitpool_value,
+    ):
         return SbcMediaCodecInformation(
             sampling_frequency=sum(
                 cls.SAMPLING_FREQUENCY_BITS[x] for x in sampling_frequencies
@@ -348,7 +348,7 @@ class SbcMediaCodecInformation:
             ]
         )
 
-    def __str__(self) -> str:
+    def __str__(self):
         channel_modes = ['MONO', 'DUAL_CHANNEL', 'STEREO', 'JOINT_STEREO']
         allocation_methods = ['SNR', 'Loudness']
         return '\n'.join(
@@ -367,19 +367,16 @@ class SbcMediaCodecInformation:
 
 
 # -----------------------------------------------------------------------------
-@dataclasses.dataclass
-class AacMediaCodecInformation:
+class AacMediaCodecInformation(
+    namedtuple(
+        'AacMediaCodecInformation',
+        ['object_type', 'sampling_frequency', 'channels', 'rfa', 'vbr', 'bitrate'],
+    )
+):
     '''
     A2DP spec - 4.5.2 Codec Specific Information Elements
     '''
 
-    object_type: int
-    sampling_frequency: int
-    channels: int
-    rfa: int
-    vbr: int
-    bitrate: int
-
     OBJECT_TYPE_BITS = {
         MPEG_2_AAC_LC_OBJECT_TYPE: 1 << 7,
         MPEG_4_AAC_LC_OBJECT_TYPE: 1 << 6,
@@ -403,7 +400,7 @@ class AacMediaCodecInformation:
     CHANNELS_BITS = {1: 1 << 1, 2: 1}
 
     @staticmethod
-    def from_bytes(data: bytes) -> AacMediaCodecInformation:
+    def from_bytes(data: bytes) -> 'AacMediaCodecInformation':
         object_type = data[0]
         sampling_frequency = (data[1] << 4) | ((data[2] >> 4) & 0x0F)
         channels = (data[2] >> 2) & 0x03
@@ -416,13 +413,8 @@ class AacMediaCodecInformation:
 
     @classmethod
     def from_discrete_values(
-        cls,
-        object_type: int,
-        sampling_frequency: int,
-        channels: int,
-        vbr: int,
-        bitrate: int,
-    ) -> AacMediaCodecInformation:
+        cls, object_type, sampling_frequency, channels, vbr, bitrate
+    ):
         return AacMediaCodecInformation(
             object_type=cls.OBJECT_TYPE_BITS[object_type],
             sampling_frequency=cls.SAMPLING_FREQUENCY_BITS[sampling_frequency],
@@ -433,14 +425,7 @@ class AacMediaCodecInformation:
         )
 
     @classmethod
-    def from_lists(
-        cls,
-        object_types: List[int],
-        sampling_frequencies: List[int],
-        channels: List[int],
-        vbr: int,
-        bitrate: int,
-    ) -> AacMediaCodecInformation:
+    def from_lists(cls, object_types, sampling_frequencies, channels, vbr, bitrate):
         return AacMediaCodecInformation(
             object_type=sum(cls.OBJECT_TYPE_BITS[x] for x in object_types),
             sampling_frequency=sum(
@@ -464,7 +449,7 @@ class AacMediaCodecInformation:
             ]
         )
 
-    def __str__(self) -> str:
+    def __str__(self):
         object_types = [
             'MPEG_2_AAC_LC',
             'MPEG_4_AAC_LC',
@@ -489,26 +474,26 @@ class AacMediaCodecInformation:
         )
 
 
-@dataclasses.dataclass
 # -----------------------------------------------------------------------------
 class VendorSpecificMediaCodecInformation:
     '''
     A2DP spec - 4.7.2 Codec Specific Information Elements
     '''
 
-    vendor_id: int
-    codec_id: int
-    value: bytes
-
     @staticmethod
-    def from_bytes(data: bytes) -> VendorSpecificMediaCodecInformation:
+    def from_bytes(data):
         (vendor_id, codec_id) = struct.unpack_from('<IH', data, 0)
         return VendorSpecificMediaCodecInformation(vendor_id, codec_id, data[6:])
 
-    def __bytes__(self) -> bytes:
+    def __init__(self, vendor_id, codec_id, value):
+        self.vendor_id = vendor_id
+        self.codec_id = codec_id
+        self.value = value
+
+    def __bytes__(self):
         return struct.pack('<IH', self.vendor_id, self.codec_id, self.value)
 
-    def __str__(self) -> str:
+    def __str__(self):
         # pylint: disable=line-too-long
         return '\n'.join(
             [
@@ -521,27 +506,29 @@ class VendorSpecificMediaCodecInformation:
 
 
 # -----------------------------------------------------------------------------
-@dataclasses.dataclass
 class SbcFrame:
-    sampling_frequency: int
-    block_count: int
-    channel_mode: int
-    subband_count: int
-    payload: bytes
+    def __init__(
+        self, sampling_frequency, block_count, channel_mode, subband_count, payload
+    ):
+        self.sampling_frequency = sampling_frequency
+        self.block_count = block_count
+        self.channel_mode = channel_mode
+        self.subband_count = subband_count
+        self.payload = payload
 
     @property
-    def sample_count(self) -> int:
+    def sample_count(self):
         return self.subband_count * self.block_count
 
     @property
-    def bitrate(self) -> int:
+    def bitrate(self):
         return 8 * ((len(self.payload) * self.sampling_frequency) // self.sample_count)
 
     @property
-    def duration(self) -> float:
+    def duration(self):
         return self.sample_count / self.sampling_frequency
 
-    def __str__(self) -> str:
+    def __str__(self):
         return (
             f'SBC(sf={self.sampling_frequency},'
             f'cm={self.channel_mode},'
@@ -553,12 +540,12 @@ class SbcFrame:
 
 # -----------------------------------------------------------------------------
 class SbcParser:
-    def __init__(self, read: Callable[[int], Awaitable[bytes]]) -> None:
+    def __init__(self, read):
         self.read = read
 
     @property
-    def frames(self) -> AsyncGenerator[SbcFrame, None]:
-        async def generate_frames() -> AsyncGenerator[SbcFrame, None]:
+    def frames(self):
+        async def generate_frames():
             while True:
                 # Read 4 bytes of header
                 header = await self.read(4)
@@ -602,9 +589,7 @@ class SbcParser:
 
 # -----------------------------------------------------------------------------
 class SbcPacketSource:
-    def __init__(
-        self, read: Callable[[int], Awaitable[bytes]], mtu: int, codec_capabilities
-    ) -> None:
+    def __init__(self, read, mtu, codec_capabilities):
         self.read = read
         self.mtu = mtu
         self.codec_capabilities = codec_capabilities

bumble/at.py

@@ -1,85 +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.
-
-from typing import List, Union
-
-
-def tokenize_parameters(buffer: bytes) -> List[bytes]:
-    """Split input parameters into tokens.
-    Removes space characters outside of double quote blocks:
-    T-rec-V-25 - 5.2.1 Command line general format: "Space characters (IA5 2/0)
-    are ignored [..], unless they are embedded in numeric or string constants"
-    Raises ValueError in case of invalid input string."""
-
-    tokens = []
-    in_quotes = False
-    token = bytearray()
-    for b in buffer:
-        char = bytearray([b])
-
-        if in_quotes:
-            token.extend(char)
-            if char == b'\"':
-                in_quotes = False
-                tokens.append(token[1:-1])
-                token = bytearray()
-        else:
-            if char == b' ':
-                pass
-            elif char == b',' or char == b')':
-                tokens.append(token)
-                tokens.append(char)
-                token = bytearray()
-            elif char == b'(':
-                if len(token) > 0:
-                    raise ValueError("open_paren following regular character")
-                tokens.append(char)
-            elif char == b'"':
-                if len(token) > 0:
-                    raise ValueError("quote following regular character")
-                in_quotes = True
-                token.extend(char)
-            else:
-                token.extend(char)
-
-    tokens.append(token)
-    return [bytes(token) for token in tokens if len(token) > 0]
-
-
-def parse_parameters(buffer: bytes) -> List[Union[bytes, list]]:
-    """Parse the parameters using the comma and parenthesis separators.
-    Raises ValueError in case of invalid input string."""
-
-    tokens = tokenize_parameters(buffer)
-    accumulator: List[list] = [[]]
-    current: Union[bytes, list] = bytes()
-
-    for token in tokens:
-        if token == b',':
-            accumulator[-1].append(current)
-            current = bytes()
-        elif token == b'(':
-            accumulator.append([])
-        elif token == b')':
-            if len(accumulator) < 2:
-                raise ValueError("close_paren without matching open_paren")
-            accumulator[-1].append(current)
-            current = accumulator.pop()
-        else:
-            current = token
-
-    accumulator[-1].append(current)
-    if len(accumulator) > 1:
-        raise ValueError("missing close_paren")
-    return accumulator[0]

bumble/att.py

@@ -23,26 +23,13 @@
 # Imports
 # -----------------------------------------------------------------------------
 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, TYPE_CHECKING
 
-from bumble.core import UUID, name_or_number, ProtocolError
-from bumble.hci import HCI_Object, key_with_value
+from bumble.core import UUID, name_or_number, get_dict_key_by_value, ProtocolError
+from bumble.hci import HCI_Object, key_with_value, HCI_Constant
 from bumble.colors import color
 
 if TYPE_CHECKING:
@@ -195,7 +182,6 @@ UUID_2_FIELD_SPEC    = lambda x, y: UUID.parse_uuid_2(x, y)  # noqa: E731
 # pylint: enable=line-too-long
 # pylint: disable=invalid-name
 
-
 # -----------------------------------------------------------------------------
 # Exceptions
 # -----------------------------------------------------------------------------
@@ -223,7 +209,7 @@ class ATT_PDU:
 
     pdu_classes: Dict[int, Type[ATT_PDU]] = {}
     op_code = 0
-    name: str
+    name = None
 
     @staticmethod
     def from_bytes(pdu):
@@ -733,94 +719,48 @@ 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.
-    '''
-
-    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
-
-
 # -----------------------------------------------------------------------------
 class Attribute(EventEmitter):
-    class Permissions(enum.IntFlag):
-        READABLE = 0x01
-        WRITEABLE = 0x02
-        READ_REQUIRES_ENCRYPTION = 0x04
-        WRITE_REQUIRES_ENCRYPTION = 0x08
-        READ_REQUIRES_AUTHENTICATION = 0x10
-        WRITE_REQUIRES_AUTHENTICATION = 0x20
-        READ_REQUIRES_AUTHORIZATION = 0x40
-        WRITE_REQUIRES_AUTHORIZATION = 0x80
+    # Permission flags
+    READABLE = 0x01
+    WRITEABLE = 0x02
+    READ_REQUIRES_ENCRYPTION = 0x04
+    WRITE_REQUIRES_ENCRYPTION = 0x08
+    READ_REQUIRES_AUTHENTICATION = 0x10
+    WRITE_REQUIRES_AUTHENTICATION = 0x20
+    READ_REQUIRES_AUTHORIZATION = 0x40
+    WRITE_REQUIRES_AUTHORIZATION = 0x80
 
-        @classmethod
-        def from_string(cls, permissions_str: str) -> Attribute.Permissions:
-            try:
-                return functools.reduce(
-                    lambda x, y: x | Attribute.Permissions[y],
-                    permissions_str.replace('|', ',').split(","),
-                    Attribute.Permissions(0),
-                )
-            except TypeError as exc:
-                # The check for `p.name is not None` here is needed because for InFlag
-                # enums, the .name property can be None, when the enum value is 0,
-                # so the type hint for .name is Optional[str].
-                enum_list: List[str] = [p.name for p in cls if p.name is not None]
-                enum_list_str = ",".join(enum_list)
-                raise TypeError(
-                    f"Attribute::permissions error:\nExpected a string containing any of the keys, separated by commas: {enum_list_str  }\nGot: {permissions_str}"
-                ) from exc
+    PERMISSION_NAMES = {
+        READABLE: 'READABLE',
+        WRITEABLE: 'WRITEABLE',
+        READ_REQUIRES_ENCRYPTION: 'READ_REQUIRES_ENCRYPTION',
+        WRITE_REQUIRES_ENCRYPTION: 'WRITE_REQUIRES_ENCRYPTION',
+        READ_REQUIRES_AUTHENTICATION: 'READ_REQUIRES_AUTHENTICATION',
+        WRITE_REQUIRES_AUTHENTICATION: 'WRITE_REQUIRES_AUTHENTICATION',
+        READ_REQUIRES_AUTHORIZATION: 'READ_REQUIRES_AUTHORIZATION',
+        WRITE_REQUIRES_AUTHORIZATION: 'WRITE_REQUIRES_AUTHORIZATION',
+    }
 
-    # Permission flags(legacy-use only)
-    READABLE = Permissions.READABLE
-    WRITEABLE = Permissions.WRITEABLE
-    READ_REQUIRES_ENCRYPTION = Permissions.READ_REQUIRES_ENCRYPTION
-    WRITE_REQUIRES_ENCRYPTION = Permissions.WRITE_REQUIRES_ENCRYPTION
-    READ_REQUIRES_AUTHENTICATION = Permissions.READ_REQUIRES_AUTHENTICATION
-    WRITE_REQUIRES_AUTHENTICATION = Permissions.WRITE_REQUIRES_AUTHENTICATION
-    READ_REQUIRES_AUTHORIZATION = Permissions.READ_REQUIRES_AUTHORIZATION
-    WRITE_REQUIRES_AUTHORIZATION = Permissions.WRITE_REQUIRES_AUTHORIZATION
+    @staticmethod
+    def string_to_permissions(permissions_str: str):
+        try:
+            return functools.reduce(
+                lambda x, y: x | get_dict_key_by_value(Attribute.PERMISSION_NAMES, y),
+                permissions_str.split(","),
+                0,
+            )
+        except TypeError as exc:
+            raise TypeError(
+                f"Attribute::permissions error:\nExpected a string containing any of the keys, separated by commas: {','.join(Attribute.PERMISSION_NAMES.values())}\nGot: {permissions_str}"
+            ) from exc
 
-    value: Union[bytes, AttributeValue]
-
-    def __init__(
-        self,
-        attribute_type: Union[str, bytes, UUID],
-        permissions: Union[str, Attribute.Permissions],
-        value: Union[str, bytes, AttributeValue] = b'',
-    ) -> None:
+    def __init__(self, attribute_type, permissions, value=b''):
         EventEmitter.__init__(self)
         self.handle = 0
         self.end_group_handle = 0
         if isinstance(permissions, str):
-            self.permissions = Attribute.Permissions.from_string(permissions)
+            self.permissions = self.string_to_permissions(permissions)
         else:
             self.permissions = permissions
 
@@ -838,26 +778,22 @@ class Attribute(EventEmitter):
         else:
             self.value = value
 
-    def encode_value(self, value: Any) -> bytes:
+    def encode_value(self, value):
         return value
 
-    def decode_value(self, value_bytes: bytes) -> Any:
+    def decode_value(self, value_bytes):
         return value_bytes
 
-    async def read_value(self, connection: Optional[Connection]) -> bytes:
+    def read_value(self, connection: Connection):
         if (
-            (self.permissions & self.READ_REQUIRES_ENCRYPTION)
-            and connection is not None
-            and not connection.encryption
-        ):
+            self.permissions & self.READ_REQUIRES_ENCRYPTION
+        ) and not connection.encryption:
             raise ATT_Error(
                 error_code=ATT_INSUFFICIENT_ENCRYPTION_ERROR, att_handle=self.handle
             )
         if (
-            (self.permissions & self.READ_REQUIRES_AUTHENTICATION)
-            and connection is not None
-            and not connection.authenticated
-        ):
+            self.permissions & self.READ_REQUIRES_AUTHENTICATION
+        ) and not connection.authenticated:
             raise ATT_Error(
                 error_code=ATT_INSUFFICIENT_AUTHENTICATION_ERROR, att_handle=self.handle
             )
@@ -867,11 +803,9 @@ class Attribute(EventEmitter):
                 error_code=ATT_INSUFFICIENT_AUTHORIZATION_ERROR, att_handle=self.handle
             )
 
-        if hasattr(self.value, 'read'):
+        if read := getattr(self.value, 'read', None):
             try:
-                value = self.value.read(connection)
-                if inspect.isawaitable(value):
-                    value = await value
+                value = read(connection)  # pylint: disable=not-callable
             except ATT_Error as error:
                 raise ATT_Error(
                     error_code=error.error_code, att_handle=self.handle
@@ -881,7 +815,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):
         if (
             self.permissions & self.WRITE_REQUIRES_ENCRYPTION
         ) and not connection.encryption:
@@ -902,11 +836,9 @@ class Attribute(EventEmitter):
 
         value = self.decode_value(value_bytes)
 
-        if hasattr(self.value, 'write'):
+        if write := getattr(self.value, 'write', None):
             try:
-                result = self.value.write(connection, value)
-                if inspect.isawaitable(result):
-                    await result
+                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/controller.py

@@ -15,8 +15,6 @@
 # -----------------------------------------------------------------------------
 # Imports
 # -----------------------------------------------------------------------------
-from __future__ import annotations
-
 import logging
 import asyncio
 import itertools
@@ -60,10 +58,8 @@ from bumble.hci import (
     HCI_Packet,
     HCI_Role_Change_Event,
 )
-from typing import Optional, Union, Dict, TYPE_CHECKING
+from typing import Optional, Union, Dict
 
-if TYPE_CHECKING:
-    from bumble.transport.common import TransportSink, TransportSource
 
 # -----------------------------------------------------------------------------
 # Logging
@@ -108,7 +104,7 @@ class Controller:
         self,
         name,
         host_source=None,
-        host_sink: Optional[TransportSink] = None,
+        host_sink=None,
         link=None,
         public_address: Optional[Union[bytes, str, Address]] = None,
     ):
@@ -134,14 +130,12 @@ class Controller:
             '0000000060000000'
         )  # BR/EDR Not Supported, LE Supported (Controller)
         self.manufacturer_name = 0xFFFF
-        self.hc_data_packet_length = 27
-        self.hc_total_num_data_packets = 64
         self.hc_le_data_packet_length = 27
         self.hc_total_num_le_data_packets = 64
         self.event_mask = 0
         self.event_mask_page_2 = 0
         self.supported_commands = bytes.fromhex(
-            '2000800000c000000000e4000000a822000000000000040000f7ffff7f000000'
+            '2000800000c000000000e40000002822000000000000040000f7ffff7f000000'
             '30f0f9ff01008004000000000000000000000000000000000000000000000000'
         )
         self.le_event_mask = 0
@@ -194,8 +188,6 @@ class Controller:
         if link:
             link.add_controller(self)
 
-        self.terminated = asyncio.get_running_loop().create_future()
-
     @property
     def host(self):
         return self.hci_sink
@@ -296,9 +288,10 @@ class Controller:
         if self.host:
             self.host.on_packet(packet.to_bytes())
 
-    # This method allows the controller to emulate the same API as a transport source
+    # This method allow the controller to emulate the same API as a transport source
     async def wait_for_termination(self):
-        await self.terminated
+        # For now, just wait forever
+        await asyncio.get_running_loop().create_future()
 
     ############################################################
     # Link connections
@@ -916,19 +909,6 @@ class Controller:
         '''
         return bytes([HCI_SUCCESS]) + self.lmp_features
 
-    def on_hci_read_buffer_size_command(self, _command):
-        '''
-        See Bluetooth spec Vol 4, Part E - 7.4.5 Read Buffer Size Command
-        '''
-        return struct.pack(
-            '<BHBHH',
-            HCI_SUCCESS,
-            self.hc_data_packet_length,
-            0,
-            self.hc_total_num_data_packets,
-            0,
-        )
-
     def on_hci_read_bd_addr_command(self, _command):
         '''
         See Bluetooth spec Vol 4, Part E - 7.4.6 Read BD_ADDR Command
@@ -1015,9 +995,6 @@ class Controller:
         '''
         See Bluetooth spec Vol 4, Part E - 7.8.10 LE Set Scan Parameters Command
         '''
-        if self.le_scan_enable:
-            return bytes([HCI_COMMAND_DISALLOWED_ERROR])
-
         self.le_scan_type = command.le_scan_type
         self.le_scan_interval = command.le_scan_interval
         self.le_scan_window = command.le_scan_window
@@ -1278,15 +1255,3 @@ class Controller:
         See Bluetooth spec Vol 4, Part E - 7.8.74 LE Read Transmit Power Command
         '''
         return struct.pack('<BBB', HCI_SUCCESS, 0, 0)
-
-    def on_hci_le_setup_iso_data_path_command(self, command):
-        '''
-        See Bluetooth spec Vol 4, Part E - 7.8.109 LE Setup ISO Data Path Command
-        '''
-        return struct.pack('<BH', HCI_SUCCESS, command.connection_handle)
-
-    def on_hci_le_remove_iso_data_path_command(self, command):
-        '''
-        See Bluetooth spec Vol 4, Part E - 7.8.110 LE Remove ISO Data Path Command
-        '''
-        return struct.pack('<BH', HCI_SUCCESS, command.connection_handle)

bumble/core.py

@@ -16,7 +16,6 @@
 # Imports
 # -----------------------------------------------------------------------------
 from __future__ import annotations
-import enum
 import struct
 from typing import List, Optional, Tuple, Union, cast, Dict
 
@@ -79,13 +78,7 @@ def get_dict_key_by_value(dictionary, value):
 class BaseError(Exception):
     """Base class for errors with an error code, error name and namespace"""
 
-    def __init__(
-        self,
-        error_code: Optional[int],
-        error_namespace: str = '',
-        error_name: str = '',
-        details: str = '',
-    ):
+    def __init__(self, error_code, error_namespace='', error_name='', details=''):
         super().__init__()
         self.error_code = error_code
         self.error_namespace = error_namespace
@@ -97,14 +90,12 @@ class BaseError(Exception):
             namespace = f'{self.error_namespace}/'
         else:
             namespace = ''
-        error_text = {
-            (True, True): f'{self.error_name} [0x{self.error_code:X}]',
-            (True, False): self.error_name,
-            (False, True): f'0x{self.error_code:X}',
-            (False, False): '',
-        }[(self.error_name != '', self.error_code is not None)]
+        if self.error_name:
+            name = f'{self.error_name} [0x{self.error_code:X}]'
+        else:
+            name = f'0x{self.error_code:X}'
 
-        return f'{type(self).__name__}({namespace}{error_text})'
+        return f'{type(self).__name__}({namespace}{name})'
 
 
 class ProtocolError(BaseError):
@@ -143,10 +134,6 @@ class ConnectionError(BaseError):  # pylint: disable=redefined-builtin
         self.peer_address = peer_address
 
 
-class ConnectionParameterUpdateError(BaseError):
-    """Connection Parameter Update Error"""
-
-
 # -----------------------------------------------------------------------------
 # UUID
 #
@@ -1052,13 +1039,3 @@ class ConnectionPHY:
 
     def __str__(self):
         return f'ConnectionPHY(tx_phy={self.tx_phy}, rx_phy={self.rx_phy})'
-
-
-# -----------------------------------------------------------------------------
-# LE Role
-# -----------------------------------------------------------------------------
-class LeRole(enum.IntEnum):
-    PERIPHERAL_ONLY = 0x00
-    CENTRAL_ONLY = 0x01
-    BOTH_PERIPHERAL_PREFERRED = 0x02
-    BOTH_CENTRAL_PREFERRED = 0x03

bumble/crypto.py

@@ -21,24 +21,24 @@
 # -----------------------------------------------------------------------------
 # Imports
 # -----------------------------------------------------------------------------
-from __future__ import annotations
-
 import logging
 import operator
+import platform
 
-import secrets
-from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
-from cryptography.hazmat.primitives.asymmetric.ec import (
-    generate_private_key,
-    ECDH,
-    EllipticCurvePrivateKey,
-    EllipticCurvePublicNumbers,
-    EllipticCurvePrivateNumbers,
-    SECP256R1,
-)
-from cryptography.hazmat.primitives import cmac
-from typing import Tuple
-
+if platform.system() != 'Emscripten':
+    import secrets
+    from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+    from cryptography.hazmat.primitives.asymmetric.ec import (
+        generate_private_key,
+        ECDH,
+        EllipticCurvePublicNumbers,
+        EllipticCurvePrivateNumbers,
+        SECP256R1,
+    )
+    from cryptography.hazmat.primitives import cmac
+else:
+    # TODO: implement stubs
+    pass
 
 # -----------------------------------------------------------------------------
 # Logging
@@ -50,18 +50,16 @@ logger = logging.getLogger(__name__)
 # Classes
 # -----------------------------------------------------------------------------
 class EccKey:
-    def __init__(self, private_key: EllipticCurvePrivateKey) -> None:
+    def __init__(self, private_key):
         self.private_key = private_key
 
     @classmethod
-    def generate(cls) -> EccKey:
+    def generate(cls):
         private_key = generate_private_key(SECP256R1())
         return cls(private_key)
 
     @classmethod
-    def from_private_key_bytes(
-        cls, d_bytes: bytes, x_bytes: bytes, y_bytes: bytes
-    ) -> EccKey:
+    def from_private_key_bytes(cls, d_bytes, x_bytes, y_bytes):
         d = int.from_bytes(d_bytes, byteorder='big', signed=False)
         x = int.from_bytes(x_bytes, byteorder='big', signed=False)
         y = int.from_bytes(y_bytes, byteorder='big', signed=False)
@@ -71,7 +69,7 @@ class EccKey:
         return cls(private_key)
 
     @property
-    def x(self) -> bytes:
+    def x(self):
         return (
             self.private_key.public_key()
             .public_numbers()
@@ -79,14 +77,14 @@ class EccKey:
         )
 
     @property
-    def y(self) -> bytes:
+    def y(self):
         return (
             self.private_key.public_key()
             .public_numbers()
             .y.to_bytes(32, byteorder='big')
         )
 
-    def dh(self, public_key_x: bytes, public_key_y: bytes) -> bytes:
+    def dh(self, public_key_x, public_key_y):
         x = int.from_bytes(public_key_x, byteorder='big', signed=False)
         y = int.from_bytes(public_key_y, byteorder='big', signed=False)
         public_key = EllipticCurvePublicNumbers(x, y, SECP256R1()).public_key()
@@ -99,33 +97,14 @@ class EccKey:
 # Functions
 # -----------------------------------------------------------------------------
 
-
 # -----------------------------------------------------------------------------
-def generate_prand() -> bytes:
-    '''Generates random 3 bytes, with the 2 most significant bits of 0b01.
-
-    See Bluetooth spec, Vol 6, Part E - Table 1.2.
-    '''
-    prand_bytes = secrets.token_bytes(6)
-    return prand_bytes[:2] + bytes([(prand_bytes[2] & 0b01111111) | 0b01000000])
-
-
-# -----------------------------------------------------------------------------
-def xor(x: bytes, y: bytes) -> bytes:
+def xor(x, y):
     assert len(x) == len(y)
     return bytes(map(operator.xor, x, y))
 
 
 # -----------------------------------------------------------------------------
-def reverse(input: bytes) -> bytes:
-    '''
-    Returns bytes of input in reversed endianness.
-    '''
-    return input[::-1]
-
-
-# -----------------------------------------------------------------------------
-def r() -> bytes:
+def r():
     '''
     Generate 16 bytes of random data
     '''
@@ -133,20 +112,20 @@ def r() -> bytes:
 
 
 # -----------------------------------------------------------------------------
-def e(key: bytes, data: bytes) -> bytes:
+def e(key, data):
     '''
     AES-128 ECB, expecting byte-swapped inputs and producing a byte-swapped output.
 
     See Bluetooth spec Vol 3, Part H - 2.2.1 Security function e
     '''
 
-    cipher = Cipher(algorithms.AES(reverse(key)), modes.ECB())
+    cipher = Cipher(algorithms.AES(bytes(reversed(key))), modes.ECB())
     encryptor = cipher.encryptor()
-    return reverse(encryptor.update(reverse(data)))
+    return bytes(reversed(encryptor.update(bytes(reversed(data)))))
 
 
 # -----------------------------------------------------------------------------
-def ah(k: bytes, r: bytes) -> bytes:  # pylint: disable=redefined-outer-name
+def ah(k, r):  # pylint: disable=redefined-outer-name
     '''
     See Bluetooth spec Vol 3, Part H - 2.2.2 Random Address Hash function ah
     '''
@@ -157,16 +136,7 @@ def ah(k: bytes, r: bytes) -> bytes:  # pylint: disable=redefined-outer-name
 
 
 # -----------------------------------------------------------------------------
-def c1(
-    k: bytes,
-    r: bytes,
-    preq: bytes,
-    pres: bytes,
-    iat: int,
-    rat: int,
-    ia: bytes,
-    ra: bytes,
-) -> bytes:  # pylint: disable=redefined-outer-name
+def c1(k, r, preq, pres, iat, rat, ia, ra):  # pylint: disable=redefined-outer-name
     '''
     See Bluetooth spec, Vol 3, Part H - 2.2.3 Confirm value generation function c1 for
     LE Legacy Pairing
@@ -178,7 +148,7 @@ def c1(
 
 
 # -----------------------------------------------------------------------------
-def s1(k: bytes, r1: bytes, r2: bytes) -> bytes:
+def s1(k, r1, r2):
     '''
     See Bluetooth spec, Vol 3, Part H - 2.2.4 Key generation function s1 for LE Legacy
     Pairing
@@ -188,7 +158,7 @@ def s1(k: bytes, r1: bytes, r2: bytes) -> bytes:
 
 
 # -----------------------------------------------------------------------------
-def aes_cmac(m: bytes, k: bytes) -> bytes:
+def aes_cmac(m, k):
     '''
     See Bluetooth spec, Vol 3, Part H - 2.2.5 FunctionAES-CMAC
 
@@ -200,16 +170,20 @@ def aes_cmac(m: bytes, k: bytes) -> bytes:
 
 
 # -----------------------------------------------------------------------------
-def f4(u: bytes, v: bytes, x: bytes, z: bytes) -> bytes:
+def f4(u, v, x, z):
     '''
     See Bluetooth spec, Vol 3, Part H - 2.2.6 LE Secure Connections Confirm Value
     Generation Function f4
     '''
-    return reverse(aes_cmac(reverse(u) + reverse(v) + z, reverse(x)))
+    return bytes(
+        reversed(
+            aes_cmac(bytes(reversed(u)) + bytes(reversed(v)) + z, bytes(reversed(x)))
+        )
+    )
 
 
 # -----------------------------------------------------------------------------
-def f5(w: bytes, n1: bytes, n2: bytes, a1: bytes, a2: bytes) -> Tuple[bytes, bytes]:
+def f5(w, n1, n2, a1, a2):
     '''
     See Bluetooth spec, Vol 3, Part H - 2.2.7 LE Secure Connections Key Generation
     Function f5
@@ -217,83 +191,87 @@ def f5(w: bytes, n1: bytes, n2: bytes, a1: bytes, a2: bytes) -> Tuple[bytes, byt
     NOTE: this returns a tuple: (MacKey, LTK) in little-endian byte order
     '''
     salt = bytes.fromhex('6C888391AAF5A53860370BDB5A6083BE')
-    t = aes_cmac(reverse(w), salt)
+    t = aes_cmac(bytes(reversed(w)), salt)
     key_id = bytes([0x62, 0x74, 0x6C, 0x65])
     return (
-        reverse(
-            aes_cmac(
-                bytes([0])
-                + key_id
-                + reverse(n1)
-                + reverse(n2)
-                + reverse(a1)
-                + reverse(a2)
-                + bytes([1, 0]),
-                t,
+        bytes(
+            reversed(
+                aes_cmac(
+                    bytes([0])
+                    + key_id
+                    + bytes(reversed(n1))
+                    + bytes(reversed(n2))
+                    + bytes(reversed(a1))
+                    + bytes(reversed(a2))
+                    + bytes([1, 0]),
+                    t,
+                )
             )
         ),
-        reverse(
-            aes_cmac(
-                bytes([1])
-                + key_id
-                + reverse(n1)
-                + reverse(n2)
-                + reverse(a1)
-                + reverse(a2)
-                + bytes([1, 0]),
-                t,
+        bytes(
+            reversed(
+                aes_cmac(
+                    bytes([1])
+                    + key_id
+                    + bytes(reversed(n1))
+                    + bytes(reversed(n2))
+                    + bytes(reversed(a1))
+                    + bytes(reversed(a2))
+                    + bytes([1, 0]),
+                    t,
+                )
             )
         ),
     )
 
 
 # -----------------------------------------------------------------------------
-def f6(
-    w: bytes, n1: bytes, n2: bytes, r: bytes, io_cap: bytes, a1: bytes, a2: bytes
-) -> bytes:  # pylint: disable=redefined-outer-name
+def f6(w, n1, n2, r, io_cap, a1, a2):  # pylint: disable=redefined-outer-name
     '''
     See Bluetooth spec, Vol 3, Part H - 2.2.8 LE Secure Connections Check Value
     Generation Function f6
     '''
-    return reverse(
-        aes_cmac(
-            reverse(n1)
-            + reverse(n2)
-            + reverse(r)
-            + reverse(io_cap)
-            + reverse(a1)
-            + reverse(a2),
-            reverse(w),
+    return bytes(
+        reversed(
+            aes_cmac(
+                bytes(reversed(n1))
+                + bytes(reversed(n2))
+                + bytes(reversed(r))
+                + bytes(reversed(io_cap))
+                + bytes(reversed(a1))
+                + bytes(reversed(a2)),
+                bytes(reversed(w)),
+            )
         )
     )
 
 
 # -----------------------------------------------------------------------------
-def g2(u: bytes, v: bytes, x: bytes, y: bytes) -> int:
+def g2(u, v, x, y):
     '''
     See Bluetooth spec, Vol 3, Part H - 2.2.9 LE Secure Connections Numeric Comparison
     Value Generation Function g2
     '''
     return int.from_bytes(
         aes_cmac(
-            reverse(u) + reverse(v) + reverse(y),
-            reverse(x),
+            bytes(reversed(u)) + bytes(reversed(v)) + bytes(reversed(y)),
+            bytes(reversed(x)),
         )[-4:],
         byteorder='big',
     )
 
 
 # -----------------------------------------------------------------------------
-def h6(w: bytes, key_id: bytes) -> bytes:
+def h6(w, key_id):
     '''
     See Bluetooth spec, Vol 3, Part H - 2.2.10 Link key conversion function h6
     '''
-    return reverse(aes_cmac(key_id, reverse(w)))
+    return aes_cmac(key_id, w)
 
 
 # -----------------------------------------------------------------------------
-def h7(salt: bytes, w: bytes) -> bytes:
+def h7(salt, w):
     '''
     See Bluetooth spec, Vol 3, Part H - 2.2.11 Link key conversion function h7
     '''
-    return reverse(aes_cmac(reverse(w), salt))
+    return aes_cmac(w, salt)

bumble/drivers/__init__.py

@@ -19,17 +19,10 @@ like loading firmware after a cold start.
 # -----------------------------------------------------------------------------
 # Imports
 # -----------------------------------------------------------------------------
-from __future__ import annotations
+import abc
 import logging
-import pathlib
-import platform
-from typing import Dict, Iterable, Optional, Type, TYPE_CHECKING
-
 from . import rtk
-from .common import Driver
 
-if TYPE_CHECKING:
-    from bumble.host import Host
 
 # -----------------------------------------------------------------------------
 # Logging
@@ -37,51 +30,39 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 
+# -----------------------------------------------------------------------------
+# Classes
+# -----------------------------------------------------------------------------
+class Driver(abc.ABC):
+    """Base class for drivers."""
+
+    @staticmethod
+    async def for_host(_host):
+        """Return a driver instance for a host.
+
+        Args:
+            host: Host object for which a driver should be created.
+
+        Returns:
+            A Driver instance if a driver should be instantiated for this host, or
+            None if no driver instance of this class is needed.
+        """
+        return None
+
+    @abc.abstractmethod
+    async def init_controller(self):
+        """Initialize the controller."""
+
+
 # -----------------------------------------------------------------------------
 # Functions
 # -----------------------------------------------------------------------------
-async def get_driver_for_host(host: Host) -> Optional[Driver]:
-    """Probe diver classes until one returns a valid instance for a host, or none is
-    found.
-    If a "driver" HCI metadata entry is present, only that driver class will be probed.
+async def get_driver_for_host(host):
+    """Probe all known diver classes until one returns a valid instance for a host,
+    or none is found.
     """
-    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
-        probe_list = [driver_name]
-    else:
-        # Probe all drivers
-        probe_list = driver_classes.keys()
-
-    for driver_name in probe_list:
-        if driver_class := driver_classes.get(driver_name):
-            logger.debug(f"Probing driver class: {driver_name}")
-            if driver := await driver_class.for_host(host):
-                logger.debug(f"Instantiated {driver_name} driver")
-                return driver
-        else:
-            logger.debug(f"Skipping unknown driver class: {driver_name}")
+    if driver := await rtk.Driver.for_host(host):
+        logger.debug("Instantiated RTK driver")
+        return driver
 
     return None
-
-
-def project_data_dir() -> pathlib.Path:
-    """
-    Returns:
-        A path to an OS-specific directory for bumble data. The directory is created if
-         it doesn't exist.
-    """
-    import platformdirs
-
-    if platform.system() == 'Darwin':
-        # platformdirs doesn't handle macOS right: it doesn't assemble a bundle id
-        # out of author & project
-        return platformdirs.user_data_path(
-            appname='com.google.bumble', ensure_exists=True
-        )
-    else:
-        # windows and linux don't use the com qualifier
-        return platformdirs.user_data_path(
-            appname='bumble', appauthor='google', ensure_exists=True
-        )

bumble/drivers/common.py

@@ -1,45 +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.
-"""
-Common types for drivers.
-"""
-
-# -----------------------------------------------------------------------------
-# Imports
-# -----------------------------------------------------------------------------
-import abc
-
-
-# -----------------------------------------------------------------------------
-# Classes
-# -----------------------------------------------------------------------------
-class Driver(abc.ABC):
-    """Base class for drivers."""
-
-    @staticmethod
-    async def for_host(_host):
-        """Return a driver instance for a host.
-
-        Args:
-            host: Host object for which a driver should be created.
-
-        Returns:
-            A Driver instance if a driver should be instantiated for this host, or
-            None if no driver instance of this class is needed.
-        """
-        return None
-
-    @abc.abstractmethod
-    async def init_controller(self):
-        """Initialize the controller."""

bumble/drivers/rtk.py

@@ -34,14 +34,15 @@ import weakref
 
 
 from bumble.hci import (
-    hci_vendor_command_op_code,
+    hci_command_op_code,
     STATUS_SPEC,
     HCI_SUCCESS,
+    HCI_COMMAND_NAMES,
     HCI_Command,
     HCI_Reset_Command,
     HCI_Read_Local_Version_Information_Command,
 )
-from bumble.drivers import common
+
 
 # -----------------------------------------------------------------------------
 # Logging
@@ -124,7 +125,6 @@ RTK_USB_PRODUCTS = {
     (0x2550, 0x8761),
     (0x2B89, 0x8761),
     (0x7392, 0xC611),
-    (0x0BDA, 0x877B),
     # Realtek 8821AE
     (0x0B05, 0x17DC),
     (0x13D3, 0x3414),
@@ -178,10 +178,8 @@ RTK_USB_PRODUCTS = {
 # -----------------------------------------------------------------------------
 # HCI Commands
 # -----------------------------------------------------------------------------
-HCI_RTK_READ_ROM_VERSION_COMMAND = hci_vendor_command_op_code(0x6D)
-HCI_RTK_DOWNLOAD_COMMAND = hci_vendor_command_op_code(0x20)
-HCI_RTK_DROP_FIRMWARE_COMMAND = hci_vendor_command_op_code(0x66)
-HCI_Command.register_commands(globals())
+HCI_RTK_READ_ROM_VERSION_COMMAND = hci_command_op_code(0x3F, 0x6D)
+HCI_COMMAND_NAMES[HCI_RTK_READ_ROM_VERSION_COMMAND] = "HCI_RTK_READ_ROM_VERSION_COMMAND"
 
 
 @HCI_Command.command(return_parameters_fields=[("status", STATUS_SPEC), ("version", 1)])
@@ -189,6 +187,10 @@ class HCI_RTK_Read_ROM_Version_Command(HCI_Command):
     pass
 
 
+HCI_RTK_DOWNLOAD_COMMAND = hci_command_op_code(0x3F, 0x20)
+HCI_COMMAND_NAMES[HCI_RTK_DOWNLOAD_COMMAND] = "HCI_RTK_DOWNLOAD_COMMAND"
+
+
 @HCI_Command.command(
     fields=[("index", 1), ("payload", RTK_FRAGMENT_LENGTH)],
     return_parameters_fields=[("status", STATUS_SPEC), ("index", 1)],
@@ -197,6 +199,10 @@ class HCI_RTK_Download_Command(HCI_Command):
     pass
 
 
+HCI_RTK_DROP_FIRMWARE_COMMAND = hci_command_op_code(0x3F, 0x66)
+HCI_COMMAND_NAMES[HCI_RTK_DROP_FIRMWARE_COMMAND] = "HCI_RTK_DROP_FIRMWARE_COMMAND"
+
+
 @HCI_Command.command()
 class HCI_RTK_Drop_Firmware_Command(HCI_Command):
     pass
@@ -285,7 +291,7 @@ class Firmware:
             )
 
 
-class Driver(common.Driver):
+class Driver:
     @dataclass
     class DriverInfo:
         rom: int
@@ -439,11 +445,6 @@ class Driver(common.Driver):
             # When the environment variable is set, don't look elsewhere
             return None
 
-        # Then, look where the firmware download tool writes by default
-        if (path := rtk_firmware_dir() / file_name).is_file():
-            logger.debug(f"{file_name} found in project data dir")
-            return path
-
         # Then, look in the package's driver directory
         if (path := pathlib.Path(__file__).parent / "rtk_fw" / file_name).is_file():
             logger.debug(f"{file_name} found in package dir")
@@ -470,12 +471,8 @@ class Driver(common.Driver):
             logger.debug("USB metadata not found")
             return False
 
-        if host.hci_metadata.get('driver') == 'rtk':
-            # Forced driver
-            return True
-
-        vendor_id = host.hci_metadata.get("vendor_id")
-        product_id = host.hci_metadata.get("product_id")
+        vendor_id = host.hci_metadata.get("vendor_id", None)
+        product_id = host.hci_metadata.get("product_id", None)
         if vendor_id is None or product_id is None:
             logger.debug("USB metadata not sufficient")
             return False
@@ -490,9 +487,6 @@ class Driver(common.Driver):
 
     @classmethod
     async def driver_info_for_host(cls, host):
-        await host.send_command(HCI_Reset_Command(), check_result=True)
-        host.ready = True  # Needed to let the host know the controller is ready.
-
         response = await host.send_command(
             HCI_Read_Local_Version_Information_Command(), check_result=True
         )
@@ -651,16 +645,3 @@ class Driver(common.Driver):
         await self.download_firmware()
         await self.host.send_command(HCI_Reset_Command(), check_result=True)
         logger.info(f"loaded FW image {self.driver_info.fw_name}")
-
-
-def rtk_firmware_dir() -> pathlib.Path:
-    """
-    Returns:
-        A path to a subdir of the project data dir for Realtek firmware.
-         The directory is created if it doesn't exist.
-    """
-    from bumble.drivers import project_data_dir
-
-    p = project_data_dir() / "firmware" / "realtek"
-    p.mkdir(parents=True, exist_ok=True)
-    return p

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, List
 
-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
 
 
 # -----------------------------------------------------------------------------
@@ -105,35 +93,20 @@ GATT_RECONNECTION_CONFIGURATION_SERVICE     = UUID.from_16_bits(0x1829, 'Reconne
 GATT_INSULIN_DELIVERY_SERVICE               = UUID.from_16_bits(0x183A, 'Insulin Delivery')
 GATT_BINARY_SENSOR_SERVICE                  = UUID.from_16_bits(0x183B, 'Binary Sensor')
 GATT_EMERGENCY_CONFIGURATION_SERVICE        = UUID.from_16_bits(0x183C, 'Emergency Configuration')
-GATT_AUTHORIZATION_CONTROL_SERVICE          = UUID.from_16_bits(0x183D, 'Authorization Control')
 GATT_PHYSICAL_ACTIVITY_MONITOR_SERVICE      = UUID.from_16_bits(0x183E, 'Physical Activity Monitor')
-GATT_ELAPSED_TIME_SERVICE                   = UUID.from_16_bits(0x183F, 'Elapsed Time')
-GATT_GENERIC_HEALTH_SENSOR_SERVICE          = UUID.from_16_bits(0x1840, 'Generic Health Sensor')
 GATT_AUDIO_INPUT_CONTROL_SERVICE            = UUID.from_16_bits(0x1843, 'Audio Input Control')
 GATT_VOLUME_CONTROL_SERVICE                 = UUID.from_16_bits(0x1844, 'Volume Control')
 GATT_VOLUME_OFFSET_CONTROL_SERVICE          = UUID.from_16_bits(0x1845, 'Volume Offset Control')
-GATT_COORDINATED_SET_IDENTIFICATION_SERVICE = UUID.from_16_bits(0x1846, 'Coordinated Set Identification')
+GATT_COORDINATED_SET_IDENTIFICATION_SERVICE = UUID.from_16_bits(0x1846, 'Coordinated Set Identification Service')
 GATT_DEVICE_TIME_SERVICE                    = UUID.from_16_bits(0x1847, 'Device Time')
-GATT_MEDIA_CONTROL_SERVICE                  = UUID.from_16_bits(0x1848, 'Media Control')
-GATT_GENERIC_MEDIA_CONTROL_SERVICE          = UUID.from_16_bits(0x1849, 'Generic Media Control')
+GATT_MEDIA_CONTROL_SERVICE                  = UUID.from_16_bits(0x1848, 'Media Control Service')
+GATT_GENERIC_MEDIA_CONTROL_SERVICE          = UUID.from_16_bits(0x1849, 'Generic Media Control Service')
 GATT_CONSTANT_TONE_EXTENSION_SERVICE        = UUID.from_16_bits(0x184A, 'Constant Tone Extension')
-GATT_TELEPHONE_BEARER_SERVICE               = UUID.from_16_bits(0x184B, 'Telephone Bearer')
-GATT_GENERIC_TELEPHONE_BEARER_SERVICE       = UUID.from_16_bits(0x184C, 'Generic Telephone Bearer')
+GATT_TELEPHONE_BEARER_SERVICE               = UUID.from_16_bits(0x184B, 'Telephone Bearer Service')
+GATT_GENERIC_TELEPHONE_BEARER_SERVICE       = UUID.from_16_bits(0x184C, 'Generic Telephone Bearer Service')
 GATT_MICROPHONE_CONTROL_SERVICE             = UUID.from_16_bits(0x184D, 'Microphone Control')
-GATT_AUDIO_STREAM_CONTROL_SERVICE           = UUID.from_16_bits(0x184E, 'Audio Stream Control')
-GATT_BROADCAST_AUDIO_SCAN_SERVICE           = UUID.from_16_bits(0x184F, 'Broadcast Audio Scan')
-GATT_PUBLISHED_AUDIO_CAPABILITIES_SERVICE   = UUID.from_16_bits(0x1850, 'Published Audio Capabilities')
-GATT_BASIC_AUDIO_ANNOUNCEMENT_SERVICE       = UUID.from_16_bits(0x1851, 'Basic Audio Announcement')
-GATT_BROADCAST_AUDIO_ANNOUNCEMENT_SERVICE   = UUID.from_16_bits(0x1852, 'Broadcast Audio Announcement')
-GATT_COMMON_AUDIO_SERVICE                   = UUID.from_16_bits(0x1853, 'Common Audio')
-GATT_HEARING_ACCESS_SERVICE                 = UUID.from_16_bits(0x1854, 'Hearing Access')
-GATT_TELEPHONY_AND_MEDIA_AUDIO_SERVICE      = UUID.from_16_bits(0x1855, 'Telephony and Media Audio')
-GATT_PUBLIC_BROADCAST_ANNOUNCEMENT_SERVICE  = UUID.from_16_bits(0x1856, 'Public Broadcast Announcement')
-GATT_ELECTRONIC_SHELF_LABEL_SERVICE         = UUID.from_16_bits(0X1857, 'Electronic Shelf Label')
-GATT_GAMING_AUDIO_SERVICE                   = UUID.from_16_bits(0x1858, 'Gaming Audio')
-GATT_MESH_PROXY_SOLICITATION_SERVICE        = UUID.from_16_bits(0x1859, 'Mesh Audio Solicitation')
 
-# Attribute Types
+# Types
 GATT_PRIMARY_SERVICE_ATTRIBUTE_TYPE   = UUID.from_16_bits(0x2800, 'Primary Service')
 GATT_SECONDARY_SERVICE_ATTRIBUTE_TYPE = UUID.from_16_bits(0x2801, 'Secondary Service')
 GATT_INCLUDE_ATTRIBUTE_TYPE           = UUID.from_16_bits(0x2802, 'Include')
@@ -156,8 +129,6 @@ GATT_ENVIRONMENTAL_SENSING_MEASUREMENT_DESCRIPTOR    = UUID.from_16_bits(0x290C,
 GATT_ENVIRONMENTAL_SENSING_TRIGGER_DESCRIPTOR        = UUID.from_16_bits(0x290D, 'Environmental Sensing Trigger Setting')
 GATT_TIME_TRIGGER_DESCRIPTOR                         = UUID.from_16_bits(0x290E, 'Time Trigger Setting')
 GATT_COMPLETE_BR_EDR_TRANSPORT_BLOCK_DATA_DESCRIPTOR = UUID.from_16_bits(0x290F, 'Complete BR-EDR Transport Block Data')
-GATT_OBSERVATION_SCHEDULE_DESCRIPTOR                 = UUID.from_16_bits(0x290F, 'Observation Schedule')
-GATT_VALID_RANGE_AND_ACCURACY_DESCRIPTOR             = UUID.from_16_bits(0x290F, 'Valid Range And Accuracy')
 
 # Device Information Service
 GATT_SYSTEM_ID_CHARACTERISTIC                          = UUID.from_16_bits(0x2A23, 'System ID')
@@ -185,96 +156,6 @@ GATT_HEART_RATE_CONTROL_POINT_CHARACTERISTIC = UUID.from_16_bits(0x2A39, 'Heart
 # Battery Service
 GATT_BATTERY_LEVEL_CHARACTERISTIC = UUID.from_16_bits(0x2A19, 'Battery Level')
 
-# Telephony And Media Audio Service (TMAS)
-GATT_TMAP_ROLE_CHARACTERISTIC = UUID.from_16_bits(0x2B51, 'TMAP Role')
-
-# Audio Input Control Service (AICS)
-GATT_AUDIO_INPUT_STATE_CHARACTERISTIC         = UUID.from_16_bits(0x2B77, 'Audio Input State')
-GATT_GAIN_SETTINGS_ATTRIBUTE_CHARACTERISTIC   = UUID.from_16_bits(0x2B78, 'Gain Settings Attribute')
-GATT_AUDIO_INPUT_TYPE_CHARACTERISTIC          = UUID.from_16_bits(0x2B79, 'Audio Input Type')
-GATT_AUDIO_INPUT_STATUS_CHARACTERISTIC        = UUID.from_16_bits(0x2B7A, 'Audio Input Status')
-GATT_AUDIO_INPUT_CONTROL_POINT_CHARACTERISTIC = UUID.from_16_bits(0x2B7B, 'Audio Input Control Point')
-GATT_AUDIO_INPUT_DESCRIPTION_CHARACTERISTIC   = UUID.from_16_bits(0x2B7C, 'Audio Input Description')
-
-# Volume Control Service (VCS)
-GATT_VOLUME_STATE_CHARACTERISTIC                = UUID.from_16_bits(0x2B7D, 'Volume State')
-GATT_VOLUME_CONTROL_POINT_CHARACTERISTIC        = UUID.from_16_bits(0x2B7E, 'Volume Control Point')
-GATT_VOLUME_FLAGS_CHARACTERISTIC                = UUID.from_16_bits(0x2B7F, 'Volume Flags')
-
-# Volume Offset Control Service (VOCS)
-GATT_VOLUME_OFFSET_STATE_CHARACTERISTIC         = UUID.from_16_bits(0x2B80, 'Volume Offset State')
-GATT_AUDIO_LOCATION_CHARACTERISTIC              = UUID.from_16_bits(0x2B81, 'Audio Location')
-GATT_VOLUME_OFFSET_CONTROL_POINT_CHARACTERISTIC = UUID.from_16_bits(0x2B82, 'Volume Offset Control Point')
-GATT_AUDIO_OUTPUT_DESCRIPTION_CHARACTERISTIC    = UUID.from_16_bits(0x2B83, 'Audio Output Description')
-
-# Coordinated Set Identification Service (CSIS)
-GATT_SET_IDENTITY_RESOLVING_KEY_CHARACTERISTIC  = UUID.from_16_bits(0x2B84, 'Set Identity Resolving Key')
-GATT_COORDINATED_SET_SIZE_CHARACTERISTIC        = UUID.from_16_bits(0x2B85, 'Coordinated Set Size')
-GATT_SET_MEMBER_LOCK_CHARACTERISTIC             = UUID.from_16_bits(0x2B86, 'Set Member Lock')
-GATT_SET_MEMBER_RANK_CHARACTERISTIC             = UUID.from_16_bits(0x2B87, 'Set Member Rank')
-
-# Media Control Service (MCS)
-GATT_MEDIA_PLAYER_NAME_CHARACTERISTIC                     = UUID.from_16_bits(0x2B93, 'Media Player Name')
-GATT_MEDIA_PLAYER_ICON_OBJECT_ID_CHARACTERISTIC           = UUID.from_16_bits(0x2B94, 'Media Player Icon Object ID')
-GATT_MEDIA_PLAYER_ICON_URL_CHARACTERISTIC                 = UUID.from_16_bits(0x2B95, 'Media Player Icon URL')
-GATT_TRACK_CHANGED_CHARACTERISTIC                         = UUID.from_16_bits(0x2B96, 'Track Changed')
-GATT_TRACK_TITLE_CHARACTERISTIC                           = UUID.from_16_bits(0x2B97, 'Track Title')
-GATT_TRACK_DURATION_CHARACTERISTIC                        = UUID.from_16_bits(0x2B98, 'Track Duration')
-GATT_TRACK_POSITION_CHARACTERISTIC                        = UUID.from_16_bits(0x2B99, 'Track Position')
-GATT_PLAYBACK_SPEED_CHARACTERISTIC                        = UUID.from_16_bits(0x2B9A, 'Playback Speed')
-GATT_SEEKING_SPEED_CHARACTERISTIC                         = UUID.from_16_bits(0x2B9B, 'Seeking Speed')
-GATT_CURRENT_TRACK_SEGMENTS_OBJECT_ID_CHARACTERISTIC      = UUID.from_16_bits(0x2B9C, 'Current Track Segments Object ID')
-GATT_CURRENT_TRACK_OBJECT_ID_CHARACTERISTIC               = UUID.from_16_bits(0x2B9D, 'Current Track Object ID')
-GATT_NEXT_TRACK_OBJECT_ID_CHARACTERISTIC                  = UUID.from_16_bits(0x2B9E, 'Next Track Object ID')
-GATT_PARENT_GROUP_OBJECT_ID_CHARACTERISTIC                = UUID.from_16_bits(0x2B9F, 'Parent Group Object ID')
-GATT_CURRENT_GROUP_OBJECT_ID_CHARACTERISTIC               = UUID.from_16_bits(0x2BA0, 'Current Group Object ID')
-GATT_PLAYING_ORDER_CHARACTERISTIC                         = UUID.from_16_bits(0x2BA1, 'Playing Order')
-GATT_PLAYING_ORDERS_SUPPORTED_CHARACTERISTIC              = UUID.from_16_bits(0x2BA2, 'Playing Orders Supported')
-GATT_MEDIA_STATE_CHARACTERISTIC                           = UUID.from_16_bits(0x2BA3, 'Media State')
-GATT_MEDIA_CONTROL_POINT_CHARACTERISTIC                   = UUID.from_16_bits(0x2BA4, 'Media Control Point')
-GATT_MEDIA_CONTROL_POINT_OPCODES_SUPPORTED_CHARACTERISTIC = UUID.from_16_bits(0x2BA5, 'Media Control Point Opcodes Supported')
-GATT_SEARCH_RESULTS_OBJECT_ID_CHARACTERISTIC              = UUID.from_16_bits(0x2BA6, 'Search Results Object ID')
-GATT_SEARCH_CONTROL_POINT_CHARACTERISTIC                  = UUID.from_16_bits(0x2BA7, 'Search Control Point')
-GATT_CONTENT_CONTROL_ID_CHARACTERISTIC                    = UUID.from_16_bits(0x2BBA, 'Content Control Id')
-
-# Telephone Bearer Service (TBS)
-GATT_BEARER_PROVIDER_NAME_CHARACTERISTIC                      = UUID.from_16_bits(0x2BB4, 'Bearer Provider Name')
-GATT_BEARER_UCI_CHARACTERISTIC                                = UUID.from_16_bits(0x2BB5, 'Bearer UCI')
-GATT_BEARER_TECHNOLOGY_CHARACTERISTIC                         = UUID.from_16_bits(0x2BB6, 'Bearer Technology')
-GATT_BEARER_URI_SCHEMES_SUPPORTED_LIST_CHARACTERISTIC         = UUID.from_16_bits(0x2BB7, 'Bearer URI Schemes Supported List')
-GATT_BEARER_SIGNAL_STRENGTH_CHARACTERISTIC                    = UUID.from_16_bits(0x2BB8, 'Bearer Signal Strength')
-GATT_BEARER_SIGNAL_STRENGTH_REPORTING_INTERVAL_CHARACTERISTIC = UUID.from_16_bits(0x2BB9, 'Bearer Signal Strength Reporting Interval')
-GATT_BEARER_LIST_CURRENT_CALLS_CHARACTERISTIC                 = UUID.from_16_bits(0x2BBA, 'Bearer List Current Calls')
-GATT_CONTENT_CONTROL_ID_CHARACTERISTIC                        = UUID.from_16_bits(0x2BBB, 'Content Control ID')
-GATT_STATUS_FLAGS_CHARACTERISTIC                              = UUID.from_16_bits(0x2BBC, 'Status Flags')
-GATT_INCOMING_CALL_TARGET_BEARER_URI_CHARACTERISTIC           = UUID.from_16_bits(0x2BBD, 'Incoming Call Target Bearer URI')
-GATT_CALL_STATE_CHARACTERISTIC                                = UUID.from_16_bits(0x2BBE, 'Call State')
-GATT_CALL_CONTROL_POINT_CHARACTERISTIC                        = UUID.from_16_bits(0x2BBF, 'Call Control Point')
-GATT_CALL_CONTROL_POINT_OPTIONAL_OPCODES_CHARACTERISTIC       = UUID.from_16_bits(0x2BC0, 'Call Control Point Optional Opcodes')
-GATT_TERMINATION_REASON_CHARACTERISTIC                        = UUID.from_16_bits(0x2BC1, 'Termination Reason')
-GATT_INCOMING_CALL_CHARACTERISTIC                             = UUID.from_16_bits(0x2BC2, 'Incoming Call')
-GATT_CALL_FRIENDLY_NAME_CHARACTERISTIC                        = UUID.from_16_bits(0x2BC3, 'Call Friendly Name')
-
-# Microphone Control Service (MICS)
-GATT_MUTE_CHARACTERISTIC = UUID.from_16_bits(0x2BC3, 'Mute')
-
-# Audio Stream Control Service (ASCS)
-GATT_SINK_ASE_CHARACTERISTIC                    = UUID.from_16_bits(0x2BC4, 'Sink ASE')
-GATT_SOURCE_ASE_CHARACTERISTIC                  = UUID.from_16_bits(0x2BC5, 'Source ASE')
-GATT_ASE_CONTROL_POINT_CHARACTERISTIC           = UUID.from_16_bits(0x2BC6, 'ASE Control Point')
-
-# Broadcast Audio Scan Service (BASS)
-GATT_BROADCAST_AUDIO_SCAN_CONTROL_POINT_CHARACTERISTIC = UUID.from_16_bits(0x2BC7, 'Broadcast Audio Scan Control Point')
-GATT_BROADCAST_RECEIVE_STATE_CHARACTERISTIC            = UUID.from_16_bits(0x2BC8, 'Broadcast Receive State')
-
-# Published Audio Capabilities Service (PACS)
-GATT_SINK_PAC_CHARACTERISTIC                    = UUID.from_16_bits(0x2BC9, 'Sink PAC')
-GATT_SINK_AUDIO_LOCATION_CHARACTERISTIC         = UUID.from_16_bits(0x2BCA, 'Sink Audio Location')
-GATT_SOURCE_PAC_CHARACTERISTIC                  = UUID.from_16_bits(0x2BCB, 'Source PAC')
-GATT_SOURCE_AUDIO_LOCATION_CHARACTERISTIC       = UUID.from_16_bits(0x2BCC, 'Source Audio Location')
-GATT_AVAILABLE_AUDIO_CONTEXTS_CHARACTERISTIC    = UUID.from_16_bits(0x2BCD, 'Available Audio Contexts')
-GATT_SUPPORTED_AUDIO_CONTEXTS_CHARACTERISTIC    = UUID.from_16_bits(0x2BCE, 'Supported Audio Contexts')
-
 # ASHA Service
 GATT_ASHA_SERVICE                             = UUID.from_16_bits(0xFDF0, 'Audio Streaming for Hearing Aid')
 GATT_ASHA_READ_ONLY_PROPERTIES_CHARACTERISTIC = UUID('6333651e-c481-4a3e-9169-7c902aad37bb', 'ReadOnlyProperties')
@@ -296,9 +177,6 @@ GATT_BOOT_KEYBOARD_INPUT_REPORT_CHARACTERISTIC                 = UUID.from_16_bi
 GATT_CURRENT_TIME_CHARACTERISTIC                               = UUID.from_16_bits(0x2A2B, 'Current Time')
 GATT_BOOT_KEYBOARD_OUTPUT_REPORT_CHARACTERISTIC                = UUID.from_16_bits(0x2A32, 'Boot Keyboard Output Report')
 GATT_CENTRAL_ADDRESS_RESOLUTION__CHARACTERISTIC                = UUID.from_16_bits(0x2AA6, 'Central Address Resolution')
-GATT_CLIENT_SUPPORTED_FEATURES_CHARACTERISTIC                  = UUID.from_16_bits(0x2B29, 'Client Supported Features')
-GATT_DATABASE_HASH_CHARACTERISTIC                              = UUID.from_16_bits(0x2B2A, 'Database Hash')
-GATT_SERVER_SUPPORTED_FEATURES_CHARACTERISTIC                  = UUID.from_16_bits(0x2B3A, 'Server Supported Features')
 
 # fmt: on
 # pylint: enable=line-too-long
@@ -309,7 +187,7 @@ GATT_SERVER_SUPPORTED_FEATURES_CHARACTERISTIC                  = UUID.from_16_bi
 # -----------------------------------------------------------------------------
 
 
-def show_services(services: Iterable[Service]) -> None:
+def show_services(services):
     for service in services:
         print(color(str(service), 'cyan'))
 
@@ -332,11 +210,11 @@ class Service(Attribute):
 
     def __init__(
         self,
-        uuid: Union[str, UUID],
+        uuid,
         characteristics: List[Characteristic],
         primary=True,
         included_services: List[Service] = [],
-    ) -> None:
+    ):
         # Convert the uuid to a UUID object if it isn't already
         if isinstance(uuid, str):
             uuid = UUID(uuid)
@@ -361,7 +239,7 @@ class Service(Attribute):
         """
         return None
 
-    def __str__(self) -> str:
+    def __str__(self):
         return (
             f'Service(handle=0x{self.handle:04X}, '
             f'end=0x{self.end_group_handle:04X}, '
@@ -377,15 +255,10 @@ class TemplateService(Service):
     to expose their UUID as a class property
     '''
 
-    UUID: UUID
+    UUID: Optional[UUID] = None
 
-    def __init__(
-        self,
-        characteristics: List[Characteristic],
-        primary: bool = True,
-        included_services: List[Service] = [],
-    ) -> None:
-        super().__init__(self.UUID, characteristics, primary, included_services)
+    def __init__(self, characteristics, primary=True):
+        super().__init__(self.UUID, characteristics, primary)
 
 
 # -----------------------------------------------------------------------------
@@ -396,7 +269,7 @@ class IncludedServiceDeclaration(Attribute):
 
     service: Service
 
-    def __init__(self, service: Service) -> None:
+    def __init__(self, service):
         declaration_bytes = struct.pack(
             '<HH2s', service.handle, service.end_group_handle, service.uuid.to_bytes()
         )
@@ -405,12 +278,13 @@ class IncludedServiceDeclaration(Attribute):
         )
         self.service = service
 
-    def __str__(self) -> str:
+    def __str__(self):
         return (
             f'IncludedServiceDefinition(handle=0x{self.handle:04X}, '
             f'group_starting_handle=0x{self.service.handle:04X}, '
             f'group_ending_handle=0x{self.service.end_group_handle:04X}, '
-            f'uuid={self.service.uuid})'
+            f'uuid={self.service.uuid}, '
+            f'{self.service.properties!s})'
         )
 
 
@@ -435,33 +309,31 @@ class Characteristic(Attribute):
         AUTHENTICATED_SIGNED_WRITES = 0x40
         EXTENDED_PROPERTIES = 0x80
 
-        @classmethod
-        def from_string(cls, properties_str: str) -> Characteristic.Properties:
+        @staticmethod
+        def from_string(properties_str: str) -> Characteristic.Properties:
+            property_names: List[str] = []
+            for property in Characteristic.Properties:
+                if property.name is None:
+                    raise TypeError()
+                property_names.append(property.name)
+
+            def string_to_property(property_string) -> Characteristic.Properties:
+                for property in zip(Characteristic.Properties, property_names):
+                    if property_string == property[1]:
+                        return property[0]
+                raise TypeError(f"Unable to convert {property_string} to Property")
+
             try:
                 return functools.reduce(
-                    lambda x, y: x | cls[y],
-                    properties_str.replace("|", ",").split(","),
+                    lambda x, y: x | string_to_property(y),
+                    properties_str.split(","),
                     Characteristic.Properties(0),
                 )
-            except (TypeError, KeyError):
-                # The check for `p.name is not None` here is needed because for InFlag
-                # enums, the .name property can be None, when the enum value is 0,
-                # so the type hint for .name is Optional[str].
-                enum_list: List[str] = [p.name for p in cls if p.name is not None]
-                enum_list_str = ",".join(enum_list)
+            except TypeError:
                 raise TypeError(
-                    f"Characteristic.Properties::from_string() error:\nExpected a string containing any of the keys, separated by , or |: {enum_list_str}\nGot: {properties_str}"
+                    f"Characteristic.Properties::from_string() error:\nExpected a string containing any of the keys, separated by commas: {','.join(property_names)}\nGot: {properties_str}"
                 )
 
-        def __str__(self) -> str:
-            # NOTE: we override this method to offer a consistent result between python
-            # versions: the value returned by IntFlag.__str__() changed in version 11.
-            return '|'.join(
-                flag.name
-                for flag in Characteristic.Properties
-                if self.value & flag.value and flag.name is not None
-            )
-
     # For backwards compatibility these are defined here
     # For new code, please use Characteristic.Properties.X
     BROADCAST = Properties.BROADCAST
@@ -475,10 +347,10 @@ class Characteristic(Attribute):
 
     def __init__(
         self,
-        uuid: Union[str, bytes, UUID],
+        uuid,
         properties: Characteristic.Properties,
-        permissions: Union[str, Attribute.Permissions],
-        value: Union[str, bytes, CharacteristicValue] = b'',
+        permissions,
+        value=b'',
         descriptors: Sequence[Descriptor] = (),
     ):
         super().__init__(uuid, permissions, value)
@@ -496,12 +368,12 @@ class Characteristic(Attribute):
     def has_properties(self, properties: Characteristic.Properties) -> bool:
         return self.properties & properties == properties
 
-    def __str__(self) -> str:
+    def __str__(self):
         return (
             f'Characteristic(handle=0x{self.handle:04X}, '
             f'end=0x{self.end_group_handle:04X}, '
             f'uuid={self.uuid}, '
-            f'{self.properties})'
+            f'{self.properties!s})'
         )
 
 
@@ -513,7 +385,7 @@ class CharacteristicDeclaration(Attribute):
 
     characteristic: Characteristic
 
-    def __init__(self, characteristic: Characteristic, value_handle: int) -> None:
+    def __init__(self, characteristic, value_handle):
         declaration_bytes = (
             struct.pack('<BH', characteristic.properties, value_handle)
             + characteristic.uuid.to_pdu_bytes()
@@ -524,53 +396,66 @@ class CharacteristicDeclaration(Attribute):
         self.value_handle = value_handle
         self.characteristic = characteristic
 
-    def __str__(self) -> str:
+    def __str__(self):
         return (
             f'CharacteristicDeclaration(handle=0x{self.handle:04X}, '
             f'value_handle=0x{self.value_handle:04X}, '
             f'uuid={self.characteristic.uuid}, '
-            f'{self.characteristic.properties})'
+            f'{self.characteristic.properties!s})'
         )
 
 
 # -----------------------------------------------------------------------------
-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):
@@ -589,13 +474,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)
         )
 
@@ -636,7 +519,7 @@ class CharacteristicAdapter:
 
         return self.wrapped_characteristic.unsubscribe(subscriber)
 
-    def __str__(self) -> str:
+    def __str__(self):
         wrapped = str(self.wrapped_characteristic)
         return f'{self.__class__.__name__}({wrapped})'
 
@@ -716,10 +599,10 @@ class UTF8CharacteristicAdapter(CharacteristicAdapter):
     Adapter that converts strings to/from bytes using UTF-8 encoding
     '''
 
-    def encode_value(self, value: str) -> bytes:
+    def encode_value(self, value):
         return value.encode('utf-8')
 
-    def decode_value(self, value: bytes) -> str:
+    def decode_value(self, value):
         return value.decode('utf-8')
 
 
@@ -729,25 +612,14 @@ class Descriptor(Attribute):
     See Vol 3, Part G - 3.3.3 Characteristic Descriptor Declarations
     '''
 
-    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 = '<...>'
+    def __str__(self):
         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

@@ -28,19 +28,7 @@ import asyncio
 import logging
 import struct
 from datetime import datetime
-from typing import (
-    List,
-    Optional,
-    Dict,
-    Tuple,
-    Callable,
-    Union,
-    Any,
-    Iterable,
-    Type,
-    Set,
-    TYPE_CHECKING,
-)
+from typing import List, Optional, Dict, Tuple, Callable, Union, Any
 
 from pyee import EventEmitter
 
@@ -78,12 +66,8 @@ from .gatt import (
     GATT_INCLUDE_ATTRIBUTE_TYPE,
     Characteristic,
     ClientCharacteristicConfigurationBits,
-    TemplateService,
 )
 
-if TYPE_CHECKING:
-    from bumble.device import Connection
-
 # -----------------------------------------------------------------------------
 # Logging
 # -----------------------------------------------------------------------------
@@ -94,16 +78,16 @@ logger = logging.getLogger(__name__)
 # Proxies
 # -----------------------------------------------------------------------------
 class AttributeProxy(EventEmitter):
-    def __init__(
-        self, client: Client, handle: int, end_group_handle: int, attribute_type: UUID
-    ) -> None:
+    client: Client
+
+    def __init__(self, client, handle, end_group_handle, attribute_type):
         EventEmitter.__init__(self)
         self.client = client
         self.handle = handle
         self.end_group_handle = end_group_handle
         self.type = attribute_type
 
-    async def read_value(self, no_long_read: bool = False) -> bytes:
+    async def read_value(self, no_long_read=False):
         return self.decode_value(
             await self.client.read_value(self.handle, no_long_read)
         )
@@ -113,13 +97,13 @@ class AttributeProxy(EventEmitter):
             self.handle, self.encode_value(value), with_response
         )
 
-    def encode_value(self, value: Any) -> bytes:
+    def encode_value(self, value):
         return value
 
-    def decode_value(self, value_bytes: bytes) -> Any:
+    def decode_value(self, value_bytes):
         return value_bytes
 
-    def __str__(self) -> str:
+    def __str__(self):
         return f'Attribute(handle=0x{self.handle:04X}, type={self.type})'
 
 
@@ -129,7 +113,7 @@ class ServiceProxy(AttributeProxy):
     included_services: List[ServiceProxy]
 
     @staticmethod
-    def from_client(service_class, client: Client, service_uuid: UUID):
+    def from_client(service_class, client, service_uuid):
         # The service and its characteristics are considered to have already been
         # discovered
         services = client.get_services_by_uuid(service_uuid)
@@ -152,14 +136,14 @@ class ServiceProxy(AttributeProxy):
     def get_characteristics_by_uuid(self, uuid):
         return self.client.get_characteristics_by_uuid(uuid, self)
 
-    def __str__(self) -> str:
+    def __str__(self):
         return f'Service(handle=0x{self.handle:04X}, uuid={self.uuid})'
 
 
 class CharacteristicProxy(AttributeProxy):
     properties: Characteristic.Properties
     descriptors: List[DescriptorProxy]
-    subscribers: Dict[Any, Callable[[bytes], Any]]
+    subscribers: Dict[Any, Callable]
 
     def __init__(
         self,
@@ -187,9 +171,7 @@ class CharacteristicProxy(AttributeProxy):
         return await self.client.discover_descriptors(self)
 
     async def subscribe(
-        self,
-        subscriber: Optional[Callable[[bytes], Any]] = None,
-        prefer_notify: bool = True,
+        self, subscriber: Optional[Callable] = None, prefer_notify=True
     ):
         if subscriber is not None:
             if subscriber in self.subscribers:
@@ -207,13 +189,13 @@ class CharacteristicProxy(AttributeProxy):
 
         return await self.client.subscribe(self, subscriber, prefer_notify)
 
-    async def unsubscribe(self, subscriber=None, force=False):
+    async def unsubscribe(self, subscriber=None):
         if subscriber in self.subscribers:
             subscriber = self.subscribers.pop(subscriber)
 
-        return await self.client.unsubscribe(self, subscriber, force)
+        return await self.client.unsubscribe(self, subscriber)
 
-    def __str__(self) -> str:
+    def __str__(self):
         return (
             f'Characteristic(handle=0x{self.handle:04X}, '
             f'uuid={self.uuid}, '
@@ -225,7 +207,7 @@ class DescriptorProxy(AttributeProxy):
     def __init__(self, client, handle, descriptor_type):
         super().__init__(client, handle, 0, descriptor_type)
 
-    def __str__(self) -> str:
+    def __str__(self):
         return f'Descriptor(handle=0x{self.handle:04X}, type={self.type})'
 
 
@@ -234,10 +216,8 @@ class ProfileServiceProxy:
     Base class for profile-specific service proxies
     '''
 
-    SERVICE_CLASS: Type[TemplateService]
-
     @classmethod
-    def from_client(cls, client: Client) -> ProfileServiceProxy:
+    def from_client(cls, client):
         return ServiceProxy.from_client(cls, client, cls.SERVICE_CLASS.UUID)
 
 
@@ -247,36 +227,30 @@ class ProfileServiceProxy:
 class Client:
     services: List[ServiceProxy]
     cached_values: Dict[int, Tuple[datetime, bytes]]
-    notification_subscribers: Dict[
-        int, Set[Union[CharacteristicProxy, Callable[[bytes], Any]]]
-    ]
-    indication_subscribers: Dict[
-        int, Set[Union[CharacteristicProxy, Callable[[bytes], Any]]]
-    ]
-    pending_response: Optional[asyncio.futures.Future[ATT_PDU]]
-    pending_request: Optional[ATT_PDU]
 
-    def __init__(self, connection: Connection) -> None:
+    def __init__(self, connection):
         self.connection = connection
         self.mtu_exchange_done = False
         self.request_semaphore = asyncio.Semaphore(1)
         self.pending_request = None
         self.pending_response = None
-        self.notification_subscribers = {}  # Subscriber set, by attribute handle
-        self.indication_subscribers = {}  # Subscriber set, by attribute handle
+        self.notification_subscribers = (
+            {}
+        )  # Notification subscribers, by attribute handle
+        self.indication_subscribers = {}  # Indication subscribers, by attribute handle
         self.services = []
         self.cached_values = {}
 
-    def send_gatt_pdu(self, pdu: bytes) -> None:
+    def send_gatt_pdu(self, pdu):
         self.connection.send_l2cap_pdu(ATT_CID, pdu)
 
-    async def send_command(self, command: ATT_PDU) -> None:
+    async def send_command(self, command):
         logger.debug(
             f'GATT Command from client: [0x{self.connection.handle:04X}] {command}'
         )
         self.send_gatt_pdu(command.to_bytes())
 
-    async def send_request(self, request: ATT_PDU):
+    async def send_request(self, request):
         logger.debug(
             f'GATT Request from client: [0x{self.connection.handle:04X}] {request}'
         )
@@ -305,14 +279,14 @@ class Client:
 
         return response
 
-    def send_confirmation(self, confirmation: ATT_Handle_Value_Confirmation) -> None:
+    def send_confirmation(self, confirmation):
         logger.debug(
             f'GATT Confirmation from client: [0x{self.connection.handle:04X}] '
             f'{confirmation}'
         )
         self.send_gatt_pdu(confirmation.to_bytes())
 
-    async def request_mtu(self, mtu: int) -> int:
+    async def request_mtu(self, mtu):
         # Check the range
         if mtu < ATT_DEFAULT_MTU:
             raise ValueError(f'MTU must be >= {ATT_DEFAULT_MTU}')
@@ -339,12 +313,10 @@ class Client:
 
         return self.connection.att_mtu
 
-    def get_services_by_uuid(self, uuid: UUID) -> List[ServiceProxy]:
+    def get_services_by_uuid(self, uuid):
         return [service for service in self.services if service.uuid == uuid]
 
-    def get_characteristics_by_uuid(
-        self, uuid: UUID, service: Optional[ServiceProxy] = None
-    ) -> List[CharacteristicProxy]:
+    def get_characteristics_by_uuid(self, uuid, service=None):
         services = [service] if service else self.services
         return [
             c
@@ -391,7 +363,7 @@ class Client:
         if not already_known:
             self.services.append(service)
 
-    async def discover_services(self, uuids: Iterable[UUID] = []) -> List[ServiceProxy]:
+    async def discover_services(self, uuids=None) -> List[ServiceProxy]:
         '''
         See Vol 3, Part G - 4.4.1 Discover All Primary Services
         '''
@@ -463,7 +435,7 @@ class Client:
 
         return services
 
-    async def discover_service(self, uuid: Union[str, UUID]) -> List[ServiceProxy]:
+    async def discover_service(self, uuid):
         '''
         See Vol 3, Part G - 4.4.2 Discover Primary Service by Service UUID
         '''
@@ -496,7 +468,7 @@ class Client:
                         f'{HCI_Constant.error_name(response.error_code)}'
                     )
                     # TODO raise appropriate exception
-                    return []
+                    return
                 break
 
             for attribute_handle, end_group_handle in response.handles_information:
@@ -508,7 +480,7 @@ class Client:
                     logger.warning(
                         f'bogus handle values: {attribute_handle} {end_group_handle}'
                     )
-                    return []
+                    return
 
                 # Create a service proxy for this service
                 service = ServiceProxy(
@@ -685,8 +657,8 @@ class Client:
     async def discover_descriptors(
         self,
         characteristic: Optional[CharacteristicProxy] = None,
-        start_handle: Optional[int] = None,
-        end_handle: Optional[int] = None,
+        start_handle=None,
+        end_handle=None,
     ) -> List[DescriptorProxy]:
         '''
         See Vol 3, Part G - 4.7.1 Discover All Characteristic Descriptors
@@ -749,7 +721,7 @@ class Client:
 
         return descriptors
 
-    async def discover_attributes(self) -> List[AttributeProxy]:
+    async def discover_attributes(self):
         '''
         Discover all attributes, regardless of type
         '''
@@ -792,12 +764,7 @@ class Client:
 
         return attributes
 
-    async def subscribe(
-        self,
-        characteristic: CharacteristicProxy,
-        subscriber: Optional[Callable[[bytes], Any]] = None,
-        prefer_notify: bool = True,
-    ) -> None:
+    async def subscribe(self, characteristic, subscriber=None, prefer_notify=True):
         # If we haven't already discovered the descriptors for this characteristic,
         # do it now
         if not characteristic.descriptors_discovered:
@@ -834,7 +801,6 @@ class Client:
         subscriber_set = subscribers.setdefault(characteristic.handle, set())
         if subscriber is not None:
             subscriber_set.add(subscriber)
-
         # Add the characteristic as a subscriber, which will result in the
         # characteristic emitting an 'update' event when a notification or indication
         # is received
@@ -842,18 +808,7 @@ class Client:
 
         await self.write_value(cccd, struct.pack('<H', bits), with_response=True)
 
-    async def unsubscribe(
-        self,
-        characteristic: CharacteristicProxy,
-        subscriber: Optional[Callable[[bytes], Any]] = None,
-        force: bool = False,
-    ) -> None:
-        '''
-        Unsubscribe from a characteristic.
-
-        If `force` is True, this will write zeros to the CCCD when there are no
-        subscribers left, even if there were already no registered subscribers.
-        '''
+    async def unsubscribe(self, characteristic, subscriber=None):
         # If we haven't already discovered the descriptors for this characteristic,
         # do it now
         if not characteristic.descriptors_discovered:
@@ -867,45 +822,29 @@ class Client:
             logger.warning('unsubscribing from characteristic with no CCCD descriptor')
             return
 
-        # Check if the characteristic has subscribers
-        if not (
-            characteristic.handle in self.notification_subscribers
-            or characteristic.handle in self.indication_subscribers
-        ):
-            if not force:
-                return
-
-        # Remove the subscriber(s)
         if subscriber is not None:
             # Remove matching subscriber from subscriber sets
             for subscriber_set in (
                 self.notification_subscribers,
                 self.indication_subscribers,
             ):
-                if (
-                    subscribers := subscriber_set.get(characteristic.handle)
-                ) and subscriber in subscribers:
+                subscribers = subscriber_set.get(characteristic.handle, [])
+                if subscriber in subscribers:
                     subscribers.remove(subscriber)
 
                     # Cleanup if we removed the last one
                     if not subscribers:
                         del subscriber_set[characteristic.handle]
         else:
-            # Remove all subscribers for this attribute from the sets
+            # Remove all subscribers for this attribute from the sets!
             self.notification_subscribers.pop(characteristic.handle, None)
             self.indication_subscribers.pop(characteristic.handle, None)
 
-        # Update the CCCD
-        if not (
-            characteristic.handle in self.notification_subscribers
-            or characteristic.handle in self.indication_subscribers
-        ):
+        if not self.notification_subscribers and not self.indication_subscribers:
             # No more subscribers left
             await self.write_value(cccd, b'\x00\x00', with_response=True)
 
-    async def read_value(
-        self, attribute: Union[int, AttributeProxy], no_long_read: bool = False
-    ) -> bytes:
+    async def read_value(self, attribute, no_long_read=False):
         '''
         See Vol 3, Part G - 4.8.1 Read Characteristic Value
 
@@ -966,9 +905,7 @@ class Client:
         # Return the value as bytes
         return attribute_value
 
-    async def read_characteristics_by_uuid(
-        self, uuid: UUID, service: Optional[ServiceProxy]
-    ) -> List[bytes]:
+    async def read_characteristics_by_uuid(self, uuid, service):
         '''
         See Vol 3, Part G - 4.8.2 Read Using Characteristic UUID
         '''
@@ -1023,12 +960,7 @@ class Client:
 
         return characteristics_values
 
-    async def write_value(
-        self,
-        attribute: Union[int, AttributeProxy],
-        value: bytes,
-        with_response: bool = False,
-    ) -> None:
+    async def write_value(self, attribute, value, with_response=False):
         '''
         See Vol 3, Part G - 4.9.1 Write Without Response & 4.9.3 Write Characteristic
         Value
@@ -1058,7 +990,7 @@ class Client:
                 )
             )
 
-    def on_gatt_pdu(self, att_pdu: ATT_PDU) -> None:
+    def on_gatt_pdu(self, att_pdu):
         logger.debug(
             f'GATT Response to client: [0x{self.connection.handle:04X}] {att_pdu}'
         )
@@ -1081,7 +1013,6 @@ class Client:
                     return
 
             # Return the response to the coroutine that is waiting for it
-            assert self.pending_response is not None
             self.pending_response.set_result(att_pdu)
         else:
             handler_name = f'on_{att_pdu.name.lower()}'
@@ -1101,7 +1032,7 @@ class Client:
     def on_att_handle_value_notification(self, notification):
         # Call all subscribers
         subscribers = self.notification_subscribers.get(
-            notification.attribute_handle, set()
+            notification.attribute_handle, []
         )
         if not subscribers:
             logger.warning('!!! received notification with no subscriber')
@@ -1115,9 +1046,7 @@ class Client:
 
     def on_att_handle_value_indication(self, indication):
         # Call all subscribers
-        subscribers = self.indication_subscribers.get(
-            indication.attribute_handle, set()
-        )
+        subscribers = self.indication_subscribers.get(indication.attribute_handle, [])
         if not subscribers:
             logger.warning('!!! received indication with no subscriber')
 
@@ -1131,7 +1060,7 @@ class Client:
         # Confirm that we received the indication
         self.send_confirmation(ATT_Handle_Value_Confirmation())
 
-    def cache_value(self, attribute_handle: int, value: bytes) -> None:
+    def cache_value(self, attribute_handle: int, value: bytes):
         self.cached_values[attribute_handle] = (
             datetime.now(),
             value,

bumble/gatt_server.py

@@ -23,17 +23,16 @@
 # -----------------------------------------------------------------------------
 # Imports
 # -----------------------------------------------------------------------------
-from __future__ import annotations
 import asyncio
 import logging
 from collections import defaultdict
 import struct
-from typing import List, Tuple, Optional, TypeVar, Type, Dict, Iterable, TYPE_CHECKING
+from typing import List, Tuple, Optional, TypeVar, Type
 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,
@@ -43,7 +42,6 @@ from bumble.att import (
     ATT_INVALID_OFFSET_ERROR,
     ATT_REQUEST_NOT_SUPPORTED_ERROR,
     ATT_REQUESTS,
-    ATT_PDU,
     ATT_UNLIKELY_ERROR_ERROR,
     ATT_UNSUPPORTED_GROUP_TYPE_ERROR,
     ATT_Error,
@@ -60,7 +58,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,10 +72,7 @@ from bumble.gatt import (
     Descriptor,
     Service,
 )
-from bumble.utils import AsyncRunner
 
-if TYPE_CHECKING:
-    from bumble.device import Device, Connection
 
 # -----------------------------------------------------------------------------
 # Logging
@@ -96,13 +91,8 @@ GATT_SERVER_DEFAULT_MAX_MTU = 517
 # -----------------------------------------------------------------------------
 class Server(EventEmitter):
     attributes: List[Attribute]
-    services: List[Service]
-    attributes_by_handle: Dict[int, Attribute]
-    subscribers: Dict[int, Dict[int, bytes]]
-    indication_semaphores: defaultdict[int, asyncio.Semaphore]
-    pending_confirmations: defaultdict[int, Optional[asyncio.futures.Future]]
 
-    def __init__(self, device: Device) -> None:
+    def __init__(self, device):
         super().__init__()
         self.device = device
         self.services = []
@@ -117,16 +107,16 @@ class Server(EventEmitter):
         self.indication_semaphores = defaultdict(lambda: asyncio.Semaphore(1))
         self.pending_confirmations = defaultdict(lambda: None)
 
-    def __str__(self) -> str:
+    def __str__(self):
         return "\n".join(map(str, self.attributes))
 
-    def send_gatt_pdu(self, connection_handle: int, pdu: bytes) -> None:
+    def send_gatt_pdu(self, connection_handle, pdu):
         self.device.send_l2cap_pdu(connection_handle, ATT_CID, pdu)
 
-    def next_handle(self) -> int:
+    def next_handle(self):
         return 1 + len(self.attributes)
 
-    def get_advertising_service_data(self) -> Dict[Attribute, bytes]:
+    def get_advertising_service_data(self):
         return {
             attribute: data
             for attribute in self.attributes
@@ -134,7 +124,7 @@ class Server(EventEmitter):
             and (data := attribute.get_advertising_data())
         }
 
-    def get_attribute(self, handle: int) -> Optional[Attribute]:
+    def get_attribute(self, handle):
         attribute = self.attributes_by_handle.get(handle)
         if attribute:
             return attribute
@@ -183,17 +173,12 @@ class Server(EventEmitter):
 
         return next(
             (
-                (
-                    attribute,
-                    self.get_attribute(attribute.characteristic.handle),
-                )  # type: ignore
+                (attribute, self.get_attribute(attribute.characteristic.handle))
                 for attribute in map(
                     self.get_attribute,
                     range(service_handle.handle, service_handle.end_group_handle + 1),
                 )
-                if attribute is not None
-                and attribute.type == GATT_CHARACTERISTIC_ATTRIBUTE_TYPE
-                and isinstance(attribute, CharacteristicDeclaration)
+                if attribute.type == GATT_CHARACTERISTIC_ATTRIBUTE_TYPE
                 and attribute.characteristic.uuid == characteristic_uuid
             ),
             None,
@@ -212,7 +197,7 @@ class Server(EventEmitter):
 
         return next(
             (
-                attribute  # type: ignore
+                attribute
                 for attribute in map(
                     self.get_attribute,
                     range(
@@ -220,12 +205,12 @@ class Server(EventEmitter):
                         characteristic_value.end_group_handle + 1,
                     ),
                 )
-                if attribute is not None and attribute.type == descriptor_uuid
+                if attribute.type == descriptor_uuid
             ),
             None,
         )
 
-    def add_attribute(self, attribute: Attribute) -> None:
+    def add_attribute(self, attribute):
         # Assign a handle to this attribute
         attribute.handle = self.next_handle()
         attribute.end_group_handle = (
@@ -235,7 +220,7 @@ class Server(EventEmitter):
         # Add this attribute to the list
         self.attributes.append(attribute)
 
-    def add_service(self, service: Service) -> None:
+    def add_service(self, service: Service):
         # Add the service attribute to the DB
         self.add_attribute(service)
 
@@ -300,13 +285,11 @@ class Server(EventEmitter):
         service.end_group_handle = self.attributes[-1].handle
         self.services.append(service)
 
-    def add_services(self, services: Iterable[Service]) -> None:
+    def add_services(self, services):
         for service in services:
             self.add_service(service)
 
-    def read_cccd(
-        self, connection: Optional[Connection], characteristic: Characteristic
-    ) -> bytes:
+    def read_cccd(self, connection, characteristic):
         if connection is None:
             return bytes([0, 0])
 
@@ -317,12 +300,7 @@ class Server(EventEmitter):
 
         return cccd or bytes([0, 0])
 
-    def write_cccd(
-        self,
-        connection: Connection,
-        characteristic: Characteristic,
-        value: bytes,
-    ) -> None:
+    def write_cccd(self, connection, characteristic, value):
         logger.debug(
             f'Subscription update for connection=0x{connection.handle:04X}, '
             f'handle=0x{characteristic.handle:04X}: {value.hex()}'
@@ -349,19 +327,13 @@ class Server(EventEmitter):
             indicate_enabled,
         )
 
-    def send_response(self, connection: Connection, response: ATT_PDU) -> None:
+    def send_response(self, connection, response):
         logger.debug(
             f'GATT Response from server: [0x{connection.handle:04X}] {response}'
         )
         self.send_gatt_pdu(connection.handle, response.to_bytes())
 
-    async def notify_subscriber(
-        self,
-        connection: Connection,
-        attribute: Attribute,
-        value: Optional[bytes] = None,
-        force: bool = False,
-    ) -> None:
+    async def notify_subscriber(self, connection, attribute, value=None, force=False):
         # Check if there's a subscriber
         if not force:
             subscribers = self.subscribers.get(connection.handle)
@@ -380,7 +352,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)
         )
@@ -398,13 +370,7 @@ class Server(EventEmitter):
         )
         self.send_gatt_pdu(connection.handle, bytes(notification))
 
-    async def indicate_subscriber(
-        self,
-        connection: Connection,
-        attribute: Attribute,
-        value: Optional[bytes] = None,
-        force: bool = False,
-    ) -> None:
+    async def indicate_subscriber(self, connection, attribute, value=None, force=False):
         # Check if there's a subscriber
         if not force:
             subscribers = self.subscribers.get(connection.handle)
@@ -423,7 +389,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,13 +411,15 @@ 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[
+            self.pending_confirmations[
                 connection.handle
             ] = asyncio.get_running_loop().create_future()
 
             try:
                 self.send_gatt_pdu(connection.handle, indication.to_bytes())
-                await asyncio.wait_for(pending_confirmation, GATT_REQUEST_TIMEOUT)
+                await asyncio.wait_for(
+                    self.pending_confirmations[connection.handle], GATT_REQUEST_TIMEOUT
+                )
             except asyncio.TimeoutError as error:
                 logger.warning(color('!!! GATT Indicate timeout', 'red'))
                 raise TimeoutError(f'GATT timeout for {indication.name}') from error
@@ -459,12 +427,8 @@ class Server(EventEmitter):
                 self.pending_confirmations[connection.handle] = None
 
     async def notify_or_indicate_subscribers(
-        self,
-        indicate: bool,
-        attribute: Attribute,
-        value: Optional[bytes] = None,
-        force: bool = False,
-    ) -> None:
+        self, indicate, attribute, value=None, force=False
+    ):
         # Get all the connections for which there's at least one subscription
         connections = [
             connection
@@ -486,23 +450,13 @@ class Server(EventEmitter):
                 ]
             )
 
-    async def notify_subscribers(
-        self,
-        attribute: Attribute,
-        value: Optional[bytes] = None,
-        force: bool = False,
-    ):
+    async def notify_subscribers(self, attribute, value=None, force=False):
         return await self.notify_or_indicate_subscribers(False, attribute, value, force)
 
-    async def indicate_subscribers(
-        self,
-        attribute: Attribute,
-        value: Optional[bytes] = None,
-        force: bool = False,
-    ):
+    async def indicate_subscribers(self, attribute, value=None, force=False):
         return await self.notify_or_indicate_subscribers(True, attribute, value, force)
 
-    def on_disconnection(self, connection: Connection) -> None:
+    def on_disconnection(self, connection):
         if connection.handle in self.subscribers:
             del self.subscribers[connection.handle]
         if connection.handle in self.indication_semaphores:
@@ -510,7 +464,7 @@ class Server(EventEmitter):
         if connection.handle in self.pending_confirmations:
             del self.pending_confirmations[connection.handle]
 
-    def on_gatt_pdu(self, connection: Connection, att_pdu: ATT_PDU) -> None:
+    def on_gatt_pdu(self, connection, att_pdu):
         logger.debug(f'GATT Request to server: [0x{connection.handle:04X}] {att_pdu}')
         handler_name = f'on_{att_pdu.name.lower()}'
         handler = getattr(self, handler_name, None)
@@ -552,7 +506,7 @@ class Server(EventEmitter):
     #######################################################
     # ATT handlers
     #######################################################
-    def on_att_request(self, connection: Connection, pdu: ATT_PDU) -> None:
+    def on_att_request(self, connection, pdu):
         '''
         Handler for requests without a more specific handler
         '''
@@ -651,8 +605,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 +613,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 +657,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
         '''
@@ -727,8 +679,9 @@ class Server(EventEmitter):
             and attribute.handle <= request.ending_handle
             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 +723,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 +748,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 +792,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 +820,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 +859,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 +892,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,9 +915,9 @@ 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}')
+            logger.warning(f'!!! ignoring exception: {error}')
 
     def on_att_handle_value_confirmation(self, connection, _confirmation):
         '''

bumble/helpers.py

@@ -15,41 +15,30 @@
 # -----------------------------------------------------------------------------
 # Imports
 # -----------------------------------------------------------------------------
-from __future__ import annotations
-
-from collections.abc import Callable, MutableMapping
-from typing import cast, Any
 import logging
 
-from bumble import avdtp
-from bumble.colors import color
-from bumble.att import ATT_CID, ATT_PDU
-from bumble.smp import SMP_CID, SMP_Command
-from bumble.core import name_or_number
-from bumble.l2cap import (
+from .colors import color
+from .att import ATT_CID, ATT_PDU
+from .smp import SMP_CID, SMP_Command
+from .core import name_or_number
+from .l2cap import (
     L2CAP_PDU,
     L2CAP_CONNECTION_REQUEST,
     L2CAP_CONNECTION_RESPONSE,
     L2CAP_SIGNALING_CID,
     L2CAP_LE_SIGNALING_CID,
     L2CAP_Control_Frame,
-    L2CAP_Connection_Request,
     L2CAP_Connection_Response,
 )
-from bumble.hci import (
-    Address,
+from .hci import (
     HCI_EVENT_PACKET,
     HCI_ACL_DATA_PACKET,
     HCI_DISCONNECTION_COMPLETE_EVENT,
     HCI_AclDataPacketAssembler,
-    HCI_Packet,
-    HCI_Event,
-    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
+from .rfcomm import RFCOMM_Frame, RFCOMM_PSM
+from .sdp import SDP_PDU, SDP_PSM
+from .avdtp import MessageAssembler as AVDTP_MessageAssembler, AVDTP_PSM
 
 # -----------------------------------------------------------------------------
 # Logging
@@ -61,25 +50,23 @@ logger = logging.getLogger(__name__)
 PSM_NAMES = {
     RFCOMM_PSM: 'RFCOMM',
     SDP_PSM: 'SDP',
-    avdtp.AVDTP_PSM: 'AVDTP',
+    AVDTP_PSM: 'AVDTP'
+    # TODO: add more PSM values
 }
 
 
 # -----------------------------------------------------------------------------
 class PacketTracer:
     class AclStream:
-        psms: MutableMapping[int, int]
-        peer: PacketTracer.AclStream
-        avdtp_assemblers: MutableMapping[int, avdtp.MessageAssembler]
-
-        def __init__(self, analyzer: PacketTracer.Analyzer) -> None:
+        def __init__(self, analyzer):
             self.analyzer = analyzer
             self.packet_assembler = HCI_AclDataPacketAssembler(self.on_acl_pdu)
             self.avdtp_assemblers = {}  # AVDTP assemblers, by source_cid
             self.psms = {}  # PSM, by source_cid
+            self.peer = None  # ACL stream in the other direction
 
         # pylint: disable=too-many-nested-blocks
-        def on_acl_pdu(self, pdu: bytes) -> None:
+        def on_acl_pdu(self, pdu):
             l2cap_pdu = L2CAP_PDU.from_bytes(pdu)
 
             if l2cap_pdu.cid == ATT_CID:
@@ -94,30 +81,26 @@ class PacketTracer:
 
                 # Check if this signals a new channel
                 if control_frame.code == L2CAP_CONNECTION_REQUEST:
-                    connection_request = cast(L2CAP_Connection_Request, control_frame)
-                    self.psms[connection_request.source_cid] = connection_request.psm
+                    self.psms[control_frame.source_cid] = control_frame.psm
                 elif control_frame.code == L2CAP_CONNECTION_RESPONSE:
-                    connection_response = cast(L2CAP_Connection_Response, control_frame)
                     if (
-                        connection_response.result
+                        control_frame.result
                         == L2CAP_Connection_Response.CONNECTION_SUCCESSFUL
                     ):
                         if self.peer:
-                            if psm := self.peer.psms.get(
-                                connection_response.source_cid
-                            ):
+                            if psm := self.peer.psms.get(control_frame.source_cid):
                                 # Found a pending connection
-                                self.psms[connection_response.destination_cid] = psm
+                                self.psms[control_frame.destination_cid] = psm
 
                                 # For AVDTP connections, create a packet assembler for
                                 # each direction
-                                if psm == avdtp.AVDTP_PSM:
+                                if psm == AVDTP_PSM:
                                     self.avdtp_assemblers[
-                                        connection_response.source_cid
-                                    ] = avdtp.MessageAssembler(self.on_avdtp_message)
+                                        control_frame.source_cid
+                                    ] = AVDTP_MessageAssembler(self.on_avdtp_message)
                                     self.peer.avdtp_assemblers[
-                                        connection_response.destination_cid
-                                    ] = avdtp.MessageAssembler(
+                                        control_frame.destination_cid
+                                    ] = AVDTP_MessageAssembler(
                                         self.peer.on_avdtp_message
                                     )
 
@@ -130,7 +113,7 @@ class PacketTracer:
                     elif psm == RFCOMM_PSM:
                         rfcomm_frame = RFCOMM_Frame.from_bytes(l2cap_pdu.payload)
                         self.analyzer.emit(rfcomm_frame)
-                    elif psm == avdtp.AVDTP_PSM:
+                    elif psm == AVDTP_PSM:
                         self.analyzer.emit(
                             f'{color("L2CAP", "green")} [CID={l2cap_pdu.cid}, '
                             f'PSM=AVDTP]: {l2cap_pdu.payload.hex()}'
@@ -147,26 +130,22 @@ class PacketTracer:
                 else:
                     self.analyzer.emit(l2cap_pdu)
 
-        def on_avdtp_message(
-            self, transaction_label: int, message: avdtp.Message
-        ) -> None:
+        def on_avdtp_message(self, transaction_label, message):
             self.analyzer.emit(
                 f'{color("AVDTP", "green")} [{transaction_label}] {message}'
             )
 
-        def feed_packet(self, packet: HCI_AclDataPacket) -> None:
+        def feed_packet(self, packet):
             self.packet_assembler.feed_packet(packet)
 
     class Analyzer:
-        acl_streams: MutableMapping[int, PacketTracer.AclStream]
-        peer: PacketTracer.Analyzer
-
-        def __init__(self, label: str, emit_message: Callable[..., None]) -> None:
+        def __init__(self, label, emit_message):
             self.label = label
             self.emit_message = emit_message
             self.acl_streams = {}  # ACL streams, by connection handle
+            self.peer = None  # Analyzer in the other direction
 
-        def start_acl_stream(self, connection_handle: int) -> PacketTracer.AclStream:
+        def start_acl_stream(self, connection_handle):
             logger.info(
                 f'[{self.label}] +++ Creating ACL stream for connection '
                 f'0x{connection_handle:04X}'
@@ -181,7 +160,7 @@ class PacketTracer:
 
             return stream
 
-        def end_acl_stream(self, connection_handle: int) -> None:
+        def end_acl_stream(self, connection_handle):
             if connection_handle in self.acl_streams:
                 logger.info(
                     f'[{self.label}] --- Removing ACL stream for connection '
@@ -192,29 +171,23 @@ 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, packet: HCI_Packet) -> None:
+        def on_packet(self, packet):
             self.emit(packet)
 
             if packet.hci_packet_type == HCI_ACL_DATA_PACKET:
-                acl_packet = cast(HCI_AclDataPacket, packet)
                 # Look for an existing stream for this handle, create one if it is the
                 # first ACL packet for that connection handle
-                if (
-                    stream := self.acl_streams.get(acl_packet.connection_handle)
-                ) is None:
-                    stream = self.start_acl_stream(acl_packet.connection_handle)
-                stream.feed_packet(acl_packet)
+                if (stream := self.acl_streams.get(packet.connection_handle)) is None:
+                    stream = self.start_acl_stream(packet.connection_handle)
+                stream.feed_packet(packet)
             elif packet.hci_packet_type == HCI_EVENT_PACKET:
-                event_packet = cast(HCI_Event, packet)
-                if event_packet.event_code == HCI_DISCONNECTION_COMPLETE_EVENT:
-                    self.end_acl_stream(
-                        cast(HCI_Disconnection_Complete_Event, packet).connection_handle
-                    )
+                if packet.event_code == HCI_DISCONNECTION_COMPLETE_EVENT:
+                    self.end_acl_stream(packet.connection_handle)
 
-        def emit(self, message: Any) -> None:
+        def emit(self, message):
             self.emit_message(f'[{self.label}] {message}')
 
-    def trace(self, packet: HCI_Packet, direction: int = 0) -> None:
+    def trace(self, packet, direction=0):
         if direction == 0:
             self.host_to_controller_analyzer.on_packet(packet)
         else:
@@ -222,10 +195,10 @@ class PacketTracer:
 
     def __init__(
         self,
-        host_to_controller_label: str = color('HOST->CONTROLLER', 'blue'),
-        controller_to_host_label: str = color('CONTROLLER->HOST', 'cyan'),
-        emit_message: Callable[..., None] = logger.info,
-    ) -> None:
+        host_to_controller_label=color('HOST->CONTROLLER', 'blue'),
+        controller_to_host_label=color('CONTROLLER->HOST', 'cyan'),
+        emit_message=logger.info,
+    ):
         self.host_to_controller_analyzer = PacketTracer.Analyzer(
             host_to_controller_label, emit_message
         )
@@ -234,15 +207,3 @@ class PacketTracer:
         )
         self.host_to_controller_analyzer.peer = self.controller_to_host_analyzer
         self.controller_to_host_analyzer.peer = self.host_to_controller_analyzer
-
-
-def generate_irk() -> bytes:
-    return crypto.r()
-
-
-def verify_rpa_with_irk(rpa: Address, irk: bytes) -> bool:
-    rpa_bytes = bytes(rpa)
-    prand_given = rpa_bytes[3:]
-    hash_given = rpa_bytes[:3]
-    hash_local = crypto.ah(irk, prand_given)
-    return hash_local[:3] == hash_given

bumble/hfp.py

@@ -1,4 +1,4 @@
-# Copyright 2023 Google LLC
+# Copyright 2021-2022 Google LLC
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -15,62 +15,24 @@
 # -----------------------------------------------------------------------------
 # Imports
 # -----------------------------------------------------------------------------
-import collections.abc
 import logging
 import asyncio
-import dataclasses
-import enum
-import traceback
-import warnings
-from typing import Dict, List, Union, Set, Any, TYPE_CHECKING
+import collections
+from typing import Union
 
-from . import at
 from . import rfcomm
-
-from bumble.colors import color
-from bumble.core import (
-    ProtocolError,
-    BT_GENERIC_AUDIO_SERVICE,
-    BT_HANDSFREE_SERVICE,
-    BT_L2CAP_PROTOCOL_ID,
-    BT_RFCOMM_PROTOCOL_ID,
-)
-from bumble.hci import (
-    HCI_Enhanced_Setup_Synchronous_Connection_Command,
-    CodingFormat,
-    CodecID,
-)
-from bumble.sdp import (
-    DataElement,
-    ServiceAttribute,
-    SDP_SERVICE_RECORD_HANDLE_ATTRIBUTE_ID,
-    SDP_SERVICE_CLASS_ID_LIST_ATTRIBUTE_ID,
-    SDP_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID,
-    SDP_BLUETOOTH_PROFILE_DESCRIPTOR_LIST_ATTRIBUTE_ID,
-    SDP_SUPPORTED_FEATURES_ATTRIBUTE_ID,
-)
-
+from .colors import color
 
 # -----------------------------------------------------------------------------
 # Logging
 # -----------------------------------------------------------------------------
 logger = logging.getLogger(__name__)
 
-# -----------------------------------------------------------------------------
-# Error
-# -----------------------------------------------------------------------------
-
-
-class HfpProtocolError(ProtocolError):
-    def __init__(self, error_name: str = '', details: str = ''):
-        super().__init__(None, 'hfp', error_name, details)
-
 
 # -----------------------------------------------------------------------------
 # Protocol Support
 # -----------------------------------------------------------------------------
 
-
 # -----------------------------------------------------------------------------
 class HfpProtocol:
     dlc: rfcomm.DLC
@@ -79,7 +41,6 @@ class HfpProtocol:
     lines_available: asyncio.Event
 
     def __init__(self, dlc: rfcomm.DLC) -> None:
-        warnings.warn("See HfProtocol", DeprecationWarning)
         self.dlc = dlc
         self.buffer = ''
         self.lines = collections.deque()
@@ -122,878 +83,19 @@ class HfpProtocol:
         logger.debug(color(f'<<< {line}', 'green'))
         return line
 
-
-# -----------------------------------------------------------------------------
-# Normative protocol definitions
-# -----------------------------------------------------------------------------
-
-
-# HF supported features (AT+BRSF=) (normative).
-# Hands-Free Profile v1.8, 4.34.2, AT Capabilities Re-Used from GSM 07.07
-# and 3GPP 27.007
-class HfFeature(enum.IntFlag):
-    EC_NR = 0x001  # Echo Cancel & Noise reduction
-    THREE_WAY_CALLING = 0x002
-    CLI_PRESENTATION_CAPABILITY = 0x004
-    VOICE_RECOGNITION_ACTIVATION = 0x008
-    REMOTE_VOLUME_CONTROL = 0x010
-    ENHANCED_CALL_STATUS = 0x020
-    ENHANCED_CALL_CONTROL = 0x040
-    CODEC_NEGOTIATION = 0x080
-    HF_INDICATORS = 0x100
-    ESCO_S4_SETTINGS_SUPPORTED = 0x200
-    ENHANCED_VOICE_RECOGNITION_STATUS = 0x400
-    VOICE_RECOGNITION_TEST = 0x800
-
-
-# AG supported features (+BRSF:) (normative).
-# Hands-Free Profile v1.8, 4.34.2, AT Capabilities Re-Used from GSM 07.07
-# and 3GPP 27.007
-class AgFeature(enum.IntFlag):
-    THREE_WAY_CALLING = 0x001
-    EC_NR = 0x002  # Echo Cancel & Noise reduction
-    VOICE_RECOGNITION_FUNCTION = 0x004
-    IN_BAND_RING_TONE_CAPABILITY = 0x008
-    VOICE_TAG = 0x010  # Attach a number to voice tag
-    REJECT_CALL = 0x020  # Ability to reject a call
-    ENHANCED_CALL_STATUS = 0x040
-    ENHANCED_CALL_CONTROL = 0x080
-    EXTENDED_ERROR_RESULT_CODES = 0x100
-    CODEC_NEGOTIATION = 0x200
-    HF_INDICATORS = 0x400
-    ESCO_S4_SETTINGS_SUPPORTED = 0x800
-    ENHANCED_VOICE_RECOGNITION_STATUS = 0x1000
-    VOICE_RECOGNITION_TEST = 0x2000
-
-
-# Audio Codec IDs (normative).
-# Hands-Free Profile v1.8, 10 Appendix B
-class AudioCodec(enum.IntEnum):
-    CVSD = 0x01  # Support for CVSD audio codec
-    MSBC = 0x02  # Support for mSBC audio codec
-
-
-# HF Indicators (normative).
-# Bluetooth Assigned Numbers, 6.10.1 HF Indicators
-class HfIndicator(enum.IntEnum):
-    ENHANCED_SAFETY = 0x01  # Enhanced safety feature
-    BATTERY_LEVEL = 0x02  # Battery level feature
-
-
-# Call Hold supported operations (normative).
-# AT Commands Reference Guide, 3.5.2.3.12 +CHLD - Call Holding Services
-class CallHoldOperation(enum.IntEnum):
-    RELEASE_ALL_HELD_CALLS = 0  # Release all held calls
-    RELEASE_ALL_ACTIVE_CALLS = 1  # Release all active calls, accept other
-    HOLD_ALL_ACTIVE_CALLS = 2  # Place all active calls on hold, accept other
-    ADD_HELD_CALL = 3  # Adds a held call to conversation
-
-
-# Response Hold status (normative).
-# Hands-Free Profile v1.8, 4.34.2, AT Capabilities Re-Used from GSM 07.07
-# and 3GPP 27.007
-class ResponseHoldStatus(enum.IntEnum):
-    INC_CALL_HELD = 0  # Put incoming call on hold
-    HELD_CALL_ACC = 1  # Accept a held incoming call
-    HELD_CALL_REJ = 2  # Reject a held incoming call
-
-
-# Values for the Call Setup AG indicator (normative).
-# Hands-Free Profile v1.8, 4.34.2, AT Capabilities Re-Used from GSM 07.07
-# and 3GPP 27.007
-class CallSetupAgIndicator(enum.IntEnum):
-    NOT_IN_CALL_SETUP = 0
-    INCOMING_CALL_PROCESS = 1
-    OUTGOING_CALL_SETUP = 2
-    REMOTE_ALERTED = 3  # Remote party alerted in an outgoing call
-
-
-# Values for the Call Held AG indicator (normative).
-# Hands-Free Profile v1.8, 4.34.2, AT Capabilities Re-Used from GSM 07.07
-# and 3GPP 27.007
-class CallHeldAgIndicator(enum.IntEnum):
-    NO_CALLS_HELD = 0
-    # Call is placed on hold or active/held calls swapped
-    # (The AG has both an active AND a held call)
-    CALL_ON_HOLD_AND_ACTIVE_CALL = 1
-    CALL_ON_HOLD_NO_ACTIVE_CALL = 2  # Call on hold, no active call
-
-
-# Call Info direction (normative).
-# AT Commands Reference Guide, 3.5.2.3.15 +CLCC - List Current Calls
-class CallInfoDirection(enum.IntEnum):
-    MOBILE_ORIGINATED_CALL = 0
-    MOBILE_TERMINATED_CALL = 1
-
-
-# Call Info status (normative).
-# AT Commands Reference Guide, 3.5.2.3.15 +CLCC - List Current Calls
-class CallInfoStatus(enum.IntEnum):
-    ACTIVE = 0
-    HELD = 1
-    DIALING = 2
-    ALERTING = 3
-    INCOMING = 4
-    WAITING = 5
-
-
-# Call Info mode (normative).
-# AT Commands Reference Guide, 3.5.2.3.15 +CLCC - List Current Calls
-class CallInfoMode(enum.IntEnum):
-    VOICE = 0
-    DATA = 1
-    FAX = 2
-    UNKNOWN = 9
-
-
-# -----------------------------------------------------------------------------
-# Hands-Free Control Interoperability Requirements
-# -----------------------------------------------------------------------------
-
-# Response codes.
-RESPONSE_CODES = [
-    "+APLSIRI",
-    "+BAC",
-    "+BCC",
-    "+BCS",
-    "+BIA",
-    "+BIEV",
-    "+BIND",
-    "+BINP",
-    "+BLDN",
-    "+BRSF",
-    "+BTRH",
-    "+BVRA",
-    "+CCWA",
-    "+CHLD",
-    "+CHUP",
-    "+CIND",
-    "+CLCC",
-    "+CLIP",
-    "+CMEE",
-    "+CMER",
-    "+CNUM",
-    "+COPS",
-    "+IPHONEACCEV",
-    "+NREC",
-    "+VGM",
-    "+VGS",
-    "+VTS",
-    "+XAPL",
-    "A",
-    "D",
-]
-
-# Unsolicited responses and statuses.
-UNSOLICITED_CODES = [
-    "+APLSIRI",
-    "+BCS",
-    "+BIND",
-    "+BSIR",
-    "+BTRH",
-    "+BVRA",
-    "+CCWA",
-    "+CIEV",
-    "+CLIP",
-    "+VGM",
-    "+VGS",
-    "BLACKLISTED",
-    "BUSY",
-    "DELAYED",
-    "NO ANSWER",
-    "NO CARRIER",
-    "RING",
-]
-
-# Status codes
-STATUS_CODES = [
-    "+CME ERROR",
-    "BLACKLISTED",
-    "BUSY",
-    "DELAYED",
-    "ERROR",
-    "NO ANSWER",
-    "NO CARRIER",
-    "OK",
-]
-
-
-@dataclasses.dataclass
-class Configuration:
-    supported_hf_features: List[HfFeature]
-    supported_hf_indicators: List[HfIndicator]
-    supported_audio_codecs: List[AudioCodec]
-
-
-class AtResponseType(enum.Enum):
-    """Indicate if a response is expected from an AT command, and if multiple
-    responses are accepted."""
-
-    NONE = 0
-    SINGLE = 1
-    MULTIPLE = 2
-
-
-class AtResponse:
-    code: str
-    parameters: list
-
-    def __init__(self, response: bytearray):
-        code_and_parameters = response.split(b':')
-        parameters = (
-            code_and_parameters[1] if len(code_and_parameters) > 1 else bytearray()
-        )
-        self.code = code_and_parameters[0].decode()
-        self.parameters = at.parse_parameters(parameters)
-
-
-@dataclasses.dataclass
-class AgIndicatorState:
-    description: str
-    index: int
-    supported_values: Set[int]
-    current_status: int
-
-
-@dataclasses.dataclass
-class HfIndicatorState:
-    supported: bool = False
-    enabled: bool = False
-
-
-class HfProtocol:
-    """Implementation for the Hands-Free side of the Hands-Free profile.
-    Reference specification Hands-Free Profile v1.8"""
-
-    supported_hf_features: int
-    supported_audio_codecs: List[AudioCodec]
-
-    supported_ag_features: int
-    supported_ag_call_hold_operations: List[CallHoldOperation]
-
-    ag_indicators: List[AgIndicatorState]
-    hf_indicators: Dict[HfIndicator, HfIndicatorState]
-
-    dlc: rfcomm.DLC
-    command_lock: asyncio.Lock
-    if TYPE_CHECKING:
-        response_queue: asyncio.Queue[AtResponse]
-        unsolicited_queue: asyncio.Queue[AtResponse]
-    else:
-        response_queue: asyncio.Queue
-        unsolicited_queue: asyncio.Queue
-    read_buffer: bytearray
-
-    def __init__(self, dlc: rfcomm.DLC, configuration: Configuration):
-        # Configure internal state.
-        self.dlc = dlc
-        self.command_lock = asyncio.Lock()
-        self.response_queue = asyncio.Queue()
-        self.unsolicited_queue = asyncio.Queue()
-        self.read_buffer = bytearray()
-
-        # Build local features.
-        self.supported_hf_features = sum(configuration.supported_hf_features)
-        self.supported_audio_codecs = configuration.supported_audio_codecs
-
-        self.hf_indicators = {
-            indicator: HfIndicatorState()
-            for indicator in configuration.supported_hf_indicators
-        }
-
-        # Clear remote features.
-        self.supported_ag_features = 0
-        self.supported_ag_call_hold_operations = []
-        self.ag_indicators = []
-
-        # Bind the AT reader to the RFCOMM channel.
-        self.dlc.sink = self._read_at
-
-    def supports_hf_feature(self, feature: HfFeature) -> bool:
-        return (self.supported_hf_features & feature) != 0
-
-    def supports_ag_feature(self, feature: AgFeature) -> bool:
-        return (self.supported_ag_features & feature) != 0
-
-    # Read AT messages from the RFCOMM channel.
-    # Enqueue AT commands, responses, unsolicited responses to their
-    # respective queues, and set the corresponding event.
-    def _read_at(self, data: bytes):
-        # Append to the read buffer.
-        self.read_buffer.extend(data)
-
-        # Locate header and trailer.
-        header = self.read_buffer.find(b'\r\n')
-        trailer = self.read_buffer.find(b'\r\n', header + 2)
-        if header == -1 or trailer == -1:
-            return
-
-        # Isolate the AT response code and parameters.
-        raw_response = self.read_buffer[header + 2 : trailer]
-        response = AtResponse(raw_response)
-        logger.debug(f"<<< {raw_response.decode()}")
-
-        # Consume the response bytes.
-        self.read_buffer = self.read_buffer[trailer + 2 :]
-
-        # Forward the received code to the correct queue.
-        if self.command_lock.locked() and (
-            response.code in STATUS_CODES or response.code in RESPONSE_CODES
-        ):
-            self.response_queue.put_nowait(response)
-        elif response.code in UNSOLICITED_CODES:
-            self.unsolicited_queue.put_nowait(response)
-        else:
-            logger.warning(f"dropping unexpected response with code '{response.code}'")
-
-    # Send an AT command and wait for the peer response.
-    # Wait for the AT responses sent by the peer, to the status code.
-    # Raises asyncio.TimeoutError if the status is not received
-    # after a timeout (default 1 second).
-    # Raises ProtocolError if the status is not OK.
-    async def execute_command(
-        self,
-        cmd: str,
-        timeout: float = 1.0,
-        response_type: AtResponseType = AtResponseType.NONE,
-    ) -> Union[None, AtResponse, List[AtResponse]]:
-        async with self.command_lock:
-            logger.debug(f">>> {cmd}")
-            self.dlc.write(cmd + '\r')
-            responses: List[AtResponse] = []
-
-            while True:
-                result = await asyncio.wait_for(
-                    self.response_queue.get(), timeout=timeout
-                )
-                if result.code == 'OK':
-                    if response_type == AtResponseType.SINGLE and len(responses) != 1:
-                        raise HfpProtocolError("NO ANSWER")
-
-                    if response_type == AtResponseType.MULTIPLE:
-                        return responses
-                    if response_type == AtResponseType.SINGLE:
-                        return responses[0]
-                    return None
-                if result.code in STATUS_CODES:
-                    raise HfpProtocolError(result.code)
-                responses.append(result)
-
-    # 4.2.1 Service Level Connection Initialization.
-    async def initiate_slc(self):
-        # 4.2.1.1 Supported features exchange
-        # First, in the initialization procedure, the HF shall send the
-        # AT+BRSF=<HF supported features> command to the AG to both notify
-        # the AG of the supported features in the HF, as well as to retrieve the
-        # supported features in the AG using the +BRSF result code.
-        response = await self.execute_command(
-            f"AT+BRSF={self.supported_hf_features}", response_type=AtResponseType.SINGLE
-        )
-
-        self.supported_ag_features = int(response.parameters[0])
-        logger.info(f"supported AG features: {self.supported_ag_features}")
-        for feature in AgFeature:
-            if self.supports_ag_feature(feature):
-                logger.info(f"  - {feature.name}")
-
-        # 4.2.1.2 Codec Negotiation
-        # Secondly, in the initialization procedure, if the HF supports the
-        # Codec Negotiation feature, it shall check if the AT+BRSF command
-        # response from the AG has indicated that it supports the Codec
-        # Negotiation feature.
-        if self.supports_hf_feature(
-            HfFeature.CODEC_NEGOTIATION
-        ) and self.supports_ag_feature(AgFeature.CODEC_NEGOTIATION):
-            # If both the HF and AG do support the Codec Negotiation feature
-            # then the HF shall send the AT+BAC=<HF available codecs> command to
-            # the AG to notify the AG of the available codecs in the HF.
-            codecs = [str(c) for c in self.supported_audio_codecs]
-            await self.execute_command(f"AT+BAC={','.join(codecs)}")
-
-        # 4.2.1.3 AG Indicators
-        # After having retrieved the supported features in the AG, the HF shall
-        # determine which indicators are supported by the AG, as well as the
-        # ordering of the supported indicators. This is because, according to
-        # the 3GPP 27.007 specification [2], the AG may support additional
-        # indicators not provided for by the Hands-Free Profile, and because the
-        # ordering of the indicators is implementation specific. The HF uses
-        # the AT+CIND=? Test command to retrieve information about the supported
-        # indicators and their ordering.
-        response = await self.execute_command(
-            "AT+CIND=?", response_type=AtResponseType.SINGLE
-        )
-
-        self.ag_indicators = []
-        for index, indicator in enumerate(response.parameters):
-            description = indicator[0].decode()
-            supported_values = []
-            for value in indicator[1]:
-                value = value.split(b'-')
-                value = [int(v) for v in value]
-                value_min = value[0]
-                value_max = value[1] if len(value) > 1 else value[0]
-                supported_values.extend([v for v in range(value_min, value_max + 1)])
-
-            self.ag_indicators.append(
-                AgIndicatorState(description, index, set(supported_values), 0)
-            )
-
-        # Once the HF has the necessary supported indicator and ordering
-        # information, it shall retrieve the current status of the indicators
-        # in the AG using the AT+CIND? Read command.
-        response = await self.execute_command(
-            "AT+CIND?", response_type=AtResponseType.SINGLE
-        )
-
-        for index, indicator in enumerate(response.parameters):
-            self.ag_indicators[index].current_status = int(indicator)
-
-        # After having retrieved the status of the indicators in the AG, the HF
-        # shall then enable the "Indicators status update" function in the AG by
-        # issuing the AT+CMER command, to which the AG shall respond with OK.
-        await self.execute_command("AT+CMER=3,,,1")
-
-        if self.supports_hf_feature(
-            HfFeature.THREE_WAY_CALLING
-        ) and self.supports_ag_feature(HfFeature.THREE_WAY_CALLING):
-            # After the HF has enabled the “Indicators status update” function in
-            # the AG, and if the “Call waiting and 3-way calling” bit was set in the
-            # supported features bitmap by both the HF and the AG, the HF shall
-            # issue the AT+CHLD=? test command to retrieve the information about how
-            # the call hold and multiparty services are supported in the AG. The HF
-            # shall not issue the AT+CHLD=? test command in case either the HF or
-            # the AG does not support the "Three-way calling" feature.
-            response = await self.execute_command(
-                "AT+CHLD=?", response_type=AtResponseType.SINGLE
-            )
-
-            self.supported_ag_call_hold_operations = [
-                CallHoldOperation(int(operation))
-                for operation in response.parameters[0]
-                if not b'x' in operation
-            ]
-
-        # 4.2.1.4 HF Indicators
-        # If the HF supports the HF indicator feature, it shall check the +BRSF
-        # response to see if the AG also supports the HF Indicator feature.
-        if self.supports_hf_feature(
-            HfFeature.HF_INDICATORS
-        ) and self.supports_ag_feature(AgFeature.HF_INDICATORS):
-            # If both the HF and AG support the HF Indicator feature, then the HF
-            # shall send the AT+BIND=<HF supported HF indicators> command to the AG
-            # to notify the AG of the supported indicators’ assigned numbers in the
-            # HF. The AG shall respond with OK
-            indicators = [str(i) for i in self.hf_indicators.keys()]
-            await self.execute_command(f"AT+BIND={','.join(indicators)}")
-
-            # After having provided the AG with the HF indicators it supports,
-            # the HF shall send the AT+BIND=? to request HF indicators supported
-            # by the AG. The AG shall reply with the +BIND response listing all
-            # HF indicators that it supports followed by an OK.
-            response = await self.execute_command(
-                "AT+BIND=?", response_type=AtResponseType.SINGLE
-            )
-
-            logger.info("supported HF indicators:")
-            for indicator in response.parameters[0]:
-                indicator = HfIndicator(int(indicator))
-                logger.info(f"  - {indicator.name}")
-                if indicator in self.hf_indicators:
-                    self.hf_indicators[indicator].supported = True
-
-            # Once the HF receives the supported HF indicators list from the AG,
-            # the HF shall send the AT+BIND? command to determine which HF
-            # indicators are enabled. The AG shall respond with one or more
-            # +BIND responses. The AG shall terminate the list with OK.
-            # (See Section 4.36.1.3).
-            responses = await self.execute_command(
-                "AT+BIND?", response_type=AtResponseType.MULTIPLE
-            )
-
-            logger.info("enabled HF indicators:")
-            for response in responses:
-                indicator = HfIndicator(int(response.parameters[0]))
-                enabled = int(response.parameters[1]) != 0
-                logger.info(f"  - {indicator.name}: {enabled}")
-                if indicator in self.hf_indicators:
-                    self.hf_indicators[indicator].enabled = True
-
-        logger.info("SLC setup completed")
-
-    # 4.11.2 Audio Connection Setup by HF
-    async def setup_audio_connection(self):
-        # When the HF triggers the establishment of the Codec Connection it
-        # shall send the AT command AT+BCC to the AG. The AG shall respond with
-        # OK if it will start the Codec Connection procedure, and with ERROR
-        # if it cannot start the Codec Connection procedure.
-        await self.execute_command("AT+BCC")
-
-    # 4.11.3 Codec Connection Setup
-    async def setup_codec_connection(self, codec_id: int):
-        # The AG shall send a +BCS=<Codec ID> unsolicited response to the HF.
-        # The HF shall then respond to the incoming unsolicited response with
-        # the AT command AT+BCS=<Codec ID>. The ID shall be the same as in the
-        # unsolicited response code as long as the ID is supported.
-        # If the received ID is not available, the HF shall respond with
-        # AT+BAC with its available codecs.
-        if codec_id not in self.supported_audio_codecs:
-            codecs = [str(c) for c in self.supported_audio_codecs]
-            await self.execute_command(f"AT+BAC={','.join(codecs)}")
-            return
-
-        await self.execute_command(f"AT+BCS={codec_id}")
-
-        # After sending the OK response, the AG shall open the
-        # Synchronous Connection with the settings that are determined by the
-        # ID. The HF shall be ready to accept the synchronous connection
-        # establishment as soon as it has sent the AT commands AT+BCS=<Codec ID>.
-
-        logger.info("codec connection setup completed")
-
-    # 4.13.1 Answer Incoming Call from the HF – In-Band Ringing
-    async def answer_incoming_call(self):
-        # The user accepts the incoming voice call by using the proper means
-        # provided by the HF. The HF shall then send the ATA command
-        # (see Section 4.34) to the AG. The AG shall then begin the procedure for
-        # accepting the incoming call.
-        await self.execute_command("ATA")
-
-    # 4.14.1 Reject an Incoming Call from the HF
-    async def reject_incoming_call(self):
-        # The user rejects the incoming call by using the User Interface on the
-        # Hands-Free unit. The HF shall then send the AT+CHUP command
-        # (see Section 4.34) to the AG. This may happen at any time during the
-        # procedures described in Sections 4.13.1 and 4.13.2.
-        await self.execute_command("AT+CHUP")
-
-    # 4.15.1 Terminate a Call Process from the HF
-    async def terminate_call(self):
-        # The user may abort the ongoing call process using whatever means
-        # provided by the Hands-Free unit. The HF shall send AT+CHUP command
-        # (see Section 4.34) to the AG, and the AG shall then start the
-        # procedure to terminate or interrupt the current call procedure.
-        # The AG shall then send the OK indication followed by the +CIEV result
-        # code, with the value indicating (call=0).
-        await self.execute_command("AT+CHUP")
-
-    async def update_ag_indicator(self, index: int, value: int):
-        self.ag_indicators[index].current_status = value
-        logger.info(
-            f"AG indicator updated: {self.ag_indicators[index].description}, {value}"
-        )
-
-    async def handle_unsolicited(self):
-        """Handle unsolicited result codes sent by the audio gateway."""
-        result = await self.unsolicited_queue.get()
-        if result.code == "+BCS":
-            await self.setup_codec_connection(int(result.parameters[0]))
-        elif result.code == "+CIEV":
-            await self.update_ag_indicator(
-                int(result.parameters[0]), int(result.parameters[1])
-            )
-        else:
-            logging.info(f"unhandled unsolicited response {result.code}")
-
-    async def run(self):
-        """Main rountine for the Hands-Free side of the HFP protocol.
-        Initiates the service level connection then loops handling
-        unsolicited AG responses."""
-
-        try:
-            await self.initiate_slc()
-            while True:
-                await self.handle_unsolicited()
-        except Exception:
-            logger.error("HFP-HF protocol failed with the following error:")
-            logger.error(traceback.format_exc())
-
-
-# -----------------------------------------------------------------------------
-# Normative SDP definitions
-# -----------------------------------------------------------------------------
-
-
-# Profile version (normative).
-# Hands-Free Profile v1.8, 5.3 SDP Interoperability Requirements
-class ProfileVersion(enum.IntEnum):
-    V1_5 = 0x0105
-    V1_6 = 0x0106
-    V1_7 = 0x0107
-    V1_8 = 0x0108
-    V1_9 = 0x0109
-
-
-# HF supported features (normative).
-# Hands-Free Profile v1.8, 5.3 SDP Interoperability Requirements
-class HfSdpFeature(enum.IntFlag):
-    EC_NR = 0x01  # Echo Cancel & Noise reduction
-    THREE_WAY_CALLING = 0x02
-    CLI_PRESENTATION_CAPABILITY = 0x04
-    VOICE_RECOGNITION_ACTIVATION = 0x08
-    REMOTE_VOLUME_CONTROL = 0x10
-    WIDE_BAND = 0x20  # Wide band speech
-    ENHANCED_VOICE_RECOGNITION_STATUS = 0x40
-    VOICE_RECOGNITION_TEST = 0x80
-
-
-# AG supported features (normative).
-# Hands-Free Profile v1.8, 5.3 SDP Interoperability Requirements
-class AgSdpFeature(enum.IntFlag):
-    THREE_WAY_CALLING = 0x01
-    EC_NR = 0x02  # Echo Cancel & Noise reduction
-    VOICE_RECOGNITION_FUNCTION = 0x04
-    IN_BAND_RING_TONE_CAPABILITY = 0x08
-    VOICE_TAG = 0x10  # Attach a number to voice tag
-    WIDE_BAND = 0x20  # Wide band speech
-    ENHANCED_VOICE_RECOGNITION_STATUS = 0x40
-    VOICE_RECOGNITION_TEST = 0x80
-
-
-def sdp_records(
-    service_record_handle: int, rfcomm_channel: int, configuration: Configuration
-) -> List[ServiceAttribute]:
-    """Generate the SDP record for HFP Hands-Free support.
-    The record exposes the features supported in the input configuration,
-    and the allocated RFCOMM channel."""
-
-    hf_supported_features = 0
-
-    if HfFeature.EC_NR in configuration.supported_hf_features:
-        hf_supported_features |= HfSdpFeature.EC_NR
-    if HfFeature.THREE_WAY_CALLING in configuration.supported_hf_features:
-        hf_supported_features |= HfSdpFeature.THREE_WAY_CALLING
-    if HfFeature.CLI_PRESENTATION_CAPABILITY in configuration.supported_hf_features:
-        hf_supported_features |= HfSdpFeature.CLI_PRESENTATION_CAPABILITY
-    if HfFeature.VOICE_RECOGNITION_ACTIVATION in configuration.supported_hf_features:
-        hf_supported_features |= HfSdpFeature.VOICE_RECOGNITION_ACTIVATION
-    if HfFeature.REMOTE_VOLUME_CONTROL in configuration.supported_hf_features:
-        hf_supported_features |= HfSdpFeature.REMOTE_VOLUME_CONTROL
-    if (
-        HfFeature.ENHANCED_VOICE_RECOGNITION_STATUS
-        in configuration.supported_hf_features
-    ):
-        hf_supported_features |= HfSdpFeature.ENHANCED_VOICE_RECOGNITION_STATUS
-    if HfFeature.VOICE_RECOGNITION_TEST in configuration.supported_hf_features:
-        hf_supported_features |= HfSdpFeature.VOICE_RECOGNITION_TEST
-
-    if AudioCodec.MSBC in configuration.supported_audio_codecs:
-        hf_supported_features |= HfSdpFeature.WIDE_BAND
-
-    return [
-        ServiceAttribute(
-            SDP_SERVICE_RECORD_HANDLE_ATTRIBUTE_ID,
-            DataElement.unsigned_integer_32(service_record_handle),
-        ),
-        ServiceAttribute(
-            SDP_SERVICE_CLASS_ID_LIST_ATTRIBUTE_ID,
-            DataElement.sequence(
-                [
-                    DataElement.uuid(BT_HANDSFREE_SERVICE),
-                    DataElement.uuid(BT_GENERIC_AUDIO_SERVICE),
-                ]
-            ),
-        ),
-        ServiceAttribute(
-            SDP_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID,
-            DataElement.sequence(
-                [
-                    DataElement.sequence([DataElement.uuid(BT_L2CAP_PROTOCOL_ID)]),
-                    DataElement.sequence(
-                        [
-                            DataElement.uuid(BT_RFCOMM_PROTOCOL_ID),
-                            DataElement.unsigned_integer_8(rfcomm_channel),
-                        ]
-                    ),
-                ]
-            ),
-        ),
-        ServiceAttribute(
-            SDP_BLUETOOTH_PROFILE_DESCRIPTOR_LIST_ATTRIBUTE_ID,
-            DataElement.sequence(
-                [
-                    DataElement.sequence(
-                        [
-                            DataElement.uuid(BT_HANDSFREE_SERVICE),
-                            DataElement.unsigned_integer_16(ProfileVersion.V1_8),
-                        ]
-                    )
-                ]
-            ),
-        ),
-        ServiceAttribute(
-            SDP_SUPPORTED_FEATURES_ATTRIBUTE_ID,
-            DataElement.unsigned_integer_16(hf_supported_features),
-        ),
-    ]
-
-
-# -----------------------------------------------------------------------------
-# ESCO Codec Default Parameters
-# -----------------------------------------------------------------------------
-
-
-# Hands-Free Profile v1.8, 5.7 Codec Interoperability Requirements
-class DefaultCodecParameters(enum.IntEnum):
-    SCO_CVSD_D0 = enum.auto()
-    SCO_CVSD_D1 = enum.auto()
-    ESCO_CVSD_S1 = enum.auto()
-    ESCO_CVSD_S2 = enum.auto()
-    ESCO_CVSD_S3 = enum.auto()
-    ESCO_CVSD_S4 = enum.auto()
-    ESCO_MSBC_T1 = enum.auto()
-    ESCO_MSBC_T2 = enum.auto()
-
-
-@dataclasses.dataclass
-class EscoParameters:
-    # Codec specific
-    transmit_coding_format: CodingFormat
-    receive_coding_format: CodingFormat
-    packet_type: HCI_Enhanced_Setup_Synchronous_Connection_Command.PacketType
-    retransmission_effort: HCI_Enhanced_Setup_Synchronous_Connection_Command.RetransmissionEffort
-    max_latency: int
-
-    # Common
-    input_coding_format: CodingFormat = CodingFormat(CodecID.LINEAR_PCM)
-    output_coding_format: CodingFormat = CodingFormat(CodecID.LINEAR_PCM)
-    input_coded_data_size: int = 16
-    output_coded_data_size: int = 16
-    input_pcm_data_format: HCI_Enhanced_Setup_Synchronous_Connection_Command.PcmDataFormat = (
-        HCI_Enhanced_Setup_Synchronous_Connection_Command.PcmDataFormat.TWOS_COMPLEMENT
-    )
-    output_pcm_data_format: HCI_Enhanced_Setup_Synchronous_Connection_Command.PcmDataFormat = (
-        HCI_Enhanced_Setup_Synchronous_Connection_Command.PcmDataFormat.TWOS_COMPLEMENT
-    )
-    input_pcm_sample_payload_msb_position: int = 0
-    output_pcm_sample_payload_msb_position: int = 0
-    input_data_path: HCI_Enhanced_Setup_Synchronous_Connection_Command.DataPath = (
-        HCI_Enhanced_Setup_Synchronous_Connection_Command.DataPath.HCI
-    )
-    output_data_path: HCI_Enhanced_Setup_Synchronous_Connection_Command.DataPath = (
-        HCI_Enhanced_Setup_Synchronous_Connection_Command.DataPath.HCI
-    )
-    input_transport_unit_size: int = 0
-    output_transport_unit_size: int = 0
-    input_bandwidth: int = 16000
-    output_bandwidth: int = 16000
-    transmit_bandwidth: int = 8000
-    receive_bandwidth: int = 8000
-    transmit_codec_frame_size: int = 60
-    receive_codec_frame_size: int = 60
-
-    def asdict(self) -> Dict[str, Any]:
-        # dataclasses.asdict() will recursively deep-copy the entire object,
-        # which is expensive and breaks CodingFormat object, so let it simply copy here.
-        return self.__dict__
-
-
-_ESCO_PARAMETERS_CVSD_D0 = EscoParameters(
-    transmit_coding_format=CodingFormat(CodecID.CVSD),
-    receive_coding_format=CodingFormat(CodecID.CVSD),
-    max_latency=0xFFFF,
-    packet_type=HCI_Enhanced_Setup_Synchronous_Connection_Command.PacketType.HV1,
-    retransmission_effort=HCI_Enhanced_Setup_Synchronous_Connection_Command.RetransmissionEffort.NO_RETRANSMISSION,
-)
-
-_ESCO_PARAMETERS_CVSD_D1 = EscoParameters(
-    transmit_coding_format=CodingFormat(CodecID.CVSD),
-    receive_coding_format=CodingFormat(CodecID.CVSD),
-    max_latency=0xFFFF,
-    packet_type=HCI_Enhanced_Setup_Synchronous_Connection_Command.PacketType.HV3,
-    retransmission_effort=HCI_Enhanced_Setup_Synchronous_Connection_Command.RetransmissionEffort.NO_RETRANSMISSION,
-)
-
-_ESCO_PARAMETERS_CVSD_S1 = EscoParameters(
-    transmit_coding_format=CodingFormat(CodecID.CVSD),
-    receive_coding_format=CodingFormat(CodecID.CVSD),
-    max_latency=0x0007,
-    packet_type=(
-        HCI_Enhanced_Setup_Synchronous_Connection_Command.PacketType.EV3
-        | HCI_Enhanced_Setup_Synchronous_Connection_Command.PacketType.NO_2_EV3
-        | HCI_Enhanced_Setup_Synchronous_Connection_Command.PacketType.NO_3_EV3
-        | HCI_Enhanced_Setup_Synchronous_Connection_Command.PacketType.NO_2_EV5
-        | HCI_Enhanced_Setup_Synchronous_Connection_Command.PacketType.NO_3_EV5
-    ),
-    retransmission_effort=HCI_Enhanced_Setup_Synchronous_Connection_Command.RetransmissionEffort.OPTIMIZE_FOR_POWER,
-)
-
-_ESCO_PARAMETERS_CVSD_S2 = EscoParameters(
-    transmit_coding_format=CodingFormat(CodecID.CVSD),
-    receive_coding_format=CodingFormat(CodecID.CVSD),
-    max_latency=0x0007,
-    packet_type=(
-        HCI_Enhanced_Setup_Synchronous_Connection_Command.PacketType.EV3
-        | HCI_Enhanced_Setup_Synchronous_Connection_Command.PacketType.NO_3_EV3
-        | HCI_Enhanced_Setup_Synchronous_Connection_Command.PacketType.NO_2_EV5
-        | HCI_Enhanced_Setup_Synchronous_Connection_Command.PacketType.NO_3_EV5
-    ),
-    retransmission_effort=HCI_Enhanced_Setup_Synchronous_Connection_Command.RetransmissionEffort.OPTIMIZE_FOR_POWER,
-)
-
-_ESCO_PARAMETERS_CVSD_S3 = EscoParameters(
-    transmit_coding_format=CodingFormat(CodecID.CVSD),
-    receive_coding_format=CodingFormat(CodecID.CVSD),
-    max_latency=0x000A,
-    packet_type=(
-        HCI_Enhanced_Setup_Synchronous_Connection_Command.PacketType.EV3
-        | HCI_Enhanced_Setup_Synchronous_Connection_Command.PacketType.NO_3_EV3
-        | HCI_Enhanced_Setup_Synchronous_Connection_Command.PacketType.NO_2_EV5
-        | HCI_Enhanced_Setup_Synchronous_Connection_Command.PacketType.NO_3_EV5
-    ),
-    retransmission_effort=HCI_Enhanced_Setup_Synchronous_Connection_Command.RetransmissionEffort.OPTIMIZE_FOR_POWER,
-)
-
-_ESCO_PARAMETERS_CVSD_S4 = EscoParameters(
-    transmit_coding_format=CodingFormat(CodecID.CVSD),
-    receive_coding_format=CodingFormat(CodecID.CVSD),
-    max_latency=0x000C,
-    packet_type=(
-        HCI_Enhanced_Setup_Synchronous_Connection_Command.PacketType.EV3
-        | HCI_Enhanced_Setup_Synchronous_Connection_Command.PacketType.NO_3_EV3
-        | HCI_Enhanced_Setup_Synchronous_Connection_Command.PacketType.NO_2_EV5
-        | HCI_Enhanced_Setup_Synchronous_Connection_Command.PacketType.NO_3_EV5
-    ),
-    retransmission_effort=HCI_Enhanced_Setup_Synchronous_Connection_Command.RetransmissionEffort.OPTIMIZE_FOR_QUALITY,
-)
-
-_ESCO_PARAMETERS_MSBC_T1 = EscoParameters(
-    transmit_coding_format=CodingFormat(CodecID.MSBC),
-    receive_coding_format=CodingFormat(CodecID.MSBC),
-    max_latency=0x0008,
-    packet_type=(
-        HCI_Enhanced_Setup_Synchronous_Connection_Command.PacketType.EV3
-        | HCI_Enhanced_Setup_Synchronous_Connection_Command.PacketType.NO_3_EV3
-        | HCI_Enhanced_Setup_Synchronous_Connection_Command.PacketType.NO_2_EV5
-        | HCI_Enhanced_Setup_Synchronous_Connection_Command.PacketType.NO_3_EV5
-    ),
-    input_bandwidth=32000,
-    output_bandwidth=32000,
-    retransmission_effort=HCI_Enhanced_Setup_Synchronous_Connection_Command.RetransmissionEffort.OPTIMIZE_FOR_QUALITY,
-)
-
-_ESCO_PARAMETERS_MSBC_T2 = EscoParameters(
-    transmit_coding_format=CodingFormat(CodecID.MSBC),
-    receive_coding_format=CodingFormat(CodecID.MSBC),
-    max_latency=0x000D,
-    packet_type=(
-        HCI_Enhanced_Setup_Synchronous_Connection_Command.PacketType.EV3
-        | HCI_Enhanced_Setup_Synchronous_Connection_Command.PacketType.NO_2_EV3
-        | HCI_Enhanced_Setup_Synchronous_Connection_Command.PacketType.NO_3_EV3
-        | HCI_Enhanced_Setup_Synchronous_Connection_Command.PacketType.NO_2_EV5
-        | HCI_Enhanced_Setup_Synchronous_Connection_Command.PacketType.NO_3_EV5
-    ),
-    input_bandwidth=32000,
-    output_bandwidth=32000,
-    retransmission_effort=HCI_Enhanced_Setup_Synchronous_Connection_Command.RetransmissionEffort.OPTIMIZE_FOR_QUALITY,
-)
-
-ESCO_PARAMETERS = {
-    DefaultCodecParameters.SCO_CVSD_D0: _ESCO_PARAMETERS_CVSD_D0,
-    DefaultCodecParameters.SCO_CVSD_D1: _ESCO_PARAMETERS_CVSD_D1,
-    DefaultCodecParameters.ESCO_CVSD_S1: _ESCO_PARAMETERS_CVSD_S1,
-    DefaultCodecParameters.ESCO_CVSD_S2: _ESCO_PARAMETERS_CVSD_S2,
-    DefaultCodecParameters.ESCO_CVSD_S3: _ESCO_PARAMETERS_CVSD_S3,
-    DefaultCodecParameters.ESCO_CVSD_S4: _ESCO_PARAMETERS_CVSD_S4,
-    DefaultCodecParameters.ESCO_MSBC_T1: _ESCO_PARAMETERS_MSBC_T1,
-    DefaultCodecParameters.ESCO_MSBC_T2: _ESCO_PARAMETERS_MSBC_T2,
-}
+    async def initialize_service(self) -> None:
+        # Perform Service Level Connection Initialization
+        self.send_command_line('AT+BRSF=2072')  # Retrieve Supported Features
+        await (self.next_line())
+        await (self.next_line())
+
+        self.send_command_line('AT+CIND=?')
+        await (self.next_line())
+        await (self.next_line())
+
+        self.send_command_line('AT+CIND?')
+        await (self.next_line())
+        await (self.next_line())
+
+        self.send_command_line('AT+CMER=3,0,0,1')
+        await (self.next_line())

bumble/hid.py

@@ -1,554 +0,0 @@
-# Copyright 2021-2022 Google LLC
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# -----------------------------------------------------------------------------
-# Imports
-# -----------------------------------------------------------------------------
-from __future__ import annotations
-from dataclasses import dataclass
-import logging
-import enum
-import struct
-
-from abc import ABC, abstractmethod
-from pyee import EventEmitter
-from typing import Optional, Callable, TYPE_CHECKING
-from typing_extensions import override
-
-from bumble import l2cap, device
-from bumble.colors import color
-from bumble.core import InvalidStateError, ProtocolError
-from .hci import Address
-
-
-# -----------------------------------------------------------------------------
-# Logging
-# -----------------------------------------------------------------------------
-logger = logging.getLogger(__name__)
-
-
-# -----------------------------------------------------------------------------
-# Constants
-# -----------------------------------------------------------------------------
-# fmt: on
-HID_CONTROL_PSM = 0x0011
-HID_INTERRUPT_PSM = 0x0013
-
-
-class Message:
-    message_type: MessageType
-    # Report types
-    class ReportType(enum.IntEnum):
-        OTHER_REPORT = 0x00
-        INPUT_REPORT = 0x01
-        OUTPUT_REPORT = 0x02
-        FEATURE_REPORT = 0x03
-
-    # Handshake parameters
-    class Handshake(enum.IntEnum):
-        SUCCESSFUL = 0x00
-        NOT_READY = 0x01
-        ERR_INVALID_REPORT_ID = 0x02
-        ERR_UNSUPPORTED_REQUEST = 0x03
-        ERR_INVALID_PARAMETER = 0x04
-        ERR_UNKNOWN = 0x0E
-        ERR_FATAL = 0x0F
-
-    # Message Type
-    class MessageType(enum.IntEnum):
-        HANDSHAKE = 0x00
-        CONTROL = 0x01
-        GET_REPORT = 0x04
-        SET_REPORT = 0x05
-        GET_PROTOCOL = 0x06
-        SET_PROTOCOL = 0x07
-        DATA = 0x0A
-
-    # Protocol modes
-    class ProtocolMode(enum.IntEnum):
-        BOOT_PROTOCOL = 0x00
-        REPORT_PROTOCOL = 0x01
-
-    # Control Operations
-    class ControlCommand(enum.IntEnum):
-        SUSPEND = 0x03
-        EXIT_SUSPEND = 0x04
-        VIRTUAL_CABLE_UNPLUG = 0x05
-
-    # Class Method to derive header
-    @classmethod
-    def header(cls, lower_bits: int = 0x00) -> bytes:
-        return bytes([(cls.message_type << 4) | lower_bits])
-
-
-# HIDP messages
-@dataclass
-class GetReportMessage(Message):
-    report_type: int
-    report_id: int
-    buffer_size: int
-    message_type = Message.MessageType.GET_REPORT
-
-    def __bytes__(self) -> bytes:
-        packet_bytes = bytearray()
-        packet_bytes.append(self.report_id)
-        if self.buffer_size == 0:
-            return self.header(self.report_type) + packet_bytes
-        else:
-            return (
-                self.header(0x08 | self.report_type)
-                + packet_bytes
-                + struct.pack("<H", self.buffer_size)
-            )
-
-
-@dataclass
-class SetReportMessage(Message):
-    report_type: int
-    data: bytes
-    message_type = Message.MessageType.SET_REPORT
-
-    def __bytes__(self) -> bytes:
-        return self.header(self.report_type) + self.data
-
-
-@dataclass
-class SendControlData(Message):
-    report_type: int
-    data: bytes
-    message_type = Message.MessageType.DATA
-
-    def __bytes__(self) -> bytes:
-        return self.header(self.report_type) + self.data
-
-
-@dataclass
-class GetProtocolMessage(Message):
-    message_type = Message.MessageType.GET_PROTOCOL
-
-    def __bytes__(self) -> bytes:
-        return self.header()
-
-
-@dataclass
-class SetProtocolMessage(Message):
-    protocol_mode: int
-    message_type = Message.MessageType.SET_PROTOCOL
-
-    def __bytes__(self) -> bytes:
-        return self.header(self.protocol_mode)
-
-
-@dataclass
-class Suspend(Message):
-    message_type = Message.MessageType.CONTROL
-
-    def __bytes__(self) -> bytes:
-        return self.header(Message.ControlCommand.SUSPEND)
-
-
-@dataclass
-class ExitSuspend(Message):
-    message_type = Message.MessageType.CONTROL
-
-    def __bytes__(self) -> bytes:
-        return self.header(Message.ControlCommand.EXIT_SUSPEND)
-
-
-@dataclass
-class VirtualCableUnplug(Message):
-    message_type = Message.MessageType.CONTROL
-
-    def __bytes__(self) -> bytes:
-        return self.header(Message.ControlCommand.VIRTUAL_CABLE_UNPLUG)
-
-
-# Device sends input report, host sends output report.
-@dataclass
-class SendData(Message):
-    data: bytes
-    report_type: int
-    message_type = Message.MessageType.DATA
-
-    def __bytes__(self) -> bytes:
-        return self.header(self.report_type) + self.data
-
-
-@dataclass
-class SendHandshakeMessage(Message):
-    result_code: int
-    message_type = Message.MessageType.HANDSHAKE
-
-    def __bytes__(self) -> bytes:
-        return self.header(self.result_code)
-
-
-# -----------------------------------------------------------------------------
-class HID(ABC, EventEmitter):
-    l2cap_ctrl_channel: Optional[l2cap.ClassicChannel] = None
-    l2cap_intr_channel: Optional[l2cap.ClassicChannel] = None
-    connection: Optional[device.Connection] = None
-
-    class Role(enum.IntEnum):
-        HOST = 0x00
-        DEVICE = 0x01
-
-    def __init__(self, device: device.Device, role: Role) -> None:
-        super().__init__()
-        self.remote_device_bd_address: Optional[Address] = None
-        self.device = device
-        self.role = role
-
-        # Register ourselves with the L2CAP channel manager
-        device.register_l2cap_server(HID_CONTROL_PSM, self.on_l2cap_connection)
-        device.register_l2cap_server(HID_INTERRUPT_PSM, self.on_l2cap_connection)
-
-        device.on('connection', self.on_device_connection)
-
-    async def connect_control_channel(self) -> None:
-        # Create a new L2CAP connection - control channel
-        try:
-            self.l2cap_ctrl_channel = await self.device.l2cap_channel_manager.connect(
-                self.connection, HID_CONTROL_PSM
-            )
-        except ProtocolError:
-            logging.exception(f'L2CAP connection failed.')
-            raise
-
-        assert self.l2cap_ctrl_channel is not None
-        # Become a sink for the L2CAP channel
-        self.l2cap_ctrl_channel.sink = self.on_ctrl_pdu
-
-    async def connect_interrupt_channel(self) -> None:
-        # Create a new L2CAP connection - interrupt channel
-        try:
-            self.l2cap_intr_channel = await self.device.l2cap_channel_manager.connect(
-                self.connection, HID_INTERRUPT_PSM
-            )
-        except ProtocolError:
-            logging.exception(f'L2CAP connection failed.')
-            raise
-
-        assert self.l2cap_intr_channel is not None
-        # Become a sink for the L2CAP channel
-        self.l2cap_intr_channel.sink = self.on_intr_pdu
-
-    async def disconnect_interrupt_channel(self) -> None:
-        if self.l2cap_intr_channel is None:
-            raise InvalidStateError('invalid state')
-        channel = self.l2cap_intr_channel
-        self.l2cap_intr_channel = None
-        await channel.disconnect()
-
-    async def disconnect_control_channel(self) -> None:
-        if self.l2cap_ctrl_channel is None:
-            raise InvalidStateError('invalid state')
-        channel = self.l2cap_ctrl_channel
-        self.l2cap_ctrl_channel = None
-        await channel.disconnect()
-
-    def on_device_connection(self, connection: device.Connection) -> None:
-        self.connection = connection
-        self.remote_device_bd_address = connection.peer_address
-        connection.on('disconnection', self.on_device_disconnection)
-
-    def on_device_disconnection(self, reason: int) -> None:
-        self.connection = None
-
-    def on_l2cap_connection(self, l2cap_channel: l2cap.ClassicChannel) -> None:
-        logger.debug(f'+++ New L2CAP connection: {l2cap_channel}')
-        l2cap_channel.on('open', lambda: self.on_l2cap_channel_open(l2cap_channel))
-        l2cap_channel.on('close', lambda: self.on_l2cap_channel_close(l2cap_channel))
-
-    def on_l2cap_channel_open(self, l2cap_channel: l2cap.ClassicChannel) -> None:
-        if l2cap_channel.psm == HID_CONTROL_PSM:
-            self.l2cap_ctrl_channel = l2cap_channel
-            self.l2cap_ctrl_channel.sink = self.on_ctrl_pdu
-        else:
-            self.l2cap_intr_channel = l2cap_channel
-            self.l2cap_intr_channel.sink = self.on_intr_pdu
-        logger.debug(f'$$$ L2CAP channel open: {l2cap_channel}')
-
-    def on_l2cap_channel_close(self, l2cap_channel: l2cap.ClassicChannel) -> None:
-        if l2cap_channel.psm == HID_CONTROL_PSM:
-            self.l2cap_ctrl_channel = None
-        else:
-            self.l2cap_intr_channel = None
-        logger.debug(f'$$$ L2CAP channel close: {l2cap_channel}')
-
-    @abstractmethod
-    def on_ctrl_pdu(self, pdu: bytes) -> None:
-        pass
-
-    def on_intr_pdu(self, pdu: bytes) -> None:
-        logger.debug(f'<<< HID INTERRUPT PDU: {pdu.hex()}')
-        self.emit("interrupt_data", pdu)
-
-    def send_pdu_on_ctrl(self, msg: bytes) -> None:
-        assert self.l2cap_ctrl_channel
-        self.l2cap_ctrl_channel.send_pdu(msg)
-
-    def send_pdu_on_intr(self, msg: bytes) -> None:
-        assert self.l2cap_intr_channel
-        self.l2cap_intr_channel.send_pdu(msg)
-
-    def send_data(self, data: bytes) -> None:
-        if self.role == HID.Role.HOST:
-            report_type = Message.ReportType.OUTPUT_REPORT
-        else:
-            report_type = Message.ReportType.INPUT_REPORT
-        msg = SendData(data, report_type)
-        hid_message = bytes(msg)
-        if self.l2cap_intr_channel is not None:
-            logger.debug(f'>>> HID INTERRUPT SEND DATA, PDU: {hid_message.hex()}')
-            self.send_pdu_on_intr(hid_message)
-
-    def virtual_cable_unplug(self) -> None:
-        msg = VirtualCableUnplug()
-        hid_message = bytes(msg)
-        logger.debug(f'>>> HID CONTROL VIRTUAL CABLE UNPLUG, PDU: {hid_message.hex()}')
-        self.send_pdu_on_ctrl(hid_message)
-
-
-# -----------------------------------------------------------------------------
-
-
-class Device(HID):
-    class GetSetReturn(enum.IntEnum):
-        FAILURE = 0x00
-        REPORT_ID_NOT_FOUND = 0x01
-        ERR_UNSUPPORTED_REQUEST = 0x02
-        ERR_UNKNOWN = 0x03
-        ERR_INVALID_PARAMETER = 0x04
-        SUCCESS = 0xFF
-
-    class GetSetStatus:
-        def __init__(self) -> None:
-            self.data = bytearray()
-            self.status = 0
-
-    def __init__(self, device: device.Device) -> None:
-        super().__init__(device, HID.Role.DEVICE)
-        get_report_cb: Optional[Callable[[int, int, int], None]] = None
-        set_report_cb: Optional[Callable[[int, int, int, bytes], None]] = None
-        get_protocol_cb: Optional[Callable[[], None]] = None
-        set_protocol_cb: Optional[Callable[[int], None]] = None
-
-    @override
-    def on_ctrl_pdu(self, pdu: bytes) -> None:
-        logger.debug(f'<<< HID CONTROL PDU: {pdu.hex()}')
-        param = pdu[0] & 0x0F
-        message_type = pdu[0] >> 4
-
-        if message_type == Message.MessageType.GET_REPORT:
-            logger.debug('<<< HID GET REPORT')
-            self.handle_get_report(pdu)
-        elif message_type == Message.MessageType.SET_REPORT:
-            logger.debug('<<< HID SET REPORT')
-            self.handle_set_report(pdu)
-        elif message_type == Message.MessageType.GET_PROTOCOL:
-            logger.debug('<<< HID GET PROTOCOL')
-            self.handle_get_protocol(pdu)
-        elif message_type == Message.MessageType.SET_PROTOCOL:
-            logger.debug('<<< HID SET PROTOCOL')
-            self.handle_set_protocol(pdu)
-        elif message_type == Message.MessageType.DATA:
-            logger.debug('<<< HID CONTROL DATA')
-            self.emit('control_data', pdu)
-        elif message_type == Message.MessageType.CONTROL:
-            if param == Message.ControlCommand.SUSPEND:
-                logger.debug('<<< HID SUSPEND')
-                self.emit('suspend')
-            elif param == Message.ControlCommand.EXIT_SUSPEND:
-                logger.debug('<<< HID EXIT SUSPEND')
-                self.emit('exit_suspend')
-            elif param == Message.ControlCommand.VIRTUAL_CABLE_UNPLUG:
-                logger.debug('<<< HID VIRTUAL CABLE UNPLUG')
-                self.emit('virtual_cable_unplug')
-            else:
-                logger.debug('<<< HID CONTROL OPERATION UNSUPPORTED')
-        else:
-            logger.debug('<<< HID MESSAGE TYPE UNSUPPORTED')
-            self.send_handshake_message(Message.Handshake.ERR_UNSUPPORTED_REQUEST)
-
-    def send_handshake_message(self, result_code: int) -> None:
-        msg = SendHandshakeMessage(result_code)
-        hid_message = bytes(msg)
-        logger.debug(f'>>> HID HANDSHAKE MESSAGE, PDU: {hid_message.hex()}')
-        self.send_pdu_on_ctrl(hid_message)
-
-    def send_control_data(self, report_type: int, data: bytes):
-        msg = SendControlData(report_type=report_type, data=data)
-        hid_message = bytes(msg)
-        logger.debug(f'>>> HID CONTROL DATA: {hid_message.hex()}')
-        self.send_pdu_on_ctrl(hid_message)
-
-    def handle_get_report(self, pdu: bytes):
-        if self.get_report_cb is None:
-            logger.debug("GetReport callback not registered !!")
-            self.send_handshake_message(Message.Handshake.ERR_UNSUPPORTED_REQUEST)
-            return
-        report_type = pdu[0] & 0x03
-        buffer_flag = (pdu[0] & 0x08) >> 3
-        report_id = pdu[1]
-        logger.debug(f"buffer_flag: {buffer_flag}")
-        if buffer_flag == 1:
-            buffer_size = (pdu[3] << 8) | pdu[2]
-        else:
-            buffer_size = 0
-
-        ret = self.get_report_cb(report_id, report_type, buffer_size)
-        assert ret is not None
-        if ret.status == self.GetSetReturn.FAILURE:
-            self.send_handshake_message(Message.Handshake.ERR_UNKNOWN)
-        elif ret.status == self.GetSetReturn.SUCCESS:
-            data = bytearray()
-            data.append(report_id)
-            data.extend(ret.data)
-            if len(data) < self.l2cap_ctrl_channel.mtu:  # type: ignore[union-attr]
-                self.send_control_data(report_type=report_type, data=data)
-            else:
-                self.send_handshake_message(Message.Handshake.ERR_INVALID_PARAMETER)
-        elif ret.status == self.GetSetReturn.REPORT_ID_NOT_FOUND:
-            self.send_handshake_message(Message.Handshake.ERR_INVALID_REPORT_ID)
-        elif ret.status == self.GetSetReturn.ERR_INVALID_PARAMETER:
-            self.send_handshake_message(Message.Handshake.ERR_INVALID_PARAMETER)
-        elif ret.status == self.GetSetReturn.ERR_UNSUPPORTED_REQUEST:
-            self.send_handshake_message(Message.Handshake.ERR_UNSUPPORTED_REQUEST)
-
-    def register_get_report_cb(self, cb: Callable[[int, int, int], None]) -> None:
-        self.get_report_cb = cb
-        logger.debug("GetReport callback registered successfully")
-
-    def handle_set_report(self, pdu: bytes):
-        if self.set_report_cb is None:
-            logger.debug("SetReport callback not registered !!")
-            self.send_handshake_message(Message.Handshake.ERR_UNSUPPORTED_REQUEST)
-            return
-        report_type = pdu[0] & 0x03
-        report_id = pdu[1]
-        report_data = pdu[2:]
-        report_size = len(report_data) + 1
-        ret = self.set_report_cb(report_id, report_type, report_size, report_data)
-        assert ret is not None
-        if ret.status == self.GetSetReturn.SUCCESS:
-            self.send_handshake_message(Message.Handshake.SUCCESSFUL)
-        elif ret.status == self.GetSetReturn.ERR_INVALID_PARAMETER:
-            self.send_handshake_message(Message.Handshake.ERR_INVALID_PARAMETER)
-        elif ret.status == self.GetSetReturn.REPORT_ID_NOT_FOUND:
-            self.send_handshake_message(Message.Handshake.ERR_INVALID_REPORT_ID)
-        else:
-            self.send_handshake_message(Message.Handshake.ERR_UNSUPPORTED_REQUEST)
-
-    def register_set_report_cb(
-        self, cb: Callable[[int, int, int, bytes], None]
-    ) -> None:
-        self.set_report_cb = cb
-        logger.debug("SetReport callback registered successfully")
-
-    def handle_get_protocol(self, pdu: bytes):
-        if self.get_protocol_cb is None:
-            logger.debug("GetProtocol callback not registered !!")
-            self.send_handshake_message(Message.Handshake.ERR_UNSUPPORTED_REQUEST)
-            return
-        ret = self.get_protocol_cb()
-        assert ret is not None
-        if ret.status == self.GetSetReturn.SUCCESS:
-            self.send_control_data(Message.ReportType.OTHER_REPORT, ret.data)
-        else:
-            self.send_handshake_message(Message.Handshake.ERR_UNSUPPORTED_REQUEST)
-
-    def register_get_protocol_cb(self, cb: Callable[[], None]) -> None:
-        self.get_protocol_cb = cb
-        logger.debug("GetProtocol callback registered successfully")
-
-    def handle_set_protocol(self, pdu: bytes):
-        if self.set_protocol_cb is None:
-            logger.debug("SetProtocol callback not registered !!")
-            self.send_handshake_message(Message.Handshake.ERR_UNSUPPORTED_REQUEST)
-            return
-        ret = self.set_protocol_cb(pdu[0] & 0x01)
-        assert ret is not None
-        if ret.status == self.GetSetReturn.SUCCESS:
-            self.send_handshake_message(Message.Handshake.SUCCESSFUL)
-        else:
-            self.send_handshake_message(Message.Handshake.ERR_UNSUPPORTED_REQUEST)
-
-    def register_set_protocol_cb(self, cb: Callable[[int], None]) -> None:
-        self.set_protocol_cb = cb
-        logger.debug("SetProtocol callback registered successfully")
-
-
-# -----------------------------------------------------------------------------
-class Host(HID):
-    def __init__(self, device: device.Device) -> None:
-        super().__init__(device, HID.Role.HOST)
-
-    def get_report(self, report_type: int, report_id: int, buffer_size: int) -> None:
-        msg = GetReportMessage(
-            report_type=report_type, report_id=report_id, buffer_size=buffer_size
-        )
-        hid_message = bytes(msg)
-        logger.debug(f'>>> HID CONTROL GET REPORT, PDU: {hid_message.hex()}')
-        self.send_pdu_on_ctrl(hid_message)
-
-    def set_report(self, report_type: int, data: bytes) -> None:
-        msg = SetReportMessage(report_type=report_type, data=data)
-        hid_message = bytes(msg)
-        logger.debug(f'>>> HID CONTROL SET REPORT, PDU:{hid_message.hex()}')
-        self.send_pdu_on_ctrl(hid_message)
-
-    def get_protocol(self) -> None:
-        msg = GetProtocolMessage()
-        hid_message = bytes(msg)
-        logger.debug(f'>>> HID CONTROL GET PROTOCOL, PDU: {hid_message.hex()}')
-        self.send_pdu_on_ctrl(hid_message)
-
-    def set_protocol(self, protocol_mode: int) -> None:
-        msg = SetProtocolMessage(protocol_mode=protocol_mode)
-        hid_message = bytes(msg)
-        logger.debug(f'>>> HID CONTROL SET PROTOCOL, PDU: {hid_message.hex()}')
-        self.send_pdu_on_ctrl(hid_message)
-
-    def suspend(self) -> None:
-        msg = Suspend()
-        hid_message = bytes(msg)
-        logger.debug(f'>>> HID CONTROL SUSPEND, PDU:{hid_message.hex()}')
-        self.send_pdu_on_ctrl(hid_message)
-
-    def exit_suspend(self) -> None:
-        msg = ExitSuspend()
-        hid_message = bytes(msg)
-        logger.debug(f'>>> HID CONTROL EXIT SUSPEND, PDU:{hid_message.hex()}')
-        self.send_pdu_on_ctrl(hid_message)
-
-    @override
-    def on_ctrl_pdu(self, pdu: bytes) -> None:
-        logger.debug(f'<<< HID CONTROL PDU: {pdu.hex()}')
-        param = pdu[0] & 0x0F
-        message_type = pdu[0] >> 4
-        if message_type == Message.MessageType.HANDSHAKE:
-            logger.debug(f'<<< HID HANDSHAKE: {Message.Handshake(param).name}')
-            self.emit('handshake', Message.Handshake(param))
-        elif message_type == Message.MessageType.DATA:
-            logger.debug('<<< HID CONTROL DATA')
-            self.emit('control_data', pdu)
-        elif message_type == Message.MessageType.CONTROL:
-            if param == Message.ControlCommand.VIRTUAL_CABLE_UNPLUG:
-                logger.debug('<<< HID VIRTUAL CABLE UNPLUG')
-                self.emit('virtual_cable_unplug')
-            else:
-                logger.debug('<<< HID CONTROL OPERATION UNSUPPORTED')
-        else:
-            logger.debug('<<< HID MESSAGE TYPE UNSUPPORTED')

bumble/host.py

@@ -15,25 +15,24 @@
 # -----------------------------------------------------------------------------
 # Imports
 # -----------------------------------------------------------------------------
-from __future__ import annotations
 import asyncio
 import collections
 import logging
 import struct
 
-from typing import Any, Awaitable, Callable, Deque, Dict, Optional, cast, TYPE_CHECKING
-
 from bumble.colors import color
 from bumble.l2cap import L2CAP_PDU
 from bumble.snoop import Snooper
 from bumble import drivers
 
+from typing import Optional
+
 from .hci import (
     Address,
     HCI_ACL_DATA_PACKET,
+    HCI_COMMAND_COMPLETE_EVENT,
     HCI_COMMAND_PACKET,
     HCI_EVENT_PACKET,
-    HCI_ISO_DATA_PACKET,
     HCI_LE_READ_BUFFER_SIZE_COMMAND,
     HCI_LE_READ_LOCAL_SUPPORTED_FEATURES_COMMAND,
     HCI_LE_READ_SUGGESTED_DEFAULT_DATA_LENGTH_COMMAND,
@@ -43,16 +42,11 @@ from .hci import (
     HCI_RESET_COMMAND,
     HCI_SUCCESS,
     HCI_SUPPORTED_COMMANDS_FLAGS,
-    HCI_SYNCHRONOUS_DATA_PACKET,
     HCI_VERSION_BLUETOOTH_CORE_4_0,
     HCI_AclDataPacket,
     HCI_AclDataPacketAssembler,
-    HCI_Command,
-    HCI_Command_Complete_Event,
     HCI_Constant,
     HCI_Error,
-    HCI_Event,
-    HCI_IsoDataPacket,
     HCI_LE_Long_Term_Key_Request_Negative_Reply_Command,
     HCI_LE_Long_Term_Key_Request_Reply_Command,
     HCI_LE_Read_Buffer_Size_Command,
@@ -69,19 +63,16 @@ from .hci import (
     HCI_Read_Local_Version_Information_Command,
     HCI_Reset_Command,
     HCI_Set_Event_Mask_Command,
-    HCI_SynchronousDataPacket,
+    map_null_terminated_utf8_string,
 )
 from .core import (
     BT_BR_EDR_TRANSPORT,
+    BT_CENTRAL_ROLE,
     BT_LE_TRANSPORT,
     ConnectionPHY,
     ConnectionParameters,
 )
 from .utils import AbortableEventEmitter
-from .transport.common import TransportLostError
-
-if TYPE_CHECKING:
-    from .transport.common import TransportSink, TransportSource
 
 
 # -----------------------------------------------------------------------------
@@ -91,99 +82,53 @@ logger = logging.getLogger(__name__)
 
 
 # -----------------------------------------------------------------------------
-class AclPacketQueue:
-    max_packet_size: int
+# Constants
+# -----------------------------------------------------------------------------
+# fmt: off
 
-    def __init__(
-        self,
-        max_packet_size: int,
-        max_in_flight: int,
-        send: Callable[[HCI_Packet], None],
-    ) -> None:
-        self.max_packet_size = max_packet_size
-        self.max_in_flight = max_in_flight
-        self.in_flight = 0
-        self.send = send
-        self.packets: Deque[HCI_AclDataPacket] = collections.deque()
+HOST_DEFAULT_HC_LE_ACL_DATA_PACKET_LENGTH = 27
+HOST_HC_TOTAL_NUM_LE_ACL_DATA_PACKETS     = 1
+HOST_DEFAULT_HC_ACL_DATA_PACKET_LENGTH    = 27
+HOST_HC_TOTAL_NUM_ACL_DATA_PACKETS        = 1
 
-    def enqueue(self, packet: HCI_AclDataPacket) -> None:
-        self.packets.appendleft(packet)
-        self.check_queue()
-
-        if self.packets:
-            logger.debug(
-                f'{self.in_flight} ACL packets in flight, '
-                f'{len(self.packets)} in queue'
-            )
-
-    def check_queue(self) -> None:
-        while self.packets and self.in_flight < self.max_in_flight:
-            packet = self.packets.pop()
-            self.send(packet)
-            self.in_flight += 1
-
-    def on_packets_completed(self, packet_count: int) -> None:
-        if packet_count > self.in_flight:
-            logger.warning(
-                color(
-                    '!!! {packet_count} completed but only '
-                    f'{self.in_flight} in flight'
-                )
-            )
-            packet_count = self.in_flight
-
-        self.in_flight -= packet_count
-        self.check_queue()
+# fmt: on
 
 
 # -----------------------------------------------------------------------------
 class Connection:
-    def __init__(self, host: Host, handle: int, peer_address: Address, transport: int):
+    def __init__(self, host, handle, peer_address, transport):
         self.host = host
         self.handle = handle
         self.peer_address = peer_address
         self.assembler = HCI_AclDataPacketAssembler(self.on_acl_pdu)
         self.transport = transport
-        acl_packet_queue: Optional[AclPacketQueue] = (
-            host.le_acl_packet_queue
-            if transport == BT_LE_TRANSPORT
-            else host.acl_packet_queue
-        )
-        assert acl_packet_queue
-        self.acl_packet_queue = acl_packet_queue
 
-    def on_hci_acl_data_packet(self, packet: HCI_AclDataPacket) -> None:
+    def on_hci_acl_data_packet(self, packet):
         self.assembler.feed_packet(packet)
 
-    def on_acl_pdu(self, pdu: bytes) -> None:
+    def on_acl_pdu(self, pdu):
         l2cap_pdu = L2CAP_PDU.from_bytes(pdu)
         self.host.on_l2cap_pdu(self, l2cap_pdu.cid, l2cap_pdu.payload)
 
 
 # -----------------------------------------------------------------------------
 class Host(AbortableEventEmitter):
-    connections: Dict[int, Connection]
-    acl_packet_queue: Optional[AclPacketQueue] = None
-    le_acl_packet_queue: Optional[AclPacketQueue] = None
-    hci_sink: Optional[TransportSink] = None
-    hci_metadata: Dict[str, Any]
-    long_term_key_provider: Optional[
-        Callable[[int, bytes, int], Awaitable[Optional[bytes]]]
-    ]
-    link_key_provider: Optional[Callable[[Address], Awaitable[Optional[bytes]]]]
-
-    def __init__(
-        self,
-        controller_source: Optional[TransportSource] = None,
-        controller_sink: Optional[TransportSink] = None,
-    ) -> None:
+    def __init__(self, controller_source=None, controller_sink=None):
         super().__init__()
 
-        self.hci_metadata = {}
+        self.hci_sink = None
+        self.hci_metadata = None
         self.ready = False  # True when we can accept incoming packets
+        self.reset_done = False
         self.connections = {}  # Connections, by connection handle
         self.pending_command = None
         self.pending_response = None
+        self.hc_le_acl_data_packet_length = HOST_DEFAULT_HC_LE_ACL_DATA_PACKET_LENGTH
+        self.hc_total_num_le_acl_data_packets = HOST_HC_TOTAL_NUM_LE_ACL_DATA_PACKETS
+        self.hc_acl_data_packet_length = HOST_DEFAULT_HC_ACL_DATA_PACKET_LENGTH
+        self.hc_total_num_acl_data_packets = HOST_HC_TOTAL_NUM_ACL_DATA_PACKETS
+        self.acl_packet_queue = collections.deque()
+        self.acl_packets_in_flight = 0
         self.local_version = None
         self.local_supported_commands = bytes(64)
         self.local_le_features = 0
@@ -197,7 +142,10 @@ class Host(AbortableEventEmitter):
 
         # Connect to the source and sink if specified
         if controller_source:
-            self.set_packet_source(controller_source)
+            controller_source.set_packet_sink(self)
+            self.hci_metadata = getattr(
+                controller_source, 'metadata', self.hci_metadata
+            )
         if controller_sink:
             self.set_packet_sink(controller_sink)
 
@@ -232,21 +180,17 @@ class Host(AbortableEventEmitter):
             self.ready = False
             await self.flush()
 
+        await self.send_command(HCI_Reset_Command(), check_result=True)
+        self.ready = True
+
         # Instantiate and init a driver for the host if needed.
         # NOTE: we don't keep a reference to the driver here, because we don't
         # currently have a need for the driver later on. But if the driver interface
         # evolves, it may be required, then, to store a reference to the driver in
         # an object property.
-        reset_needed = True
         if driver_factory is not None:
             if driver := await driver_factory(self):
                 await driver.init_controller()
-                reset_needed = False
-
-        # Send a reset command unless a driver has already done so.
-        if reset_needed:
-            await self.send_command(HCI_Reset_Command(), check_result=True)
-            self.ready = True
 
         response = await self.send_command(
             HCI_Read_Local_Supported_Commands_Command(), check_result=True
@@ -279,7 +223,7 @@ class Host(AbortableEventEmitter):
             # understand
             le_event_mask = bytes.fromhex('1F00000000000000')
         else:
-            le_event_mask = bytes.fromhex('FFFFFFFF00000000')
+            le_event_mask = bytes.fromhex('FFFFF00000000000')
 
         await self.send_command(
             HCI_LE_Set_Event_Mask_Command(le_event_mask=le_event_mask)
@@ -289,54 +233,46 @@ class Host(AbortableEventEmitter):
             response = await self.send_command(
                 HCI_Read_Buffer_Size_Command(), check_result=True
             )
-            hc_acl_data_packet_length = (
+            self.hc_acl_data_packet_length = (
                 response.return_parameters.hc_acl_data_packet_length
             )
-            hc_total_num_acl_data_packets = (
+            self.hc_total_num_acl_data_packets = (
                 response.return_parameters.hc_total_num_acl_data_packets
             )
 
             logger.debug(
                 'HCI ACL flow control: '
-                f'hc_acl_data_packet_length={hc_acl_data_packet_length},'
-                f'hc_total_num_acl_data_packets={hc_total_num_acl_data_packets}'
+                f'hc_acl_data_packet_length={self.hc_acl_data_packet_length},'
+                f'hc_total_num_acl_data_packets={self.hc_total_num_acl_data_packets}'
             )
 
-            self.acl_packet_queue = AclPacketQueue(
-                max_packet_size=hc_acl_data_packet_length,
-                max_in_flight=hc_total_num_acl_data_packets,
-                send=self.send_hci_packet,
-            )
-
-        hc_le_acl_data_packet_length = 0
-        hc_total_num_le_acl_data_packets = 0
         if self.supports_command(HCI_LE_READ_BUFFER_SIZE_COMMAND):
             response = await self.send_command(
                 HCI_LE_Read_Buffer_Size_Command(), check_result=True
             )
-            hc_le_acl_data_packet_length = (
+            self.hc_le_acl_data_packet_length = (
                 response.return_parameters.hc_le_acl_data_packet_length
             )
-            hc_total_num_le_acl_data_packets = (
+            self.hc_total_num_le_acl_data_packets = (
                 response.return_parameters.hc_total_num_le_acl_data_packets
             )
 
             logger.debug(
                 'HCI LE ACL flow control: '
-                f'hc_le_acl_data_packet_length={hc_le_acl_data_packet_length},'
-                f'hc_total_num_le_acl_data_packets={hc_total_num_le_acl_data_packets}'
+                f'hc_le_acl_data_packet_length={self.hc_le_acl_data_packet_length},'
+                'hc_total_num_le_acl_data_packets='
+                f'{self.hc_total_num_le_acl_data_packets}'
             )
 
-        if hc_le_acl_data_packet_length == 0 or hc_total_num_le_acl_data_packets == 0:
-            # LE and Classic share the same queue
-            self.le_acl_packet_queue = self.acl_packet_queue
-        else:
-            # Create a separate queue for LE
-            self.le_acl_packet_queue = AclPacketQueue(
-                max_packet_size=hc_le_acl_data_packet_length,
-                max_in_flight=hc_total_num_le_acl_data_packets,
-                send=self.send_hci_packet,
-            )
+            if (
+                response.return_parameters.hc_le_acl_data_packet_length == 0
+                or response.return_parameters.hc_total_num_le_acl_data_packets == 0
+            ):
+                # LE and Classic share the same values
+                self.hc_le_acl_data_packet_length = self.hc_acl_data_packet_length
+                self.hc_total_num_le_acl_data_packets = (
+                    self.hc_total_num_acl_data_packets
+                )
 
         if self.supports_command(
             HCI_LE_READ_SUGGESTED_DEFAULT_DATA_LENGTH_COMMAND
@@ -357,31 +293,30 @@ class Host(AbortableEventEmitter):
                     )
                 )
 
+        self.reset_done = True
+
     @property
-    def controller(self) -> Optional[TransportSink]:
+    def controller(self):
         return self.hci_sink
 
     @controller.setter
-    def controller(self, controller) -> None:
+    def controller(self, controller):
         self.set_packet_sink(controller)
         if controller:
             controller.set_packet_sink(self)
 
-    def set_packet_sink(self, sink: Optional[TransportSink]) -> None:
+    def set_packet_sink(self, sink):
         self.hci_sink = sink
 
-    def set_packet_source(self, source: TransportSource) -> None:
-        source.set_packet_sink(self)
-        self.hci_metadata = getattr(source, 'metadata', self.hci_metadata)
-
-    def send_hci_packet(self, packet: HCI_Packet) -> None:
-        logger.debug(f'{color("### HOST -> CONTROLLER", "blue")}: {packet}')
+    def send_hci_packet(self, packet):
         if self.snooper:
             self.snooper.snoop(bytes(packet), Snooper.Direction.HOST_TO_CONTROLLER)
-        if self.hci_sink:
-            self.hci_sink.on_packet(bytes(packet))
+
+        self.hci_sink.on_packet(bytes(packet))
 
     async def send_command(self, command, check_result=False):
+        logger.debug(f'{color("### HOST -> CONTROLLER", "blue")}: {command}')
+
         # Wait until we can send (only one pending command at a time)
         async with self.command_semaphore:
             assert self.pending_command is None
@@ -414,7 +349,7 @@ class Host(AbortableEventEmitter):
                 return response
             except Exception as error:
                 logger.warning(
-                    f'{color("!!! Exception while sending command:", "red")} {error}'
+                    f'{color("!!! Exception while sending HCI packet:", "red")} {error}'
                 )
                 raise error
             finally:
@@ -422,24 +357,13 @@ class Host(AbortableEventEmitter):
                 self.pending_response = None
 
     # Use this method to send a command from a task
-    def send_command_sync(self, command: HCI_Command) -> None:
-        async def send_command(command: HCI_Command) -> None:
+    def send_command_sync(self, command):
+        async def send_command(command):
             await self.send_command(command)
 
         asyncio.create_task(send_command(command))
 
-    def send_l2cap_pdu(self, connection_handle: int, cid: int, pdu: bytes) -> None:
-        if not (connection := self.connections.get(connection_handle)):
-            logger.warning(f'connection 0x{connection_handle:04X} not found')
-            return
-        packet_queue = connection.acl_packet_queue
-        if packet_queue is None:
-            logger.warning(
-                f'no ACL packet queue for connection 0x{connection_handle:04X}'
-            )
-            return
-
-        # Create a PDU
+    def send_l2cap_pdu(self, connection_handle, cid, pdu):
         l2cap_pdu = bytes(L2CAP_PDU(cid, pdu))
 
         # Send the data to the controller via ACL packets
@@ -447,7 +371,8 @@ class Host(AbortableEventEmitter):
         offset = 0
         pb_flag = 0
         while bytes_remaining:
-            data_total_length = min(bytes_remaining, packet_queue.max_packet_size)
+            # TODO: support different LE/Classic lengths
+            data_total_length = min(bytes_remaining, self.hc_le_acl_data_packet_length)
             acl_packet = HCI_AclDataPacket(
                 connection_handle=connection_handle,
                 pb_flag=pb_flag,
@@ -455,12 +380,34 @@ class Host(AbortableEventEmitter):
                 data_total_length=data_total_length,
                 data=l2cap_pdu[offset : offset + data_total_length],
             )
-            logger.debug(f'>>> ACL packet enqueue: (CID={cid}) {acl_packet}')
-            packet_queue.enqueue(acl_packet)
+            logger.debug(
+                f'{color("### HOST -> CONTROLLER", "blue")}: (CID={cid}) {acl_packet}'
+            )
+            self.queue_acl_packet(acl_packet)
             pb_flag = 1
             offset += data_total_length
             bytes_remaining -= data_total_length
 
+    def queue_acl_packet(self, acl_packet):
+        self.acl_packet_queue.appendleft(acl_packet)
+        self.check_acl_packet_queue()
+
+        if len(self.acl_packet_queue):
+            logger.debug(
+                f'{self.acl_packets_in_flight} ACL packets in flight, '
+                f'{len(self.acl_packet_queue)} in queue'
+            )
+
+    def check_acl_packet_queue(self):
+        # Send all we can (TODO: support different LE/Classic limits)
+        while (
+            len(self.acl_packet_queue) > 0
+            and self.acl_packets_in_flight < self.hc_total_num_le_acl_data_packets
+        ):
+            packet = self.acl_packet_queue.pop()
+            self.send_hci_packet(packet)
+            self.acl_packets_in_flight += 1
+
     def supports_command(self, command):
         # Find the support flag position for this command
         for octet, flags in enumerate(HCI_SUPPORTED_COMMANDS_FLAGS):
@@ -497,24 +444,18 @@ class Host(AbortableEventEmitter):
         ]
 
     # Packet Sink protocol (packets coming from the controller via HCI)
-    def on_packet(self, packet: bytes) -> None:
+    def on_packet(self, packet):
         hci_packet = HCI_Packet.from_bytes(packet)
         if self.ready or (
-            isinstance(hci_packet, HCI_Command_Complete_Event)
+            hci_packet.hci_packet_type == HCI_EVENT_PACKET
+            and hci_packet.event_code == HCI_COMMAND_COMPLETE_EVENT
             and hci_packet.command_opcode == HCI_RESET_COMMAND
         ):
             self.on_hci_packet(hci_packet)
         else:
             logger.debug('reset not done, ignoring packet from controller')
 
-    def on_transport_lost(self):
-        # Called by the source when the transport has been lost.
-        if self.pending_response:
-            self.pending_response.set_exception(TransportLostError('transport lost'))
-
-        self.emit('flush')
-
-    def on_hci_packet(self, packet: HCI_Packet) -> None:
+    def on_hci_packet(self, packet):
         logger.debug(f'{color("### CONTROLLER -> HOST", "green")}: {packet}')
 
         if self.snooper:
@@ -522,40 +463,28 @@ class Host(AbortableEventEmitter):
 
         # If the packet is a command, invoke the handler for this packet
         if packet.hci_packet_type == HCI_COMMAND_PACKET:
-            self.on_hci_command_packet(cast(HCI_Command, packet))
+            self.on_hci_command_packet(packet)
         elif packet.hci_packet_type == HCI_EVENT_PACKET:
-            self.on_hci_event_packet(cast(HCI_Event, packet))
+            self.on_hci_event_packet(packet)
         elif packet.hci_packet_type == HCI_ACL_DATA_PACKET:
-            self.on_hci_acl_data_packet(cast(HCI_AclDataPacket, packet))
-        elif packet.hci_packet_type == HCI_SYNCHRONOUS_DATA_PACKET:
-            self.on_hci_sco_data_packet(cast(HCI_SynchronousDataPacket, packet))
-        elif packet.hci_packet_type == HCI_ISO_DATA_PACKET:
-            self.on_hci_iso_data_packet(cast(HCI_IsoDataPacket, packet))
+            self.on_hci_acl_data_packet(packet)
         else:
             logger.warning(f'!!! unknown packet type {packet.hci_packet_type}')
 
-    def on_hci_command_packet(self, command: HCI_Command) -> None:
+    def on_hci_command_packet(self, command):
         logger.warning(f'!!! unexpected command packet: {command}')
 
-    def on_hci_event_packet(self, event: HCI_Event) -> None:
+    def on_hci_event_packet(self, event):
         handler_name = f'on_{event.name.lower()}'
         handler = getattr(self, handler_name, self.on_hci_event)
         handler(event)
 
-    def on_hci_acl_data_packet(self, packet: HCI_AclDataPacket) -> None:
+    def on_hci_acl_data_packet(self, packet):
         # Look for the connection to which this data belongs
         if connection := self.connections.get(packet.connection_handle):
             connection.on_hci_acl_data_packet(packet)
 
-    def on_hci_sco_data_packet(self, packet: HCI_SynchronousDataPacket) -> None:
-        # Experimental
-        self.emit('sco_packet', packet.connection_handle, packet)
-
-    def on_hci_iso_data_packet(self, packet: HCI_IsoDataPacket) -> None:
-        # Experimental
-        self.emit('iso_packet', packet.connection_handle, packet)
-
-    def on_l2cap_pdu(self, connection: Connection, cid: int, pdu: bytes) -> None:
+    def on_l2cap_pdu(self, connection, cid, pdu):
         self.emit('l2cap_pdu', connection.handle, cid, pdu)
 
     def on_command_processed(self, event):
@@ -583,7 +512,7 @@ class Host(AbortableEventEmitter):
             # This is used just for the Num_HCI_Command_Packets field, not related to
             # an actual command
             logger.debug('no-command event')
-            return
+            return None
 
         return self.on_command_processed(event)
 
@@ -591,17 +520,18 @@ class Host(AbortableEventEmitter):
         return self.on_command_processed(event)
 
     def on_hci_number_of_completed_packets_event(self, event):
-        for connection_handle, num_completed_packets in zip(
-            event.connection_handles, event.num_completed_packets
-        ):
-            if not (connection := self.connections.get(connection_handle)):
-                logger.warning(
-                    'received packet completion event for unknown handle '
-                    f'0x{connection_handle:04X}'
+        total_packets = sum(event.num_completed_packets)
+        if total_packets <= self.acl_packets_in_flight:
+            self.acl_packets_in_flight -= total_packets
+            self.check_acl_packet_queue()
+        else:
+            logger.warning(
+                color(
+                    '!!! {total_packets} completed but only '
+                    f'{self.acl_packets_in_flight} in flight'
                 )
-                continue
-
-            connection.acl_packet_queue.on_packets_completed(num_completed_packets)
+            )
+            self.acl_packets_in_flight = 0
 
     # Classic only
     def on_hci_connection_request_event(self, event):
@@ -754,32 +684,6 @@ class Host(AbortableEventEmitter):
     def on_hci_le_extended_advertising_report_event(self, event):
         self.on_hci_le_advertising_report_event(event)
 
-    def on_hci_le_advertising_set_terminated_event(self, event):
-        self.emit(
-            'advertising_set_termination',
-            event.status,
-            event.advertising_handle,
-            event.connection_handle,
-        )
-
-    def on_hci_le_cis_request_event(self, event):
-        self.emit(
-            'cis_request',
-            event.acl_connection_handle,
-            event.cis_connection_handle,
-            event.cig_id,
-            event.cis_id,
-        )
-
-    def on_hci_le_cis_established_event(self, event):
-        # The remaining parameters are unused for now.
-        if event.status == HCI_SUCCESS:
-            self.emit('cis_establishment', event.connection_handle)
-        else:
-            self.emit(
-                'cis_establishment_failure', event.connection_handle, event.status
-            )
-
     def on_hci_le_remote_connection_parameter_request_event(self, event):
         if event.connection_handle not in self.connections:
             logger.warning('!!! REMOTE CONNECTION PARAMETER REQUEST: unknown handle')
@@ -833,25 +737,7 @@ class Host(AbortableEventEmitter):
         asyncio.create_task(send_long_term_key())
 
     def on_hci_synchronous_connection_complete_event(self, event):
-        if event.status == HCI_SUCCESS:
-            # Create/update the connection
-            logger.debug(
-                f'### SCO CONNECTION: [0x{event.connection_handle:04X}] '
-                f'{event.bd_addr}'
-            )
-
-            # Notify the client
-            self.emit(
-                'sco_connection',
-                event.bd_addr,
-                event.connection_handle,
-                event.link_type,
-            )
-        else:
-            logger.debug(f'### SCO CONNECTION FAILED: {event.status}')
-
-            # Notify the client
-            self.emit('sco_connection_failure', event.bd_addr, event.status)
+        pass
 
     def on_hci_synchronous_connection_changed_event(self, event):
         pass
@@ -936,10 +822,6 @@ class Host(AbortableEventEmitter):
             f'simple pairing complete for {event.bd_addr}: '
             f'status={HCI_Constant.status_name(event.status)}'
         )
-        if event.status == HCI_SUCCESS:
-            self.emit('classic_pairing', event.bd_addr)
-        else:
-            self.emit('classic_pairing_failure', event.bd_addr, event.status)
 
     def on_hci_pin_code_request_event(self, event):
         self.emit('pin_code_request', event.bd_addr)

bumble/pairing.py

@@ -15,13 +15,10 @@
 # -----------------------------------------------------------------------------
 # Imports
 # -----------------------------------------------------------------------------
-from __future__ import annotations
 import enum
-from dataclasses import dataclass
 from typing import Optional, Tuple
 
 from .hci import (
-    Address,
     HCI_NO_INPUT_NO_OUTPUT_IO_CAPABILITY,
     HCI_DISPLAY_ONLY_IO_CAPABILITY,
     HCI_DISPLAY_YES_NO_IO_CAPABILITY,
@@ -37,60 +34,7 @@ from .smp import (
     SMP_ID_KEY_DISTRIBUTION_FLAG,
     SMP_SIGN_KEY_DISTRIBUTION_FLAG,
     SMP_LINK_KEY_DISTRIBUTION_FLAG,
-    OobContext,
-    OobLegacyContext,
-    OobSharedData,
 )
-from .core import AdvertisingData, LeRole
-
-
-# -----------------------------------------------------------------------------
-@dataclass
-class OobData:
-    """OOB data that can be sent from one device to another."""
-
-    address: Optional[Address] = None
-    role: Optional[LeRole] = None
-    shared_data: Optional[OobSharedData] = None
-    legacy_context: Optional[OobLegacyContext] = None
-
-    @classmethod
-    def from_ad(cls, ad: AdvertisingData) -> OobData:
-        instance = cls()
-        shared_data_c: Optional[bytes] = None
-        shared_data_r: Optional[bytes] = None
-        for ad_type, ad_data in ad.ad_structures:
-            if ad_type == AdvertisingData.LE_BLUETOOTH_DEVICE_ADDRESS:
-                instance.address = Address(ad_data)
-            elif ad_type == AdvertisingData.LE_ROLE:
-                instance.role = LeRole(ad_data[0])
-            elif ad_type == AdvertisingData.LE_SECURE_CONNECTIONS_CONFIRMATION_VALUE:
-                shared_data_c = ad_data
-            elif ad_type == AdvertisingData.LE_SECURE_CONNECTIONS_RANDOM_VALUE:
-                shared_data_r = ad_data
-            elif ad_type == AdvertisingData.SECURITY_MANAGER_TK_VALUE:
-                instance.legacy_context = OobLegacyContext(tk=ad_data)
-        if shared_data_c and shared_data_r:
-            instance.shared_data = OobSharedData(c=shared_data_c, r=shared_data_r)
-
-        return instance
-
-    def to_ad(self) -> AdvertisingData:
-        ad_structures = []
-        if self.address is not None:
-            ad_structures.append(
-                (AdvertisingData.LE_BLUETOOTH_DEVICE_ADDRESS, bytes(self.address))
-            )
-        if self.role is not None:
-            ad_structures.append((AdvertisingData.LE_ROLE, bytes([self.role])))
-        if self.shared_data is not None:
-            ad_structures.extend(self.shared_data.to_ad().ad_structures)
-        if self.legacy_context is not None:
-            ad_structures.append(
-                (AdvertisingData.SECURITY_MANAGER_TK_VALUE, self.legacy_context.tk)
-            )
-
-        return AdvertisingData(ad_structures)
 
 
 # -----------------------------------------------------------------------------
@@ -224,39 +168,21 @@ class PairingDelegate:
 class PairingConfig:
     """Configuration for the Pairing protocol."""
 
-    class AddressType(enum.IntEnum):
-        PUBLIC = Address.PUBLIC_DEVICE_ADDRESS
-        RANDOM = Address.RANDOM_DEVICE_ADDRESS
-
-    @dataclass
-    class OobConfig:
-        """Config for OOB pairing."""
-
-        our_context: Optional[OobContext]
-        peer_data: Optional[OobSharedData]
-        legacy_context: Optional[OobLegacyContext]
-
     def __init__(
         self,
         sc: bool = True,
         mitm: bool = True,
         bonding: bool = True,
         delegate: Optional[PairingDelegate] = None,
-        identity_address_type: Optional[AddressType] = None,
-        oob: Optional[OobConfig] = None,
     ) -> None:
         self.sc = sc
         self.mitm = mitm
         self.bonding = bonding
         self.delegate = delegate or PairingDelegate()
-        self.identity_address_type = identity_address_type
-        self.oob = oob
 
     def __str__(self) -> str:
         return (
             f'PairingConfig(sc={self.sc}, '
             f'mitm={self.mitm}, bonding={self.bonding}, '
-            f'identity_address_type={self.identity_address_type}, '
-            f'delegate[{self.delegate.io_capability}]), '
-            f'oob[{self.oob}])'
+            f'delegate[{self.delegate.io_capability}])'
         )

bumble/pandora/config.py

@@ -12,8 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from __future__ import annotations
-from bumble.pairing import PairingConfig, PairingDelegate
+from bumble.pairing import PairingDelegate
 from dataclasses import dataclass
 from typing import Any, Dict
 
@@ -21,7 +20,6 @@ from typing import Any, Dict
 @dataclass
 class Config:
     io_capability: PairingDelegate.IoCapability = PairingDelegate.NO_OUTPUT_NO_INPUT
-    identity_address_type: PairingConfig.AddressType = PairingConfig.AddressType.RANDOM
     pairing_sc_enable: bool = True
     pairing_mitm_enable: bool = True
     pairing_bonding_enable: bool = True
@@ -37,12 +35,6 @@ class Config:
             'io_capability', 'no_output_no_input'
         ).upper()
         self.io_capability = getattr(PairingDelegate, io_capability_name)
-        identity_address_type_name: str = config.get(
-            'identity_address_type', 'random'
-        ).upper()
-        self.identity_address_type = getattr(
-            PairingConfig.AddressType, identity_address_type_name
-        )
         self.pairing_sc_enable = config.get('pairing_sc_enable', True)
         self.pairing_mitm_enable = config.get('pairing_mitm_enable', True)
         self.pairing_bonding_enable = config.get('pairing_bonding_enable', True)

bumble/pandora/device.py

@@ -14,7 +14,6 @@
 
 """Generic & dependency free Bumble (reference) device."""
 
-from __future__ import annotations
 from bumble import transport
 from bumble.core import (
     BT_GENERIC_AUDIO_SERVICE,
@@ -35,10 +34,6 @@ from bumble.sdp import (
 from typing import Any, Dict, List, Optional
 
 
-# Default rootcanal HCI TCP address
-ROOTCANAL_HCI_ADDRESS = "localhost:6402"
-
-
 class PandoraDevice:
     """
     Small wrapper around a Bumble device and it's HCI transport.
@@ -58,9 +53,7 @@ class PandoraDevice:
     def __init__(self, config: Dict[str, Any]) -> None:
         self.config = config
         self.device = _make_device(config)
-        self._hci_name = config.get(
-            'transport', f"tcp-client:{config.get('tcp', ROOTCANAL_HCI_ADDRESS)}"
-        )
+        self._hci_name = config.get('transport', '')
         self._hci = None
 
     @property

bumble/pandora/host.py

@@ -12,7 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from __future__ import annotations
 import asyncio
 import bumble.device
 import grpc
@@ -113,7 +112,7 @@ class HostService(HostServicer):
     async def FactoryReset(
         self, request: empty_pb2.Empty, context: grpc.ServicerContext
     ) -> empty_pb2.Empty:
-        self.log.debug('FactoryReset')
+        self.log.info('FactoryReset')
 
         # delete all bonds
         if self.device.keystore is not None:
@@ -127,7 +126,7 @@ class HostService(HostServicer):
     async def Reset(
         self, request: empty_pb2.Empty, context: grpc.ServicerContext
     ) -> empty_pb2.Empty:
-        self.log.debug('Reset')
+        self.log.info('Reset')
 
         # clear service.
         self.waited_connections.clear()
@@ -140,7 +139,7 @@ class HostService(HostServicer):
     async def ReadLocalAddress(
         self, request: empty_pb2.Empty, context: grpc.ServicerContext
     ) -> ReadLocalAddressResponse:
-        self.log.debug('ReadLocalAddress')
+        self.log.info('ReadLocalAddress')
         return ReadLocalAddressResponse(
             address=bytes(reversed(bytes(self.device.public_address)))
         )
@@ -153,7 +152,7 @@ class HostService(HostServicer):
         address = Address(
             bytes(reversed(request.address)), address_type=Address.PUBLIC_DEVICE_ADDRESS
         )
-        self.log.debug(f"Connect to {address}")
+        self.log.info(f"Connect to {address}")
 
         try:
             connection = await self.device.connect(
@@ -168,7 +167,7 @@ class HostService(HostServicer):
                 return ConnectResponse(connection_already_exists=empty_pb2.Empty())
             raise e
 
-        self.log.debug(f"Connect to {address} done (handle={connection.handle})")
+        self.log.info(f"Connect to {address} done (handle={connection.handle})")
 
         cookie = any_pb2.Any(value=connection.handle.to_bytes(4, 'big'))
         return ConnectResponse(connection=Connection(cookie=cookie))
@@ -187,7 +186,7 @@ class HostService(HostServicer):
         if address in (Address.NIL, Address.ANY):
             raise ValueError('Invalid address')
 
-        self.log.debug(f"WaitConnection from {address}...")
+        self.log.info(f"WaitConnection from {address}...")
 
         connection = self.device.find_connection_by_bd_addr(
             address, transport=BT_BR_EDR_TRANSPORT
@@ -202,7 +201,7 @@ class HostService(HostServicer):
         # save connection has waited and respond.
         self.waited_connections.add(id(connection))
 
-        self.log.debug(
+        self.log.info(
             f"WaitConnection from {address} done (handle={connection.handle})"
         )
 
@@ -217,7 +216,7 @@ class HostService(HostServicer):
         if address in (Address.NIL, Address.ANY):
             raise ValueError('Invalid address')
 
-        self.log.debug(f"ConnectLE to {address}...")
+        self.log.info(f"ConnectLE to {address}...")
 
         try:
             connection = await self.device.connect(
@@ -234,7 +233,7 @@ class HostService(HostServicer):
                 return ConnectLEResponse(connection_already_exists=empty_pb2.Empty())
             raise e
 
-        self.log.debug(f"ConnectLE to {address} done (handle={connection.handle})")
+        self.log.info(f"ConnectLE to {address} done (handle={connection.handle})")
 
         cookie = any_pb2.Any(value=connection.handle.to_bytes(4, 'big'))
         return ConnectLEResponse(connection=Connection(cookie=cookie))
@@ -244,12 +243,12 @@ class HostService(HostServicer):
         self, request: DisconnectRequest, context: grpc.ServicerContext
     ) -> empty_pb2.Empty:
         connection_handle = int.from_bytes(request.connection.cookie.value, 'big')
-        self.log.debug(f"Disconnect: {connection_handle}")
+        self.log.info(f"Disconnect: {connection_handle}")
 
-        self.log.debug("Disconnecting...")
+        self.log.info("Disconnecting...")
         if connection := self.device.lookup_connection(connection_handle):
             await connection.disconnect(HCI_REMOTE_USER_TERMINATED_CONNECTION_ERROR)
-        self.log.debug("Disconnected")
+        self.log.info("Disconnected")
 
         return empty_pb2.Empty()
 
@@ -258,7 +257,7 @@ class HostService(HostServicer):
         self, request: WaitDisconnectionRequest, context: grpc.ServicerContext
     ) -> empty_pb2.Empty:
         connection_handle = int.from_bytes(request.connection.cookie.value, 'big')
-        self.log.debug(f"WaitDisconnection: {connection_handle}")
+        self.log.info(f"WaitDisconnection: {connection_handle}")
 
         if connection := self.device.lookup_connection(connection_handle):
             disconnection_future: asyncio.Future[
@@ -271,7 +270,7 @@ class HostService(HostServicer):
             connection.on('disconnection', on_disconnection)
             try:
                 await disconnection_future
-                self.log.debug("Disconnected")
+                self.log.info("Disconnected")
             finally:
                 connection.remove_listener('disconnection', on_disconnection)  # type: ignore
 
@@ -379,7 +378,7 @@ class HostService(HostServicer):
         try:
             while True:
                 if not self.device.is_advertising:
-                    self.log.debug('Advertise')
+                    self.log.info('Advertise')
                     await self.device.start_advertising(
                         target=target,
                         advertising_type=advertising_type,
@@ -394,10 +393,10 @@ class HostService(HostServicer):
                     bumble.device.Connection
                 ] = asyncio.get_running_loop().create_future()
 
-                self.log.debug('Wait for LE connection...')
+                self.log.info('Wait for LE connection...')
                 connection = await pending_connection
 
-                self.log.debug(
+                self.log.info(
                     f"Advertise: Connected to {connection.peer_address} (handle={connection.handle})"
                 )
 
@@ -411,7 +410,7 @@ class HostService(HostServicer):
                 self.device.remove_listener('connection', on_connection)  # type: ignore
 
             try:
-                self.log.debug('Stop advertising')
+                self.log.info('Stop advertising')
                 await self.device.abort_on('flush', self.device.stop_advertising())
             except:
                 pass
@@ -424,7 +423,7 @@ class HostService(HostServicer):
         if request.phys:
             raise NotImplementedError("TODO: add support for `request.phys`")
 
-        self.log.debug('Scan')
+        self.log.info('Scan')
 
         scan_queue: asyncio.Queue[Advertisement] = asyncio.Queue()
         handler = self.device.on('advertisement', scan_queue.put_nowait)
@@ -471,7 +470,7 @@ class HostService(HostServicer):
         finally:
             self.device.remove_listener('advertisement', handler)  # type: ignore
             try:
-                self.log.debug('Stop scanning')
+                self.log.info('Stop scanning')
                 await self.device.abort_on('flush', self.device.stop_scanning())
             except:
                 pass
@@ -480,7 +479,7 @@ class HostService(HostServicer):
     async def Inquiry(
         self, request: empty_pb2.Empty, context: grpc.ServicerContext
     ) -> AsyncGenerator[InquiryResponse, None]:
-        self.log.debug('Inquiry')
+        self.log.info('Inquiry')
 
         inquiry_queue: asyncio.Queue[
             Optional[Tuple[Address, int, AdvertisingData, int]]
@@ -511,7 +510,7 @@ class HostService(HostServicer):
             self.device.remove_listener('inquiry_complete', complete_handler)  # type: ignore
             self.device.remove_listener('inquiry_result', result_handler)  # type: ignore
             try:
-                self.log.debug('Stop inquiry')
+                self.log.info('Stop inquiry')
                 await self.device.abort_on('flush', self.device.stop_discovery())
             except:
                 pass
@@ -520,7 +519,7 @@ class HostService(HostServicer):
     async def SetDiscoverabilityMode(
         self, request: SetDiscoverabilityModeRequest, context: grpc.ServicerContext
     ) -> empty_pb2.Empty:
-        self.log.debug("SetDiscoverabilityMode")
+        self.log.info("SetDiscoverabilityMode")
         await self.device.set_discoverable(request.mode != NOT_DISCOVERABLE)
         return empty_pb2.Empty()
 
@@ -528,7 +527,7 @@ class HostService(HostServicer):
     async def SetConnectabilityMode(
         self, request: SetConnectabilityModeRequest, context: grpc.ServicerContext
     ) -> empty_pb2.Empty:
-        self.log.debug("SetConnectabilityMode")
+        self.log.info("SetConnectabilityMode")
         await self.device.set_connectable(request.mode != NOT_CONNECTABLE)
         return empty_pb2.Empty()
 

bumble/pandora/security.py

@@ -12,9 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from __future__ import annotations
 import asyncio
-import contextlib
 import grpc
 import logging
 
@@ -29,8 +27,8 @@ from bumble.core import (
 )
 from bumble.device import Connection as BumbleConnection, Device
 from bumble.hci import HCI_Error
-from bumble.utils import EventWatcher
 from bumble.pairing import PairingConfig, PairingDelegate as BasePairingDelegate
+from contextlib import suppress
 from google.protobuf import any_pb2  # pytype: disable=pyi-error
 from google.protobuf import empty_pb2  # pytype: disable=pyi-error
 from google.protobuf import wrappers_pb2  # pytype: disable=pyi-error
@@ -101,7 +99,7 @@ class PairingDelegate(BasePairingDelegate):
         return ev
 
     async def confirm(self, auto: bool = False) -> bool:
-        self.log.debug(
+        self.log.info(
             f"Pairing event: `just_works` (io_capability: {self.io_capability})"
         )
 
@@ -116,7 +114,7 @@ class PairingDelegate(BasePairingDelegate):
         return answer.confirm
 
     async def compare_numbers(self, number: int, digits: int = 6) -> bool:
-        self.log.debug(
+        self.log.info(
             f"Pairing event: `numeric_comparison` (io_capability: {self.io_capability})"
         )
 
@@ -131,7 +129,7 @@ class PairingDelegate(BasePairingDelegate):
         return answer.confirm
 
     async def get_number(self) -> Optional[int]:
-        self.log.debug(
+        self.log.info(
             f"Pairing event: `passkey_entry_request` (io_capability: {self.io_capability})"
         )
 
@@ -148,7 +146,7 @@ class PairingDelegate(BasePairingDelegate):
         return answer.passkey
 
     async def get_string(self, max_length: int) -> Optional[str]:
-        self.log.debug(
+        self.log.info(
             f"Pairing event: `pin_code_request` (io_capability: {self.io_capability})"
         )
 
@@ -179,7 +177,7 @@ class PairingDelegate(BasePairingDelegate):
         ):
             return
 
-        self.log.debug(
+        self.log.info(
             f"Pairing event: `passkey_entry_notification` (io_capability: {self.io_capability})"
         )
 
@@ -234,11 +232,6 @@ class SecurityService(SecurityServicer):
                 sc=config.pairing_sc_enable,
                 mitm=config.pairing_mitm_enable,
                 bonding=config.pairing_bonding_enable,
-                identity_address_type=(
-                    PairingConfig.AddressType.PUBLIC
-                    if connection.self_address.is_public
-                    else config.identity_address_type
-                ),
                 delegate=PairingDelegate(
                     connection,
                     self,
@@ -254,7 +247,7 @@ class SecurityService(SecurityServicer):
     async def OnPairing(
         self, request: AsyncIterator[PairingEventAnswer], context: grpc.ServicerContext
     ) -> AsyncGenerator[PairingEvent, None]:
-        self.log.debug('OnPairing')
+        self.log.info('OnPairing')
 
         if self.event_queue is not None:
             raise RuntimeError('already streaming pairing events')
@@ -280,7 +273,7 @@ class SecurityService(SecurityServicer):
         self, request: SecureRequest, context: grpc.ServicerContext
     ) -> SecureResponse:
         connection_handle = int.from_bytes(request.connection.cookie.value, 'big')
-        self.log.debug(f"Secure: {connection_handle}")
+        self.log.info(f"Secure: {connection_handle}")
 
         connection = self.device.lookup_connection(connection_handle)
         assert connection
@@ -298,37 +291,25 @@ class SecurityService(SecurityServicer):
         # trigger pairing if needed
         if self.need_pairing(connection, level):
             try:
-                self.log.debug('Pair...')
+                self.log.info('Pair...')
 
-                security_result = asyncio.get_running_loop().create_future()
+                if (
+                    connection.transport == BT_LE_TRANSPORT
+                    and connection.role == BT_PERIPHERAL_ROLE
+                ):
+                    wait_for_security: asyncio.Future[
+                        bool
+                    ] = asyncio.get_running_loop().create_future()
+                    connection.on("pairing", lambda *_: wait_for_security.set_result(True))  # type: ignore
+                    connection.on("pairing_failure", wait_for_security.set_exception)
 
-                with contextlib.closing(EventWatcher()) as watcher:
+                    connection.request_pairing()
 
-                    @watcher.on(connection, 'pairing')
-                    def on_pairing(*_: Any) -> None:
-                        security_result.set_result('success')
+                    await wait_for_security
+                else:
+                    await connection.pair()
 
-                    @watcher.on(connection, 'pairing_failure')
-                    def on_pairing_failure(*_: Any) -> None:
-                        security_result.set_result('pairing_failure')
-
-                    @watcher.on(connection, 'disconnection')
-                    def on_disconnection(*_: Any) -> None:
-                        security_result.set_result('connection_died')
-
-                    if (
-                        connection.transport == BT_LE_TRANSPORT
-                        and connection.role == BT_PERIPHERAL_ROLE
-                    ):
-                        connection.request_pairing()
-                    else:
-                        await connection.pair()
-
-                    result = await security_result
-
-                self.log.debug(f'Pairing session complete, status={result}')
-                if result != 'success':
-                    return SecureResponse(**{result: empty_pb2.Empty()})
+                self.log.info('Paired')
             except asyncio.CancelledError:
                 self.log.warning("Connection died during encryption")
                 return SecureResponse(connection_died=empty_pb2.Empty())
@@ -339,9 +320,9 @@ class SecurityService(SecurityServicer):
         # trigger authentication if needed
         if self.need_authentication(connection, level):
             try:
-                self.log.debug('Authenticate...')
+                self.log.info('Authenticate...')
                 await connection.authenticate()
-                self.log.debug('Authenticated')
+                self.log.info('Authenticated')
             except asyncio.CancelledError:
                 self.log.warning("Connection died during authentication")
                 return SecureResponse(connection_died=empty_pb2.Empty())
@@ -352,9 +333,9 @@ class SecurityService(SecurityServicer):
         # trigger encryption if needed
         if self.need_encryption(connection, level):
             try:
-                self.log.debug('Encrypt...')
+                self.log.info('Encrypt...')
                 await connection.encrypt()
-                self.log.debug('Encrypted')
+                self.log.info('Encrypted')
             except asyncio.CancelledError:
                 self.log.warning("Connection died during encryption")
                 return SecureResponse(connection_died=empty_pb2.Empty())
@@ -372,7 +353,7 @@ class SecurityService(SecurityServicer):
         self, request: WaitSecurityRequest, context: grpc.ServicerContext
     ) -> WaitSecurityResponse:
         connection_handle = int.from_bytes(request.connection.cookie.value, 'big')
-        self.log.debug(f"WaitSecurity: {connection_handle}")
+        self.log.info(f"WaitSecurity: {connection_handle}")
 
         connection = self.device.lookup_connection(connection_handle)
         assert connection
@@ -387,7 +368,6 @@ class SecurityService(SecurityServicer):
             str
         ] = asyncio.get_running_loop().create_future()
         authenticate_task: Optional[asyncio.Future[None]] = None
-        pair_task: Optional[asyncio.Future[None]] = None
 
         async def authenticate() -> None:
             assert connection
@@ -410,7 +390,7 @@ class SecurityService(SecurityServicer):
 
         def set_failure(name: str) -> Callable[..., None]:
             def wrapper(*args: Any) -> None:
-                self.log.debug(f'Wait for security: error `{name}`: {args}')
+                self.log.info(f'Wait for security: error `{name}`: {args}')
                 wait_for_security.set_result(name)
 
             return wrapper
@@ -418,13 +398,13 @@ class SecurityService(SecurityServicer):
         def try_set_success(*_: Any) -> None:
             assert connection
             if self.reached_security_level(connection, level):
-                self.log.debug('Wait for security: done')
+                self.log.info('Wait for security: done')
                 wait_for_security.set_result('success')
 
         def on_encryption_change(*_: Any) -> None:
             assert connection
             if self.reached_security_level(connection, level):
-                self.log.debug('Wait for security: done')
+                self.log.info('Wait for security: done')
                 wait_for_security.set_result('success')
             elif (
                 connection.transport == BT_BR_EDR_TRANSPORT
@@ -434,10 +414,6 @@ class SecurityService(SecurityServicer):
                 if authenticate_task is None:
                     authenticate_task = asyncio.create_task(authenticate())
 
-        def pair(*_: Any) -> None:
-            if self.need_pairing(connection, level):
-                pair_task = asyncio.create_task(connection.pair())
-
         listeners: Dict[str, Callable[..., None]] = {
             'disconnection': set_failure('connection_died'),
             'pairing_failure': set_failure('pairing_failure'),
@@ -446,41 +422,32 @@ class SecurityService(SecurityServicer):
             'pairing': try_set_success,
             'connection_authentication': try_set_success,
             'connection_encryption_change': on_encryption_change,
-            'classic_pairing': try_set_success,
-            'classic_pairing_failure': set_failure('pairing_failure'),
-            'security_request': pair,
         }
 
-        with contextlib.closing(EventWatcher()) as watcher:
-            # register event handlers
-            for event, listener in listeners.items():
-                watcher.on(connection, event, listener)
+        # register event handlers
+        for event, listener in listeners.items():
+            connection.on(event, listener)
 
-            # security level already reached
-            if self.reached_security_level(connection, level):
-                return WaitSecurityResponse(success=empty_pb2.Empty())
+        # security level already reached
+        if self.reached_security_level(connection, level):
+            return WaitSecurityResponse(success=empty_pb2.Empty())
 
-            self.log.debug('Wait for security...')
-            kwargs = {}
-            kwargs[await wait_for_security] = empty_pb2.Empty()
+        self.log.info('Wait for security...')
+        kwargs = {}
+        kwargs[await wait_for_security] = empty_pb2.Empty()
+
+        # remove event handlers
+        for event, listener in listeners.items():
+            connection.remove_listener(event, listener)  # type: ignore
 
         # wait for `authenticate` to finish if any
         if authenticate_task is not None:
-            self.log.debug('Wait for authentication...')
+            self.log.info('Wait for authentication...')
             try:
                 await authenticate_task  # type: ignore
             except:
                 pass
-            self.log.debug('Authenticated')
-
-        # wait for `pair` to finish if any
-        if pair_task is not None:
-            self.log.debug('Wait for authentication...')
-            try:
-                await pair_task  # type: ignore
-            except:
-                pass
-            self.log.debug('paired')
+            self.log.info('Authenticated')
 
         return WaitSecurityResponse(**kwargs)
 
@@ -536,7 +503,7 @@ class SecurityStorageService(SecurityStorageServicer):
         self, request: IsBondedRequest, context: grpc.ServicerContext
     ) -> wrappers_pb2.BoolValue:
         address = utils.address_from_request(request, request.WhichOneof("address"))
-        self.log.debug(f"IsBonded: {address}")
+        self.log.info(f"IsBonded: {address}")
 
         if self.device.keystore is not None:
             is_bonded = await self.device.keystore.get(str(address)) is not None
@@ -550,10 +517,10 @@ class SecurityStorageService(SecurityStorageServicer):
         self, request: DeleteBondRequest, context: grpc.ServicerContext
     ) -> empty_pb2.Empty:
         address = utils.address_from_request(request, request.WhichOneof("address"))
-        self.log.debug(f"DeleteBond: {address}")
+        self.log.info(f"DeleteBond: {address}")
 
         if self.device.keystore is not None:
-            with contextlib.suppress(KeyError):
+            with suppress(KeyError):
                 await self.device.keystore.delete(str(address))
 
         return empty_pb2.Empty()

bumble/pandora/utils.py

@@ -12,7 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from __future__ import annotations
 import contextlib
 import functools
 import grpc

bumble/profiles/asha_service.py

@@ -18,9 +18,7 @@
 # -----------------------------------------------------------------------------
 import struct
 import logging
-from typing import List, Optional
-
-from bumble import l2cap
+from typing import List
 from ..core import AdvertisingData
 from ..device import Device, Connection
 from ..gatt import (
@@ -67,7 +65,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:
@@ -151,10 +149,7 @@ class AshaService(TemplateService):
             channel.sink = on_data
 
         # let the server find a free PSM
-        self.psm = device.create_l2cap_server(
-            spec=l2cap.LeCreditBasedChannelSpec(psm=self.psm, max_credits=8),
-            handler=on_coc,
-        ).psm
+        self.psm = self.device.register_l2cap_channel_server(self.psm, on_coc, 8)
         self.le_psm_out_characteristic = Characteristic(
             GATT_ASHA_LE_PSM_OUT_CHARACTERISTIC,
             Characteristic.Properties.READ,

bumble/profiles/cap.py

@@ -1,52 +0,0 @@
-# Copyright 2021-2023 Google LLC
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-# -----------------------------------------------------------------------------
-# Imports
-# -----------------------------------------------------------------------------
-from __future__ import annotations
-
-from bumble import gatt
-from bumble import gatt_client
-from bumble.profiles import csip
-
-
-# -----------------------------------------------------------------------------
-# Server
-# -----------------------------------------------------------------------------
-class CommonAudioServiceService(gatt.TemplateService):
-    UUID = gatt.GATT_COMMON_AUDIO_SERVICE
-
-    def __init__(
-        self,
-        coordinated_set_identification_service: csip.CoordinatedSetIdentificationService,
-    ) -> None:
-        self.coordinated_set_identification_service = (
-            coordinated_set_identification_service
-        )
-        super().__init__(
-            characteristics=[],
-            included_services=[coordinated_set_identification_service],
-        )
-
-
-# -----------------------------------------------------------------------------
-# Client
-# -----------------------------------------------------------------------------
-class CommonAudioServiceServiceProxy(gatt_client.ProfileServiceProxy):
-    SERVICE_CLASS = CommonAudioServiceService
-
-    def __init__(self, service_proxy: gatt_client.ServiceProxy) -> None:
-        self.service_proxy = service_proxy

bumble/profiles/csip.py

@@ -1,257 +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 Optional, Tuple
-
-from bumble import core
-from bumble import crypto
-from bumble import device
-from bumble import gatt
-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.'''
-
-    ENCRYPTED = 0x00
-    PLAINTEXT = 0x01
-
-
-class MemberLock(enum.IntEnum):
-    '''Coordinated Set Identification Service - 5.3 Set Member Lock.'''
-
-    UNLOCKED = 0x01
-    LOCKED = 0x02
-
-
-# -----------------------------------------------------------------------------
-# Crypto Toolbox
-# -----------------------------------------------------------------------------
-def s1(m: bytes) -> bytes:
-    '''
-    Coordinated Set Identification Service - 4.3 s1 SALT generation function.
-    '''
-    return crypto.aes_cmac(m[::-1], bytes(16))[::-1]
-
-
-def k1(n: bytes, salt: bytes, p: bytes) -> bytes:
-    '''
-    Coordinated Set Identification Service - 4.4 k1 derivation function.
-    '''
-    t = crypto.aes_cmac(n[::-1], salt[::-1])
-    return crypto.aes_cmac(p[::-1], t)[::-1]
-
-
-def sef(k: bytes, r: bytes) -> bytes:
-    '''
-    Coordinated Set Identification Service - 4.5 SIRK encryption function sef.
-
-    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)
-
-
-def sih(k: bytes, r: bytes) -> bytes:
-    '''
-    Coordinated Set Identification Service - 4.7 Resolvable Set Identifier hash function sih.
-    '''
-    return crypto.e(k, r + bytes(13))[:3]
-
-
-def generate_rsi(sirk: bytes) -> bytes:
-    '''
-    Coordinated Set Identification Service - 4.8 Resolvable Set Identifier generation operation.
-    '''
-    prand = crypto.generate_prand()
-    return sih(sirk, prand) + prand
-
-
-# -----------------------------------------------------------------------------
-# Server
-# -----------------------------------------------------------------------------
-class CoordinatedSetIdentificationService(gatt.TemplateService):
-    UUID = gatt.GATT_COORDINATED_SET_IDENTIFICATION_SERVICE
-
-    set_identity_resolving_key: bytes
-    set_identity_resolving_key_characteristic: gatt.Characteristic
-    coordinated_set_size_characteristic: Optional[gatt.Characteristic] = None
-    set_member_lock_characteristic: Optional[gatt.Characteristic] = None
-    set_member_rank_characteristic: Optional[gatt.Characteristic] = None
-
-    def __init__(
-        self,
-        set_identity_resolving_key: bytes,
-        set_identity_resolving_key_type: SirkType,
-        coordinated_set_size: Optional[int] = None,
-        set_member_lock: Optional[MemberLock] = None,
-        set_member_rank: Optional[int] = None,
-    ) -> None:
-        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
-        self.set_identity_resolving_key_type = set_identity_resolving_key_type
-        self.set_identity_resolving_key_characteristic = gatt.Characteristic(
-            uuid=gatt.GATT_SET_IDENTITY_RESOLVING_KEY_CHARACTERISTIC,
-            properties=gatt.Characteristic.Properties.READ
-            | gatt.Characteristic.Properties.NOTIFY,
-            permissions=gatt.Characteristic.Permissions.READ_REQUIRES_ENCRYPTION,
-            value=gatt.CharacteristicValue(read=self.on_sirk_read),
-        )
-        characteristics.append(self.set_identity_resolving_key_characteristic)
-
-        if coordinated_set_size is not None:
-            self.coordinated_set_size_characteristic = gatt.Characteristic(
-                uuid=gatt.GATT_COORDINATED_SET_SIZE_CHARACTERISTIC,
-                properties=gatt.Characteristic.Properties.READ
-                | gatt.Characteristic.Properties.NOTIFY,
-                permissions=gatt.Characteristic.Permissions.READ_REQUIRES_ENCRYPTION,
-                value=struct.pack('B', coordinated_set_size),
-            )
-            characteristics.append(self.coordinated_set_size_characteristic)
-
-        if set_member_lock is not None:
-            self.set_member_lock_characteristic = gatt.Characteristic(
-                uuid=gatt.GATT_SET_MEMBER_LOCK_CHARACTERISTIC,
-                properties=gatt.Characteristic.Properties.READ
-                | gatt.Characteristic.Properties.NOTIFY
-                | gatt.Characteristic.Properties.WRITE,
-                permissions=gatt.Characteristic.Permissions.READ_REQUIRES_ENCRYPTION
-                | gatt.Characteristic.Permissions.WRITEABLE,
-                value=struct.pack('B', set_member_lock),
-            )
-            characteristics.append(self.set_member_lock_characteristic)
-
-        if set_member_rank is not None:
-            self.set_member_rank_characteristic = gatt.Characteristic(
-                uuid=gatt.GATT_SET_MEMBER_RANK_CHARACTERISTIC,
-                properties=gatt.Characteristic.Properties.READ
-                | gatt.Characteristic.Properties.NOTIFY,
-                permissions=gatt.Characteristic.Permissions.READ_REQUIRES_ENCRYPTION,
-                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:
-        if self.set_identity_resolving_key_type == SirkType.PLAINTEXT:
-            sirk_bytes = 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
-
-    def get_advertising_data(self) -> bytes:
-        return bytes(
-            core.AdvertisingData(
-                [
-                    (
-                        core.AdvertisingData.RESOLVABLE_SET_IDENTIFIER,
-                        generate_rsi(self.set_identity_resolving_key),
-                    ),
-                ]
-            )
-        )
-
-
-# -----------------------------------------------------------------------------
-# Client
-# -----------------------------------------------------------------------------
-class CoordinatedSetIdentificationProxy(gatt_client.ProfileServiceProxy):
-    SERVICE_CLASS = CoordinatedSetIdentificationService
-
-    set_identity_resolving_key: gatt_client.CharacteristicProxy
-    coordinated_set_size: Optional[gatt_client.CharacteristicProxy] = None
-    set_member_lock: Optional[gatt_client.CharacteristicProxy] = None
-    set_member_rank: Optional[gatt_client.CharacteristicProxy] = None
-
-    def __init__(self, service_proxy: gatt_client.ServiceProxy) -> None:
-        self.service_proxy = service_proxy
-
-        self.set_identity_resolving_key = service_proxy.get_characteristics_by_uuid(
-            gatt.GATT_SET_IDENTITY_RESOLVING_KEY_CHARACTERISTIC
-        )[0]
-
-        if characteristics := service_proxy.get_characteristics_by_uuid(
-            gatt.GATT_COORDINATED_SET_SIZE_CHARACTERISTIC
-        ):
-            self.coordinated_set_size = characteristics[0]
-
-        if characteristics := service_proxy.get_characteristics_by_uuid(
-            gatt.GATT_SET_MEMBER_LOCK_CHARACTERISTIC
-        ):
-            self.set_member_lock = characteristics[0]
-
-        if characteristics := service_proxy.get_characteristics_by_uuid(
-            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/heart_rate_service.py

@@ -42,12 +42,12 @@ class HeartRateService(TemplateService):
     RESET_ENERGY_EXPENDED = 0x01
 
     class BodySensorLocation(IntEnum):
-        OTHER = 0
-        CHEST = 1
-        WRIST = 2
-        FINGER = 3
-        HAND = 4
-        EAR_LOBE = 5
+        OTHER = (0,)
+        CHEST = (1,)
+        WRIST = (2,)
+        FINGER = (3,)
+        HAND = (4,)
+        EAR_LOBE = (5,)
         FOOT = 6
 
     class HeartRateMeasurement:

bumble/rfcomm.py

@@ -15,37 +15,15 @@
 # -----------------------------------------------------------------------------
 # Imports
 # -----------------------------------------------------------------------------
-from __future__ import annotations
-
 import logging
 import asyncio
-import enum
-from typing import Callable, Dict, List, Optional, Tuple, Union, TYPE_CHECKING
 
 from pyee import EventEmitter
+from typing import Optional, Tuple, Callable, Dict, Union
 
 from . import core, l2cap
 from .colors import color
-from .core import (
-    UUID,
-    BT_RFCOMM_PROTOCOL_ID,
-    BT_BR_EDR_TRANSPORT,
-    BT_L2CAP_PROTOCOL_ID,
-    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
+from .core import BT_BR_EDR_TRANSPORT, InvalidStateError, ProtocolError
 
 # -----------------------------------------------------------------------------
 # Logging
@@ -118,8 +96,8 @@ CRC_TABLE = bytes([
     0XBA, 0X2B, 0X59, 0XC8, 0XBD, 0X2C, 0X5E, 0XCF
 ])
 
-RFCOMM_DEFAULT_WINDOW_SIZE    = 16
-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
@@ -127,50 +105,6 @@ RFCOMM_DYNAMIC_CHANNEL_NUMBER_END   = 30
 # fmt: on
 
 
-# -----------------------------------------------------------------------------
-def make_service_sdp_records(
-    service_record_handle: int, channel: int, uuid: Optional[UUID] = None
-) -> 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 = [
-        ServiceAttribute(
-            SDP_SERVICE_RECORD_HANDLE_ATTRIBUTE_ID,
-            DataElement.unsigned_integer_32(service_record_handle),
-        ),
-        ServiceAttribute(
-            SDP_BROWSE_GROUP_LIST_ATTRIBUTE_ID,
-            DataElement.sequence([DataElement.uuid(SDP_PUBLIC_BROWSE_ROOT)]),
-        ),
-        ServiceAttribute(
-            SDP_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID,
-            DataElement.sequence(
-                [
-                    DataElement.sequence([DataElement.uuid(BT_L2CAP_PROTOCOL_ID)]),
-                    DataElement.sequence(
-                        [
-                            DataElement.uuid(BT_RFCOMM_PROTOCOL_ID),
-                            DataElement.unsigned_integer_8(channel),
-                        ]
-                    ),
-                ]
-            ),
-        ),
-    ]
-
-    if uuid:
-        records.append(
-            ServiceAttribute(
-                SDP_SERVICE_CLASS_ID_LIST_ATTRIBUTE_ID,
-                DataElement.sequence([DataElement.uuid(uuid)]),
-            )
-        )
-
-    return records
-
-
 # -----------------------------------------------------------------------------
 def compute_fcs(buffer: bytes) -> int:
     result = 0xFF
@@ -215,9 +149,9 @@ class RFCOMM_Frame:
         return RFCOMM_FRAME_TYPE_NAMES[self.type]
 
     @staticmethod
-    def parse_mcc(data) -> Tuple[int, bool, bytes]:
+    def parse_mcc(data) -> Tuple[int, int, bytes]:
         mcc_type = data[0] >> 2
-        c_r = bool((data[0] >> 1) & 1)
+        c_r = (data[0] >> 1) & 1
         length = data[1]
         if data[1] & 1:
             length >>= 1
@@ -258,7 +192,7 @@ class RFCOMM_Frame:
         )
 
     @staticmethod
-    def from_bytes(data: bytes) -> RFCOMM_Frame:
+    def from_bytes(data: bytes):
         # Extract fields
         dlci = (data[0] >> 2) & 0x3F
         c_r = (data[0] >> 1) & 0x01
@@ -281,7 +215,7 @@ class RFCOMM_Frame:
 
         return frame
 
-    def __bytes__(self) -> bytes:
+    def __bytes__(self):
         return (
             bytes([self.address, self.control])
             + self.length
@@ -289,7 +223,7 @@ class RFCOMM_Frame:
             + bytes([self.fcs])
         )
 
-    def __str__(self) -> str:
+    def __str__(self):
         return (
             f'{color(self.type_name(), "yellow")}'
             f'(c/r={self.c_r},'
@@ -319,7 +253,7 @@ class RFCOMM_MCC_PN:
         max_frame_size: int,
         max_retransmissions: int,
         window_size: int,
-    ) -> None:
+    ):
         self.dlci = dlci
         self.cl = cl
         self.priority = priority
@@ -329,7 +263,7 @@ class RFCOMM_MCC_PN:
         self.window_size = window_size
 
     @staticmethod
-    def from_bytes(data: bytes) -> RFCOMM_MCC_PN:
+    def from_bytes(data: bytes):
         return RFCOMM_MCC_PN(
             dlci=data[0],
             cl=data[1],
@@ -340,7 +274,7 @@ class RFCOMM_MCC_PN:
             window_size=data[7],
         )
 
-    def __bytes__(self) -> bytes:
+    def __bytes__(self):
         return bytes(
             [
                 self.dlci & 0xFF,
@@ -354,7 +288,7 @@ class RFCOMM_MCC_PN:
             ]
         )
 
-    def __str__(self) -> str:
+    def __str__(self):
         return (
             f'PN(dlci={self.dlci},'
             f'cl={self.cl},'
@@ -375,9 +309,7 @@ class RFCOMM_MCC_MSC:
     ic: int
     dv: int
 
-    def __init__(
-        self, dlci: int, fc: int, rtc: int, rtr: int, ic: int, dv: int
-    ) -> None:
+    def __init__(self, dlci: int, fc: int, rtc: int, rtr: int, ic: int, dv: int):
         self.dlci = dlci
         self.fc = fc
         self.rtc = rtc
@@ -386,7 +318,7 @@ class RFCOMM_MCC_MSC:
         self.dv = dv
 
     @staticmethod
-    def from_bytes(data: bytes) -> RFCOMM_MCC_MSC:
+    def from_bytes(data: bytes):
         return RFCOMM_MCC_MSC(
             dlci=data[0] >> 2,
             fc=data[1] >> 1 & 1,
@@ -396,7 +328,7 @@ class RFCOMM_MCC_MSC:
             dv=data[1] >> 7 & 1,
         )
 
-    def __bytes__(self) -> bytes:
+    def __bytes__(self):
         return bytes(
             [
                 (self.dlci << 2) | 3,
@@ -409,7 +341,7 @@ class RFCOMM_MCC_MSC:
             ]
         )
 
-    def __str__(self) -> str:
+    def __str__(self):
         return (
             f'MSC(dlci={self.dlci},'
             f'fc={self.fc},'
@@ -422,40 +354,41 @@ class RFCOMM_MCC_MSC:
 
 # -----------------------------------------------------------------------------
 class DLC(EventEmitter):
-    class State(enum.IntEnum):
-        INIT = 0x00
-        CONNECTING = 0x01
-        CONNECTED = 0x02
-        DISCONNECTING = 0x03
-        DISCONNECTED = 0x04
-        RESET = 0x05
+    # States
+    INIT = 0x00
+    CONNECTING = 0x01
+    CONNECTED = 0x02
+    DISCONNECTING = 0x03
+    DISCONNECTED = 0x04
+    RESET = 0x05
+
+    STATE_NAMES = {
+        INIT: 'INIT',
+        CONNECTING: 'CONNECTING',
+        CONNECTED: 'CONNECTED',
+        DISCONNECTING: 'DISCONNECTING',
+        DISCONNECTED: 'DISCONNECTED',
+        RESET: 'RESET',
+    }
 
     connection_result: Optional[asyncio.Future]
     sink: Optional[Callable[[bytes], None]]
 
     def __init__(
-        self,
-        multiplexer: Multiplexer,
-        dlci: int,
-        max_frame_size: int,
-        window_size: int,
-    ) -> None:
+        self, multiplexer, dlci: int, max_frame_size: int, initial_tx_credits: int
+    ):
         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.state = DLC.INIT
         self.role = multiplexer.role
-        self.c_r = 1 if self.role == Multiplexer.Role.INITIATOR else 0
+        self.c_r = 1 if self.role == Multiplexer.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
@@ -463,8 +396,14 @@ class DLC(EventEmitter):
             max_frame_size, self.multiplexer.l2cap_channel.mtu - max_overhead
         )
 
-    def change_state(self, new_state: State) -> None:
-        logger.debug(f'{self} state change -> {color(new_state.name, "magenta")}')
+    @staticmethod
+    def state_name(state: int) -> str:
+        return DLC.STATE_NAMES[state]
+
+    def change_state(self, new_state: int) -> None:
+        logger.debug(
+            f'{self} state change -> {color(self.state_name(new_state), "magenta")}'
+        )
         self.state = new_state
 
     def send_frame(self, frame: RFCOMM_Frame) -> None:
@@ -474,8 +413,8 @@ class DLC(EventEmitter):
         handler = getattr(self, f'on_{frame.type_name()}_frame'.lower())
         handler(frame)
 
-    def on_sabm_frame(self, _frame: RFCOMM_Frame) -> None:
-        if self.state != DLC.State.CONNECTING:
+    def on_sabm_frame(self, _frame) -> None:
+        if self.state != DLC.CONNECTING:
             logger.warning(
                 color('!!! received SABM when not in CONNECTING state', 'red')
             )
@@ -491,11 +430,11 @@ class DLC(EventEmitter):
         logger.debug(f'>>> MCC MSC Command: {msc}')
         self.send_frame(RFCOMM_Frame.uih(c_r=self.c_r, dlci=0, information=mcc))
 
-        self.change_state(DLC.State.CONNECTED)
+        self.change_state(DLC.CONNECTED)
         self.emit('open')
 
-    def on_ua_frame(self, _frame: RFCOMM_Frame) -> None:
-        if self.state != DLC.State.CONNECTING:
+    def on_ua_frame(self, _frame) -> None:
+        if self.state != DLC.CONNECTING:
             logger.warning(
                 color('!!! received SABM when not in CONNECTING state', 'red')
             )
@@ -509,14 +448,14 @@ class DLC(EventEmitter):
         logger.debug(f'>>> MCC MSC Command: {msc}')
         self.send_frame(RFCOMM_Frame.uih(c_r=self.c_r, dlci=0, information=mcc))
 
-        self.change_state(DLC.State.CONNECTED)
+        self.change_state(DLC.CONNECTED)
         self.multiplexer.on_dlc_open_complete(self)
 
-    def on_dm_frame(self, frame: RFCOMM_Frame) -> None:
+    def on_dm_frame(self, frame) -> None:
         # TODO: handle all states
         pass
 
-    def on_disc_frame(self, _frame: RFCOMM_Frame) -> None:
+    def on_disc_frame(self, _frame) -> None:
         # TODO: handle all states
         self.send_frame(RFCOMM_Frame.ua(c_r=1 - self.c_r, dlci=self.dlci))
 
@@ -541,19 +480,19 @@ class DLC(EventEmitter):
         if len(data) and self.sink:
             self.sink(data)  # pylint: disable=not-callable
 
-            # Update the credits
-            if self.rx_credits > 0:
-                self.rx_credits -= 1
-            else:
-                logger.warning(color('!!! received frame with no rx credits', 'red'))
+        # Update the credits
+        if self.rx_credits > 0:
+            self.rx_credits -= 1
+        else:
+            logger.warning(color('!!! received frame with no rx credits', 'red'))
 
         # Check if there's anything to send (including credits)
         self.process_tx()
 
-    def on_ui_frame(self, frame: RFCOMM_Frame) -> None:
+    def on_ui_frame(self, frame) -> None:
         pass
 
-    def on_mcc_msc(self, c_r: bool, msc: RFCOMM_MCC_MSC) -> None:
+    def on_mcc_msc(self, c_r, msc) -> None:
         if c_r:
             # Command
             logger.debug(f'<<< MCC MSC Command: {msc}')
@@ -568,15 +507,15 @@ class DLC(EventEmitter):
             logger.debug(f'<<< MCC MSC Response: {msc}')
 
     def connect(self) -> None:
-        if self.state != DLC.State.INIT:
+        if self.state != DLC.INIT:
             raise InvalidStateError('invalid state')
 
-        self.change_state(DLC.State.CONNECTING)
+        self.change_state(DLC.CONNECTING)
         self.connection_result = asyncio.get_running_loop().create_future()
         self.send_frame(RFCOMM_Frame.sabm(c_r=self.c_r, dlci=self.dlci))
 
     def accept(self) -> None:
-        if self.state != DLC.State.INIT:
+        if self.state != DLC.INIT:
             raise InvalidStateError('invalid state')
 
         pn = RFCOMM_MCC_PN(
@@ -584,18 +523,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=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)
+        self.change_state(DLC.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
 
@@ -635,8 +574,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:
@@ -649,30 +586,40 @@ 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})'
+    def __str__(self):
+        return f'DLC(dlci={self.dlci},state={self.state_name(self.state)})'
 
 
 # -----------------------------------------------------------------------------
 class Multiplexer(EventEmitter):
-    class Role(enum.IntEnum):
-        INITIATOR = 0x00
-        RESPONDER = 0x01
+    # Roles
+    INITIATOR = 0x00
+    RESPONDER = 0x01
 
-    class State(enum.IntEnum):
-        INIT = 0x00
-        CONNECTING = 0x01
-        CONNECTED = 0x02
-        OPENING = 0x03
-        DISCONNECTING = 0x04
-        DISCONNECTED = 0x05
-        RESET = 0x06
+    # States
+    INIT = 0x00
+    CONNECTING = 0x01
+    CONNECTED = 0x02
+    OPENING = 0x03
+    DISCONNECTING = 0x04
+    DISCONNECTED = 0x05
+    RESET = 0x06
+
+    STATE_NAMES = {
+        INIT: 'INIT',
+        CONNECTING: 'CONNECTING',
+        CONNECTED: 'CONNECTED',
+        OPENING: 'OPENING',
+        DISCONNECTING: 'DISCONNECTING',
+        DISCONNECTED: 'DISCONNECTED',
+        RESET: 'RESET',
+    }
 
     connection_result: Optional[asyncio.Future]
     disconnection_result: Optional[asyncio.Future]
@@ -680,11 +627,11 @@ class Multiplexer(EventEmitter):
     acceptor: Optional[Callable[[int], bool]]
     dlcs: Dict[int, DLC]
 
-    def __init__(self, l2cap_channel: l2cap.ClassicChannel, role: Role) -> None:
+    def __init__(self, l2cap_channel: l2cap.Channel, role: int) -> None:
         super().__init__()
         self.role = role
         self.l2cap_channel = l2cap_channel
-        self.state = Multiplexer.State.INIT
+        self.state = Multiplexer.INIT
         self.dlcs = {}  # DLCs, by DLCI
         self.connection_result = None
         self.disconnection_result = None
@@ -694,8 +641,14 @@ class Multiplexer(EventEmitter):
         # Become a sink for the L2CAP channel
         l2cap_channel.sink = self.on_pdu
 
-    def change_state(self, new_state: State) -> None:
-        logger.debug(f'{self} state change -> {color(new_state.name, "cyan")}')
+    @staticmethod
+    def state_name(state: int):
+        return Multiplexer.STATE_NAMES[state]
+
+    def change_state(self, new_state: int) -> None:
+        logger.debug(
+            f'{self} state change -> {color(self.state_name(new_state), "cyan")}'
+        )
         self.state = new_state
 
     def send_frame(self, frame: RFCOMM_Frame) -> None:
@@ -726,28 +679,28 @@ class Multiplexer(EventEmitter):
         handler = getattr(self, f'on_{frame.type_name()}_frame'.lower())
         handler(frame)
 
-    def on_sabm_frame(self, _frame: RFCOMM_Frame) -> None:
-        if self.state != Multiplexer.State.INIT:
+    def on_sabm_frame(self, _frame) -> None:
+        if self.state != Multiplexer.INIT:
             logger.debug('not in INIT state, ignoring SABM')
             return
-        self.change_state(Multiplexer.State.CONNECTED)
+        self.change_state(Multiplexer.CONNECTED)
         self.send_frame(RFCOMM_Frame.ua(c_r=1, dlci=0))
 
-    def on_ua_frame(self, _frame: RFCOMM_Frame) -> None:
-        if self.state == Multiplexer.State.CONNECTING:
-            self.change_state(Multiplexer.State.CONNECTED)
+    def on_ua_frame(self, _frame) -> None:
+        if self.state == Multiplexer.CONNECTING:
+            self.change_state(Multiplexer.CONNECTED)
             if self.connection_result:
                 self.connection_result.set_result(0)
                 self.connection_result = None
-        elif self.state == Multiplexer.State.DISCONNECTING:
-            self.change_state(Multiplexer.State.DISCONNECTED)
+        elif self.state == Multiplexer.DISCONNECTING:
+            self.change_state(Multiplexer.DISCONNECTED)
             if self.disconnection_result:
                 self.disconnection_result.set_result(None)
                 self.disconnection_result = None
 
-    def on_dm_frame(self, _frame: RFCOMM_Frame) -> None:
-        if self.state == Multiplexer.State.OPENING:
-            self.change_state(Multiplexer.State.CONNECTED)
+    def on_dm_frame(self, _frame) -> None:
+        if self.state == Multiplexer.OPENING:
+            self.change_state(Multiplexer.CONNECTED)
             if self.open_result:
                 self.open_result.set_exception(
                     core.ConnectionError(
@@ -760,12 +713,10 @@ class Multiplexer(EventEmitter):
         else:
             logger.warning(f'unexpected state for DM: {self}')
 
-    def on_disc_frame(self, _frame: RFCOMM_Frame) -> None:
-        self.change_state(Multiplexer.State.DISCONNECTED)
+    def on_disc_frame(self, _frame) -> None:
+        self.change_state(Multiplexer.DISCONNECTED)
         self.send_frame(
-            RFCOMM_Frame.ua(
-                c_r=0 if self.role == Multiplexer.Role.INITIATOR else 1, dlci=0
-            )
+            RFCOMM_Frame.ua(c_r=0 if self.role == Multiplexer.INITIATOR else 1, dlci=0)
         )
 
     def on_uih_frame(self, frame: RFCOMM_Frame) -> None:
@@ -778,11 +729,11 @@ class Multiplexer(EventEmitter):
             mcs = RFCOMM_MCC_MSC.from_bytes(value)
             self.on_mcc_msc(c_r, mcs)
 
-    def on_ui_frame(self, frame: RFCOMM_Frame) -> None:
+    def on_ui_frame(self, frame) -> None:
         pass
 
-    def on_mcc_pn(self, c_r: bool, pn: RFCOMM_MCC_PN) -> None:
-        if c_r:
+    def on_mcc_pn(self, c_r, pn) -> None:
+        if c_r == 1:
             # Command
             logger.debug(f'<<< PN Command: {pn}')
 
@@ -813,14 +764,14 @@ class Multiplexer(EventEmitter):
         else:
             # Response
             logger.debug(f'>>> PN Response: {pn}')
-            if self.state == Multiplexer.State.OPENING:
+            if self.state == Multiplexer.OPENING:
                 dlc = DLC(self, pn.dlci, pn.max_frame_size, pn.window_size)
                 self.dlcs[pn.dlci] = dlc
                 dlc.connect()
             else:
                 logger.warning('ignoring PN response')
 
-    def on_mcc_msc(self, c_r: bool, msc: RFCOMM_MCC_MSC) -> None:
+    def on_mcc_msc(self, c_r, msc) -> None:
         dlc = self.dlcs.get(msc.dlci)
         if dlc is None:
             logger.warning(f'no dlc for DLCI {msc.dlci}')
@@ -828,35 +779,30 @@ class Multiplexer(EventEmitter):
         dlc.on_mcc_msc(c_r, msc)
 
     async def connect(self) -> None:
-        if self.state != Multiplexer.State.INIT:
+        if self.state != Multiplexer.INIT:
             raise InvalidStateError('invalid state')
 
-        self.change_state(Multiplexer.State.CONNECTING)
+        self.change_state(Multiplexer.CONNECTING)
         self.connection_result = asyncio.get_running_loop().create_future()
         self.send_frame(RFCOMM_Frame.sabm(c_r=1, dlci=0))
         return await self.connection_result
 
     async def disconnect(self) -> None:
-        if self.state != Multiplexer.State.CONNECTED:
+        if self.state != Multiplexer.CONNECTED:
             return
 
         self.disconnection_result = asyncio.get_running_loop().create_future()
-        self.change_state(Multiplexer.State.DISCONNECTING)
+        self.change_state(Multiplexer.DISCONNECTING)
         self.send_frame(
             RFCOMM_Frame.disc(
-                c_r=1 if self.role == Multiplexer.Role.INITIATOR else 0, dlci=0
+                c_r=1 if self.role == Multiplexer.INITIATOR else 0, dlci=0
             )
         )
         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:
-        if self.state != Multiplexer.State.CONNECTED:
-            if self.state == Multiplexer.State.OPENING:
+    async def open_dlc(self, channel: int) -> DLC:
+        if self.state != Multiplexer.CONNECTED:
+            if self.state == Multiplexer.OPENING:
                 raise InvalidStateError('open already in progress')
 
             raise InvalidStateError('not connected')
@@ -866,17 +812,17 @@ 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=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)
+        self.change_state(Multiplexer.OPENING)
         self.send_frame(
             RFCOMM_Frame.uih(
-                c_r=1 if self.role == Multiplexer.Role.INITIATOR else 0,
+                c_r=1 if self.role == Multiplexer.INITIATOR else 0,
                 dlci=0,
                 information=mcc,
             )
@@ -885,22 +831,23 @@ class Multiplexer(EventEmitter):
         self.open_result = None
         return result
 
-    def on_dlc_open_complete(self, dlc: DLC) -> None:
+    def on_dlc_open_complete(self, dlc: DLC):
         logger.debug(f'DLC [{dlc.dlci}] open complete')
-        self.change_state(Multiplexer.State.CONNECTED)
+        self.change_state(Multiplexer.CONNECTED)
         if self.open_result:
             self.open_result.set_result(dlc)
 
-    def __str__(self) -> str:
-        return f'Multiplexer(state={self.state.name})'
+    def __str__(self):
+        return f'Multiplexer(state={self.state_name(self.state)})'
 
 
 # -----------------------------------------------------------------------------
 class Client:
     multiplexer: Optional[Multiplexer]
-    l2cap_channel: Optional[l2cap.ClassicChannel]
+    l2cap_channel: Optional[l2cap.Channel]
 
-    def __init__(self, connection: Connection) -> None:
+    def __init__(self, device, connection) -> None:
+        self.device = device
         self.connection = connection
         self.l2cap_channel = None
         self.multiplexer = None
@@ -908,16 +855,16 @@ class Client:
     async def start(self) -> Multiplexer:
         # Create a new L2CAP connection
         try:
-            self.l2cap_channel = await self.connection.create_l2cap_channel(
-                spec=l2cap.ClassicChannelSpec(RFCOMM_PSM)
+            self.l2cap_channel = await self.device.l2cap_channel_manager.connect(
+                self.connection, RFCOMM_PSM
             )
         except ProtocolError as error:
             logger.warning(f'L2CAP connection failed: {error}')
             raise
 
         assert self.l2cap_channel is not None
-        # Create a multiplexer to manage DLCs with the server
-        self.multiplexer = Multiplexer(self.l2cap_channel, Multiplexer.Role.INITIATOR)
+        # Create a mutliplexer to manage DLCs with the server
+        self.multiplexer = Multiplexer(self.l2cap_channel, Multiplexer.INITIATOR)
 
         # Connect the multiplexer
         await self.multiplexer.connect()
@@ -939,16 +886,14 @@ class Client:
 class Server(EventEmitter):
     acceptors: Dict[int, Callable[[DLC], None]]
 
-    def __init__(self, device: Device) -> None:
+    def __init__(self, device) -> None:
         super().__init__()
         self.device = device
         self.multiplexer = None
         self.acceptors = {}
 
         # Register ourselves with the L2CAP channel manager
-        device.create_l2cap_server(
-            spec=l2cap.ClassicChannelSpec(psm=RFCOMM_PSM), handler=self.on_connection
-        )
+        device.register_l2cap_server(RFCOMM_PSM, self.on_connection)
 
     def listen(self, acceptor: Callable[[DLC], None], channel: int = 0) -> int:
         if channel:
@@ -972,15 +917,15 @@ class Server(EventEmitter):
         self.acceptors[channel] = acceptor
         return channel
 
-    def on_connection(self, l2cap_channel: l2cap.ClassicChannel) -> None:
+    def on_connection(self, l2cap_channel: l2cap.Channel) -> None:
         logger.debug(f'+++ new L2CAP connection: {l2cap_channel}')
         l2cap_channel.on('open', lambda: self.on_l2cap_channel_open(l2cap_channel))
 
-    def on_l2cap_channel_open(self, l2cap_channel: l2cap.ClassicChannel) -> None:
+    def on_l2cap_channel_open(self, l2cap_channel: l2cap.Channel) -> None:
         logger.debug(f'$$$ L2CAP channel open: {l2cap_channel}')
 
         # Create a new multiplexer for the channel
-        multiplexer = Multiplexer(l2cap_channel, Multiplexer.Role.RESPONDER)
+        multiplexer = Multiplexer(l2cap_channel, Multiplexer.RESPONDER)
         multiplexer.acceptor = self.accept_dlc
         multiplexer.on('dlc', self.on_dlc)
 

bumble/sdp.py

@@ -18,16 +18,13 @@
 from __future__ import annotations
 import logging
 import struct
-from typing import Dict, List, Type, Optional, Tuple, Union, NewType, TYPE_CHECKING
+from typing import Dict, List, Type
 
-from . import core, l2cap
+from . import core
 from .colors import color
 from .core import InvalidStateError
 from .hci import HCI_Object, name_or_number, key_with_value
 
-if TYPE_CHECKING:
-    from .device import Device, Connection
-
 # -----------------------------------------------------------------------------
 # Logging
 # -----------------------------------------------------------------------------
@@ -97,10 +94,6 @@ SDP_CLIENT_EXECUTABLE_URL_ATTRIBUTE_ID               = 0X000B
 SDP_ICON_URL_ATTRIBUTE_ID                            = 0X000C
 SDP_ADDITIONAL_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID = 0X000D
 
-# Attribute Identifier (cf. Assigned Numbers for Service Discovery)
-# used by AVRCP, HFP and A2DP
-SDP_SUPPORTED_FEATURES_ATTRIBUTE_ID = 0x0311
-
 SDP_ATTRIBUTE_ID_NAMES = {
     SDP_SERVICE_RECORD_HANDLE_ATTRIBUTE_ID:               'SDP_SERVICE_RECORD_HANDLE_ATTRIBUTE_ID',
     SDP_SERVICE_CLASS_ID_LIST_ATTRIBUTE_ID:               'SDP_SERVICE_CLASS_ID_LIST_ATTRIBUTE_ID',
@@ -167,7 +160,7 @@ class DataElement:
         UUID: lambda x: DataElement(
             DataElement.UUID, core.UUID.from_bytes(bytes(reversed(x)))
         ),
-        TEXT_STRING: lambda x: DataElement(DataElement.TEXT_STRING, x),
+        TEXT_STRING: lambda x: DataElement(DataElement.TEXT_STRING, x.decode('utf8')),
         BOOLEAN: lambda x: DataElement(DataElement.BOOLEAN, x[0] == 1),
         SEQUENCE: lambda x: DataElement(
             DataElement.SEQUENCE, DataElement.list_from_bytes(x)
@@ -229,7 +222,7 @@ class DataElement:
         return DataElement(DataElement.UUID, value)
 
     @staticmethod
-    def text_string(value: bytes) -> DataElement:
+    def text_string(value: str) -> DataElement:
         return DataElement(DataElement.TEXT_STRING, value)
 
     @staticmethod
@@ -376,7 +369,7 @@ class DataElement:
                 raise ValueError('invalid value_size')
         elif self.type == DataElement.UUID:
             data = bytes(reversed(bytes(self.value)))
-        elif self.type == DataElement.URL:
+        elif self.type in (DataElement.TEXT_STRING, DataElement.URL):
             data = self.value.encode('utf8')
         elif self.type == DataElement.BOOLEAN:
             data = bytes([1 if self.value else 0])
@@ -469,7 +462,7 @@ class ServiceAttribute:
         self.value = value
 
     @staticmethod
-    def list_from_data_elements(elements: List[DataElement]) -> List[ServiceAttribute]:
+    def list_from_data_elements(elements):
         attribute_list = []
         for i in range(0, len(elements) // 2):
             attribute_id, attribute_value = elements[2 * i : 2 * (i + 1)]
@@ -481,9 +474,7 @@ class ServiceAttribute:
         return attribute_list
 
     @staticmethod
-    def find_attribute_in_list(
-        attribute_list: List[ServiceAttribute], attribute_id: int
-    ) -> Optional[DataElement]:
+    def find_attribute_in_list(attribute_list, attribute_id):
         return next(
             (
                 attribute.value
@@ -498,7 +489,7 @@ class ServiceAttribute:
         return name_or_number(SDP_ATTRIBUTE_ID_NAMES, id_code)
 
     @staticmethod
-    def is_uuid_in_value(uuid: core.UUID, value: DataElement) -> bool:
+    def is_uuid_in_value(uuid, value):
         # Find if a uuid matches a value, either directly or recursing into sequences
         if value.type == DataElement.UUID:
             return value.value == uuid
@@ -552,9 +543,7 @@ class SDP_PDU:
         return self
 
     @staticmethod
-    def parse_service_record_handle_list_preceded_by_count(
-        data: bytes, offset: int
-    ) -> Tuple[int, List[int]]:
+    def parse_service_record_handle_list_preceded_by_count(data, offset):
         count = struct.unpack_from('>H', data, offset - 2)[0]
         handle_list = [
             struct.unpack_from('>I', data, offset + x * 4)[0] for x in range(count)
@@ -652,10 +641,6 @@ class SDP_ServiceSearchRequest(SDP_PDU):
     See Bluetooth spec @ Vol 3, Part B - 4.5.1 SDP_ServiceSearchRequest PDU
     '''
 
-    service_search_pattern: DataElement
-    maximum_service_record_count: int
-    continuation_state: bytes
-
 
 # -----------------------------------------------------------------------------
 @SDP_PDU.subclass(
@@ -674,11 +659,6 @@ class SDP_ServiceSearchResponse(SDP_PDU):
     See Bluetooth spec @ Vol 3, Part B - 4.5.2 SDP_ServiceSearchResponse PDU
     '''
 
-    service_record_handle_list: List[int]
-    total_service_record_count: int
-    current_service_record_count: int
-    continuation_state: bytes
-
 
 # -----------------------------------------------------------------------------
 @SDP_PDU.subclass(
@@ -694,11 +674,6 @@ class SDP_ServiceAttributeRequest(SDP_PDU):
     See Bluetooth spec @ Vol 3, Part B - 4.6.1 SDP_ServiceAttributeRequest PDU
     '''
 
-    service_record_handle: int
-    maximum_attribute_byte_count: int
-    attribute_id_list: DataElement
-    continuation_state: bytes
-
 
 # -----------------------------------------------------------------------------
 @SDP_PDU.subclass(
@@ -713,10 +688,6 @@ class SDP_ServiceAttributeResponse(SDP_PDU):
     See Bluetooth spec @ Vol 3, Part B - 4.6.2 SDP_ServiceAttributeResponse PDU
     '''
 
-    attribute_list_byte_count: int
-    attribute_list: bytes
-    continuation_state: bytes
-
 
 # -----------------------------------------------------------------------------
 @SDP_PDU.subclass(
@@ -732,11 +703,6 @@ class SDP_ServiceSearchAttributeRequest(SDP_PDU):
     See Bluetooth spec @ Vol 3, Part B - 4.7.1 SDP_ServiceSearchAttributeRequest PDU
     '''
 
-    service_search_pattern: DataElement
-    maximum_attribute_byte_count: int
-    attribute_id_list: DataElement
-    continuation_state: bytes
-
 
 # -----------------------------------------------------------------------------
 @SDP_PDU.subclass(
@@ -751,35 +717,26 @@ class SDP_ServiceSearchAttributeResponse(SDP_PDU):
     See Bluetooth spec @ Vol 3, Part B - 4.7.2 SDP_ServiceSearchAttributeResponse PDU
     '''
 
-    attribute_list_byte_count: int
-    attribute_list: bytes
-    continuation_state: bytes
-
 
 # -----------------------------------------------------------------------------
 class Client:
-    channel: Optional[l2cap.ClassicChannel]
-
-    def __init__(self, connection: Connection) -> None:
-        self.connection = connection
+    def __init__(self, device):
+        self.device = device
         self.pending_request = None
         self.channel = None
 
-    async def connect(self) -> None:
-        self.channel = await self.connection.create_l2cap_channel(
-            spec=l2cap.ClassicChannelSpec(SDP_PSM)
-        )
+    async def connect(self, connection):
+        result = await self.device.l2cap_channel_manager.connect(connection, SDP_PSM)
+        self.channel = result
 
-    async def disconnect(self) -> None:
+    async def disconnect(self):
         if self.channel:
             await self.channel.disconnect()
             self.channel = None
 
-    async def search_services(self, uuids: List[core.UUID]) -> List[int]:
+    async def search_services(self, uuids):
         if self.pending_request is not None:
             raise InvalidStateError('request already pending')
-        if self.channel is None:
-            raise InvalidStateError('L2CAP not connected')
 
         service_search_pattern = DataElement.sequence(
             [DataElement.uuid(uuid) for uuid in uuids]
@@ -809,13 +766,9 @@ class Client:
 
         return service_record_handle_list
 
-    async def search_attributes(
-        self, uuids: List[core.UUID], attribute_ids: List[Union[int, Tuple[int, int]]]
-    ) -> List[List[ServiceAttribute]]:
+    async def search_attributes(self, uuids, attribute_ids):
         if self.pending_request is not None:
             raise InvalidStateError('request already pending')
-        if self.channel is None:
-            raise InvalidStateError('L2CAP not connected')
 
         service_search_pattern = DataElement.sequence(
             [DataElement.uuid(uuid) for uuid in uuids]
@@ -866,15 +819,9 @@ class Client:
             if sequence.type == DataElement.SEQUENCE
         ]
 
-    async def get_attributes(
-        self,
-        service_record_handle: int,
-        attribute_ids: List[Union[int, Tuple[int, int]]],
-    ) -> List[ServiceAttribute]:
+    async def get_attributes(self, service_record_handle, attribute_ids):
         if self.pending_request is not None:
             raise InvalidStateError('request already pending')
-        if self.channel is None:
-            raise InvalidStateError('L2CAP not connected')
 
         attribute_id_list = DataElement.sequence(
             [
@@ -922,27 +869,21 @@ class Client:
 # -----------------------------------------------------------------------------
 class Server:
     CONTINUATION_STATE = bytes([0x01, 0x43])
-    channel: Optional[l2cap.ClassicChannel]
-    Service = NewType('Service', List[ServiceAttribute])
-    service_records: Dict[int, Service]
-    current_response: Union[None, bytes, Tuple[int, List[int]]]
 
-    def __init__(self, device: Device) -> None:
+    def __init__(self, device):
         self.device = device
         self.service_records = {}  # Service records maps, by record handle
         self.channel = None
         self.current_response = None
 
-    def register(self, l2cap_channel_manager: l2cap.ChannelManager) -> None:
-        l2cap_channel_manager.create_classic_server(
-            spec=l2cap.ClassicChannelSpec(psm=SDP_PSM), handler=self.on_connection
-        )
+    def register(self, l2cap_channel_manager):
+        l2cap_channel_manager.register_server(SDP_PSM, self.on_connection)
 
     def send_response(self, response):
         logger.debug(f'{color(">>> Sending SDP Response", "blue")}: {response}')
         self.channel.send_pdu(response)
 
-    def match_services(self, search_pattern: DataElement) -> Dict[int, Service]:
+    def match_services(self, search_pattern):
         # Find the services for which the attributes in the pattern is a subset of the
         # service's attribute values (NOTE: the value search recurses into sequences)
         matching_services = {}
@@ -1012,9 +953,7 @@ class Server:
         return (payload, continuation_state)
 
     @staticmethod
-    def get_service_attributes(
-        service: Service, attribute_ids: List[DataElement]
-    ) -> DataElement:
+    def get_service_attributes(service, attribute_ids):
         attributes = []
         for attribute_id in attribute_ids:
             if attribute_id.value_size == 4:
@@ -1039,10 +978,10 @@ class Server:
 
         return attribute_list
 
-    def on_sdp_service_search_request(self, request: SDP_ServiceSearchRequest) -> None:
+    def on_sdp_service_search_request(self, request):
         # Check if this is a continuation
         if len(request.continuation_state) > 1:
-            if self.current_response is None:
+            if not self.current_response:
                 self.send_response(
                     SDP_ErrorResponse(
                         transaction_id=request.transaction_id,
@@ -1071,7 +1010,6 @@ class Server:
             )
 
         # Respond, keeping any unsent handles for later
-        assert isinstance(self.current_response, tuple)
         service_record_handles = self.current_response[1][
             : request.maximum_service_record_count
         ]
@@ -1095,12 +1033,10 @@ class Server:
             )
         )
 
-    def on_sdp_service_attribute_request(
-        self, request: SDP_ServiceAttributeRequest
-    ) -> None:
+    def on_sdp_service_attribute_request(self, request):
         # Check if this is a continuation
         if len(request.continuation_state) > 1:
-            if self.current_response is None:
+            if not self.current_response:
                 self.send_response(
                     SDP_ErrorResponse(
                         transaction_id=request.transaction_id,
@@ -1133,24 +1069,22 @@ class Server:
             self.current_response = bytes(attribute_list)
 
         # Respond, keeping any pending chunks for later
-        attribute_list_response, continuation_state = self.get_next_response_payload(
+        attribute_list, continuation_state = self.get_next_response_payload(
             request.maximum_attribute_byte_count
         )
         self.send_response(
             SDP_ServiceAttributeResponse(
                 transaction_id=request.transaction_id,
-                attribute_list_byte_count=len(attribute_list_response),
+                attribute_list_byte_count=len(attribute_list),
                 attribute_list=attribute_list,
                 continuation_state=continuation_state,
             )
         )
 
-    def on_sdp_service_search_attribute_request(
-        self, request: SDP_ServiceSearchAttributeRequest
-    ) -> None:
+    def on_sdp_service_search_attribute_request(self, request):
         # Check if this is a continuation
         if len(request.continuation_state) > 1:
-            if self.current_response is None:
+            if not self.current_response:
                 self.send_response(
                     SDP_ErrorResponse(
                         transaction_id=request.transaction_id,
@@ -1180,13 +1114,13 @@ class Server:
             self.current_response = bytes(attribute_lists)
 
         # Respond, keeping any pending chunks for later
-        attribute_lists_response, continuation_state = self.get_next_response_payload(
+        attribute_lists, continuation_state = self.get_next_response_payload(
             request.maximum_attribute_byte_count
         )
         self.send_response(
             SDP_ServiceSearchAttributeResponse(
                 transaction_id=request.transaction_id,
-                attribute_lists_byte_count=len(attribute_lists_response),
+                attribute_lists_byte_count=len(attribute_lists),
                 attribute_lists=attribute_lists,
                 continuation_state=continuation_state,
             )

bumble/smp.py

@@ -27,7 +27,6 @@ import logging
 import asyncio
 import enum
 import secrets
-from dataclasses import dataclass
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -38,7 +37,6 @@ from typing import (
     Optional,
     Tuple,
     Type,
-    cast,
 )
 
 from pyee import EventEmitter
@@ -54,7 +52,6 @@ from .core import (
     BT_BR_EDR_TRANSPORT,
     BT_CENTRAL_ROLE,
     BT_LE_TRANSPORT,
-    AdvertisingData,
     ProtocolError,
     name_or_number,
 )
@@ -187,8 +184,8 @@ SMP_KEYPRESS_AUTHREQ = 0b00010000
 SMP_CT2_AUTHREQ      = 0b00100000
 
 # Crypto salt
-SMP_CTKD_H7_LEBR_SALT = bytes.fromhex('000000000000000000000000746D7031')
-SMP_CTKD_H7_BRLE_SALT = bytes.fromhex('000000000000000000000000746D7032')
+SMP_CTKD_H7_LEBR_SALT = bytes.fromhex('00000000000000000000000000000000746D7031')
+SMP_CTKD_H7_BRLE_SALT = bytes.fromhex('00000000000000000000000000000000746D7032')
 
 # fmt: on
 # pylint: enable=line-too-long
@@ -565,54 +562,6 @@ class PairingMethod(enum.IntEnum):
     CTKD_OVER_CLASSIC = 4
 
 
-# -----------------------------------------------------------------------------
-class OobContext:
-    """Cryptographic context for LE SC OOB pairing."""
-
-    ecc_key: crypto.EccKey
-    r: bytes
-
-    def __init__(
-        self, ecc_key: Optional[crypto.EccKey] = None, r: Optional[bytes] = None
-    ) -> None:
-        self.ecc_key = crypto.EccKey.generate() if ecc_key is None else ecc_key
-        self.r = crypto.r() if r is None else r
-
-    def share(self) -> OobSharedData:
-        pkx = self.ecc_key.x[::-1]
-        return OobSharedData(c=crypto.f4(pkx, pkx, self.r, bytes(1)), r=self.r)
-
-
-# -----------------------------------------------------------------------------
-class OobLegacyContext:
-    """Cryptographic context for LE Legacy OOB pairing."""
-
-    tk: bytes
-
-    def __init__(self, tk: Optional[bytes] = None) -> None:
-        self.tk = crypto.r() if tk is None else tk
-
-
-# -----------------------------------------------------------------------------
-@dataclass
-class OobSharedData:
-    """Shareable data for LE SC OOB pairing."""
-
-    c: bytes
-    r: bytes
-
-    def to_ad(self) -> AdvertisingData:
-        return AdvertisingData(
-            [
-                (AdvertisingData.LE_SECURE_CONNECTIONS_CONFIRMATION_VALUE, self.c),
-                (AdvertisingData.LE_SECURE_CONNECTIONS_RANDOM_VALUE, self.r),
-            ]
-        )
-
-    def __str__(self) -> str:
-        return f'OOB(C={self.c.hex()}, R={self.r.hex()})'
-
-
 # -----------------------------------------------------------------------------
 class Session:
     # I/O Capability to pairing method decision matrix
@@ -677,13 +626,6 @@ class Session:
         },
     }
 
-    ea: bytes
-    eb: bytes
-    ltk: bytes
-    preq: bytes
-    pres: bytes
-    tk: bytes
-
     def __init__(
         self,
         manager: Manager,
@@ -693,10 +635,17 @@ class Session:
     ) -> None:
         self.manager = manager
         self.connection = connection
+        self.preq: Optional[bytes] = None
+        self.pres: Optional[bytes] = None
+        self.ea = None
+        self.eb = None
+        self.tk = bytes(16)
+        self.r = bytes(16)
         self.stk = None
+        self.ltk = None
         self.ltk_ediv = 0
         self.ltk_rand = bytes(8)
-        self.link_key: Optional[bytes] = None
+        self.link_key = None
         self.initiator_key_distribution: int = 0
         self.responder_key_distribution: int = 0
         self.peer_random_value: Optional[bytes] = None
@@ -709,7 +658,7 @@ class Session:
         self.peer_bd_addr: Optional[Address] = None
         self.peer_signature_key = None
         self.peer_expected_distributions: List[Type[SMP_Command]] = []
-        self.dh_key = b''
+        self.dh_key = None
         self.confirm_value = None
         self.passkey: Optional[int] = None
         self.passkey_ready = asyncio.Event()
@@ -762,8 +711,8 @@ class Session:
         self.io_capability = pairing_config.delegate.io_capability
         self.peer_io_capability = SMP_NO_INPUT_NO_OUTPUT_IO_CAPABILITY
 
-        # OOB
-        self.oob_data_flag = 0 if pairing_config.oob is None else 1
+        # OOB (not supported yet)
+        self.oob = False
 
         # Set up addresses
         self_address = connection.self_address
@@ -779,35 +728,9 @@ class Session:
             self.ia = bytes(peer_address)
             self.iat = 1 if peer_address.is_random else 0
 
-        # Select the ECC key, TK and r initial value
-        if pairing_config.oob:
-            self.peer_oob_data = pairing_config.oob.peer_data
-            if pairing_config.sc:
-                if pairing_config.oob.our_context is None:
-                    raise ValueError(
-                        "oob pairing config requires a context when sc is True"
-                    )
-                self.r = pairing_config.oob.our_context.r
-                self.ecc_key = pairing_config.oob.our_context.ecc_key
-                if pairing_config.oob.legacy_context is not None:
-                    self.tk = pairing_config.oob.legacy_context.tk
-            else:
-                if pairing_config.oob.legacy_context is None:
-                    raise ValueError(
-                        "oob pairing config requires a legacy context when sc is False"
-                    )
-                self.r = bytes(16)
-                self.ecc_key = manager.ecc_key
-                self.tk = pairing_config.oob.legacy_context.tk
-        else:
-            self.peer_oob_data = None
-            self.r = bytes(16)
-            self.ecc_key = manager.ecc_key
-            self.tk = bytes(16)
-
     @property
     def pkx(self) -> Tuple[bytes, bytes]:
-        return (self.ecc_key.x[::-1], self.peer_public_key_x)
+        return (bytes(reversed(self.manager.ecc_key.x)), self.peer_public_key_x)
 
     @property
     def pka(self) -> bytes:
@@ -844,10 +767,7 @@ class Session:
         return None
 
     def decide_pairing_method(
-        self,
-        auth_req: int,
-        initiator_io_capability: int,
-        responder_io_capability: int,
+        self, auth_req: int, initiator_io_capability: int, responder_io_capability: int
     ) -> None:
         if self.connection.transport == BT_BR_EDR_TRANSPORT:
             self.pairing_method = PairingMethod.CTKD_OVER_CLASSIC
@@ -988,7 +908,7 @@ class Session:
 
         command = SMP_Pairing_Request_Command(
             io_capability=self.io_capability,
-            oob_data_flag=self.oob_data_flag,
+            oob_data_flag=0,
             auth_req=self.auth_req,
             maximum_encryption_key_size=16,
             initiator_key_distribution=self.initiator_key_distribution,
@@ -1000,7 +920,7 @@ class Session:
     def send_pairing_response_command(self) -> None:
         response = SMP_Pairing_Response_Command(
             io_capability=self.io_capability,
-            oob_data_flag=self.oob_data_flag,
+            oob_data_flag=0,
             auth_req=self.auth_req,
             maximum_encryption_key_size=16,
             initiator_key_distribution=self.initiator_key_distribution,
@@ -1061,8 +981,8 @@ class Session:
     def send_public_key_command(self) -> None:
         self.send_command(
             SMP_Pairing_Public_Key_Command(
-                public_key_x=self.ecc_key.x[::-1],
-                public_key_y=self.ecc_key.y[::-1],
+                public_key_x=bytes(reversed(self.manager.ecc_key.x)),
+                public_key_y=bytes(reversed(self.manager.ecc_key.y)),
             )
         )
 
@@ -1073,24 +993,11 @@ class Session:
             )
         )
 
-    def send_identity_address_command(self) -> None:
-        identity_address = {
-            None: self.connection.self_address,
-            Address.PUBLIC_DEVICE_ADDRESS: self.manager.device.public_address,
-            Address.RANDOM_DEVICE_ADDRESS: self.manager.device.random_address,
-        }[self.pairing_config.identity_address_type]
-        self.send_command(
-            SMP_Identity_Address_Information_Command(
-                addr_type=identity_address.address_type,
-                bd_addr=identity_address,
-            )
-        )
-
     def start_encryption(self, key: bytes) -> None:
         # We can now encrypt the connection with the short term key, so that we can
         # distribute the long term and/or other keys over an encrypted connection
         self.manager.device.host.send_command_sync(
-            HCI_LE_Enable_Encryption_Command(
+            HCI_LE_Enable_Encryption_Command(  # type: ignore[call-arg]
                 connection_handle=self.connection.handle,
                 random_number=bytes(8),
                 encrypted_diversifier=0,
@@ -1098,52 +1005,15 @@ class Session:
             )
         )
 
-    @classmethod
-    def derive_ltk(cls, link_key: bytes, ct2: bool) -> bytes:
-        '''Derives Long Term Key from Link Key.
-
-        Args:
-            link_key: BR/EDR Link Key bytes in little-endian.
-            ct2: whether ct2 is supported on both devices.
-        Returns:
-            LE Long Tern Key bytes in little-endian.
-        '''
+    async def derive_ltk(self) -> None:
+        link_key = await self.manager.device.get_link_key(self.connection.peer_address)
+        assert link_key is not None
         ilk = (
             crypto.h7(salt=SMP_CTKD_H7_BRLE_SALT, w=link_key)
-            if ct2
+            if self.ct2
             else crypto.h6(link_key, b'tmp2')
         )
-        return crypto.h6(ilk, b'brle')
-
-    @classmethod
-    def derive_link_key(cls, ltk: bytes, ct2: bool) -> bytes:
-        '''Derives Link Key from Long Term Key.
-
-        Args:
-            ltk: LE Long Term Key bytes in little-endian.
-            ct2: whether ct2 is supported on both devices.
-        Returns:
-            BR/EDR Link Key bytes in little-endian.
-        '''
-        ilk = (
-            crypto.h7(salt=SMP_CTKD_H7_LEBR_SALT, w=ltk)
-            if ct2
-            else crypto.h6(ltk, b'tmp1')
-        )
-        return crypto.h6(ilk, b'lebr')
-
-    async def get_link_key_and_derive_ltk(self) -> None:
-        '''Retrieves BR/EDR Link Key from storage and derive it to LE LTK.'''
-        link_key = await self.manager.device.get_link_key(self.connection.peer_address)
-        if link_key is None:
-            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!'
-            )
-            self.send_pairing_failed(
-                SMP_CROSS_TRANSPORT_KEY_DERIVATION_NOT_ALLOWED_ERROR
-            )
-        else:
-            self.ltk = self.derive_ltk(link_key, self.ct2)
+        self.ltk = crypto.h6(ilk, b'brle')
 
     def distribute_keys(self) -> None:
         # Distribute the keys as required
@@ -1154,7 +1024,7 @@ class Session:
                 and self.initiator_key_distribution & SMP_ENC_KEY_DISTRIBUTION_FLAG
             ):
                 self.ctkd_task = self.connection.abort_on(
-                    'disconnection', self.get_link_key_and_derive_ltk()
+                    'disconnection', self.derive_ltk()
                 )
             elif not self.sc:
                 # Distribute the LTK, EDIV and RAND
@@ -1175,7 +1045,12 @@ class Session:
                         identity_resolving_key=self.manager.device.irk
                     )
                 )
-                self.send_identity_address_command()
+                self.send_command(
+                    SMP_Identity_Address_Information_Command(
+                        addr_type=self.connection.self_address.address_type,
+                        bd_addr=self.connection.self_address,
+                    )
+                )
 
             # Distribute CSRK
             csrk = bytes(16)  # FIXME: testing
@@ -1184,7 +1059,12 @@ class Session:
 
             # CTKD, calculate BR/EDR link key
             if self.initiator_key_distribution & SMP_LINK_KEY_DISTRIBUTION_FLAG:
-                self.link_key = self.derive_link_key(self.ltk, self.ct2)
+                ilk = (
+                    crypto.h7(salt=SMP_CTKD_H7_LEBR_SALT, w=self.ltk)
+                    if self.ct2
+                    else crypto.h6(self.ltk, b'tmp1')
+                )
+                self.link_key = crypto.h6(ilk, b'lebr')
 
         else:
             # CTKD: Derive LTK from LinkKey
@@ -1193,7 +1073,7 @@ class Session:
                 and self.responder_key_distribution & SMP_ENC_KEY_DISTRIBUTION_FLAG
             ):
                 self.ctkd_task = self.connection.abort_on(
-                    'disconnection', self.get_link_key_and_derive_ltk()
+                    'disconnection', self.derive_ltk()
                 )
             # Distribute the LTK, EDIV and RAND
             elif not self.sc:
@@ -1214,7 +1094,12 @@ class Session:
                         identity_resolving_key=self.manager.device.irk
                     )
                 )
-                self.send_identity_address_command()
+                self.send_command(
+                    SMP_Identity_Address_Information_Command(
+                        addr_type=self.connection.self_address.address_type,
+                        bd_addr=self.connection.self_address,
+                    )
+                )
 
             # Distribute CSRK
             csrk = bytes(16)  # FIXME: testing
@@ -1223,7 +1108,12 @@ class Session:
 
             # CTKD, calculate BR/EDR link key
             if self.responder_key_distribution & SMP_LINK_KEY_DISTRIBUTION_FLAG:
-                self.link_key = self.derive_link_key(self.ltk, self.ct2)
+                ilk = (
+                    crypto.h7(salt=SMP_CTKD_H7_LEBR_SALT, w=self.ltk)
+                    if self.ct2
+                    else crypto.h6(self.ltk, b'tmp1')
+                )
+                self.link_key = crypto.h6(ilk, b'lebr')
 
     def compute_peer_expected_distributions(self, key_distribution_flags: int) -> None:
         # Set our expectations for what to wait for in the key distribution phase
@@ -1378,7 +1268,7 @@ class Session:
             keys.link_key = PairingKeys.Key(
                 value=self.link_key, authenticated=authenticated
             )
-        await self.manager.on_pairing(self, peer_address, keys)
+        self.manager.on_pairing(self, peer_address, keys)
 
     def on_pairing_failure(self, reason: int) -> None:
         logger.warning(f'pairing failure ({error_name(reason)})')
@@ -1401,7 +1291,7 @@ class Session:
             try:
                 handler(command)
             except Exception as error:
-                logger.exception(f'{color("!!! Exception in handler:", "red")} {error}')
+                logger.warning(f'{color("!!! Exception in handler:", "red")} {error}')
                 response = SMP_Pairing_Failed_Command(
                     reason=SMP_UNSPECIFIED_REASON_ERROR
                 )
@@ -1438,28 +1328,15 @@ class Session:
         self.sc = self.sc and (command.auth_req & SMP_SC_AUTHREQ != 0)
         self.ct2 = self.ct2 and (command.auth_req & SMP_CT2_AUTHREQ != 0)
 
-        # Infer the pairing method
-        if (self.sc and (self.oob_data_flag != 0 or command.oob_data_flag != 0)) or (
-            not self.sc and (self.oob_data_flag != 0 and command.oob_data_flag != 0)
-        ):
-            # Use OOB
-            self.pairing_method = PairingMethod.OOB
-            if not self.sc and self.tk is None:
-                # For legacy OOB, TK is required.
-                logger.warning("legacy OOB without TK")
-                self.send_pairing_failed(SMP_OOB_NOT_AVAILABLE_ERROR)
-                return
-            if command.oob_data_flag == 0:
-                # The peer doesn't have OOB data, use r=0
-                self.r = bytes(16)
-        else:
-            # Decide which pairing method to use from the IO capability
-            self.decide_pairing_method(
-                command.auth_req,
-                command.io_capability,
-                self.io_capability,
-            )
+        # Check for OOB
+        if command.oob_data_flag != 0:
+            self.send_pairing_failed(SMP_OOB_NOT_AVAILABLE_ERROR)
+            return
 
+        # Decide which pairing method to use
+        self.decide_pairing_method(
+            command.auth_req, command.io_capability, self.io_capability
+        )
         logger.debug(f'pairing method: {self.pairing_method.name}')
 
         # Key distribution
@@ -1508,26 +1385,15 @@ class Session:
         self.bonding = self.bonding and (command.auth_req & SMP_BONDING_AUTHREQ != 0)
         self.sc = self.sc and (command.auth_req & SMP_SC_AUTHREQ != 0)
 
-        # Infer the pairing method
-        if (self.sc and (self.oob_data_flag != 0 or command.oob_data_flag != 0)) or (
-            not self.sc and (self.oob_data_flag != 0 and command.oob_data_flag != 0)
-        ):
-            # Use OOB
-            self.pairing_method = PairingMethod.OOB
-            if not self.sc and self.tk is None:
-                # For legacy OOB, TK is required.
-                logger.warning("legacy OOB without TK")
-                self.send_pairing_failed(SMP_OOB_NOT_AVAILABLE_ERROR)
-                return
-            if command.oob_data_flag == 0:
-                # The peer doesn't have OOB data, use r=0
-                self.r = bytes(16)
-        else:
-            # Decide which pairing method to use from the IO capability
-            self.decide_pairing_method(
-                command.auth_req, self.io_capability, command.io_capability
-            )
+        # Check for OOB
+        if self.sc and command.oob_data_flag:
+            self.send_pairing_failed(SMP_OOB_NOT_AVAILABLE_ERROR)
+            return
 
+        # Decide which pairing method to use
+        self.decide_pairing_method(
+            command.auth_req, self.io_capability, command.io_capability
+        )
         logger.debug(f'pairing method: {self.pairing_method.name}')
 
         # Key distribution
@@ -1678,13 +1544,12 @@ class Session:
                 if self.passkey_step < 20:
                     self.send_pairing_confirm_command()
                     return
-            elif self.pairing_method != PairingMethod.OOB:
+            else:
                 return
         else:
             if self.pairing_method in (
                 PairingMethod.JUST_WORKS,
                 PairingMethod.NUMERIC_COMPARISON,
-                PairingMethod.OOB,
             ):
                 self.send_pairing_random_command()
             elif self.pairing_method == PairingMethod.PASSKEY:
@@ -1721,7 +1586,6 @@ class Session:
         if self.pairing_method in (
             PairingMethod.JUST_WORKS,
             PairingMethod.NUMERIC_COMPARISON,
-            PairingMethod.OOB,
         ):
             ra = bytes(16)
             rb = ra
@@ -1730,6 +1594,7 @@ class Session:
             ra = self.passkey.to_bytes(16, byteorder='little')
             rb = ra
         else:
+            # OOB not implemented yet
             return
 
         assert self.preq and self.pres
@@ -1781,33 +1646,18 @@ class Session:
         self.peer_public_key_y = command.public_key_y
 
         # Compute the DH key
-        self.dh_key = self.ecc_key.dh(
-            command.public_key_x[::-1],
-            command.public_key_y[::-1],
-        )[::-1]
+        self.dh_key = bytes(
+            reversed(
+                self.manager.ecc_key.dh(
+                    bytes(reversed(command.public_key_x)),
+                    bytes(reversed(command.public_key_y)),
+                )
+            )
+        )
         logger.debug(f'DH key: {self.dh_key.hex()}')
 
-        if self.pairing_method == PairingMethod.OOB:
-            # Check against shared OOB data
-            if self.peer_oob_data:
-                confirm_verifier = crypto.f4(
-                    self.peer_public_key_x,
-                    self.peer_public_key_x,
-                    self.peer_oob_data.r,
-                    bytes(1),
-                )
-                if not self.check_expected_value(
-                    self.peer_oob_data.c,
-                    confirm_verifier,
-                    SMP_CONFIRM_VALUE_FAILED_ERROR,
-                ):
-                    return
-
         if self.is_initiator:
-            if self.pairing_method == PairingMethod.OOB:
-                self.send_pairing_random_command()
-            else:
-                self.send_pairing_confirm_command()
+            self.send_pairing_confirm_command()
         else:
             if self.pairing_method == PairingMethod.PASSKEY:
                 self.display_or_input_passkey()
@@ -1818,7 +1668,6 @@ class Session:
             if self.pairing_method in (
                 PairingMethod.JUST_WORKS,
                 PairingMethod.NUMERIC_COMPARISON,
-                PairingMethod.OOB,
             ):
                 # We can now send the confirmation value
                 self.send_pairing_confirm_command()
@@ -1847,6 +1696,7 @@ class Session:
             else:
                 self.send_pairing_dhkey_check_command()
         else:
+            assert self.ltk
             self.start_encryption(self.ltk)
 
     def on_smp_pairing_failed_command(
@@ -1896,7 +1746,6 @@ class Manager(EventEmitter):
     sessions: Dict[int, Session]
     pairing_config_factory: Callable[[Connection], PairingConfig]
     session_proxy: Type[Session]
-    _ecc_key: Optional[crypto.EccKey]
 
     def __init__(
         self,
@@ -1918,26 +1767,7 @@ class Manager(EventEmitter):
         cid = SMP_BR_CID if connection.transport == BT_BR_EDR_TRANSPORT else SMP_CID
         connection.send_l2cap_pdu(cid, command.to_bytes())
 
-    def on_smp_security_request_command(
-        self, connection: Connection, request: SMP_Security_Request_Command
-    ) -> None:
-        connection.emit('security_request', request.auth_req)
-
     def on_smp_pdu(self, connection: Connection, pdu: bytes) -> None:
-        # Parse the L2CAP payload into an SMP Command object
-        command = SMP_Command.from_bytes(pdu)
-        logger.debug(
-            f'<<< Received SMP Command on connection [0x{connection.handle:04X}] '
-            f'{connection.peer_address}: {command}'
-        )
-
-        # Security request is more than just pairing, so let applications handle them
-        if command.code == SMP_SECURITY_REQUEST_COMMAND:
-            self.on_smp_security_request_command(
-                connection, cast(SMP_Security_Request_Command, command)
-            )
-            return
-
         # Look for a session with this connection, and create one if none exists
         if not (session := self.sessions.get(connection.handle)):
             if connection.role == BT_CENTRAL_ROLE:
@@ -1948,6 +1778,13 @@ class Manager(EventEmitter):
             )
             self.sessions[connection.handle] = session
 
+        # Parse the L2CAP payload into an SMP Command object
+        command = SMP_Command.from_bytes(pdu)
+        logger.debug(
+            f'<<< Received SMP Command on connection [0x{connection.handle:04X}] '
+            f'{connection.peer_address}: {command}'
+        )
+
         # Delegate the handling of the command to the session
         session.on_smp_command(command)
 
@@ -1986,14 +1823,20 @@ class Manager(EventEmitter):
     def on_session_start(self, session: Session) -> None:
         self.device.on_pairing_start(session.connection)
 
-    async def on_pairing(
+    def on_pairing(
         self, session: Session, identity_address: Optional[Address], keys: PairingKeys
     ) -> None:
         # Store the keys in the key store
         if self.device.keystore and identity_address is not None:
-            self.device.abort_on(
-                'flush', self.device.update_keys(str(identity_address), keys)
-            )
+
+            async def store_keys():
+                try:
+                    assert self.device.keystore
+                    await self.device.keystore.update(str(identity_address), keys)
+                except Exception as error:
+                    logger.warning(f'!!! error while storing keys: {error}')
+
+            self.device.abort_on('flush', store_keys())
 
         # Notify the device
         self.device.on_pairing(session.connection, identity_address, keys, session.sc)

bumble/transport/__init__.py

@@ -18,9 +18,9 @@
 from contextlib import asynccontextmanager
 import logging
 import os
-from typing import Optional
 
 from .common import Transport, AsyncPipeSink, SnoopingTransport
+from ..controller import Controller
 from ..snoop import create_snooper
 
 # -----------------------------------------------------------------------------
@@ -53,16 +53,8 @@ def _wrap_transport(transport: Transport) -> Transport:
 async def open_transport(name: str) -> Transport:
     """
     Open a transport by name.
-    The name must be <type>:<metadata><parameters>
-    Where <parameters> depend on the type (and may be empty for some types), and
-    <metadata> is either omitted, or a ,-separated list of <key>=<value> pairs,
-    enclosed in [].
-    If there are not metadata or parameter, the : after the <type> may be omitted.
-    Examples:
-      * usb:0
-      * usb:[driver=rtk]0
-      * android-netsim
-
+    The name must be <type>:<parameters>
+    Where <parameters> depend on the type (and may be empty for some types).
     The supported types are:
       * serial
       * udp
@@ -77,109 +69,86 @@ async def open_transport(name: str) -> Transport:
       * usb
       * pyusb
       * android-emulator
-      * android-netsim
     """
 
-    scheme, *tail = name.split(':', 1)
-    spec = tail[0] if tail else 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:
-        transport.source.metadata = {  # type: ignore[attr-defined]
-            **metadata,
-            **getattr(transport.source, 'metadata', {}),
-        }
-        # pylint: disable=line-too-long
-        logger.debug(f'HCI metadata: {transport.source.metadata}')  # type: ignore[attr-defined]
-
-    return _wrap_transport(transport)
+    return _wrap_transport(await _open_transport(name))
 
 
 # -----------------------------------------------------------------------------
-async def _open_transport(scheme: str, spec: Optional[str]) -> Transport:
+async def _open_transport(name: str) -> Transport:
     # pylint: disable=import-outside-toplevel
     # pylint: disable=too-many-return-statements
 
+    scheme, *spec = name.split(':', 1)
     if scheme == 'serial' and spec:
         from .serial import open_serial_transport
 
-        return await open_serial_transport(spec)
+        return await open_serial_transport(spec[0])
 
     if scheme == 'udp' and spec:
         from .udp import open_udp_transport
 
-        return await open_udp_transport(spec)
+        return await open_udp_transport(spec[0])
 
     if scheme == 'tcp-client' and spec:
         from .tcp_client import open_tcp_client_transport
 
-        return await open_tcp_client_transport(spec)
+        return await open_tcp_client_transport(spec[0])
 
     if scheme == 'tcp-server' and spec:
         from .tcp_server import open_tcp_server_transport
 
-        return await open_tcp_server_transport(spec)
+        return await open_tcp_server_transport(spec[0])
 
     if scheme == 'ws-client' and spec:
         from .ws_client import open_ws_client_transport
 
-        return await open_ws_client_transport(spec)
+        return await open_ws_client_transport(spec[0])
 
     if scheme == 'ws-server' and spec:
         from .ws_server import open_ws_server_transport
 
-        return await open_ws_server_transport(spec)
+        return await open_ws_server_transport(spec[0])
 
     if scheme == 'pty':
         from .pty import open_pty_transport
 
-        return await open_pty_transport(spec)
+        return await open_pty_transport(spec[0] if spec else None)
 
     if scheme == 'file':
         from .file import open_file_transport
 
-        assert spec is not None
-        return await open_file_transport(spec)
+        return await open_file_transport(spec[0] if spec else None)
 
     if scheme == 'vhci':
         from .vhci import open_vhci_transport
 
-        return await open_vhci_transport(spec)
+        return await open_vhci_transport(spec[0] if spec else None)
 
     if scheme == 'hci-socket':
         from .hci_socket import open_hci_socket_transport
 
-        return await open_hci_socket_transport(spec)
+        return await open_hci_socket_transport(spec[0] if spec else None)
 
     if scheme == 'usb':
         from .usb import open_usb_transport
 
-        assert spec
-        return await open_usb_transport(spec)
+        return await open_usb_transport(spec[0] if spec else None)
 
     if scheme == 'pyusb':
         from .pyusb import open_pyusb_transport
 
-        assert spec
-        return await open_pyusb_transport(spec)
+        return await open_pyusb_transport(spec[0] if spec else None)
 
     if scheme == 'android-emulator':
         from .android_emulator import open_android_emulator_transport
 
-        return await open_android_emulator_transport(spec)
+        return await open_android_emulator_transport(spec[0] if spec else None)
 
     if scheme == 'android-netsim':
         from .android_netsim import open_android_netsim_transport
 
-        return await open_android_netsim_transport(spec)
+        return await open_android_netsim_transport(spec[0] if spec else None)
 
     raise ValueError('unknown transport scheme')
 
@@ -198,7 +167,6 @@ async def open_transport_or_link(name: str) -> Transport:
 
     """
     if name.startswith('link-relay:'):
-        from ..controller import Controller
         from ..link import RemoteLink  # lazy import
 
         link = RemoteLink(name[11:])

bumble/transport/android_emulator.py

@@ -18,9 +18,7 @@
 import logging
 import grpc.aio
 
-from typing import Optional, Union
-
-from .common import PumpedTransport, PumpedPacketSource, PumpedPacketSink, Transport
+from .common import PumpedTransport, PumpedPacketSource, PumpedPacketSink
 
 # pylint: disable=no-name-in-module
 from .grpc_protobuf.emulated_bluetooth_pb2_grpc import EmulatedBluetoothServiceStub
@@ -35,7 +33,7 @@ logger = logging.getLogger(__name__)
 
 
 # -----------------------------------------------------------------------------
-async def open_android_emulator_transport(spec: Optional[str]) -> Transport:
+async def open_android_emulator_transport(spec):
     '''
     Open a transport connection to an Android emulator via its gRPC interface.
     The parameter string has this syntax:
@@ -68,8 +66,8 @@ async def open_android_emulator_transport(spec: Optional[str]) -> Transport:
     # Parse the parameters
     mode = 'host'
     server_host = 'localhost'
-    server_port = '8554'
-    if spec:
+    server_port = 8554
+    if spec is not None:
         params = spec.split(',')
         for param in params:
             if param.startswith('mode='):
@@ -84,7 +82,6 @@ async def open_android_emulator_transport(spec: Optional[str]) -> Transport:
     logger.debug(f'connecting to gRPC server at {server_address}')
     channel = grpc.aio.insecure_channel(server_address)
 
-    service: Union[EmulatedBluetoothServiceStub, VhciForwardingServiceStub]
     if mode == 'host':
         # Connect as a host
         service = EmulatedBluetoothServiceStub(channel)
@@ -97,13 +94,10 @@ async def open_android_emulator_transport(spec: Optional[str]) -> Transport:
         raise ValueError('invalid mode')
 
     # Create the transport object
-    class EmulatorTransport(PumpedTransport):
-        async def close(self):
-            await super().close()
-            await channel.close()
-
-    transport = EmulatorTransport(
-        PumpedPacketSource(hci_device.read), PumpedPacketSink(hci_device.write)
+    transport = PumpedTransport(
+        PumpedPacketSource(hci_device.read),
+        PumpedPacketSink(hci_device.write),
+        channel.close,
     )
     transport.start()
 

bumble/transport/android_netsim.py

@@ -18,12 +18,11 @@
 import asyncio
 import atexit
 import logging
+import grpc.aio
 import os
 import pathlib
 import sys
-from typing import Dict, Optional
-
-import grpc.aio
+from typing import Optional
 
 from .common import (
     ParserSource,
@@ -34,8 +33,8 @@ from .common import (
 )
 
 # pylint: disable=no-name-in-module
+from .grpc_protobuf.packet_streamer_pb2_grpc import PacketStreamerStub
 from .grpc_protobuf.packet_streamer_pb2_grpc import (
-    PacketStreamerStub,
     PacketStreamerServicer,
     add_PacketStreamerServicer_to_server,
 )
@@ -44,7 +43,6 @@ from .grpc_protobuf.hci_packet_pb2 import HCIPacket
 from .grpc_protobuf.startup_pb2 import Chip, ChipInfo
 from .grpc_protobuf.common_pb2 import ChipKind
 
-
 # -----------------------------------------------------------------------------
 # Logging
 # -----------------------------------------------------------------------------
@@ -76,20 +74,14 @@ def get_ini_dir() -> Optional[pathlib.Path]:
 
 
 # -----------------------------------------------------------------------------
-def ini_file_name(instance_number: int) -> str:
-    suffix = f'_{instance_number}' if instance_number > 0 else ''
-    return f'netsim{suffix}.ini'
-
-
-# -----------------------------------------------------------------------------
-def find_grpc_port(instance_number: int) -> int:
+def find_grpc_port() -> int:
     if not (ini_dir := get_ini_dir()):
         logger.debug('no known directory for .ini file')
         return 0
 
-    ini_file = ini_dir / ini_file_name(instance_number)
-    logger.debug(f'Looking for .ini file at {ini_file}')
+    ini_file = ini_dir / 'netsim.ini'
     if ini_file.is_file():
+        logger.debug(f'Found .ini file at {ini_file}')
         with open(ini_file, 'r') as ini_file_data:
             for line in ini_file_data.readlines():
                 if '=' in line:
@@ -98,14 +90,12 @@ def find_grpc_port(instance_number: int) -> int:
                         logger.debug(f'gRPC port = {value}')
                         return int(value)
 
-        logger.debug('no grpc.port property found in .ini file')
-
     # Not found
     return 0
 
 
 # -----------------------------------------------------------------------------
-def publish_grpc_port(grpc_port: int, instance_number: int) -> bool:
+def publish_grpc_port(grpc_port) -> bool:
     if not (ini_dir := get_ini_dir()):
         logger.debug('no known directory for .ini file')
         return False
@@ -114,7 +104,7 @@ def publish_grpc_port(grpc_port: int, instance_number: int) -> bool:
         logger.debug('ini directory does not exist')
         return False
 
-    ini_file = ini_dir / ini_file_name(instance_number)
+    ini_file = ini_dir / 'netsim.ini'
     try:
         ini_file.write_text(f'grpc.port={grpc_port}\n')
         logger.debug(f"published gRPC port at {ini_file}")
@@ -131,16 +121,13 @@ def publish_grpc_port(grpc_port: int, instance_number: int) -> bool:
 
 
 # -----------------------------------------------------------------------------
-async def open_android_netsim_controller_transport(
-    server_host: Optional[str], server_port: int, options: Dict[str, str]
-) -> Transport:
+async def open_android_netsim_controller_transport(server_host, server_port):
     if not server_port:
         raise ValueError('invalid port')
     if server_host == '_' or not server_host:
         server_host = 'localhost'
 
-    instance_number = int(options.get('instance', "0"))
-    if not publish_grpc_port(server_port, instance_number):
+    if not publish_grpc_port(server_port):
         logger.warning("unable to publish gRPC port")
 
     class HciDevice:
@@ -197,12 +184,15 @@ async def open_android_netsim_controller_transport(
                 logger.debug(f'<<< PACKET: {data.hex()}')
                 self.on_data_received(data)
 
-        async def send_packet(self, data):
-            return await self.context.write(
-                PacketResponse(
-                    hci_packet=HCIPacket(packet_type=data[0], packet=data[1:])
+        def send_packet(self, data):
+            async def send():
+                await self.context.write(
+                    PacketResponse(
+                        hci_packet=HCIPacket(packet_type=data[0], packet=data[1:])
+                    )
                 )
-            )
+
+            self.loop.create_task(send())
 
         def terminate(self):
             self.task.cancel()
@@ -236,17 +226,17 @@ async def open_android_netsim_controller_transport(
                 logger.debug('gRPC server cancelled')
                 await self.grpc_server.stop(None)
 
-        async def send_packet(self, packet):
+        def on_packet(self, packet):
             if not self.device:
                 logger.debug('no device, dropping packet')
                 return
 
-            return await self.device.send_packet(packet)
+            self.device.send_packet(packet)
 
         async def StreamPackets(self, _request_iterator, context):
             logger.debug('StreamPackets request')
 
-            # Check that we don't already have a device
+            # Check that we won't already have a device
             if self.device:
                 logger.debug('busy, already serving a device')
                 return PacketResponse(error='Busy')
@@ -269,42 +259,15 @@ async def open_android_netsim_controller_transport(
     await server.start()
     asyncio.get_running_loop().create_task(server.serve())
 
-    sink = PumpedPacketSink(server.send_packet)
-    sink.start()
-    return Transport(server, sink)
+    class GrpcServerTransport(Transport):
+        async def close(self):
+            await super().close()
+
+    return GrpcServerTransport(server, server)
 
 
 # -----------------------------------------------------------------------------
-async def open_android_netsim_host_transport_with_address(
-    server_host: Optional[str],
-    server_port: int,
-    options: Optional[Dict[str, str]] = None,
-):
-    if server_host == '_' or not server_host:
-        server_host = 'localhost'
-
-    if not server_port:
-        # Look for the gRPC config in a .ini file
-        instance_number = 0 if options is None else int(options.get('instance', '0'))
-        server_port = find_grpc_port(instance_number)
-        if not server_port:
-            raise RuntimeError('gRPC server port not found')
-
-    # Connect to the gRPC server
-    server_address = f'{server_host}:{server_port}'
-    logger.debug(f'Connecting to gRPC server at {server_address}')
-    channel = grpc.aio.insecure_channel(server_address)
-
-    return await open_android_netsim_host_transport_with_channel(
-        channel,
-        options,
-    )
-
-
-# -----------------------------------------------------------------------------
-async def open_android_netsim_host_transport_with_channel(
-    channel, options: Optional[Dict[str, str]] = None
-):
+async def open_android_netsim_host_transport(server_host, server_port, options):
     # Wrapper for I/O operations
     class HciDevice:
         def __init__(self, name, manufacturer, hci_device):
@@ -323,12 +286,10 @@ async def open_android_netsim_host_transport_with_channel(
         async def read(self):
             response = await self.hci_device.read()
             response_type = response.WhichOneof('response_type')
-
             if response_type == 'error':
                 logger.warning(f'received error: {response.error}')
                 raise RuntimeError(response.error)
-
-            if response_type == 'hci_packet':
+            elif response_type == 'hci_packet':
                 return (
                     bytes([response.hci_packet.packet_type])
                     + response.hci_packet.packet
@@ -343,9 +304,24 @@ async def open_android_netsim_host_transport_with_channel(
                 )
             )
 
-    name = DEFAULT_NAME if options is None else options.get('name', DEFAULT_NAME)
+    name = options.get('name', DEFAULT_NAME)
     manufacturer = DEFAULT_MANUFACTURER
 
+    if server_host == '_' or not server_host:
+        server_host = 'localhost'
+
+    if not server_port:
+        # Look for the gRPC config in a .ini file
+        server_host = 'localhost'
+        server_port = find_grpc_port()
+        if not server_port:
+            raise RuntimeError('gRPC server port not found')
+
+    # Connect to the gRPC server
+    server_address = f'{server_host}:{server_port}'
+    logger.debug(f'Connecting to gRPC server at {server_address}')
+    channel = grpc.aio.insecure_channel(server_address)
+
     # Connect as a host
     service = PacketStreamerStub(channel)
     hci_device = HciDevice(
@@ -356,14 +332,10 @@ async def open_android_netsim_host_transport_with_channel(
     await hci_device.start()
 
     # Create the transport object
-    class GrpcTransport(PumpedTransport):
-        async def close(self):
-            await super().close()
-            await channel.close()
-
-    transport = GrpcTransport(
+    transport = PumpedTransport(
         PumpedPacketSource(hci_device.read),
         PumpedPacketSink(hci_device.write),
+        channel.close,
     )
     transport.start()
 
@@ -371,7 +343,7 @@ async def open_android_netsim_host_transport_with_channel(
 
 
 # -----------------------------------------------------------------------------
-async def open_android_netsim_transport(spec: Optional[str]) -> Transport:
+async def open_android_netsim_transport(spec):
     '''
     Open a transport connection as a client or server, implementing Android's `netsim`
     simulator protocol over gRPC.
@@ -385,11 +357,6 @@ async def open_android_netsim_transport(spec: Optional[str]) -> Transport:
         to connect *to* a netsim server (netsim is the controller), or accept
         connections *as* a netsim-compatible server.
 
-      instance=<n>
-        Specifies an instance number, with <n> > 0. This is used to determine which
-        .init file to use. In `host` mode, it is ignored when the <host>:<port>
-        specifier is present, since in that case no .ini file is used.
-
     In `host` mode:
       The <host>:<port> part is optional. When not specified, the transport
       looks for a netsim .ini file, from which it will read the `grpc.backend.port`
@@ -418,15 +385,14 @@ async def open_android_netsim_transport(spec: Optional[str]) -> Transport:
     params = spec.split(',') if spec else []
     if params and ':' in params[0]:
         # Explicit <host>:<port>
-        host, port_str = params[0].split(':')
-        port = int(port_str)
+        host, port = params[0].split(':')
         params_offset = 1
     else:
         host = None
         port = 0
         params_offset = 0
 
-    options: Dict[str, str] = {}
+    options = {}
     for param in params[params_offset:]:
         if '=' not in param:
             raise ValueError('invalid parameter, expected <name>=<value>')
@@ -435,12 +401,10 @@ async def open_android_netsim_transport(spec: Optional[str]) -> Transport:
 
     mode = options.get('mode', 'host')
     if mode == 'host':
-        return await open_android_netsim_host_transport_with_address(
-            host, port, options
-        )
+        return await open_android_netsim_host_transport(host, port, options)
     if mode == 'controller':
         if host is None:
             raise ValueError('<host>:<port> missing')
-        return await open_android_netsim_controller_transport(host, port, options)
+        return await open_android_netsim_controller_transport(host, port)
 
     raise ValueError('invalid mode option')

bumble/transport/common.py

@@ -20,12 +20,11 @@ import contextlib
 import struct
 import asyncio
 import logging
-import io
-from typing import Any, ContextManager, Tuple, Optional, Protocol, Dict
+from typing import ContextManager
 
-from bumble import hci
-from bumble.colors import color
-from bumble.snoop import Snooper
+from .. import hci
+from ..colors import color
+from ..snoop import Snooper
 
 
 # -----------------------------------------------------------------------------
@@ -37,64 +36,42 @@ logger = logging.getLogger(__name__)
 # Information needed to parse HCI packets with a generic parser:
 # For each packet type, the info represents:
 # (length-size, length-offset, unpack-type)
-HCI_PACKET_INFO: Dict[int, Tuple[int, int, str]] = {
+HCI_PACKET_INFO = {
     hci.HCI_COMMAND_PACKET: (1, 2, 'B'),
     hci.HCI_ACL_DATA_PACKET: (2, 2, 'H'),
     hci.HCI_SYNCHRONOUS_DATA_PACKET: (1, 2, 'B'),
     hci.HCI_EVENT_PACKET: (1, 1, 'B'),
-    hci.HCI_ISO_DATA_PACKET: (2, 2, 'H'),
 }
 
 
-# -----------------------------------------------------------------------------
-# Errors
-# -----------------------------------------------------------------------------
-class TransportLostError(Exception):
-    """
-    The Transport has been lost/disconnected.
-    """
-
-
-# -----------------------------------------------------------------------------
-# Typing Protocols
-# -----------------------------------------------------------------------------
-class TransportSink(Protocol):
-    def on_packet(self, packet: bytes) -> None:
-        ...
-
-
-class TransportSource(Protocol):
-    terminated: asyncio.Future[None]
-
-    def set_packet_sink(self, sink: TransportSink) -> None:
-        ...
-
-
 # -----------------------------------------------------------------------------
 class PacketPump:
-    """
-    Pump HCI packets from a reader to a sink.
-    """
+    '''
+    Pump HCI packets from a reader to a sink
+    '''
 
-    def __init__(self, reader: AsyncPacketReader, sink: TransportSink) -> None:
+    def __init__(self, reader, sink):
         self.reader = reader
         self.sink = sink
 
-    async def run(self) -> None:
+    async def run(self):
         while True:
             try:
+                # Get a packet from the source
+                packet = hci.HCI_Packet.from_bytes(await self.reader.next_packet())
+
                 # Deliver the packet to the sink
-                self.sink.on_packet(await self.reader.next_packet())
+                self.sink.on_packet(packet)
             except Exception as error:
                 logger.warning(f'!!! {error}')
 
 
 # -----------------------------------------------------------------------------
 class PacketParser:
-    """
+    '''
     In-line parser that accepts data and emits 'on_packet' when a full packet has been
-    parsed.
-    """
+    parsed
+    '''
 
     # pylint: disable=attribute-defined-outside-init
 
@@ -102,22 +79,18 @@ class PacketParser:
     NEED_LENGTH = 1
     NEED_BODY = 2
 
-    sink: Optional[TransportSink]
-    extended_packet_info: Dict[int, Tuple[int, int, str]]
-    packet_info: Optional[Tuple[int, int, str]] = None
-
-    def __init__(self, sink: Optional[TransportSink] = None) -> None:
+    def __init__(self, sink=None):
         self.sink = sink
         self.extended_packet_info = {}
         self.reset()
 
-    def reset(self) -> None:
+    def reset(self):
         self.state = PacketParser.NEED_TYPE
         self.bytes_needed = 1
         self.packet = bytearray()
         self.packet_info = None
 
-    def feed_data(self, data: bytes) -> None:
+    def feed_data(self, data):
         data_offset = 0
         data_left = len(data)
         while data_left and self.bytes_needed:
@@ -138,7 +111,6 @@ class PacketParser:
                     self.state = PacketParser.NEED_LENGTH
                     self.bytes_needed = self.packet_info[0] + self.packet_info[1]
                 elif self.state == PacketParser.NEED_LENGTH:
-                    assert self.packet_info is not None
                     body_length = struct.unpack_from(
                         self.packet_info[2], self.packet, 1 + self.packet_info[1]
                     )[0]
@@ -151,25 +123,25 @@ class PacketParser:
                         try:
                             self.sink.on_packet(bytes(self.packet))
                         except Exception as error:
-                            logger.exception(
+                            logger.warning(
                                 color(f'!!! Exception in on_packet: {error}', 'red')
                             )
                     self.reset()
 
-    def set_packet_sink(self, sink: TransportSink) -> None:
+    def set_packet_sink(self, sink):
         self.sink = sink
 
 
 # -----------------------------------------------------------------------------
 class PacketReader:
-    """
-    Reader that reads HCI packets from a sync source.
-    """
+    '''
+    Reader that reads HCI packets from a sync source
+    '''
 
-    def __init__(self, source: io.BufferedReader) -> None:
+    def __init__(self, source):
         self.source = source
 
-    def next_packet(self) -> Optional[bytes]:
+    def next_packet(self):
         # Get the packet type
         packet_type = self.source.read(1)
         if len(packet_type) != 1:
@@ -178,7 +150,7 @@ class PacketReader:
         # Get the packet info based on its type
         packet_info = HCI_PACKET_INFO.get(packet_type[0])
         if packet_info is None:
-            raise ValueError(f'invalid packet type {packet_type[0]} found')
+            raise ValueError(f'invalid packet type {packet_type} found')
 
         # Read the header (that includes the length)
         header_size = packet_info[0] + packet_info[1]
@@ -197,21 +169,21 @@ class PacketReader:
 
 # -----------------------------------------------------------------------------
 class AsyncPacketReader:
-    """
-    Reader that reads HCI packets from an async source.
-    """
+    '''
+    Reader that reads HCI packets from an async source
+    '''
 
-    def __init__(self, source: asyncio.StreamReader) -> None:
+    def __init__(self, source):
         self.source = source
 
-    async def next_packet(self) -> bytes:
+    async def next_packet(self):
         # Get the packet type
         packet_type = await self.source.readexactly(1)
 
         # Get the packet info based on its type
         packet_info = HCI_PACKET_INFO.get(packet_type[0])
         if packet_info is None:
-            raise ValueError(f'invalid packet type {packet_type[0]} found')
+            raise ValueError(f'invalid packet type {packet_type} found')
 
         # Read the header (that includes the length)
         header_size = packet_info[0] + packet_info[1]
@@ -226,15 +198,15 @@ class AsyncPacketReader:
 
 # -----------------------------------------------------------------------------
 class AsyncPipeSink:
-    """
-    Sink that forwards packets asynchronously to another sink.
-    """
+    '''
+    Sink that forwards packets asynchronously to another sink
+    '''
 
-    def __init__(self, sink: TransportSink) -> None:
+    def __init__(self, sink):
         self.sink = sink
         self.loop = asyncio.get_running_loop()
 
-    def on_packet(self, packet: bytes) -> None:
+    def on_packet(self, packet):
         self.loop.call_soon(self.sink.on_packet, packet)
 
 
@@ -244,48 +216,35 @@ class ParserSource:
     Base class designed to be subclassed by transport-specific source classes
     """
 
-    terminated: asyncio.Future[None]
-    parser: PacketParser
-
-    def __init__(self) -> None:
+    def __init__(self):
         self.parser = PacketParser()
         self.terminated = asyncio.get_running_loop().create_future()
 
-    def set_packet_sink(self, sink: TransportSink) -> None:
+    def set_packet_sink(self, sink):
         self.parser.set_packet_sink(sink)
 
-    def on_transport_lost(self) -> None:
-        self.terminated.set_result(None)
-        if self.parser.sink:
-            if hasattr(self.parser.sink, 'on_transport_lost'):
-                self.parser.sink.on_transport_lost()
-
-    async def wait_for_termination(self) -> None:
-        """
-        Convenience method for backward compatibility. Prefer using the `terminated`
-        attribute instead.
-        """
+    async def wait_for_termination(self):
         return await self.terminated
 
-    def close(self) -> None:
+    def close(self):
         pass
 
 
 # -----------------------------------------------------------------------------
 class StreamPacketSource(asyncio.Protocol, ParserSource):
-    def data_received(self, data: bytes) -> None:
+    def data_received(self, data):
         self.parser.feed_data(data)
 
 
 # -----------------------------------------------------------------------------
 class StreamPacketSink:
-    def __init__(self, transport: asyncio.WriteTransport) -> None:
+    def __init__(self, transport):
         self.transport = transport
 
-    def on_packet(self, packet: bytes) -> None:
+    def on_packet(self, packet):
         self.transport.write(packet)
 
-    def close(self) -> None:
+    def close(self):
         self.transport.close()
 
 
@@ -305,7 +264,7 @@ class Transport:
         ...
     """
 
-    def __init__(self, source: TransportSource, sink: TransportSink) -> None:
+    def __init__(self, source, sink):
         self.source = source
         self.sink = sink
 
@@ -319,39 +278,34 @@ class Transport:
         return iter((self.source, self.sink))
 
     async def close(self) -> None:
-        if hasattr(self.source, 'close'):
-            self.source.close()
-        if hasattr(self.sink, 'close'):
-            self.sink.close()
+        self.source.close()
+        self.sink.close()
 
 
 # -----------------------------------------------------------------------------
 class PumpedPacketSource(ParserSource):
-    pump_task: Optional[asyncio.Task[None]]
-
-    def __init__(self, receive) -> None:
+    def __init__(self, receive):
         super().__init__()
         self.receive_function = receive
         self.pump_task = None
 
-    def start(self) -> None:
-        async def pump_packets() -> None:
+    def start(self):
+        async def pump_packets():
             while True:
                 try:
                     packet = await self.receive_function()
                     self.parser.feed_data(packet)
-                except asyncio.CancelledError:
+                except asyncio.exceptions.CancelledError:
                     logger.debug('source pump task done')
-                    self.terminated.set_result(None)
                     break
                 except Exception as error:
                     logger.warning(f'exception while waiting for packet: {error}')
-                    self.terminated.set_exception(error)
+                    self.terminated.set_result(error)
                     break
 
         self.pump_task = asyncio.create_task(pump_packets())
 
-    def close(self) -> None:
+    def close(self):
         if self.pump_task:
             self.pump_task.cancel()
 
@@ -363,7 +317,7 @@ class PumpedPacketSink:
         self.packet_queue = asyncio.Queue()
         self.pump_task = None
 
-    def on_packet(self, packet: bytes) -> None:
+    def on_packet(self, packet):
         self.packet_queue.put_nowait(packet)
 
     def start(self):
@@ -372,7 +326,7 @@ class PumpedPacketSink:
                 try:
                     packet = await self.packet_queue.get()
                     await self.send_function(packet)
-                except asyncio.CancelledError:
+                except asyncio.exceptions.CancelledError:
                     logger.debug('sink pump task done')
                     break
                 except Exception as error:
@@ -388,20 +342,18 @@ class PumpedPacketSink:
 
 # -----------------------------------------------------------------------------
 class PumpedTransport(Transport):
-    source: PumpedPacketSource
-    sink: PumpedPacketSink
-
-    def __init__(
-        self,
-        source: PumpedPacketSource,
-        sink: PumpedPacketSink,
-    ) -> None:
+    def __init__(self, source, sink, close_function):
         super().__init__(source, sink)
+        self.close_function = close_function
 
-    def start(self) -> None:
+    def start(self):
         self.source.start()
         self.sink.start()
 
+    async def close(self):
+        await super().close()
+        await self.close_function()
+
 
 # -----------------------------------------------------------------------------
 class SnoopingTransport(Transport):
@@ -423,38 +375,31 @@ class SnoopingTransport(Transport):
         raise RuntimeError('unexpected code path')  # Satisfy the type checker
 
     class Source:
-        sink: TransportSink
-
-        def __init__(self, source: TransportSource, snooper: Snooper):
+        def __init__(self, source, snooper):
             self.source = source
             self.snooper = snooper
-            self.terminated = source.terminated
+            self.sink = None
 
-        def set_packet_sink(self, sink: TransportSink) -> None:
+        def set_packet_sink(self, sink):
             self.sink = sink
             self.source.set_packet_sink(self)
 
-        def on_packet(self, packet: bytes) -> None:
+        def on_packet(self, packet):
             self.snooper.snoop(packet, Snooper.Direction.CONTROLLER_TO_HOST)
             if self.sink:
                 self.sink.on_packet(packet)
 
     class Sink:
-        def __init__(self, sink: TransportSink, snooper: Snooper) -> None:
+        def __init__(self, sink, snooper):
             self.sink = sink
             self.snooper = snooper
 
-        def on_packet(self, packet: bytes) -> None:
+        def on_packet(self, packet):
             self.snooper.snoop(packet, Snooper.Direction.HOST_TO_CONTROLLER)
             if self.sink:
                 self.sink.on_packet(packet)
 
-    def __init__(
-        self,
-        transport: Transport,
-        snooper: Snooper,
-        close_snooper=None,
-    ) -> None:
+    def __init__(self, transport, snooper, close_snooper=None):
         super().__init__(
             self.Source(transport.source, snooper), self.Sink(transport.sink, snooper)
         )

bumble/transport/file.py

@@ -28,7 +28,7 @@ logger = logging.getLogger(__name__)
 
 
 # -----------------------------------------------------------------------------
-async def open_file_transport(spec: str) -> Transport:
+async def open_file_transport(spec):
     '''
     Open a File transport (typically not for a real file, but for a PTY or other unix
     virtual files).

bumble/transport/hci_socket.py

@@ -23,8 +23,6 @@ import socket
 import ctypes
 import collections
 
-from typing import Optional
-
 from .common import Transport, ParserSource
 
 
@@ -35,7 +33,7 @@ logger = logging.getLogger(__name__)
 
 
 # -----------------------------------------------------------------------------
-async def open_hci_socket_transport(spec: Optional[str]) -> Transport:
+async def open_hci_socket_transport(spec):
     '''
     Open an HCI Socket (only available on some platforms).
     The parameter string is either empty (to use the first/default Bluetooth adapter)
@@ -47,9 +45,9 @@ async def open_hci_socket_transport(spec: Optional[str]) -> Transport:
     # Create a raw HCI socket
     try:
         hci_socket = socket.socket(
-            socket.AF_BLUETOOTH,  # type: ignore[attr-defined]
-            socket.SOCK_RAW | socket.SOCK_NONBLOCK,  # type: ignore[attr-defined]
-            socket.BTPROTO_HCI,  # type: ignore[attr-defined]
+            socket.AF_BLUETOOTH,
+            socket.SOCK_RAW | socket.SOCK_NONBLOCK,
+            socket.BTPROTO_HCI,
         )
     except AttributeError as error:
         # Not supported on this platform
@@ -59,7 +57,10 @@ async def open_hci_socket_transport(spec: Optional[str]) -> Transport:
         ) from error
 
     # Compute the adapter index
-    adapter_index = int(spec) if spec else 0
+    if spec is None:
+        adapter_index = 0
+    else:
+        adapter_index = int(spec)
 
     # Bind the socket
     # NOTE: since Python doesn't support binding with the required address format (yet),
@@ -77,7 +78,7 @@ async def open_hci_socket_transport(spec: Optional[str]) -> Transport:
     bind_address = struct.pack(
         # pylint: disable=no-member
         '<HHH',
-        socket.AF_BLUETOOTH,  # type: ignore[attr-defined]
+        socket.AF_BLUETOOTH,
         adapter_index,
         HCI_CHANNEL_USER,
     )

bumble/transport/pty.py

@@ -23,8 +23,6 @@ import atexit
 import os
 import logging
 
-from typing import Optional
-
 from .common import Transport, StreamPacketSource, StreamPacketSink
 
 # -----------------------------------------------------------------------------
@@ -34,7 +32,7 @@ logger = logging.getLogger(__name__)
 
 
 # -----------------------------------------------------------------------------
-async def open_pty_transport(spec: Optional[str]) -> Transport:
+async def open_pty_transport(spec):
     '''
     Open a PTY transport.
     The parameter string may be empty, or a path name where a symbolic link

bumble/transport/pyusb.py

@@ -35,7 +35,7 @@ logger = logging.getLogger(__name__)
 
 
 # -----------------------------------------------------------------------------
-async def open_pyusb_transport(spec: str) -> Transport:
+async def open_pyusb_transport(spec):
     '''
     Open a USB transport. [Implementation based on PyUSB]
     The parameter string has this syntax:

bumble/transport/serial.py

@@ -28,7 +28,7 @@ logger = logging.getLogger(__name__)
 
 
 # -----------------------------------------------------------------------------
-async def open_serial_transport(spec: str) -> Transport:
+async def open_serial_transport(spec):
     '''
     Open a serial port transport.
     The parameter string has this syntax:

bumble/transport/tcp_client.py

@@ -27,7 +27,7 @@ logger = logging.getLogger(__name__)
 
 
 # -----------------------------------------------------------------------------
-async def open_tcp_client_transport(spec: str) -> Transport:
+async def open_tcp_client_transport(spec):
     '''
     Open a TCP client transport.
     The parameter string has this syntax:
@@ -39,7 +39,7 @@ async def open_tcp_client_transport(spec: str) -> Transport:
     class TcpPacketSource(StreamPacketSource):
         def connection_lost(self, exc):
             logger.debug(f'connection lost: {exc}')
-            self.on_transport_lost()
+            self.terminated.set_result(exc)
 
     remote_host, remote_port = spec.split(':')
     tcp_transport, packet_source = await asyncio.get_running_loop().create_connection(

bumble/transport/tcp_server.py

@@ -15,7 +15,6 @@
 # -----------------------------------------------------------------------------
 # Imports
 # -----------------------------------------------------------------------------
-from __future__ import annotations
 import asyncio
 import logging
 
@@ -28,7 +27,7 @@ logger = logging.getLogger(__name__)
 
 
 # -----------------------------------------------------------------------------
-async def open_tcp_server_transport(spec: str) -> Transport:
+async def open_tcp_server_transport(spec):
     '''
     Open a TCP server transport.
     The parameter string has this syntax:
@@ -43,7 +42,7 @@ async def open_tcp_server_transport(spec: str) -> Transport:
         async def close(self):
             await super().close()
 
-    class TcpServerProtocol(asyncio.BaseProtocol):
+    class TcpServerProtocol:
         def __init__(self, packet_source, packet_sink):
             self.packet_source = packet_source
             self.packet_sink = packet_sink

bumble/transport/udp.py

@@ -27,7 +27,7 @@ logger = logging.getLogger(__name__)
 
 
 # -----------------------------------------------------------------------------
-async def open_udp_transport(spec: str) -> Transport:
+async def open_udp_transport(spec):
     '''
     Open a UDP transport.
     The parameter string has this syntax:

bumble/transport/usb.py

@@ -24,10 +24,9 @@ import platform
 
 import usb1
 
-from bumble.transport.common import Transport, ParserSource
-from bumble import hci
-from bumble.colors import color
-from bumble.utils import AsyncRunner
+from .common import Transport, ParserSource
+from .. import hci
+from ..colors import color
 
 
 # -----------------------------------------------------------------------------
@@ -61,7 +60,7 @@ def load_libusb():
             usb1.loadLibrary(libusb_dll)
 
 
-async def open_usb_transport(spec: str) -> Transport:
+async def open_usb_transport(spec):
     '''
     Open a USB transport.
     The moniker string has this syntax:
@@ -108,13 +107,13 @@ 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):
             self.device = device
             self.acl_out = acl_out
-            self.acl_out_transfer = device.getTransfer()
+            self.transfer = device.getTransfer()
             self.packets = collections.deque()  # Queue of packets waiting to be sent
             self.loop = asyncio.get_running_loop()
             self.cancel_done = self.loop.create_future()
@@ -138,20 +137,21 @@ async def open_usb_transport(spec: str) -> Transport:
                 # The queue was previously empty, re-prime the pump
                 self.process_queue()
 
-        def transfer_callback(self, transfer):
+        def on_packet_sent(self, transfer):
             status = transfer.getStatus()
+            # logger.debug(f'<<< USB out transfer callback: status={status}')
 
             # pylint: disable=no-member
             if status == usb1.TRANSFER_COMPLETED:
-                self.loop.call_soon_threadsafe(self.on_packet_sent)
+                self.loop.call_soon_threadsafe(self.on_packet_sent_)
             elif status == usb1.TRANSFER_CANCELLED:
                 self.loop.call_soon_threadsafe(self.cancel_done.set_result, None)
             else:
                 logger.warning(
-                    color(f'!!! OUT transfer not completed: status={status}', 'red')
+                    color(f'!!! out transfer not completed: status={status}', 'red')
                 )
 
-        def on_packet_sent(self):
+        def on_packet_sent_(self):
             if self.packets:
                 self.packets.popleft()
                 self.process_queue()
@@ -163,20 +163,22 @@ async def open_usb_transport(spec: str) -> Transport:
             packet = self.packets[0]
             packet_type = packet[0]
             if packet_type == hci.HCI_ACL_DATA_PACKET:
-                self.acl_out_transfer.setBulk(
-                    self.acl_out, packet[1:], callback=self.transfer_callback
+                self.transfer.setBulk(
+                    self.acl_out, packet[1:], callback=self.on_packet_sent
                 )
-                self.acl_out_transfer.submit()
+                logger.debug('submit ACL')
+                self.transfer.submit()
             elif packet_type == hci.HCI_COMMAND_PACKET:
-                self.acl_out_transfer.setControl(
+                self.transfer.setControl(
                     USB_RECIPIENT_DEVICE | USB_REQUEST_TYPE_CLASS,
                     0,
                     0,
                     0,
                     packet[1:],
-                    callback=self.transfer_callback,
+                    callback=self.on_packet_sent,
                 )
-                self.acl_out_transfer.submit()
+                logger.debug('submit COMMAND')
+                self.transfer.submit()
             else:
                 logger.warning(color(f'unsupported packet type {packet_type}', 'red'))
 
@@ -191,11 +193,11 @@ async def open_usb_transport(spec: str) -> Transport:
             self.packets.clear()
 
             # If we have a transfer in flight, cancel it
-            if self.acl_out_transfer.isSubmitted():
+            if self.transfer.isSubmitted():
                 # Try to cancel the transfer, but that may fail because it may have
                 # already completed
                 try:
-                    self.acl_out_transfer.cancel()
+                    self.transfer.cancel()
 
                     logger.debug('waiting for OUT transfer cancellation to be done...')
                     await self.cancel_done
@@ -204,22 +206,27 @@ async def open_usb_transport(spec: str) -> Transport:
                     logger.debug('OUT transfer likely already completed')
 
     class UsbPacketSource(asyncio.Protocol, ParserSource):
-        def __init__(self, device, metadata, acl_in, events_in):
+        def __init__(self, context, device, metadata, acl_in, events_in):
             super().__init__()
+            self.context = context
             self.device = device
             self.metadata = metadata
             self.acl_in = acl_in
-            self.acl_in_transfer = None
             self.events_in = events_in
-            self.events_in_transfer = None
             self.loop = asyncio.get_running_loop()
             self.queue = asyncio.Queue()
             self.dequeue_task = None
+            self.closed = False
+            self.event_loop_done = self.loop.create_future()
             self.cancel_done = {
                 hci.HCI_EVENT_PACKET: self.loop.create_future(),
                 hci.HCI_ACL_DATA_PACKET: self.loop.create_future(),
             }
-            self.closed = False
+            self.events_in_transfer = None
+            self.acl_in_transfer = None
+
+            # Create a thread to process events
+            self.event_thread = threading.Thread(target=self.run)
 
         def start(self):
             # Set up transfer objects for input
@@ -227,7 +234,7 @@ async def open_usb_transport(spec: str) -> Transport:
             self.events_in_transfer.setInterrupt(
                 self.events_in,
                 READ_SIZE,
-                callback=self.transfer_callback,
+                callback=self.on_packet_received,
                 user_data=hci.HCI_EVENT_PACKET,
             )
             self.events_in_transfer.submit()
@@ -236,23 +243,22 @@ async def open_usb_transport(spec: str) -> Transport:
             self.acl_in_transfer.setBulk(
                 self.acl_in,
                 READ_SIZE,
-                callback=self.transfer_callback,
+                callback=self.on_packet_received,
                 user_data=hci.HCI_ACL_DATA_PACKET,
             )
             self.acl_in_transfer.submit()
 
             self.dequeue_task = self.loop.create_task(self.dequeue())
+            self.event_thread.start()
 
-        @property
-        def usb_transfer_submitted(self):
-            return (
-                self.events_in_transfer.isSubmitted()
-                or self.acl_in_transfer.isSubmitted()
-            )
-
-        def transfer_callback(self, transfer):
+        def on_packet_received(self, transfer):
             packet_type = transfer.getUserData()
             status = transfer.getStatus()
+            # logger.debug(
+            #     f'<<< USB IN transfer callback: status={status} '
+            #     f'packet_type={packet_type} '
+            #     f'length={transfer.getActualLength()}'
+            # )
 
             # pylint: disable=no-member
             if status == usb1.TRANSFER_COMPLETED:
@@ -261,18 +267,18 @@ async def open_usb_transport(spec: str) -> Transport:
                     + transfer.getBuffer()[: transfer.getActualLength()]
                 )
                 self.loop.call_soon_threadsafe(self.queue.put_nowait, packet)
-
-                # Re-submit the transfer so we can receive more data
-                transfer.submit()
             elif status == usb1.TRANSFER_CANCELLED:
                 self.loop.call_soon_threadsafe(
                     self.cancel_done[packet_type].set_result, None
                 )
+                return
             else:
                 logger.warning(
-                    color(f'!!! IN transfer not completed: status={status}', 'red')
+                    color(f'!!! transfer not completed: status={status}', 'red')
                 )
-                self.loop.call_soon_threadsafe(self.on_transport_lost)
+
+            # Re-submit the transfer so we can receive more data
+            transfer.submit()
 
         async def dequeue(self):
             while not self.closed:
@@ -282,6 +288,21 @@ async def open_usb_transport(spec: str) -> Transport:
                     return
                 self.parser.feed_data(packet)
 
+        def run(self):
+            logger.debug('starting USB event loop')
+            while (
+                self.events_in_transfer.isSubmitted()
+                or self.acl_in_transfer.isSubmitted()
+            ):
+                # pylint: disable=no-member
+                try:
+                    self.context.handleEvents()
+                except usb1.USBErrorInterrupted:
+                    pass
+
+            logger.debug('USB event loop done')
+            self.loop.call_soon_threadsafe(self.event_loop_done.set_result, None)
+
         def close(self):
             self.closed = True
 
@@ -310,14 +331,15 @@ async def open_usb_transport(spec: str) -> Transport:
                             f'IN[{packet_type}] transfer likely already completed'
                         )
 
+            # Wait for the thread to terminate
+            await self.event_loop_done
+
     class UsbTransport(Transport):
         def __init__(self, context, device, interface, setting, source, sink):
             super().__init__(source, sink)
             self.context = context
             self.device = device
             self.interface = interface
-            self.loop = asyncio.get_running_loop()
-            self.event_loop_done = self.loop.create_future()
 
             # Get exclusive access
             device.claimInterface(interface)
@@ -330,22 +352,6 @@ async def open_usb_transport(spec: str) -> Transport:
             source.start()
             sink.start()
 
-            # Create a thread to process events
-            self.event_thread = threading.Thread(target=self.run)
-            self.event_thread.start()
-
-        def run(self):
-            logger.debug('starting USB event loop')
-            while self.source.usb_transfer_submitted:
-                # pylint: disable=no-member
-                try:
-                    self.context.handleEvents()
-                except usb1.USBErrorInterrupted:
-                    pass
-
-            logger.debug('USB event loop done')
-            self.loop.call_soon_threadsafe(self.event_loop_done.set_result, None)
-
         async def close(self):
             self.source.close()
             self.sink.close()
@@ -355,9 +361,6 @@ async def open_usb_transport(spec: str) -> Transport:
             self.device.close()
             self.context.close()
 
-            # Wait for the thread to terminate
-            await self.event_loop_done
-
     # Find the device according to the spec moniker
     load_libusb()
     context = usb1.USBContext()
@@ -537,7 +540,7 @@ async def open_usb_transport(spec: str) -> Transport:
             except usb1.USBError:
                 logger.warning('failed to set configuration')
 
-        source = UsbPacketSource(device, device_metadata, acl_in, events_in)
+        source = UsbPacketSource(context, device, device_metadata, acl_in, events_in)
         sink = UsbPacketSink(device, acl_out)
         return UsbTransport(context, device, interface, setting, source, sink)
     except usb1.USBError as error:

bumble/transport/vhci.py

@@ -17,9 +17,6 @@
 # -----------------------------------------------------------------------------
 import logging
 
-from typing import Optional
-
-from .common import Transport
 from .file import open_file_transport
 
 # -----------------------------------------------------------------------------
@@ -29,7 +26,7 @@ logger = logging.getLogger(__name__)
 
 
 # -----------------------------------------------------------------------------
-async def open_vhci_transport(spec: Optional[str]) -> Transport:
+async def open_vhci_transport(spec):
     '''
     Open a VHCI transport (only available on some platforms).
     The parameter string is either empty (to use the default VHCI device
@@ -45,15 +42,15 @@ async def open_vhci_transport(spec: Optional[str]) -> Transport:
     # Override the source's `data_received` method so that we can
     # filter out the vendor packet that is received just after the
     # initial open
-    def vhci_data_received(data: bytes) -> None:
+    def vhci_data_received(data):
         if len(data) > 0 and data[0] == HCI_VENDOR_PKT:
             if len(data) == 4:
                 hci_index = data[2] << 8 | data[3]
                 logger.info(f'HCI index {hci_index}')
         else:
-            transport.source.parser.feed_data(data)  # type: ignore
+            transport.source.parser.feed_data(data)
 
-    transport.source.data_received = vhci_data_received  # type: ignore
+    transport.source.data_received = vhci_data_received
 
     # Write the initial config
     transport.sink.on_packet(bytes([HCI_VENDOR_PKT, HCI_BREDR]))

bumble/transport/ws_client.py

@@ -16,9 +16,9 @@
 # Imports
 # -----------------------------------------------------------------------------
 import logging
-import websockets.client
+import websockets
 
-from .common import PumpedPacketSource, PumpedPacketSink, PumpedTransport, Transport
+from .common import PumpedPacketSource, PumpedPacketSink, PumpedTransport
 
 # -----------------------------------------------------------------------------
 # Logging
@@ -27,25 +27,23 @@ logger = logging.getLogger(__name__)
 
 
 # -----------------------------------------------------------------------------
-async def open_ws_client_transport(spec: str) -> Transport:
+async def open_ws_client_transport(spec):
     '''
     Open a WebSocket client transport.
     The parameter string has this syntax:
-    <websocket-url>
+    <remote-host>:<remote-port>
 
-    Example: ws://localhost:7681/v1/websocket/bt
+    Example: 127.0.0.1:9001
     '''
 
-    websocket = await websockets.client.connect(spec)
+    remote_host, remote_port = spec.split(':')
+    uri = f'ws://{remote_host}:{remote_port}'
+    websocket = await websockets.connect(uri)
 
-    class WsTransport(PumpedTransport):
-        async def close(self):
-            await super().close()
-            await websocket.close()
-
-    transport = WsTransport(
+    transport = PumpedTransport(
         PumpedPacketSource(websocket.recv),
         PumpedPacketSink(websocket.send),
+        websocket.close,
     )
     transport.start()
     return transport

bumble/transport/ws_server.py

@@ -15,6 +15,7 @@
 # -----------------------------------------------------------------------------
 # Imports
 # -----------------------------------------------------------------------------
+import asyncio
 import logging
 import websockets
 
@@ -27,7 +28,7 @@ logger = logging.getLogger(__name__)
 
 
 # -----------------------------------------------------------------------------
-async def open_ws_server_transport(spec: str) -> Transport:
+async def open_ws_server_transport(spec):
     '''
     Open a WebSocket server transport.
     The parameter string has this syntax:
@@ -42,7 +43,7 @@ async def open_ws_server_transport(spec: str) -> Transport:
         def __init__(self):
             source = ParserSource()
             sink = PumpedPacketSink(self.send_packet)
-            self.connection = None
+            self.connection = asyncio.get_running_loop().create_future()
             self.server = None
 
             super().__init__(source, sink)
@@ -62,7 +63,7 @@ async def open_ws_server_transport(spec: str) -> Transport:
                 f'new connection on {connection.local_address} '
                 f'from {connection.remote_address}'
             )
-            self.connection = connection
+            self.connection.set_result(connection)
             # pylint: disable=no-member
             try:
                 async for packet in connection:
@@ -73,14 +74,12 @@ async def open_ws_server_transport(spec: str) -> Transport:
             except websockets.WebSocketException as error:
                 logger.debug(f'exception while receiving packet: {error}')
 
-            # We're now disconnected
-            self.connection = None
+            # Wait for a new connection
+            self.connection = asyncio.get_running_loop().create_future()
 
         async def send_packet(self, packet):
-            if self.connection is None:
-                logger.debug('no connection, dropping packet')
-                return
-            return await self.connection.send(packet)
+            connection = await self.connection
+            return await connection.send(packet)
 
     local_host, local_port = spec.split(':')
     transport = WsServerTransport()

bumble/utils.py

@@ -15,26 +15,13 @@
 # -----------------------------------------------------------------------------
 # Imports
 # -----------------------------------------------------------------------------
-from __future__ import annotations
 import asyncio
 import logging
 import traceback
 import collections
 import sys
-import warnings
-from typing import (
-    Awaitable,
-    Set,
-    TypeVar,
-    List,
-    Tuple,
-    Callable,
-    Any,
-    Optional,
-    Union,
-    overload,
-)
-from functools import wraps, partial
+from typing import Awaitable, Set, TypeVar
+from functools import wraps
 from pyee import EventEmitter
 
 from .colors import color
@@ -77,102 +64,6 @@ def composite_listener(cls):
     return cls
 
 
-# -----------------------------------------------------------------------------
-_Handler = TypeVar('_Handler', bound=Callable)
-
-
-class EventWatcher:
-    '''A wrapper class to control the lifecycle of event handlers better.
-
-    Usage:
-    ```
-    watcher = EventWatcher()
-
-    def on_foo():
-        ...
-    watcher.on(emitter, 'foo', on_foo)
-
-    @watcher.on(emitter, 'bar')
-    def on_bar():
-        ...
-
-    # Close all event handlers watching through this watcher
-    watcher.close()
-    ```
-
-    As context:
-    ```
-    with contextlib.closing(EventWatcher()) as context:
-        @context.on(emitter, 'foo')
-        def on_foo():
-            ...
-    # on_foo() has been removed here!
-    ```
-    '''
-
-    handlers: List[Tuple[EventEmitter, str, Callable[..., Any]]]
-
-    def __init__(self) -> None:
-        self.handlers = []
-
-    @overload
-    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: Optional[_Handler] = None
-    ) -> Union[_Handler, Callable[[_Handler], _Handler]]:
-        '''Watch an event until the context is closed.
-
-        Args:
-            emitter: EventEmitter to watch
-            event: Event name
-            handler: (Optional) Event handler. When nothing is passed, this method works as a decorator.
-        '''
-
-        def wrapper(f: _Handler) -> _Handler:
-            self.handlers.append((emitter, event, f))
-            emitter.on(event, f)
-            return f
-
-        return wrapper if handler is None else wrapper(handler)
-
-    @overload
-    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: Optional[_Handler] = None
-    ) -> Union[_Handler, Callable[[_Handler], _Handler]]:
-        '''Watch an event for once.
-
-        Args:
-            emitter: EventEmitter to watch
-            event: Event name
-            handler: (Optional) Event handler. When nothing passed, this method works as a decorator.
-        '''
-
-        def wrapper(f: _Handler) -> _Handler:
-            self.handlers.append((emitter, event, f))
-            emitter.once(event, f)
-            return f
-
-        return wrapper if handler is None else wrapper(handler)
-
-    def close(self) -> None:
-        for emitter, event, handler in self.handlers:
-            if handler in emitter.listeners(event):
-                emitter.remove_listener(event, handler)
-
-
 # -----------------------------------------------------------------------------
 _T = TypeVar('_T')
 
@@ -280,14 +171,17 @@ class AsyncRunner:
             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)
@@ -408,52 +302,3 @@ class FlowControlAsyncPipe:
                     self.resume_source()
 
             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.
-
-    result = await async_call(some_function, ...)
-    """
-    return function(*args, **kwargs)
-
-
-def wrap_async(function):
-    """
-    Wraps the provided function in an async function.
-    """
-    return partial(async_call, function)
-
-
-def deprecated(msg: str):
-    """
-    Throw deprecation warning before execution.
-    """
-
-    def wrapper(function):
-        @wraps(function)
-        def inner(*args, **kwargs):
-            warnings.warn(msg, DeprecationWarning)
-            return function(*args, **kwargs)
-
-        return inner
-
-    return wrapper
-
-
-def experimental(msg: str):
-    """
-    Throws a future warning before execution.
-    """
-
-    def wrapper(function):
-        @wraps(function)
-        def inner(*args, **kwargs):
-            warnings.warn(msg, FutureWarning)
-            return function(*args, **kwargs)
-
-        return inner
-
-    return wrapper

bumble/vendor/android/hci.py

@@ -1,318 +0,0 @@
-# Copyright 2021-2023 Google LLC
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# -----------------------------------------------------------------------------
-# Imports
-# -----------------------------------------------------------------------------
-import struct
-
-from bumble.hci import (
-    name_or_number,
-    hci_vendor_command_op_code,
-    Address,
-    HCI_Constant,
-    HCI_Object,
-    HCI_Command,
-    HCI_Vendor_Event,
-    STATUS_SPEC,
-)
-
-
-# -----------------------------------------------------------------------------
-# Constants
-# -----------------------------------------------------------------------------
-
-# Android Vendor Specific Commands and Events.
-# Only a subset of the commands are implemented here currently.
-#
-# pylint: disable-next=line-too-long
-# See https://source.android.com/docs/core/connect/bluetooth/hci_requirements#chip-capabilities-and-configuration
-HCI_LE_GET_VENDOR_CAPABILITIES_COMMAND = hci_vendor_command_op_code(0x153)
-HCI_LE_APCF_COMMAND = hci_vendor_command_op_code(0x157)
-HCI_GET_CONTROLLER_ACTIVITY_ENERGY_INFO_COMMAND = hci_vendor_command_op_code(0x159)
-HCI_A2DP_HARDWARE_OFFLOAD_COMMAND = hci_vendor_command_op_code(0x15D)
-HCI_BLUETOOTH_QUALITY_REPORT_COMMAND = hci_vendor_command_op_code(0x15E)
-HCI_DYNAMIC_AUDIO_BUFFER_COMMAND = hci_vendor_command_op_code(0x15F)
-
-HCI_BLUETOOTH_QUALITY_REPORT_EVENT = 0x58
-
-HCI_Command.register_commands(globals())
-HCI_Vendor_Event.register_subevents(globals())
-
-
-# -----------------------------------------------------------------------------
-@HCI_Command.command(
-    return_parameters_fields=[
-        ('status', STATUS_SPEC),
-        ('max_advt_instances', 1),
-        ('offloaded_resolution_of_private_address', 1),
-        ('total_scan_results_storage', 2),
-        ('max_irk_list_sz', 1),
-        ('filtering_support', 1),
-        ('max_filter', 1),
-        ('activity_energy_info_support', 1),
-        ('version_supported', 2),
-        ('total_num_of_advt_tracked', 2),
-        ('extended_scan_support', 1),
-        ('debug_logging_supported', 1),
-        ('le_address_generation_offloading_support', 1),
-        ('a2dp_source_offload_capability_mask', 4),
-        ('bluetooth_quality_report_support', 1),
-        ('dynamic_audio_buffer_support', 4),
-    ]
-)
-class HCI_LE_Get_Vendor_Capabilities_Command(HCI_Command):
-    # pylint: disable=line-too-long
-    '''
-    See https://source.android.com/docs/core/connect/bluetooth/hci_requirements#vendor-specific-capabilities
-    '''
-
-    @classmethod
-    def parse_return_parameters(cls, parameters):
-        # There are many versions of this data structure, so we need to parse until
-        # there are no more bytes to parse, and leave un-signal parameters set to
-        # None (older versions)
-        nones = {field: None for field, _ in cls.return_parameters_fields}
-        return_parameters = HCI_Object(cls.return_parameters_fields, **nones)
-
-        try:
-            offset = 0
-            for field in cls.return_parameters_fields:
-                field_name, field_type = field
-                field_value, field_size = HCI_Object.parse_field(
-                    parameters, offset, field_type
-                )
-                setattr(return_parameters, field_name, field_value)
-                offset += field_size
-        except struct.error:
-            pass
-
-        return return_parameters
-
-
-# -----------------------------------------------------------------------------
-@HCI_Command.command(
-    fields=[
-        (
-            'opcode',
-            {
-                'size': 1,
-                'mapper': lambda x: HCI_LE_APCF_Command.opcode_name(x),
-            },
-        ),
-        ('payload', '*'),
-    ],
-    return_parameters_fields=[
-        ('status', STATUS_SPEC),
-        (
-            'opcode',
-            {
-                'size': 1,
-                'mapper': lambda x: HCI_LE_APCF_Command.opcode_name(x),
-            },
-        ),
-        ('payload', '*'),
-    ],
-)
-class HCI_LE_APCF_Command(HCI_Command):
-    # pylint: disable=line-too-long
-    '''
-    See https://source.android.com/docs/core/connect/bluetooth/hci_requirements#le_apcf_command
-
-    NOTE: the subcommand-specific payloads are left as opaque byte arrays in this
-    implementation. A future enhancement may define subcommand-specific data structures.
-    '''
-
-    # APCF Subcommands
-    # TODO: use the OpenIntEnum class (when upcoming PR is merged)
-    APCF_ENABLE = 0x00
-    APCF_SET_FILTERING_PARAMETERS = 0x01
-    APCF_BROADCASTER_ADDRESS = 0x02
-    APCF_SERVICE_UUID = 0x03
-    APCF_SERVICE_SOLICITATION_UUID = 0x04
-    APCF_LOCAL_NAME = 0x05
-    APCF_MANUFACTURER_DATA = 0x06
-    APCF_SERVICE_DATA = 0x07
-    APCF_TRANSPORT_DISCOVERY_SERVICE = 0x08
-    APCF_AD_TYPE_FILTER = 0x09
-    APCF_READ_EXTENDED_FEATURES = 0xFF
-
-    OPCODE_NAMES = {
-        APCF_ENABLE: 'APCF_ENABLE',
-        APCF_SET_FILTERING_PARAMETERS: 'APCF_SET_FILTERING_PARAMETERS',
-        APCF_BROADCASTER_ADDRESS: 'APCF_BROADCASTER_ADDRESS',
-        APCF_SERVICE_UUID: 'APCF_SERVICE_UUID',
-        APCF_SERVICE_SOLICITATION_UUID: 'APCF_SERVICE_SOLICITATION_UUID',
-        APCF_LOCAL_NAME: 'APCF_LOCAL_NAME',
-        APCF_MANUFACTURER_DATA: 'APCF_MANUFACTURER_DATA',
-        APCF_SERVICE_DATA: 'APCF_SERVICE_DATA',
-        APCF_TRANSPORT_DISCOVERY_SERVICE: 'APCF_TRANSPORT_DISCOVERY_SERVICE',
-        APCF_AD_TYPE_FILTER: 'APCF_AD_TYPE_FILTER',
-        APCF_READ_EXTENDED_FEATURES: 'APCF_READ_EXTENDED_FEATURES',
-    }
-
-    @classmethod
-    def opcode_name(cls, opcode):
-        return name_or_number(cls.OPCODE_NAMES, opcode)
-
-
-# -----------------------------------------------------------------------------
-@HCI_Command.command(
-    return_parameters_fields=[
-        ('status', STATUS_SPEC),
-        ('total_tx_time_ms', 4),
-        ('total_rx_time_ms', 4),
-        ('total_idle_time_ms', 4),
-        ('total_energy_used', 4),
-    ],
-)
-class HCI_Get_Controller_Activity_Energy_Info_Command(HCI_Command):
-    # pylint: disable=line-too-long
-    '''
-    See https://source.android.com/docs/core/connect/bluetooth/hci_requirements#le_get_controller_activity_energy_info
-    '''
-
-
-# -----------------------------------------------------------------------------
-@HCI_Command.command(
-    fields=[
-        (
-            'opcode',
-            {
-                'size': 1,
-                'mapper': lambda x: HCI_A2DP_Hardware_Offload_Command.opcode_name(x),
-            },
-        ),
-        ('payload', '*'),
-    ],
-    return_parameters_fields=[
-        ('status', STATUS_SPEC),
-        (
-            'opcode',
-            {
-                'size': 1,
-                'mapper': lambda x: HCI_A2DP_Hardware_Offload_Command.opcode_name(x),
-            },
-        ),
-        ('payload', '*'),
-    ],
-)
-class HCI_A2DP_Hardware_Offload_Command(HCI_Command):
-    # pylint: disable=line-too-long
-    '''
-    See https://source.android.com/docs/core/connect/bluetooth/hci_requirements#a2dp-hardware-offload-support
-
-    NOTE: the subcommand-specific payloads are left as opaque byte arrays in this
-    implementation. A future enhancement may define subcommand-specific data structures.
-    '''
-
-    # A2DP Hardware Offload Subcommands
-    # TODO: use the OpenIntEnum class (when upcoming PR is merged)
-    START_A2DP_OFFLOAD = 0x01
-    STOP_A2DP_OFFLOAD = 0x02
-
-    OPCODE_NAMES = {
-        START_A2DP_OFFLOAD: 'START_A2DP_OFFLOAD',
-        STOP_A2DP_OFFLOAD: 'STOP_A2DP_OFFLOAD',
-    }
-
-    @classmethod
-    def opcode_name(cls, opcode):
-        return name_or_number(cls.OPCODE_NAMES, opcode)
-
-
-# -----------------------------------------------------------------------------
-@HCI_Command.command(
-    fields=[
-        (
-            'opcode',
-            {
-                'size': 1,
-                'mapper': lambda x: HCI_Dynamic_Audio_Buffer_Command.opcode_name(x),
-            },
-        ),
-        ('payload', '*'),
-    ],
-    return_parameters_fields=[
-        ('status', STATUS_SPEC),
-        (
-            'opcode',
-            {
-                'size': 1,
-                'mapper': lambda x: HCI_Dynamic_Audio_Buffer_Command.opcode_name(x),
-            },
-        ),
-        ('payload', '*'),
-    ],
-)
-class HCI_Dynamic_Audio_Buffer_Command(HCI_Command):
-    # pylint: disable=line-too-long
-    '''
-    See https://source.android.com/docs/core/connect/bluetooth/hci_requirements#dynamic-audio-buffer-command
-
-    NOTE: the subcommand-specific payloads are left as opaque byte arrays in this
-    implementation. A future enhancement may define subcommand-specific data structures.
-    '''
-
-    # Dynamic Audio Buffer Subcommands
-    # TODO: use the OpenIntEnum class (when upcoming PR is merged)
-    GET_AUDIO_BUFFER_TIME_CAPABILITY = 0x01
-
-    OPCODE_NAMES = {
-        GET_AUDIO_BUFFER_TIME_CAPABILITY: 'GET_AUDIO_BUFFER_TIME_CAPABILITY',
-    }
-
-    @classmethod
-    def opcode_name(cls, opcode):
-        return name_or_number(cls.OPCODE_NAMES, opcode)
-
-
-# -----------------------------------------------------------------------------
-@HCI_Vendor_Event.event(
-    fields=[
-        ('quality_report_id', 1),
-        ('packet_types', 1),
-        ('connection_handle', 2),
-        ('connection_role', {'size': 1, 'mapper': HCI_Constant.role_name}),
-        ('tx_power_level', -1),
-        ('rssi', -1),
-        ('snr', 1),
-        ('unused_afh_channel_count', 1),
-        ('afh_select_unideal_channel_count', 1),
-        ('lsto', 2),
-        ('connection_piconet_clock', 4),
-        ('retransmission_count', 4),
-        ('no_rx_count', 4),
-        ('nak_count', 4),
-        ('last_tx_ack_timestamp', 4),
-        ('flow_off_count', 4),
-        ('last_flow_on_timestamp', 4),
-        ('buffer_overflow_bytes', 4),
-        ('buffer_underflow_bytes', 4),
-        ('bdaddr', Address.parse_address),
-        ('cal_failed_item_count', 1),
-        ('tx_total_packets', 4),
-        ('tx_unacked_packets', 4),
-        ('tx_flushed_packets', 4),
-        ('tx_last_subevent_packets', 4),
-        ('crc_error_packets', 4),
-        ('rx_duplicate_packets', 4),
-        ('vendor_specific_parameters', '*'),
-    ]
-)
-class HCI_Bluetooth_Quality_Report_Event(HCI_Vendor_Event):
-    # pylint: disable=line-too-long
-    '''
-    See https://source.android.com/docs/core/connect/bluetooth/hci_requirements#bluetooth-quality-report-sub-event
-    '''

bumble/vendor/zephyr/hci.py

@@ -1,88 +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 bumble.hci import (
-    hci_vendor_command_op_code,
-    HCI_Command,
-    STATUS_SPEC,
-)
-
-
-# -----------------------------------------------------------------------------
-# Constants
-# -----------------------------------------------------------------------------
-
-# Zephyr RTOS Vendor Specific Commands and Events.
-# Only a subset of the commands are implemented here currently.
-#
-# pylint: disable-next=line-too-long
-# See https://github.com/zephyrproject-rtos/zephyr/blob/main/include/zephyr/bluetooth/hci_vs.h
-HCI_WRITE_TX_POWER_LEVEL_COMMAND = hci_vendor_command_op_code(0x000E)
-HCI_READ_TX_POWER_LEVEL_COMMAND = hci_vendor_command_op_code(0x000F)
-
-HCI_Command.register_commands(globals())
-
-
-# -----------------------------------------------------------------------------
-class TX_Power_Level_Command:
-    '''
-    Base class for read and write TX power level HCI commands
-    '''
-
-    TX_POWER_HANDLE_TYPE_ADV = 0x00
-    TX_POWER_HANDLE_TYPE_SCAN = 0x01
-    TX_POWER_HANDLE_TYPE_CONN = 0x02
-
-
-# -----------------------------------------------------------------------------
-@HCI_Command.command(
-    fields=[('handle_type', 1), ('connection_handle', 2), ('tx_power_level', -1)],
-    return_parameters_fields=[
-        ('status', STATUS_SPEC),
-        ('handle_type', 1),
-        ('connection_handle', 2),
-        ('selected_tx_power_level', -1),
-    ],
-)
-class HCI_Write_Tx_Power_Level_Command(HCI_Command, TX_Power_Level_Command):
-    '''
-    Write TX power level. See BT_HCI_OP_VS_WRITE_TX_POWER_LEVEL in
-    https://github.com/zephyrproject-rtos/zephyr/blob/main/include/zephyr/bluetooth/hci_vs.h
-
-    Power level is in dB. Connection handle for TX_POWER_HANDLE_TYPE_ADV and
-    TX_POWER_HANDLE_TYPE_SCAN should be zero.
-    '''
-
-
-# -----------------------------------------------------------------------------
-@HCI_Command.command(
-    fields=[('handle_type', 1), ('connection_handle', 2)],
-    return_parameters_fields=[
-        ('status', STATUS_SPEC),
-        ('handle_type', 1),
-        ('connection_handle', 2),
-        ('tx_power_level', -1),
-    ],
-)
-class HCI_Read_Tx_Power_Level_Command(HCI_Command, TX_Power_Level_Command):
-    '''
-    Read TX power level. See BT_HCI_OP_VS_READ_TX_POWER_LEVEL in
-    https://github.com/zephyrproject-rtos/zephyr/blob/main/include/zephyr/bluetooth/hci_vs.h
-
-    Power level is in dB. Connection handle for TX_POWER_HANDLE_TYPE_ADV and
-    TX_POWER_HANDLE_TYPE_SCAN should be zero.
-    '''

docs/mkdocs/mkdocs.yml

@@ -10,7 +10,7 @@ nav:
     - Contributing: development/contributing.md
     - Code Style: development/code_style.md
   - Use Cases:
-    - use_cases/index.md
+    - Overview: use_cases/index.md
     - Use Case 1: use_cases/use_case_1.md
     - Use Case 2: use_cases/use_case_2.md
     - Use Case 3: use_cases/use_case_3.md
@@ -23,7 +23,7 @@ nav:
     - GATT: components/gatt.md
     - Security Manager: components/security_manager.md
   - Transports:
-    - transports/index.md
+    - Overview: transports/index.md
     - Serial: transports/serial.md
     - USB: transports/usb.md
     - PTY: transports/pty.md
@@ -37,14 +37,14 @@ nav:
     - Android Emulator: transports/android_emulator.md
     - File: transports/file.md
   - Drivers:
-    - drivers/index.md
+    - Overview: drivers/index.md
     - Realtek: drivers/realtek.md
   - API:
     - Guide: api/guide.md
     - Examples: api/examples.md
     - Reference: api/reference.md
   - Apps & Tools:
-    - apps_and_tools/index.md
+    - Overview: apps_and_tools/index.md
     - Console: apps_and_tools/console.md
     - Bench: apps_and_tools/bench.md
     - Speaker: apps_and_tools/speaker.md
@@ -57,25 +57,15 @@ nav:
     - USB Probe: apps_and_tools/usb_probe.md
     - Link Relay: apps_and_tools/link_relay.md
   - Hardware:
-    - hardware/index.md
+    - Overview: hardware/index.md
   - Platforms:
-    - platforms/index.md
+    - Overview: platforms/index.md
     - macOS: platforms/macos.md
     - Linux: platforms/linux.md
     - Windows: platforms/windows.md
     - Android: platforms/android.md
-    - Zephyr: platforms/zephyr.md
   - Examples:
-    - examples/index.md
-  - Extras:
-    - extras/index.md
-    - Android Remote HCI: extras/android_remote_hci.md
-    - Android BT Bench: extras/android_bt_bench.md
-  - Hive:
-    - hive/index.md
-    - Speaker: hive/web/speaker/speaker.html
-    - Scanner: hive/web/scanner/scanner.html
-    - Heart Rate Monitor: hive/web/heart_rate_monitor/heart_rate_monitor.html
+    - Overview: examples/index.md
 
 copyright: Copyright 2021-2023 Google LLC
 
@@ -84,8 +74,6 @@ theme:
   logo: 'images/logo.png'
   favicon: 'images/favicon.ico'
   custom_dir: 'theme'
-  features:
-    - navigation.indexes
 
 plugins:
   - mkdocstrings:
@@ -110,8 +98,6 @@ markdown_extensions:
   - pymdownx.emoji:
       emoji_index: !!python/name:materialx.emoji.twemoji
       emoji_generator: !!python/name:materialx.emoji.to_svg
-  - pymdownx.tabbed:
-      alternate_style: true
   - codehilite:
       guess_lang: false
   - toc:

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/drivers/index.md

@@ -5,15 +5,6 @@ Some Bluetooth controllers require a driver to function properly.
 This may include, for instance, loading a Firmware image or patch,
 loading a configuration.
 
-By default, drivers will be automatically probed to determine if they should be
-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
-first USB device, even if a normal probe would not have selected it based on the
-USB vendor ID and product ID.
-
 Drivers included in the module are:
 
   * [Realtek](realtek.md): Loading of Firmware and Config for Realtek USB dongles.

docs/mkdocs/src/drivers/realtek.md

@@ -1,16 +1,13 @@
 REALTEK DRIVER
 ==============
 
-This driver supports loading firmware images and optional config data to
+This driver supports loading firmware images and optional config data to 
 USB dongles with a Realtek chipset.
 A number of USB dongles are supported, but likely not all.
-When using a USB dongle, the USB product ID and vendor ID are used
+When using a USB dongle, the USB product ID and manufacturer ID are used
 to find whether a matching set of firmware image and config data
 is needed for that specific model. If a match exists, the driver will try
 load the firmware image and, if needed, config data.
-Alternatively, the metadata property ``driver=rtk`` may be specified in a transport
-name to force that driver to be used (ex: ``usb:[driver=rtk]0`` instead of just
-``usb:0`` for the first USB device).
 The driver will look for those files by name, in order, in:
 
   * The directory specified by the environment variable `BUMBLE_RTK_FIRMWARE_DIR`

docs/mkdocs/src/extras/android_bt_bench.md

@@ -1,64 +0,0 @@
-ANDROID BENCH APP
-=================
-
-This Android app that is compatible with the Bumble `bench` command line app.
-This app can be used to test the throughput and latency between two Android
-devices, or between an Android device and another device running the Bumble
-`bench` app.
-Only the RFComm Client, RFComm Server, L2CAP Client and L2CAP Server modes are
-supported.
-
-Building
---------
-
-You can build the app by running `./gradlew build` (use `gradlew.bat` on Windows) from the `BtBench` top level directory.
-You can also build with Android Studio: open the `BtBench` project. You can build and/or debug from there.
-
-If the build succeeds, you can find the app APKs (debug and release) at:
-
-  * [Release] ``app/build/outputs/apk/release/app-release-unsigned.apk``
-  * [Debug] ``app/build/outputs/apk/debug/app-debug.apk``
-
-
-Running
--------
-
-### Starting the app
-You can start the app from the Android launcher, from Android Studio, or with `adb`
-
-#### Launching from the launcher
-Just tap the app icon on the launcher, check the parameters, and tap
-one of the benchmark action buttons.
-
-#### Launching with `adb`
-Using the `am` command, you can start the activity, and pass it arguments so that you can
-automatically start the benchmark test, and/or set the parameters.
-
-| Parameter Name         | Parameter Type | Description
-|------------------------|----------------|------------
-| autostart              | String         | Benchmark to start. (rfcomm-client, rfcomm-server, l2cap-client or l2cap-server)
-| packet-count           | Integer        | Number of packets to send (rfcomm-client and l2cap-client only)
-| packet-size            | Integer        | Number of bytes per packet (rfcomm-client and l2cap-client only)
-| peer-bluetooth-address | Integer        | Peer Bluetooth address to connect to (rfcomm-client and l2cap-client | only)
-
-
-!!! tip "Launching from adb with auto-start"
-    In this example, we auto-start the Rfcomm Server bench action.
-    ```bash
-    $ adb shell am start -n com.github.google.bumble.btbench/.MainActivity --es autostart rfcomm-server
-    ```
-
-!!! tip "Launching from adb with auto-start and some parameters"
-    In this example, we auto-start the Rfcomm Client bench action, set the packet count to 100,
-    and the packet size to 1024, and connect to DA:4C:10:DE:17:02
-    ```bash
-    $ adb shell am start -n com.github.google.bumble.btbench/.MainActivity --es autostart rfcomm-client --ei packet-count 100 --ei packet-size 1024 --es peer-bluetooth-address DA:4C:10:DE:17:02
-    ```
-
-#### Selecting a Peer Bluetooth Address
-The app's main activity has a "Peer Bluetooth Address" setting where you can change the address.
-
-!!! note "Bluetooth Address for L2CAP vs RFComm"
-    For BLE (L2CAP mode), the address of a device typically changes regularly (it is randomized for privacy), whereas the Bluetooth Classic addresses will remain the same (RFComm mode).
-    If two devices are paired and bonded, then they will each "see" a non-changing address for each other even with BLE (Resolvable Private Address)
-

docs/mkdocs/src/extras/android_remote_hci.md

@@ -1,181 +0,0 @@
-ANDROID REMOTE HCI APP
-======================
-
-This application allows using an android phone's built-in Bluetooth controller with
-a Bumble host stack running outside the phone (typically a development laptop or desktop).
-The app runs an HCI proxy between a TCP socket on the "outside" and the Bluetooth HCI HAL
-on the "inside". (See [this page](https://source.android.com/docs/core/connect/bluetooth) for a high level
-description of the Android Bluetooth HCI HAL).
-The HCI packets received on the TCP socket are forwarded to the phone's controller, and the
-packets coming from the controller are forwarded to the TCP socket.
-
-
-Building
---------
-
-You can build the app by running `./gradlew build` (use `gradlew.bat` on Windows) from the `extras/android/RemoteHCI` top level directory.
-You can also build with Android Studio: open the `RemoteHCI` project. You can build and/or debug from there.
-
-If the build succeeds, you can find the app APKs (debug and release) at:
-
-  * [Release] ``app/build/outputs/apk/release/app-release-unsigned.apk``
-  * [Debug] ``app/build/outputs/apk/debug/app-debug.apk``
-
-
-Running
--------
-
-!!! note
-    In the following examples, it is assumed that shell commands are executed while in the
-    app's root directory, `extras/android/RemoteHCI`. If you are in a different directory,
-    adjust the relative paths accordingly.
-
-### Preconditions
-When the proxy starts (tapping the "Start" button in the app's main activity, or running the proxy
-from an `adb shell` command line), it will try to bind to the Bluetooth HAL.
-This requires that there is no other HAL client, and requires certain privileges.
-For running as a regular app, this requires disabling SELinux temporarily.
-For running as a command-line executable, this just requires a root shell.
-
-#### Root Shell
-!!! tip "Restart `adb` as root"
-    ```bash
-    $ adb root
-    ```
-
-#### Disabling SELinux
-Binding to the Bluetooth HCI HAL requires certain SELinux permissions that can't simply be changed
-on a device without rebuilding its system image. To bypass these restrictions, you will need
-to disable SELinux on your phone (please be aware that this is global, not just for the proxy app,
-so proceed with caution).
-In order to disable SELinux, you need to root the phone (it may be advisable to do this on a
-development phone).
-
-!!! tip "Disabling SELinux Temporarily"
-    Restart `adb` as root:
-    ```bash
-    $ adb root
-    ```
-
-    Then disable SELinux
-    ```bash
-    $ adb shell setenforce 0
-    ```
-
-    Once you're done using the proxy, you can restore SELinux, if you need to, with
-    ```bash
-    $ adb shell setenforce 1
-    ```
-
-    This state will also reset to the normal SELinux enforcement when you reboot.
-
-#### Stopping the bluetooth process
-Since the Bluetooth HAL service can only accept one client, and that in normal conditions
-that client is the Android's bluetooth stack, it is required to first shut down the
-Android bluetooth stack process.
-
-!!! tip "Checking if the Bluetooth process is running"
-    ```bash
-    $ adb shell "ps -A | grep com.google.android.bluetooth"
-    ```
-    If the process is running, you will get a line like:
-    ```
-    bluetooth 10759 876 17455796 136620 do_epoll_wait 0 S com.google.android.bluetooth
-    ```
-    If you don't, it means that the process is not running and you are clear to proceed.
-
-Simply turning Bluetooth off from the phone's settings does not ensure that the bluetooth process will exit.
-If the bluetooth process is still running after toggling Bluetooth off from the settings, you may try enabling
-Airplane Mode, then rebooting. The bluetooth process should, in theory, not restart after the reboot.
-
-!!! tip "Stopping the bluetooth process with adb"
-    ```bash
-    $ adb shell cmd bluetooth_manager disable
-    ```
-
-### Running as a command line app
-
-You push the built APK to a temporary location on the phone's filesystem, then launch the command
-line executable with an `adb shell` command.
-
-!!! tip "Pushing the executable"
-    ```bash
-    $ adb push app/build/outputs/apk/release/app-release-unsigned.apk /data/local/tmp/remotehci.apk
-    ```
-    Do this every time you rebuild. Alternatively, you can push the `debug` APK instead:
-    ```bash
-    $ adb push app/build/outputs/apk/debug/app-debug.apk /data/local/tmp/remotehci.apk
-    ```
-
-!!! tip "Start the proxy from the command line"
-    ```bash
-    adb shell "CLASSPATH=/data/local/tmp/remotehci.apk app_process /system/bin com.github.google.bumble.remotehci.CommandLineInterface"
-    ```
-    This will run the proxy, listening on the default TCP port.
-    If you want a different port, pass it as a command line parameter
-
-!!! tip "Start the proxy from the command line with a specific TCP port"
-    ```bash
-    adb shell "CLASSPATH=/data/local/tmp/remotehci.apk app_process /system/bin com.github.google.bumble.remotehci.CommandLineInterface 12345"
-    ```
-
-### Running as a normal app
-You can start the app from the Android launcher, from Android Studio, or with `adb`
-
-#### Launching from the launcher
-Just tap the app icon on the launcher, check the TCP port that is configured, and tap
-the "Start" button.
-
-#### Launching with `adb`
-Using the `am` command, you can start the activity, and pass it arguments so that you can
-automatically start the proxy, and/or set the port number.
-
-!!! tip "Launching from adb with auto-start"
-    ```bash
-    $ adb shell am start -n com.github.google.bumble.remotehci/.MainActivity --ez autostart true
-    ```
-
-!!! tip "Launching from adb with auto-start and a port"
-    In this example, we auto-start the proxy upon launch, with the port set to 9995
-    ```bash
-    $ adb shell am start -n com.github.google.bumble.remotehci/.MainActivity --ez autostart true --ei port 9995
-    ```
-
-#### Selecting a TCP port
-The RemoteHCI app's main activity has a "TCP Port" setting where you can change the port on
-which the proxy is accepting connections. If the default value isn't suitable, you can
-change it there (you can also use the special value 0 to let the OS assign a port number for you).
-
-### Connecting to the proxy
-To connect the Bumble stack to the proxy, you need to be able to reach the phone's network
-stack. This can be done over the phone's WiFi connection, or, alternatively, using an `adb`
-TCP forward (which should be faster than over WiFi).
-
-!!! tip "Forwarding TCP with `adb`"
-    To connect to the proxy via an `adb` TCP forward, use:
-    ```bash
-    $ adb forward tcp:<outside-port> tcp:<inside-port>
-    ```
-    Where ``<outside-port>`` is the port number for a listening socket on your laptop or
-    desktop machine, and <inside-port> is the TCP port selected in the app's user interface.
-    Those two ports may be the same, of course.
-    For example, with the default TCP port 9993:
-    ```bash
-    $ adb forward tcp:9993 tcp:9993
-    ```
-
-Once you've ensured that you can reach the proxy's TCP port on the phone, either directly or
-via an `adb` forward, you can then use it as a Bumble transport, using the transport name:
-``tcp-client:<host>:<port>`` syntax.
-
-!!! example "Connecting a Bumble client"
-    Connecting the `bumble-controller-info` app to the phone's controller.
-    Assuming you have set up an `adb` forward on port 9993:
-    ```bash
-    $ bumble-controller-info tcp-client:localhost:9993
-    ```
-
-    Or over WiFi with, in this example, the IP address of the phone being ```192.168.86.27```
-    ```bash
-    $ bumble-controller-info tcp-client:192.168.86.27:9993
-    ```

docs/mkdocs/src/extras/index.md

@@ -1,19 +0,0 @@
-EXTRAS
-======
-
-A collection of add-ons, apps and tools, to the Bumble project.
-
-Android Remote HCI
-------------------
-
-Allows using an Android phone's built-in Bluetooth controller with a Bumble
-stack running on a development machine.
-See [Android Remote HCI](android_remote_hci.md) for details.
-
-Android BT Bench
-----------------
-
-An Android app that is compatible with the Bumble `bench` command line app.
-This app can be used to test the throughput and latency between two Android
-devices, or between an Android device and another device running the Bumble
-`bench` app.

docs/mkdocs/src/hardware/index.md

@@ -3,7 +3,7 @@ HARDWARE
 
 The Bumble Host connects to a controller over an [HCI Transport](../transports/index.md).
 To use a hardware controller attached to the host on which the host application is running, the transport is typically either [HCI over UART](../transports/serial.md) or [HCI over USB](../transports/usb.md).
-On Linux, the [VHCI Transport](../transports/vhci.md) can be used to communicate with any controller hardware managed by the operating system. Alternatively, a remote controller (a phyiscal controller attached to a remote host) can be used by connecting one of the networked transports (such as the [TCP Client transport](../transports/tcp_client.md), the [TCP Server transport](../transports/tcp_server.md) or the [UDP Transport](../transports/udp.md)) to an [HCI Bridge](../apps_and_tools/hci_bridge.md) bridging the network transport to a physical controller on a remote host.
+On Linux, the [VHCI Transport](../transports/vhci.md) can be used to communicate with any controller hardware managed by the operating system. Alternatively, a remote controller (a phyiscal controller attached to a remote host) can be used by connecting one of the networked transports (such as the [TCP Client transport](../transports/tcp_client.md), the [TCP Server transport](../transports/tcp_server.md) or the [UDP Transport](../transports/udp.md)) to an [HCI Bridge](../apps_and_tools/hci_bridge) bridging the network transport to a physical controller on a remote host.
 
 In theory, any controller that is compliant with the HCI over UART or HCI over USB protocols can be used.
 

docs/mkdocs/src/hive/index.md

@@ -1,59 +0,0 @@
-HIVE
-====
-
-Welcome to the Bumble Hive.
-This is a collection of apps and virtual devices that can run entirely in a browser page.
-The code for the apps and devices, as well as the Bumble runtime code, runs via [Pyodide](https://pyodide.org/).
-Pyodide is a Python distribution for the browser and Node.js based on WebAssembly.
-
-The Bumble stack uses a WebSocket to exchange HCI packets with a virtual or physical
-Bluetooth controller.
-
-The apps and devices in the hive can be accessed by following the links below. Each
-page has a settings button that may be used to configure the WebSocket URL to use for
-the virtual HCI connection. This will typically be the WebSocket URL for a `netsim`
-daemon.
-There is also a [TOML index](index.toml) that can be used by tools to know at which URL to access
-each of the apps and devices, as well as their names and short descriptions.
-
-!!! tip "Using `netsim`"
-    When the `netsimd` daemon is running (for example when using the Android Emulator that
-    is included in Android Studio), the daemon listens for connections on a TCP port.
-    To find out what this TCP port is, you can read the `netsim.ini` file that `netsimd`
-    creates, it includes a line with `web.port=<tcp-port>` (for example `web.port=7681`).
-    The location of the `netsim.ini` file is platform-specific.
-
-    === "macOS"
-        On macOS, the directory where `netsim.ini` is stored is $TMPDIR
-        ```bash
-            $ cat $TMPDIR/netsim.ini
-        ```
-
-    === "Linux"
-        On Linux, the directory where `netsim.ini` is stored is $XDG_RUNTIME_DIR
-        ```bash
-            $ cat $XDG_RUNTIME_DIR/netsim.ini
-        ```
-
-
-!!! tip "Using a local radio"
-    You can connect the hive virtual apps and devices to a local Bluetooth radio, like,
-    for example, a USB dongle.
-    For that, you need to run a local HCI bridge to bridge a local HCI device to a WebSocket
-    that a web page can connect to.
-    Use the `bumble-hci-bridge` app, with the host transport set to a WebSocket server on an
-    available port (ex: `ws-server:_:7682`) and the controller transport set to the transport
-    name for the radio you want to use (ex: `usb:0` for the first USB dongle)
-
-
-Applications
-------------
-
-  * [Scanner](web/scanner/scanner.html) - Scans for BLE devices.
-
-Virtual Devices
----------------
-
-  * [Speaker](web/speaker/speaker.html) - Virtual speaker that plays audio in a browser page.
-  * [Heart Rate Monitor](web/heart_rate_monitor/heart_rate_monitor.html) - Virtual heart rate monitor.
-

docs/mkdocs/src/hive/index.toml

@@ -1,21 +0,0 @@
-version = "1.0.0"
-base_url = "https://google.github.io/bumble/hive/web"
-default_hci_query_param = "hci"
-
-[[index]]
-name = "speaker"
-description = "Bumble Virtual Speaker"
-type = "Device"
-url = "speaker/speaker.html"
-
-[[index]]
-name = "scanner"
-description = "Simple Scanner Application"
-type = "Application"
-url = "scanner/scanner.html"
-
-[[index]]
-name = "heart-rate-monitor"
-description = "Virtual Heart Rate Monitor"
-type = "Device"
-url = "heart_rate_monitor/heart_rate_monitor.html"

docs/mkdocs/src/hive/web/bumble.js

@@ -1 +0,0 @@
-../../../../../web/bumble.js

docs/mkdocs/src/hive/web/heart_rate_monitor/heart_rate_monitor.html

@@ -1 +0,0 @@
-../../../../../../web/heart_rate_monitor/heart_rate_monitor.html

docs/mkdocs/src/hive/web/heart_rate_monitor/heart_rate_monitor.js

@@ -1 +0,0 @@
-../../../../../../web/heart_rate_monitor/heart_rate_monitor.js

docs/mkdocs/src/hive/web/heart_rate_monitor/heart_rate_monitor.py

@@ -1 +0,0 @@
-../../../../../../web/heart_rate_monitor/heart_rate_monitor.py

docs/mkdocs/src/hive/web/scanner/scanner.css

@@ -1 +0,0 @@
-../../../../../../web/scanner/scanner.css

docs/mkdocs/src/hive/web/scanner/scanner.html

@@ -1 +0,0 @@
-../../../../../../web/scanner/scanner.html

docs/mkdocs/src/hive/web/scanner/scanner.js

@@ -1 +0,0 @@
-../../../../../../web/scanner/scanner.js

docs/mkdocs/src/hive/web/scanner/scanner.py

@@ -1 +0,0 @@
-../../../../../../web/scanner/scanner.py

docs/mkdocs/src/hive/web/speaker/logo.svg

@@ -1 +0,0 @@
-../../../../../../web/speaker/logo.svg

docs/mkdocs/src/hive/web/speaker/speaker.css

@@ -1 +0,0 @@
-../../../../../../web/speaker/speaker.css

docs/mkdocs/src/hive/web/speaker/speaker.html

@@ -1 +0,0 @@
-../../../../../../web/speaker/speaker.html

docs/mkdocs/src/hive/web/speaker/speaker.js

@@ -1 +0,0 @@
-../../../../../../web/speaker/speaker.js

docs/mkdocs/src/hive/web/speaker/speaker.py

@@ -1 +0,0 @@
-../../../../../../web/speaker/speaker.py

docs/mkdocs/src/hive/web/ui.js

@@ -1 +0,0 @@
-../../../../../web/ui.js