add pyee group util

.devcontainer/devcontainer.json

@@ -1,30 +0,0 @@
-// For format details, see https://aka.ms/devcontainer.json. For config options, see the
-// README at: https://github.com/devcontainers/templates/tree/main/src/python
-{
-	// Or use a Dockerfile or Docker Compose file. More info: https://containers.dev/guide/dockerfile
-    "image": "mcr.microsoft.com/devcontainers/universal:2",
-
-	// Features to add to the dev container. More info: https://containers.dev/features.
-	// "features": {},
-
-	// Use 'forwardPorts' to make a list of ports inside the container available locally.
-	// "forwardPorts": [],
-
-	// Use 'postCreateCommand' to run commands after the container is created.
-    "postCreateCommand": 
-        "python -m pip install '.[build,test,development,documentation]'",
-
-    // Configure tool-specific properties.
-    "customizations": {
-        // Configure properties specific to VS Code.
-        "vscode": {
-            // Add the IDs of extensions you want installed when the container is created.
-            "extensions": [
-                "ms-python.python"
-            ]
-        }
-    }
-
-	// Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root.
-	// "remoteUser": "root"
-}

.github/workflows/code-check.yml

@@ -16,7 +16,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12"]
+        python-version: ["3.8", "3.9", "3.10", "3.11"]
       fail-fast: false
 
     steps:
@@ -29,11 +29,11 @@ jobs:
     - name: Set up Python
       uses: actions/setup-python@v3
       with:
-        python-version: ${{ matrix.python-version }}
+        python-version: '3.10'
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
-        python -m pip install ".[build,test,development,pandora]"
+        python -m pip install ".[build,test,development]"
     - name: Check
       run: |
         invoke project.pre-commit

.github/workflows/python-avatar.yml

@@ -1,50 +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,pandora]
-      - 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
-        if: always()
-        run: cat rootcanal.log
-      - name: Upload Mobly logs
-        if: always()
-        uses: actions/upload-artifact@v3
-        with:
-          name: mobly-logs
-          path: /tmp/logs/mobly/bumble.bumbles/

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

@@ -16,7 +16,7 @@ jobs:
     strategy:
       matrix:
         os: ['ubuntu-latest', 'macos-latest', 'windows-latest']
-        python-version: ["3.8", "3.9", "3.10", "3.11", "3.12"]
+        python-version: ["3.8", "3.9", "3.10", "3.11"]
       fail-fast: false
 
     steps:
@@ -46,8 +46,8 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        python-version: [ "3.8", "3.9", "3.10", "3.11", "3.12" ]
-        rust-version: [ "1.76.0", "stable" ]
+        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
@@ -56,7 +56,7 @@ jobs:
         uses: actions/setup-python@v4
         with:
           python-version: ${{ matrix.python-version }}
-      - name: Install Python dependencies
+      - name: Install dependencies
         run: |
           python -m pip install --upgrade pip
           python -m pip install ".[build,test,development,documentation]"
@@ -65,17 +65,13 @@ jobs:
         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
+        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
+        run: cd rust && cargo test
       # 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

.gitignore

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

.vscode/settings.json

@@ -1,7 +1,6 @@
 {
     "cSpell.words": [
         "Abortable",
-        "aiohttp",
         "altsetting",
         "ansiblue",
         "ansicyan",
@@ -10,13 +9,10 @@
         "ansired",
         "ansiyellow",
         "appendleft",
-        "ascs",
         "ASHA",
         "asyncio",
         "ATRAC",
-        "avctp",
         "avdtp",
-        "avrcp",
         "bitpool",
         "bitstruct",
         "BSCP",
@@ -25,10 +21,7 @@
         "cccds",
         "cmac",
         "CONNECTIONLESS",
-        "csip",
-        "csis",
         "csrcs",
-        "CVSD",
         "datagram",
         "DATALINK",
         "delayreport",
@@ -36,8 +29,6 @@
         "deregistration",
         "dhkey",
         "diversifier",
-        "endianness",
-        "ESCO",
         "Fitbit",
         "GATTLINK",
         "HANDSFREE",
@@ -45,21 +36,15 @@
         "keyup",
         "levelname",
         "libc",
-        "liblc",
         "libusb",
         "MITM",
-        "MSBC",
         "NDIS",
-        "netsim",
         "NONBLOCK",
         "NONCONN",
         "OXIMETER",
         "popleft",
-        "PRAND",
-        "protobuf",
         "psms",
         "pyee",
-        "Pyodide",
         "pyusb",
         "rfcomm",
         "ROHC",
@@ -67,7 +52,6 @@
         "SEID",
         "seids",
         "SERV",
-        "SIRK",
         "ssrc",
         "strerror",
         "subband",
@@ -77,11 +61,8 @@
         "substates",
         "tobytes",
         "tsep",
-        "UNMUTE",
-        "unmuted",
         "usbmodem",
         "vhci",
-        "wasmtime",
         "websockets",
         "xcursor",
         "ycursor"

apps/auracast.py

@@ -1,692 +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
-# -----------------------------------------------------------------------------
-from __future__ import annotations
-import asyncio
-import contextlib
-import dataclasses
-import logging
-import os
-from typing import cast, Any, AsyncGenerator, Coroutine, Dict, Optional, Tuple
-
-import click
-import pyee
-
-from bumble.colors import color
-import bumble.company_ids
-import bumble.core
-import bumble.device
-import bumble.gatt
-import bumble.hci
-import bumble.profiles.bap
-import bumble.profiles.bass
-import bumble.profiles.pbp
-import bumble.transport
-import bumble.utils
-
-
-# -----------------------------------------------------------------------------
-# Logging
-# -----------------------------------------------------------------------------
-logger = logging.getLogger(__name__)
-
-
-# -----------------------------------------------------------------------------
-# Constants
-# -----------------------------------------------------------------------------
-AURACAST_DEFAULT_DEVICE_NAME = 'Bumble Auracast'
-AURACAST_DEFAULT_DEVICE_ADDRESS = bumble.hci.Address('F0:F1:F2:F3:F4:F5')
-AURACAST_DEFAULT_SYNC_TIMEOUT = 5.0
-AURACAST_DEFAULT_ATT_MTU = 256
-
-
-# -----------------------------------------------------------------------------
-# Scan For Broadcasts
-# -----------------------------------------------------------------------------
-class BroadcastScanner(pyee.EventEmitter):
-    @dataclasses.dataclass
-    class Broadcast(pyee.EventEmitter):
-        name: str
-        sync: bumble.device.PeriodicAdvertisingSync
-        rssi: int = 0
-        public_broadcast_announcement: Optional[
-            bumble.profiles.pbp.PublicBroadcastAnnouncement
-        ] = None
-        broadcast_audio_announcement: Optional[
-            bumble.profiles.bap.BroadcastAudioAnnouncement
-        ] = None
-        basic_audio_announcement: Optional[
-            bumble.profiles.bap.BasicAudioAnnouncement
-        ] = None
-        appearance: Optional[bumble.core.Appearance] = None
-        biginfo: Optional[bumble.device.BIGInfoAdvertisement] = None
-        manufacturer_data: Optional[Tuple[str, bytes]] = None
-
-        def __post_init__(self) -> None:
-            super().__init__()
-            self.sync.on('establishment', self.on_sync_establishment)
-            self.sync.on('loss', self.on_sync_loss)
-            self.sync.on('periodic_advertisement', self.on_periodic_advertisement)
-            self.sync.on('biginfo_advertisement', self.on_biginfo_advertisement)
-
-        def update(self, advertisement: bumble.device.Advertisement) -> None:
-            self.rssi = advertisement.rssi
-            for service_data in advertisement.data.get_all(
-                bumble.core.AdvertisingData.SERVICE_DATA
-            ):
-                assert isinstance(service_data, tuple)
-                service_uuid, data = service_data
-                assert isinstance(data, bytes)
-
-                if (
-                    service_uuid
-                    == bumble.gatt.GATT_PUBLIC_BROADCAST_ANNOUNCEMENT_SERVICE
-                ):
-                    self.public_broadcast_announcement = (
-                        bumble.profiles.pbp.PublicBroadcastAnnouncement.from_bytes(data)
-                    )
-                    continue
-
-                if (
-                    service_uuid
-                    == bumble.gatt.GATT_BROADCAST_AUDIO_ANNOUNCEMENT_SERVICE
-                ):
-                    self.broadcast_audio_announcement = (
-                        bumble.profiles.bap.BroadcastAudioAnnouncement.from_bytes(data)
-                    )
-                    continue
-
-            self.appearance = advertisement.data.get(  # type: ignore[assignment]
-                bumble.core.AdvertisingData.APPEARANCE
-            )
-
-            if manufacturer_data := advertisement.data.get(
-                bumble.core.AdvertisingData.MANUFACTURER_SPECIFIC_DATA
-            ):
-                assert isinstance(manufacturer_data, tuple)
-                company_id = cast(int, manufacturer_data[0])
-                data = cast(bytes, manufacturer_data[1])
-                self.manufacturer_data = (
-                    bumble.company_ids.COMPANY_IDENTIFIERS.get(
-                        company_id, f'0x{company_id:04X}'
-                    ),
-                    data,
-                )
-
-            self.emit('update')
-
-        def print(self) -> None:
-            print(
-                color('Broadcast:', 'yellow'),
-                self.sync.advertiser_address,
-                color(self.sync.state.name, 'green'),
-            )
-            print(f'  {color("Name", "cyan")}:         {self.name}')
-            if self.appearance:
-                print(f'  {color("Appearance", "cyan")}:   {str(self.appearance)}')
-            print(f'  {color("RSSI", "cyan")}:         {self.rssi}')
-            print(f'  {color("SID", "cyan")}:          {self.sync.sid}')
-
-            if self.manufacturer_data:
-                print(
-                    f'  {color("Manufacturer Data", "cyan")}: '
-                    f'{self.manufacturer_data[0]} -> {self.manufacturer_data[1].hex()}'
-                )
-
-            if self.broadcast_audio_announcement:
-                print(
-                    f'  {color("Broadcast ID", "cyan")}: '
-                    f'{self.broadcast_audio_announcement.broadcast_id}'
-                )
-
-            if self.public_broadcast_announcement:
-                print(
-                    f'  {color("Features", "cyan")}:     '
-                    f'{self.public_broadcast_announcement.features}'
-                )
-                print(
-                    f'  {color("Metadata", "cyan")}:     '
-                    f'{self.public_broadcast_announcement.metadata}'
-                )
-
-            if self.basic_audio_announcement:
-                print(color('  Audio:', 'cyan'))
-                print(
-                    color('    Presentation Delay:', 'magenta'),
-                    self.basic_audio_announcement.presentation_delay,
-                )
-                for subgroup in self.basic_audio_announcement.subgroups:
-                    print(color('    Subgroup:', 'magenta'))
-                    print(color('      Codec ID:', 'yellow'))
-                    print(
-                        color('        Coding Format:           ', 'green'),
-                        subgroup.codec_id.coding_format.name,
-                    )
-                    print(
-                        color('        Company ID:              ', 'green'),
-                        subgroup.codec_id.company_id,
-                    )
-                    print(
-                        color('        Vendor Specific Codec ID:', 'green'),
-                        subgroup.codec_id.vendor_specific_codec_id,
-                    )
-                    print(
-                        color('      Codec Config:', 'yellow'),
-                        subgroup.codec_specific_configuration,
-                    )
-                    print(color('      Metadata:    ', 'yellow'), subgroup.metadata)
-
-                    for bis in subgroup.bis:
-                        print(color(f'      BIS [{bis.index}]:', 'yellow'))
-                        print(
-                            color('       Codec Config:', 'green'),
-                            bis.codec_specific_configuration,
-                        )
-
-            if self.biginfo:
-                print(color('  BIG:', 'cyan'))
-                print(
-                    color('    Number of BIS:', 'magenta'),
-                    self.biginfo.num_bis,
-                )
-                print(
-                    color('    PHY:          ', 'magenta'),
-                    self.biginfo.phy.name,
-                )
-                print(
-                    color('    Framed:       ', 'magenta'),
-                    self.biginfo.framed,
-                )
-                print(
-                    color('    Encrypted:    ', 'magenta'),
-                    self.biginfo.encrypted,
-                )
-
-        def on_sync_establishment(self) -> None:
-            self.emit('sync_establishment')
-
-        def on_sync_loss(self) -> None:
-            self.basic_audio_announcement = None
-            self.biginfo = None
-            self.emit('sync_loss')
-
-        def on_periodic_advertisement(
-            self, advertisement: bumble.device.PeriodicAdvertisement
-        ) -> None:
-            if advertisement.data is None:
-                return
-
-            for service_data in advertisement.data.get_all(
-                bumble.core.AdvertisingData.SERVICE_DATA
-            ):
-                assert isinstance(service_data, tuple)
-                service_uuid, data = service_data
-                assert isinstance(data, bytes)
-
-                if service_uuid == bumble.gatt.GATT_BASIC_AUDIO_ANNOUNCEMENT_SERVICE:
-                    self.basic_audio_announcement = (
-                        bumble.profiles.bap.BasicAudioAnnouncement.from_bytes(data)
-                    )
-                    break
-
-            self.emit('change')
-
-        def on_biginfo_advertisement(
-            self, advertisement: bumble.device.BIGInfoAdvertisement
-        ) -> None:
-            self.biginfo = advertisement
-            self.emit('change')
-
-    def __init__(
-        self,
-        device: bumble.device.Device,
-        filter_duplicates: bool,
-        sync_timeout: float,
-    ):
-        super().__init__()
-        self.device = device
-        self.filter_duplicates = filter_duplicates
-        self.sync_timeout = sync_timeout
-        self.broadcasts: Dict[bumble.hci.Address, BroadcastScanner.Broadcast] = {}
-        device.on('advertisement', self.on_advertisement)
-
-    async def start(self) -> None:
-        await self.device.start_scanning(
-            active=False,
-            filter_duplicates=False,
-        )
-
-    async def stop(self) -> None:
-        await self.device.stop_scanning()
-
-    def on_advertisement(self, advertisement: bumble.device.Advertisement) -> None:
-        if (
-            broadcast_name := advertisement.data.get(
-                bumble.core.AdvertisingData.BROADCAST_NAME
-            )
-        ) is None:
-            return
-        assert isinstance(broadcast_name, str)
-
-        if broadcast := self.broadcasts.get(advertisement.address):
-            broadcast.update(advertisement)
-            return
-
-        bumble.utils.AsyncRunner.spawn(
-            self.on_new_broadcast(broadcast_name, advertisement)
-        )
-
-    async def on_new_broadcast(
-        self, name: str, advertisement: bumble.device.Advertisement
-    ) -> None:
-        periodic_advertising_sync = await self.device.create_periodic_advertising_sync(
-            advertiser_address=advertisement.address,
-            sid=advertisement.sid,
-            sync_timeout=self.sync_timeout,
-            filter_duplicates=self.filter_duplicates,
-        )
-        broadcast = self.Broadcast(
-            name,
-            periodic_advertising_sync,
-        )
-        broadcast.update(advertisement)
-        self.broadcasts[advertisement.address] = broadcast
-        periodic_advertising_sync.on('loss', lambda: self.on_broadcast_loss(broadcast))
-        self.emit('new_broadcast', broadcast)
-
-    def on_broadcast_loss(self, broadcast: Broadcast) -> None:
-        del self.broadcasts[broadcast.sync.advertiser_address]
-        bumble.utils.AsyncRunner.spawn(broadcast.sync.terminate())
-        self.emit('broadcast_loss', broadcast)
-
-
-class PrintingBroadcastScanner:
-    def __init__(
-        self, device: bumble.device.Device, filter_duplicates: bool, sync_timeout: float
-    ) -> None:
-        self.scanner = BroadcastScanner(device, filter_duplicates, sync_timeout)
-        self.scanner.on('new_broadcast', self.on_new_broadcast)
-        self.scanner.on('broadcast_loss', self.on_broadcast_loss)
-        self.scanner.on('update', self.refresh)
-        self.status_message = ''
-
-    async def start(self) -> None:
-        self.status_message = color('Scanning...', 'green')
-        await self.scanner.start()
-
-    def on_new_broadcast(self, broadcast: BroadcastScanner.Broadcast) -> None:
-        self.status_message = color(
-            f'+Found {len(self.scanner.broadcasts)} broadcasts', 'green'
-        )
-        broadcast.on('change', self.refresh)
-        broadcast.on('update', self.refresh)
-        self.refresh()
-
-    def on_broadcast_loss(self, broadcast: BroadcastScanner.Broadcast) -> None:
-        self.status_message = color(
-            f'-Found {len(self.scanner.broadcasts)} broadcasts', 'green'
-        )
-        self.refresh()
-
-    def refresh(self) -> None:
-        # Clear the screen from the top
-        print('\033[H')
-        print('\033[0J')
-        print('\033[H')
-
-        # Print the status message
-        print(self.status_message)
-        print("==========================================")
-
-        # Print all broadcasts
-        for broadcast in self.scanner.broadcasts.values():
-            broadcast.print()
-            print('------------------------------------------')
-
-        # Clear the screen to the bottom
-        print('\033[0J')
-
-
-@contextlib.asynccontextmanager
-async def create_device(transport: str) -> AsyncGenerator[bumble.device.Device, Any]:
-    async with await bumble.transport.open_transport(transport) as (
-        hci_source,
-        hci_sink,
-    ):
-        device_config = bumble.device.DeviceConfiguration(
-            name=AURACAST_DEFAULT_DEVICE_NAME,
-            address=AURACAST_DEFAULT_DEVICE_ADDRESS,
-            keystore='JsonKeyStore',
-        )
-
-        device = bumble.device.Device.from_config_with_hci(
-            device_config,
-            hci_source,
-            hci_sink,
-        )
-        await device.power_on()
-
-        yield device
-
-
-async def find_broadcast_by_name(
-    device: bumble.device.Device, name: Optional[str]
-) -> BroadcastScanner.Broadcast:
-    result = asyncio.get_running_loop().create_future()
-
-    def on_broadcast_change(broadcast: BroadcastScanner.Broadcast) -> None:
-        if broadcast.basic_audio_announcement and not result.done():
-            print(color('Broadcast basic audio announcement received', 'green'))
-            result.set_result(broadcast)
-
-    def on_new_broadcast(broadcast: BroadcastScanner.Broadcast) -> None:
-        if name is None or broadcast.name == name:
-            print(color('Broadcast found:', 'green'), broadcast.name)
-            broadcast.on('change', lambda: on_broadcast_change(broadcast))
-            return
-
-        print(color(f'Skipping broadcast {broadcast.name}'))
-
-    scanner = BroadcastScanner(device, False, AURACAST_DEFAULT_SYNC_TIMEOUT)
-    scanner.on('new_broadcast', on_new_broadcast)
-    await scanner.start()
-
-    broadcast = await result
-    await scanner.stop()
-
-    return broadcast
-
-
-async def run_scan(
-    filter_duplicates: bool, sync_timeout: float, transport: str
-) -> None:
-    async with create_device(transport) as device:
-        if not device.supports_le_periodic_advertising:
-            print(color('Periodic advertising not supported', 'red'))
-            return
-
-        scanner = PrintingBroadcastScanner(device, filter_duplicates, sync_timeout)
-        await scanner.start()
-        await asyncio.get_running_loop().create_future()
-
-
-async def run_assist(
-    broadcast_name: Optional[str],
-    source_id: Optional[int],
-    command: str,
-    transport: str,
-    address: str,
-) -> None:
-    async with create_device(transport) as device:
-        if not device.supports_le_periodic_advertising:
-            print(color('Periodic advertising not supported', 'red'))
-            return
-
-        # Connect to the server
-        print(f'=== Connecting to {address}...')
-        connection = await device.connect(address)
-        peer = bumble.device.Peer(connection)
-        print(f'=== Connected to {peer}')
-
-        print("+++ Encrypting connection...")
-        await peer.connection.encrypt()
-        print("+++ Connection encrypted")
-
-        # Request a larger MTU
-        mtu = AURACAST_DEFAULT_ATT_MTU
-        print(color(f'$$$ Requesting MTU={mtu}', 'yellow'))
-        await peer.request_mtu(mtu)
-
-        # Get the BASS service
-        bass = await peer.discover_service_and_create_proxy(
-            bumble.profiles.bass.BroadcastAudioScanServiceProxy
-        )
-
-        # Check that the service was found
-        if not bass:
-            print(color('!!! Broadcast Audio Scan Service not found', 'red'))
-            return
-
-        # Subscribe to and read the broadcast receive state characteristics
-        for i, broadcast_receive_state in enumerate(bass.broadcast_receive_states):
-            try:
-                await broadcast_receive_state.subscribe(
-                    lambda value, i=i: print(
-                        f"{color(f'Broadcast Receive State Update [{i}]:', 'green')} {value}"
-                    )
-                )
-            except bumble.core.ProtocolError as error:
-                print(
-                    color(
-                        f'!!! Failed to subscribe to Broadcast Receive State characteristic:',
-                        'red',
-                    ),
-                    error,
-                )
-            value = await broadcast_receive_state.read_value()
-            print(
-                f'{color(f"Initial Broadcast Receive State [{i}]:", "green")} {value}'
-            )
-
-        if command == 'monitor-state':
-            await peer.sustain()
-            return
-
-        if command == 'add-source':
-            # Find the requested broadcast
-            await bass.remote_scan_started()
-            if broadcast_name:
-                print(color('Scanning for broadcast:', 'cyan'), broadcast_name)
-            else:
-                print(color('Scanning for any broadcast', 'cyan'))
-            broadcast = await find_broadcast_by_name(device, broadcast_name)
-
-            if broadcast.broadcast_audio_announcement is None:
-                print(color('No broadcast audio announcement found', 'red'))
-                return
-
-            if (
-                broadcast.basic_audio_announcement is None
-                or not broadcast.basic_audio_announcement.subgroups
-            ):
-                print(color('No subgroups found', 'red'))
-                return
-
-            # Add the source
-            print(color('Adding source:', 'blue'), broadcast.sync.advertiser_address)
-            await bass.add_source(
-                broadcast.sync.advertiser_address,
-                broadcast.sync.sid,
-                broadcast.broadcast_audio_announcement.broadcast_id,
-                bumble.profiles.bass.PeriodicAdvertisingSyncParams.SYNCHRONIZE_TO_PA_PAST_AVAILABLE,
-                0xFFFF,
-                [
-                    bumble.profiles.bass.SubgroupInfo(
-                        bumble.profiles.bass.SubgroupInfo.ANY_BIS,
-                        bytes(broadcast.basic_audio_announcement.subgroups[0].metadata),
-                    )
-                ],
-            )
-
-            # Initiate a PA Sync Transfer
-            await broadcast.sync.transfer(peer.connection)
-
-            # Notify the sink that we're done scanning.
-            await bass.remote_scan_stopped()
-
-            await peer.sustain()
-            return
-
-        if command == 'modify-source':
-            if source_id is None:
-                print(color('!!! modify-source requires --source-id'))
-                return
-
-            # Find the requested broadcast
-            await bass.remote_scan_started()
-            if broadcast_name:
-                print(color('Scanning for broadcast:', 'cyan'), broadcast_name)
-            else:
-                print(color('Scanning for any broadcast', 'cyan'))
-            broadcast = await find_broadcast_by_name(device, broadcast_name)
-
-            if broadcast.broadcast_audio_announcement is None:
-                print(color('No broadcast audio announcement found', 'red'))
-                return
-
-            if (
-                broadcast.basic_audio_announcement is None
-                or not broadcast.basic_audio_announcement.subgroups
-            ):
-                print(color('No subgroups found', 'red'))
-                return
-
-            # Modify the source
-            print(
-                color('Modifying source:', 'blue'),
-                source_id,
-            )
-            await bass.modify_source(
-                source_id,
-                bumble.profiles.bass.PeriodicAdvertisingSyncParams.SYNCHRONIZE_TO_PA_PAST_NOT_AVAILABLE,
-                0xFFFF,
-                [
-                    bumble.profiles.bass.SubgroupInfo(
-                        bumble.profiles.bass.SubgroupInfo.ANY_BIS,
-                        bytes(broadcast.basic_audio_announcement.subgroups[0].metadata),
-                    )
-                ],
-            )
-            await peer.sustain()
-            return
-
-        if command == 'remove-source':
-            if source_id is None:
-                print(color('!!! remove-source requires --source-id'))
-                return
-
-            # Remove the source
-            print(color('Removing source:', 'blue'), source_id)
-            await bass.remove_source(source_id)
-            await peer.sustain()
-            return
-
-        print(color(f'!!! invalid command {command}'))
-
-
-async def run_pair(transport: str, address: str) -> None:
-    async with create_device(transport) as device:
-
-        # Connect to the server
-        print(f'=== Connecting to {address}...')
-        async with device.connect_as_gatt(address) as peer:
-            print(f'=== Connected to {peer}')
-
-            print("+++ Initiating pairing...")
-            await peer.connection.pair()
-            print("+++ Paired")
-
-
-def run_async(async_command: Coroutine) -> None:
-    try:
-        asyncio.run(async_command)
-    except bumble.core.ProtocolError as error:
-        if error.error_namespace == 'att' and error.error_code in list(
-            bumble.profiles.bass.ApplicationError
-        ):
-            message = bumble.profiles.bass.ApplicationError(error.error_code).name
-        else:
-            message = str(error)
-
-        print(
-            color('!!! An error occurred while executing the command:', 'red'), message
-        )
-
-
-# -----------------------------------------------------------------------------
-# Main
-# -----------------------------------------------------------------------------
-@click.group()
-@click.pass_context
-def auracast(
-    ctx,
-):
-    ctx.ensure_object(dict)
-
-
-@auracast.command('scan')
-@click.option(
-    '--filter-duplicates', is_flag=True, default=False, help='Filter duplicates'
-)
-@click.option(
-    '--sync-timeout',
-    metavar='SYNC_TIMEOUT',
-    type=float,
-    default=AURACAST_DEFAULT_SYNC_TIMEOUT,
-    help='Sync timeout (in seconds)',
-)
-@click.argument('transport')
-@click.pass_context
-def scan(ctx, filter_duplicates, sync_timeout, transport):
-    """Scan for public broadcasts"""
-    run_async(run_scan(filter_duplicates, sync_timeout, transport))
-
-
-@auracast.command('assist')
-@click.option(
-    '--broadcast-name',
-    metavar='BROADCAST_NAME',
-    help='Broadcast Name to tune to',
-)
-@click.option(
-    '--source-id',
-    metavar='SOURCE_ID',
-    type=int,
-    help='Source ID (for remove-source command)',
-)
-@click.option(
-    '--command',
-    type=click.Choice(
-        ['monitor-state', 'add-source', 'modify-source', 'remove-source']
-    ),
-    required=True,
-)
-@click.argument('transport')
-@click.argument('address')
-@click.pass_context
-def assist(ctx, broadcast_name, source_id, command, transport, address):
-    """Scan for broadcasts on behalf of a audio server"""
-    run_async(run_assist(broadcast_name, source_id, command, transport, address))
-
-
-@auracast.command('pair')
-@click.argument('transport')
-@click.argument('address')
-@click.pass_context
-def pair(ctx, transport, address):
-    """Pair with an audio server"""
-    run_async(run_pair(transport, address))
-
-
-def main():
-    logging.basicConfig(level=os.environ.get('BUMBLE_LOGLEVEL', 'INFO').upper())
-    auracast()
-
-
-# -----------------------------------------------------------------------------
-if __name__ == "__main__":
-    main()  # pylint: disable=no-value-for-parameter

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

@@ -63,7 +63,6 @@ from bumble.transport import open_transport_or_link
 from bumble.gatt import Characteristic, Service, CharacteristicDeclaration, Descriptor
 from bumble.gatt_client import CharacteristicProxy
 from bumble.hci import (
-    Address,
     HCI_Constant,
     HCI_LE_1M_PHY,
     HCI_LE_2M_PHY,
@@ -290,7 +289,11 @@ class ConsoleApp:
                     device_config, hci_source, hci_sink
                 )
             else:
-                random_address = Address.generate_static_address()
+                random_address = (
+                    f"{random.randint(192,255):02X}"  # address is static random
+                )
+                for random_byte in random.sample(range(255), 5):
+                    random_address += f":{random_byte:02X}"
                 self.append_to_log(f"Setting random address: {random_address}")
                 self.device = Device.with_hci(
                     'Bumble', random_address, hci_source, hci_sink
@@ -500,9 +503,21 @@ class ConsoleApp:
             self.show_error('not connected')
             return
 
-        self.append_to_output('Service Discovery starting...')
-        await self.connected_peer.discover_all()
-        self.append_to_output('Service Discovery done!')
+        # Discover all services, characteristics and descriptors
+        self.append_to_output('discovering services...')
+        await self.connected_peer.discover_services()
+        self.append_to_output(
+            f'found {len(self.connected_peer.services)} services,'
+            ' discovering characteristics...'
+        )
+        await self.connected_peer.discover_characteristics()
+        self.append_to_output('found characteristics, discovering descriptors...')
+        for service in self.connected_peer.services:
+            for characteristic in service.characteristics:
+                await self.connected_peer.discover_descriptors(characteristic)
+        self.append_to_output('discovery completed')
+
+        self.show_remote_services(self.connected_peer.services)
 
     async def discover_attributes(self):
         if not self.connected_peer:
@@ -762,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:
@@ -781,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
 
@@ -929,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):
@@ -1157,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

@@ -18,42 +18,30 @@
 import asyncio
 import os
 import logging
-import time
-
 import click
-
 from bumble.company_ids import COMPANY_IDENTIFIERS
+
 from bumble.colors import color
 from bumble.core import name_or_number
 from bumble.hci import (
     map_null_terminated_utf8_string,
-    CodecID,
-    LeFeature,
     HCI_SUCCESS,
+    HCI_LE_SUPPORTED_FEATURES_NAMES,
     HCI_VERSION_NAMES,
     LMP_VERSION_NAMES,
     HCI_Command,
     HCI_Command_Complete_Event,
     HCI_Command_Status_Event,
-    HCI_READ_BUFFER_SIZE_COMMAND,
-    HCI_Read_Buffer_Size_Command,
     HCI_READ_BD_ADDR_COMMAND,
     HCI_Read_BD_ADDR_Command,
     HCI_READ_LOCAL_NAME_COMMAND,
     HCI_Read_Local_Name_Command,
-    HCI_LE_READ_BUFFER_SIZE_COMMAND,
-    HCI_LE_Read_Buffer_Size_Command,
     HCI_LE_READ_MAXIMUM_DATA_LENGTH_COMMAND,
     HCI_LE_Read_Maximum_Data_Length_Command,
     HCI_LE_READ_NUMBER_OF_SUPPORTED_ADVERTISING_SETS_COMMAND,
     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,
-    HCI_Read_Local_Supported_Codecs_Command,
-    HCI_Read_Local_Supported_Codecs_V2_Command,
-    HCI_Read_Local_Version_Information_Command,
 )
 from bumble.host import Host
 from bumble.transport import open_transport_or_link
@@ -69,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):
@@ -90,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):
@@ -129,104 +116,13 @@ 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(f'  {LeFeature(feature).name}')
+        print('  ', name_or_number(HCI_LE_SUPPORTED_FEATURES_NAMES, feature))
 
 
 # -----------------------------------------------------------------------------
-async def get_acl_flow_control_info(host: Host) -> None:
-    print()
-
-    if host.supports_command(HCI_READ_BUFFER_SIZE_COMMAND):
-        response = await host.send_command(
-            HCI_Read_Buffer_Size_Command(), check_result=True
-        )
-        print(
-            color('ACL Flow Control:', 'yellow'),
-            f'{response.return_parameters.hc_total_num_acl_data_packets} '
-            f'packets of size {response.return_parameters.hc_acl_data_packet_length}',
-        )
-
-    if host.supports_command(HCI_LE_READ_BUFFER_SIZE_COMMAND):
-        response = await host.send_command(
-            HCI_LE_Read_Buffer_Size_Command(), check_result=True
-        )
-        print(
-            color('LE ACL Flow Control:', 'yellow'),
-            f'{response.return_parameters.hc_total_num_le_acl_data_packets} '
-            f'packets of size {response.return_parameters.hc_le_acl_data_packet_length}',
-        )
-
-
-# -----------------------------------------------------------------------------
-async def get_codecs_info(host: Host) -> None:
-    print()
-
-    if host.supports_command(HCI_Read_Local_Supported_Codecs_V2_Command.op_code):
-        response = await host.send_command(
-            HCI_Read_Local_Supported_Codecs_V2_Command(), check_result=True
-        )
-        print(color('Codecs:', 'yellow'))
-
-        for codec_id, transport in zip(
-            response.return_parameters.standard_codec_ids,
-            response.return_parameters.standard_codec_transports,
-        ):
-            transport_name = HCI_Read_Local_Supported_Codecs_V2_Command.Transport(
-                transport
-            ).name
-            codec_name = CodecID(codec_id).name
-            print(f'  {codec_name} - {transport_name}')
-
-        for codec_id, transport in zip(
-            response.return_parameters.vendor_specific_codec_ids,
-            response.return_parameters.vendor_specific_codec_transports,
-        ):
-            transport_name = HCI_Read_Local_Supported_Codecs_V2_Command.Transport(
-                transport
-            ).name
-            company = name_or_number(COMPANY_IDENTIFIERS, codec_id >> 16)
-            print(f'  {company} / {codec_id & 0xFFFF} - {transport_name}')
-
-        if not response.return_parameters.standard_codec_ids:
-            print('  No standard codecs')
-        if not response.return_parameters.vendor_specific_codec_ids:
-            print('  No Vendor-specific codecs')
-
-    if host.supports_command(HCI_Read_Local_Supported_Codecs_Command.op_code):
-        response = await host.send_command(
-            HCI_Read_Local_Supported_Codecs_Command(), check_result=True
-        )
-        print(color('Codecs (BR/EDR):', 'yellow'))
-        for codec_id in response.return_parameters.standard_codec_ids:
-            codec_name = CodecID(codec_id).name
-            print(f'  {codec_name}')
-
-        for codec_id in response.return_parameters.vendor_specific_codec_ids:
-            company = name_or_number(COMPANY_IDENTIFIERS, codec_id >> 16)
-            print(f'  {company} / {codec_id & 0xFFFF}')
-
-        if not response.return_parameters.standard_codec_ids:
-            print('  No standard codecs')
-        if not response.return_parameters.vendor_specific_codec_ids:
-            print('  No Vendor-specific codecs')
-
-
-# -----------------------------------------------------------------------------
-async def async_main(latency_probes, transport):
+async def async_main(transport):
     print('<<< connecting to HCI...')
     async with await open_transport_or_link(transport) as (hci_source, hci_sink):
         print('<<< connected')
@@ -234,23 +130,6 @@ async def async_main(latency_probes, transport):
         host = Host(hci_source, hci_sink)
         await host.reset()
 
-        # Measure the latency if requested
-        latencies = []
-        if latency_probes:
-            for _ in range(latency_probes):
-                start = time.time()
-                await host.send_command(HCI_Read_Local_Version_Information_Command())
-                latencies.append(1000 * (time.time() - start))
-            print(
-                color('HCI Command Latency:', 'yellow'),
-                (
-                    f'min={min(latencies):.2f}, '
-                    f'max={max(latencies):.2f}, '
-                    f'average={sum(latencies)/len(latencies):.2f}'
-                ),
-                '\n',
-            )
-
         # Print version
         print(color('Version:', 'yellow'))
         print(
@@ -274,31 +153,19 @@ async def async_main(latency_probes, transport):
         # Get the LE info
         await get_le_info(host)
 
-        # Print the ACL flow control info
-        await get_acl_flow_control_info(host)
-
-        # Get codec info
-        await get_codecs_info(host)
-
         # Print the list of commands supported by the controller
         print()
         print(color('Supported Commands:', 'yellow'))
         for command in host.supported_commands:
-            print(f'  {HCI_Command.command_name(command)}')
+            print('  ', HCI_Command.command_name(command))
 
 
 # -----------------------------------------------------------------------------
 @click.command()
-@click.option(
-    '--latency-probes',
-    metavar='N',
-    type=int,
-    help='Send N commands to measure HCI transport latency statistics',
-)
 @click.argument('transport')
-def main(latency_probes, transport):
+def main(transport):
     logging.basicConfig(level=os.environ.get('BUMBLE_LOGLEVEL', 'WARNING').upper())
-    asyncio.run(async_main(latency_probes, transport))
+    asyncio.run(async_main(transport))
 
 
 # -----------------------------------------------------------------------------

apps/controller_loopback.py

@@ -1,205 +0,0 @@
-# Copyright 2024 Google LLC
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# -----------------------------------------------------------------------------
-# Imports
-# -----------------------------------------------------------------------------
-import asyncio
-import logging
-import os
-import time
-from typing import Optional
-from bumble.colors import color
-from bumble.hci import (
-    HCI_READ_LOOPBACK_MODE_COMMAND,
-    HCI_Read_Loopback_Mode_Command,
-    HCI_WRITE_LOOPBACK_MODE_COMMAND,
-    HCI_Write_Loopback_Mode_Command,
-    LoopbackMode,
-)
-from bumble.host import Host
-from bumble.transport import open_transport_or_link
-import click
-
-
-class Loopback:
-    """Send and receive ACL data packets in local loopback mode"""
-
-    def __init__(self, packet_size: int, packet_count: int, transport: str):
-        self.transport = transport
-        self.packet_size = packet_size
-        self.packet_count = packet_count
-        self.connection_handle: Optional[int] = None
-        self.connection_event = asyncio.Event()
-        self.done = asyncio.Event()
-        self.expected_cid = 0
-        self.bytes_received = 0
-        self.start_timestamp = 0.0
-        self.last_timestamp = 0.0
-
-    def on_connection(self, connection_handle: int, *args):
-        """Retrieve connection handle from new connection event"""
-        if not self.connection_event.is_set():
-            # save first connection handle for ACL
-            # subsequent connections are SCO
-            self.connection_handle = connection_handle
-            self.connection_event.set()
-
-    def on_l2cap_pdu(self, connection_handle: int, cid: int, pdu: bytes):
-        """Calculate packet receive speed"""
-        now = time.time()
-        print(f'<<< Received packet {cid}: {len(pdu)} bytes')
-        assert connection_handle == self.connection_handle
-        assert cid == self.expected_cid
-        self.expected_cid += 1
-        if cid == 0:
-            self.start_timestamp = now
-        else:
-            elapsed_since_start = now - self.start_timestamp
-            elapsed_since_last = now - self.last_timestamp
-            self.bytes_received += len(pdu)
-            instant_rx_speed = len(pdu) / elapsed_since_last
-            average_rx_speed = self.bytes_received / elapsed_since_start
-            print(
-                color(
-                    f'@@@ RX speed: instant={instant_rx_speed:.4f},'
-                    f' average={average_rx_speed:.4f}',
-                    'cyan',
-                )
-            )
-
-        self.last_timestamp = now
-
-        if self.expected_cid == self.packet_count:
-            print(color('@@@ Received last packet', 'green'))
-            self.done.set()
-
-    async def run(self):
-        """Run a loopback throughput test"""
-        print(color('>>> Connecting to HCI...', 'green'))
-        async with await open_transport_or_link(self.transport) as (
-            hci_source,
-            hci_sink,
-        ):
-            print(color('>>> Connected', 'green'))
-
-            host = Host(hci_source, hci_sink)
-            await host.reset()
-
-            # make sure data can fit in one l2cap pdu
-            l2cap_header_size = 4
-
-            max_packet_size = (
-                host.acl_packet_queue
-                if host.acl_packet_queue
-                else host.le_acl_packet_queue
-            ).max_packet_size - l2cap_header_size
-            if self.packet_size > max_packet_size:
-                print(
-                    color(
-                        f'!!! Packet size ({self.packet_size}) larger than max supported'
-                        f' size ({max_packet_size})',
-                        'red',
-                    )
-                )
-                return
-
-            if not host.supports_command(
-                HCI_WRITE_LOOPBACK_MODE_COMMAND
-            ) or not host.supports_command(HCI_READ_LOOPBACK_MODE_COMMAND):
-                print(color('!!! Loopback mode not supported', 'red'))
-                return
-
-            # set event callbacks
-            host.on('connection', self.on_connection)
-            host.on('l2cap_pdu', self.on_l2cap_pdu)
-
-            loopback_mode = LoopbackMode.LOCAL
-
-            print(color('### Setting loopback mode', 'blue'))
-            await host.send_command(
-                HCI_Write_Loopback_Mode_Command(loopback_mode=LoopbackMode.LOCAL),
-                check_result=True,
-            )
-
-            print(color('### Checking loopback mode', 'blue'))
-            response = await host.send_command(
-                HCI_Read_Loopback_Mode_Command(), check_result=True
-            )
-            if response.return_parameters.loopback_mode != loopback_mode:
-                print(color('!!! Loopback mode mismatch', 'red'))
-                return
-
-            await self.connection_event.wait()
-            print(color('### Connected', 'cyan'))
-
-            print(color('=== Start sending', 'magenta'))
-            start_time = time.time()
-            bytes_sent = 0
-            for cid in range(0, self.packet_count):
-                # using the cid as an incremental index
-                host.send_l2cap_pdu(
-                    self.connection_handle, cid, bytes(self.packet_size)
-                )
-                print(
-                    color(
-                        f'>>> Sending packet {cid}: {self.packet_size} bytes', 'yellow'
-                    )
-                )
-                bytes_sent += self.packet_size  # don't count L2CAP or HCI header sizes
-                await asyncio.sleep(0)  # yield to allow packet receive
-
-            await self.done.wait()
-            print(color('=== Done!', 'magenta'))
-
-            elapsed = time.time() - start_time
-            average_tx_speed = bytes_sent / elapsed
-            print(
-                color(
-                    f'@@@ TX speed: average={average_tx_speed:.4f} ({bytes_sent} bytes'
-                    f' in {elapsed:.2f} seconds)',
-                    'green',
-                )
-            )
-
-
-# -----------------------------------------------------------------------------
-@click.command()
-@click.option(
-    '--packet-size',
-    '-s',
-    metavar='SIZE',
-    type=click.IntRange(8, 4096),
-    default=500,
-    help='Packet size',
-)
-@click.option(
-    '--packet-count',
-    '-c',
-    metavar='COUNT',
-    type=click.IntRange(1, 65535),
-    default=10,
-    help='Packet count',
-)
-@click.argument('transport')
-def main(packet_size, packet_count, transport):
-    logging.basicConfig(level=os.environ.get('BUMBLE_LOGLEVEL', 'WARNING').upper())
-
-    loopback = Loopback(packet_size, packet_count, transport)
-    asyncio.run(loopback.run())
-
-
-# -----------------------------------------------------------------------------
-if __name__ == '__main__':
-    main()

apps/device_info.py

@@ -1,230 +0,0 @@
-# Copyright 2021-2022 Google LLC
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# -----------------------------------------------------------------------------
-# Imports
-# -----------------------------------------------------------------------------
-import asyncio
-import os
-import logging
-from typing import Callable, Iterable, Optional
-
-import click
-
-from bumble.core import ProtocolError
-from bumble.colors import color
-from bumble.device import Device, Peer
-from bumble.gatt import Service
-from bumble.profiles.device_information_service import DeviceInformationServiceProxy
-from bumble.profiles.battery_service import BatteryServiceProxy
-from bumble.profiles.gap import GenericAccessServiceProxy
-from bumble.profiles.tmap import TelephonyAndMediaAudioServiceProxy
-from bumble.transport import open_transport_or_link
-
-
-# -----------------------------------------------------------------------------
-async def try_show(function: Callable, *args, **kwargs) -> None:
-    try:
-        await function(*args, **kwargs)
-    except ProtocolError as error:
-        print(color('ERROR:', 'red'), error)
-
-
-# -----------------------------------------------------------------------------
-def show_services(services: Iterable[Service]) -> None:
-    for service in services:
-        print(color(str(service), 'cyan'))
-
-        for characteristic in service.characteristics:
-            print(color('  ' + str(characteristic), 'magenta'))
-
-
-# -----------------------------------------------------------------------------
-async def show_gap_information(
-    gap_service: GenericAccessServiceProxy,
-):
-    print(color('### Generic Access Profile', 'yellow'))
-
-    if gap_service.device_name:
-        print(
-            color(' Device Name:', 'green'),
-            await gap_service.device_name.read_value(),
-        )
-
-    if gap_service.appearance:
-        print(
-            color(' Appearance: ', 'green'),
-            await gap_service.appearance.read_value(),
-        )
-
-    print()
-
-
-# -----------------------------------------------------------------------------
-async def show_device_information(
-    device_information_service: DeviceInformationServiceProxy,
-):
-    print(color('### Device Information', 'yellow'))
-
-    if device_information_service.manufacturer_name:
-        print(
-            color('  Manufacturer Name:', 'green'),
-            await device_information_service.manufacturer_name.read_value(),
-        )
-
-    if device_information_service.model_number:
-        print(
-            color('  Model Number:     ', 'green'),
-            await device_information_service.model_number.read_value(),
-        )
-
-    if device_information_service.serial_number:
-        print(
-            color('  Serial Number:    ', 'green'),
-            await device_information_service.serial_number.read_value(),
-        )
-
-    if device_information_service.firmware_revision:
-        print(
-            color('  Firmware Revision:', 'green'),
-            await device_information_service.firmware_revision.read_value(),
-        )
-
-    print()
-
-
-# -----------------------------------------------------------------------------
-async def show_battery_level(
-    battery_service: BatteryServiceProxy,
-):
-    print(color('### Battery Information', 'yellow'))
-
-    if battery_service.battery_level:
-        print(
-            color('  Battery Level:', 'green'),
-            await battery_service.battery_level.read_value(),
-        )
-
-    print()
-
-
-# -----------------------------------------------------------------------------
-async def show_tmas(
-    tmas: TelephonyAndMediaAudioServiceProxy,
-):
-    print(color('### Telephony And Media Audio Service', 'yellow'))
-
-    if tmas.role:
-        print(
-            color('  Role:', 'green'),
-            await tmas.role.read_value(),
-        )
-
-    print()
-
-
-# -----------------------------------------------------------------------------
-async def show_device_info(peer, done: Optional[asyncio.Future]) -> None:
-    try:
-        # Discover all services
-        print(color('### Discovering Services and Characteristics', 'magenta'))
-        await peer.discover_services()
-        for service in peer.services:
-            await service.discover_characteristics()
-
-        print(color('=== Services ===', 'yellow'))
-        show_services(peer.services)
-        print()
-
-        if gap_service := peer.create_service_proxy(GenericAccessServiceProxy):
-            await try_show(show_gap_information, gap_service)
-
-        if device_information_service := peer.create_service_proxy(
-            DeviceInformationServiceProxy
-        ):
-            await try_show(show_device_information, device_information_service)
-
-        if battery_service := peer.create_service_proxy(BatteryServiceProxy):
-            await try_show(show_battery_level, battery_service)
-
-        if tmas := peer.create_service_proxy(TelephonyAndMediaAudioServiceProxy):
-            await try_show(show_tmas, tmas)
-
-        if done is not None:
-            done.set_result(None)
-    except asyncio.CancelledError:
-        print(color('!!! Operation canceled', 'red'))
-
-
-# -----------------------------------------------------------------------------
-async def async_main(device_config, encrypt, transport, address_or_name):
-    async with await open_transport_or_link(transport) as (hci_source, hci_sink):
-
-        # Create a device
-        if device_config:
-            device = Device.from_config_file_with_hci(
-                device_config, hci_source, hci_sink
-            )
-        else:
-            device = Device.with_hci(
-                'Bumble', 'F0:F1:F2:F3:F4:F5', hci_source, hci_sink
-            )
-        await device.power_on()
-
-        if address_or_name:
-            # Connect to the target peer
-            print(color('>>> Connecting...', 'green'))
-            connection = await device.connect(address_or_name)
-            print(color('>>> Connected', 'green'))
-
-            # Encrypt the connection if required
-            if encrypt:
-                print(color('+++ Encrypting connection...', 'blue'))
-                await connection.encrypt()
-                print(color('+++ Encryption established', 'blue'))
-
-            await show_device_info(Peer(connection), None)
-        else:
-            # Wait for a connection
-            done = asyncio.get_running_loop().create_future()
-            device.on(
-                'connection',
-                lambda connection: asyncio.create_task(
-                    show_device_info(Peer(connection), done)
-                ),
-            )
-            await device.start_advertising(auto_restart=True)
-
-            print(color('### Waiting for connection...', 'blue'))
-            await done
-
-
-# -----------------------------------------------------------------------------
-@click.command()
-@click.option('--device-config', help='Device configuration', type=click.Path())
-@click.option('--encrypt', help='Encrypt the connection', is_flag=True, default=False)
-@click.argument('transport')
-@click.argument('address-or-name', required=False)
-def main(device_config, encrypt, transport, address_or_name):
-    """
-    Dump the GATT database on a remote device. If ADDRESS_OR_NAME is not specified,
-    wait for an incoming connection.
-    """
-    logging.basicConfig(level=os.environ.get('BUMBLE_LOGLEVEL', 'INFO').upper())
-    asyncio.run(async_main(device_config, encrypt, transport, address_or_name))
-
-
-# -----------------------------------------------------------------------------
-if __name__ == '__main__':
-    main()

apps/gatt_dump.py

@@ -75,15 +75,11 @@ async def async_main(device_config, encrypt, transport, address_or_name):
 
         if address_or_name:
             # Connect to the target peer
-            print(color('>>> Connecting...', 'green'))
             connection = await device.connect(address_or_name)
-            print(color('>>> Connected', 'green'))
 
             # Encrypt the connection if required
             if encrypt:
-                print(color('+++ Encrypting connection...', 'blue'))
                 await connection.encrypt()
-                print(color('+++ Encryption established', 'blue'))
 
             await dump_gatt_db(Peer(connection), None)
         else:

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
@@ -130,7 +128,7 @@ class ServerBridge:
                 if self.tcp_transport is not None:
                     self.tcp_transport.close()
 
-            def on_channel_sdu(self, sdu):
+            def on_coc_sdu(self, sdu):
                 print(color(f'<<< [L2CAP SDU]: {len(sdu)} bytes', 'cyan'))
                 if self.tcp_transport is None:
                     print(color('!!! TCP socket not open, dropping', 'red'))
@@ -185,7 +183,7 @@ class ClientBridge:
             peer_name = writer.get_extra_info('peer_name')
             print(color(f'<<< TCP connection from {peer_name}', 'magenta'))
 
-            def on_channel_sdu(sdu):
+            def on_coc_sdu(sdu):
                 print(color(f'<<< [L2CAP SDU]: {len(sdu)} bytes', 'cyan'))
                 l2cap_to_tcp_pipe.write(sdu)
 
@@ -197,13 +195,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 +207,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 +272,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 +296,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/lea_unicast/app.py

@@ -1,576 +0,0 @@
-# Copyright 2021-2024 Google LLC
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# -----------------------------------------------------------------------------
-# Imports
-# -----------------------------------------------------------------------------
-from __future__ import annotations
-import asyncio
-import datetime
-import enum
-import functools
-from importlib import resources
-import json
-import os
-import logging
-import pathlib
-from typing import Optional, List, cast
-import weakref
-import struct
-
-import ctypes
-import wasmtime
-import wasmtime.loader
-import liblc3  # type: ignore
-
-import click
-import aiohttp.web
-
-import bumble
-from bumble.core import AdvertisingData
-from bumble.colors import color
-from bumble.device import Device, DeviceConfiguration, AdvertisingParameters
-from bumble.transport import open_transport
-from bumble.profiles import ascs, bap, pacs
-from bumble.hci import Address, CodecID, CodingFormat, HCI_IsoDataPacket
-
-# -----------------------------------------------------------------------------
-# Logging
-# -----------------------------------------------------------------------------
-logger = logging.getLogger(__name__)
-
-# -----------------------------------------------------------------------------
-# Constants
-# -----------------------------------------------------------------------------
-DEFAULT_UI_PORT = 7654
-
-
-def _sink_pac_record() -> pacs.PacRecord:
-    return pacs.PacRecord(
-        coding_format=CodingFormat(CodecID.LC3),
-        codec_specific_capabilities=bap.CodecSpecificCapabilities(
-            supported_sampling_frequencies=(
-                bap.SupportedSamplingFrequency.FREQ_8000
-                | bap.SupportedSamplingFrequency.FREQ_16000
-                | bap.SupportedSamplingFrequency.FREQ_24000
-                | bap.SupportedSamplingFrequency.FREQ_32000
-                | bap.SupportedSamplingFrequency.FREQ_48000
-            ),
-            supported_frame_durations=(
-                bap.SupportedFrameDuration.DURATION_10000_US_SUPPORTED
-            ),
-            supported_audio_channel_count=[1, 2],
-            min_octets_per_codec_frame=26,
-            max_octets_per_codec_frame=240,
-            supported_max_codec_frames_per_sdu=2,
-        ),
-    )
-
-
-def _source_pac_record() -> pacs.PacRecord:
-    return pacs.PacRecord(
-        coding_format=CodingFormat(CodecID.LC3),
-        codec_specific_capabilities=bap.CodecSpecificCapabilities(
-            supported_sampling_frequencies=(
-                bap.SupportedSamplingFrequency.FREQ_8000
-                | bap.SupportedSamplingFrequency.FREQ_16000
-                | bap.SupportedSamplingFrequency.FREQ_24000
-                | bap.SupportedSamplingFrequency.FREQ_32000
-                | bap.SupportedSamplingFrequency.FREQ_48000
-            ),
-            supported_frame_durations=(
-                bap.SupportedFrameDuration.DURATION_10000_US_SUPPORTED
-            ),
-            supported_audio_channel_count=[1],
-            min_octets_per_codec_frame=30,
-            max_octets_per_codec_frame=100,
-            supported_max_codec_frames_per_sdu=1,
-        ),
-    )
-
-
-# -----------------------------------------------------------------------------
-# WASM - liblc3
-# -----------------------------------------------------------------------------
-store = wasmtime.loader.store
-_memory = cast(wasmtime.Memory, liblc3.memory)
-STACK_POINTER = _memory.data_len(store)
-_memory.grow(store, 1)
-# Mapping wasmtime memory to linear address
-memory = (ctypes.c_ubyte * _memory.data_len(store)).from_address(
-    ctypes.addressof(_memory.data_ptr(store).contents)  # type: ignore
-)
-
-
-class Liblc3PcmFormat(enum.IntEnum):
-    S16 = 0
-    S24 = 1
-    S24_3LE = 2
-    FLOAT = 3
-
-
-MAX_DECODER_SIZE = liblc3.lc3_decoder_size(10000, 48000)
-MAX_ENCODER_SIZE = liblc3.lc3_encoder_size(10000, 48000)
-
-DECODER_STACK_POINTER = STACK_POINTER
-ENCODER_STACK_POINTER = DECODER_STACK_POINTER + MAX_DECODER_SIZE * 2
-DECODE_BUFFER_STACK_POINTER = ENCODER_STACK_POINTER + MAX_ENCODER_SIZE * 2
-ENCODE_BUFFER_STACK_POINTER = DECODE_BUFFER_STACK_POINTER + 8192
-DEFAULT_PCM_SAMPLE_RATE = 48000
-DEFAULT_PCM_FORMAT = Liblc3PcmFormat.S16
-DEFAULT_PCM_BYTES_PER_SAMPLE = 2
-
-
-encoders: List[int] = []
-decoders: List[int] = []
-
-
-def setup_encoders(
-    sample_rate_hz: int, frame_duration_us: int, num_channels: int
-) -> None:
-    logger.info(
-        f"setup_encoders {sample_rate_hz}Hz {frame_duration_us}us {num_channels}channels"
-    )
-    encoders[:num_channels] = [
-        liblc3.lc3_setup_encoder(
-            frame_duration_us,
-            sample_rate_hz,
-            DEFAULT_PCM_SAMPLE_RATE,  # Input sample rate
-            ENCODER_STACK_POINTER + MAX_ENCODER_SIZE * i,
-        )
-        for i in range(num_channels)
-    ]
-
-
-def setup_decoders(
-    sample_rate_hz: int, frame_duration_us: int, num_channels: int
-) -> None:
-    logger.info(
-        f"setup_decoders {sample_rate_hz}Hz {frame_duration_us}us {num_channels}channels"
-    )
-    decoders[:num_channels] = [
-        liblc3.lc3_setup_decoder(
-            frame_duration_us,
-            sample_rate_hz,
-            DEFAULT_PCM_SAMPLE_RATE,  # Output sample rate
-            DECODER_STACK_POINTER + MAX_DECODER_SIZE * i,
-        )
-        for i in range(num_channels)
-    ]
-
-
-def decode(
-    frame_duration_us: int,
-    num_channels: int,
-    input_bytes: bytes,
-) -> bytes:
-    if not input_bytes:
-        return b''
-
-    input_buffer_offset = DECODE_BUFFER_STACK_POINTER
-    input_buffer_size = len(input_bytes)
-    input_bytes_per_frame = input_buffer_size // num_channels
-
-    # Copy into wasm
-    memory[input_buffer_offset : input_buffer_offset + input_buffer_size] = input_bytes  # type: ignore
-
-    output_buffer_offset = input_buffer_offset + input_buffer_size
-    output_buffer_size = (
-        liblc3.lc3_frame_samples(frame_duration_us, DEFAULT_PCM_SAMPLE_RATE)
-        * DEFAULT_PCM_BYTES_PER_SAMPLE
-        * num_channels
-    )
-
-    for i in range(num_channels):
-        res = liblc3.lc3_decode(
-            decoders[i],
-            input_buffer_offset + input_bytes_per_frame * i,
-            input_bytes_per_frame,
-            DEFAULT_PCM_FORMAT,
-            output_buffer_offset + i * DEFAULT_PCM_BYTES_PER_SAMPLE,
-            num_channels,  # Stride
-        )
-
-        if res != 0:
-            logging.error(f"Parsing failed, res={res}")
-
-    # Extract decoded data from the output buffer
-    return bytes(
-        memory[output_buffer_offset : output_buffer_offset + output_buffer_size]
-    )
-
-
-def encode(
-    sdu_length: int,
-    num_channels: int,
-    stride: int,
-    input_bytes: bytes,
-) -> bytes:
-    if not input_bytes:
-        return b''
-
-    input_buffer_offset = ENCODE_BUFFER_STACK_POINTER
-    input_buffer_size = len(input_bytes)
-
-    # Copy into wasm
-    memory[input_buffer_offset : input_buffer_offset + input_buffer_size] = input_bytes  # type: ignore
-
-    output_buffer_offset = input_buffer_offset + input_buffer_size
-    output_buffer_size = sdu_length
-    output_frame_size = output_buffer_size // num_channels
-
-    for i in range(num_channels):
-        res = liblc3.lc3_encode(
-            encoders[i],
-            DEFAULT_PCM_FORMAT,
-            input_buffer_offset + DEFAULT_PCM_BYTES_PER_SAMPLE * i,
-            stride,
-            output_frame_size,
-            output_buffer_offset + output_frame_size * i,
-        )
-
-        if res != 0:
-            logging.error(f"Parsing failed, res={res}")
-
-    # Extract decoded data from the output buffer
-    return bytes(
-        memory[output_buffer_offset : output_buffer_offset + output_buffer_size]
-    )
-
-
-async def lc3_source_task(
-    filename: str,
-    sdu_length: int,
-    frame_duration_us: int,
-    device: Device,
-    cis_handle: int,
-) -> None:
-    with open(filename, 'rb') as f:
-        header = f.read(44)
-        assert header[8:12] == b'WAVE'
-
-        pcm_num_channel, pcm_sample_rate, _byte_rate, _block_align, bits_per_sample = (
-            struct.unpack("<HIIHH", header[22:36])
-        )
-        assert pcm_sample_rate == DEFAULT_PCM_SAMPLE_RATE
-        assert bits_per_sample == DEFAULT_PCM_BYTES_PER_SAMPLE * 8
-
-        frame_bytes = (
-            liblc3.lc3_frame_samples(frame_duration_us, DEFAULT_PCM_SAMPLE_RATE)
-            * DEFAULT_PCM_BYTES_PER_SAMPLE
-        )
-        packet_sequence_number = 0
-
-        while True:
-            next_round = datetime.datetime.now() + datetime.timedelta(
-                microseconds=frame_duration_us
-            )
-            pcm_data = f.read(frame_bytes)
-            sdu = encode(sdu_length, pcm_num_channel, pcm_num_channel, pcm_data)
-
-            iso_packet = HCI_IsoDataPacket(
-                connection_handle=cis_handle,
-                data_total_length=sdu_length + 4,
-                packet_sequence_number=packet_sequence_number,
-                pb_flag=0b10,
-                packet_status_flag=0,
-                iso_sdu_length=sdu_length,
-                iso_sdu_fragment=sdu,
-            )
-            device.host.send_hci_packet(iso_packet)
-            packet_sequence_number += 1
-            sleep_time = next_round - datetime.datetime.now()
-            await asyncio.sleep(sleep_time.total_seconds())
-
-
-# -----------------------------------------------------------------------------
-class UiServer:
-    speaker: weakref.ReferenceType[Speaker]
-    port: int
-
-    def __init__(self, speaker: Speaker, port: int) -> None:
-        self.speaker = weakref.ref(speaker)
-        self.port = port
-        self.channel_socket = None
-
-    async def start_http(self) -> None:
-        """Start the UI HTTP server."""
-
-        app = aiohttp.web.Application()
-        app.add_routes(
-            [
-                aiohttp.web.get('/', self.get_static),
-                aiohttp.web.get('/index.html', self.get_static),
-                aiohttp.web.get('/channel', self.get_channel),
-            ]
-        )
-
-        runner = aiohttp.web.AppRunner(app)
-        await runner.setup()
-        site = aiohttp.web.TCPSite(runner, 'localhost', self.port)
-        print('UI HTTP server at ' + color(f'http://127.0.0.1:{self.port}', 'green'))
-        await site.start()
-
-    async def get_static(self, request):
-        path = request.path
-        if path == '/':
-            path = '/index.html'
-        if path.endswith('.html'):
-            content_type = 'text/html'
-        elif path.endswith('.js'):
-            content_type = 'text/javascript'
-        elif path.endswith('.css'):
-            content_type = 'text/css'
-        elif path.endswith('.svg'):
-            content_type = 'image/svg+xml'
-        else:
-            content_type = 'text/plain'
-        text = (
-            resources.files("bumble.apps.lea_unicast")
-            .joinpath(pathlib.Path(path).relative_to('/'))
-            .read_text(encoding="utf-8")
-        )
-        return aiohttp.web.Response(text=text, content_type=content_type)
-
-    async def get_channel(self, request):
-        ws = aiohttp.web.WebSocketResponse()
-        await ws.prepare(request)
-
-        # Process messages until the socket is closed.
-        self.channel_socket = ws
-        async for message in ws:
-            if message.type == aiohttp.WSMsgType.TEXT:
-                logger.debug(f'<<< received message: {message.data}')
-                await self.on_message(message.data)
-            elif message.type == aiohttp.WSMsgType.ERROR:
-                logger.debug(
-                    f'channel connection closed with exception {ws.exception()}'
-                )
-
-        self.channel_socket = None
-        logger.debug('--- channel connection closed')
-
-        return ws
-
-    async def on_message(self, message_str: str):
-        # Parse the message as JSON
-        message = json.loads(message_str)
-
-        # Dispatch the message
-        message_type = message['type']
-        message_params = message.get('params', {})
-        handler = getattr(self, f'on_{message_type}_message')
-        if handler:
-            await handler(**message_params)
-
-    async def on_hello_message(self):
-        await self.send_message(
-            'hello',
-            bumble_version=bumble.__version__,
-            codec=self.speaker().codec,
-            streamState=self.speaker().stream_state.name,
-        )
-        if connection := self.speaker().connection:
-            await self.send_message(
-                'connection',
-                peer_address=connection.peer_address.to_string(False),
-                peer_name=connection.peer_name,
-            )
-
-    async def send_message(self, message_type: str, **kwargs) -> None:
-        if self.channel_socket is None:
-            return
-
-        message = {'type': message_type, 'params': kwargs}
-        await self.channel_socket.send_json(message)
-
-    async def send_audio(self, data: bytes) -> None:
-        if self.channel_socket is None:
-            return
-
-        try:
-            await self.channel_socket.send_bytes(data)
-        except Exception as error:
-            logger.warning(f'exception while sending audio packet: {error}')
-
-
-# -----------------------------------------------------------------------------
-class Speaker:
-
-    def __init__(
-        self,
-        device_config_path: Optional[str],
-        ui_port: int,
-        transport: str,
-        lc3_input_file_path: str,
-    ):
-        self.device_config_path = device_config_path
-        self.transport = transport
-        self.lc3_input_file_path = lc3_input_file_path
-
-        # Create an HTTP server for the UI
-        self.ui_server = UiServer(speaker=self, port=ui_port)
-
-    async def run(self) -> None:
-        await self.ui_server.start_http()
-
-        async with await open_transport(self.transport) as hci_transport:
-            # Create a device
-            if self.device_config_path:
-                device_config = DeviceConfiguration.from_file(self.device_config_path)
-            else:
-                device_config = DeviceConfiguration(
-                    name="Bumble LE Headphone",
-                    class_of_device=0x244418,
-                    keystore="JsonKeyStore",
-                    advertising_interval_min=25,
-                    advertising_interval_max=25,
-                    address=Address('F1:F2:F3:F4:F5:F6'),
-                )
-
-            device_config.le_enabled = True
-            device_config.cis_enabled = True
-            self.device = Device.from_config_with_hci(
-                device_config, hci_transport.source, hci_transport.sink
-            )
-
-            self.device.add_service(
-                pacs.PublishedAudioCapabilitiesService(
-                    supported_source_context=bap.ContextType(0xFFFF),
-                    available_source_context=bap.ContextType(0xFFFF),
-                    supported_sink_context=bap.ContextType(0xFFFF),  # All context types
-                    available_sink_context=bap.ContextType(0xFFFF),  # All context types
-                    sink_audio_locations=(
-                        bap.AudioLocation.FRONT_LEFT | bap.AudioLocation.FRONT_RIGHT
-                    ),
-                    sink_pac=[_sink_pac_record()],
-                    source_audio_locations=bap.AudioLocation.FRONT_LEFT,
-                    source_pac=[_source_pac_record()],
-                )
-            )
-
-            ascs_service = ascs.AudioStreamControlService(
-                self.device, sink_ase_id=[1], source_ase_id=[2]
-            )
-            self.device.add_service(ascs_service)
-
-            advertising_data = bytes(
-                AdvertisingData(
-                    [
-                        (
-                            AdvertisingData.COMPLETE_LOCAL_NAME,
-                            bytes(device_config.name, 'utf-8'),
-                        ),
-                        (
-                            AdvertisingData.FLAGS,
-                            bytes([AdvertisingData.LE_GENERAL_DISCOVERABLE_MODE_FLAG]),
-                        ),
-                        (
-                            AdvertisingData.INCOMPLETE_LIST_OF_16_BIT_SERVICE_CLASS_UUIDS,
-                            bytes(pacs.PublishedAudioCapabilitiesService.UUID),
-                        ),
-                    ]
-                )
-            ) + bytes(bap.UnicastServerAdvertisingData())
-
-            def on_pdu(pdu: HCI_IsoDataPacket, ase: ascs.AseStateMachine):
-                codec_config = ase.codec_specific_configuration
-                assert isinstance(codec_config, bap.CodecSpecificConfiguration)
-                pcm = decode(
-                    codec_config.frame_duration.us,
-                    codec_config.audio_channel_allocation.channel_count,
-                    pdu.iso_sdu_fragment,
-                )
-                self.device.abort_on('disconnection', self.ui_server.send_audio(pcm))
-
-            def on_ase_state_change(ase: ascs.AseStateMachine) -> None:
-                if ase.state == ascs.AseStateMachine.State.STREAMING:
-                    codec_config = ase.codec_specific_configuration
-                    assert isinstance(codec_config, bap.CodecSpecificConfiguration)
-                    assert ase.cis_link
-                    if ase.role == ascs.AudioRole.SOURCE:
-                        ase.cis_link.abort_on(
-                            'disconnection',
-                            lc3_source_task(
-                                filename=self.lc3_input_file_path,
-                                sdu_length=(
-                                    codec_config.codec_frames_per_sdu
-                                    * codec_config.octets_per_codec_frame
-                                ),
-                                frame_duration_us=codec_config.frame_duration.us,
-                                device=self.device,
-                                cis_handle=ase.cis_link.handle,
-                            ),
-                        )
-                    else:
-                        ase.cis_link.sink = functools.partial(on_pdu, ase=ase)
-                elif ase.state == ascs.AseStateMachine.State.CODEC_CONFIGURED:
-                    codec_config = ase.codec_specific_configuration
-                    assert isinstance(codec_config, bap.CodecSpecificConfiguration)
-                    if ase.role == ascs.AudioRole.SOURCE:
-                        setup_encoders(
-                            codec_config.sampling_frequency.hz,
-                            codec_config.frame_duration.us,
-                            codec_config.audio_channel_allocation.channel_count,
-                        )
-                    else:
-                        setup_decoders(
-                            codec_config.sampling_frequency.hz,
-                            codec_config.frame_duration.us,
-                            codec_config.audio_channel_allocation.channel_count,
-                        )
-
-            for ase in ascs_service.ase_state_machines.values():
-                ase.on('state_change', functools.partial(on_ase_state_change, ase=ase))
-
-            await self.device.power_on()
-            await self.device.create_advertising_set(
-                advertising_data=advertising_data,
-                auto_restart=True,
-                advertising_parameters=AdvertisingParameters(
-                    primary_advertising_interval_min=100,
-                    primary_advertising_interval_max=100,
-                ),
-            )
-
-            await hci_transport.source.terminated
-
-
-@click.command()
-@click.option(
-    '--ui-port',
-    'ui_port',
-    metavar='HTTP_PORT',
-    default=DEFAULT_UI_PORT,
-    show_default=True,
-    help='HTTP port for the UI server',
-)
-@click.option('--device-config', metavar='FILENAME', help='Device configuration file')
-@click.argument('transport')
-@click.argument('lc3_file')
-def speaker(ui_port: int, device_config: str, transport: str, lc3_file: str) -> None:
-    """Run the speaker."""
-
-    asyncio.run(Speaker(device_config, ui_port, transport, lc3_file).run())
-
-
-# -----------------------------------------------------------------------------
-def main():
-    logging.basicConfig(level=os.environ.get('BUMBLE_LOGLEVEL', 'WARNING').upper())
-    speaker()
-
-
-# -----------------------------------------------------------------------------
-if __name__ == "__main__":
-    main()  # pylint: disable=no-value-for-parameter

apps/lea_unicast/index.html

@@ -1,68 +0,0 @@
-<html data-bs-theme="dark">
-
-<head>
-    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.2/dist/css/bootstrap.min.css" rel="stylesheet"
-        integrity="sha384-T3c6CoIi6uLrA9TneNEoa7RxnatzjcDSCmG1MXxSR1GAsXEV/Dwwykc2MPK8M2HN" crossorigin="anonymous">
-    <script src="https://unpkg.com/pcm-player"></script>
-</head>
-
-<body>
-    <nav class="navbar navbar-dark bg-primary">
-        <div class="container">
-            <span class="navbar-brand mb-0 h1">Bumble Unicast Server</span>
-        </div>
-    </nav>
-    <br>
-
-    <div class="container">
-        <button type="button" class="btn btn-danger" id="connect-audio" onclick="connectAudio()">Connect Audio</button>
-        <button class="btn btn-primary" type="button" disabled>
-            <span class="spinner-border spinner-border-sm" id="ws-status-spinner" aria-hidden="true"></span>
-            <span role="status" id="ws-status">WebSocket Connecting...</span>
-        </button>
-    </div>
-
-
-    <script>
-        let player = null;
-        const wsStatus = document.getElementById("ws-status");
-        const wsStatusSpinner = document.getElementById("ws-status-spinner");
-
-        const socket = new WebSocket('ws://127.0.0.1:7654/channel');
-        socket.binaryType = "arraybuffer";
-        socket.onmessage = function (message) {
-            if (typeof message.data === 'string' || message.data instanceof String) {
-                console.log(`channel MESSAGE: ${message.data}`);
-            } else {
-                console.log(typeof (message.data))
-                // BINARY audio data.
-                if (player == null) return;
-                player.feed(message.data);
-            }
-        };
-
-        socket.onopen = (message) => {
-            wsStatusSpinner.remove();
-            wsStatus.textContent = "WebSocket Connected";
-        }
-
-        socket.onclose = (message) => {
-            wsStatus.textContent = "WebSocket Disconnected";
-        }
-
-        function connectAudio() {
-            player = new PCMPlayer({
-                inputCodec: 'Int16',
-                channels: 2,
-                sampleRate: 48000,
-                flushTime: 10,
-            });
-            const button = document.getElementById("connect-audio")
-            button.disabled = true;
-            button.textContent = "Audio Connected";
-        }
-    </script>
-    </div>
-</body>
-
-</html>

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,
@@ -46,25 +40,17 @@ from bumble.att import (
     ATT_INSUFFICIENT_AUTHENTICATION_ERROR,
     ATT_INSUFFICIENT_ENCRYPTION_ERROR,
 )
-from bumble.utils import AsyncRunner
-
-# -----------------------------------------------------------------------------
-# Constants
-# -----------------------------------------------------------------------------
-POST_PAIRING_DELAY = 1
 
 
 # -----------------------------------------------------------------------------
 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
@@ -74,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,
@@ -241,10 +227,8 @@ def on_connection(connection, request):
 
     # Listen for pairing events
     connection.on('pairing_start', on_pairing_start)
-    connection.on('pairing', lambda keys: on_pairing(connection, keys))
-    connection.on(
-        'pairing_failure', lambda reason: on_pairing_failure(connection, reason)
-    )
+    connection.on('pairing', lambda keys: on_pairing(connection.peer_address, keys))
+    connection.on('pairing_failure', on_pairing_failure)
 
     # Listen for encryption changes
     connection.on(
@@ -278,24 +262,19 @@ def on_pairing_start():
 
 
 # -----------------------------------------------------------------------------
-@AsyncRunner.run_in_task()
-async def on_pairing(connection, keys):
+def on_pairing(address, keys):
     print(color('***-----------------------------------', 'cyan'))
-    print(color(f'*** Paired! (peer identity={connection.peer_address})', 'cyan'))
+    print(color(f'*** Paired! (peer identity={address})', 'cyan'))
     keys.print(prefix=color('*** ', 'cyan'))
     print(color('***-----------------------------------', 'cyan'))
-    await asyncio.sleep(POST_PAIRING_DELAY)
-    await connection.disconnect()
     Waiter.instance.terminate()
 
 
 # -----------------------------------------------------------------------------
-@AsyncRunner.run_in_task()
-async def on_pairing_failure(connection, reason):
+def on_pairing_failure(reason):
     print(color('***-----------------------------------', 'red'))
     print(color(f'*** Pairing failed: {smp_error_name(reason)}', 'red'))
     print(color('***-----------------------------------', 'red'))
-    await connection.disconnect()
     Waiter.instance.terminate()
 
 
@@ -306,10 +285,7 @@ async def pair(
     mitm,
     bond,
     ctkd,
-    identity_address,
-    linger,
     io,
-    oob,
     prompt,
     request,
     print_keys,
@@ -318,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):
@@ -330,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',
@@ -351,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
@@ -367,58 +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
-        if identity_address == 'public':
-            identity_address_type = PairingConfig.AddressType.PUBLIC
-        elif identity_address == 'random':
-            identity_address_type = PairingConfig.AddressType.RANDOM
-        else:
-            identity_address_type = None
         device.pairing_config_factory = lambda connection: PairingConfig(
-            sc=sc,
-            mitm=mitm,
-            bonding=bond,
-            oob=oob_contexts,
-            identity_address_type=identity_address_type,
-            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:
@@ -426,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
@@ -478,11 +413,6 @@ class LogHandler(logging.Handler):
     help='Enable CTKD',
     show_default=True,
 )
-@click.option(
-    '--identity-address',
-    type=click.Choice(['random', 'public']),
-)
-@click.option('--linger', default=False, is_flag=True, help='Linger after pairing')
 @click.option(
     '--io',
     type=click.Choice(
@@ -491,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'
@@ -518,10 +440,7 @@ def main(
     mitm,
     bond,
     ctkd,
-    identity_address,
-    linger,
     io,
-    oob,
     prompt,
     request,
     print_keys,
@@ -544,10 +463,7 @@ def main(
             mitm,
             bond,
             ctkd,
-            identity_address,
-            linger,
             io,
-            oob,
             prompt,
             request,
             print_keys,

apps/player/player.py

@@ -1,608 +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
-# -----------------------------------------------------------------------------
-from __future__ import annotations
-import asyncio
-import asyncio.subprocess
-import os
-import logging
-from typing import Optional, Union
-
-import click
-
-from bumble.a2dp import (
-    make_audio_source_service_sdp_records,
-    A2DP_SBC_CODEC_TYPE,
-    A2DP_MPEG_2_4_AAC_CODEC_TYPE,
-    A2DP_NON_A2DP_CODEC_TYPE,
-    AacFrame,
-    AacParser,
-    AacPacketSource,
-    AacMediaCodecInformation,
-    SbcFrame,
-    SbcParser,
-    SbcPacketSource,
-    SbcMediaCodecInformation,
-    OpusPacket,
-    OpusParser,
-    OpusPacketSource,
-    OpusMediaCodecInformation,
-)
-from bumble.avrcp import Protocol as AvrcpProtocol
-from bumble.avdtp import (
-    find_avdtp_service_with_connection,
-    AVDTP_AUDIO_MEDIA_TYPE,
-    AVDTP_DELAY_REPORTING_SERVICE_CATEGORY,
-    MediaCodecCapabilities,
-    MediaPacketPump,
-    Protocol as AvdtpProtocol,
-)
-from bumble.colors import color
-from bumble.core import (
-    AdvertisingData,
-    ConnectionError as BumbleConnectionError,
-    DeviceClass,
-    BT_BR_EDR_TRANSPORT,
-)
-from bumble.device import Connection, Device, DeviceConfiguration
-from bumble.hci import Address, HCI_CONNECTION_ALREADY_EXISTS_ERROR, HCI_Constant
-from bumble.pairing import PairingConfig
-from bumble.transport import open_transport
-from bumble.utils import AsyncRunner
-
-
-# -----------------------------------------------------------------------------
-# Logging
-# -----------------------------------------------------------------------------
-logger = logging.getLogger(__name__)
-
-
-# -----------------------------------------------------------------------------
-def a2dp_source_sdp_records():
-    service_record_handle = 0x00010001
-    return {
-        service_record_handle: make_audio_source_service_sdp_records(
-            service_record_handle
-        )
-    }
-
-
-# -----------------------------------------------------------------------------
-async def sbc_codec_capabilities(read_function) -> MediaCodecCapabilities:
-    sbc_parser = SbcParser(read_function)
-    sbc_frame: SbcFrame
-    async for sbc_frame in sbc_parser.frames:
-        # We only need the first frame
-        print(color(f"SBC format: {sbc_frame}", "cyan"))
-        break
-
-    channel_mode = [
-        SbcMediaCodecInformation.ChannelMode.MONO,
-        SbcMediaCodecInformation.ChannelMode.DUAL_CHANNEL,
-        SbcMediaCodecInformation.ChannelMode.STEREO,
-        SbcMediaCodecInformation.ChannelMode.JOINT_STEREO,
-    ][sbc_frame.channel_mode]
-    block_length = {
-        4: SbcMediaCodecInformation.BlockLength.BL_4,
-        8: SbcMediaCodecInformation.BlockLength.BL_8,
-        12: SbcMediaCodecInformation.BlockLength.BL_12,
-        16: SbcMediaCodecInformation.BlockLength.BL_16,
-    }[sbc_frame.block_count]
-    subbands = {
-        4: SbcMediaCodecInformation.Subbands.S_4,
-        8: SbcMediaCodecInformation.Subbands.S_8,
-    }[sbc_frame.subband_count]
-    allocation_method = [
-        SbcMediaCodecInformation.AllocationMethod.LOUDNESS,
-        SbcMediaCodecInformation.AllocationMethod.SNR,
-    ][sbc_frame.allocation_method]
-    return MediaCodecCapabilities(
-        media_type=AVDTP_AUDIO_MEDIA_TYPE,
-        media_codec_type=A2DP_SBC_CODEC_TYPE,
-        media_codec_information=SbcMediaCodecInformation(
-            sampling_frequency=SbcMediaCodecInformation.SamplingFrequency.from_int(
-                sbc_frame.sampling_frequency
-            ),
-            channel_mode=channel_mode,
-            block_length=block_length,
-            subbands=subbands,
-            allocation_method=allocation_method,
-            minimum_bitpool_value=2,
-            maximum_bitpool_value=40,
-        ),
-    )
-
-
-# -----------------------------------------------------------------------------
-async def aac_codec_capabilities(read_function) -> MediaCodecCapabilities:
-    aac_parser = AacParser(read_function)
-    aac_frame: AacFrame
-    async for aac_frame in aac_parser.frames:
-        # We only need the first frame
-        print(color(f"AAC format: {aac_frame}", "cyan"))
-        break
-
-    sampling_frequency = AacMediaCodecInformation.SamplingFrequency.from_int(
-        aac_frame.sampling_frequency
-    )
-    channels = (
-        AacMediaCodecInformation.Channels.MONO
-        if aac_frame.channel_configuration == 1
-        else AacMediaCodecInformation.Channels.STEREO
-    )
-
-    return MediaCodecCapabilities(
-        media_type=AVDTP_AUDIO_MEDIA_TYPE,
-        media_codec_type=A2DP_MPEG_2_4_AAC_CODEC_TYPE,
-        media_codec_information=AacMediaCodecInformation(
-            object_type=AacMediaCodecInformation.ObjectType.MPEG_2_AAC_LC,
-            sampling_frequency=sampling_frequency,
-            channels=channels,
-            vbr=1,
-            bitrate=128000,
-        ),
-    )
-
-
-# -----------------------------------------------------------------------------
-async def opus_codec_capabilities(read_function) -> MediaCodecCapabilities:
-    opus_parser = OpusParser(read_function)
-    opus_packet: OpusPacket
-    async for opus_packet in opus_parser.packets:
-        # We only need the first packet
-        print(color(f"Opus format: {opus_packet}", "cyan"))
-        break
-
-    if opus_packet.channel_mode == OpusPacket.ChannelMode.MONO:
-        channel_mode = OpusMediaCodecInformation.ChannelMode.MONO
-    elif opus_packet.channel_mode == OpusPacket.ChannelMode.STEREO:
-        channel_mode = OpusMediaCodecInformation.ChannelMode.STEREO
-    else:
-        channel_mode = OpusMediaCodecInformation.ChannelMode.DUAL_MONO
-
-    if opus_packet.duration == 10:
-        frame_size = OpusMediaCodecInformation.FrameSize.FS_10MS
-    else:
-        frame_size = OpusMediaCodecInformation.FrameSize.FS_20MS
-
-    return MediaCodecCapabilities(
-        media_type=AVDTP_AUDIO_MEDIA_TYPE,
-        media_codec_type=A2DP_NON_A2DP_CODEC_TYPE,
-        media_codec_information=OpusMediaCodecInformation(
-            channel_mode=channel_mode,
-            sampling_frequency=OpusMediaCodecInformation.SamplingFrequency.SF_48000,
-            frame_size=frame_size,
-        ),
-    )
-
-
-# -----------------------------------------------------------------------------
-class Player:
-    def __init__(
-        self,
-        transport: str,
-        device_config: Optional[str],
-        authenticate: bool,
-        encrypt: bool,
-    ) -> None:
-        self.transport = transport
-        self.device_config = device_config
-        self.authenticate = authenticate
-        self.encrypt = encrypt
-        self.avrcp_protocol: Optional[AvrcpProtocol] = None
-        self.done: Optional[asyncio.Event]
-
-    async def run(self, workload) -> None:
-        self.done = asyncio.Event()
-        try:
-            await self._run(workload)
-        except Exception as error:
-            print(color(f"!!! ERROR: {error}", "red"))
-
-    async def _run(self, workload) -> None:
-        async with await open_transport(self.transport) as (hci_source, hci_sink):
-            # Create a device
-            device_config = DeviceConfiguration()
-            if self.device_config:
-                device_config.load_from_file(self.device_config)
-            else:
-                device_config.name = "Bumble Player"
-                device_config.class_of_device = DeviceClass.pack_class_of_device(
-                    DeviceClass.AUDIO_SERVICE_CLASS,
-                    DeviceClass.AUDIO_VIDEO_MAJOR_DEVICE_CLASS,
-                    DeviceClass.AUDIO_VIDEO_UNCATEGORIZED_MINOR_DEVICE_CLASS,
-                )
-                device_config.keystore = "JsonKeyStore"
-
-            device_config.classic_enabled = True
-            device_config.le_enabled = False
-            device_config.le_simultaneous_enabled = False
-            device_config.classic_sc_enabled = False
-            device_config.classic_smp_enabled = False
-            device = Device.from_config_with_hci(device_config, hci_source, hci_sink)
-
-            # Setup the SDP records to expose the SRC service
-            device.sdp_service_records = a2dp_source_sdp_records()
-
-            # Setup AVRCP
-            self.avrcp_protocol = AvrcpProtocol()
-            self.avrcp_protocol.listen(device)
-
-            # Don't require MITM when pairing.
-            device.pairing_config_factory = lambda connection: PairingConfig(mitm=False)
-
-            # Start the controller
-            await device.power_on()
-
-            # Print some of the config/properties
-            print(
-                "Player Bluetooth Address:",
-                color(
-                    device.public_address.to_string(with_type_qualifier=False),
-                    "yellow",
-                ),
-            )
-
-            # Listen for connections
-            device.on("connection", self.on_bluetooth_connection)
-
-            # Run the workload
-            try:
-                await workload(device)
-            except BumbleConnectionError as error:
-                if error.error_code == HCI_CONNECTION_ALREADY_EXISTS_ERROR:
-                    print(color("Connection already established", "blue"))
-                else:
-                    print(color(f"Failed to connect: {error}", "red"))
-
-            # Wait until it is time to exit
-            assert self.done is not None
-            await asyncio.wait(
-                [hci_source.terminated, asyncio.ensure_future(self.done.wait())],
-                return_when=asyncio.FIRST_COMPLETED,
-            )
-
-    def on_bluetooth_connection(self, connection: Connection) -> None:
-        print(color(f"--- Connected: {connection}", "cyan"))
-        connection.on("disconnection", self.on_bluetooth_disconnection)
-
-    def on_bluetooth_disconnection(self, reason) -> None:
-        print(color(f"--- Disconnected: {HCI_Constant.error_name(reason)}", "cyan"))
-        self.set_done()
-
-    async def connect(self, device: Device, address: str) -> Connection:
-        print(color(f"Connecting to {address}...", "green"))
-        connection = await device.connect(address, transport=BT_BR_EDR_TRANSPORT)
-
-        # Request authentication
-        if self.authenticate:
-            print(color("*** Authenticating...", "blue"))
-            await connection.authenticate()
-            print(color("*** Authenticated", "blue"))
-
-        # Enable encryption
-        if self.encrypt:
-            print(color("*** Enabling encryption...", "blue"))
-            await connection.encrypt()
-            print(color("*** Encryption on", "blue"))
-
-        return connection
-
-    async def create_avdtp_protocol(self, connection: Connection) -> AvdtpProtocol:
-        # Look for an A2DP service
-        avdtp_version = await find_avdtp_service_with_connection(connection)
-        if not avdtp_version:
-            raise RuntimeError("no A2DP service found")
-
-        print(color(f"AVDTP Version: {avdtp_version}"))
-
-        # Create a client to interact with the remote device
-        return await AvdtpProtocol.connect(connection, avdtp_version)
-
-    async def stream_packets(
-        self,
-        protocol: AvdtpProtocol,
-        codec_type: int,
-        vendor_id: int,
-        codec_id: int,
-        packet_source: Union[SbcPacketSource, AacPacketSource, OpusPacketSource],
-        codec_capabilities: MediaCodecCapabilities,
-    ):
-        # Discover all endpoints on the remote device
-        endpoints = await protocol.discover_remote_endpoints()
-        for endpoint in endpoints:
-            print('@@@', endpoint)
-
-        # Select a sink
-        sink = protocol.find_remote_sink_by_codec(
-            AVDTP_AUDIO_MEDIA_TYPE, codec_type, vendor_id, codec_id
-        )
-        if sink is None:
-            print(color('!!! no compatible sink found', 'red'))
-            return
-        print(f'### Selected sink: {sink.seid}')
-
-        # Check if the sink supports delay reporting
-        delay_reporting = False
-        for capability in sink.capabilities:
-            if capability.service_category == AVDTP_DELAY_REPORTING_SERVICE_CATEGORY:
-                delay_reporting = True
-                break
-
-        def on_delay_report(delay: int):
-            print(color(f"*** DELAY REPORT: {delay}", "blue"))
-
-        # Adjust the codec capabilities for certain codecs
-        for capability in sink.capabilities:
-            if isinstance(capability, MediaCodecCapabilities):
-                if isinstance(
-                    codec_capabilities.media_codec_information, SbcMediaCodecInformation
-                ) and isinstance(
-                    capability.media_codec_information, SbcMediaCodecInformation
-                ):
-                    codec_capabilities.media_codec_information.minimum_bitpool_value = (
-                        capability.media_codec_information.minimum_bitpool_value
-                    )
-                    codec_capabilities.media_codec_information.maximum_bitpool_value = (
-                        capability.media_codec_information.maximum_bitpool_value
-                    )
-                    print(color("Source media codec:", "green"), codec_capabilities)
-
-        # Stream the packets
-        packet_pump = MediaPacketPump(packet_source.packets)
-        source = protocol.add_source(codec_capabilities, packet_pump, delay_reporting)
-        source.on("delay_report", on_delay_report)
-        stream = await protocol.create_stream(source, sink)
-        await stream.start()
-
-        await packet_pump.wait_for_completion()
-
-    async def discover(self, device: Device) -> None:
-        @device.listens_to("inquiry_result")
-        def on_inquiry_result(
-            address: Address, class_of_device: int, data: AdvertisingData, rssi: int
-        ) -> None:
-            (
-                service_classes,
-                major_device_class,
-                minor_device_class,
-            ) = DeviceClass.split_class_of_device(class_of_device)
-            separator = "\n  "
-            print(f">>> {color(address.to_string(False), 'yellow')}:")
-            print(f"  Device Class (raw): {class_of_device:06X}")
-            major_class_name = DeviceClass.major_device_class_name(major_device_class)
-            print("  Device Major Class: " f"{major_class_name}")
-            minor_class_name = DeviceClass.minor_device_class_name(
-                major_device_class, minor_device_class
-            )
-            print("  Device Minor Class: " f"{minor_class_name}")
-            print(
-                "  Device Services: "
-                f"{', '.join(DeviceClass.service_class_labels(service_classes))}"
-            )
-            print(f"  RSSI: {rssi}")
-            if data.ad_structures:
-                print(f"  {data.to_string(separator)}")
-
-        await device.start_discovery()
-
-    async def pair(self, device: Device, address: str) -> None:
-        print(color(f"Connecting to {address}...", "green"))
-        connection = await device.connect(address, transport=BT_BR_EDR_TRANSPORT)
-
-        print(color("Pairing...", "magenta"))
-        await connection.authenticate()
-        print(color("Pairing completed", "magenta"))
-        self.set_done()
-
-    async def inquire(self, device: Device, address: str) -> None:
-        connection = await self.connect(device, address)
-        avdtp_protocol = await self.create_avdtp_protocol(connection)
-
-        # Discover the remote endpoints
-        endpoints = await avdtp_protocol.discover_remote_endpoints()
-        print(f'@@@ Found {len(list(endpoints))} endpoints')
-        for endpoint in endpoints:
-            print('@@@', endpoint)
-
-        self.set_done()
-
-    async def play(
-        self,
-        device: Device,
-        address: Optional[str],
-        audio_format: str,
-        audio_file: str,
-    ) -> None:
-        if audio_format == "auto":
-            if audio_file.endswith(".sbc"):
-                audio_format = "sbc"
-            elif audio_file.endswith(".aac") or audio_file.endswith(".adts"):
-                audio_format = "aac"
-            elif audio_file.endswith(".ogg"):
-                audio_format = "opus"
-            else:
-                raise ValueError("Unable to determine audio format from file extension")
-
-        device.on(
-            "connection",
-            lambda connection: AsyncRunner.spawn(on_connection(connection)),
-        )
-
-        async def on_connection(connection: Connection):
-            avdtp_protocol = await self.create_avdtp_protocol(connection)
-
-            with open(audio_file, 'rb') as input_file:
-                # NOTE: this should be using asyncio file reading, but blocking reads
-                # are good enough for this command line app.
-                async def read_audio_data(byte_count):
-                    return input_file.read(byte_count)
-
-                # Obtain the codec capabilities from the stream
-                packet_source: Union[SbcPacketSource, AacPacketSource, OpusPacketSource]
-                vendor_id = 0
-                codec_id = 0
-                if audio_format == "sbc":
-                    codec_type = A2DP_SBC_CODEC_TYPE
-                    codec_capabilities = await sbc_codec_capabilities(read_audio_data)
-                    packet_source = SbcPacketSource(
-                        read_audio_data,
-                        avdtp_protocol.l2cap_channel.peer_mtu,
-                    )
-                elif audio_format == "aac":
-                    codec_type = A2DP_MPEG_2_4_AAC_CODEC_TYPE
-                    codec_capabilities = await aac_codec_capabilities(read_audio_data)
-                    packet_source = AacPacketSource(
-                        read_audio_data,
-                        avdtp_protocol.l2cap_channel.peer_mtu,
-                    )
-                else:
-                    codec_type = A2DP_NON_A2DP_CODEC_TYPE
-                    vendor_id = OpusMediaCodecInformation.VENDOR_ID
-                    codec_id = OpusMediaCodecInformation.CODEC_ID
-                    codec_capabilities = await opus_codec_capabilities(read_audio_data)
-                    packet_source = OpusPacketSource(
-                        read_audio_data,
-                        avdtp_protocol.l2cap_channel.peer_mtu,
-                    )
-
-                # Rewind to the start
-                input_file.seek(0)
-
-                try:
-                    await self.stream_packets(
-                        avdtp_protocol,
-                        codec_type,
-                        vendor_id,
-                        codec_id,
-                        packet_source,
-                        codec_capabilities,
-                    )
-                except Exception as error:
-                    print(color(f"!!! Error while streaming: {error}", "red"))
-
-            self.set_done()
-
-        if address:
-            await self.connect(device, address)
-        else:
-            print(color("Waiting for an incoming connection...", "magenta"))
-
-    def set_done(self) -> None:
-        if self.done:
-            self.done.set()
-
-
-# -----------------------------------------------------------------------------
-def create_player(context) -> Player:
-    return Player(
-        transport=context.obj["hci_transport"],
-        device_config=context.obj["device_config"],
-        authenticate=context.obj["authenticate"],
-        encrypt=context.obj["encrypt"],
-    )
-
-
-# -----------------------------------------------------------------------------
-@click.group()
-@click.pass_context
-@click.option("--hci-transport", metavar="TRANSPORT", required=True)
-@click.option("--device-config", metavar="FILENAME", help="Device configuration file")
-@click.option(
-    "--authenticate",
-    is_flag=True,
-    help="Request authentication when connecting",
-    default=False,
-)
-@click.option(
-    "--encrypt", is_flag=True, help="Request encryption when connecting", default=True
-)
-def player_cli(ctx, hci_transport, device_config, authenticate, encrypt):
-    ctx.ensure_object(dict)
-    ctx.obj["hci_transport"] = hci_transport
-    ctx.obj["device_config"] = device_config
-    ctx.obj["authenticate"] = authenticate
-    ctx.obj["encrypt"] = encrypt
-
-
-@player_cli.command("discover")
-@click.pass_context
-def discover(context):
-    """Discover speakers or headphones"""
-    player = create_player(context)
-    asyncio.run(player.run(player.discover))
-
-
-@player_cli.command("inquire")
-@click.pass_context
-@click.argument(
-    "address",
-    metavar="ADDRESS",
-)
-def inquire(context, address):
-    """Connect to a speaker or headphone and inquire about their capabilities"""
-    player = create_player(context)
-    asyncio.run(player.run(lambda device: player.inquire(device, address)))
-
-
-@player_cli.command("pair")
-@click.pass_context
-@click.argument(
-    "address",
-    metavar="ADDRESS",
-)
-def pair(context, address):
-    """Pair with a speaker or headphone"""
-    player = create_player(context)
-    asyncio.run(player.run(lambda device: player.pair(device, address)))
-
-
-@player_cli.command("play")
-@click.pass_context
-@click.option(
-    "--connect",
-    "address",
-    metavar="ADDRESS",
-    help="Address or name to connect to",
-)
-@click.option(
-    "-f",
-    "--audio-format",
-    type=click.Choice(["auto", "sbc", "aac", "opus"]),
-    help="Audio file format (use 'auto' to infer the format from the file extension)",
-    default="auto",
-)
-@click.argument("audio_file")
-def play(context, address, audio_format, audio_file):
-    """Play and audio file"""
-    player = create_player(context)
-    asyncio.run(
-        player.run(
-            lambda device: player.play(device, address, audio_format, audio_file)
-        )
-    )
-
-
-# -----------------------------------------------------------------------------
-def main():
-    logging.basicConfig(level=os.environ.get("BUMBLE_LOGLEVEL", "WARNING").upper())
-    player_cli()
-
-
-# -----------------------------------------------------------------------------
-if __name__ == "__main__":
-    main()  # pylint: disable=no-value-for-parameter

apps/rfcomm_bridge.py

@@ -1,511 +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
-
-import click
-
-from bumble.colors import color
-from bumble.device import Device, DeviceConfiguration, Connection
-from bumble import core
-from bumble import hci
-from bumble import rfcomm
-from bumble import transport
-from bumble import utils
-
-
-# -----------------------------------------------------------------------------
-# Constants
-# -----------------------------------------------------------------------------
-DEFAULT_RFCOMM_UUID = "E6D55659-C8B4-4B85-96BB-B1143AF6D3AE"
-DEFAULT_MTU = 4096
-DEFAULT_CLIENT_TCP_PORT = 9544
-DEFAULT_SERVER_TCP_PORT = 9545
-
-TRACE_MAX_SIZE = 48
-
-
-# -----------------------------------------------------------------------------
-class Tracer:
-    """
-    Trace data buffers transmitted from one endpoint to another, with stats.
-    """
-
-    def __init__(self, channel_name: str) -> None:
-        self.channel_name = channel_name
-        self.last_ts: float = 0.0
-
-    def trace_data(self, data: bytes) -> None:
-        now = time.time()
-        elapsed_s = now - self.last_ts if self.last_ts else 0
-        elapsed_ms = int(elapsed_s * 1000)
-        instant_throughput_kbps = ((len(data) / elapsed_s) / 1000) if elapsed_s else 0.0
-
-        hex_str = data[:TRACE_MAX_SIZE].hex() + (
-            "..." if len(data) > TRACE_MAX_SIZE else ""
-        )
-        print(
-            f"[{self.channel_name}] {len(data):4} bytes "
-            f"(+{elapsed_ms:4}ms, {instant_throughput_kbps: 7.2f}kB/s) "
-            f" {hex_str}"
-        )
-
-        self.last_ts = now
-
-
-# -----------------------------------------------------------------------------
-class ServerBridge:
-    """
-    RFCOMM server bridge: waits for a peer to connect an RFCOMM channel.
-    The RFCOMM channel may be associated with a UUID published in an SDP service
-    description, or simply be on a system-assigned channel number.
-    When the connection is made, the bridge connects a TCP socket to a remote host and
-    bridges the data in both directions, with flow control.
-    When the RFCOMM channel is closed, the bridge disconnects the TCP socket
-    and waits for a new channel to be connected.
-    """
-
-    READ_CHUNK_SIZE = 4096
-
-    def __init__(
-        self, channel: int, uuid: str, trace: bool, tcp_host: str, tcp_port: int
-    ) -> None:
-        self.device: Optional[Device] = None
-        self.channel = channel
-        self.uuid = uuid
-        self.tcp_host = tcp_host
-        self.tcp_port = tcp_port
-        self.rfcomm_channel: Optional[rfcomm.DLC] = None
-        self.tcp_tracer: Optional[Tracer]
-        self.rfcomm_tracer: Optional[Tracer]
-
-        if trace:
-            self.tcp_tracer = Tracer(color("RFCOMM->TCP", "cyan"))
-            self.rfcomm_tracer = Tracer(color("TCP->RFCOMM", "magenta"))
-        else:
-            self.rfcomm_tracer = None
-            self.tcp_tracer = None
-
-    async def start(self, device: Device) -> None:
-        self.device = device
-
-        # Create and register a server
-        rfcomm_server = rfcomm.Server(self.device)
-
-        # Listen for incoming DLC connections
-        self.channel = rfcomm_server.listen(self.on_rfcomm_channel, self.channel)
-
-        # Setup the SDP to advertise this channel
-        service_record_handle = 0x00010001
-        self.device.sdp_service_records = {
-            service_record_handle: rfcomm.make_service_sdp_records(
-                service_record_handle, self.channel, core.UUID(self.uuid)
-            )
-        }
-
-        # We're ready for a connection
-        self.device.on("connection", self.on_connection)
-        await self.set_available(True)
-
-        print(
-            color(
-                (
-                    f"### Listening for RFCOMM connection on {device.public_address}, "
-                    f"channel {self.channel}"
-                ),
-                "yellow",
-            )
-        )
-
-    async def set_available(self, available: bool):
-        # Become discoverable and connectable
-        assert self.device
-        await self.device.set_connectable(available)
-        await self.device.set_discoverable(available)
-
-    def on_connection(self, connection):
-        print(color(f"@@@ Bluetooth connection: {connection}", "blue"))
-        connection.on("disconnection", self.on_disconnection)
-
-        # Don't accept new connections until we're disconnected
-        utils.AsyncRunner.spawn(self.set_available(False))
-
-    def on_disconnection(self, reason: int):
-        print(
-            color("@@@ Bluetooth disconnection:", "red"),
-            hci.HCI_Constant.error_name(reason),
-        )
-
-        # We're ready for a new connection
-        utils.AsyncRunner.spawn(self.set_available(True))
-
-    # Called when an RFCOMM channel is established
-    @utils.AsyncRunner.run_in_task()
-    async def on_rfcomm_channel(self, rfcomm_channel):
-        print(color("*** RFCOMM channel:", "cyan"), rfcomm_channel)
-
-        # Connect to the TCP server
-        print(
-            color(
-                f"### Connecting to TCP {self.tcp_host}:{self.tcp_port}",
-                "yellow",
-            )
-        )
-        try:
-            reader, writer = await asyncio.open_connection(self.tcp_host, self.tcp_port)
-        except OSError:
-            print(color("!!! Connection failed", "red"))
-            await rfcomm_channel.disconnect()
-            return
-
-        # Pipe data from RFCOMM to TCP
-        def on_rfcomm_channel_closed():
-            print(color("*** RFCOMM channel closed", "cyan"))
-            writer.close()
-
-        def write_rfcomm_data(data):
-            if self.rfcomm_tracer:
-                self.rfcomm_tracer.trace_data(data)
-
-            writer.write(data)
-
-        rfcomm_channel.sink = write_rfcomm_data
-        rfcomm_channel.on("close", on_rfcomm_channel_closed)
-
-        # Pipe data from TCP to RFCOMM
-        while True:
-            try:
-                data = await reader.read(self.READ_CHUNK_SIZE)
-
-                if len(data) == 0:
-                    print(color("### TCP end of stream", "yellow"))
-                    if rfcomm_channel.state == rfcomm.DLC.State.CONNECTED:
-                        await rfcomm_channel.disconnect()
-                    return
-
-                if self.tcp_tracer:
-                    self.tcp_tracer.trace_data(data)
-
-                rfcomm_channel.write(data)
-                await rfcomm_channel.drain()
-            except Exception as error:
-                print(f"!!! Exception: {error}")
-                break
-
-        writer.close()
-        await writer.wait_closed()
-        print(color("~~~ Bye bye", "magenta"))
-
-
-# -----------------------------------------------------------------------------
-class ClientBridge:
-    """
-    RFCOMM client bridge: connects to a BR/EDR device, then waits for an inbound
-    TCP connection on a specified port number. When a TCP client connects, an
-    RFCOMM connection to the device is established, and the data is bridged in both
-    directions, with flow control.
-    When the TCP connection is closed by the client, the RFCOMM channel is
-    disconnected, but the connection to the device remains, ready for a new TCP client
-    to connect.
-    """
-
-    READ_CHUNK_SIZE = 4096
-
-    def __init__(
-        self,
-        channel: int,
-        uuid: str,
-        trace: bool,
-        address: str,
-        tcp_host: str,
-        tcp_port: int,
-        encrypt: bool,
-    ):
-        self.channel = channel
-        self.uuid = uuid
-        self.trace = trace
-        self.address = address
-        self.tcp_host = tcp_host
-        self.tcp_port = tcp_port
-        self.encrypt = encrypt
-        self.device: Optional[Device] = None
-        self.connection: Optional[Connection] = None
-        self.rfcomm_client: Optional[rfcomm.Client]
-        self.rfcomm_mux: Optional[rfcomm.Multiplexer]
-        self.tcp_connected: bool = False
-
-        self.tcp_tracer: Optional[Tracer]
-        self.rfcomm_tracer: Optional[Tracer]
-
-        if trace:
-            self.tcp_tracer = Tracer(color("RFCOMM->TCP", "cyan"))
-            self.rfcomm_tracer = Tracer(color("TCP->RFCOMM", "magenta"))
-        else:
-            self.rfcomm_tracer = None
-            self.tcp_tracer = None
-
-    async def connect(self) -> None:
-        if self.connection:
-            return
-
-        print(color(f"@@@ Connecting to Bluetooth {self.address}", "blue"))
-        assert self.device
-        self.connection = await self.device.connect(
-            self.address, transport=core.BT_BR_EDR_TRANSPORT
-        )
-        print(color(f"@@@ Bluetooth connection: {self.connection}", "blue"))
-        self.connection.on("disconnection", self.on_disconnection)
-
-        if self.encrypt:
-            print(color("@@@ Encrypting Bluetooth connection", "blue"))
-            await self.connection.encrypt()
-            print(color("@@@ Bluetooth connection encrypted", "blue"))
-
-        self.rfcomm_client = rfcomm.Client(self.connection)
-        try:
-            self.rfcomm_mux = await self.rfcomm_client.start()
-        except BaseException as e:
-            print(color("!!! Failed to setup RFCOMM connection", "red"), e)
-            raise
-
-    async def start(self, device: Device) -> None:
-        self.device = device
-        await device.set_connectable(False)
-        await device.set_discoverable(False)
-
-        # Called when a TCP connection is established
-        async def on_tcp_connection(reader, writer):
-            print(color("<<< TCP connection", "magenta"))
-            if self.tcp_connected:
-                print(
-                    color("!!! TCP connection already active, rejecting new one", "red")
-                )
-                writer.close()
-                return
-            self.tcp_connected = True
-
-            try:
-                await self.pipe(reader, writer)
-            except BaseException as error:
-                print(color("!!! Exception while piping data:", "red"), error)
-                return
-            finally:
-                writer.close()
-                await writer.wait_closed()
-                self.tcp_connected = False
-
-        await asyncio.start_server(
-            on_tcp_connection,
-            host=self.tcp_host if self.tcp_host != "_" else None,
-            port=self.tcp_port,
-        )
-        print(
-            color(
-                f"### Listening for TCP connections on port {self.tcp_port}", "magenta"
-            )
-        )
-
-    async def pipe(
-        self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter
-    ) -> None:
-        # Resolve the channel number from the UUID if needed
-        if self.channel == 0:
-            await self.connect()
-            assert self.connection
-            channel = await rfcomm.find_rfcomm_channel_with_uuid(
-                self.connection, self.uuid
-            )
-            if channel:
-                print(color(f"### Found RFCOMM channel {channel}", "yellow"))
-            else:
-                print(color(f"!!! RFCOMM channel with UUID {self.uuid} not found"))
-                return
-        else:
-            channel = self.channel
-
-        # Connect a new RFCOMM channel
-        await self.connect()
-        assert self.rfcomm_mux
-        print(color(f"*** Opening RFCOMM channel {channel}", "green"))
-        try:
-            rfcomm_channel = await self.rfcomm_mux.open_dlc(channel)
-            print(color(f"*** RFCOMM channel open: {rfcomm_channel}", "green"))
-        except Exception as error:
-            print(color(f"!!! RFCOMM open failed: {error}", "red"))
-            return
-
-        # Pipe data from RFCOMM to TCP
-        def on_rfcomm_channel_closed():
-            print(color("*** RFCOMM channel closed", "green"))
-
-        def write_rfcomm_data(data):
-            if self.trace:
-                self.rfcomm_tracer.trace_data(data)
-
-            writer.write(data)
-
-        rfcomm_channel.on("close", on_rfcomm_channel_closed)
-        rfcomm_channel.sink = write_rfcomm_data
-
-        # Pipe data from TCP to RFCOMM
-        while True:
-            try:
-                data = await reader.read(self.READ_CHUNK_SIZE)
-
-                if len(data) == 0:
-                    print(color("### TCP end of stream", "yellow"))
-                    if rfcomm_channel.state == rfcomm.DLC.State.CONNECTED:
-                        await rfcomm_channel.disconnect()
-                    self.tcp_connected = False
-                    return
-
-                if self.tcp_tracer:
-                    self.tcp_tracer.trace_data(data)
-
-                rfcomm_channel.write(data)
-                await rfcomm_channel.drain()
-            except Exception as error:
-                print(f"!!! Exception: {error}")
-                break
-
-        print(color("~~~ Bye bye", "magenta"))
-
-    def on_disconnection(self, reason: int) -> None:
-        print(
-            color("@@@ Bluetooth disconnection:", "red"),
-            hci.HCI_Constant.error_name(reason),
-        )
-        self.connection = None
-
-
-# -----------------------------------------------------------------------------
-async def run(device_config, hci_transport, bridge):
-    print("<<< connecting to HCI...")
-    async with await transport.open_transport_or_link(hci_transport) as (
-        hci_source,
-        hci_sink,
-    ):
-        print("<<< connected")
-
-        if device_config:
-            device = Device.from_config_file_with_hci(
-                device_config, hci_source, hci_sink
-            )
-        else:
-            device = Device.from_config_with_hci(
-                DeviceConfiguration(), hci_source, hci_sink
-            )
-        device.classic_enabled = True
-
-        # Let's go
-        await device.power_on()
-        try:
-            await bridge.start(device)
-
-            # Wait until the transport terminates
-            await hci_source.wait_for_termination()
-        except core.ConnectionError as error:
-            print(color(f"!!! Bluetooth connection failed: {error}", "red"))
-        except Exception as error:
-            print(f"Exception while running bridge: {error}")
-
-
-# -----------------------------------------------------------------------------
-@click.group()
-@click.pass_context
-@click.option(
-    "--device-config",
-    metavar="CONFIG_FILE",
-    help="Device configuration file",
-)
-@click.option(
-    "--hci-transport", metavar="TRANSPORT_NAME", help="HCI transport", required=True
-)
-@click.option("--trace", is_flag=True, help="Trace bridged data to stdout")
-@click.option(
-    "--channel",
-    metavar="CHANNEL_NUMER",
-    help="RFCOMM channel number",
-    type=int,
-    default=0,
-)
-@click.option(
-    "--uuid",
-    metavar="UUID",
-    help="UUID for the RFCOMM channel",
-    default=DEFAULT_RFCOMM_UUID,
-)
-def cli(
-    context,
-    device_config,
-    hci_transport,
-    trace,
-    channel,
-    uuid,
-):
-    context.ensure_object(dict)
-    context.obj["device_config"] = device_config
-    context.obj["hci_transport"] = hci_transport
-    context.obj["trace"] = trace
-    context.obj["channel"] = channel
-    context.obj["uuid"] = uuid
-
-
-# -----------------------------------------------------------------------------
-@cli.command()
-@click.pass_context
-@click.option("--tcp-host", help="TCP host", default="localhost")
-@click.option("--tcp-port", help="TCP port", default=DEFAULT_SERVER_TCP_PORT)
-def server(context, tcp_host, tcp_port):
-    bridge = ServerBridge(
-        context.obj["channel"],
-        context.obj["uuid"],
-        context.obj["trace"],
-        tcp_host,
-        tcp_port,
-    )
-    asyncio.run(run(context.obj["device_config"], context.obj["hci_transport"], bridge))
-
-
-# -----------------------------------------------------------------------------
-@cli.command()
-@click.pass_context
-@click.argument("bluetooth-address")
-@click.option("--tcp-host", help="TCP host", default="_")
-@click.option("--tcp-port", help="TCP port", default=DEFAULT_CLIENT_TCP_PORT)
-@click.option("--encrypt", is_flag=True, help="Encrypt the connection")
-def client(context, bluetooth_address, tcp_host, tcp_port, encrypt):
-    bridge = ClientBridge(
-        context.obj["channel"],
-        context.obj["uuid"],
-        context.obj["trace"],
-        bluetooth_address,
-        tcp_host,
-        tcp_port,
-        encrypt,
-    )
-    asyncio.run(run(context.obj["device_config"], context.obj["hci_transport"], bridge))
-
-
-# -----------------------------------------------------------------------------
-logging.basicConfig(level=os.environ.get("BUMBLE_LOGLEVEL", "WARNING").upper())
-if __name__ == "__main__":
-    cli(obj={})  # pylint: disable=no-value-for-parameter

apps/scan.py

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

apps/show.py

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

apps/speaker/speaker.py

@@ -44,18 +44,25 @@ from bumble.avdtp import (
     AVDTP_AUDIO_MEDIA_TYPE,
     Listener,
     MediaCodecCapabilities,
+    MediaPacket,
     Protocol,
 )
 from bumble.a2dp import (
+    MPEG_2_AAC_LC_OBJECT_TYPE,
     make_audio_sink_service_sdp_records,
     A2DP_SBC_CODEC_TYPE,
     A2DP_MPEG_2_4_AAC_CODEC_TYPE,
+    SBC_MONO_CHANNEL_MODE,
+    SBC_DUAL_CHANNEL_MODE,
+    SBC_SNR_ALLOCATION_METHOD,
+    SBC_LOUDNESS_ALLOCATION_METHOD,
+    SBC_STEREO_CHANNEL_MODE,
+    SBC_JOINT_STEREO_CHANNEL_MODE,
     SbcMediaCodecInformation,
     AacMediaCodecInformation,
 )
 from bumble.utils import AsyncRunner
 from bumble.codecs import AacAudioRtpPacket
-from bumble.rtp import MediaPacket
 
 
 # -----------------------------------------------------------------------------
@@ -69,7 +76,6 @@ logger = logging.getLogger(__name__)
 # -----------------------------------------------------------------------------
 DEFAULT_UI_PORT = 7654
 
-
 # -----------------------------------------------------------------------------
 class AudioExtractor:
     @staticmethod
@@ -86,7 +92,7 @@ class AudioExtractor:
 # -----------------------------------------------------------------------------
 class AacAudioExtractor:
     def extract_audio(self, packet: MediaPacket) -> bytes:
-        return AacAudioRtpPacket.from_bytes(packet.payload).to_adts()
+        return AacAudioRtpPacket(packet.payload).to_adts()
 
 
 # -----------------------------------------------------------------------------
@@ -189,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,
@@ -370,7 +376,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,
             )
 
@@ -444,12 +450,10 @@ class Speaker:
         return MediaCodecCapabilities(
             media_type=AVDTP_AUDIO_MEDIA_TYPE,
             media_codec_type=A2DP_MPEG_2_4_AAC_CODEC_TYPE,
-            media_codec_information=AacMediaCodecInformation(
-                object_type=AacMediaCodecInformation.ObjectType.MPEG_2_AAC_LC,
-                sampling_frequency=AacMediaCodecInformation.SamplingFrequency.SF_48000
-                | AacMediaCodecInformation.SamplingFrequency.SF_44100,
-                channels=AacMediaCodecInformation.Channels.MONO
-                | AacMediaCodecInformation.Channels.STEREO,
+            media_codec_information=AacMediaCodecInformation.from_lists(
+                object_types=[MPEG_2_AAC_LC_OBJECT_TYPE],
+                sampling_frequencies=[48000, 44100],
+                channels=[1, 2],
                 vbr=1,
                 bitrate=256000,
             ),
@@ -459,23 +463,20 @@ class Speaker:
         return MediaCodecCapabilities(
             media_type=AVDTP_AUDIO_MEDIA_TYPE,
             media_codec_type=A2DP_SBC_CODEC_TYPE,
-            media_codec_information=SbcMediaCodecInformation(
-                sampling_frequency=SbcMediaCodecInformation.SamplingFrequency.SF_48000
-                | SbcMediaCodecInformation.SamplingFrequency.SF_44100
-                | SbcMediaCodecInformation.SamplingFrequency.SF_32000
-                | SbcMediaCodecInformation.SamplingFrequency.SF_16000,
-                channel_mode=SbcMediaCodecInformation.ChannelMode.MONO
-                | SbcMediaCodecInformation.ChannelMode.DUAL_CHANNEL
-                | SbcMediaCodecInformation.ChannelMode.STEREO
-                | SbcMediaCodecInformation.ChannelMode.JOINT_STEREO,
-                block_length=SbcMediaCodecInformation.BlockLength.BL_4
-                | SbcMediaCodecInformation.BlockLength.BL_8
-                | SbcMediaCodecInformation.BlockLength.BL_12
-                | SbcMediaCodecInformation.BlockLength.BL_16,
-                subbands=SbcMediaCodecInformation.Subbands.S_4
-                | SbcMediaCodecInformation.Subbands.S_8,
-                allocation_method=SbcMediaCodecInformation.AllocationMethod.LOUDNESS
-                | SbcMediaCodecInformation.AllocationMethod.SNR,
+            media_codec_information=SbcMediaCodecInformation.from_lists(
+                sampling_frequencies=[48000, 44100, 32000, 16000],
+                channel_modes=[
+                    SBC_MONO_CHANNEL_MODE,
+                    SBC_DUAL_CHANNEL_MODE,
+                    SBC_STEREO_CHANNEL_MODE,
+                    SBC_JOINT_STEREO_CHANNEL_MODE,
+                ],
+                block_lengths=[4, 8, 12, 16],
+                subbands=[4, 8],
+                allocation_methods=[
+                    SBC_LOUDNESS_ALLOCATION_METHOD,
+                    SBC_SNR_ALLOCATION_METHOD,
+                ],
                 minimum_bitpool_value=2,
                 maximum_bitpool_value=53,
             ),
@@ -640,7 +641,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")}')

apps/unbond.py

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

bumble/a2dp.py

@@ -15,18 +15,10 @@
 # -----------------------------------------------------------------------------
 # Imports
 # -----------------------------------------------------------------------------
-from __future__ import annotations
-
-from collections.abc import AsyncGenerator
-import dataclasses
-import enum
-import logging
 import struct
-from typing import Awaitable, Callable
-from typing_extensions import ClassVar, Self
+import logging
+from collections import namedtuple
 
-
-from .codecs import AacAudioRtpPacket
 from .company_ids import COMPANY_IDENTIFIERS
 from .sdp import (
     DataElement,
@@ -46,7 +38,6 @@ from .core import (
     BT_ADVANCED_AUDIO_DISTRIBUTION_SERVICE,
     name_or_number,
 )
-from .rtp import MediaPacket
 
 
 # -----------------------------------------------------------------------------
@@ -108,8 +99,6 @@ SBC_ALLOCATION_METHOD_NAMES = {
     SBC_LOUDNESS_ALLOCATION_METHOD: 'SBC_LOUDNESS_ALLOCATION_METHOD'
 }
 
-SBC_MAX_FRAMES_IN_RTP_PAYLOAD = 15
-
 MPEG_2_4_AAC_SAMPLING_FREQUENCIES = [
     8000,
     11025,
@@ -137,9 +126,6 @@ MPEG_2_4_OBJECT_TYPE_NAMES = {
     MPEG_4_AAC_SCALABLE_OBJECT_TYPE: 'MPEG_4_AAC_SCALABLE_OBJECT_TYPE'
 }
 
-
-OPUS_MAX_FRAMES_IN_RTP_PAYLOAD = 15
-
 # fmt: on
 
 
@@ -194,12 +180,8 @@ def make_audio_source_service_sdp_records(service_record_handle, version=(1, 3))
             SDP_BLUETOOTH_PROFILE_DESCRIPTOR_LIST_ATTRIBUTE_ID,
             DataElement.sequence(
                 [
-                    DataElement.sequence(
-                        [
-                            DataElement.uuid(BT_ADVANCED_AUDIO_DISTRIBUTION_SERVICE),
-                            DataElement.unsigned_integer_16(version_int),
-                        ]
-                    )
+                    DataElement.uuid(BT_ADVANCED_AUDIO_DISTRIBUTION_SERVICE),
+                    DataElement.unsigned_integer_16(version_int),
                 ]
             ),
         ),
@@ -248,12 +230,8 @@ def make_audio_sink_service_sdp_records(service_record_handle, version=(1, 3)):
             SDP_BLUETOOTH_PROFILE_DESCRIPTOR_LIST_ATTRIBUTE_ID,
             DataElement.sequence(
                 [
-                    DataElement.sequence(
-                        [
-                            DataElement.uuid(BT_ADVANCED_AUDIO_DISTRIBUTION_SERVICE),
-                            DataElement.unsigned_integer_16(version_int),
-                        ]
-                    )
+                    DataElement.uuid(BT_ADVANCED_AUDIO_DISTRIBUTION_SERVICE),
+                    DataElement.unsigned_integer_16(version_int),
                 ]
             ),
         ),
@@ -261,67 +239,48 @@ 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: SamplingFrequency
-    channel_mode: ChannelMode
-    block_length: BlockLength
-    subbands: Subbands
-    allocation_method: AllocationMethod
-    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,
+        SBC_DUAL_CHANNEL_MODE: 1 << 2,
+        SBC_STEREO_CHANNEL_MODE: 1 << 1,
+        SBC_JOINT_STEREO_CHANNEL_MODE: 1,
+    }
+    BLOCK_LENGTH_BITS = {4: 1 << 3, 8: 1 << 2, 12: 1 << 1, 16: 1}
+    SUBBANDS_BITS = {4: 1 << 1, 8: 1}
+    ALLOCATION_METHOD_BITS = {
+        SBC_SNR_ALLOCATION_METHOD: 1 << 1,
+        SBC_LOUDNESS_ALLOCATION_METHOD: 1,
+    }
 
-    class SamplingFrequency(enum.IntFlag):
-        SF_16000 = 1 << 3
-        SF_32000 = 1 << 2
-        SF_44100 = 1 << 1
-        SF_48000 = 1 << 0
-
-        @classmethod
-        def from_int(cls, sampling_frequency: int) -> Self:
-            sampling_frequencies = [
-                16000,
-                32000,
-                44100,
-                48000,
-            ]
-            index = sampling_frequencies.index(sampling_frequency)
-            return cls(1 << (len(sampling_frequencies) - index - 1))
-
-    class ChannelMode(enum.IntFlag):
-        MONO = 1 << 3
-        DUAL_CHANNEL = 1 << 2
-        STEREO = 1 << 1
-        JOINT_STEREO = 1 << 0
-
-    class BlockLength(enum.IntFlag):
-        BL_4 = 1 << 3
-        BL_8 = 1 << 2
-        BL_12 = 1 << 1
-        BL_16 = 1 << 0
-
-    class Subbands(enum.IntFlag):
-        S_4 = 1 << 1
-        S_8 = 1 << 0
-
-    class AllocationMethod(enum.IntFlag):
-        SNR = 1 << 1
-        LOUDNESS = 1 << 0
-
-    @classmethod
-    def from_bytes(cls, data: bytes) -> Self:
-        sampling_frequency = cls.SamplingFrequency((data[0] >> 4) & 0x0F)
-        channel_mode = cls.ChannelMode((data[0] >> 0) & 0x0F)
-        block_length = cls.BlockLength((data[1] >> 4) & 0x0F)
-        subbands = cls.Subbands((data[1] >> 2) & 0x03)
-        allocation_method = cls.AllocationMethod((data[1] >> 0) & 0x03)
+    @staticmethod
+    def from_bytes(data: bytes) -> 'SbcMediaCodecInformation':
+        sampling_frequency = (data[0] >> 4) & 0x0F
+        channel_mode = (data[0] >> 0) & 0x0F
+        block_length = (data[1] >> 4) & 0x0F
+        subbands = (data[1] >> 2) & 0x03
+        allocation_method = (data[1] >> 0) & 0x03
         minimum_bitpool_value = (data[2] >> 0) & 0xFF
         maximum_bitpool_value = (data[3] >> 0) & 0xFF
-        return cls(
+        return SbcMediaCodecInformation(
             sampling_frequency,
             channel_mode,
             block_length,
@@ -331,6 +290,52 @@ class SbcMediaCodecInformation:
             maximum_bitpool_value,
         )
 
+    @classmethod
+    def from_discrete_values(
+        cls,
+        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],
+            block_length=cls.BLOCK_LENGTH_BITS[block_length],
+            subbands=cls.SUBBANDS_BITS[subbands],
+            allocation_method=cls.ALLOCATION_METHOD_BITS[allocation_method],
+            minimum_bitpool_value=minimum_bitpool_value,
+            maximum_bitpool_value=maximum_bitpool_value,
+        )
+
+    @classmethod
+    def from_lists(
+        cls,
+        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
+            ),
+            channel_mode=sum(cls.CHANNEL_MODE_BITS[x] for x in channel_modes),
+            block_length=sum(cls.BLOCK_LENGTH_BITS[x] for x in block_lengths),
+            subbands=sum(cls.SUBBANDS_BITS[x] for x in subbands),
+            allocation_method=sum(
+                cls.ALLOCATION_METHOD_BITS[x] for x in allocation_methods
+            ),
+            minimum_bitpool_value=minimum_bitpool_value,
+            maximum_bitpool_value=maximum_bitpool_value,
+        )
+
     def __bytes__(self) -> bytes:
         return bytes(
             [
@@ -343,74 +348,93 @@ class SbcMediaCodecInformation:
             ]
         )
 
+    def __str__(self):
+        channel_modes = ['MONO', 'DUAL_CHANNEL', 'STEREO', 'JOINT_STEREO']
+        allocation_methods = ['SNR', 'Loudness']
+        return '\n'.join(
+            # pylint: disable=line-too-long
+            [
+                'SbcMediaCodecInformation(',
+                f'  sampling_frequency:    {",".join([str(x) for x in flags_to_list(self.sampling_frequency, SBC_SAMPLING_FREQUENCIES)])}',
+                f'  channel_mode:          {",".join([str(x) for x in flags_to_list(self.channel_mode, channel_modes)])}',
+                f'  block_length:          {",".join([str(x) for x in flags_to_list(self.block_length, SBC_BLOCK_LENGTHS)])}',
+                f'  subbands:              {",".join([str(x) for x in flags_to_list(self.subbands, SBC_SUBBANDS)])}',
+                f'  allocation_method:     {",".join([str(x) for x in flags_to_list(self.allocation_method, allocation_methods)])}',
+                f'  minimum_bitpool_value: {self.minimum_bitpool_value}',
+                f'  maximum_bitpool_value: {self.maximum_bitpool_value}' ')',
+            ]
+        )
+
 
 # -----------------------------------------------------------------------------
-@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: ObjectType
-    sampling_frequency: SamplingFrequency
-    channels: Channels
-    vbr: int
-    bitrate: int
+    OBJECT_TYPE_BITS = {
+        MPEG_2_AAC_LC_OBJECT_TYPE: 1 << 7,
+        MPEG_4_AAC_LC_OBJECT_TYPE: 1 << 6,
+        MPEG_4_AAC_LTP_OBJECT_TYPE: 1 << 5,
+        MPEG_4_AAC_SCALABLE_OBJECT_TYPE: 1 << 4,
+    }
+    SAMPLING_FREQUENCY_BITS = {
+        8000: 1 << 11,
+        11025: 1 << 10,
+        12000: 1 << 9,
+        16000: 1 << 8,
+        22050: 1 << 7,
+        24000: 1 << 6,
+        32000: 1 << 5,
+        44100: 1 << 4,
+        48000: 1 << 3,
+        64000: 1 << 2,
+        88200: 1 << 1,
+        96000: 1,
+    }
+    CHANNELS_BITS = {1: 1 << 1, 2: 1}
 
-    class ObjectType(enum.IntFlag):
-        MPEG_2_AAC_LC = 1 << 7
-        MPEG_4_AAC_LC = 1 << 6
-        MPEG_4_AAC_LTP = 1 << 5
-        MPEG_4_AAC_SCALABLE = 1 << 4
-
-    class SamplingFrequency(enum.IntFlag):
-        SF_8000 = 1 << 11
-        SF_11025 = 1 << 10
-        SF_12000 = 1 << 9
-        SF_16000 = 1 << 8
-        SF_22050 = 1 << 7
-        SF_24000 = 1 << 6
-        SF_32000 = 1 << 5
-        SF_44100 = 1 << 4
-        SF_48000 = 1 << 3
-        SF_64000 = 1 << 2
-        SF_88200 = 1 << 1
-        SF_96000 = 1 << 0
-
-        @classmethod
-        def from_int(cls, sampling_frequency: int) -> Self:
-            sampling_frequencies = [
-                8000,
-                11025,
-                12000,
-                16000,
-                22050,
-                24000,
-                32000,
-                44100,
-                48000,
-                64000,
-                88200,
-                96000,
-            ]
-            index = sampling_frequencies.index(sampling_frequency)
-            return cls(1 << (len(sampling_frequencies) - index - 1))
-
-    class Channels(enum.IntFlag):
-        MONO = 1 << 1
-        STEREO = 1 << 0
-
-    @classmethod
-    def from_bytes(cls, data: bytes) -> AacMediaCodecInformation:
-        object_type = cls.ObjectType(data[0])
-        sampling_frequency = cls.SamplingFrequency(
-            (data[1] << 4) | ((data[2] >> 4) & 0x0F)
-        )
-        channels = cls.Channels((data[2] >> 2) & 0x03)
+    @staticmethod
+    def from_bytes(data: bytes) -> 'AacMediaCodecInformation':
+        object_type = data[0]
+        sampling_frequency = (data[1] << 4) | ((data[2] >> 4) & 0x0F)
+        channels = (data[2] >> 2) & 0x03
+        rfa = 0
         vbr = (data[3] >> 7) & 0x01
         bitrate = ((data[3] & 0x7F) << 16) | (data[4] << 8) | data[5]
         return AacMediaCodecInformation(
-            object_type, sampling_frequency, channels, vbr, bitrate
+            object_type, sampling_frequency, channels, rfa, vbr, bitrate
+        )
+
+    @classmethod
+    def from_discrete_values(
+        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],
+            channels=cls.CHANNELS_BITS[channels],
+            rfa=0,
+            vbr=vbr,
+            bitrate=bitrate,
+        )
+
+    @classmethod
+    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(
+                cls.SAMPLING_FREQUENCY_BITS[x] for x in sampling_frequencies
+            ),
+            channels=sum(cls.CHANNELS_BITS[x] for x in channels),
+            rfa=0,
+            vbr=vbr,
+            bitrate=bitrate,
         )
 
     def __bytes__(self) -> bytes:
@@ -425,27 +449,51 @@ class AacMediaCodecInformation:
             ]
         )
 
+    def __str__(self):
+        object_types = [
+            'MPEG_2_AAC_LC',
+            'MPEG_4_AAC_LC',
+            'MPEG_4_AAC_LTP',
+            'MPEG_4_AAC_SCALABLE',
+            '[4]',
+            '[5]',
+            '[6]',
+            '[7]',
+        ]
+        channels = [1, 2]
+        # pylint: disable=line-too-long
+        return '\n'.join(
+            [
+                'AacMediaCodecInformation(',
+                f'  object_type:        {",".join([str(x) for x in flags_to_list(self.object_type, object_types)])}',
+                f'  sampling_frequency: {",".join([str(x) for x in flags_to_list(self.sampling_frequency, MPEG_2_4_AAC_SAMPLING_FREQUENCIES)])}',
+                f'  channels:           {",".join([str(x) for x in flags_to_list(self.channels, channels)])}',
+                f'  vbr:                {self.vbr}',
+                f'  bitrate:            {self.bitrate}' ')',
+            ]
+        )
+
 
-@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:
-        return struct.pack('<IH', self.vendor_id, self.codec_id) + self.value
+    def __init__(self, vendor_id, codec_id, value):
+        self.vendor_id = vendor_id
+        self.codec_id = codec_id
+        self.value = value
 
-    def __str__(self) -> str:
+    def __bytes__(self):
+        return struct.pack('<IH', self.vendor_id, self.codec_id, self.value)
+
+    def __str__(self):
         # pylint: disable=line-too-long
         return '\n'.join(
             [
@@ -458,102 +506,46 @@ class VendorSpecificMediaCodecInformation:
 
 
 # -----------------------------------------------------------------------------
-@dataclasses.dataclass
-class OpusMediaCodecInformation(VendorSpecificMediaCodecInformation):
-    vendor_id: int = dataclasses.field(init=False, repr=False)
-    codec_id: int = dataclasses.field(init=False, repr=False)
-    value: bytes = dataclasses.field(init=False, repr=False)
-    channel_mode: ChannelMode
-    frame_size: FrameSize
-    sampling_frequency: SamplingFrequency
-
-    class ChannelMode(enum.IntFlag):
-        MONO = 1 << 0
-        STEREO = 1 << 1
-        DUAL_MONO = 1 << 2
-
-    class FrameSize(enum.IntFlag):
-        FS_10MS = 1 << 0
-        FS_20MS = 1 << 1
-
-    class SamplingFrequency(enum.IntFlag):
-        SF_48000 = 1 << 0
-
-    VENDOR_ID: ClassVar[int] = 0x000000E0
-    CODEC_ID: ClassVar[int] = 0x0001
-
-    def __post_init__(self) -> None:
-        self.vendor_id = self.VENDOR_ID
-        self.codec_id = self.CODEC_ID
-        self.value = bytes(
-            [
-                self.channel_mode
-                | (self.frame_size << 3)
-                | (self.sampling_frequency << 7)
-            ]
-        )
-
-    @classmethod
-    def from_bytes(cls, data: bytes) -> Self:
-        """Create a new instance from the `value` part of the data, not including
-        the vendor id and codec id"""
-        channel_mode = cls.ChannelMode(data[0] & 0x07)
-        frame_size = cls.FrameSize((data[0] >> 3) & 0x03)
-        sampling_frequency = cls.SamplingFrequency((data[0] >> 7) & 0x01)
-
-        return cls(
-            channel_mode,
-            frame_size,
-            sampling_frequency,
-        )
-
-    def __str__(self) -> str:
-        return repr(self)
-
-
-# -----------------------------------------------------------------------------
-@dataclasses.dataclass
 class SbcFrame:
-    sampling_frequency: int
-    block_count: int
-    channel_mode: int
-    allocation_method: int
-    subband_count: int
-    bitpool: 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},'
-            f'am={self.allocation_method},'
             f'br={self.bitrate},'
             f'sc={self.sample_count},'
-            f'bp={self.bitpool},'
             f'size={len(self.payload)})'
         )
 
 
 # -----------------------------------------------------------------------------
 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)
@@ -570,7 +562,6 @@ class SbcParser:
                 blocks = 4 * (1 + ((header[1] >> 4) & 3))
                 channel_mode = (header[1] >> 2) & 3
                 channels = 1 if channel_mode == SBC_MONO_CHANNEL_MODE else 2
-                allocation_method = (header[1] >> 1) & 1
                 subbands = 8 if ((header[1]) & 1) else 4
                 bitpool = header[2]
 
@@ -590,13 +581,7 @@ class SbcParser:
 
                 # Emit the next frame
                 yield SbcFrame(
-                    sampling_frequency,
-                    blocks,
-                    channel_mode,
-                    allocation_method,
-                    subbands,
-                    bitpool,
-                    payload,
+                    sampling_frequency, blocks, channel_mode, subbands, payload
                 )
 
         return generate_frames()
@@ -604,15 +589,19 @@ class SbcParser:
 
 # -----------------------------------------------------------------------------
 class SbcPacketSource:
-    def __init__(self, read: Callable[[int], Awaitable[bytes]], mtu: int) -> None:
+    def __init__(self, read, mtu, codec_capabilities):
         self.read = read
         self.mtu = mtu
+        self.codec_capabilities = codec_capabilities
 
     @property
     def packets(self):
         async def generate_packets():
+            # pylint: disable=import-outside-toplevel
+            from .avdtp import MediaPacket  # Import here to avoid a circular reference
+
             sequence_number = 0
-            sample_count = 0
+            timestamp = 0
             frames = []
             frames_size = 0
             max_rtp_payload = self.mtu - 12 - 1
@@ -620,29 +609,27 @@ class SbcPacketSource:
             # NOTE: this doesn't support frame fragments
             sbc_parser = SbcParser(self.read)
             async for frame in sbc_parser.frames:
+                print(frame)
+
                 if (
                     frames_size + len(frame.payload) > max_rtp_payload
-                    or len(frames) == SBC_MAX_FRAMES_IN_RTP_PAYLOAD
+                    or len(frames) == 16
                 ):
                     # Need to flush what has been accumulated so far
-                    logger.debug(f"yielding {len(frames)} frames")
 
                     # Emit a packet
-                    sbc_payload = bytes([len(frames) & 0x0F]) + b''.join(
+                    sbc_payload = bytes([len(frames)]) + b''.join(
                         [frame.payload for frame in frames]
                     )
-                    timestamp_seconds = sample_count / frame.sampling_frequency
-                    timestamp = int(1000 * timestamp_seconds)
                     packet = MediaPacket(
                         2, 0, 0, 0, sequence_number, timestamp, 0, [], 96, sbc_payload
                     )
-                    packet.timestamp_seconds = timestamp_seconds
+                    packet.timestamp_seconds = timestamp / frame.sampling_frequency
                     yield packet
 
                     # Prepare for next packets
                     sequence_number += 1
-                    sequence_number &= 0xFFFF
-                    sample_count += sum((frame.sample_count for frame in frames))
+                    timestamp += sum((frame.sample_count for frame in frames))
                     frames = [frame]
                     frames_size = len(frame.payload)
                 else:
@@ -651,315 +638,3 @@ class SbcPacketSource:
                     frames_size += len(frame.payload)
 
         return generate_packets()
-
-
-# -----------------------------------------------------------------------------
-@dataclasses.dataclass
-class AacFrame:
-    class Profile(enum.IntEnum):
-        MAIN = 0
-        LC = 1
-        SSR = 2
-        LTP = 3
-
-    profile: Profile
-    sampling_frequency: int
-    channel_configuration: int
-    payload: bytes
-
-    @property
-    def sample_count(self) -> int:
-        return 1024
-
-    @property
-    def duration(self) -> float:
-        return self.sample_count / self.sampling_frequency
-
-    def __str__(self) -> str:
-        return (
-            f'AAC(sf={self.sampling_frequency},'
-            f'ch={self.channel_configuration},'
-            f'size={len(self.payload)})'
-        )
-
-
-# -----------------------------------------------------------------------------
-ADTS_AAC_SAMPLING_FREQUENCIES = [
-    96000,
-    88200,
-    64000,
-    48000,
-    44100,
-    32000,
-    24000,
-    22050,
-    16000,
-    12000,
-    11025,
-    8000,
-    7350,
-    0,
-    0,
-    0,
-]
-
-
-# -----------------------------------------------------------------------------
-class AacParser:
-    """Parser for AAC frames in an ADTS stream"""
-
-    def __init__(self, read: Callable[[int], Awaitable[bytes]]) -> None:
-        self.read = read
-
-    @property
-    def frames(self) -> AsyncGenerator[AacFrame, None]:
-        async def generate_frames() -> AsyncGenerator[AacFrame, None]:
-            while True:
-                header = await self.read(7)
-                if not header:
-                    return
-
-                sync_word = (header[0] << 4) | (header[1] >> 4)
-                if sync_word != 0b111111111111:
-                    raise ValueError(f"invalid sync word ({sync_word:06x})")
-                layer = (header[1] >> 1) & 0b11
-                profile = AacFrame.Profile((header[2] >> 6) & 0b11)
-                sampling_frequency = ADTS_AAC_SAMPLING_FREQUENCIES[
-                    (header[2] >> 2) & 0b1111
-                ]
-                channel_configuration = ((header[2] & 0b1) << 2) | (header[3] >> 6)
-                frame_length = (
-                    ((header[3] & 0b11) << 11) | (header[4] << 3) | (header[5] >> 5)
-                )
-
-                if layer != 0:
-                    raise ValueError("layer must be 0")
-
-                payload = await self.read(frame_length - 7)
-                if payload:
-                    yield AacFrame(
-                        profile, sampling_frequency, channel_configuration, payload
-                    )
-
-        return generate_frames()
-
-
-# -----------------------------------------------------------------------------
-class AacPacketSource:
-    def __init__(self, read: Callable[[int], Awaitable[bytes]], mtu: int) -> None:
-        self.read = read
-        self.mtu = mtu
-
-    @property
-    def packets(self):
-        async def generate_packets():
-            sequence_number = 0
-            sample_count = 0
-
-            aac_parser = AacParser(self.read)
-            async for frame in aac_parser.frames:
-                logger.debug("yielding one AAC frame")
-
-                # Emit a packet
-                aac_payload = bytes(
-                    AacAudioRtpPacket.for_simple_aac(
-                        frame.sampling_frequency,
-                        frame.channel_configuration,
-                        frame.payload,
-                    )
-                )
-                timestamp_seconds = sample_count / frame.sampling_frequency
-                timestamp = int(1000 * timestamp_seconds)
-                packet = MediaPacket(
-                    2, 0, 0, 0, sequence_number, timestamp, 0, [], 96, aac_payload
-                )
-                packet.timestamp_seconds = timestamp_seconds
-                yield packet
-
-                # Prepare for next packets
-                sequence_number += 1
-                sequence_number &= 0xFFFF
-                sample_count += frame.sample_count
-
-        return generate_packets()
-
-
-# -----------------------------------------------------------------------------
-@dataclasses.dataclass
-class OpusPacket:
-    class ChannelMode(enum.IntEnum):
-        MONO = 0
-        STEREO = 1
-        DUAL_MONO = 2
-
-    channel_mode: ChannelMode
-    duration: int  # Duration in ms.
-    sampling_frequency: int
-    payload: bytes
-
-    def __str__(self) -> str:
-        return (
-            f'Opus(ch={self.channel_mode.name}, '
-            f'd={self.duration}ms, '
-            f'size={len(self.payload)})'
-        )
-
-
-# -----------------------------------------------------------------------------
-class OpusParser:
-    """
-    Parser for Opus packets in an Ogg stream
-
-    See RFC 3533
-
-    NOTE: this parser only supports bitstreams with a single logical stream.
-    """
-
-    CAPTURE_PATTERN = b'OggS'
-
-    class HeaderType(enum.IntFlag):
-        CONTINUED = 0x01
-        FIRST = 0x02
-        LAST = 0x04
-
-    def __init__(self, read: Callable[[int], Awaitable[bytes]]) -> None:
-        self.read = read
-
-    @property
-    def packets(self) -> AsyncGenerator[OpusPacket, None]:
-        async def generate_frames() -> AsyncGenerator[OpusPacket, None]:
-            packet = b''
-            packet_count = 0
-            expected_bitstream_serial_number = None
-            expected_page_sequence_number = 0
-            channel_mode = OpusPacket.ChannelMode.STEREO
-
-            while True:
-                # Parse the page header
-                header = await self.read(27)
-                if len(header) != 27:
-                    logger.debug("end of stream")
-                    break
-
-                capture_pattern = header[:4]
-                if capture_pattern != self.CAPTURE_PATTERN:
-                    print(capture_pattern.hex())
-                    raise ValueError("invalid capture pattern at start of page")
-
-                version = header[4]
-                if version != 0:
-                    raise ValueError(f"version {version} not supported")
-
-                header_type = self.HeaderType(header[5])
-                (
-                    granule_position,
-                    bitstream_serial_number,
-                    page_sequence_number,
-                    crc_checksum,
-                    page_segments,
-                ) = struct.unpack_from("<QIIIB", header, 6)
-                segment_table = await self.read(page_segments)
-
-                if header_type & self.HeaderType.FIRST:
-                    if expected_bitstream_serial_number is None:
-                        # We will only accept pages for the first encountered stream
-                        logger.debug("BOS")
-                        expected_bitstream_serial_number = bitstream_serial_number
-                        expected_page_sequence_number = page_sequence_number
-
-                if (
-                    expected_bitstream_serial_number is None
-                    or expected_bitstream_serial_number != bitstream_serial_number
-                ):
-                    logger.debug("skipping page (not the first logical bitstream)")
-                    for lacing_value in segment_table:
-                        if lacing_value:
-                            await self.read(lacing_value)
-                    continue
-
-                if expected_page_sequence_number != page_sequence_number:
-                    raise ValueError(
-                        f"expected page sequence number {expected_page_sequence_number}"
-                        f" but got {page_sequence_number}"
-                    )
-                expected_page_sequence_number = page_sequence_number + 1
-
-                # Assemble the page
-                if not header_type & self.HeaderType.CONTINUED:
-                    packet = b''
-                for lacing_value in segment_table:
-                    if lacing_value:
-                        packet += await self.read(lacing_value)
-                    if lacing_value < 255:
-                        # End of packet
-                        packet_count += 1
-
-                        if packet_count == 1:
-                            # The first packet contains the identification header
-                            logger.debug("first packet (header)")
-                            if packet[:8] != b"OpusHead":
-                                raise ValueError("first packet is not OpusHead")
-                            packet_count = (
-                                OpusPacket.ChannelMode.MONO
-                                if packet[9] == 1
-                                else OpusPacket.ChannelMode.STEREO
-                            )
-
-                        elif packet_count == 2:
-                            # The second packet contains the comment header
-                            logger.debug("second packet (tags)")
-                            if packet[:8] != b"OpusTags":
-                                logger.warning("second packet is not OpusTags")
-                        else:
-                            yield OpusPacket(channel_mode, 20, 48000, packet)
-
-                        packet = b''
-
-                if header_type & self.HeaderType.LAST:
-                    logger.debug("EOS")
-
-        return generate_frames()
-
-
-# -----------------------------------------------------------------------------
-class OpusPacketSource:
-    def __init__(self, read: Callable[[int], Awaitable[bytes]], mtu: int) -> None:
-        self.read = read
-        self.mtu = mtu
-
-    @property
-    def packets(self):
-        async def generate_packets():
-            sequence_number = 0
-            elapsed_ms = 0
-
-            opus_parser = OpusParser(self.read)
-            async for opus_packet in opus_parser.packets:
-                # We only support sending one Opus frame per RTP packet
-                # TODO: check the spec for the first byte value here
-                opus_payload = bytes([1]) + opus_packet.payload
-                elapsed_s = elapsed_ms / 1000
-                timestamp = int(elapsed_s * opus_packet.sampling_frequency)
-                rtp_packet = MediaPacket(
-                    2, 0, 0, 0, sequence_number, timestamp, 0, [], 96, opus_payload
-                )
-                rtp_packet.timestamp_seconds = elapsed_s
-                yield rtp_packet
-
-                # Prepare for next packets
-                sequence_number += 1
-                sequence_number &= 0xFFFF
-                elapsed_ms += opus_packet.duration
-
-        return generate_packets()
-
-
-# -----------------------------------------------------------------------------
-# This map should be left at the end of the file so it can refer to the classes
-# above
-# -----------------------------------------------------------------------------
-A2DP_VENDOR_MEDIA_CODEC_INFORMATION_CLASSES = {
-    OpusMediaCodecInformation.VENDOR_ID: {
-        OpusMediaCodecInformation.CODEC_ID: OpusMediaCodecInformation
-    }
-}

bumble/at.py

@@ -14,19 +14,13 @@
 
 from typing import List, Union
 
-from bumble import core
-
-
-class AtParsingError(core.InvalidPacketError):
-    """Error raised when parsing AT commands fails."""
-
 
 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 AtParsingError in case of invalid input string."""
+    Raises ValueError in case of invalid input string."""
 
     tokens = []
     in_quotes = False
@@ -49,11 +43,11 @@ def tokenize_parameters(buffer: bytes) -> List[bytes]:
                 token = bytearray()
             elif char == b'(':
                 if len(token) > 0:
-                    raise AtParsingError("open_paren following regular character")
+                    raise ValueError("open_paren following regular character")
                 tokens.append(char)
             elif char == b'"':
                 if len(token) > 0:
-                    raise AtParsingError("quote following regular character")
+                    raise ValueError("quote following regular character")
                 in_quotes = True
                 token.extend(char)
             else:
@@ -65,7 +59,7 @@ def tokenize_parameters(buffer: bytes) -> List[bytes]:
 
 def parse_parameters(buffer: bytes) -> List[Union[bytes, list]]:
     """Parse the parameters using the comma and parenthesis separators.
-    Raises AtParsingError in case of invalid input string."""
+    Raises ValueError in case of invalid input string."""
 
     tokens = tokenize_parameters(buffer)
     accumulator: List[list] = [[]]
@@ -79,7 +73,7 @@ def parse_parameters(buffer: bytes) -> List[Union[bytes, list]]:
             accumulator.append([])
         elif token == b')':
             if len(accumulator) < 2:
-                raise AtParsingError("close_paren without matching open_paren")
+                raise ValueError("close_paren without matching open_paren")
             accumulator[-1].append(current)
             current = accumulator.pop()
         else:
@@ -87,5 +81,5 @@ def parse_parameters(buffer: bytes) -> List[Union[bytes, list]]:
 
     accumulator[-1].append(current)
     if len(accumulator) > 1:
-        raise AtParsingError("missing close_paren")
+        raise ValueError("missing close_paren")
     return accumulator[0]

bumble/att.py

@@ -23,28 +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 import utils
-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:
@@ -147,57 +132,43 @@ ATT_RESPONSES = [
     ATT_EXECUTE_WRITE_RESPONSE
 ]
 
-class ErrorCode(utils.OpenIntEnum):
-    '''
-    See
+ATT_INVALID_HANDLE_ERROR                   = 0x01
+ATT_READ_NOT_PERMITTED_ERROR               = 0x02
+ATT_WRITE_NOT_PERMITTED_ERROR              = 0x03
+ATT_INVALID_PDU_ERROR                      = 0x04
+ATT_INSUFFICIENT_AUTHENTICATION_ERROR      = 0x05
+ATT_REQUEST_NOT_SUPPORTED_ERROR            = 0x06
+ATT_INVALID_OFFSET_ERROR                   = 0x07
+ATT_INSUFFICIENT_AUTHORIZATION_ERROR       = 0x08
+ATT_PREPARE_QUEUE_FULL_ERROR               = 0x09
+ATT_ATTRIBUTE_NOT_FOUND_ERROR              = 0x0A
+ATT_ATTRIBUTE_NOT_LONG_ERROR               = 0x0B
+ATT_INSUFFICIENT_ENCRYPTION_KEY_SIZE_ERROR = 0x0C
+ATT_INVALID_ATTRIBUTE_LENGTH_ERROR         = 0x0D
+ATT_UNLIKELY_ERROR_ERROR                   = 0x0E
+ATT_INSUFFICIENT_ENCRYPTION_ERROR          = 0x0F
+ATT_UNSUPPORTED_GROUP_TYPE_ERROR           = 0x10
+ATT_INSUFFICIENT_RESOURCES_ERROR           = 0x11
 
-    * Bluetooth spec @ Vol 3, Part F - 3.4.1.1 Error Response
-    * Core Specification Supplement: Common Profile And Service Error Codes
-    '''
-    INVALID_HANDLE                   = 0x01
-    READ_NOT_PERMITTED               = 0x02
-    WRITE_NOT_PERMITTED              = 0x03
-    INVALID_PDU                      = 0x04
-    INSUFFICIENT_AUTHENTICATION      = 0x05
-    REQUEST_NOT_SUPPORTED            = 0x06
-    INVALID_OFFSET                   = 0x07
-    INSUFFICIENT_AUTHORIZATION       = 0x08
-    PREPARE_QUEUE_FULL               = 0x09
-    ATTRIBUTE_NOT_FOUND              = 0x0A
-    ATTRIBUTE_NOT_LONG               = 0x0B
-    INSUFFICIENT_ENCRYPTION_KEY_SIZE = 0x0C
-    INVALID_ATTRIBUTE_LENGTH         = 0x0D
-    UNLIKELY_ERROR                   = 0x0E
-    INSUFFICIENT_ENCRYPTION          = 0x0F
-    UNSUPPORTED_GROUP_TYPE           = 0x10
-    INSUFFICIENT_RESOURCES           = 0x11
-    DATABASE_OUT_OF_SYNC             = 0x12
-    VALUE_NOT_ALLOWED                = 0x13
-    # 0x80 – 0x9F: Application Error
-    # 0xE0 – 0xFF: Common Profile and Service Error Codes
-    WRITE_REQUEST_REJECTED           = 0xFC
-    CCCD_IMPROPERLY_CONFIGURED       = 0xFD
-    PROCEDURE_ALREADY_IN_PROGRESS    = 0xFE
-    OUT_OF_RANGE                     = 0xFF
-
-# Backward Compatible Constants
-ATT_INVALID_HANDLE_ERROR                   = ErrorCode.INVALID_HANDLE
-ATT_READ_NOT_PERMITTED_ERROR               = ErrorCode.READ_NOT_PERMITTED
-ATT_WRITE_NOT_PERMITTED_ERROR              = ErrorCode.WRITE_NOT_PERMITTED
-ATT_INVALID_PDU_ERROR                      = ErrorCode.INVALID_PDU
-ATT_INSUFFICIENT_AUTHENTICATION_ERROR      = ErrorCode.INSUFFICIENT_AUTHENTICATION
-ATT_REQUEST_NOT_SUPPORTED_ERROR            = ErrorCode.REQUEST_NOT_SUPPORTED
-ATT_INVALID_OFFSET_ERROR                   = ErrorCode.INVALID_OFFSET
-ATT_INSUFFICIENT_AUTHORIZATION_ERROR       = ErrorCode.INSUFFICIENT_AUTHORIZATION
-ATT_PREPARE_QUEUE_FULL_ERROR               = ErrorCode.PREPARE_QUEUE_FULL
-ATT_ATTRIBUTE_NOT_FOUND_ERROR              = ErrorCode.ATTRIBUTE_NOT_FOUND
-ATT_ATTRIBUTE_NOT_LONG_ERROR               = ErrorCode.ATTRIBUTE_NOT_LONG
-ATT_INSUFFICIENT_ENCRYPTION_KEY_SIZE_ERROR = ErrorCode.INSUFFICIENT_ENCRYPTION_KEY_SIZE
-ATT_INVALID_ATTRIBUTE_LENGTH_ERROR         = ErrorCode.INVALID_ATTRIBUTE_LENGTH
-ATT_UNLIKELY_ERROR_ERROR                   = ErrorCode.UNLIKELY_ERROR
-ATT_INSUFFICIENT_ENCRYPTION_ERROR          = ErrorCode.INSUFFICIENT_ENCRYPTION
-ATT_UNSUPPORTED_GROUP_TYPE_ERROR           = ErrorCode.UNSUPPORTED_GROUP_TYPE
-ATT_INSUFFICIENT_RESOURCES_ERROR           = ErrorCode.INSUFFICIENT_RESOURCES
+ATT_ERROR_NAMES = {
+    ATT_INVALID_HANDLE_ERROR:                   'ATT_INVALID_HANDLE_ERROR',
+    ATT_READ_NOT_PERMITTED_ERROR:               'ATT_READ_NOT_PERMITTED_ERROR',
+    ATT_WRITE_NOT_PERMITTED_ERROR:              'ATT_WRITE_NOT_PERMITTED_ERROR',
+    ATT_INVALID_PDU_ERROR:                      'ATT_INVALID_PDU_ERROR',
+    ATT_INSUFFICIENT_AUTHENTICATION_ERROR:      'ATT_INSUFFICIENT_AUTHENTICATION_ERROR',
+    ATT_REQUEST_NOT_SUPPORTED_ERROR:            'ATT_REQUEST_NOT_SUPPORTED_ERROR',
+    ATT_INVALID_OFFSET_ERROR:                   'ATT_INVALID_OFFSET_ERROR',
+    ATT_INSUFFICIENT_AUTHORIZATION_ERROR:       'ATT_INSUFFICIENT_AUTHORIZATION_ERROR',
+    ATT_PREPARE_QUEUE_FULL_ERROR:               'ATT_PREPARE_QUEUE_FULL_ERROR',
+    ATT_ATTRIBUTE_NOT_FOUND_ERROR:              'ATT_ATTRIBUTE_NOT_FOUND_ERROR',
+    ATT_ATTRIBUTE_NOT_LONG_ERROR:               'ATT_ATTRIBUTE_NOT_LONG_ERROR',
+    ATT_INSUFFICIENT_ENCRYPTION_KEY_SIZE_ERROR: 'ATT_INSUFFICIENT_ENCRYPTION_KEY_SIZE_ERROR',
+    ATT_INVALID_ATTRIBUTE_LENGTH_ERROR:         'ATT_INVALID_ATTRIBUTE_LENGTH_ERROR',
+    ATT_UNLIKELY_ERROR_ERROR:                   'ATT_UNLIKELY_ERROR_ERROR',
+    ATT_INSUFFICIENT_ENCRYPTION_ERROR:          'ATT_INSUFFICIENT_ENCRYPTION_ERROR',
+    ATT_UNSUPPORTED_GROUP_TYPE_ERROR:           'ATT_UNSUPPORTED_GROUP_TYPE_ERROR',
+    ATT_INSUFFICIENT_RESOURCES_ERROR:           'ATT_INSUFFICIENT_RESOURCES_ERROR'
+}
 
 ATT_DEFAULT_MTU = 23
 
@@ -211,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
 # -----------------------------------------------------------------------------
@@ -239,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):
@@ -261,9 +231,9 @@ class ATT_PDU:
     def pdu_name(op_code):
         return name_or_number(ATT_PDU_NAMES, op_code, 2)
 
-    @classmethod
-    def error_name(cls, error_code: int) -> str:
-        return ErrorCode(error_code).name
+    @staticmethod
+    def error_name(error_code):
+        return name_or_number(ATT_ERROR_NAMES, error_code, 2)
 
     @staticmethod
     def subclass(fields):
@@ -671,7 +641,7 @@ class ATT_Write_Command(ATT_PDU):
 @ATT_PDU.subclass(
     [
         ('attribute_handle', HANDLE_FIELD_SPEC),
-        ('attribute_value', '*'),
+        ('attribute_value', '*')
         # ('authentication_signature', 'TODO')
     ]
 )
@@ -749,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
 
@@ -854,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
             )
@@ -883,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
@@ -897,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:
@@ -918,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/avc.py

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

bumble/avctp.py

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

bumble/codecs.py

@@ -17,9 +17,6 @@
 # -----------------------------------------------------------------------------
 from __future__ import annotations
 from dataclasses import dataclass
-from typing_extensions import Self
-
-from bumble import core
 
 
 # -----------------------------------------------------------------------------
@@ -43,7 +40,7 @@ class BitReader:
         """ "Read up to 32 bits."""
 
         if bits > 32:
-            raise core.InvalidArgumentError('maximum read size is 32')
+            raise ValueError('maximum read size is 32')
 
         if self.bits_cached >= bits:
             # We have enough bits.
@@ -56,7 +53,7 @@ class BitReader:
         feed_size = len(feed_bytes)
         feed_int = int.from_bytes(feed_bytes, byteorder='big')
         if 8 * feed_size + self.bits_cached < bits:
-            raise core.InvalidArgumentError('trying to read past the data')
+            raise ValueError('trying to read past the data')
         self.byte_position += feed_size
 
         # Combine the new cache and the old cache
@@ -71,7 +68,7 @@ class BitReader:
 
     def read_bytes(self, count: int):
         if self.bit_position + 8 * count > 8 * len(self.data):
-            raise core.InvalidArgumentError('not enough data')
+            raise ValueError('not enough data')
 
         if self.bit_position % 8:
             # Not byte aligned
@@ -102,40 +99,12 @@ class BitReader:
                 break
 
 
-# -----------------------------------------------------------------------------
-class BitWriter:
-    """Simple but not optimized bit stream writer."""
-
-    data: int
-    bit_count: int
-
-    def __init__(self) -> None:
-        self.data = 0
-        self.bit_count = 0
-
-    def write(self, value: int, bit_count: int) -> None:
-        self.data = (self.data << bit_count) | value
-        self.bit_count += bit_count
-
-    def write_bytes(self, data: bytes) -> None:
-        bit_count = 8 * len(data)
-        self.data = (self.data << bit_count) | int.from_bytes(data, 'big')
-        self.bit_count += bit_count
-
-    def __bytes__(self) -> bytes:
-        return (self.data << ((8 - (self.bit_count % 8)) % 8)).to_bytes(
-            (self.bit_count + 7) // 8, 'big'
-        )
-
-
 # -----------------------------------------------------------------------------
 class AacAudioRtpPacket:
     """AAC payload encapsulated in an RTP packet payload"""
 
-    audio_mux_element: AudioMuxElement
-
     @staticmethod
-    def read_latm_value(reader: BitReader) -> int:
+    def latm_value(reader: BitReader) -> int:
         bytes_for_value = reader.read(2)
         value = 0
         for _ in range(bytes_for_value + 1):
@@ -143,33 +112,24 @@ class AacAudioRtpPacket:
         return value
 
     @staticmethod
-    def read_audio_object_type(reader: BitReader):
-        # GetAudioObjectType - ISO/EIC 14496-3 Table 1.16
-        audio_object_type = reader.read(5)
-        if audio_object_type == 31:
-            audio_object_type = 32 + reader.read(6)
-
-        return audio_object_type
+    def program_config_element(reader: BitReader):
+        raise ValueError('program_config_element not supported')
 
     @dataclass
     class GASpecificConfig:
-        audio_object_type: int
-        # NOTE: other fields not supported
-
-        @classmethod
-        def from_bits(
-            cls, reader: BitReader, channel_configuration: int, audio_object_type: int
-        ) -> Self:
+        def __init__(
+            self, reader: BitReader, channel_configuration: int, audio_object_type: int
+        ) -> None:
             # GASpecificConfig - ISO/EIC 14496-3 Table 4.1
             frame_length_flag = reader.read(1)
             depends_on_core_coder = reader.read(1)
             if depends_on_core_coder:
-                core_coder_delay = reader.read(14)
+                self.core_coder_delay = reader.read(14)
             extension_flag = reader.read(1)
             if not channel_configuration:
-                raise core.InvalidPacketError('program_config_element not supported')
+                AacAudioRtpPacket.program_config_element(reader)
             if audio_object_type in (6, 20):
-                layer_nr = reader.read(3)
+                self.layer_nr = reader.read(3)
             if extension_flag:
                 if audio_object_type == 22:
                     num_of_sub_frame = reader.read(5)
@@ -180,15 +140,16 @@ class AacAudioRtpPacket:
                     aac_spectral_data_resilience_flags = reader.read(1)
                 extension_flag_3 = reader.read(1)
                 if extension_flag_3 == 1:
-                    raise core.InvalidPacketError('extensionFlag3 == 1 not supported')
+                    raise ValueError('extensionFlag3 == 1 not supported')
 
-            return cls(audio_object_type)
+    @staticmethod
+    def audio_object_type(reader: BitReader):
+        # GetAudioObjectType - ISO/EIC 14496-3 Table 1.16
+        audio_object_type = reader.read(5)
+        if audio_object_type == 31:
+            audio_object_type = 32 + reader.read(6)
 
-        def to_bits(self, writer: BitWriter) -> None:
-            assert self.audio_object_type in (1, 2)
-            writer.write(0, 1)  # frame_length_flag = 0
-            writer.write(0, 1)  # depends_on_core_coder = 0
-            writer.write(0, 1)  # extension_flag = 0
+        return audio_object_type
 
     @dataclass
     class AudioSpecificConfig:
@@ -196,7 +157,6 @@ class AacAudioRtpPacket:
         sampling_frequency_index: int
         sampling_frequency: int
         channel_configuration: int
-        ga_specific_config: AacAudioRtpPacket.GASpecificConfig
         sbr_present_flag: int
         ps_present_flag: int
         extension_audio_object_type: int
@@ -220,73 +180,44 @@ class AacAudioRtpPacket:
             7350,
         ]
 
-        @classmethod
-        def for_simple_aac(
-            cls,
-            audio_object_type: int,
-            sampling_frequency: int,
-            channel_configuration: int,
-        ) -> Self:
-            if sampling_frequency not in cls.SAMPLING_FREQUENCIES:
-                raise ValueError(f'invalid sampling frequency {sampling_frequency}')
-
-            ga_specific_config = AacAudioRtpPacket.GASpecificConfig(audio_object_type)
-
-            return cls(
-                audio_object_type=audio_object_type,
-                sampling_frequency_index=cls.SAMPLING_FREQUENCIES.index(
-                    sampling_frequency
-                ),
-                sampling_frequency=sampling_frequency,
-                channel_configuration=channel_configuration,
-                ga_specific_config=ga_specific_config,
-                sbr_present_flag=0,
-                ps_present_flag=0,
-                extension_audio_object_type=0,
-                extension_sampling_frequency_index=0,
-                extension_sampling_frequency=0,
-                extension_channel_configuration=0,
-            )
-
-        @classmethod
-        def from_bits(cls, reader: BitReader) -> Self:
+        def __init__(self, reader: BitReader) -> None:
             # AudioSpecificConfig - ISO/EIC 14496-3 Table 1.15
-            audio_object_type = AacAudioRtpPacket.read_audio_object_type(reader)
-            sampling_frequency_index = reader.read(4)
-            if sampling_frequency_index == 0xF:
-                sampling_frequency = reader.read(24)
+            self.audio_object_type = AacAudioRtpPacket.audio_object_type(reader)
+            self.sampling_frequency_index = reader.read(4)
+            if self.sampling_frequency_index == 0xF:
+                self.sampling_frequency = reader.read(24)
             else:
-                sampling_frequency = cls.SAMPLING_FREQUENCIES[sampling_frequency_index]
-            channel_configuration = reader.read(4)
-            sbr_present_flag = 0
-            ps_present_flag = 0
-            extension_sampling_frequency_index = 0
-            extension_sampling_frequency = 0
-            extension_channel_configuration = 0
-            extension_audio_object_type = 0
-            if audio_object_type in (5, 29):
-                extension_audio_object_type = 5
-                sbr_present_flag = 1
-                if audio_object_type == 29:
-                    ps_present_flag = 1
-                extension_sampling_frequency_index = reader.read(4)
-                if extension_sampling_frequency_index == 0xF:
-                    extension_sampling_frequency = reader.read(24)
+                self.sampling_frequency = self.SAMPLING_FREQUENCIES[
+                    self.sampling_frequency_index
+                ]
+            self.channel_configuration = reader.read(4)
+            self.sbr_present_flag = -1
+            self.ps_present_flag = -1
+            if self.audio_object_type in (5, 29):
+                self.extension_audio_object_type = 5
+                self.sbc_present_flag = 1
+                if self.audio_object_type == 29:
+                    self.ps_present_flag = 1
+                self.extension_sampling_frequency_index = reader.read(4)
+                if self.extension_sampling_frequency_index == 0xF:
+                    self.extension_sampling_frequency = reader.read(24)
                 else:
-                    extension_sampling_frequency = cls.SAMPLING_FREQUENCIES[
-                        extension_sampling_frequency_index
+                    self.extension_sampling_frequency = self.SAMPLING_FREQUENCIES[
+                        self.extension_sampling_frequency_index
                     ]
-                audio_object_type = AacAudioRtpPacket.read_audio_object_type(reader)
-                if audio_object_type == 22:
-                    extension_channel_configuration = reader.read(4)
+                self.audio_object_type = AacAudioRtpPacket.audio_object_type(reader)
+                if self.audio_object_type == 22:
+                    self.extension_channel_configuration = reader.read(4)
+            else:
+                self.extension_audio_object_type = 0
 
-            if audio_object_type in (1, 2, 3, 4, 6, 7, 17, 19, 20, 21, 22, 23):
-                ga_specific_config = AacAudioRtpPacket.GASpecificConfig.from_bits(
-                    reader, channel_configuration, audio_object_type
+            if self.audio_object_type in (1, 2, 3, 4, 6, 7, 17, 19, 20, 21, 22, 23):
+                ga_specific_config = AacAudioRtpPacket.GASpecificConfig(
+                    reader, self.channel_configuration, self.audio_object_type
                 )
             else:
-                raise core.InvalidPacketError(
-                    f'audioObjectType {audio_object_type} not supported'
+                raise ValueError(
+                    f'audioObjectType {self.audio_object_type} not supported'
                 )
 
             # if self.extension_audio_object_type != 5 and bits_to_decode >= 16:
@@ -315,44 +246,13 @@ class AacAudioRtpPacket:
             #                     self.extension_sampling_frequency = self.SAMPLING_FREQUENCIES[self.extension_sampling_frequency_index]
             #             self.extension_channel_configuration = reader.read(4)
 
-            return cls(
-                audio_object_type,
-                sampling_frequency_index,
-                sampling_frequency,
-                channel_configuration,
-                ga_specific_config,
-                sbr_present_flag,
-                ps_present_flag,
-                extension_audio_object_type,
-                extension_sampling_frequency_index,
-                extension_sampling_frequency,
-                extension_channel_configuration,
-            )
-
-        def to_bits(self, writer: BitWriter) -> None:
-            if self.sampling_frequency_index >= 15:
-                raise ValueError(
-                    f"unsupported sampling frequency index {self.sampling_frequency_index}"
-                )
-
-            if self.audio_object_type not in (1, 2):
-                raise ValueError(
-                    f"unsupported audio object type {self.audio_object_type} "
-                )
-
-            writer.write(self.audio_object_type, 5)
-            writer.write(self.sampling_frequency_index, 4)
-            writer.write(self.channel_configuration, 4)
-            self.ga_specific_config.to_bits(writer)
-
     @dataclass
     class StreamMuxConfig:
         other_data_present: int
         other_data_len_bits: int
         audio_specific_config: AacAudioRtpPacket.AudioSpecificConfig
 
-        @classmethod
-        def from_bits(cls, reader: BitReader) -> Self:
+        def __init__(self, reader: BitReader) -> None:
             # StreamMuxConfig - ISO/EIC 14496-3 Table 1.42
             audio_mux_version = reader.read(1)
             if audio_mux_version == 1:
@@ -360,31 +260,31 @@ class AacAudioRtpPacket:
             else:
                 audio_mux_version_a = 0
             if audio_mux_version_a != 0:
-                raise core.InvalidPacketError('audioMuxVersionA != 0 not supported')
+                raise ValueError('audioMuxVersionA != 0 not supported')
             if audio_mux_version == 1:
-                tara_buffer_fullness = AacAudioRtpPacket.read_latm_value(reader)
+                tara_buffer_fullness = AacAudioRtpPacket.latm_value(reader)
             stream_cnt = 0
             all_streams_same_time_framing = reader.read(1)
             num_sub_frames = reader.read(6)
             num_program = reader.read(4)
             if num_program != 0:
-                raise core.InvalidPacketError('num_program != 0 not supported')
+                raise ValueError('num_program != 0 not supported')
             num_layer = reader.read(3)
             if num_layer != 0:
-                raise core.InvalidPacketError('num_layer != 0 not supported')
+                raise ValueError('num_layer != 0 not supported')
             if audio_mux_version == 0:
-                audio_specific_config = AacAudioRtpPacket.AudioSpecificConfig.from_bits(
+                self.audio_specific_config = AacAudioRtpPacket.AudioSpecificConfig(
                     reader
                 )
             else:
-                asc_len = AacAudioRtpPacket.read_latm_value(reader)
+                asc_len = AacAudioRtpPacket.latm_value(reader)
                 marker = reader.bit_position
-                audio_specific_config = AacAudioRtpPacket.AudioSpecificConfig.from_bits(
+                self.audio_specific_config = AacAudioRtpPacket.AudioSpecificConfig(
                     reader
                 )
                 audio_specific_config_len = reader.bit_position - marker
                 if asc_len < audio_specific_config_len:
-                    raise core.InvalidPacketError('audio_specific_config_len > asc_len')
+                    raise ValueError('audio_specific_config_len > asc_len')
                 asc_len -= audio_specific_config_len
                 reader.skip(asc_len)
             frame_length_type = reader.read(3)
@@ -393,53 +293,38 @@ class AacAudioRtpPacket:
             elif frame_length_type == 1:
                 frame_length = reader.read(9)
             else:
-                raise core.InvalidPacketError(
-                    f'frame_length_type {frame_length_type} not supported'
-                )
+                raise ValueError(f'frame_length_type {frame_length_type} not supported')
 
-            other_data_present = reader.read(1)
-            other_data_len_bits = 0
-            if other_data_present:
+            self.other_data_present = reader.read(1)
+            if self.other_data_present:
                 if audio_mux_version == 1:
-                    other_data_len_bits = AacAudioRtpPacket.read_latm_value(reader)
+                    self.other_data_len_bits = AacAudioRtpPacket.latm_value(reader)
                 else:
+                    self.other_data_len_bits = 0
                     while True:
-                        other_data_len_bits *= 256
+                        self.other_data_len_bits *= 256
                         other_data_len_esc = reader.read(1)
-                        other_data_len_bits += reader.read(8)
+                        self.other_data_len_bits += reader.read(8)
                         if other_data_len_esc == 0:
                             break
             crc_check_present = reader.read(1)
             if crc_check_present:
                 crc_checksum = reader.read(8)
 
-            return cls(other_data_present, other_data_len_bits, audio_specific_config)
-
-        def to_bits(self, writer: BitWriter) -> None:
-            writer.write(0, 1)  # audioMuxVersion = 0
-            writer.write(1, 1)  # allStreamsSameTimeFraming = 1
-            writer.write(0, 6)  # numSubFrames = 0
-            writer.write(0, 4)  # numProgram = 0
-            writer.write(0, 3)  # numLayer = 0
-            self.audio_specific_config.to_bits(writer)
-            writer.write(0, 3)  # frameLengthType = 0
-            writer.write(0, 8)  # latmBufferFullness = 0
-            writer.write(0, 1)  # otherDataPresent = 0
-            writer.write(0, 1)  # crcCheckPresent = 0
-
     @dataclass
     class AudioMuxElement:
-        stream_mux_config: AacAudioRtpPacket.StreamMuxConfig
         payload: bytes
+        stream_mux_config: AacAudioRtpPacket.StreamMuxConfig
+
+        def __init__(self, reader: BitReader, mux_config_present: int):
+            if mux_config_present == 0:
+                raise ValueError('muxConfigPresent == 0 not supported')
 
-        @classmethod
-        def from_bits(cls, reader: BitReader) -> Self:
             # AudioMuxElement - ISO/EIC 14496-3 Table 1.41
-            # (only supports mux_config_present=1)
             use_same_stream_mux = reader.read(1)
             if use_same_stream_mux:
-                raise core.InvalidPacketError('useSameStreamMux == 1 not supported')
-            stream_mux_config = AacAudioRtpPacket.StreamMuxConfig.from_bits(reader)
+                raise ValueError('useSameStreamMux == 1 not supported')
+            self.stream_mux_config = AacAudioRtpPacket.StreamMuxConfig(reader)
 
             # We only support:
             # allStreamsSameTimeFraming == 1
@@ -455,46 +340,19 @@ class AacAudioRtpPacket:
                 if tmp != 255:
                     break
 
-            payload = reader.read_bytes(mux_slot_length_bytes)
+            self.payload = reader.read_bytes(mux_slot_length_bytes)
 
-            if stream_mux_config.other_data_present:
-                reader.skip(stream_mux_config.other_data_len_bits)
+            if self.stream_mux_config.other_data_present:
+                reader.skip(self.stream_mux_config.other_data_len_bits)
 
             # ByteAlign
             while reader.bit_position % 8:
                 reader.read(1)
 
-            return cls(stream_mux_config, payload)
-
-        def to_bits(self, writer: BitWriter) -> None:
-            writer.write(0, 1)  # useSameStreamMux = 0
-            self.stream_mux_config.to_bits(writer)
-            mux_slot_length_bytes = len(self.payload)
-            while mux_slot_length_bytes > 255:
-                writer.write(255, 8)
-                mux_slot_length_bytes -= 255
-            writer.write(mux_slot_length_bytes, 8)
-            if mux_slot_length_bytes == 255:
-                writer.write(0, 8)
-            writer.write_bytes(self.payload)
-
-    @classmethod
-    def from_bytes(cls, data: bytes) -> Self:
+    def __init__(self, data: bytes) -> None:
         # Parse the bit stream
         reader = BitReader(data)
-        return cls(cls.AudioMuxElement.from_bits(reader))
-
-    @classmethod
-    def for_simple_aac(
-        cls, sampling_frequency: int, channel_configuration: int, payload: bytes
-    ) -> Self:
-        audio_specific_config = cls.AudioSpecificConfig.for_simple_aac(
-            2, sampling_frequency, channel_configuration
-        )
-        stream_mux_config = cls.StreamMuxConfig(0, 0, audio_specific_config)
-        audio_mux_element = cls.AudioMuxElement(stream_mux_config, payload)
-
-        return cls(audio_mux_element)
+        self.audio_mux_element = self.AudioMuxElement(reader, mux_config_present=1)
 
     def to_adts(self):
         # pylint: disable=line-too-long
@@ -521,11 +379,3 @@ class AacAudioRtpPacket:
             )
             + self.audio_mux_element.payload
         )
-
-    def __init__(self, audio_mux_element: AudioMuxElement) -> None:
-        self.audio_mux_element = audio_mux_element
-
-    def __bytes__(self) -> bytes:
-        writer = BitWriter()
-        self.audio_mux_element.to_bits(writer)
-        return bytes(writer)

bumble/colors.py

@@ -16,10 +16,6 @@ from functools import partial
 from typing import List, Optional, Union
 
 
-class ColorError(ValueError):
-    """Error raised when a color spec is invalid."""
-
-
 # ANSI color names. There is also a "default"
 COLORS = ('black', 'red', 'green', 'yellow', 'blue', 'magenta', 'cyan', 'white')
 
@@ -56,7 +52,7 @@ def _color_code(spec: ColorSpec, base: int) -> str:
     elif isinstance(spec, int) and 0 <= spec <= 255:
         return _join(base + 8, 5, spec)
     else:
-        raise ColorError('Invalid color spec "%s"' % spec)
+        raise ValueError('Invalid color spec "%s"' % spec)
 
 
 def color(
@@ -76,7 +72,7 @@ def color(
             if style_part in STYLES:
                 codes.append(STYLES.index(style_part))
             else:
-                raise ColorError('Invalid style "%s"' % style_part)
+                raise ValueError('Invalid style "%s"' % style_part)
 
     if codes:
         return '\x1b[{0}m{1}\x1b[0m'.format(_join(*codes), s)

bumble/controller.py

@@ -19,7 +19,6 @@ from __future__ import annotations
 
 import logging
 import asyncio
-import dataclasses
 import itertools
 import random
 import struct
@@ -43,7 +42,6 @@ from bumble.hci import (
     HCI_LE_1M_PHY,
     HCI_SUCCESS,
     HCI_UNKNOWN_HCI_COMMAND_ERROR,
-    HCI_UNKNOWN_CONNECTION_IDENTIFIER_ERROR,
     HCI_REMOTE_USER_TERMINATED_CONNECTION_ERROR,
     HCI_VERSION_BLUETOOTH_CORE_5_0,
     Address,
@@ -55,21 +53,17 @@ from bumble.hci import (
     HCI_Connection_Request_Event,
     HCI_Disconnection_Complete_Event,
     HCI_Encryption_Change_Event,
-    HCI_Synchronous_Connection_Complete_Event,
     HCI_LE_Advertising_Report_Event,
-    HCI_LE_CIS_Established_Event,
-    HCI_LE_CIS_Request_Event,
     HCI_LE_Connection_Complete_Event,
     HCI_LE_Read_Remote_Features_Complete_Event,
     HCI_Number_Of_Completed_Packets_Event,
     HCI_Packet,
     HCI_Role_Change_Event,
 )
-from typing import Optional, Union, Dict, Any, TYPE_CHECKING
+from typing import Optional, Union, Dict, TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from bumble.link import LocalLink
-    from bumble.transport.common import TransportSink
+    from bumble.transport.common import TransportSink, TransportSource
 
 # -----------------------------------------------------------------------------
 # Logging
@@ -85,27 +79,15 @@ class DataObject:
 
 
 # -----------------------------------------------------------------------------
-@dataclasses.dataclass
-class CisLink:
-    handle: int
-    cis_id: int
-    cig_id: int
-    acl_connection: Optional[Connection] = None
-
-
-# -----------------------------------------------------------------------------
-@dataclasses.dataclass
 class Connection:
-    controller: Controller
-    handle: int
-    role: int
-    peer_address: Address
-    link: Any
-    transport: int
-    link_type: int
-
-    def __post_init__(self):
+    def __init__(self, controller, handle, role, peer_address, link, transport):
+        self.controller = controller
+        self.handle = handle
+        self.role = role
+        self.peer_address = peer_address
+        self.link = link
         self.assembler = HCI_AclDataPacketAssembler(self.on_acl_pdu)
+        self.transport = transport
 
     def on_hci_acl_data_packet(self, packet):
         self.assembler.feed_packet(packet)
@@ -124,27 +106,25 @@ class Connection:
 class Controller:
     def __init__(
         self,
-        name: str,
+        name,
         host_source=None,
         host_sink: Optional[TransportSink] = None,
-        link: Optional[LocalLink] = None,
+        link=None,
         public_address: Optional[Union[bytes, str, Address]] = None,
     ):
         self.name = name
         self.hci_sink = None
         self.link = link
 
-        self.central_connections: Dict[Address, Connection] = (
-            {}
-        )  # Connections where this controller is the central
-        self.peripheral_connections: Dict[Address, Connection] = (
-            {}
-        )  # Connections where this controller is the peripheral
-        self.classic_connections: Dict[Address, Connection] = (
-            {}
-        )  # Connections in BR/EDR
-        self.central_cis_links: Dict[int, CisLink] = {}  # CIS links by handle
-        self.peripheral_cis_links: Dict[int, CisLink] = {}  # CIS links by handle
+        self.central_connections: Dict[
+            Address, Connection
+        ] = {}  # Connections where this controller is the central
+        self.peripheral_connections: Dict[
+            Address, Connection
+        ] = {}  # Connections where this controller is the peripheral
+        self.classic_connections: Dict[
+            Address, Connection
+        ] = {}  # Connections in BR/EDR
 
         self.hci_version = HCI_VERSION_BLUETOOTH_CORE_5_0
         self.hci_revision = 0
@@ -154,14 +134,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
@@ -323,7 +301,7 @@ class Controller:
     ############################################################
     # Link connections
     ############################################################
-    def allocate_connection_handle(self) -> int:
+    def allocate_connection_handle(self):
         handle = 0
         max_handle = 0
         for connection in itertools.chain(
@@ -335,13 +313,6 @@ class Controller:
             if connection.handle == handle:
                 # Already used, continue searching after the current max
                 handle = max_handle + 1
-        for cis_handle in itertools.chain(
-            self.central_cis_links.keys(), self.peripheral_cis_links.keys()
-        ):
-            max_handle = max(max_handle, cis_handle)
-            if cis_handle == handle:
-                # Already used, continue searching after the current max
-                handle = max_handle + 1
         return handle
 
     def find_le_connection_by_address(self, address):
@@ -386,13 +357,12 @@ class Controller:
         if connection is None:
             connection_handle = self.allocate_connection_handle()
             connection = Connection(
-                controller=self,
-                handle=connection_handle,
-                role=BT_PERIPHERAL_ROLE,
-                peer_address=peer_address,
-                link=self.link,
-                transport=BT_LE_TRANSPORT,
-                link_type=HCI_Connection_Complete_Event.ACL_LINK_TYPE,
+                self,
+                connection_handle,
+                BT_PERIPHERAL_ROLE,
+                peer_address,
+                self.link,
+                BT_LE_TRANSPORT,
             )
             self.peripheral_connections[peer_address] = connection
             logger.debug(f'New PERIPHERAL connection handle: 0x{connection_handle:04X}')
@@ -446,13 +416,12 @@ class Controller:
             if connection is None:
                 connection_handle = self.allocate_connection_handle()
                 connection = Connection(
-                    controller=self,
-                    handle=connection_handle,
-                    role=BT_CENTRAL_ROLE,
-                    peer_address=peer_address,
-                    link=self.link,
-                    transport=BT_LE_TRANSPORT,
-                    link_type=HCI_Connection_Complete_Event.ACL_LINK_TYPE,
+                    self,
+                    connection_handle,
+                    BT_CENTRAL_ROLE,
+                    peer_address,
+                    self.link,
+                    BT_LE_TRANSPORT,
                 )
                 self.central_connections[peer_address] = connection
                 logger.debug(
@@ -569,104 +538,6 @@ class Controller:
         )
         self.send_hci_packet(HCI_LE_Advertising_Report_Event([report]))
 
-    def on_link_cis_request(
-        self, central_address: Address, cig_id: int, cis_id: int
-    ) -> None:
-        '''
-        Called when an incoming CIS request occurs from a central on the link
-        '''
-
-        connection = self.peripheral_connections.get(central_address)
-        assert connection
-
-        pending_cis_link = CisLink(
-            handle=self.allocate_connection_handle(),
-            cis_id=cis_id,
-            cig_id=cig_id,
-            acl_connection=connection,
-        )
-        self.peripheral_cis_links[pending_cis_link.handle] = pending_cis_link
-
-        self.send_hci_packet(
-            HCI_LE_CIS_Request_Event(
-                acl_connection_handle=connection.handle,
-                cis_connection_handle=pending_cis_link.handle,
-                cig_id=cig_id,
-                cis_id=cis_id,
-            )
-        )
-
-    def on_link_cis_established(self, cig_id: int, cis_id: int) -> None:
-        '''
-        Called when an incoming CIS established.
-        '''
-
-        cis_link = next(
-            cis_link
-            for cis_link in itertools.chain(
-                self.central_cis_links.values(), self.peripheral_cis_links.values()
-            )
-            if cis_link.cis_id == cis_id and cis_link.cig_id == cig_id
-        )
-
-        self.send_hci_packet(
-            HCI_LE_CIS_Established_Event(
-                status=HCI_SUCCESS,
-                connection_handle=cis_link.handle,
-                # CIS parameters are ignored.
-                cig_sync_delay=0,
-                cis_sync_delay=0,
-                transport_latency_c_to_p=0,
-                transport_latency_p_to_c=0,
-                phy_c_to_p=0,
-                phy_p_to_c=0,
-                nse=0,
-                bn_c_to_p=0,
-                bn_p_to_c=0,
-                ft_c_to_p=0,
-                ft_p_to_c=0,
-                max_pdu_c_to_p=0,
-                max_pdu_p_to_c=0,
-                iso_interval=0,
-            )
-        )
-
-    def on_link_cis_disconnected(self, cig_id: int, cis_id: int) -> None:
-        '''
-        Called when a CIS disconnected.
-        '''
-
-        if cis_link := next(
-            (
-                cis_link
-                for cis_link in self.peripheral_cis_links.values()
-                if cis_link.cis_id == cis_id and cis_link.cig_id == cig_id
-            ),
-            None,
-        ):
-            # Remove peripheral CIS on disconnection.
-            self.peripheral_cis_links.pop(cis_link.handle)
-        elif cis_link := next(
-            (
-                cis_link
-                for cis_link in self.central_cis_links.values()
-                if cis_link.cis_id == cis_id and cis_link.cig_id == cig_id
-            ),
-            None,
-        ):
-            # Keep central CIS on disconnection. They should be removed by HCI_LE_Remove_CIG_Command.
-            cis_link.acl_connection = None
-        else:
-            return
-
-        self.send_hci_packet(
-            HCI_Disconnection_Complete_Event(
-                status=HCI_SUCCESS,
-                connection_handle=cis_link.handle,
-                reason=HCI_REMOTE_USER_TERMINATED_CONNECTION_ERROR,
-            )
-        )
-
     ############################################################
     # Classic link connections
     ############################################################
@@ -695,7 +566,6 @@ class Controller:
                     peer_address=peer_address,
                     link=self.link,
                     transport=BT_BR_EDR_TRANSPORT,
-                    link_type=HCI_Connection_Complete_Event.ACL_LINK_TYPE,
                 )
                 self.classic_connections[peer_address] = connection
                 logger.debug(
@@ -749,42 +619,6 @@ class Controller:
             )
         )
 
-    def on_classic_sco_connection_complete(
-        self, peer_address: Address, status: int, link_type: int
-    ):
-        if status == HCI_SUCCESS:
-            # Allocate (or reuse) a connection handle
-            connection_handle = self.allocate_connection_handle()
-            connection = Connection(
-                controller=self,
-                handle=connection_handle,
-                # Role doesn't matter in SCO.
-                role=BT_CENTRAL_ROLE,
-                peer_address=peer_address,
-                link=self.link,
-                transport=BT_BR_EDR_TRANSPORT,
-                link_type=link_type,
-            )
-            self.classic_connections[peer_address] = connection
-            logger.debug(f'New SCO connection handle: 0x{connection_handle:04X}')
-        else:
-            connection_handle = 0
-
-        self.send_hci_packet(
-            HCI_Synchronous_Connection_Complete_Event(
-                status=status,
-                connection_handle=connection_handle,
-                bd_addr=peer_address,
-                link_type=link_type,
-                # TODO: Provide SCO connection parameters.
-                transmission_interval=0,
-                retransmission_window=0,
-                rx_packet_length=0,
-                tx_packet_length=0,
-                air_mode=0,
-            )
-        )
-
     ############################################################
     # Advertising support
     ############################################################
@@ -887,17 +721,6 @@ class Controller:
             else:
                 # Remove the connection
                 del self.classic_connections[connection.peer_address]
-        elif cis_link := (
-            self.central_cis_links.get(handle) or self.peripheral_cis_links.get(handle)
-        ):
-            if self.link:
-                self.link.disconnect_cis(
-                    initiator_controller=self,
-                    peer_address=cis_link.acl_connection.peer_address,
-                    cig_id=cis_link.cig_id,
-                    cis_id=cis_link.cis_id,
-                )
-            # Spec requires handle to be kept after disconnection.
 
     def on_hci_accept_connection_request_command(self, command):
         '''
@@ -915,68 +738,6 @@ class Controller:
         )
         self.link.classic_accept_connection(self, command.bd_addr, command.role)
 
-    def on_hci_enhanced_setup_synchronous_connection_command(self, command):
-        '''
-        See Bluetooth spec Vol 4, Part E - 7.1.45 Enhanced Setup Synchronous Connection command
-        '''
-
-        if self.link is None:
-            return
-
-        if not (
-            connection := self.find_classic_connection_by_handle(
-                command.connection_handle
-            )
-        ):
-            self.send_hci_packet(
-                HCI_Command_Status_Event(
-                    status=HCI_UNKNOWN_CONNECTION_IDENTIFIER_ERROR,
-                    num_hci_command_packets=1,
-                    command_opcode=command.op_code,
-                )
-            )
-            return
-
-        self.send_hci_packet(
-            HCI_Command_Status_Event(
-                status=HCI_SUCCESS,
-                num_hci_command_packets=1,
-                command_opcode=command.op_code,
-            )
-        )
-        self.link.classic_sco_connect(
-            self, connection.peer_address, HCI_Connection_Complete_Event.ESCO_LINK_TYPE
-        )
-
-    def on_hci_enhanced_accept_synchronous_connection_request_command(self, command):
-        '''
-        See Bluetooth spec Vol 4, Part E - 7.1.46 Enhanced Accept Synchronous Connection Request command
-        '''
-
-        if self.link is None:
-            return
-
-        if not (connection := self.find_classic_connection_by_address(command.bd_addr)):
-            self.send_hci_packet(
-                HCI_Command_Status_Event(
-                    status=HCI_UNKNOWN_CONNECTION_IDENTIFIER_ERROR,
-                    num_hci_command_packets=1,
-                    command_opcode=command.op_code,
-                )
-            )
-            return
-
-        self.send_hci_packet(
-            HCI_Command_Status_Event(
-                status=HCI_SUCCESS,
-                num_hci_command_packets=1,
-                command_opcode=command.op_code,
-            )
-        )
-        self.link.classic_accept_sco_connection(
-            self, connection.peer_address, HCI_Connection_Complete_Event.ESCO_LINK_TYPE
-        )
-
     def on_hci_switch_role_command(self, command):
         '''
         See Bluetooth spec Vol 4, Part E - 7.2.8 Switch Role command
@@ -1151,41 +912,7 @@ class Controller:
         '''
         See Bluetooth spec Vol 4, Part E - 7.4.3 Read Local Supported Features Command
         '''
-        return bytes([HCI_SUCCESS]) + self.lmp_features[:8]
-
-    def on_hci_read_local_extended_features_command(self, command):
-        '''
-        See Bluetooth spec Vol 4, Part E - 7.4.4 Read Local Extended Features Command
-        '''
-        if command.page_number * 8 > len(self.lmp_features):
-            return bytes([HCI_INVALID_HCI_COMMAND_PARAMETERS_ERROR])
-        return (
-            bytes(
-                [
-                    # Status
-                    HCI_SUCCESS,
-                    # Page number
-                    command.page_number,
-                    # Max page number
-                    len(self.lmp_features) // 8 - 1,
-                ]
-            )
-            # Features of the current page
-            + self.lmp_features[command.page_number * 8 : (command.page_number + 1) * 8]
-        )
-
-    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,
-        )
+        return bytes([HCI_SUCCESS]) + self.lmp_features
 
     def on_hci_read_bd_addr_command(self, _command):
         '''
@@ -1273,9 +1000,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
@@ -1362,18 +1086,6 @@ class Controller:
         See Bluetooth spec Vol 4, Part E - 7.8.21 LE Read Remote Features Command
         '''
 
-        handle = command.connection_handle
-
-        if not self.find_connection_by_handle(handle):
-            self.send_hci_packet(
-                HCI_Command_Status_Event(
-                    status=HCI_INVALID_HCI_COMMAND_PARAMETERS_ERROR,
-                    num_hci_command_packets=1,
-                    command_opcode=command.op_code,
-                )
-            )
-            return
-
         # First, say that the command is pending
         self.send_hci_packet(
             HCI_Command_Status_Event(
@@ -1387,7 +1099,7 @@ class Controller:
         self.send_hci_packet(
             HCI_LE_Read_Remote_Features_Complete_Event(
                 status=HCI_SUCCESS,
-                connection_handle=handle,
+                connection_handle=0,
                 le_features=bytes.fromhex('dd40000000000000'),
             )
         )
@@ -1543,135 +1255,8 @@ class Controller:
         }
         return bytes([HCI_SUCCESS])
 
-    def on_hci_le_read_maximum_advertising_data_length_command(self, _command):
-        '''
-        See Bluetooth spec Vol 4, Part E - 7.8.57 LE Read Maximum Advertising Data
-        Length Command
-        '''
-        return struct.pack('<BH', HCI_SUCCESS, 0x0672)
-
-    def on_hci_le_read_number_of_supported_advertising_sets_command(self, _command):
-        '''
-        See Bluetooth spec Vol 4, Part E - 7.8.58 LE Read Number of Supported
-        Advertising Set Command
-        '''
-        return struct.pack('<BB', HCI_SUCCESS, 0xF0)
-
     def on_hci_le_read_transmit_power_command(self, _command):
         '''
         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_set_cig_parameters_command(self, command):
-        '''
-        See Bluetooth spec Vol 4, Part E - 7.8.97 LE Set CIG Parameter Command
-        '''
-
-        # Remove old CIG implicitly.
-        for handle, cis_link in self.central_cis_links.items():
-            if cis_link.cig_id == command.cig_id:
-                self.central_cis_links.pop(handle)
-
-        handles = []
-        for cis_id in command.cis_id:
-            handle = self.allocate_connection_handle()
-            handles.append(handle)
-            self.central_cis_links[handle] = CisLink(
-                cis_id=cis_id,
-                cig_id=command.cig_id,
-                handle=handle,
-            )
-        return struct.pack(
-            '<BBB', HCI_SUCCESS, command.cig_id, len(handles)
-        ) + b''.join([struct.pack('<H', handle) for handle in handles])
-
-    def on_hci_le_create_cis_command(self, command):
-        '''
-        See Bluetooth spec Vol 4, Part E - 7.8.99 LE Create CIS Command
-        '''
-        if not self.link:
-            return
-
-        for cis_handle, acl_handle in zip(
-            command.cis_connection_handle, command.acl_connection_handle
-        ):
-            if not (connection := self.find_connection_by_handle(acl_handle)):
-                logger.error(f'Cannot find connection with handle={acl_handle}')
-                return bytes([HCI_INVALID_HCI_COMMAND_PARAMETERS_ERROR])
-
-            if not (cis_link := self.central_cis_links.get(cis_handle)):
-                logger.error(f'Cannot find CIS with handle={cis_handle}')
-                return bytes([HCI_INVALID_HCI_COMMAND_PARAMETERS_ERROR])
-
-            cis_link.acl_connection = connection
-
-            self.link.create_cis(
-                self,
-                peripheral_address=connection.peer_address,
-                cig_id=cis_link.cig_id,
-                cis_id=cis_link.cis_id,
-            )
-
-        self.send_hci_packet(
-            HCI_Command_Status_Event(
-                status=HCI_COMMAND_STATUS_PENDING,
-                num_hci_command_packets=1,
-                command_opcode=command.op_code,
-            )
-        )
-
-    def on_hci_le_remove_cig_command(self, command):
-        '''
-        See Bluetooth spec Vol 4, Part E - 7.8.100 LE Remove CIG Command
-        '''
-
-        status = HCI_UNKNOWN_CONNECTION_IDENTIFIER_ERROR
-
-        for cis_handle, cis_link in self.central_cis_links.items():
-            if cis_link.cig_id == command.cig_id:
-                self.central_cis_links.pop(cis_handle)
-                status = HCI_SUCCESS
-
-        return struct.pack('<BH', status, command.cig_id)
-
-    def on_hci_le_accept_cis_request_command(self, command):
-        '''
-        See Bluetooth spec Vol 4, Part E - 7.8.101 LE Accept CIS Request Command
-        '''
-        if not self.link:
-            return
-
-        if not (
-            pending_cis_link := self.peripheral_cis_links.get(command.connection_handle)
-        ):
-            logger.error(f'Cannot find CIS with handle={command.connection_handle}')
-            return bytes([HCI_INVALID_HCI_COMMAND_PARAMETERS_ERROR])
-
-        assert pending_cis_link.acl_connection
-        self.link.accept_cis(
-            peripheral_controller=self,
-            central_address=pending_cis_link.acl_connection.peer_address,
-            cig_id=pending_cis_link.cig_id,
-            cis_id=pending_cis_link.cis_id,
-        )
-
-        self.send_hci_packet(
-            HCI_Command_Status_Event(
-                status=HCI_COMMAND_STATUS_PENDING,
-                num_hci_command_packets=1,
-                command_opcode=command.op_code,
-            )
-        )
-
-    def on_hci_le_setup_iso_data_path_command(self, command):
-        '''
-        See Bluetooth spec Vol 4, Part E - 7.8.109 LE Setup ISO Data Path Command
-        '''
-        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/crypto.py

@@ -21,8 +21,6 @@
 # -----------------------------------------------------------------------------
 # Imports
 # -----------------------------------------------------------------------------
-from __future__ import annotations
-
 import logging
 import operator
 
@@ -31,13 +29,11 @@ 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
 
 
 # -----------------------------------------------------------------------------
@@ -50,18 +46,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 +65,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 +73,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 +93,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 +108,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 +132,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 +144,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 +154,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 +166,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 +187,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/decoder.py

@@ -12,8 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Union
-
 # -----------------------------------------------------------------------------
 # Constants
 # -----------------------------------------------------------------------------
@@ -151,7 +149,7 @@ QMF_COEFFS = [3, -11, 12, 32, -210, 951, 3876, -805, 362, -156, 53, -11]
 # -----------------------------------------------------------------------------
 # Classes
 # -----------------------------------------------------------------------------
-class G722Decoder:
+class G722Decoder(object):
     """G.722 decoder with bitrate 64kbit/s.
 
     For the Blocks in the sub-band decoders, please refer to the G.722
@@ -159,7 +157,7 @@ class G722Decoder:
     https://www.itu.int/rec/T-REC-G.722-201209-I
     """
 
-    def __init__(self) -> None:
+    def __init__(self):
         self._x = [0] * 24
         self._band = [Band(), Band()]
         # The initial value in BLOCK 3L
@@ -167,12 +165,12 @@ class G722Decoder:
         # The initial value in BLOCK 3H
         self._band[1].det = 8
 
-    def decode_frame(self, encoded_data: Union[bytes, bytearray]) -> bytearray:
+    def decode_frame(self, encoded_data) -> bytearray:
         result_array = bytearray(len(encoded_data) * 4)
         self.g722_decode(result_array, encoded_data)
         return result_array
 
-    def g722_decode(self, result_array, encoded_data: Union[bytes, bytearray]) -> int:
+    def g722_decode(self, result_array, encoded_data) -> int:
         """Decode the data frame using g722 decoder."""
         result_length = 0
 
@@ -200,16 +198,14 @@ class G722Decoder:
 
         return result_length
 
-    def update_decoded_result(
-        self, xout: int, byte_length: int, byte_array: bytearray
-    ) -> int:
+    def update_decoded_result(self, xout, byte_length, byte_array) -> int:
         result = (int)(xout >> 11)
         bytes_result = result.to_bytes(2, 'little', signed=True)
         byte_array[byte_length] = bytes_result[0]
         byte_array[byte_length + 1] = bytes_result[1]
         return byte_length + 2
 
-    def lower_sub_band_decoder(self, lower_bits: int) -> int:
+    def lower_sub_band_decoder(self, lower_bits) -> int:
         """Lower sub-band decoder for last six bits."""
 
         # Block 5L
@@ -262,7 +258,7 @@ class G722Decoder:
 
         return rlow
 
-    def higher_sub_band_decoder(self, higher_bits: int) -> int:
+    def higher_sub_band_decoder(self, higher_bits) -> int:
         """Higher sub-band decoder for first two bits."""
 
         # Block 2H
@@ -310,14 +306,14 @@ class G722Decoder:
 
 
 # -----------------------------------------------------------------------------
-class Band:
-    """Structure for G722 decode processing."""
+class Band(object):
+    """Structure for G722 decode proccessing."""
 
     s: int = 0
     nb: int = 0
     det: int = 0
 
-    def __init__(self) -> None:
+    def __init__(self):
         self._sp = 0
         self._sz = 0
         self._r = [0] * 3

bumble/drivers/__init__.py

@@ -19,17 +19,12 @@ 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 . import rtk, intel
-from .common import Driver
-
-if TYPE_CHECKING:
-    from bumble.host import Host
 
 # -----------------------------------------------------------------------------
 # Logging
@@ -37,31 +32,40 @@ 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, "intel": intel.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
 

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/intel.py

@@ -1,102 +0,0 @@
-# Copyright 2024 Google LLC
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# -----------------------------------------------------------------------------
-# Imports
-# -----------------------------------------------------------------------------
-import logging
-
-from bumble.drivers import common
-from bumble.hci import (
-    hci_vendor_command_op_code,  # type: ignore
-    HCI_Command,
-    HCI_Reset_Command,
-)
-
-# -----------------------------------------------------------------------------
-# Logging
-# -----------------------------------------------------------------------------
-logger = logging.getLogger(__name__)
-
-# -----------------------------------------------------------------------------
-# Constant
-# -----------------------------------------------------------------------------
-
-INTEL_USB_PRODUCTS = {
-    # Intel AX210
-    (0x8087, 0x0032),
-    # Intel BE200
-    (0x8087, 0x0036),
-}
-
-# -----------------------------------------------------------------------------
-# HCI Commands
-# -----------------------------------------------------------------------------
-HCI_INTEL_DDC_CONFIG_WRITE_COMMAND = hci_vendor_command_op_code(0xFC8B)  # type: ignore
-HCI_INTEL_DDC_CONFIG_WRITE_PAYLOAD = [0x03, 0xE4, 0x02, 0x00]
-
-HCI_Command.register_commands(globals())
-
-
-@HCI_Command.command(  # type: ignore
-    fields=[("params", "*")],
-    return_parameters_fields=[
-        ("params", "*"),
-    ],
-)
-class Hci_Intel_DDC_Config_Write_Command(HCI_Command):
-    pass
-
-
-class Driver(common.Driver):
-    def __init__(self, host):
-        self.host = host
-
-    @staticmethod
-    def check(host):
-        driver = host.hci_metadata.get("driver")
-        if driver == "intel":
-            return True
-
-        vendor_id = host.hci_metadata.get("vendor_id")
-        product_id = host.hci_metadata.get("product_id")
-
-        if vendor_id is None or product_id is None:
-            logger.debug("USB metadata not sufficient")
-            return False
-
-        if (vendor_id, product_id) not in INTEL_USB_PRODUCTS:
-            logger.debug(
-                f"USB device ({vendor_id:04X}, {product_id:04X}) " "not in known list"
-            )
-            return False
-
-        return True
-
-    @classmethod
-    async def for_host(cls, host, force=False):  # type: ignore
-        # Only instantiate this driver if explicitly selected
-        if not force and not cls.check(host):
-            return None
-
-        return cls(host)
-
-    async def init_controller(self):
-        self.host.ready = True
-        await self.host.send_command(HCI_Reset_Command(), check_result=True)
-        await self.host.send_command(
-            Hci_Intel_DDC_Config_Write_Command(
-                params=HCI_INTEL_DDC_CONFIG_WRITE_PAYLOAD
-            )
-        )

bumble/drivers/rtk.py

@@ -33,7 +33,6 @@ from typing import Tuple
 import weakref
 
 
-from bumble import core
 from bumble.hci import (
     hci_vendor_command_op_code,
     STATUS_SPEC,
@@ -42,7 +41,7 @@ from bumble.hci import (
     HCI_Reset_Command,
     HCI_Read_Local_Version_Information_Command,
 )
-from bumble.drivers import common
+
 
 # -----------------------------------------------------------------------------
 # Logging
@@ -50,10 +49,6 @@ from bumble.drivers import common
 logger = logging.getLogger(__name__)
 
 
-class RtkFirmwareError(core.BaseBumbleError):
-    """Error raised when RTK firmware initialization fails."""
-
-
 # -----------------------------------------------------------------------------
 # Constants
 # -----------------------------------------------------------------------------
@@ -213,15 +208,15 @@ class Firmware:
         extension_sig = bytes([0x51, 0x04, 0xFD, 0x77])
 
         if not firmware.startswith(RTK_EPATCH_SIGNATURE):
-            raise RtkFirmwareError("Firmware does not start with epatch signature")
+            raise ValueError("Firmware does not start with epatch signature")
 
         if not firmware.endswith(extension_sig):
-            raise RtkFirmwareError("Firmware does not end with extension sig")
+            raise ValueError("Firmware does not end with extension sig")
 
         # The firmware should start with a 14 byte header.
         epatch_header_size = 14
         if len(firmware) < epatch_header_size:
-            raise RtkFirmwareError("Firmware too short")
+            raise ValueError("Firmware too short")
 
         # Look for the "project ID", starting from the end.
         offset = len(firmware) - len(extension_sig)
@@ -235,7 +230,7 @@ class Firmware:
                 break
 
             if length == 0:
-                raise RtkFirmwareError("Invalid 0-length instruction")
+                raise ValueError("Invalid 0-length instruction")
 
             if opcode == 0 and length == 1:
                 project_id = firmware[offset - 1]
@@ -244,7 +239,7 @@ class Firmware:
             offset -= length
 
         if project_id < 0:
-            raise RtkFirmwareError("Project ID not found")
+            raise ValueError("Project ID not found")
 
         self.project_id = project_id
 
@@ -257,7 +252,7 @@ class Firmware:
         # <PatchLength_1><PatchLength_2>...<PatchLength_N> (16 bits each)
         # <PatchOffset_1><PatchOffset_2>...<PatchOffset_N> (32 bits each)
         if epatch_header_size + 8 * num_patches > len(firmware):
-            raise RtkFirmwareError("Firmware too short")
+            raise ValueError("Firmware too short")
         chip_id_table_offset = epatch_header_size
         patch_length_table_offset = chip_id_table_offset + 2 * num_patches
         patch_offset_table_offset = chip_id_table_offset + 4 * num_patches
@@ -271,7 +266,7 @@ class Firmware:
                 "<I", firmware, patch_offset_table_offset + 4 * patch_index
             )
             if patch_offset + patch_length > len(firmware):
-                raise RtkFirmwareError("Firmware too short")
+                raise ValueError("Firmware too short")
 
             # Get the SVN version for the patch
             (svn_version,) = struct.unpack_from(
@@ -290,7 +285,7 @@ class Firmware:
             )
 
 
-class Driver(common.Driver):
+class Driver:
     @dataclass
     class DriverInfo:
         rom: int
@@ -301,8 +296,6 @@ class Driver(common.Driver):
         fw_name: str = ""
         config_name: str = ""
 
-    POST_RESET_DELAY: float = 0.2
-
     DRIVER_INFOS = [
         # 8723A
         DriverInfo(
@@ -477,12 +470,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
@@ -497,24 +486,9 @@ class Driver(common.Driver):
 
     @classmethod
     async def driver_info_for_host(cls, host):
-        try:
-            await host.send_command(
-                HCI_Reset_Command(),
-                check_result=True,
-                response_timeout=cls.POST_RESET_DELAY,
-            )
-            host.ready = True  # Needed to let the host know the controller is ready.
-        except asyncio.exceptions.TimeoutError:
-            logger.warning("timeout waiting for hci reset, retrying")
-            await host.send_command(HCI_Reset_Command(), check_result=True)
-            host.ready = True
-
-        command = HCI_Read_Local_Version_Information_Command()
-        response = await host.send_command(command, check_result=True)
-        if response.command_opcode != command.op_code:
-            logger.error("failed to probe local version information")
-            return None
-
+        response = await host.send_command(
+            HCI_Read_Local_Version_Information_Command(), check_result=True
+        )
         local_version = response.return_parameters
 
         logger.debug(
@@ -664,7 +638,7 @@ class Driver(common.Driver):
         ):
             return await self.download_for_rtl8723b()
 
-        raise RtkFirmwareError("ROM not supported")
+        raise ValueError("ROM not supported")
 
     async def init_controller(self):
         await self.download_firmware()

bumble/gap.py

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

bumble/gatt.py

@@ -23,28 +23,16 @@
 # Imports
 # -----------------------------------------------------------------------------
 from __future__ import annotations
+import asyncio
 import enum
 import functools
 import logging
 import struct
-from typing import (
-    Callable,
-    Dict,
-    Iterable,
-    List,
-    Optional,
-    Sequence,
-    Union,
-    TYPE_CHECKING,
-)
+from typing import Optional, Sequence, List
 
-from bumble.colors import color
-from bumble.core import BaseBumbleError, 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,101 +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(0x2BB3, 'Bearer Provider Name')
-GATT_BEARER_UCI_CHARACTERISTIC                                = UUID.from_16_bits(0x2BB4, 'Bearer UCI')
-GATT_BEARER_TECHNOLOGY_CHARACTERISTIC                         = UUID.from_16_bits(0x2BB5, 'Bearer Technology')
-GATT_BEARER_URI_SCHEMES_SUPPORTED_LIST_CHARACTERISTIC         = UUID.from_16_bits(0x2BB6, 'Bearer URI Schemes Supported List')
-GATT_BEARER_SIGNAL_STRENGTH_CHARACTERISTIC                    = UUID.from_16_bits(0x2BB7, 'Bearer Signal Strength')
-GATT_BEARER_SIGNAL_STRENGTH_REPORTING_INTERVAL_CHARACTERISTIC = UUID.from_16_bits(0x2BB8, 'Bearer Signal Strength Reporting Interval')
-GATT_BEARER_LIST_CURRENT_CALLS_CHARACTERISTIC                 = UUID.from_16_bits(0x2BB9, 'Bearer List Current Calls')
-GATT_CONTENT_CONTROL_ID_CHARACTERISTIC                        = UUID.from_16_bits(0x2BBA, 'Content Control ID')
-GATT_STATUS_FLAGS_CHARACTERISTIC                              = UUID.from_16_bits(0x2BBB, 'Status Flags')
-GATT_INCOMING_CALL_TARGET_BEARER_URI_CHARACTERISTIC           = UUID.from_16_bits(0x2BBC, 'Incoming Call Target Bearer URI')
-GATT_CALL_STATE_CHARACTERISTIC                                = UUID.from_16_bits(0x2BBD, 'Call State')
-GATT_CALL_CONTROL_POINT_CHARACTERISTIC                        = UUID.from_16_bits(0x2BBE, 'Call Control Point')
-GATT_CALL_CONTROL_POINT_OPTIONAL_OPCODES_CHARACTERISTIC       = UUID.from_16_bits(0x2BBF, 'Call Control Point Optional Opcodes')
-GATT_TERMINATION_REASON_CHARACTERISTIC                        = UUID.from_16_bits(0x2BC0, 'Termination Reason')
-GATT_INCOMING_CALL_CHARACTERISTIC                             = UUID.from_16_bits(0x2BC1, 'Incoming Call')
-GATT_CALL_FRIENDLY_NAME_CHARACTERISTIC                        = UUID.from_16_bits(0x2BC2, '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')
-
-# Hearing Access Service
-GATT_HEARING_AID_FEATURES_CHARACTERISTIC             = UUID.from_16_bits(0x2BDA, 'Hearing Aid Features')
-GATT_HEARING_AID_PRESET_CONTROL_POINT_CHARACTERISTIC = UUID.from_16_bits(0x2BDB, 'Hearing Aid Preset Control Point')
-GATT_ACTIVE_PRESET_INDEX_CHARACTERISTIC              = UUID.from_16_bits(0x2BDC, 'Active Preset Index')
-
 # 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')
@@ -301,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
@@ -314,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'))
 
@@ -325,11 +198,6 @@ def show_services(services: Iterable[Service]) -> None:
                 print(color('    ' + str(descriptor), 'green'))
 
 
-# -----------------------------------------------------------------------------
-class InvalidServiceError(BaseBumbleError):
-    """The service is not compliant with the spec/profile"""
-
-
 # -----------------------------------------------------------------------------
 class Service(Attribute):
     '''
@@ -342,26 +210,24 @@ class Service(Attribute):
 
     def __init__(
         self,
-        uuid: Union[str, UUID],
+        uuid,
         characteristics: List[Characteristic],
         primary=True,
-        included_services: Iterable[Service] = (),
-    ) -> None:
+        included_services: List[Service] = [],
+    ):
         # Convert the uuid to a UUID object if it isn't already
         if isinstance(uuid, str):
             uuid = UUID(uuid)
 
         super().__init__(
-            (
-                GATT_PRIMARY_SERVICE_ATTRIBUTE_TYPE
-                if primary
-                else GATT_SECONDARY_SERVICE_ATTRIBUTE_TYPE
-            ),
+            GATT_PRIMARY_SERVICE_ATTRIBUTE_TYPE
+            if primary
+            else GATT_SECONDARY_SERVICE_ATTRIBUTE_TYPE,
             Attribute.READABLE,
             uuid.to_pdu_bytes(),
         )
         self.uuid = uuid
-        self.included_services = list(included_services)
+        self.included_services = included_services[:]
         self.characteristics = characteristics[:]
         self.primary = primary
 
@@ -373,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}, '
@@ -389,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: Iterable[Service] = (),
-    ) -> None:
-        super().__init__(self.UUID, characteristics, primary, included_services)
+    def __init__(self, characteristics, primary=True):
+        super().__init__(self.UUID, characteristics, primary)
 
 
 # -----------------------------------------------------------------------------
@@ -408,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()
         )
@@ -417,7 +278,7 @@ 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}, '
@@ -465,7 +326,7 @@ class Characteristic(Attribute):
                     f"Characteristic.Properties::from_string() error:\nExpected a string containing any of the keys, separated by , or |: {enum_list_str}\nGot: {properties_str}"
                 )
 
-        def __str__(self) -> str:
+        def __str__(self):
             # 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(
@@ -487,10 +348,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)
@@ -508,7 +369,7 @@ 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}, '
@@ -525,7 +386,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()
@@ -536,7 +397,7 @@ 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}, '
@@ -546,43 +407,56 @@ class CharacteristicDeclaration(Attribute):
 
 
 # -----------------------------------------------------------------------------
-class CharacteristicValue(AttributeValue):
-    """Same as AttributeValue, for backward compatibility"""
+class CharacteristicValue:
+    '''
+    Characteristic value where reading and/or writing is delegated to functions
+    passed as arguments to the constructor.
+    '''
+
+    def __init__(self, read=None, write=None):
+        self._read = read
+        self._write = write
+
+    def read(self, connection):
+        return self._read(connection) if self._read else b''
+
+    def write(self, connection, value):
+        if self._write:
+            self._write(connection, value)
 
 
 # -----------------------------------------------------------------------------
 class CharacteristicAdapter:
     '''
-    An adapter that can adapt Characteristic and AttributeProxy objects
-    by wrapping their `read_value()` and `write_value()` methods with ones that
-    return/accept encoded/decoded values.
-
-    For proxies (i.e used by a GATT client), the adaptation is one where the return
-    value of `read_value()` is decoded and the value passed to `write_value()` is
-    encoded. The `subscribe()` method, is wrapped with one where the values are decoded
-    before being passed to the subscriber.
-
-    For local values (i.e hosted by a GATT server) the adaptation is one where the
-    return value of `read_value()` is encoded and the value passed to `write_value()`
-    is decoded.
+    An adapter that can adapt any object with `read_value` and `write_value`
+    methods (like Characteristic and CharacteristicProxy objects) by wrapping
+    those methods with ones that return/accept encoded/decoded values.
+    Objects with async methods are considered proxies, so the adaptation is one
+    where the return value of `read_value` is decoded and the value passed to
+    `write_value` is encoded. Other objects are considered local characteristics
+    so the adaptation is one where the return value of `read_value` is encoded
+    and the value passed to `write_value` is decoded.
+    If the characteristic has a `subscribe` method, it is wrapped with one where
+    the values are decoded before being passed to the subscriber.
     '''
 
-    read_value: Callable
-    write_value: Callable
-
-    def __init__(self, characteristic: Union[Characteristic, AttributeProxy]):
+    def __init__(self, characteristic):
         self.wrapped_characteristic = characteristic
-        self.subscribers: Dict[Callable, Callable] = (
-            {}
-        )  # Map from subscriber to proxy subscriber
+        self.subscribers = {}  # Map from subscriber to proxy subscriber
 
-        if isinstance(characteristic, Characteristic):
-            self.read_value = self.read_encoded_value
-            self.write_value = self.write_encoded_value
-        else:
+        if asyncio.iscoroutinefunction(
+            characteristic.read_value
+        ) and asyncio.iscoroutinefunction(characteristic.write_value):
             self.read_value = self.read_decoded_value
             self.write_value = self.write_decoded_value
+        else:
+            self.read_value = self.read_encoded_value
+            self.write_value = self.write_encoded_value
+
+        if hasattr(self.wrapped_characteristic, 'subscribe'):
             self.subscribe = self.wrapped_subscribe
+
+        if hasattr(self.wrapped_characteristic, 'unsubscribe'):
             self.unsubscribe = self.wrapped_unsubscribe
 
     def __getattr__(self, name):
@@ -601,13 +475,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)
         )
 
@@ -648,7 +520,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})'
 
@@ -728,10 +600,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')
 
 
@@ -741,25 +613,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
 
@@ -68,7 +56,7 @@ from .att import (
     ATT_Error,
 )
 from . import core
-from .core import UUID, InvalidStateError
+from .core import UUID, InvalidStateError, ProtocolError
 from .gatt import (
     GATT_CHARACTERISTIC_ATTRIBUTE_TYPE,
     GATT_CLIENT_CHARACTERISTIC_CONFIGURATION_DESCRIPTOR,
@@ -78,48 +66,28 @@ from .gatt import (
     GATT_INCLUDE_ATTRIBUTE_TYPE,
     Characteristic,
     ClientCharacteristicConfigurationBits,
-    TemplateService,
 )
 
-if TYPE_CHECKING:
-    from bumble.device import Connection
-
 # -----------------------------------------------------------------------------
 # Logging
 # -----------------------------------------------------------------------------
 logger = logging.getLogger(__name__)
 
 
-# -----------------------------------------------------------------------------
-# Utils
-# -----------------------------------------------------------------------------
-
-
-def show_services(services: Iterable[ServiceProxy]) -> None:
-    for service in services:
-        print(color(str(service), 'cyan'))
-
-        for characteristic in service.characteristics:
-            print(color('  ' + str(characteristic), 'magenta'))
-
-            for descriptor in characteristic.descriptors:
-                print(color('    ' + str(descriptor), 'green'))
-
-
 # -----------------------------------------------------------------------------
 # Proxies
 # -----------------------------------------------------------------------------
 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)
         )
@@ -129,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})'
 
 
@@ -145,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)
@@ -168,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,
@@ -203,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:
@@ -223,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}, '
@@ -241,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})'
 
 
@@ -250,10 +216,8 @@ class ProfileServiceProxy:
     Base class for profile-specific service proxies
     '''
 
-    SERVICE_CLASS: Type[TemplateService]
-
     @classmethod
-    def from_client(cls, client: Client) -> Optional[ProfileServiceProxy]:
+    def from_client(cls, client):
         return ServiceProxy.from_client(cls, client, cls.SERVICE_CLASS.UUID)
 
 
@@ -263,38 +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 = {}
 
-        connection.on('disconnection', self.on_disconnection)
-
-    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}'
         )
@@ -323,19 +279,19 @@ 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 core.InvalidArgumentError(f'MTU must be >= {ATT_DEFAULT_MTU}')
+            raise ValueError(f'MTU must be >= {ATT_DEFAULT_MTU}')
         if mtu > 0xFFFF:
-            raise core.InvalidArgumentError('MTU must be <= 0xFFFF')
+            raise ValueError('MTU must be <= 0xFFFF')
 
         # We can only send one request per connection
         if self.mtu_exchange_done:
@@ -345,19 +301,22 @@ class Client:
         self.mtu_exchange_done = True
         response = await self.send_request(ATT_Exchange_MTU_Request(client_rx_mtu=mtu))
         if response.op_code == ATT_ERROR_RESPONSE:
-            raise ATT_Error(error_code=response.error_code, message=response)
+            raise ProtocolError(
+                response.error_code,
+                'att',
+                ATT_PDU.error_name(response.error_code),
+                response,
+            )
 
         # Compute the final MTU
         self.connection.att_mtu = min(mtu, response.server_rx_mtu)
 
         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
@@ -365,7 +324,9 @@ class Client:
             if c.uuid == uuid
         ]
 
-    def get_attribute_grouping(self, attribute_handle: int) -> Optional[
+    def get_attribute_grouping(
+        self, attribute_handle: int
+    ) -> Optional[
         Union[
             ServiceProxy,
             Tuple[ServiceProxy, CharacteristicProxy],
@@ -402,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
         '''
@@ -474,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
         '''
@@ -507,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:
@@ -519,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(
@@ -696,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
@@ -760,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
         '''
@@ -803,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:
@@ -845,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
@@ -853,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:
@@ -878,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
 
@@ -931,7 +859,12 @@ class Client:
         if response is None:
             raise TimeoutError('read timeout')
         if response.op_code == ATT_ERROR_RESPONSE:
-            raise ATT_Error(error_code=response.error_code, message=response)
+            raise ProtocolError(
+                response.error_code,
+                'att',
+                ATT_PDU.error_name(response.error_code),
+                response,
+            )
 
         # If the value is the max size for the MTU, try to read more unless the caller
         # specifically asked not to do that
@@ -953,7 +886,12 @@ class Client:
                         ATT_INVALID_OFFSET_ERROR,
                     ):
                         break
-                    raise ATT_Error(error_code=response.error_code, message=response)
+                    raise ProtocolError(
+                        response.error_code,
+                        'att',
+                        ATT_PDU.error_name(response.error_code),
+                        response,
+                    )
 
                 part = response.part_attribute_value
                 attribute_value += part
@@ -967,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
         '''
@@ -1024,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
@@ -1046,7 +977,12 @@ class Client:
                 )
             )
             if response.op_code == ATT_ERROR_RESPONSE:
-                raise ATT_Error(error_code=response.error_code, message=response)
+                raise ProtocolError(
+                    response.error_code,
+                    'att',
+                    ATT_PDU.error_name(response.error_code),
+                    response,
+                )
         else:
             await self.send_command(
                 ATT_Write_Command(
@@ -1054,11 +990,7 @@ class Client:
                 )
             )
 
-    def on_disconnection(self, _) -> None:
-        if self.pending_response and not self.pending_response.done():
-            self.pending_response.cancel()
-
-    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}'
         )
@@ -1068,7 +1000,7 @@ class Client:
                 logger.warning('!!! unexpected response, there is no pending request')
                 return
 
-            # The response should match the pending request unless it is
+            # Sanity check: the response should match the pending request unless it is
             # an error response
             if att_pdu.op_code != ATT_ERROR_RESPONSE:
                 expected_response_name = self.pending_request.name.replace(
@@ -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,18 +300,13 @@ 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()}'
         )
 
-        # Check parameters
+        # Sanity check
         if len(value) != 2:
             logger.warning('CCCD value not 2 bytes long')
             return
@@ -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[connection.handle] = (
-                asyncio.get_running_loop().create_future()
-            )
+            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,13 +859,12 @@ 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
         '''
 
-        # Check that the attribute exists
+        # Check  that the attribute exists
         attribute = self.get_attribute(request.attribute_handle)
         if attribute is None:
             self.send_response(
@@ -942,22 +891,13 @@ class Server(EventEmitter):
             )
             return
 
-        try:
-            # Accept the value
-            await attribute.write_value(connection, request.attribute_value)
-        except ATT_Error as error:
-            response = ATT_Error_Response(
-                request_opcode_in_error=request.op_code,
-                attribute_handle_in_error=request.attribute_handle,
-                error_code=error.error_code,
-            )
-        else:
-            # Done
-            response = ATT_Write_Response()
-        self.send_response(connection, response)
+        # Accept the value
+        attribute.write_value(connection, request.attribute_value)
 
-    @AsyncRunner.run_in_task()
-    async def on_att_write_command(self, connection, request):
+        # Done
+        self.send_response(connection, ATT_Write_Response())
+
+    def on_att_write_command(self, connection, request):
         '''
         See Bluetooth spec Vol 3, Part F - 3.4.5.3 Write Command
         '''
@@ -975,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,46 +15,30 @@
 # -----------------------------------------------------------------------------
 # Imports
 # -----------------------------------------------------------------------------
-from __future__ import annotations
-
-from collections.abc import Callable, MutableMapping
-import datetime
-from typing import cast, Any, Optional
 import logging
 
-from bumble import avc
-from bumble import avctp
-from bumble import avdtp
-from bumble import avrcp
-from bumble import crypto
-from bumble import rfcomm
-from bumble import sdp
-from bumble.colors import color
-from bumble.att import ATT_CID, ATT_PDU
-from bumble.smp import SMP_CID, SMP_Command
-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 .rfcomm import RFCOMM_Frame, RFCOMM_PSM
+from .sdp import SDP_PDU, SDP_PSM
+from .avdtp import MessageAssembler as AVDTP_MessageAssembler, AVDTP_PSM
 
 # -----------------------------------------------------------------------------
 # Logging
@@ -64,36 +48,26 @@ logger = logging.getLogger(__name__)
 
 # -----------------------------------------------------------------------------
 PSM_NAMES = {
-    rfcomm.RFCOMM_PSM: 'RFCOMM',
-    sdp.SDP_PSM: 'SDP',
-    avdtp.AVDTP_PSM: 'AVDTP',
-    avctp.AVCTP_PSM: 'AVCTP',
+    RFCOMM_PSM: 'RFCOMM',
+    SDP_PSM: 'SDP',
+    AVDTP_PSM: 'AVDTP'
     # TODO: add more PSM values
 }
 
-AVCTP_PID_NAMES = {avrcp.AVRCP_PID: 'AVRCP'}
-
 
 # -----------------------------------------------------------------------------
 class PacketTracer:
     class AclStream:
-        psms: MutableMapping[int, int]
-        peer: Optional[PacketTracer.AclStream]
-        avdtp_assemblers: MutableMapping[int, avdtp.MessageAssembler]
-        avctp_assemblers: MutableMapping[int, avctp.MessageAssembler]
-
-        def __init__(self, analyzer: PacketTracer.Analyzer) -> None:
+        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.avctp_assemblers = {}  # AVCTP assemblers, by source_cid
             self.psms = {}  # PSM, by source_cid
-            self.peer = None
+            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)
-            self.analyzer.emit(l2cap_pdu)
 
             if l2cap_pdu.cid == ATT_CID:
                 att_pdu = ATT_PDU.from_bytes(l2cap_pdu.payload)
@@ -107,59 +81,46 @@ 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 and (
-                            psm := self.peer.psms.get(connection_response.source_cid)
-                        ):
-                            # Found a pending connection
-                            self.psms[connection_response.destination_cid] = psm
+                        if self.peer:
+                            if psm := self.peer.psms.get(control_frame.source_cid):
+                                # Found a pending connection
+                                self.psms[control_frame.destination_cid] = psm
+
+                                # For AVDTP connections, create a packet assembler for
+                                # each direction
+                                if psm == AVDTP_PSM:
+                                    self.avdtp_assemblers[
+                                        control_frame.source_cid
+                                    ] = AVDTP_MessageAssembler(self.on_avdtp_message)
+                                    self.peer.avdtp_assemblers[
+                                        control_frame.destination_cid
+                                    ] = AVDTP_MessageAssembler(
+                                        self.peer.on_avdtp_message
+                                    )
 
-                            # For AVDTP connections, create a packet assembler for
-                            # each direction
-                            if psm == avdtp.AVDTP_PSM:
-                                self.avdtp_assemblers[
-                                    connection_response.source_cid
-                                ] = avdtp.MessageAssembler(self.on_avdtp_message)
-                                self.peer.avdtp_assemblers[
-                                    connection_response.destination_cid
-                                ] = avdtp.MessageAssembler(self.peer.on_avdtp_message)
-                            elif psm == avctp.AVCTP_PSM:
-                                self.avctp_assemblers[
-                                    connection_response.source_cid
-                                ] = avctp.MessageAssembler(self.on_avctp_message)
-                                self.peer.avctp_assemblers[
-                                    connection_response.destination_cid
-                                ] = avctp.MessageAssembler(self.peer.on_avctp_message)
             else:
                 # Try to find the PSM associated with this PDU
                 if self.peer and (psm := self.peer.psms.get(l2cap_pdu.cid)):
-                    if psm == sdp.SDP_PSM:
-                        sdp_pdu = sdp.SDP_PDU.from_bytes(l2cap_pdu.payload)
+                    if psm == SDP_PSM:
+                        sdp_pdu = SDP_PDU.from_bytes(l2cap_pdu.payload)
                         self.analyzer.emit(sdp_pdu)
-                    elif psm == rfcomm.RFCOMM_PSM:
-                        rfcomm_frame = rfcomm.RFCOMM_Frame.from_bytes(l2cap_pdu.payload)
+                    elif psm == RFCOMM_PSM:
+                        rfcomm_frame = RFCOMM_Frame.from_bytes(l2cap_pdu.payload)
                         self.analyzer.emit(rfcomm_frame)
-                    elif psm == avdtp.AVDTP_PSM:
+                    elif psm == AVDTP_PSM:
                         self.analyzer.emit(
                             f'{color("L2CAP", "green")} [CID={l2cap_pdu.cid}, '
                             f'PSM=AVDTP]: {l2cap_pdu.payload.hex()}'
                         )
-                        if avdtp_assembler := self.avdtp_assemblers.get(l2cap_pdu.cid):
-                            avdtp_assembler.on_pdu(l2cap_pdu.payload)
-                    elif psm == avctp.AVCTP_PSM:
-                        self.analyzer.emit(
-                            f'{color("L2CAP", "green")} [CID={l2cap_pdu.cid}, '
-                            f'PSM=AVCTP]: {l2cap_pdu.payload.hex()}'
-                        )
-                        if avctp_assembler := self.avctp_assemblers.get(l2cap_pdu.cid):
-                            avctp_assembler.on_pdu(l2cap_pdu.payload)
+                        assembler = self.avdtp_assemblers.get(l2cap_pdu.cid)
+                        if assembler:
+                            assembler.on_pdu(l2cap_pdu.payload)
                     else:
                         psm_string = name_or_number(PSM_NAMES, psm)
                         self.analyzer.emit(
@@ -169,49 +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 on_avctp_message(
-            self,
-            transaction_label: int,
-            is_command: bool,
-            ipid: bool,
-            pid: int,
-            payload: bytes,
-        ):
-            if pid == avrcp.AVRCP_PID:
-                avc_frame = avc.Frame.from_bytes(payload)
-                details = str(avc_frame)
-            else:
-                details = payload.hex()
-
-            c_r = 'Command' if is_command else 'Response'
-            self.analyzer.emit(
-                f'{color("AVCTP", "green")} '
-                f'{c_r}[{transaction_label}][{name_or_number(AVCTP_PID_NAMES, pid)}] '
-                f'{"#" if ipid else ""}'
-                f'{details}'
-            )
-
-        def feed_packet(self, packet: HCI_AclDataPacket) -> None:
+        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.packet_timestamp: Optional[datetime.datetime] = None
+            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}'
@@ -226,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 '
@@ -237,52 +171,34 @@ class PacketTracer:
                 # Let the other forwarder know so it can cleanup its stream as well
                 self.peer.end_acl_stream(connection_handle)
 
-        def on_packet(
-            self, timestamp: Optional[datetime.datetime], packet: HCI_Packet
-        ) -> None:
-            self.packet_timestamp = timestamp
+        def on_packet(self, packet):
             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:
-            if self.packet_timestamp:
-                prefix = f"[{self.packet_timestamp.strftime('%Y-%m-%d %H:%M:%S.%f')}]"
-            else:
-                prefix = ""
-            self.emit_message(f'{prefix}[{self.label}] {message}')
+        def emit(self, message):
+            self.emit_message(f'[{self.label}] {message}')
 
-    def trace(
-        self,
-        packet: HCI_Packet,
-        direction: int = 0,
-        timestamp: Optional[datetime.datetime] = None,
-    ) -> None:
+    def trace(self, packet, direction=0):
         if direction == 0:
-            self.host_to_controller_analyzer.on_packet(timestamp, packet)
+            self.host_to_controller_analyzer.on_packet(packet)
         else:
-            self.controller_to_host_analyzer.on_packet(timestamp, packet)
+            self.controller_to_host_analyzer.on_packet(packet)
 
     def __init__(
         self,
-        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
         )
@@ -291,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/hid.py

@@ -1,551 +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
-from typing_extensions import override
-
-from bumble import l2cap, device
-from bumble.core import InvalidStateError, ProtocolError
-from bumble.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:
-            channel = await self.device.l2cap_channel_manager.connect(
-                self.connection, HID_CONTROL_PSM
-            )
-            channel.sink = self.on_ctrl_pdu
-            self.l2cap_ctrl_channel = channel
-        except ProtocolError:
-            logging.exception(f'L2CAP connection failed.')
-            raise
-
-    async def connect_interrupt_channel(self) -> None:
-        # Create a new L2CAP connection - interrupt channel
-        try:
-            channel = await self.device.l2cap_channel_manager.connect(
-                self.connection, HID_INTERRUPT_PSM
-            )
-            channel.sink = self.on_intr_pdu
-            self.l2cap_intr_channel = channel
-        except ProtocolError:
-            logging.exception(f'L2CAP connection failed.')
-            raise
-
-    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
-
-    @dataclass
-    class GetSetStatus:
-        data: bytes = b''
-        status: int = 0
-
-    get_report_cb: Optional[Callable[[int, int, int], GetSetStatus]] = None
-    set_report_cb: Optional[Callable[[int, int, int, bytes], GetSetStatus]] = None
-    get_protocol_cb: Optional[Callable[[], GetSetStatus]] = None
-    set_protocol_cb: Optional[Callable[[int], GetSetStatus]] = None
-
-    def __init__(self, device: device.Device) -> None:
-        super().__init__(device, HID.Role.DEVICE)
-
-    @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)
-        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.peer_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], Device.GetSetStatus]
-    ) -> 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)
-        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], Device.GetSetStatus]
-    ) -> 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()
-        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[[], Device.GetSetStatus]) -> 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)
-        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], Device.GetSetStatus]
-    ) -> 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/keys.py

@@ -25,8 +25,7 @@ import asyncio
 import logging
 import os
 import json
-from typing import TYPE_CHECKING, Dict, List, Optional, Tuple, Type
-from typing_extensions import Self
+from typing import TYPE_CHECKING, Dict, List, Optional, Tuple
 
 from .colors import color
 from .hci import Address
@@ -129,10 +128,10 @@ class PairingKeys:
 
     def print(self, prefix=''):
         keys_dict = self.to_dict()
-        for container_property, value in keys_dict.items():
+        for (container_property, value) in keys_dict.items():
             if isinstance(value, dict):
                 print(f'{prefix}{color(container_property, "cyan")}:')
-                for key_property, key_value in value.items():
+                for (key_property, key_value) in value.items():
                     print(f'{prefix}  {color(key_property, "green")}: {key_value}')
             else:
                 print(f'{prefix}{color(container_property, "cyan")}: {value}')
@@ -159,7 +158,7 @@ class KeyStore:
     async def get_resolving_keys(self):
         all_keys = await self.get_all()
         resolving_keys = []
-        for name, keys in all_keys:
+        for (name, keys) in all_keys:
             if keys.irk is not None:
                 if keys.address_type is None:
                     address_type = Address.RANDOM_DEVICE_ADDRESS
@@ -172,7 +171,7 @@ class KeyStore:
     async def print(self, prefix=''):
         entries = await self.get_all()
         separator = ''
-        for name, keys in entries:
+        for (name, keys) in entries:
             print(separator + prefix + color(name, 'yellow'))
             keys.print(prefix=prefix + '  ')
             separator = '\n'
@@ -254,10 +253,8 @@ class JsonKeyStore(KeyStore):
 
         logger.debug(f'JSON keystore: {self.filename}')
 
-    @classmethod
-    def from_device(
-        cls: Type[Self], device: Device, filename: Optional[str] = None
-    ) -> Self:
+    @staticmethod
+    def from_device(device: Device, filename=None) -> Optional[JsonKeyStore]:
         if not filename:
             # Extract the filename from the config if there is one
             if device.config.keystore is not None:
@@ -273,7 +270,7 @@ class JsonKeyStore(KeyStore):
         else:
             namespace = JsonKeyStore.DEFAULT_NAMESPACE
 
-        return cls(namespace, filename)
+        return JsonKeyStore(namespace, filename)
 
     async def load(self):
         # Try to open the file, without failing. If the file does not exist, it

bumble/link.py

@@ -19,25 +19,16 @@ import logging
 import asyncio
 from functools import partial
 
-from bumble.core import (
-    BT_PERIPHERAL_ROLE,
-    BT_BR_EDR_TRANSPORT,
-    BT_LE_TRANSPORT,
-    InvalidStateError,
-)
+from bumble.core import BT_PERIPHERAL_ROLE, BT_BR_EDR_TRANSPORT, BT_LE_TRANSPORT
 from bumble.colors import color
 from bumble.hci import (
     Address,
     HCI_SUCCESS,
     HCI_CONNECTION_ACCEPT_TIMEOUT_ERROR,
     HCI_CONNECTION_TIMEOUT_ERROR,
-    HCI_UNKNOWN_CONNECTION_IDENTIFIER_ERROR,
     HCI_PAGE_TIMEOUT_ERROR,
     HCI_Connection_Complete_Event,
 )
-from bumble import controller
-
-from typing import Optional, Set
 
 # -----------------------------------------------------------------------------
 # Logging
@@ -66,8 +57,6 @@ class LocalLink:
     Link bus for controllers to communicate with each other
     '''
 
-    controllers: Set[controller.Controller]
-
     def __init__(self):
         self.controllers = set()
         self.pending_connection = None
@@ -90,9 +79,7 @@ class LocalLink:
                 return controller
         return None
 
-    def find_classic_controller(
-        self, address: Address
-    ) -> Optional[controller.Controller]:
+    def find_classic_controller(self, address):
         for controller in self.controllers:
             if controller.public_address == address:
                 return controller
@@ -201,60 +188,6 @@ class LocalLink:
         if peripheral_controller := self.find_controller(peripheral_address):
             peripheral_controller.on_link_encrypted(central_address, rand, ediv, ltk)
 
-    def create_cis(
-        self,
-        central_controller: controller.Controller,
-        peripheral_address: Address,
-        cig_id: int,
-        cis_id: int,
-    ) -> None:
-        logger.debug(
-            f'$$$ CIS Request {central_controller.random_address} -> {peripheral_address}'
-        )
-        if peripheral_controller := self.find_controller(peripheral_address):
-            asyncio.get_running_loop().call_soon(
-                peripheral_controller.on_link_cis_request,
-                central_controller.random_address,
-                cig_id,
-                cis_id,
-            )
-
-    def accept_cis(
-        self,
-        peripheral_controller: controller.Controller,
-        central_address: Address,
-        cig_id: int,
-        cis_id: int,
-    ) -> None:
-        logger.debug(
-            f'$$$ CIS Accept {peripheral_controller.random_address} -> {central_address}'
-        )
-        if central_controller := self.find_controller(central_address):
-            asyncio.get_running_loop().call_soon(
-                central_controller.on_link_cis_established, cig_id, cis_id
-            )
-            asyncio.get_running_loop().call_soon(
-                peripheral_controller.on_link_cis_established, cig_id, cis_id
-            )
-
-    def disconnect_cis(
-        self,
-        initiator_controller: controller.Controller,
-        peer_address: Address,
-        cig_id: int,
-        cis_id: int,
-    ) -> None:
-        logger.debug(
-            f'$$$ CIS Disconnect {initiator_controller.random_address} -> {peer_address}'
-        )
-        if peer_controller := self.find_controller(peer_address):
-            asyncio.get_running_loop().call_soon(
-                initiator_controller.on_link_cis_disconnected, cig_id, cis_id
-            )
-            asyncio.get_running_loop().call_soon(
-                peer_controller.on_link_cis_disconnected, cig_id, cis_id
-            )
-
     ############################################################
     # Classic handlers
     ############################################################
@@ -338,52 +271,6 @@ class LocalLink:
             initiator_controller.public_address, int(not (initiator_new_role))
         )
 
-    def classic_sco_connect(
-        self,
-        initiator_controller: controller.Controller,
-        responder_address: Address,
-        link_type: int,
-    ):
-        logger.debug(
-            f'[Classic] {initiator_controller.public_address} connects SCO to {responder_address}'
-        )
-        responder_controller = self.find_classic_controller(responder_address)
-        # Initiator controller should handle it.
-        assert responder_controller
-
-        responder_controller.on_classic_connection_request(
-            initiator_controller.public_address,
-            link_type,
-        )
-
-    def classic_accept_sco_connection(
-        self,
-        responder_controller: controller.Controller,
-        initiator_address: Address,
-        link_type: int,
-    ):
-        logger.debug(
-            f'[Classic] {responder_controller.public_address} accepts to connect SCO {initiator_address}'
-        )
-        initiator_controller = self.find_classic_controller(initiator_address)
-        if initiator_controller is None:
-            responder_controller.on_classic_sco_connection_complete(
-                responder_controller.public_address,
-                HCI_UNKNOWN_CONNECTION_IDENTIFIER_ERROR,
-                link_type,
-            )
-            return
-
-        async def task():
-            initiator_controller.on_classic_sco_connection_complete(
-                responder_controller.public_address, HCI_SUCCESS, link_type
-            )
-
-        asyncio.create_task(task())
-        responder_controller.on_classic_sco_connection_complete(
-            initiator_controller.public_address, HCI_SUCCESS, link_type
-        )
-
 
 # -----------------------------------------------------------------------------
 class RemoteLink:
@@ -410,12 +297,12 @@ class RemoteLink:
 
     def add_controller(self, controller):
         if self.controller:
-            raise InvalidStateError('controller already set')
+            raise ValueError('controller already set')
         self.controller = controller
 
     def remove_controller(self, controller):
         if self.controller != controller:
-            raise InvalidStateError('controller mismatch')
+            raise ValueError('controller mismatch')
         self.controller = None
 
     def get_pending_connection(self):

bumble/pairing.py

@@ -15,9 +15,7 @@
 # -----------------------------------------------------------------------------
 # Imports
 # -----------------------------------------------------------------------------
-from __future__ import annotations
 import enum
-from dataclasses import dataclass
 from typing import Optional, Tuple
 
 from .hci import (
@@ -37,60 +35,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)
 
 
 # -----------------------------------------------------------------------------
@@ -228,14 +173,6 @@ class PairingConfig:
         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,
@@ -243,20 +180,17 @@ class PairingConfig:
         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/__init__.py

@@ -25,10 +25,8 @@ import grpc.aio
 from .config import Config
 from .device import PandoraDevice
 from .host import HostService
-from .l2cap import L2CAPService
 from .security import SecurityService, SecurityStorageService
 from pandora.host_grpc_aio import add_HostServicer_to_server
-from pandora.l2cap_grpc_aio import add_L2CAPServicer_to_server
 from pandora.security_grpc_aio import (
     add_SecurityServicer_to_server,
     add_SecurityStorageServicer_to_server,
@@ -79,7 +77,6 @@ async def serve(
             add_SecurityStorageServicer_to_server(
                 SecurityStorageService(bumble.device, config), server
             )
-            add_L2CAPServicer_to_server(L2CAPService(bumble.device, config), server)
 
             # call hooks if any.
             for hook in _SERVICERS_HOOKS:

bumble/pandora/config.py

@@ -12,7 +12,6 @@
 # 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 dataclasses import dataclass
 from typing import Any, Dict

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,

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
@@ -28,18 +27,14 @@ from bumble.core import (
     BT_PERIPHERAL_ROLE,
     UUID,
     AdvertisingData,
-    Appearance,
     ConnectionError,
 )
 from bumble.device import (
     DEVICE_DEFAULT_SCAN_INTERVAL,
     DEVICE_DEFAULT_SCAN_WINDOW,
     Advertisement,
-    AdvertisingParameters,
-    AdvertisingEventProperties,
     AdvertisingType,
     Device,
-    Phy,
 )
 from bumble.gatt import Service
 from bumble.hci import (
@@ -51,12 +46,9 @@ from bumble.hci import (
 from google.protobuf import any_pb2  # pytype: disable=pyi-error
 from google.protobuf import empty_pb2  # pytype: disable=pyi-error
 from pandora.host_grpc_aio import HostServicer
-from pandora import host_pb2
 from pandora.host_pb2 import (
     NOT_CONNECTABLE,
     NOT_DISCOVERABLE,
-    DISCOVERABLE_LIMITED,
-    DISCOVERABLE_GENERAL,
     PRIMARY_1M,
     PRIMARY_CODED,
     SECONDARY_1M,
@@ -72,7 +64,6 @@ from pandora.host_pb2 import (
     ConnectResponse,
     DataTypes,
     DisconnectRequest,
-    DiscoverabilityMode,
     InquiryResponse,
     PrimaryPhy,
     ReadLocalAddressResponse,
@@ -102,25 +93,6 @@ SECONDARY_PHY_MAP: Dict[int, SecondaryPhy] = {
     3: SECONDARY_CODED,
 }
 
-PRIMARY_PHY_TO_BUMBLE_PHY_MAP: Dict[PrimaryPhy, Phy] = {
-    PRIMARY_1M: Phy.LE_1M,
-    PRIMARY_CODED: Phy.LE_CODED,
-}
-
-SECONDARY_PHY_TO_BUMBLE_PHY_MAP: Dict[SecondaryPhy, Phy] = {
-    SECONDARY_NONE: Phy.LE_1M,
-    SECONDARY_1M: Phy.LE_1M,
-    SECONDARY_2M: Phy.LE_2M,
-    SECONDARY_CODED: Phy.LE_CODED,
-}
-
-OWN_ADDRESS_MAP: Dict[host_pb2.OwnAddressType, bumble.hci.OwnAddressType] = {
-    host_pb2.PUBLIC: bumble.hci.OwnAddressType.PUBLIC,
-    host_pb2.RANDOM: bumble.hci.OwnAddressType.RANDOM,
-    host_pb2.RESOLVABLE_OR_PUBLIC: bumble.hci.OwnAddressType.RESOLVABLE_OR_PUBLIC,
-    host_pb2.RESOLVABLE_OR_RANDOM: bumble.hci.OwnAddressType.RESOLVABLE_OR_RANDOM,
-}
-
 
 class HostService(HostServicer):
     waited_connections: Set[int]
@@ -288,9 +260,9 @@ class HostService(HostServicer):
         self.log.debug(f"WaitDisconnection: {connection_handle}")
 
         if connection := self.device.lookup_connection(connection_handle):
-            disconnection_future: asyncio.Future[None] = (
-                asyncio.get_running_loop().create_future()
-            )
+            disconnection_future: asyncio.Future[
+                None
+            ] = asyncio.get_running_loop().create_future()
 
             def on_disconnection(_: None) -> None:
                 disconnection_future.set_result(None)
@@ -308,118 +280,14 @@ class HostService(HostServicer):
     async def Advertise(
         self, request: AdvertiseRequest, context: grpc.ServicerContext
     ) -> AsyncGenerator[AdvertiseResponse, None]:
-        try:
-            if request.legacy:
-                async for rsp in self.legacy_advertise(request, context):
-                    yield rsp
-            else:
-                async for rsp in self.extended_advertise(request, context):
-                    yield rsp
-        finally:
-            pass
-
-    async def extended_advertise(
-        self, request: AdvertiseRequest, context: grpc.ServicerContext
-    ) -> AsyncGenerator[AdvertiseResponse, None]:
-        advertising_data = bytes(self.unpack_data_types(request.data))
-        scan_response_data = bytes(self.unpack_data_types(request.scan_response_data))
-        scannable = len(scan_response_data) != 0
-
-        advertising_event_properties = AdvertisingEventProperties(
-            is_connectable=request.connectable,
-            is_scannable=scannable,
-            is_directed=request.target is not None,
-            is_high_duty_cycle_directed_connectable=False,
-            is_legacy=False,
-            is_anonymous=False,
-            include_tx_power=False,
-        )
-
-        peer_address = Address.ANY
-        if request.target:
-            # Need to reverse bytes order since Bumble Address is using MSB.
-            target_bytes = bytes(reversed(request.target))
-            if request.target_variant() == "public":
-                peer_address = Address(target_bytes, Address.PUBLIC_DEVICE_ADDRESS)
-            else:
-                peer_address = Address(target_bytes, Address.RANDOM_DEVICE_ADDRESS)
-
-        advertising_parameters = AdvertisingParameters(
-            advertising_event_properties=advertising_event_properties,
-            own_address_type=OWN_ADDRESS_MAP[request.own_address_type],
-            peer_address=peer_address,
-            primary_advertising_phy=PRIMARY_PHY_TO_BUMBLE_PHY_MAP[request.primary_phy],
-            secondary_advertising_phy=SECONDARY_PHY_TO_BUMBLE_PHY_MAP[
-                request.secondary_phy
-            ],
-        )
-        if advertising_interval := request.interval:
-            advertising_parameters.primary_advertising_interval_min = int(
-                advertising_interval
+        if not request.legacy:
+            raise NotImplementedError(
+                "TODO: add support for extended advertising in Bumble"
             )
-            advertising_parameters.primary_advertising_interval_max = int(
-                advertising_interval
-            )
-        if interval_range := request.interval_range:
-            advertising_parameters.primary_advertising_interval_max += int(
-                interval_range
-            )
-
-        advertising_set = await self.device.create_advertising_set(
-            advertising_parameters=advertising_parameters,
-            advertising_data=advertising_data,
-            scan_response_data=scan_response_data,
-        )
-
-        pending_connection: asyncio.Future[bumble.device.Connection] = (
-            asyncio.get_running_loop().create_future()
-        )
-
-        if request.connectable:
-
-            def on_connection(connection: bumble.device.Connection) -> None:
-                if (
-                    connection.transport == BT_LE_TRANSPORT
-                    and connection.role == BT_PERIPHERAL_ROLE
-                ):
-                    pending_connection.set_result(connection)
-
-            self.device.on('connection', on_connection)
-
-        try:
-            # Advertise until RPC is canceled
-            while True:
-                if not advertising_set.enabled:
-                    self.log.debug('Advertise (extended)')
-                    await advertising_set.start()
-
-                if not request.connectable:
-                    await asyncio.sleep(1)
-                    continue
-
-                connection = await pending_connection
-                pending_connection = asyncio.get_running_loop().create_future()
-
-                cookie = any_pb2.Any(value=connection.handle.to_bytes(4, 'big'))
-                yield AdvertiseResponse(connection=Connection(cookie=cookie))
-
-                await asyncio.sleep(1)
-        finally:
-            try:
-                self.log.debug('Stop Advertise (extended)')
-                await advertising_set.stop()
-                await advertising_set.remove()
-            except Exception:
-                pass
-
-    async def legacy_advertise(
-        self, request: AdvertiseRequest, context: grpc.ServicerContext
-    ) -> AsyncGenerator[AdvertiseResponse, None]:
-        if advertising_interval := request.interval:
-            self.device.config.advertising_interval_min = int(advertising_interval)
-            self.device.config.advertising_interval_max = int(advertising_interval)
-        if interval_range := request.interval_range:
-            self.device.config.advertising_interval_max += int(interval_range)
+        if request.interval:
+            raise NotImplementedError("TODO: add support for `request.interval`")
+        if request.interval_range:
+            raise NotImplementedError("TODO: add support for `request.interval_range`")
         if request.primary_phy:
             raise NotImplementedError("TODO: add support for `request.primary_phy`")
         if request.secondary_phy:
@@ -487,10 +355,14 @@ class HostService(HostServicer):
             target_bytes = bytes(reversed(request.target))
             if request.target_variant() == "public":
                 target = Address(target_bytes, Address.PUBLIC_DEVICE_ADDRESS)
-                advertising_type = AdvertisingType.DIRECTED_CONNECTABLE_LOW_DUTY
+                advertising_type = (
+                    AdvertisingType.DIRECTED_CONNECTABLE_HIGH_DUTY
+                )  # FIXME: HIGH_DUTY ?
             else:
                 target = Address(target_bytes, Address.RANDOM_DEVICE_ADDRESS)
-                advertising_type = AdvertisingType.DIRECTED_CONNECTABLE_LOW_DUTY
+                advertising_type = (
+                    AdvertisingType.DIRECTED_CONNECTABLE_HIGH_DUTY
+                )  # FIXME: HIGH_DUTY ?
 
         if request.connectable:
 
@@ -517,9 +389,9 @@ class HostService(HostServicer):
                     await asyncio.sleep(1)
                     continue
 
-                pending_connection: asyncio.Future[bumble.device.Connection] = (
-                    asyncio.get_running_loop().create_future()
-                )
+                pending_connection: asyncio.Future[
+                    bumble.device.Connection
+                ] = asyncio.get_running_loop().create_future()
 
                 self.log.debug('Wait for LE connection...')
                 connection = await pending_connection
@@ -548,15 +420,10 @@ class HostService(HostServicer):
         self, request: ScanRequest, context: grpc.ServicerContext
     ) -> AsyncGenerator[ScanningResponse, None]:
         # TODO: modify `start_scanning` to accept floats instead of int for ms values
-        self.log.debug('Scan')
+        if request.phys:
+            raise NotImplementedError("TODO: add support for `request.phys`")
 
-        scanning_phys = []
-        if PRIMARY_1M in request.phys:
-            scanning_phys.append(int(Phy.LE_1M))
-        if PRIMARY_CODED in request.phys:
-            scanning_phys.append(int(Phy.LE_CODED))
-        if not scanning_phys:
-            scanning_phys = [int(Phy.LE_1M), int(Phy.LE_CODED)]
+        self.log.debug('Scan')
 
         scan_queue: asyncio.Queue[Advertisement] = asyncio.Queue()
         handler = self.device.on('advertisement', scan_queue.put_nowait)
@@ -564,15 +431,12 @@ class HostService(HostServicer):
             legacy=request.legacy,
             active=not request.passive,
             own_address_type=request.own_address_type,
-            scan_interval=(
-                int(request.interval)
-                if request.interval
-                else DEVICE_DEFAULT_SCAN_INTERVAL
-            ),
-            scan_window=(
-                int(request.window) if request.window else DEVICE_DEFAULT_SCAN_WINDOW
-            ),
-            scanning_phys=scanning_phys,
+            scan_interval=int(request.interval)
+            if request.interval
+            else DEVICE_DEFAULT_SCAN_INTERVAL,
+            scan_window=int(request.window)
+            if request.window
+            else DEVICE_DEFAULT_SCAN_WINDOW,
         )
 
         try:
@@ -785,11 +649,9 @@ class HostService(HostServicer):
                             *struct.pack('<H', dt.peripheral_connection_interval_min),
                             *struct.pack(
                                 '<H',
-                                (
-                                    dt.peripheral_connection_interval_max
-                                    if dt.peripheral_connection_interval_max
-                                    else dt.peripheral_connection_interval_min
-                                ),
+                                dt.peripheral_connection_interval_max
+                                if dt.peripheral_connection_interval_max
+                                else dt.peripheral_connection_interval_min,
                             ),
                         ]
                     ),
@@ -871,16 +733,6 @@ class HostService(HostServicer):
                 )
             )
 
-        flag_map = {
-            NOT_DISCOVERABLE: 0x00,
-            DISCOVERABLE_LIMITED: AdvertisingData.LE_LIMITED_DISCOVERABLE_MODE_FLAG,
-            DISCOVERABLE_GENERAL: AdvertisingData.LE_GENERAL_DISCOVERABLE_MODE_FLAG,
-        }
-
-        if dt.le_discoverability_mode:
-            flags = flag_map[dt.le_discoverability_mode]
-            ad_structures.append((AdvertisingData.FLAGS, flags.to_bytes(1, 'big')))
-
         return AdvertisingData(ad_structures)
 
     def pack_data_types(self, ad: AdvertisingData) -> DataTypes:
@@ -989,8 +841,8 @@ class HostService(HostServicer):
             dt.random_target_addresses.extend(
                 [data[i * 6 :: i * 6 + 6] for i in range(int(len(data) / 6))]
             )
-        if appearance := cast(Appearance, ad.get(AdvertisingData.APPEARANCE)):
-            dt.appearance = int(appearance)
+        if i := cast(int, ad.get(AdvertisingData.APPEARANCE)):
+            dt.appearance = i
         if i := cast(int, ad.get(AdvertisingData.ADVERTISING_INTERVAL)):
             dt.advertising_interval = i
         if s := cast(str, ad.get(AdvertisingData.URI)):

bumble/pandora/l2cap.py

@@ -1,310 +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.
-from __future__ import annotations
-import asyncio
-import grpc
-import json
-import logging
-
-from asyncio import Queue as AsyncQueue, Future
-
-from . import utils
-from .config import Config
-from bumble.core import OutOfResourcesError, InvalidArgumentError
-from bumble.device import Device
-from bumble.l2cap import (
-    ClassicChannel,
-    ClassicChannelServer,
-    ClassicChannelSpec,
-    LeCreditBasedChannel,
-    LeCreditBasedChannelServer,
-    LeCreditBasedChannelSpec,
-)
-from google.protobuf import any_pb2, empty_pb2  # pytype: disable=pyi-error
-from pandora.l2cap_grpc_aio import L2CAPServicer  # pytype: disable=pyi-error
-from pandora.l2cap_pb2 import (  # pytype: disable=pyi-error
-    COMMAND_NOT_UNDERSTOOD,
-    INVALID_CID_IN_REQUEST,
-    Channel as PandoraChannel,
-    ConnectRequest,
-    ConnectResponse,
-    CreditBasedChannelRequest,
-    DisconnectRequest,
-    DisconnectResponse,
-    ReceiveRequest,
-    ReceiveResponse,
-    SendRequest,
-    SendResponse,
-    WaitConnectionRequest,
-    WaitConnectionResponse,
-    WaitDisconnectionRequest,
-    WaitDisconnectionResponse,
-)
-from typing import AsyncGenerator, Dict, Optional, Union
-from dataclasses import dataclass
-
-L2capChannel = Union[ClassicChannel, LeCreditBasedChannel]
-
-
-@dataclass
-class ChannelContext:
-    close_future: Future
-    sdu_queue: AsyncQueue
-
-
-class L2CAPService(L2CAPServicer):
-    def __init__(self, device: Device, config: Config) -> None:
-        self.log = utils.BumbleServerLoggerAdapter(
-            logging.getLogger(), {'service_name': 'L2CAP', 'device': device}
-        )
-        self.device = device
-        self.config = config
-        self.channels: Dict[bytes, ChannelContext] = {}
-
-    def register_event(self, l2cap_channel: L2capChannel) -> ChannelContext:
-        close_future = asyncio.get_running_loop().create_future()
-        sdu_queue: AsyncQueue = AsyncQueue()
-
-        def on_channel_sdu(sdu):
-            sdu_queue.put_nowait(sdu)
-
-        def on_close():
-            close_future.set_result(None)
-
-        l2cap_channel.sink = on_channel_sdu
-        l2cap_channel.on('close', on_close)
-
-        return ChannelContext(close_future, sdu_queue)
-
-    @utils.rpc
-    async def WaitConnection(
-        self, request: WaitConnectionRequest, context: grpc.ServicerContext
-    ) -> WaitConnectionResponse:
-        self.log.debug('WaitConnection')
-        if not request.connection:
-            raise ValueError('A valid connection field must be set')
-
-        # find connection on device based on connection cookie value
-        connection_handle = int.from_bytes(request.connection.cookie.value, 'big')
-        connection = self.device.lookup_connection(connection_handle)
-
-        if not connection:
-            raise ValueError('The connection specified is invalid.')
-
-        oneof = request.WhichOneof('type')
-        self.log.debug(f'WaitConnection channel request type: {oneof}.')
-        channel_type = getattr(request, oneof)
-        spec: Optional[Union[ClassicChannelSpec, LeCreditBasedChannelSpec]] = None
-        l2cap_server: Optional[
-            Union[ClassicChannelServer, LeCreditBasedChannelServer]
-        ] = None
-        if isinstance(channel_type, CreditBasedChannelRequest):
-            spec = LeCreditBasedChannelSpec(
-                psm=channel_type.spsm,
-                max_credits=channel_type.initial_credit,
-                mtu=channel_type.mtu,
-                mps=channel_type.mps,
-            )
-            if channel_type.spsm in self.device.l2cap_channel_manager.le_coc_servers:
-                l2cap_server = self.device.l2cap_channel_manager.le_coc_servers[
-                    channel_type.spsm
-                ]
-        else:
-            spec = ClassicChannelSpec(
-                psm=channel_type.psm,
-                mtu=channel_type.mtu,
-            )
-            if channel_type.psm in self.device.l2cap_channel_manager.servers:
-                l2cap_server = self.device.l2cap_channel_manager.servers[
-                    channel_type.psm
-                ]
-
-        self.log.info(f'Listening for L2CAP connection on PSM {spec.psm}')
-        channel_future: Future[PandoraChannel] = (
-            asyncio.get_running_loop().create_future()
-        )
-
-        def on_l2cap_channel(l2cap_channel: L2capChannel):
-            try:
-                channel_context = self.register_event(l2cap_channel)
-                pandora_channel: PandoraChannel = self.craft_pandora_channel(
-                    connection_handle, l2cap_channel
-                )
-                self.channels[pandora_channel.cookie.value] = channel_context
-                channel_future.set_result(pandora_channel)
-            except Exception as e:
-                self.log.error(f'Failed to set channel future: {e}')
-
-        if l2cap_server is None:
-            l2cap_server = self.device.create_l2cap_server(
-                spec=spec, handler=on_l2cap_channel
-            )
-        else:
-            l2cap_server.on('connection', on_l2cap_channel)
-
-        try:
-            self.log.debug('Waiting for a channel connection.')
-            pandora_channel: PandoraChannel = await channel_future
-
-            return WaitConnectionResponse(channel=pandora_channel)
-        except Exception as e:
-            self.log.warning(f'Exception: {e}')
-
-        return WaitConnectionResponse(error=COMMAND_NOT_UNDERSTOOD)
-
-    @utils.rpc
-    async def WaitDisconnection(
-        self, request: WaitDisconnectionRequest, context: grpc.ServicerContext
-    ) -> WaitDisconnectionResponse:
-        try:
-            self.log.debug('WaitDisconnection')
-
-            await self.lookup_context(request.channel).close_future
-            self.log.debug("return WaitDisconnectionResponse")
-            return WaitDisconnectionResponse(success=empty_pb2.Empty())
-        except KeyError as e:
-            self.log.warning(f'WaitDisconnection: Unable to find the channel: {e}')
-            return WaitDisconnectionResponse(error=INVALID_CID_IN_REQUEST)
-        except Exception as e:
-            self.log.exception(f'WaitDisonnection failed: {e}')
-            return WaitDisconnectionResponse(error=COMMAND_NOT_UNDERSTOOD)
-
-    @utils.rpc
-    async def Receive(
-        self, request: ReceiveRequest, context: grpc.ServicerContext
-    ) -> AsyncGenerator[ReceiveResponse, None]:
-        self.log.debug('Receive')
-        oneof = request.WhichOneof('source')
-        self.log.debug(f'Source: {oneof}.')
-        pandora_channel = getattr(request, oneof)
-
-        sdu_queue = self.lookup_context(pandora_channel).sdu_queue
-
-        while sdu := await sdu_queue.get():
-            self.log.debug(f'Receive: Received {len(sdu)} bytes -> {sdu.decode()}')
-            response = ReceiveResponse(data=sdu)
-            yield response
-
-    @utils.rpc
-    async def Connect(
-        self, request: ConnectRequest, context: grpc.ServicerContext
-    ) -> ConnectResponse:
-        self.log.debug('Connect')
-
-        if not request.connection:
-            raise ValueError('A valid connection field must be set')
-
-        # find connection on device based on connection cookie value
-        connection_handle = int.from_bytes(request.connection.cookie.value, 'big')
-        connection = self.device.lookup_connection(connection_handle)
-
-        if not connection:
-            raise ValueError('The connection specified is invalid.')
-
-        oneof = request.WhichOneof('type')
-        self.log.debug(f'Channel request type: {oneof}.')
-        channel_type = getattr(request, oneof)
-        spec: Optional[Union[ClassicChannelSpec, LeCreditBasedChannelSpec]] = None
-        if isinstance(channel_type, CreditBasedChannelRequest):
-            spec = LeCreditBasedChannelSpec(
-                psm=channel_type.spsm,
-                max_credits=channel_type.initial_credit,
-                mtu=channel_type.mtu,
-                mps=channel_type.mps,
-            )
-        else:
-            spec = ClassicChannelSpec(
-                psm=channel_type.psm,
-                mtu=channel_type.mtu,
-            )
-
-        try:
-            self.log.info(f'Opening L2CAP channel on PSM = {spec.psm}')
-            l2cap_channel = await connection.create_l2cap_channel(spec=spec)
-            channel_context = self.register_event(l2cap_channel)
-            pandora_channel = self.craft_pandora_channel(
-                connection_handle, l2cap_channel
-            )
-            self.channels[pandora_channel.cookie.value] = channel_context
-
-            return ConnectResponse(channel=pandora_channel)
-
-        except OutOfResourcesError as e:
-            self.log.error(e)
-            return ConnectResponse(error=INVALID_CID_IN_REQUEST)
-        except InvalidArgumentError as e:
-            self.log.error(e)
-            return ConnectResponse(error=COMMAND_NOT_UNDERSTOOD)
-
-    @utils.rpc
-    async def Disconnect(
-        self, request: DisconnectRequest, context: grpc.ServicerContext
-    ) -> DisconnectResponse:
-        try:
-            self.log.debug('Disconnect')
-            l2cap_channel = self.lookup_channel(request.channel)
-            if not l2cap_channel:
-                self.log.warning('Disconnect: Unable to find the channel')
-                return DisconnectResponse(error=INVALID_CID_IN_REQUEST)
-
-            await l2cap_channel.disconnect()
-            return DisconnectResponse(success=empty_pb2.Empty())
-        except Exception as e:
-            self.log.exception(f'Disonnect failed: {e}')
-            return DisconnectResponse(error=COMMAND_NOT_UNDERSTOOD)
-
-    @utils.rpc
-    async def Send(
-        self, request: SendRequest, context: grpc.ServicerContext
-    ) -> SendResponse:
-        self.log.debug('Send')
-        try:
-            oneof = request.WhichOneof('sink')
-            self.log.debug(f'Sink: {oneof}.')
-            pandora_channel = getattr(request, oneof)
-
-            l2cap_channel = self.lookup_channel(pandora_channel)
-            if not l2cap_channel:
-                return SendResponse(error=COMMAND_NOT_UNDERSTOOD)
-            if isinstance(l2cap_channel, ClassicChannel):
-                l2cap_channel.send_pdu(request.data)
-            else:
-                l2cap_channel.write(request.data)
-            return SendResponse(success=empty_pb2.Empty())
-        except Exception as e:
-            self.log.exception(f'Disonnect failed: {e}')
-            return SendResponse(error=COMMAND_NOT_UNDERSTOOD)
-
-    def craft_pandora_channel(
-        self,
-        connection_handle: int,
-        l2cap_channel: L2capChannel,
-    ) -> PandoraChannel:
-        parameters = {
-            "connection_handle": connection_handle,
-            "source_cid": l2cap_channel.source_cid,
-        }
-        cookie = any_pb2.Any()
-        cookie.value = json.dumps(parameters).encode()
-        return PandoraChannel(cookie=cookie)
-
-    def lookup_channel(self, pandora_channel: PandoraChannel) -> L2capChannel:
-        (connection_handle, source_cid) = json.loads(
-            pandora_channel.cookie.value
-        ).values()
-
-        return self.device.l2cap_channel_manager.channels[connection_handle][source_cid]
-
-    def lookup_context(self, pandora_channel: PandoraChannel) -> ChannelContext:
-        return self.channels[pandora_channel.cookie.value]

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
@@ -110,7 +108,7 @@ class PairingDelegate(BasePairingDelegate):
 
         event = self.add_origin(PairingEvent(just_works=empty_pb2.Empty()))
         self.service.event_queue.put_nowait(event)
-        answer = await anext(self.service.event_answer)  # type: ignore
+        answer = await anext(self.service.event_answer)  # pytype: disable=name-error
         assert answer.event == event
         assert answer.answer_variant() == 'confirm' and answer.confirm is not None
         return answer.confirm
@@ -125,7 +123,7 @@ class PairingDelegate(BasePairingDelegate):
 
         event = self.add_origin(PairingEvent(numeric_comparison=number))
         self.service.event_queue.put_nowait(event)
-        answer = await anext(self.service.event_answer)  # type: ignore
+        answer = await anext(self.service.event_answer)  # pytype: disable=name-error
         assert answer.event == event
         assert answer.answer_variant() == 'confirm' and answer.confirm is not None
         return answer.confirm
@@ -140,7 +138,7 @@ class PairingDelegate(BasePairingDelegate):
 
         event = self.add_origin(PairingEvent(passkey_entry_request=empty_pb2.Empty()))
         self.service.event_queue.put_nowait(event)
-        answer = await anext(self.service.event_answer)  # type: ignore
+        answer = await anext(self.service.event_answer)  # pytype: disable=name-error
         assert answer.event == event
         if answer.answer_variant() is None:
             return None
@@ -157,7 +155,7 @@ class PairingDelegate(BasePairingDelegate):
 
         event = self.add_origin(PairingEvent(pin_code_request=empty_pb2.Empty()))
         self.service.event_queue.put_nowait(event)
-        answer = await anext(self.service.event_answer)  # type: ignore
+        answer = await anext(self.service.event_answer)  # pytype: disable=name-error
         assert answer.event == event
         if answer.answer_variant() is None:
             return None
@@ -234,11 +232,7 @@ 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
-                ),
+                identity_address_type=config.identity_address_type,
                 delegate=PairingDelegate(
                     connection,
                     self,
@@ -300,35 +294,23 @@ class SecurityService(SecurityServicer):
             try:
                 self.log.debug('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.debug('Paired')
             except asyncio.CancelledError:
                 self.log.warning("Connection died during encryption")
                 return SecureResponse(connection_died=empty_pb2.Empty())
@@ -383,11 +365,10 @@ class SecurityService(SecurityServicer):
             connection.transport
         ] == request.level_variant()
 
-        wait_for_security: asyncio.Future[str] = (
-            asyncio.get_running_loop().create_future()
-        )
+        wait_for_security: asyncio.Future[
+            str
+        ] = asyncio.get_running_loop().create_future()
         authenticate_task: Optional[asyncio.Future[None]] = None
-        pair_task: Optional[asyncio.Future[None]] = None
 
         async def authenticate() -> None:
             assert connection
@@ -434,10 +415,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'),
@@ -448,21 +425,23 @@ class SecurityService(SecurityServicer):
             '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.debug('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:
@@ -473,15 +452,6 @@ class SecurityService(SecurityServicer):
                 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')
-
         return WaitSecurityResponse(**kwargs)
 
     def reached_security_level(
@@ -553,7 +523,7 @@ class SecurityStorageService(SecurityStorageServicer):
         self.log.debug(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/aics.py

@@ -1,520 +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.
-
-"""LE Audio - Audio Input Control Service"""
-
-# -----------------------------------------------------------------------------
-# Imports
-# -----------------------------------------------------------------------------
-import logging
-import struct
-
-from dataclasses import dataclass
-from typing import Optional
-
-from bumble import gatt
-from bumble.device import Connection
-from bumble.att import ATT_Error
-from bumble.gatt import (
-    Characteristic,
-    DelegatedCharacteristicAdapter,
-    TemplateService,
-    CharacteristicValue,
-    PackedCharacteristicAdapter,
-    GATT_AUDIO_INPUT_CONTROL_SERVICE,
-    GATT_AUDIO_INPUT_STATE_CHARACTERISTIC,
-    GATT_GAIN_SETTINGS_ATTRIBUTE_CHARACTERISTIC,
-    GATT_AUDIO_INPUT_TYPE_CHARACTERISTIC,
-    GATT_AUDIO_INPUT_STATUS_CHARACTERISTIC,
-    GATT_AUDIO_INPUT_CONTROL_POINT_CHARACTERISTIC,
-    GATT_AUDIO_INPUT_DESCRIPTION_CHARACTERISTIC,
-)
-from bumble.gatt_client import ProfileServiceProxy, ServiceProxy
-from bumble.utils import OpenIntEnum
-
-# -----------------------------------------------------------------------------
-# Logging
-# -----------------------------------------------------------------------------
-logger = logging.getLogger(__name__)
-
-
-# -----------------------------------------------------------------------------
-# Constants
-# -----------------------------------------------------------------------------
-CHANGE_COUNTER_MAX_VALUE = 0xFF
-GAIN_SETTINGS_MIN_VALUE = 0
-GAIN_SETTINGS_MAX_VALUE = 255
-
-
-class ErrorCode(OpenIntEnum):
-    '''
-    Cf. 1.6 Application error codes
-    '''
-
-    INVALID_CHANGE_COUNTER = 0x80
-    OPCODE_NOT_SUPPORTED = 0x81
-    MUTE_DISABLED = 0x82
-    VALUE_OUT_OF_RANGE = 0x83
-    GAIN_MODE_CHANGE_NOT_ALLOWED = 0x84
-
-
-class Mute(OpenIntEnum):
-    '''
-    Cf. 2.2.1.2 Mute Field
-    '''
-
-    NOT_MUTED = 0x00
-    MUTED = 0x01
-    DISABLED = 0x02
-
-
-class GainMode(OpenIntEnum):
-    '''
-    Cf. 2.2.1.3 Gain Mode
-    '''
-
-    MANUAL_ONLY = 0x00
-    AUTOMATIC_ONLY = 0x01
-    MANUAL = 0x02
-    AUTOMATIC = 0x03
-
-
-class AudioInputStatus(OpenIntEnum):
-    '''
-    Cf. 3.4 Audio Input Status
-    '''
-
-    INATIVE = 0x00
-    ACTIVE = 0x01
-
-
-class AudioInputControlPointOpCode(OpenIntEnum):
-    '''
-    Cf. 3.5.1 Audio Input Control Point procedure requirements
-    '''
-
-    SET_GAIN_SETTING = 0x00
-    UNMUTE = 0x02
-    MUTE = 0x03
-    SET_MANUAL_GAIN_MODE = 0x04
-    SET_AUTOMATIC_GAIN_MODE = 0x05
-
-
-# -----------------------------------------------------------------------------
-@dataclass
-class AudioInputState:
-    '''
-    Cf. 2.2.1 Audio Input State
-    '''
-
-    gain_settings: int = 0
-    mute: Mute = Mute.NOT_MUTED
-    gain_mode: GainMode = GainMode.MANUAL
-    change_counter: int = 0
-    attribute_value: Optional[CharacteristicValue] = None
-
-    def __bytes__(self) -> bytes:
-        return bytes(
-            [self.gain_settings, self.mute, self.gain_mode, self.change_counter]
-        )
-
-    @classmethod
-    def from_bytes(cls, data: bytes):
-        gain_settings, mute, gain_mode, change_counter = struct.unpack("BBBB", data)
-        return cls(gain_settings, mute, gain_mode, change_counter)
-
-    def update_gain_settings_unit(self, gain_settings_unit: int) -> None:
-        self.gain_settings_unit = gain_settings_unit
-
-    def increment_gain_settings(self, gain_settings_unit: int) -> None:
-        self.gain_settings += gain_settings_unit
-        self.increment_change_counter()
-
-    def decrement_gain_settings(self) -> None:
-        self.gain_settings -= self.gain_settings_unit
-        self.increment_change_counter()
-
-    def increment_change_counter(self):
-        self.change_counter = (self.change_counter + 1) % (CHANGE_COUNTER_MAX_VALUE + 1)
-
-    async def notify_subscribers_via_connection(self, connection: Connection) -> None:
-        assert self.attribute_value is not None
-        await connection.device.notify_subscribers(
-            attribute=self.attribute_value, value=bytes(self)
-        )
-
-    def on_read(self, _connection: Optional[Connection]) -> bytes:
-        return bytes(self)
-
-
-@dataclass
-class GainSettingsProperties:
-    '''
-    Cf. 3.2 Gain Settings Properties
-    '''
-
-    gain_settings_unit: int = 1
-    gain_settings_minimum: int = GAIN_SETTINGS_MIN_VALUE
-    gain_settings_maximum: int = GAIN_SETTINGS_MAX_VALUE
-
-    @classmethod
-    def from_bytes(cls, data: bytes):
-        (gain_settings_unit, gain_settings_minimum, gain_settings_maximum) = (
-            struct.unpack('BBB', data)
-        )
-        GainSettingsProperties(
-            gain_settings_unit, gain_settings_minimum, gain_settings_maximum
-        )
-
-    def __bytes__(self) -> bytes:
-        return bytes(
-            [
-                self.gain_settings_unit,
-                self.gain_settings_minimum,
-                self.gain_settings_maximum,
-            ]
-        )
-
-    def on_read(self, _connection: Optional[Connection]) -> bytes:
-        return bytes(self)
-
-
-@dataclass
-class AudioInputControlPoint:
-    '''
-    Cf. 3.5.2 Audio Input Control Point
-    '''
-
-    audio_input_state: AudioInputState
-    gain_settings_properties: GainSettingsProperties
-
-    async def on_write(self, connection: Optional[Connection], value: bytes) -> None:
-        assert connection
-
-        opcode = AudioInputControlPointOpCode(value[0])
-
-        if opcode == AudioInputControlPointOpCode.SET_GAIN_SETTING:
-            gain_settings_operand = value[2]
-            await self._set_gain_settings(connection, gain_settings_operand)
-        elif opcode == AudioInputControlPointOpCode.UNMUTE:
-            await self._unmute(connection)
-        elif opcode == AudioInputControlPointOpCode.MUTE:
-            change_counter_operand = value[1]
-            await self._mute(connection, change_counter_operand)
-        elif opcode == AudioInputControlPointOpCode.SET_MANUAL_GAIN_MODE:
-            await self._set_manual_gain_mode(connection)
-        elif opcode == AudioInputControlPointOpCode.SET_AUTOMATIC_GAIN_MODE:
-            await self._set_automatic_gain_mode(connection)
-        else:
-            logger.error(f"OpCode value is incorrect: {opcode}")
-            raise ATT_Error(ErrorCode.OPCODE_NOT_SUPPORTED)
-
-    async def _set_gain_settings(
-        self, connection: Connection, gain_settings_operand: int
-    ) -> None:
-        '''Cf. 3.5.2.1 Set Gain Settings Procedure'''
-
-        gain_mode = self.audio_input_state.gain_mode
-
-        logger.error(f"set_gain_setting: gain_mode: {gain_mode}")
-        if not (gain_mode == GainMode.MANUAL or gain_mode == GainMode.MANUAL_ONLY):
-            logger.warning(
-                "GainMode should be either MANUAL or MANUAL_ONLY Cf Spec Audio Input Control Service 3.5.2.1"
-            )
-            return
-
-        if (
-            gain_settings_operand < self.gain_settings_properties.gain_settings_minimum
-            or gain_settings_operand
-            > self.gain_settings_properties.gain_settings_maximum
-        ):
-            logger.error("gain_seetings value out of range")
-            raise ATT_Error(ErrorCode.VALUE_OUT_OF_RANGE)
-
-        if self.audio_input_state.gain_settings != gain_settings_operand:
-            self.audio_input_state.gain_settings = gain_settings_operand
-            await self.audio_input_state.notify_subscribers_via_connection(connection)
-
-    async def _unmute(self, connection: Connection):
-        '''Cf. 3.5.2.2 Unmute procedure'''
-
-        logger.error(f'unmute: {self.audio_input_state.mute}')
-        mute = self.audio_input_state.mute
-        if mute == Mute.DISABLED:
-            logger.error("unmute: Cannot change Mute value, Mute state is DISABLED")
-            raise ATT_Error(ErrorCode.MUTE_DISABLED)
-
-        if mute == Mute.NOT_MUTED:
-            return
-
-        self.audio_input_state.mute = Mute.NOT_MUTED
-        self.audio_input_state.increment_change_counter()
-        await self.audio_input_state.notify_subscribers_via_connection(connection)
-
-    async def _mute(self, connection: Connection, change_counter_operand: int) -> None:
-        '''Cf. 3.5.5.2 Mute procedure'''
-
-        change_counter = self.audio_input_state.change_counter
-        mute = self.audio_input_state.mute
-        if mute == Mute.DISABLED:
-            logger.error("mute: Cannot change Mute value, Mute state is DISABLED")
-            raise ATT_Error(ErrorCode.MUTE_DISABLED)
-
-        if change_counter != change_counter_operand:
-            raise ATT_Error(ErrorCode.INVALID_CHANGE_COUNTER)
-
-        if mute == Mute.MUTED:
-            return
-
-        self.audio_input_state.mute = Mute.MUTED
-        self.audio_input_state.increment_change_counter()
-        await self.audio_input_state.notify_subscribers_via_connection(connection)
-
-    async def _set_manual_gain_mode(self, connection: Connection) -> None:
-        '''Cf. 3.5.2.4 Set Manual Gain Mode procedure'''
-
-        gain_mode = self.audio_input_state.gain_mode
-        if gain_mode in (GainMode.AUTOMATIC_ONLY, GainMode.MANUAL_ONLY):
-            logger.error(f"Cannot change gain_mode, bad state: {gain_mode}")
-            raise ATT_Error(ErrorCode.GAIN_MODE_CHANGE_NOT_ALLOWED)
-
-        if gain_mode == GainMode.MANUAL:
-            return
-
-        self.audio_input_state.gain_mode = GainMode.MANUAL
-        self.audio_input_state.increment_change_counter()
-        await self.audio_input_state.notify_subscribers_via_connection(connection)
-
-    async def _set_automatic_gain_mode(self, connection: Connection) -> None:
-        '''Cf. 3.5.2.5 Set Automatic Gain Mode'''
-
-        gain_mode = self.audio_input_state.gain_mode
-        if gain_mode in (GainMode.AUTOMATIC_ONLY, GainMode.MANUAL_ONLY):
-            logger.error(f"Cannot change gain_mode, bad state: {gain_mode}")
-            raise ATT_Error(ErrorCode.GAIN_MODE_CHANGE_NOT_ALLOWED)
-
-        if gain_mode == GainMode.AUTOMATIC:
-            return
-
-        self.audio_input_state.gain_mode = GainMode.AUTOMATIC
-        self.audio_input_state.increment_change_counter()
-        await self.audio_input_state.notify_subscribers_via_connection(connection)
-
-
-@dataclass
-class AudioInputDescription:
-    '''
-    Cf. 3.6 Audio Input Description
-    '''
-
-    audio_input_description: str = "Bluetooth"
-    attribute_value: Optional[CharacteristicValue] = None
-
-    @classmethod
-    def from_bytes(cls, data: bytes):
-        return cls(audio_input_description=data.decode('utf-8'))
-
-    def __bytes__(self) -> bytes:
-        return self.audio_input_description.encode('utf-8')
-
-    def on_read(self, _connection: Optional[Connection]) -> bytes:
-        return self.audio_input_description.encode('utf-8')
-
-    async def on_write(self, connection: Optional[Connection], value: bytes) -> None:
-        assert connection
-        assert self.attribute_value
-
-        self.audio_input_description = value.decode('utf-8')
-        await connection.device.notify_subscribers(
-            attribute=self.attribute_value, value=value
-        )
-
-
-class AICSService(TemplateService):
-    UUID = GATT_AUDIO_INPUT_CONTROL_SERVICE
-
-    def __init__(
-        self,
-        audio_input_state: Optional[AudioInputState] = None,
-        gain_settings_properties: Optional[GainSettingsProperties] = None,
-        audio_input_type: str = "local",
-        audio_input_status: Optional[AudioInputStatus] = None,
-        audio_input_description: Optional[AudioInputDescription] = None,
-    ):
-        self.audio_input_state = (
-            AudioInputState() if audio_input_state is None else audio_input_state
-        )
-        self.gain_settings_properties = (
-            GainSettingsProperties()
-            if gain_settings_properties is None
-            else gain_settings_properties
-        )
-        self.audio_input_status = (
-            AudioInputStatus.ACTIVE
-            if audio_input_status is None
-            else audio_input_status
-        )
-        self.audio_input_description = (
-            AudioInputDescription()
-            if audio_input_description is None
-            else audio_input_description
-        )
-
-        self.audio_input_control_point: AudioInputControlPoint = AudioInputControlPoint(
-            self.audio_input_state, self.gain_settings_properties
-        )
-
-        self.audio_input_state_characteristic = DelegatedCharacteristicAdapter(
-            Characteristic(
-                uuid=GATT_AUDIO_INPUT_STATE_CHARACTERISTIC,
-                properties=Characteristic.Properties.READ
-                | Characteristic.Properties.NOTIFY,
-                permissions=Characteristic.Permissions.READ_REQUIRES_ENCRYPTION,
-                value=CharacteristicValue(read=self.audio_input_state.on_read),
-            ),
-            encode=lambda value: bytes(value),
-        )
-        self.audio_input_state.attribute_value = (
-            self.audio_input_state_characteristic.value
-        )
-
-        self.gain_settings_properties_characteristic = DelegatedCharacteristicAdapter(
-            Characteristic(
-                uuid=GATT_GAIN_SETTINGS_ATTRIBUTE_CHARACTERISTIC,
-                properties=Characteristic.Properties.READ,
-                permissions=Characteristic.Permissions.READ_REQUIRES_ENCRYPTION,
-                value=CharacteristicValue(read=self.gain_settings_properties.on_read),
-            )
-        )
-
-        self.audio_input_type_characteristic = Characteristic(
-            uuid=GATT_AUDIO_INPUT_TYPE_CHARACTERISTIC,
-            properties=Characteristic.Properties.READ,
-            permissions=Characteristic.Permissions.READ_REQUIRES_ENCRYPTION,
-            value=audio_input_type,
-        )
-
-        self.audio_input_status_characteristic = Characteristic(
-            uuid=GATT_AUDIO_INPUT_STATUS_CHARACTERISTIC,
-            properties=Characteristic.Properties.READ,
-            permissions=Characteristic.Permissions.READ_REQUIRES_ENCRYPTION,
-            value=bytes([self.audio_input_status]),
-        )
-
-        self.audio_input_control_point_characteristic = DelegatedCharacteristicAdapter(
-            Characteristic(
-                uuid=GATT_AUDIO_INPUT_CONTROL_POINT_CHARACTERISTIC,
-                properties=Characteristic.Properties.WRITE,
-                permissions=Characteristic.Permissions.WRITE_REQUIRES_ENCRYPTION,
-                value=CharacteristicValue(
-                    write=self.audio_input_control_point.on_write
-                ),
-            )
-        )
-
-        self.audio_input_description_characteristic = DelegatedCharacteristicAdapter(
-            Characteristic(
-                uuid=GATT_AUDIO_INPUT_DESCRIPTION_CHARACTERISTIC,
-                properties=Characteristic.Properties.READ
-                | Characteristic.Properties.NOTIFY
-                | Characteristic.Properties.WRITE_WITHOUT_RESPONSE,
-                permissions=Characteristic.Permissions.READ_REQUIRES_ENCRYPTION
-                | Characteristic.Permissions.WRITE_REQUIRES_ENCRYPTION,
-                value=CharacteristicValue(
-                    write=self.audio_input_description.on_write,
-                    read=self.audio_input_description.on_read,
-                ),
-            )
-        )
-        self.audio_input_description.attribute_value = (
-            self.audio_input_control_point_characteristic.value
-        )
-
-        super().__init__(
-            characteristics=[
-                self.audio_input_state_characteristic,  # type: ignore
-                self.gain_settings_properties_characteristic,  # type: ignore
-                self.audio_input_type_characteristic,  # type: ignore
-                self.audio_input_status_characteristic,  # type: ignore
-                self.audio_input_control_point_characteristic,  # type: ignore
-                self.audio_input_description_characteristic,  # type: ignore
-            ],
-            primary=False,
-        )
-
-
-# -----------------------------------------------------------------------------
-# Client
-# -----------------------------------------------------------------------------
-class AICSServiceProxy(ProfileServiceProxy):
-    SERVICE_CLASS = AICSService
-
-    def __init__(self, service_proxy: ServiceProxy) -> None:
-        self.service_proxy = service_proxy
-
-        if not (
-            characteristics := service_proxy.get_characteristics_by_uuid(
-                GATT_AUDIO_INPUT_STATE_CHARACTERISTIC
-            )
-        ):
-            raise gatt.InvalidServiceError("Audio Input State Characteristic not found")
-        self.audio_input_state = DelegatedCharacteristicAdapter(
-            characteristic=characteristics[0], decode=AudioInputState.from_bytes
-        )
-
-        if not (
-            characteristics := service_proxy.get_characteristics_by_uuid(
-                GATT_GAIN_SETTINGS_ATTRIBUTE_CHARACTERISTIC
-            )
-        ):
-            raise gatt.InvalidServiceError(
-                "Gain Settings Attribute Characteristic not found"
-            )
-        self.gain_settings_properties = PackedCharacteristicAdapter(
-            characteristics[0],
-            'BBB',
-        )
-
-        if not (
-            characteristics := service_proxy.get_characteristics_by_uuid(
-                GATT_AUDIO_INPUT_STATUS_CHARACTERISTIC
-            )
-        ):
-            raise gatt.InvalidServiceError(
-                "Audio Input Status Characteristic not found"
-            )
-        self.audio_input_status = PackedCharacteristicAdapter(
-            characteristics[0],
-            'B',
-        )
-
-        if not (
-            characteristics := service_proxy.get_characteristics_by_uuid(
-                GATT_AUDIO_INPUT_CONTROL_POINT_CHARACTERISTIC
-            )
-        ):
-            raise gatt.InvalidServiceError(
-                "Audio Input Control Point Characteristic not found"
-            )
-        self.audio_input_control_point = characteristics[0]
-
-        if not (
-            characteristics := service_proxy.get_characteristics_by_uuid(
-                GATT_AUDIO_INPUT_DESCRIPTION_CHARACTERISTIC
-            )
-        ):
-            raise gatt.InvalidServiceError(
-                "Audio Input Description Characteristic not found"
-            )
-        self.audio_input_description = characteristics[0]

bumble/profiles/ascs.py

@@ -1,739 +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
-
-"""LE Audio - Audio Stream Control Service"""
-
-# -----------------------------------------------------------------------------
-# Imports
-# -----------------------------------------------------------------------------
-from __future__ import annotations
-import enum
-import logging
-import struct
-from typing import Any, Dict, List, Optional, Sequence, Tuple, Type, Union
-
-from bumble import colors
-from bumble.profiles.bap import CodecSpecificConfiguration
-from bumble.profiles import le_audio
-from bumble import device
-from bumble import gatt
-from bumble import gatt_client
-from bumble import hci
-
-# -----------------------------------------------------------------------------
-# Logging
-# -----------------------------------------------------------------------------
-logger = logging.getLogger(__name__)
-
-
-# -----------------------------------------------------------------------------
-# ASE Operations
-# -----------------------------------------------------------------------------
-
-
-class ASE_Operation:
-    '''
-    See Audio Stream Control Service - 5 ASE Control operations.
-    '''
-
-    classes: Dict[int, Type[ASE_Operation]] = {}
-    op_code: int
-    name: str
-    fields: Optional[Sequence[Any]] = None
-    ase_id: List[int]
-
-    class Opcode(enum.IntEnum):
-        # fmt: off
-        CONFIG_CODEC         = 0x01
-        CONFIG_QOS           = 0x02
-        ENABLE               = 0x03
-        RECEIVER_START_READY = 0x04
-        DISABLE              = 0x05
-        RECEIVER_STOP_READY  = 0x06
-        UPDATE_METADATA      = 0x07
-        RELEASE              = 0x08
-
-    @staticmethod
-    def from_bytes(pdu: bytes) -> ASE_Operation:
-        op_code = pdu[0]
-
-        cls = ASE_Operation.classes.get(op_code)
-        if cls is None:
-            instance = ASE_Operation(pdu)
-            instance.name = ASE_Operation.Opcode(op_code).name
-            instance.op_code = op_code
-            return instance
-        self = cls.__new__(cls)
-        ASE_Operation.__init__(self, pdu)
-        if self.fields is not None:
-            self.init_from_bytes(pdu, 1)
-        return self
-
-    @staticmethod
-    def subclass(fields):
-        def inner(cls: Type[ASE_Operation]):
-            try:
-                operation = ASE_Operation.Opcode[cls.__name__[4:].upper()]
-                cls.name = operation.name
-                cls.op_code = operation
-            except:
-                raise KeyError(f'PDU name {cls.name} not found in Ase_Operation.Opcode')
-            cls.fields = fields
-
-            # Register a factory for this class
-            ASE_Operation.classes[cls.op_code] = cls
-
-            return cls
-
-        return inner
-
-    def __init__(self, pdu: Optional[bytes] = None, **kwargs) -> None:
-        if self.fields is not None and kwargs:
-            hci.HCI_Object.init_from_fields(self, self.fields, kwargs)
-        if pdu is None:
-            pdu = bytes([self.op_code]) + hci.HCI_Object.dict_to_bytes(
-                kwargs, self.fields
-            )
-        self.pdu = pdu
-
-    def init_from_bytes(self, pdu: bytes, offset: int):
-        return hci.HCI_Object.init_from_bytes(self, pdu, offset, self.fields)
-
-    def __bytes__(self) -> bytes:
-        return self.pdu
-
-    def __str__(self) -> str:
-        result = f'{colors.color(self.name, "yellow")} '
-        if fields := getattr(self, 'fields', None):
-            result += ':\n' + hci.HCI_Object.format_fields(self.__dict__, fields, '  ')
-        else:
-            if len(self.pdu) > 1:
-                result += f': {self.pdu.hex()}'
-        return result
-
-
-@ASE_Operation.subclass(
-    [
-        [
-            ('ase_id', 1),
-            ('target_latency', 1),
-            ('target_phy', 1),
-            ('codec_id', hci.CodingFormat.parse_from_bytes),
-            ('codec_specific_configuration', 'v'),
-        ],
-    ]
-)
-class ASE_Config_Codec(ASE_Operation):
-    '''
-    See Audio Stream Control Service 5.1 - Config Codec Operation
-    '''
-
-    target_latency: List[int]
-    target_phy: List[int]
-    codec_id: List[hci.CodingFormat]
-    codec_specific_configuration: List[bytes]
-
-
-@ASE_Operation.subclass(
-    [
-        [
-            ('ase_id', 1),
-            ('cig_id', 1),
-            ('cis_id', 1),
-            ('sdu_interval', 3),
-            ('framing', 1),
-            ('phy', 1),
-            ('max_sdu', 2),
-            ('retransmission_number', 1),
-            ('max_transport_latency', 2),
-            ('presentation_delay', 3),
-        ],
-    ]
-)
-class ASE_Config_QOS(ASE_Operation):
-    '''
-    See Audio Stream Control Service 5.2 - Config Qos Operation
-    '''
-
-    cig_id: List[int]
-    cis_id: List[int]
-    sdu_interval: List[int]
-    framing: List[int]
-    phy: List[int]
-    max_sdu: List[int]
-    retransmission_number: List[int]
-    max_transport_latency: List[int]
-    presentation_delay: List[int]
-
-
-@ASE_Operation.subclass([[('ase_id', 1), ('metadata', 'v')]])
-class ASE_Enable(ASE_Operation):
-    '''
-    See Audio Stream Control Service 5.3 - Enable Operation
-    '''
-
-    metadata: bytes
-
-
-@ASE_Operation.subclass([[('ase_id', 1)]])
-class ASE_Receiver_Start_Ready(ASE_Operation):
-    '''
-    See Audio Stream Control Service 5.4 - Receiver Start Ready Operation
-    '''
-
-
-@ASE_Operation.subclass([[('ase_id', 1)]])
-class ASE_Disable(ASE_Operation):
-    '''
-    See Audio Stream Control Service 5.5 - Disable Operation
-    '''
-
-
-@ASE_Operation.subclass([[('ase_id', 1)]])
-class ASE_Receiver_Stop_Ready(ASE_Operation):
-    '''
-    See Audio Stream Control Service 5.6 - Receiver Stop Ready Operation
-    '''
-
-
-@ASE_Operation.subclass([[('ase_id', 1), ('metadata', 'v')]])
-class ASE_Update_Metadata(ASE_Operation):
-    '''
-    See Audio Stream Control Service 5.7 - Update Metadata Operation
-    '''
-
-    metadata: List[bytes]
-
-
-@ASE_Operation.subclass([[('ase_id', 1)]])
-class ASE_Release(ASE_Operation):
-    '''
-    See Audio Stream Control Service 5.8 - Release Operation
-    '''
-
-
-class AseResponseCode(enum.IntEnum):
-    # fmt: off
-    SUCCESS                                     = 0x00
-    UNSUPPORTED_OPCODE                          = 0x01
-    INVALID_LENGTH                              = 0x02
-    INVALID_ASE_ID                              = 0x03
-    INVALID_ASE_STATE_MACHINE_TRANSITION        = 0x04
-    INVALID_ASE_DIRECTION                       = 0x05
-    UNSUPPORTED_AUDIO_CAPABILITIES              = 0x06
-    UNSUPPORTED_CONFIGURATION_PARAMETER_VALUE   = 0x07
-    REJECTED_CONFIGURATION_PARAMETER_VALUE      = 0x08
-    INVALID_CONFIGURATION_PARAMETER_VALUE       = 0x09
-    UNSUPPORTED_METADATA                        = 0x0A
-    REJECTED_METADATA                           = 0x0B
-    INVALID_METADATA                            = 0x0C
-    INSUFFICIENT_RESOURCES                      = 0x0D
-    UNSPECIFIED_ERROR                           = 0x0E
-
-
-class AseReasonCode(enum.IntEnum):
-    # fmt: off
-    NONE                            = 0x00
-    CODEC_ID                        = 0x01
-    CODEC_SPECIFIC_CONFIGURATION    = 0x02
-    SDU_INTERVAL                    = 0x03
-    FRAMING                         = 0x04
-    PHY                             = 0x05
-    MAXIMUM_SDU_SIZE                = 0x06
-    RETRANSMISSION_NUMBER           = 0x07
-    MAX_TRANSPORT_LATENCY           = 0x08
-    PRESENTATION_DELAY              = 0x09
-    INVALID_ASE_CIS_MAPPING         = 0x0A
-
-
-# -----------------------------------------------------------------------------
-class AudioRole(enum.IntEnum):
-    SINK = hci.HCI_LE_Setup_ISO_Data_Path_Command.Direction.CONTROLLER_TO_HOST
-    SOURCE = hci.HCI_LE_Setup_ISO_Data_Path_Command.Direction.HOST_TO_CONTROLLER
-
-
-# -----------------------------------------------------------------------------
-class AseStateMachine(gatt.Characteristic):
-    class State(enum.IntEnum):
-        # fmt: off
-        IDLE             = 0x00
-        CODEC_CONFIGURED = 0x01
-        QOS_CONFIGURED   = 0x02
-        ENABLING         = 0x03
-        STREAMING        = 0x04
-        DISABLING        = 0x05
-        RELEASING        = 0x06
-
-    cis_link: Optional[device.CisLink] = None
-
-    # Additional parameters in CODEC_CONFIGURED State
-    preferred_framing = 0  # Unframed PDU supported
-    preferred_phy = 0
-    preferred_retransmission_number = 13
-    preferred_max_transport_latency = 100
-    supported_presentation_delay_min = 0
-    supported_presentation_delay_max = 0
-    preferred_presentation_delay_min = 0
-    preferred_presentation_delay_max = 0
-    codec_id = hci.CodingFormat(hci.CodecID.LC3)
-    codec_specific_configuration: Union[CodecSpecificConfiguration, bytes] = b''
-
-    # Additional parameters in QOS_CONFIGURED State
-    cig_id = 0
-    cis_id = 0
-    sdu_interval = 0
-    framing = 0
-    phy = 0
-    max_sdu = 0
-    retransmission_number = 0
-    max_transport_latency = 0
-    presentation_delay = 0
-
-    # Additional parameters in ENABLING, STREAMING, DISABLING State
-    metadata = le_audio.Metadata()
-
-    def __init__(
-        self,
-        role: AudioRole,
-        ase_id: int,
-        service: AudioStreamControlService,
-    ) -> None:
-        self.service = service
-        self.ase_id = ase_id
-        self._state = AseStateMachine.State.IDLE
-        self.role = role
-
-        uuid = (
-            gatt.GATT_SINK_ASE_CHARACTERISTIC
-            if role == AudioRole.SINK
-            else gatt.GATT_SOURCE_ASE_CHARACTERISTIC
-        )
-        super().__init__(
-            uuid=uuid,
-            properties=gatt.Characteristic.Properties.READ
-            | gatt.Characteristic.Properties.NOTIFY,
-            permissions=gatt.Characteristic.Permissions.READABLE,
-            value=gatt.CharacteristicValue(read=self.on_read),
-        )
-
-        self.service.device.on('cis_request', self.on_cis_request)
-        self.service.device.on('cis_establishment', self.on_cis_establishment)
-
-    def on_cis_request(
-        self,
-        acl_connection: device.Connection,
-        cis_handle: int,
-        cig_id: int,
-        cis_id: int,
-    ) -> None:
-        if (
-            cig_id == self.cig_id
-            and cis_id == self.cis_id
-            and self.state == self.State.ENABLING
-        ):
-            acl_connection.abort_on(
-                'flush', self.service.device.accept_cis_request(cis_handle)
-            )
-
-    def on_cis_establishment(self, cis_link: device.CisLink) -> None:
-        if (
-            cis_link.cig_id == self.cig_id
-            and cis_link.cis_id == self.cis_id
-            and self.state == self.State.ENABLING
-        ):
-            cis_link.on('disconnection', self.on_cis_disconnection)
-
-            async def post_cis_established():
-                await self.service.device.send_command(
-                    hci.HCI_LE_Setup_ISO_Data_Path_Command(
-                        connection_handle=cis_link.handle,
-                        data_path_direction=self.role,
-                        data_path_id=0x00,  # Fixed HCI
-                        codec_id=hci.CodingFormat(hci.CodecID.TRANSPARENT),
-                        controller_delay=0,
-                        codec_configuration=b'',
-                    )
-                )
-                if self.role == AudioRole.SINK:
-                    self.state = self.State.STREAMING
-                await self.service.device.notify_subscribers(self, self.value)
-
-            cis_link.acl_connection.abort_on('flush', post_cis_established())
-            self.cis_link = cis_link
-
-    def on_cis_disconnection(self, _reason) -> None:
-        self.cis_link = None
-
-    def on_config_codec(
-        self,
-        target_latency: int,
-        target_phy: int,
-        codec_id: hci.CodingFormat,
-        codec_specific_configuration: bytes,
-    ) -> Tuple[AseResponseCode, AseReasonCode]:
-        if self.state not in (
-            self.State.IDLE,
-            self.State.CODEC_CONFIGURED,
-            self.State.QOS_CONFIGURED,
-        ):
-            return (
-                AseResponseCode.INVALID_ASE_STATE_MACHINE_TRANSITION,
-                AseReasonCode.NONE,
-            )
-
-        self.max_transport_latency = target_latency
-        self.phy = target_phy
-        self.codec_id = codec_id
-        if codec_id.codec_id == hci.CodecID.VENDOR_SPECIFIC:
-            self.codec_specific_configuration = codec_specific_configuration
-        else:
-            self.codec_specific_configuration = CodecSpecificConfiguration.from_bytes(
-                codec_specific_configuration
-            )
-
-        self.state = self.State.CODEC_CONFIGURED
-
-        return (AseResponseCode.SUCCESS, AseReasonCode.NONE)
-
-    def on_config_qos(
-        self,
-        cig_id: int,
-        cis_id: int,
-        sdu_interval: int,
-        framing: int,
-        phy: int,
-        max_sdu: int,
-        retransmission_number: int,
-        max_transport_latency: int,
-        presentation_delay: int,
-    ) -> Tuple[AseResponseCode, AseReasonCode]:
-        if self.state not in (
-            AseStateMachine.State.CODEC_CONFIGURED,
-            AseStateMachine.State.QOS_CONFIGURED,
-        ):
-            return (
-                AseResponseCode.INVALID_ASE_STATE_MACHINE_TRANSITION,
-                AseReasonCode.NONE,
-            )
-
-        self.cig_id = cig_id
-        self.cis_id = cis_id
-        self.sdu_interval = sdu_interval
-        self.framing = framing
-        self.phy = phy
-        self.max_sdu = max_sdu
-        self.retransmission_number = retransmission_number
-        self.max_transport_latency = max_transport_latency
-        self.presentation_delay = presentation_delay
-
-        self.state = self.State.QOS_CONFIGURED
-
-        return (AseResponseCode.SUCCESS, AseReasonCode.NONE)
-
-    def on_enable(self, metadata: bytes) -> Tuple[AseResponseCode, AseReasonCode]:
-        if self.state != AseStateMachine.State.QOS_CONFIGURED:
-            return (
-                AseResponseCode.INVALID_ASE_STATE_MACHINE_TRANSITION,
-                AseReasonCode.NONE,
-            )
-
-        self.metadata = le_audio.Metadata.from_bytes(metadata)
-        self.state = self.State.ENABLING
-
-        return (AseResponseCode.SUCCESS, AseReasonCode.NONE)
-
-    def on_receiver_start_ready(self) -> Tuple[AseResponseCode, AseReasonCode]:
-        if self.state != AseStateMachine.State.ENABLING:
-            return (
-                AseResponseCode.INVALID_ASE_STATE_MACHINE_TRANSITION,
-                AseReasonCode.NONE,
-            )
-        self.state = self.State.STREAMING
-        return (AseResponseCode.SUCCESS, AseReasonCode.NONE)
-
-    def on_disable(self) -> Tuple[AseResponseCode, AseReasonCode]:
-        if self.state not in (
-            AseStateMachine.State.ENABLING,
-            AseStateMachine.State.STREAMING,
-        ):
-            return (
-                AseResponseCode.INVALID_ASE_STATE_MACHINE_TRANSITION,
-                AseReasonCode.NONE,
-            )
-        if self.role == AudioRole.SINK:
-            self.state = self.State.QOS_CONFIGURED
-        else:
-            self.state = self.State.DISABLING
-        return (AseResponseCode.SUCCESS, AseReasonCode.NONE)
-
-    def on_receiver_stop_ready(self) -> Tuple[AseResponseCode, AseReasonCode]:
-        if (
-            self.role != AudioRole.SOURCE
-            or self.state != AseStateMachine.State.DISABLING
-        ):
-            return (
-                AseResponseCode.INVALID_ASE_STATE_MACHINE_TRANSITION,
-                AseReasonCode.NONE,
-            )
-        self.state = self.State.QOS_CONFIGURED
-        return (AseResponseCode.SUCCESS, AseReasonCode.NONE)
-
-    def on_update_metadata(
-        self, metadata: bytes
-    ) -> Tuple[AseResponseCode, AseReasonCode]:
-        if self.state not in (
-            AseStateMachine.State.ENABLING,
-            AseStateMachine.State.STREAMING,
-        ):
-            return (
-                AseResponseCode.INVALID_ASE_STATE_MACHINE_TRANSITION,
-                AseReasonCode.NONE,
-            )
-        self.metadata = le_audio.Metadata.from_bytes(metadata)
-        return (AseResponseCode.SUCCESS, AseReasonCode.NONE)
-
-    def on_release(self) -> Tuple[AseResponseCode, AseReasonCode]:
-        if self.state == AseStateMachine.State.IDLE:
-            return (
-                AseResponseCode.INVALID_ASE_STATE_MACHINE_TRANSITION,
-                AseReasonCode.NONE,
-            )
-        self.state = self.State.RELEASING
-
-        async def remove_cis_async():
-            await self.service.device.send_command(
-                hci.HCI_LE_Remove_ISO_Data_Path_Command(
-                    connection_handle=self.cis_link.handle,
-                    data_path_direction=self.role,
-                )
-            )
-            self.state = self.State.IDLE
-            await self.service.device.notify_subscribers(self, self.value)
-
-        self.service.device.abort_on('flush', remove_cis_async())
-        return (AseResponseCode.SUCCESS, AseReasonCode.NONE)
-
-    @property
-    def state(self) -> State:
-        return self._state
-
-    @state.setter
-    def state(self, new_state: State) -> None:
-        logger.debug(f'{self} state change -> {colors.color(new_state.name, "cyan")}')
-        self._state = new_state
-        self.emit('state_change')
-
-    @property
-    def value(self):
-        '''Returns ASE_ID, ASE_STATE, and ASE Additional Parameters.'''
-
-        if self.state == self.State.CODEC_CONFIGURED:
-            codec_specific_configuration_bytes = bytes(
-                self.codec_specific_configuration
-            )
-            additional_parameters = (
-                struct.pack(
-                    '<BBBH',
-                    self.preferred_framing,
-                    self.preferred_phy,
-                    self.preferred_retransmission_number,
-                    self.preferred_max_transport_latency,
-                )
-                + self.supported_presentation_delay_min.to_bytes(3, 'little')
-                + self.supported_presentation_delay_max.to_bytes(3, 'little')
-                + self.preferred_presentation_delay_min.to_bytes(3, 'little')
-                + self.preferred_presentation_delay_max.to_bytes(3, 'little')
-                + bytes(self.codec_id)
-                + bytes([len(codec_specific_configuration_bytes)])
-                + codec_specific_configuration_bytes
-            )
-        elif self.state == self.State.QOS_CONFIGURED:
-            additional_parameters = (
-                bytes([self.cig_id, self.cis_id])
-                + self.sdu_interval.to_bytes(3, 'little')
-                + struct.pack(
-                    '<BBHBH',
-                    self.framing,
-                    self.phy,
-                    self.max_sdu,
-                    self.retransmission_number,
-                    self.max_transport_latency,
-                )
-                + self.presentation_delay.to_bytes(3, 'little')
-            )
-        elif self.state in (
-            self.State.ENABLING,
-            self.State.STREAMING,
-            self.State.DISABLING,
-        ):
-            metadata_bytes = bytes(self.metadata)
-            additional_parameters = (
-                bytes([self.cig_id, self.cis_id, len(metadata_bytes)]) + metadata_bytes
-            )
-        else:
-            additional_parameters = b''
-
-        return bytes([self.ase_id, self.state]) + additional_parameters
-
-    @value.setter
-    def value(self, _new_value):
-        # Readonly. Do nothing in the setter.
-        pass
-
-    def on_read(self, _: Optional[device.Connection]) -> bytes:
-        return self.value
-
-    def __str__(self) -> str:
-        return (
-            f'AseStateMachine(id={self.ase_id}, role={self.role.name} '
-            f'state={self._state.name})'
-        )
-
-
-# -----------------------------------------------------------------------------
-class AudioStreamControlService(gatt.TemplateService):
-    UUID = gatt.GATT_AUDIO_STREAM_CONTROL_SERVICE
-
-    ase_state_machines: Dict[int, AseStateMachine]
-    ase_control_point: gatt.Characteristic
-    _active_client: Optional[device.Connection] = None
-
-    def __init__(
-        self,
-        device: device.Device,
-        source_ase_id: Sequence[int] = (),
-        sink_ase_id: Sequence[int] = (),
-    ) -> None:
-        self.device = device
-        self.ase_state_machines = {
-            **{
-                id: AseStateMachine(role=AudioRole.SINK, ase_id=id, service=self)
-                for id in sink_ase_id
-            },
-            **{
-                id: AseStateMachine(role=AudioRole.SOURCE, ase_id=id, service=self)
-                for id in source_ase_id
-            },
-        }  # ASE state machines, by ASE ID
-
-        self.ase_control_point = gatt.Characteristic(
-            uuid=gatt.GATT_ASE_CONTROL_POINT_CHARACTERISTIC,
-            properties=gatt.Characteristic.Properties.WRITE
-            | gatt.Characteristic.Properties.WRITE_WITHOUT_RESPONSE
-            | gatt.Characteristic.Properties.NOTIFY,
-            permissions=gatt.Characteristic.Permissions.WRITEABLE,
-            value=gatt.CharacteristicValue(write=self.on_write_ase_control_point),
-        )
-
-        super().__init__([self.ase_control_point, *self.ase_state_machines.values()])
-
-    def on_operation(self, opcode: ASE_Operation.Opcode, ase_id: int, args):
-        if ase := self.ase_state_machines.get(ase_id):
-            handler = getattr(ase, 'on_' + opcode.name.lower())
-            return (ase_id, *handler(*args))
-        else:
-            return (ase_id, AseResponseCode.INVALID_ASE_ID, AseReasonCode.NONE)
-
-    def _on_client_disconnected(self, _reason: int) -> None:
-        for ase in self.ase_state_machines.values():
-            ase.state = AseStateMachine.State.IDLE
-        self._active_client = None
-
-    def on_write_ase_control_point(self, connection, data):
-        if not self._active_client and connection:
-            self._active_client = connection
-            connection.once('disconnection', self._on_client_disconnected)
-
-        operation = ASE_Operation.from_bytes(data)
-        responses = []
-        logger.debug(f'*** ASCS Write {operation} ***')
-
-        if operation.op_code == ASE_Operation.Opcode.CONFIG_CODEC:
-            for ase_id, *args in zip(
-                operation.ase_id,
-                operation.target_latency,
-                operation.target_phy,
-                operation.codec_id,
-                operation.codec_specific_configuration,
-            ):
-                responses.append(self.on_operation(operation.op_code, ase_id, args))
-        elif operation.op_code == ASE_Operation.Opcode.CONFIG_QOS:
-            for ase_id, *args in zip(
-                operation.ase_id,
-                operation.cig_id,
-                operation.cis_id,
-                operation.sdu_interval,
-                operation.framing,
-                operation.phy,
-                operation.max_sdu,
-                operation.retransmission_number,
-                operation.max_transport_latency,
-                operation.presentation_delay,
-            ):
-                responses.append(self.on_operation(operation.op_code, ase_id, args))
-        elif operation.op_code in (
-            ASE_Operation.Opcode.ENABLE,
-            ASE_Operation.Opcode.UPDATE_METADATA,
-        ):
-            for ase_id, *args in zip(
-                operation.ase_id,
-                operation.metadata,
-            ):
-                responses.append(self.on_operation(operation.op_code, ase_id, args))
-        elif operation.op_code in (
-            ASE_Operation.Opcode.RECEIVER_START_READY,
-            ASE_Operation.Opcode.DISABLE,
-            ASE_Operation.Opcode.RECEIVER_STOP_READY,
-            ASE_Operation.Opcode.RELEASE,
-        ):
-            for ase_id in operation.ase_id:
-                responses.append(self.on_operation(operation.op_code, ase_id, []))
-
-        control_point_notification = bytes(
-            [operation.op_code, len(responses)]
-        ) + b''.join(map(bytes, responses))
-        self.device.abort_on(
-            'flush',
-            self.device.notify_subscribers(
-                self.ase_control_point, control_point_notification
-            ),
-        )
-
-        for ase_id, *_ in responses:
-            if ase := self.ase_state_machines.get(ase_id):
-                self.device.abort_on(
-                    'flush',
-                    self.device.notify_subscribers(ase, ase.value),
-                )
-
-
-# -----------------------------------------------------------------------------
-class AudioStreamControlServiceProxy(gatt_client.ProfileServiceProxy):
-    SERVICE_CLASS = AudioStreamControlService
-
-    sink_ase: List[gatt_client.CharacteristicProxy]
-    source_ase: List[gatt_client.CharacteristicProxy]
-    ase_control_point: gatt_client.CharacteristicProxy
-
-    def __init__(self, service_proxy: gatt_client.ServiceProxy):
-        self.service_proxy = service_proxy
-
-        self.sink_ase = service_proxy.get_characteristics_by_uuid(
-            gatt.GATT_SINK_ASE_CHARACTERISTIC
-        )
-        self.source_ase = service_proxy.get_characteristics_by_uuid(
-            gatt.GATT_SOURCE_ASE_CHARACTERISTIC
-        )
-        self.ase_control_point = service_proxy.get_characteristics_by_uuid(
-            gatt.GATT_ASE_CONTROL_POINT_CHARACTERISTIC
-        )[0]

bumble/profiles/asha.py

@@ -1,295 +0,0 @@
-# Copyright 2021-2022 Google LLC
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-# -----------------------------------------------------------------------------
-# Imports
-# -----------------------------------------------------------------------------
-import enum
-import struct
-import logging
-from typing import List, Optional, Callable, Union, Any
-
-from bumble import l2cap
-from bumble import utils
-from bumble import gatt
-from bumble import gatt_client
-from bumble.core import AdvertisingData
-from bumble.device import Device, Connection
-
-# -----------------------------------------------------------------------------
-# Logging
-# -----------------------------------------------------------------------------
-_logger = logging.getLogger(__name__)
-
-
-# -----------------------------------------------------------------------------
-# Constants
-# -----------------------------------------------------------------------------
-class DeviceCapabilities(enum.IntFlag):
-    IS_RIGHT = 0x01
-    IS_DUAL = 0x02
-    CSIS_SUPPORTED = 0x04
-
-
-class FeatureMap(enum.IntFlag):
-    LE_COC_AUDIO_OUTPUT_STREAMING_SUPPORTED = 0x01
-
-
-class AudioType(utils.OpenIntEnum):
-    UNKNOWN = 0x00
-    RINGTONE = 0x01
-    PHONE_CALL = 0x02
-    MEDIA = 0x03
-
-
-class OpCode(utils.OpenIntEnum):
-    START = 1
-    STOP = 2
-    STATUS = 3
-
-
-class Codec(utils.OpenIntEnum):
-    G_722_16KHZ = 1
-
-
-class SupportedCodecs(enum.IntFlag):
-    G_722_16KHZ = 1 << Codec.G_722_16KHZ
-
-
-class PeripheralStatus(utils.OpenIntEnum):
-    """Status update on the other peripheral."""
-
-    OTHER_PERIPHERAL_DISCONNECTED = 1
-    OTHER_PERIPHERAL_CONNECTED = 2
-    CONNECTION_PARAMETER_UPDATED = 3
-
-
-class AudioStatus(utils.OpenIntEnum):
-    """Status report field for the audio control point."""
-
-    OK = 0
-    UNKNOWN_COMMAND = -1
-    ILLEGAL_PARAMETERS = -2
-
-
-# -----------------------------------------------------------------------------
-class AshaService(gatt.TemplateService):
-    UUID = gatt.GATT_ASHA_SERVICE
-
-    audio_sink: Optional[Callable[[bytes], Any]]
-    active_codec: Optional[Codec] = None
-    audio_type: Optional[AudioType] = None
-    volume: Optional[int] = None
-    other_state: Optional[int] = None
-    connection: Optional[Connection] = None
-
-    def __init__(
-        self,
-        capability: int,
-        hisyncid: Union[List[int], bytes],
-        device: Device,
-        psm: int = 0,
-        audio_sink: Optional[Callable[[bytes], Any]] = None,
-        feature_map: int = FeatureMap.LE_COC_AUDIO_OUTPUT_STREAMING_SUPPORTED,
-        protocol_version: int = 0x01,
-        render_delay_milliseconds: int = 0,
-        supported_codecs: int = SupportedCodecs.G_722_16KHZ,
-    ) -> None:
-        if len(hisyncid) != 8:
-            _logger.warning('HiSyncId should have a length of 8, got %d', len(hisyncid))
-
-        self.hisyncid = bytes(hisyncid)
-        self.capability = capability
-        self.device = device
-        self.audio_out_data = b''
-        self.psm = psm  # a non-zero psm is mainly for testing purpose
-        self.audio_sink = audio_sink
-        self.protocol_version = protocol_version
-
-        self.read_only_properties_characteristic = gatt.Characteristic(
-            gatt.GATT_ASHA_READ_ONLY_PROPERTIES_CHARACTERISTIC,
-            gatt.Characteristic.Properties.READ,
-            gatt.Characteristic.READABLE,
-            struct.pack(
-                "<BB8sBH2sH",
-                protocol_version,
-                capability,
-                self.hisyncid,
-                feature_map,
-                render_delay_milliseconds,
-                b'\x00\x00',
-                supported_codecs,
-            ),
-        )
-
-        self.audio_control_point_characteristic = gatt.Characteristic(
-            gatt.GATT_ASHA_AUDIO_CONTROL_POINT_CHARACTERISTIC,
-            gatt.Characteristic.Properties.WRITE
-            | gatt.Characteristic.Properties.WRITE_WITHOUT_RESPONSE,
-            gatt.Characteristic.WRITEABLE,
-            gatt.CharacteristicValue(write=self._on_audio_control_point_write),
-        )
-        self.audio_status_characteristic = gatt.Characteristic(
-            gatt.GATT_ASHA_AUDIO_STATUS_CHARACTERISTIC,
-            gatt.Characteristic.Properties.READ | gatt.Characteristic.Properties.NOTIFY,
-            gatt.Characteristic.READABLE,
-            bytes([AudioStatus.OK]),
-        )
-        self.volume_characteristic = gatt.Characteristic(
-            gatt.GATT_ASHA_VOLUME_CHARACTERISTIC,
-            gatt.Characteristic.Properties.WRITE_WITHOUT_RESPONSE,
-            gatt.Characteristic.WRITEABLE,
-            gatt.CharacteristicValue(write=self._on_volume_write),
-        )
-
-        # let the server find a free PSM
-        self.psm = device.create_l2cap_server(
-            spec=l2cap.LeCreditBasedChannelSpec(psm=self.psm, max_credits=8),
-            handler=self._on_connection,
-        ).psm
-        self.le_psm_out_characteristic = gatt.Characteristic(
-            gatt.GATT_ASHA_LE_PSM_OUT_CHARACTERISTIC,
-            gatt.Characteristic.Properties.READ,
-            gatt.Characteristic.READABLE,
-            struct.pack('<H', self.psm),
-        )
-
-        characteristics = [
-            self.read_only_properties_characteristic,
-            self.audio_control_point_characteristic,
-            self.audio_status_characteristic,
-            self.volume_characteristic,
-            self.le_psm_out_characteristic,
-        ]
-
-        super().__init__(characteristics)
-
-    def get_advertising_data(self) -> bytes:
-        # Advertisement only uses 4 least significant bytes of the HiSyncId.
-        return bytes(
-            AdvertisingData(
-                [
-                    (
-                        AdvertisingData.SERVICE_DATA_16_BIT_UUID,
-                        bytes(gatt.GATT_ASHA_SERVICE)
-                        + bytes([self.protocol_version, self.capability])
-                        + self.hisyncid[:4],
-                    ),
-                ]
-            )
-        )
-
-    # Handler for audio control commands
-    async def _on_audio_control_point_write(
-        self, connection: Optional[Connection], value: bytes
-    ) -> None:
-        _logger.debug(f'--- AUDIO CONTROL POINT Write:{value.hex()}')
-        opcode = value[0]
-        if opcode == OpCode.START:
-            # Start
-            self.active_codec = Codec(value[1])
-            self.audio_type = AudioType(value[2])
-            self.volume = value[3]
-            self.other_state = value[4]
-            _logger.debug(
-                f'### START: codec={self.active_codec.name}, '
-                f'audio_type={self.audio_type.name}, '
-                f'volume={self.volume}, '
-                f'other_state={self.other_state}'
-            )
-            self.emit('started')
-        elif opcode == OpCode.STOP:
-            _logger.debug('### STOP')
-            self.active_codec = None
-            self.audio_type = None
-            self.volume = None
-            self.other_state = None
-            self.emit('stopped')
-        elif opcode == OpCode.STATUS:
-            _logger.debug('### STATUS: %s', PeripheralStatus(value[1]).name)
-
-        if self.connection is None and connection:
-            self.connection = connection
-
-            def on_disconnection(_reason) -> None:
-                self.connection = None
-                self.active_codec = None
-                self.audio_type = None
-                self.volume = None
-                self.other_state = None
-                self.emit('disconnected')
-
-            connection.once('disconnection', on_disconnection)
-
-        # OPCODE_STATUS does not need audio status point update
-        if opcode != OpCode.STATUS:
-            await self.device.notify_subscribers(
-                self.audio_status_characteristic, force=True
-            )
-
-    # Handler for volume control
-    def _on_volume_write(self, connection: Optional[Connection], value: bytes) -> None:
-        _logger.debug(f'--- VOLUME Write:{value[0]}')
-        self.volume = value[0]
-        self.emit('volume_changed')
-
-    # Register an L2CAP CoC server
-    def _on_connection(self, channel: l2cap.LeCreditBasedChannel) -> None:
-        def on_data(data: bytes) -> None:
-            if self.audio_sink:  # pylint: disable=not-callable
-                self.audio_sink(data)
-
-        channel.sink = on_data
-
-
-# -----------------------------------------------------------------------------
-class AshaServiceProxy(gatt_client.ProfileServiceProxy):
-    SERVICE_CLASS = AshaService
-    read_only_properties_characteristic: gatt_client.CharacteristicProxy
-    audio_control_point_characteristic: gatt_client.CharacteristicProxy
-    audio_status_point_characteristic: gatt_client.CharacteristicProxy
-    volume_characteristic: gatt_client.CharacteristicProxy
-    psm_characteristic: gatt_client.CharacteristicProxy
-
-    def __init__(self, service_proxy: gatt_client.ServiceProxy) -> None:
-        self.service_proxy = service_proxy
-
-        for uuid, attribute_name in (
-            (
-                gatt.GATT_ASHA_READ_ONLY_PROPERTIES_CHARACTERISTIC,
-                'read_only_properties_characteristic',
-            ),
-            (
-                gatt.GATT_ASHA_AUDIO_CONTROL_POINT_CHARACTERISTIC,
-                'audio_control_point_characteristic',
-            ),
-            (
-                gatt.GATT_ASHA_AUDIO_STATUS_CHARACTERISTIC,
-                'audio_status_point_characteristic',
-            ),
-            (
-                gatt.GATT_ASHA_VOLUME_CHARACTERISTIC,
-                'volume_characteristic',
-            ),
-            (
-                gatt.GATT_ASHA_LE_PSM_OUT_CHARACTERISTIC,
-                'psm_characteristic',
-            ),
-        ):
-            if not (
-                characteristics := self.service_proxy.get_characteristics_by_uuid(uuid)
-            ):
-                raise gatt.InvalidServiceError(f"Missing {uuid} Characteristic")
-            setattr(self, attribute_name, characteristics[0])

bumble/profiles/asha_service.py

@@ -0,0 +1,188 @@
+# Copyright 2021-2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import struct
+import logging
+from typing import List
+from ..core import AdvertisingData
+from ..device import Device, Connection
+from ..gatt import (
+    GATT_ASHA_SERVICE,
+    GATT_ASHA_READ_ONLY_PROPERTIES_CHARACTERISTIC,
+    GATT_ASHA_AUDIO_CONTROL_POINT_CHARACTERISTIC,
+    GATT_ASHA_AUDIO_STATUS_CHARACTERISTIC,
+    GATT_ASHA_VOLUME_CHARACTERISTIC,
+    GATT_ASHA_LE_PSM_OUT_CHARACTERISTIC,
+    TemplateService,
+    Characteristic,
+    CharacteristicValue,
+)
+from ..utils import AsyncRunner
+
+# -----------------------------------------------------------------------------
+# Logging
+# -----------------------------------------------------------------------------
+logger = logging.getLogger(__name__)
+
+
+# -----------------------------------------------------------------------------
+class AshaService(TemplateService):
+    UUID = GATT_ASHA_SERVICE
+    OPCODE_START = 1
+    OPCODE_STOP = 2
+    OPCODE_STATUS = 3
+    PROTOCOL_VERSION = 0x01
+    RESERVED_FOR_FUTURE_USE = [00, 00]
+    FEATURE_MAP = [0x01]  # [LE CoC audio output streaming supported]
+    SUPPORTED_CODEC_ID = [0x02, 0x01]  # Codec IDs [G.722 at 16 kHz]
+    RENDER_DELAY = [00, 00]
+
+    def __init__(self, capability: int, hisyncid: List[int], device: Device, psm=0):
+        self.hisyncid = hisyncid
+        self.capability = capability  # Device Capabilities [Left, Monaural]
+        self.device = device
+        self.audio_out_data = b''
+        self.psm = psm  # a non-zero psm is mainly for testing purpose
+
+        # Handler for volume control
+        def on_volume_write(connection, value):
+            logger.info(f'--- VOLUME Write:{value[0]}')
+            self.emit('volume', connection, value[0])
+
+        # Handler for audio control commands
+        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:
+                # Start
+                audio_type = ('Unknown', 'Ringtone', 'Phone Call', 'Media')[value[2]]
+                logger.info(
+                    f'### START: codec={value[1]}, '
+                    f'audio_type={audio_type}, '
+                    f'volume={value[3]}, '
+                    f'otherstate={value[4]}'
+                )
+                self.emit(
+                    'start',
+                    connection,
+                    {
+                        'codec': value[1],
+                        'audiotype': value[2],
+                        'volume': value[3],
+                        'otherstate': value[4],
+                    },
+                )
+            elif opcode == AshaService.OPCODE_STOP:
+                logger.info('### STOP')
+                self.emit('stop', connection)
+            elif opcode == AshaService.OPCODE_STATUS:
+                logger.info(f'### STATUS: connected={value[1]}')
+
+            # OPCODE_STATUS does not need audio status point update
+            if opcode != AshaService.OPCODE_STATUS:
+                AsyncRunner.spawn(
+                    device.notify_subscribers(
+                        self.audio_status_characteristic, force=True
+                    )
+                )
+
+        self.read_only_properties_characteristic = Characteristic(
+            GATT_ASHA_READ_ONLY_PROPERTIES_CHARACTERISTIC,
+            Characteristic.Properties.READ,
+            Characteristic.READABLE,
+            bytes(
+                [
+                    AshaService.PROTOCOL_VERSION,  # Version
+                    self.capability,
+                ]
+            )
+            + bytes(self.hisyncid)
+            + bytes(AshaService.FEATURE_MAP)
+            + bytes(AshaService.RENDER_DELAY)
+            + bytes(AshaService.RESERVED_FOR_FUTURE_USE)
+            + bytes(AshaService.SUPPORTED_CODEC_ID),
+        )
+
+        self.audio_control_point_characteristic = Characteristic(
+            GATT_ASHA_AUDIO_CONTROL_POINT_CHARACTERISTIC,
+            Characteristic.Properties.WRITE
+            | Characteristic.Properties.WRITE_WITHOUT_RESPONSE,
+            Characteristic.WRITEABLE,
+            CharacteristicValue(write=on_audio_control_point_write),
+        )
+        self.audio_status_characteristic = Characteristic(
+            GATT_ASHA_AUDIO_STATUS_CHARACTERISTIC,
+            Characteristic.Properties.READ | Characteristic.Properties.NOTIFY,
+            Characteristic.READABLE,
+            bytes([0]),
+        )
+        self.volume_characteristic = Characteristic(
+            GATT_ASHA_VOLUME_CHARACTERISTIC,
+            Characteristic.Properties.WRITE_WITHOUT_RESPONSE,
+            Characteristic.WRITEABLE,
+            CharacteristicValue(write=on_volume_write),
+        )
+
+        # Register an L2CAP CoC server
+        def on_coc(channel):
+            def on_data(data):
+                logging.debug(f'<<< data received:{data}')
+
+                self.emit('data', channel.connection, data)
+                self.audio_out_data += data
+
+            channel.sink = on_data
+
+        # let the server find a free 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,
+            Characteristic.READABLE,
+            struct.pack('<H', self.psm),
+        )
+
+        characteristics = [
+            self.read_only_properties_characteristic,
+            self.audio_control_point_characteristic,
+            self.audio_status_characteristic,
+            self.volume_characteristic,
+            self.le_psm_out_characteristic,
+        ]
+
+        super().__init__(characteristics)
+
+    def get_advertising_data(self):
+        # Advertisement only uses 4 least significant bytes of the HiSyncId.
+        return bytes(
+            AdvertisingData(
+                [
+                    (
+                        AdvertisingData.SERVICE_DATA_16_BIT_UUID,
+                        bytes(GATT_ASHA_SERVICE)
+                        + bytes(
+                            [
+                                AshaService.PROTOCOL_VERSION,
+                                self.capability,
+                            ]
+                        )
+                        + bytes(self.hisyncid[:4]),
+                    ),
+                ]
+            )
+        )

bumble/profiles/bap.py

@@ -1,548 +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 collections.abc import Sequence
-import dataclasses
-import enum
-import struct
-import functools
-import logging
-from typing import List
-from typing_extensions import Self
-
-from bumble import core
-from bumble import hci
-from bumble import gatt
-from bumble import utils
-from bumble.profiles import le_audio
-
-
-# -----------------------------------------------------------------------------
-# Logging
-# -----------------------------------------------------------------------------
-logger = logging.getLogger(__name__)
-
-# -----------------------------------------------------------------------------
-# Constants
-# -----------------------------------------------------------------------------
-
-
-class AudioLocation(enum.IntFlag):
-    '''Bluetooth Assigned Numbers, Section 6.12.1 - Audio Location'''
-
-    # fmt: off
-    NOT_ALLOWED             = 0x00000000
-    FRONT_LEFT              = 0x00000001
-    FRONT_RIGHT             = 0x00000002
-    FRONT_CENTER            = 0x00000004
-    LOW_FREQUENCY_EFFECTS_1 = 0x00000008
-    BACK_LEFT               = 0x00000010
-    BACK_RIGHT              = 0x00000020
-    FRONT_LEFT_OF_CENTER    = 0x00000040
-    FRONT_RIGHT_OF_CENTER   = 0x00000080
-    BACK_CENTER             = 0x00000100
-    LOW_FREQUENCY_EFFECTS_2 = 0x00000200
-    SIDE_LEFT               = 0x00000400
-    SIDE_RIGHT              = 0x00000800
-    TOP_FRONT_LEFT          = 0x00001000
-    TOP_FRONT_RIGHT         = 0x00002000
-    TOP_FRONT_CENTER        = 0x00004000
-    TOP_CENTER              = 0x00008000
-    TOP_BACK_LEFT           = 0x00010000
-    TOP_BACK_RIGHT          = 0x00020000
-    TOP_SIDE_LEFT           = 0x00040000
-    TOP_SIDE_RIGHT          = 0x00080000
-    TOP_BACK_CENTER         = 0x00100000
-    BOTTOM_FRONT_CENTER     = 0x00200000
-    BOTTOM_FRONT_LEFT       = 0x00400000
-    BOTTOM_FRONT_RIGHT      = 0x00800000
-    FRONT_LEFT_WIDE         = 0x01000000
-    FRONT_RIGHT_WIDE        = 0x02000000
-    LEFT_SURROUND           = 0x04000000
-    RIGHT_SURROUND          = 0x08000000
-
-    @property
-    def channel_count(self) -> int:
-        return bin(self.value).count('1')
-
-
-class AudioInputType(enum.IntEnum):
-    '''Bluetooth Assigned Numbers, Section 6.12.2 - Audio Input Type'''
-
-    # fmt: off
-    UNSPECIFIED = 0x00
-    BLUETOOTH   = 0x01
-    MICROPHONE  = 0x02
-    ANALOG      = 0x03
-    DIGITAL     = 0x04
-    RADIO       = 0x05
-    STREAMING   = 0x06
-    AMBIENT     = 0x07
-
-
-class ContextType(enum.IntFlag):
-    '''Bluetooth Assigned Numbers, Section 6.12.3 - Context Type'''
-
-    # fmt: off
-    PROHIBITED       = 0x0000
-    CONVERSATIONAL   = 0x0002
-    MEDIA            = 0x0004
-    GAME             = 0x0008
-    INSTRUCTIONAL    = 0x0010
-    VOICE_ASSISTANTS = 0x0020
-    LIVE             = 0x0040
-    SOUND_EFFECTS    = 0x0080
-    NOTIFICATIONS    = 0x0100
-    RINGTONE         = 0x0200
-    ALERTS           = 0x0400
-    EMERGENCY_ALARM  = 0x0800
-
-
-class SamplingFrequency(utils.OpenIntEnum):
-    '''Bluetooth Assigned Numbers, Section 6.12.5.1 - Sampling Frequency'''
-
-    # fmt: off
-    FREQ_8000    = 0x01
-    FREQ_11025   = 0x02
-    FREQ_16000   = 0x03
-    FREQ_22050   = 0x04
-    FREQ_24000   = 0x05
-    FREQ_32000   = 0x06
-    FREQ_44100   = 0x07
-    FREQ_48000   = 0x08
-    FREQ_88200   = 0x09
-    FREQ_96000   = 0x0A
-    FREQ_176400  = 0x0B
-    FREQ_192000  = 0x0C
-    FREQ_384000  = 0x0D
-    # fmt: on
-
-    @classmethod
-    def from_hz(cls, frequency: int) -> SamplingFrequency:
-        return {
-            8000: SamplingFrequency.FREQ_8000,
-            11025: SamplingFrequency.FREQ_11025,
-            16000: SamplingFrequency.FREQ_16000,
-            22050: SamplingFrequency.FREQ_22050,
-            24000: SamplingFrequency.FREQ_24000,
-            32000: SamplingFrequency.FREQ_32000,
-            44100: SamplingFrequency.FREQ_44100,
-            48000: SamplingFrequency.FREQ_48000,
-            88200: SamplingFrequency.FREQ_88200,
-            96000: SamplingFrequency.FREQ_96000,
-            176400: SamplingFrequency.FREQ_176400,
-            192000: SamplingFrequency.FREQ_192000,
-            384000: SamplingFrequency.FREQ_384000,
-        }[frequency]
-
-    @property
-    def hz(self) -> int:
-        return {
-            SamplingFrequency.FREQ_8000: 8000,
-            SamplingFrequency.FREQ_11025: 11025,
-            SamplingFrequency.FREQ_16000: 16000,
-            SamplingFrequency.FREQ_22050: 22050,
-            SamplingFrequency.FREQ_24000: 24000,
-            SamplingFrequency.FREQ_32000: 32000,
-            SamplingFrequency.FREQ_44100: 44100,
-            SamplingFrequency.FREQ_48000: 48000,
-            SamplingFrequency.FREQ_88200: 88200,
-            SamplingFrequency.FREQ_96000: 96000,
-            SamplingFrequency.FREQ_176400: 176400,
-            SamplingFrequency.FREQ_192000: 192000,
-            SamplingFrequency.FREQ_384000: 384000,
-        }[self]
-
-
-class SupportedSamplingFrequency(enum.IntFlag):
-    '''Bluetooth Assigned Numbers, Section 6.12.4.1 - Sample Frequency'''
-
-    # fmt: off
-    FREQ_8000    = 1 << (SamplingFrequency.FREQ_8000 - 1)
-    FREQ_11025   = 1 << (SamplingFrequency.FREQ_11025 - 1)
-    FREQ_16000   = 1 << (SamplingFrequency.FREQ_16000 - 1)
-    FREQ_22050   = 1 << (SamplingFrequency.FREQ_22050 - 1)
-    FREQ_24000   = 1 << (SamplingFrequency.FREQ_24000 - 1)
-    FREQ_32000   = 1 << (SamplingFrequency.FREQ_32000 - 1)
-    FREQ_44100   = 1 << (SamplingFrequency.FREQ_44100 - 1)
-    FREQ_48000   = 1 << (SamplingFrequency.FREQ_48000 - 1)
-    FREQ_88200   = 1 << (SamplingFrequency.FREQ_88200 - 1)
-    FREQ_96000   = 1 << (SamplingFrequency.FREQ_96000 - 1)
-    FREQ_176400  = 1 << (SamplingFrequency.FREQ_176400 - 1)
-    FREQ_192000  = 1 << (SamplingFrequency.FREQ_192000 - 1)
-    FREQ_384000  = 1 << (SamplingFrequency.FREQ_384000 - 1)
-    # fmt: on
-
-    @classmethod
-    def from_hz(cls, frequencies: Sequence[int]) -> SupportedSamplingFrequency:
-        MAPPING = {
-            8000: SupportedSamplingFrequency.FREQ_8000,
-            11025: SupportedSamplingFrequency.FREQ_11025,
-            16000: SupportedSamplingFrequency.FREQ_16000,
-            22050: SupportedSamplingFrequency.FREQ_22050,
-            24000: SupportedSamplingFrequency.FREQ_24000,
-            32000: SupportedSamplingFrequency.FREQ_32000,
-            44100: SupportedSamplingFrequency.FREQ_44100,
-            48000: SupportedSamplingFrequency.FREQ_48000,
-            88200: SupportedSamplingFrequency.FREQ_88200,
-            96000: SupportedSamplingFrequency.FREQ_96000,
-            176400: SupportedSamplingFrequency.FREQ_176400,
-            192000: SupportedSamplingFrequency.FREQ_192000,
-            384000: SupportedSamplingFrequency.FREQ_384000,
-        }
-
-        return functools.reduce(
-            lambda x, y: x | MAPPING[y],
-            frequencies,
-            cls(0),
-        )
-
-
-class FrameDuration(enum.IntEnum):
-    '''Bluetooth Assigned Numbers, Section 6.12.5.2 - Frame Duration'''
-
-    # fmt: off
-    DURATION_7500_US  = 0x00
-    DURATION_10000_US = 0x01
-
-    @property
-    def us(self) -> int:
-        return {
-            FrameDuration.DURATION_7500_US: 7500,
-            FrameDuration.DURATION_10000_US: 10000,
-        }[self]
-
-
-class SupportedFrameDuration(enum.IntFlag):
-    '''Bluetooth Assigned Numbers, Section 6.12.4.2 - Frame Duration'''
-
-    # fmt: off
-    DURATION_7500_US_SUPPORTED  = 0b0001
-    DURATION_10000_US_SUPPORTED = 0b0010
-    DURATION_7500_US_PREFERRED  = 0b0001
-    DURATION_10000_US_PREFERRED = 0b0010
-
-
-class AnnouncementType(utils.OpenIntEnum):
-    '''Basic Audio Profile, 3.5.3. Additional Audio Stream Control Service requirements'''
-
-    # fmt: off
-    GENERAL  = 0x00
-    TARGETED = 0x01
-
-
-@dataclasses.dataclass
-class UnicastServerAdvertisingData:
-    """Advertising Data for ASCS."""
-
-    announcement_type: AnnouncementType = AnnouncementType.TARGETED
-    available_audio_contexts: ContextType = ContextType.MEDIA
-    metadata: bytes = b''
-
-    def __bytes__(self) -> bytes:
-        return bytes(
-            core.AdvertisingData(
-                [
-                    (
-                        core.AdvertisingData.SERVICE_DATA_16_BIT_UUID,
-                        struct.pack(
-                            '<2sBIB',
-                            gatt.GATT_AUDIO_STREAM_CONTROL_SERVICE.to_bytes(),
-                            self.announcement_type,
-                            self.available_audio_contexts,
-                            len(self.metadata),
-                        )
-                        + self.metadata,
-                    )
-                ]
-            )
-        )
-
-
-# -----------------------------------------------------------------------------
-# Utils
-# -----------------------------------------------------------------------------
-
-
-def bits_to_channel_counts(data: int) -> List[int]:
-    pos = 0
-    counts = []
-    while data != 0:
-        # Bit 0 = count 1
-        # Bit 1 = count 2, and so on
-        pos += 1
-        if data & 1:
-            counts.append(pos)
-        data >>= 1
-    return counts
-
-
-def channel_counts_to_bits(counts: Sequence[int]) -> int:
-    return sum(set([1 << (count - 1) for count in counts]))
-
-
-# -----------------------------------------------------------------------------
-# Structures
-# -----------------------------------------------------------------------------
-
-
-@dataclasses.dataclass
-class CodecSpecificCapabilities:
-    '''See:
-    * Bluetooth Assigned Numbers, 6.12.4 - Codec Specific Capabilities LTV Structures
-    * Basic Audio Profile, 4.3.1 - Codec_Specific_Capabilities LTV requirements
-    '''
-
-    class Type(enum.IntEnum):
-        # fmt: off
-        SAMPLING_FREQUENCY   = 0x01
-        FRAME_DURATION       = 0x02
-        AUDIO_CHANNEL_COUNT  = 0x03
-        OCTETS_PER_FRAME     = 0x04
-        CODEC_FRAMES_PER_SDU = 0x05
-
-    supported_sampling_frequencies: SupportedSamplingFrequency
-    supported_frame_durations: SupportedFrameDuration
-    supported_audio_channel_count: Sequence[int]
-    min_octets_per_codec_frame: int
-    max_octets_per_codec_frame: int
-    supported_max_codec_frames_per_sdu: int
-
-    @classmethod
-    def from_bytes(cls, data: bytes) -> CodecSpecificCapabilities:
-        offset = 0
-        # Allowed default values.
-        supported_audio_channel_count = [1]
-        supported_max_codec_frames_per_sdu = 1
-        while offset < len(data):
-            length, type = struct.unpack_from('BB', data, offset)
-            offset += 2
-            value = int.from_bytes(data[offset : offset + length - 1], 'little')
-            offset += length - 1
-
-            if type == CodecSpecificCapabilities.Type.SAMPLING_FREQUENCY:
-                supported_sampling_frequencies = SupportedSamplingFrequency(value)
-            elif type == CodecSpecificCapabilities.Type.FRAME_DURATION:
-                supported_frame_durations = SupportedFrameDuration(value)
-            elif type == CodecSpecificCapabilities.Type.AUDIO_CHANNEL_COUNT:
-                supported_audio_channel_count = bits_to_channel_counts(value)
-            elif type == CodecSpecificCapabilities.Type.OCTETS_PER_FRAME:
-                min_octets_per_sample = value & 0xFFFF
-                max_octets_per_sample = value >> 16
-            elif type == CodecSpecificCapabilities.Type.CODEC_FRAMES_PER_SDU:
-                supported_max_codec_frames_per_sdu = value
-
-        # It is expected here that if some fields are missing, an error should be raised.
-        return CodecSpecificCapabilities(
-            supported_sampling_frequencies=supported_sampling_frequencies,
-            supported_frame_durations=supported_frame_durations,
-            supported_audio_channel_count=supported_audio_channel_count,
-            min_octets_per_codec_frame=min_octets_per_sample,
-            max_octets_per_codec_frame=max_octets_per_sample,
-            supported_max_codec_frames_per_sdu=supported_max_codec_frames_per_sdu,
-        )
-
-    def __bytes__(self) -> bytes:
-        return struct.pack(
-            '<BBHBBBBBBBBHHBBB',
-            3,
-            CodecSpecificCapabilities.Type.SAMPLING_FREQUENCY,
-            self.supported_sampling_frequencies,
-            2,
-            CodecSpecificCapabilities.Type.FRAME_DURATION,
-            self.supported_frame_durations,
-            2,
-            CodecSpecificCapabilities.Type.AUDIO_CHANNEL_COUNT,
-            channel_counts_to_bits(self.supported_audio_channel_count),
-            5,
-            CodecSpecificCapabilities.Type.OCTETS_PER_FRAME,
-            self.min_octets_per_codec_frame,
-            self.max_octets_per_codec_frame,
-            2,
-            CodecSpecificCapabilities.Type.CODEC_FRAMES_PER_SDU,
-            self.supported_max_codec_frames_per_sdu,
-        )
-
-
-@dataclasses.dataclass
-class CodecSpecificConfiguration:
-    '''See:
-    * Bluetooth Assigned Numbers, 6.12.5 - Codec Specific Configuration LTV Structures
-    * Basic Audio Profile, 4.3.2 - Codec_Specific_Capabilities LTV requirements
-    '''
-
-    class Type(utils.OpenIntEnum):
-        # fmt: off
-        SAMPLING_FREQUENCY       = 0x01
-        FRAME_DURATION           = 0x02
-        AUDIO_CHANNEL_ALLOCATION = 0x03
-        OCTETS_PER_FRAME         = 0x04
-        CODEC_FRAMES_PER_SDU     = 0x05
-
-    sampling_frequency: SamplingFrequency
-    frame_duration: FrameDuration
-    audio_channel_allocation: AudioLocation
-    octets_per_codec_frame: int
-    codec_frames_per_sdu: int
-
-    @classmethod
-    def from_bytes(cls, data: bytes) -> CodecSpecificConfiguration:
-        offset = 0
-        # Allowed default values.
-        audio_channel_allocation = AudioLocation.NOT_ALLOWED
-        codec_frames_per_sdu = 1
-        while offset < len(data):
-            length, type = struct.unpack_from('BB', data, offset)
-            offset += 2
-            value = int.from_bytes(data[offset : offset + length - 1], 'little')
-            offset += length - 1
-
-            if type == CodecSpecificConfiguration.Type.SAMPLING_FREQUENCY:
-                sampling_frequency = SamplingFrequency(value)
-            elif type == CodecSpecificConfiguration.Type.FRAME_DURATION:
-                frame_duration = FrameDuration(value)
-            elif type == CodecSpecificConfiguration.Type.AUDIO_CHANNEL_ALLOCATION:
-                audio_channel_allocation = AudioLocation(value)
-            elif type == CodecSpecificConfiguration.Type.OCTETS_PER_FRAME:
-                octets_per_codec_frame = value
-            elif type == CodecSpecificConfiguration.Type.CODEC_FRAMES_PER_SDU:
-                codec_frames_per_sdu = value
-
-        # It is expected here that if some fields are missing, an error should be raised.
-        return CodecSpecificConfiguration(
-            sampling_frequency=sampling_frequency,
-            frame_duration=frame_duration,
-            audio_channel_allocation=audio_channel_allocation,
-            octets_per_codec_frame=octets_per_codec_frame,
-            codec_frames_per_sdu=codec_frames_per_sdu,
-        )
-
-    def __bytes__(self) -> bytes:
-        return struct.pack(
-            '<BBBBBBBBIBBHBBB',
-            2,
-            CodecSpecificConfiguration.Type.SAMPLING_FREQUENCY,
-            self.sampling_frequency,
-            2,
-            CodecSpecificConfiguration.Type.FRAME_DURATION,
-            self.frame_duration,
-            5,
-            CodecSpecificConfiguration.Type.AUDIO_CHANNEL_ALLOCATION,
-            self.audio_channel_allocation,
-            3,
-            CodecSpecificConfiguration.Type.OCTETS_PER_FRAME,
-            self.octets_per_codec_frame,
-            2,
-            CodecSpecificConfiguration.Type.CODEC_FRAMES_PER_SDU,
-            self.codec_frames_per_sdu,
-        )
-
-
-@dataclasses.dataclass
-class BroadcastAudioAnnouncement:
-    broadcast_id: int
-
-    @classmethod
-    def from_bytes(cls, data: bytes) -> Self:
-        return cls(int.from_bytes(data[:3], 'little'))
-
-
-@dataclasses.dataclass
-class BasicAudioAnnouncement:
-    @dataclasses.dataclass
-    class BIS:
-        index: int
-        codec_specific_configuration: CodecSpecificConfiguration
-
-    @dataclasses.dataclass
-    class CodecInfo:
-        coding_format: hci.CodecID
-        company_id: int
-        vendor_specific_codec_id: int
-
-        @classmethod
-        def from_bytes(cls, data: bytes) -> Self:
-            coding_format = hci.CodecID(data[0])
-            company_id = int.from_bytes(data[1:3], 'little')
-            vendor_specific_codec_id = int.from_bytes(data[3:5], 'little')
-            return cls(coding_format, company_id, vendor_specific_codec_id)
-
-    @dataclasses.dataclass
-    class Subgroup:
-        codec_id: BasicAudioAnnouncement.CodecInfo
-        codec_specific_configuration: CodecSpecificConfiguration
-        metadata: le_audio.Metadata
-        bis: List[BasicAudioAnnouncement.BIS]
-
-    presentation_delay: int
-    subgroups: List[BasicAudioAnnouncement.Subgroup]
-
-    @classmethod
-    def from_bytes(cls, data: bytes) -> Self:
-        presentation_delay = int.from_bytes(data[:3], 'little')
-        subgroups = []
-        offset = 4
-        for _ in range(data[3]):
-            num_bis = data[offset]
-            offset += 1
-            codec_id = cls.CodecInfo.from_bytes(data[offset : offset + 5])
-            offset += 5
-            codec_specific_configuration_length = data[offset]
-            offset += 1
-            codec_specific_configuration = data[
-                offset : offset + codec_specific_configuration_length
-            ]
-            offset += codec_specific_configuration_length
-            metadata_length = data[offset]
-            offset += 1
-            metadata = le_audio.Metadata.from_bytes(
-                data[offset : offset + metadata_length]
-            )
-            offset += metadata_length
-
-            bis = []
-            for _ in range(num_bis):
-                bis_index = data[offset]
-                offset += 1
-                bis_codec_specific_configuration_length = data[offset]
-                offset += 1
-                bis_codec_specific_configuration = data[
-                    offset : offset + bis_codec_specific_configuration_length
-                ]
-                offset += bis_codec_specific_configuration_length
-                bis.append(
-                    cls.BIS(
-                        bis_index,
-                        CodecSpecificConfiguration.from_bytes(
-                            bis_codec_specific_configuration
-                        ),
-                    )
-                )
-
-            subgroups.append(
-                cls.Subgroup(
-                    codec_id,
-                    CodecSpecificConfiguration.from_bytes(codec_specific_configuration),
-                    metadata,
-                    bis,
-                )
-            )
-
-        return cls(presentation_delay, subgroups)

bumble/profiles/bass.py

@@ -1,440 +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
-
-"""LE Audio - Broadcast Audio Scan Service"""
-
-# -----------------------------------------------------------------------------
-# Imports
-# -----------------------------------------------------------------------------
-from __future__ import annotations
-import dataclasses
-import logging
-import struct
-from typing import ClassVar, List, Optional, Sequence
-
-from bumble import core
-from bumble import device
-from bumble import gatt
-from bumble import gatt_client
-from bumble import hci
-from bumble import utils
-
-# -----------------------------------------------------------------------------
-# Logging
-# -----------------------------------------------------------------------------
-logger = logging.getLogger(__name__)
-
-
-# -----------------------------------------------------------------------------
-# Constants
-# -----------------------------------------------------------------------------
-class ApplicationError(utils.OpenIntEnum):
-    OPCODE_NOT_SUPPORTED = 0x80
-    INVALID_SOURCE_ID = 0x81
-
-
-# -----------------------------------------------------------------------------
-def encode_subgroups(subgroups: Sequence[SubgroupInfo]) -> bytes:
-    return bytes([len(subgroups)]) + b"".join(
-        struct.pack("<IB", subgroup.bis_sync, len(subgroup.metadata))
-        + subgroup.metadata
-        for subgroup in subgroups
-    )
-
-
-def decode_subgroups(data: bytes) -> List[SubgroupInfo]:
-    num_subgroups = data[0]
-    offset = 1
-    subgroups = []
-    for _ in range(num_subgroups):
-        bis_sync = struct.unpack("<I", data[offset : offset + 4])[0]
-        metadata_length = data[offset + 4]
-        metadata = data[offset + 5 : offset + 5 + metadata_length]
-        offset += 5 + metadata_length
-        subgroups.append(SubgroupInfo(bis_sync, metadata))
-
-    return subgroups
-
-
-# -----------------------------------------------------------------------------
-class PeriodicAdvertisingSyncParams(utils.OpenIntEnum):
-    DO_NOT_SYNCHRONIZE_TO_PA = 0x00
-    SYNCHRONIZE_TO_PA_PAST_AVAILABLE = 0x01
-    SYNCHRONIZE_TO_PA_PAST_NOT_AVAILABLE = 0x02
-
-
-@dataclasses.dataclass
-class SubgroupInfo:
-    ANY_BIS: ClassVar[int] = 0xFFFFFFFF
-
-    bis_sync: int
-    metadata: bytes
-
-
-class ControlPointOperation:
-    class OpCode(utils.OpenIntEnum):
-        REMOTE_SCAN_STOPPED = 0x00
-        REMOTE_SCAN_STARTED = 0x01
-        ADD_SOURCE = 0x02
-        MODIFY_SOURCE = 0x03
-        SET_BROADCAST_CODE = 0x04
-        REMOVE_SOURCE = 0x05
-
-    op_code: OpCode
-    parameters: bytes
-
-    @classmethod
-    def from_bytes(cls, data: bytes) -> ControlPointOperation:
-        op_code = data[0]
-
-        if op_code == cls.OpCode.REMOTE_SCAN_STOPPED:
-            return RemoteScanStoppedOperation()
-
-        if op_code == cls.OpCode.REMOTE_SCAN_STARTED:
-            return RemoteScanStartedOperation()
-
-        if op_code == cls.OpCode.ADD_SOURCE:
-            return AddSourceOperation.from_parameters(data[1:])
-
-        if op_code == cls.OpCode.MODIFY_SOURCE:
-            return ModifySourceOperation.from_parameters(data[1:])
-
-        if op_code == cls.OpCode.SET_BROADCAST_CODE:
-            return SetBroadcastCodeOperation.from_parameters(data[1:])
-
-        if op_code == cls.OpCode.REMOVE_SOURCE:
-            return RemoveSourceOperation.from_parameters(data[1:])
-
-        raise core.InvalidArgumentError("invalid op code")
-
-    def __init__(self, op_code: OpCode, parameters: bytes = b"") -> None:
-        self.op_code = op_code
-        self.parameters = parameters
-
-    def __bytes__(self) -> bytes:
-        return bytes([self.op_code]) + self.parameters
-
-
-class RemoteScanStoppedOperation(ControlPointOperation):
-    def __init__(self) -> None:
-        super().__init__(ControlPointOperation.OpCode.REMOTE_SCAN_STOPPED)
-
-
-class RemoteScanStartedOperation(ControlPointOperation):
-    def __init__(self) -> None:
-        super().__init__(ControlPointOperation.OpCode.REMOTE_SCAN_STARTED)
-
-
-class AddSourceOperation(ControlPointOperation):
-    @classmethod
-    def from_parameters(cls, parameters: bytes) -> AddSourceOperation:
-        instance = cls.__new__(cls)
-        instance.op_code = ControlPointOperation.OpCode.ADD_SOURCE
-        instance.parameters = parameters
-        instance.advertiser_address = hci.Address.parse_address_preceded_by_type(
-            parameters, 1
-        )[1]
-        instance.advertising_sid = parameters[7]
-        instance.broadcast_id = int.from_bytes(parameters[8:11], "little")
-        instance.pa_sync = PeriodicAdvertisingSyncParams(parameters[11])
-        instance.pa_interval = struct.unpack("<H", parameters[12:14])[0]
-        instance.subgroups = decode_subgroups(parameters[14:])
-        return instance
-
-    def __init__(
-        self,
-        advertiser_address: hci.Address,
-        advertising_sid: int,
-        broadcast_id: int,
-        pa_sync: PeriodicAdvertisingSyncParams,
-        pa_interval: int,
-        subgroups: Sequence[SubgroupInfo],
-    ) -> None:
-        super().__init__(
-            ControlPointOperation.OpCode.ADD_SOURCE,
-            struct.pack(
-                "<B6sB3sBH",
-                advertiser_address.address_type,
-                bytes(advertiser_address),
-                advertising_sid,
-                broadcast_id.to_bytes(3, "little"),
-                pa_sync,
-                pa_interval,
-            )
-            + encode_subgroups(subgroups),
-        )
-        self.advertiser_address = advertiser_address
-        self.advertising_sid = advertising_sid
-        self.broadcast_id = broadcast_id
-        self.pa_sync = pa_sync
-        self.pa_interval = pa_interval
-        self.subgroups = list(subgroups)
-
-
-class ModifySourceOperation(ControlPointOperation):
-    @classmethod
-    def from_parameters(cls, parameters: bytes) -> ModifySourceOperation:
-        instance = cls.__new__(cls)
-        instance.op_code = ControlPointOperation.OpCode.MODIFY_SOURCE
-        instance.parameters = parameters
-        instance.source_id = parameters[0]
-        instance.pa_sync = PeriodicAdvertisingSyncParams(parameters[1])
-        instance.pa_interval = struct.unpack("<H", parameters[2:4])[0]
-        instance.subgroups = decode_subgroups(parameters[4:])
-        return instance
-
-    def __init__(
-        self,
-        source_id: int,
-        pa_sync: PeriodicAdvertisingSyncParams,
-        pa_interval: int,
-        subgroups: Sequence[SubgroupInfo],
-    ) -> None:
-        super().__init__(
-            ControlPointOperation.OpCode.MODIFY_SOURCE,
-            struct.pack("<BBH", source_id, pa_sync, pa_interval)
-            + encode_subgroups(subgroups),
-        )
-        self.source_id = source_id
-        self.pa_sync = pa_sync
-        self.pa_interval = pa_interval
-        self.subgroups = list(subgroups)
-
-
-class SetBroadcastCodeOperation(ControlPointOperation):
-    @classmethod
-    def from_parameters(cls, parameters: bytes) -> SetBroadcastCodeOperation:
-        instance = cls.__new__(cls)
-        instance.op_code = ControlPointOperation.OpCode.SET_BROADCAST_CODE
-        instance.parameters = parameters
-        instance.source_id = parameters[0]
-        instance.broadcast_code = parameters[1:17]
-        return instance
-
-    def __init__(
-        self,
-        source_id: int,
-        broadcast_code: bytes,
-    ) -> None:
-        super().__init__(
-            ControlPointOperation.OpCode.SET_BROADCAST_CODE,
-            bytes([source_id]) + broadcast_code,
-        )
-        self.source_id = source_id
-        self.broadcast_code = broadcast_code
-
-        if len(self.broadcast_code) != 16:
-            raise core.InvalidArgumentError("broadcast_code must be 16 bytes")
-
-
-class RemoveSourceOperation(ControlPointOperation):
-    @classmethod
-    def from_parameters(cls, parameters: bytes) -> RemoveSourceOperation:
-        instance = cls.__new__(cls)
-        instance.op_code = ControlPointOperation.OpCode.REMOVE_SOURCE
-        instance.parameters = parameters
-        instance.source_id = parameters[0]
-        return instance
-
-    def __init__(self, source_id: int) -> None:
-        super().__init__(ControlPointOperation.OpCode.REMOVE_SOURCE, bytes([source_id]))
-        self.source_id = source_id
-
-
-@dataclasses.dataclass
-class BroadcastReceiveState:
-    class PeriodicAdvertisingSyncState(utils.OpenIntEnum):
-        NOT_SYNCHRONIZED_TO_PA = 0x00
-        SYNCINFO_REQUEST = 0x01
-        SYNCHRONIZED_TO_PA = 0x02
-        FAILED_TO_SYNCHRONIZE_TO_PA = 0x03
-        NO_PAST = 0x04
-
-    class BigEncryption(utils.OpenIntEnum):
-        NOT_ENCRYPTED = 0x00
-        BROADCAST_CODE_REQUIRED = 0x01
-        DECRYPTING = 0x02
-        BAD_CODE = 0x03
-
-    source_id: int
-    source_address: hci.Address
-    source_adv_sid: int
-    broadcast_id: int
-    pa_sync_state: PeriodicAdvertisingSyncState
-    big_encryption: BigEncryption
-    bad_code: bytes
-    subgroups: List[SubgroupInfo]
-
-    @classmethod
-    def from_bytes(cls, data: bytes) -> Optional[BroadcastReceiveState]:
-        if not data:
-            return None
-
-        source_id = data[0]
-        _, source_address = hci.Address.parse_address_preceded_by_type(data, 2)
-        source_adv_sid = data[8]
-        broadcast_id = int.from_bytes(data[9:12], "little")
-        pa_sync_state = cls.PeriodicAdvertisingSyncState(data[12])
-        big_encryption = cls.BigEncryption(data[13])
-        if big_encryption == cls.BigEncryption.BAD_CODE:
-            bad_code = data[14:30]
-            subgroups = decode_subgroups(data[30:])
-        else:
-            bad_code = b""
-            subgroups = decode_subgroups(data[14:])
-
-        return cls(
-            source_id,
-            source_address,
-            source_adv_sid,
-            broadcast_id,
-            pa_sync_state,
-            big_encryption,
-            bad_code,
-            subgroups,
-        )
-
-    def __bytes__(self) -> bytes:
-        return (
-            struct.pack(
-                "<BB6sB3sBB",
-                self.source_id,
-                self.source_address.address_type,
-                bytes(self.source_address),
-                self.source_adv_sid,
-                self.broadcast_id.to_bytes(3, "little"),
-                self.pa_sync_state,
-                self.big_encryption,
-            )
-            + self.bad_code
-            + encode_subgroups(self.subgroups)
-        )
-
-
-# -----------------------------------------------------------------------------
-class BroadcastAudioScanService(gatt.TemplateService):
-    UUID = gatt.GATT_BROADCAST_AUDIO_SCAN_SERVICE
-
-    def __init__(self):
-        self.broadcast_audio_scan_control_point_characteristic = gatt.Characteristic(
-            gatt.GATT_BROADCAST_AUDIO_SCAN_CONTROL_POINT_CHARACTERISTIC,
-            gatt.Characteristic.Properties.WRITE
-            | gatt.Characteristic.Properties.WRITE_WITHOUT_RESPONSE,
-            gatt.Characteristic.WRITEABLE,
-            gatt.CharacteristicValue(
-                write=self.on_broadcast_audio_scan_control_point_write
-            ),
-        )
-
-        self.broadcast_receive_state_characteristic = gatt.Characteristic(
-            gatt.GATT_BROADCAST_RECEIVE_STATE_CHARACTERISTIC,
-            gatt.Characteristic.Properties.READ | gatt.Characteristic.Properties.NOTIFY,
-            gatt.Characteristic.Permissions.READABLE
-            | gatt.Characteristic.Permissions.READ_REQUIRES_ENCRYPTION,
-            b"12",  # TEST
-        )
-
-        super().__init__([self.battery_level_characteristic])
-
-    def on_broadcast_audio_scan_control_point_write(
-        self, connection: device.Connection, value: bytes
-    ) -> None:
-        pass
-
-
-# -----------------------------------------------------------------------------
-class BroadcastAudioScanServiceProxy(gatt_client.ProfileServiceProxy):
-    SERVICE_CLASS = BroadcastAudioScanService
-
-    broadcast_audio_scan_control_point: gatt_client.CharacteristicProxy
-    broadcast_receive_states: List[gatt.DelegatedCharacteristicAdapter]
-
-    def __init__(self, service_proxy: gatt_client.ServiceProxy):
-        self.service_proxy = service_proxy
-
-        if not (
-            characteristics := service_proxy.get_characteristics_by_uuid(
-                gatt.GATT_BROADCAST_AUDIO_SCAN_CONTROL_POINT_CHARACTERISTIC
-            )
-        ):
-            raise gatt.InvalidServiceError(
-                "Broadcast Audio Scan Control Point characteristic not found"
-            )
-        self.broadcast_audio_scan_control_point = characteristics[0]
-
-        if not (
-            characteristics := service_proxy.get_characteristics_by_uuid(
-                gatt.GATT_BROADCAST_RECEIVE_STATE_CHARACTERISTIC
-            )
-        ):
-            raise gatt.InvalidServiceError(
-                "Broadcast Receive State characteristic not found"
-            )
-        self.broadcast_receive_states = [
-            gatt.DelegatedCharacteristicAdapter(
-                characteristic, decode=BroadcastReceiveState.from_bytes
-            )
-            for characteristic in characteristics
-        ]
-
-    async def send_control_point_operation(
-        self, operation: ControlPointOperation
-    ) -> None:
-        await self.broadcast_audio_scan_control_point.write_value(
-            bytes(operation), with_response=True
-        )
-
-    async def remote_scan_started(self) -> None:
-        await self.send_control_point_operation(RemoteScanStartedOperation())
-
-    async def remote_scan_stopped(self) -> None:
-        await self.send_control_point_operation(RemoteScanStoppedOperation())
-
-    async def add_source(
-        self,
-        advertiser_address: hci.Address,
-        advertising_sid: int,
-        broadcast_id: int,
-        pa_sync: PeriodicAdvertisingSyncParams,
-        pa_interval: int,
-        subgroups: Sequence[SubgroupInfo],
-    ) -> None:
-        await self.send_control_point_operation(
-            AddSourceOperation(
-                advertiser_address,
-                advertising_sid,
-                broadcast_id,
-                pa_sync,
-                pa_interval,
-                subgroups,
-            )
-        )
-
-    async def modify_source(
-        self,
-        source_id: int,
-        pa_sync: PeriodicAdvertisingSyncParams,
-        pa_interval: int,
-        subgroups: Sequence[SubgroupInfo],
-    ) -> None:
-        await self.send_control_point_operation(
-            ModifySourceOperation(
-                source_id,
-                pa_sync,
-                pa_interval,
-                subgroups,
-            )
-        )
-
-    async def remove_source(self, source_id: int) -> None:
-        await self.send_control_point_operation(RemoveSourceOperation(source_id))

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 core.InvalidArgumentError(
-                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 core.InvalidOperationError('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 core.InvalidPacketError('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 core.InvalidOperationError('LTK or LinkKey is not present')
-
-            sirk = sef(key, response[1:])
-
-        return (sirk_type, sirk)

bumble/profiles/device_information_service.py

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

bumble/profiles/gap.py

@@ -1,110 +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.
-
-"""Generic Access Profile"""
-
-# -----------------------------------------------------------------------------
-# Imports
-# -----------------------------------------------------------------------------
-import logging
-import struct
-from typing import Optional, Tuple, Union
-
-from bumble.core import Appearance
-from bumble.gatt import (
-    TemplateService,
-    Characteristic,
-    CharacteristicAdapter,
-    DelegatedCharacteristicAdapter,
-    UTF8CharacteristicAdapter,
-    GATT_GENERIC_ACCESS_SERVICE,
-    GATT_DEVICE_NAME_CHARACTERISTIC,
-    GATT_APPEARANCE_CHARACTERISTIC,
-)
-from bumble.gatt_client import ProfileServiceProxy, ServiceProxy
-
-# -----------------------------------------------------------------------------
-# Logging
-# -----------------------------------------------------------------------------
-logger = logging.getLogger(__name__)
-
-
-# -----------------------------------------------------------------------------
-# Classes
-# -----------------------------------------------------------------------------
-
-
-# -----------------------------------------------------------------------------
-class GenericAccessService(TemplateService):
-    UUID = GATT_GENERIC_ACCESS_SERVICE
-
-    def __init__(
-        self, device_name: str, appearance: Union[Appearance, Tuple[int, int], int] = 0
-    ):
-        if isinstance(appearance, int):
-            appearance_int = appearance
-        elif isinstance(appearance, tuple):
-            appearance_int = (appearance[0] << 6) | appearance[1]
-        elif isinstance(appearance, Appearance):
-            appearance_int = int(appearance)
-        else:
-            raise TypeError()
-
-        self.device_name_characteristic = Characteristic(
-            GATT_DEVICE_NAME_CHARACTERISTIC,
-            Characteristic.Properties.READ,
-            Characteristic.READABLE,
-            device_name.encode('utf-8')[:248],
-        )
-
-        self.appearance_characteristic = Characteristic(
-            GATT_APPEARANCE_CHARACTERISTIC,
-            Characteristic.Properties.READ,
-            Characteristic.READABLE,
-            struct.pack('<H', appearance_int),
-        )
-
-        super().__init__(
-            [self.device_name_characteristic, self.appearance_characteristic]
-        )
-
-
-# -----------------------------------------------------------------------------
-class GenericAccessServiceProxy(ProfileServiceProxy):
-    SERVICE_CLASS = GenericAccessService
-
-    device_name: Optional[CharacteristicAdapter]
-    appearance: Optional[DelegatedCharacteristicAdapter]
-
-    def __init__(self, service_proxy: ServiceProxy):
-        self.service_proxy = service_proxy
-
-        if characteristics := service_proxy.get_characteristics_by_uuid(
-            GATT_DEVICE_NAME_CHARACTERISTIC
-        ):
-            self.device_name = UTF8CharacteristicAdapter(characteristics[0])
-        else:
-            self.device_name = None
-
-        if characteristics := service_proxy.get_characteristics_by_uuid(
-            GATT_APPEARANCE_CHARACTERISTIC
-        ):
-            self.appearance = DelegatedCharacteristicAdapter(
-                characteristics[0],
-                decode=lambda value: Appearance.from_int(
-                    struct.unpack_from('<H', value, 0)[0],
-                ),
-            )
-        else:
-            self.appearance = None

bumble/profiles/hap.py

@@ -1,674 +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
-# -----------------------------------------------------------------------------
-from __future__ import annotations
-import asyncio
-import functools
-from bumble import att, gatt, gatt_client
-from bumble.core import InvalidArgumentError, InvalidStateError
-from bumble.device import Device, Connection
-from bumble.utils import AsyncRunner, OpenIntEnum
-from bumble.hci import Address
-from dataclasses import dataclass, field
-import logging
-from typing import Any, Dict, List, Optional, Set, Union
-
-
-# -----------------------------------------------------------------------------
-# Constants
-# -----------------------------------------------------------------------------
-class ErrorCode(OpenIntEnum):
-    '''See Hearing Access Service 2.4. Attribute Profile error codes.'''
-
-    INVALID_OPCODE = 0x80
-    WRITE_NAME_NOT_ALLOWED = 0x81
-    PRESET_SYNCHRONIZATION_NOT_SUPPORTED = 0x82
-    PRESET_OPERATION_NOT_POSSIBLE = 0x83
-    INVALID_PARAMETERS_LENGTH = 0x84
-
-
-class HearingAidType(OpenIntEnum):
-    '''See Hearing Access Service 3.1. Hearing Aid Features.'''
-
-    BINAURAL_HEARING_AID = 0b00
-    MONAURAL_HEARING_AID = 0b01
-    BANDED_HEARING_AID = 0b10
-
-
-class PresetSynchronizationSupport(OpenIntEnum):
-    '''See Hearing Access Service 3.1. Hearing Aid Features.'''
-
-    PRESET_SYNCHRONIZATION_IS_NOT_SUPPORTED = 0b0
-    PRESET_SYNCHRONIZATION_IS_SUPPORTED = 0b1
-
-
-class IndependentPresets(OpenIntEnum):
-    '''See Hearing Access Service 3.1. Hearing Aid Features.'''
-
-    IDENTICAL_PRESET_RECORD = 0b0
-    DIFFERENT_PRESET_RECORD = 0b1
-
-
-class DynamicPresets(OpenIntEnum):
-    '''See Hearing Access Service 3.1. Hearing Aid Features.'''
-
-    PRESET_RECORDS_DOES_NOT_CHANGE = 0b0
-    PRESET_RECORDS_MAY_CHANGE = 0b1
-
-
-class WritablePresetsSupport(OpenIntEnum):
-    '''See Hearing Access Service 3.1. Hearing Aid Features.'''
-
-    WRITABLE_PRESET_RECORDS_NOT_SUPPORTED = 0b0
-    WRITABLE_PRESET_RECORDS_SUPPORTED = 0b1
-
-
-class HearingAidPresetControlPointOpcode(OpenIntEnum):
-    '''See Hearing Access Service 3.3.1 Hearing Aid Preset Control Point operation requirements.'''
-
-    # fmt: off
-    READ_PRESETS_REQUEST                     = 0x01
-    READ_PRESET_RESPONSE                     = 0x02
-    PRESET_CHANGED                           = 0x03
-    WRITE_PRESET_NAME                        = 0x04
-    SET_ACTIVE_PRESET                        = 0x05
-    SET_NEXT_PRESET                          = 0x06
-    SET_PREVIOUS_PRESET                      = 0x07
-    SET_ACTIVE_PRESET_SYNCHRONIZED_LOCALLY   = 0x08
-    SET_NEXT_PRESET_SYNCHRONIZED_LOCALLY     = 0x09
-    SET_PREVIOUS_PRESET_SYNCHRONIZED_LOCALLY = 0x0A
-
-
-@dataclass
-class HearingAidFeatures:
-    '''See Hearing Access Service 3.1. Hearing Aid Features.'''
-
-    hearing_aid_type: HearingAidType
-    preset_synchronization_support: PresetSynchronizationSupport
-    independent_presets: IndependentPresets
-    dynamic_presets: DynamicPresets
-    writable_presets_support: WritablePresetsSupport
-
-    def __bytes__(self) -> bytes:
-        return bytes(
-            [
-                (self.hearing_aid_type << 0)
-                | (self.preset_synchronization_support << 2)
-                | (self.independent_presets << 3)
-                | (self.dynamic_presets << 4)
-                | (self.writable_presets_support << 5)
-            ]
-        )
-
-
-def HearingAidFeatures_from_bytes(data: int) -> HearingAidFeatures:
-    return HearingAidFeatures(
-        HearingAidType(data & 0b11),
-        PresetSynchronizationSupport(data >> 2 & 0b1),
-        IndependentPresets(data >> 3 & 0b1),
-        DynamicPresets(data >> 4 & 0b1),
-        WritablePresetsSupport(data >> 5 & 0b1),
-    )
-
-
-@dataclass
-class PresetChangedOperation:
-    '''See Hearing Access Service 3.2.2.2. Preset Changed operation.'''
-
-    class ChangeId(OpenIntEnum):
-        # fmt: off
-        GENERIC_UPDATE            = 0x00
-        PRESET_RECORD_DELETED     = 0x01
-        PRESET_RECORD_AVAILABLE   = 0x02
-        PRESET_RECORD_UNAVAILABLE = 0x03
-
-    @dataclass
-    class Generic:
-        prev_index: int
-        preset_record: PresetRecord
-
-        def __bytes__(self) -> bytes:
-            return bytes([self.prev_index]) + bytes(self.preset_record)
-
-    change_id: ChangeId
-    additional_parameters: Union[Generic, int]
-
-    def to_bytes(self, is_last: bool) -> bytes:
-        if isinstance(self.additional_parameters, PresetChangedOperation.Generic):
-            additional_parameters_bytes = bytes(self.additional_parameters)
-        else:
-            additional_parameters_bytes = bytes([self.additional_parameters])
-
-        return (
-            bytes(
-                [
-                    HearingAidPresetControlPointOpcode.PRESET_CHANGED,
-                    self.change_id,
-                    is_last,
-                ]
-            )
-            + additional_parameters_bytes
-        )
-
-
-class PresetChangedOperationDeleted(PresetChangedOperation):
-    def __init__(self, index) -> None:
-        self.change_id = PresetChangedOperation.ChangeId.PRESET_RECORD_DELETED
-        self.additional_parameters = index
-
-
-class PresetChangedOperationAvailable(PresetChangedOperation):
-    def __init__(self, index) -> None:
-        self.change_id = PresetChangedOperation.ChangeId.PRESET_RECORD_AVAILABLE
-        self.additional_parameters = index
-
-
-class PresetChangedOperationUnavailable(PresetChangedOperation):
-    def __init__(self, index) -> None:
-        self.change_id = PresetChangedOperation.ChangeId.PRESET_RECORD_UNAVAILABLE
-        self.additional_parameters = index
-
-
-@dataclass
-class PresetRecord:
-    '''See Hearing Access Service 2.8. Preset record.'''
-
-    @dataclass
-    class Property:
-        class Writable(OpenIntEnum):
-            CANNOT_BE_WRITTEN = 0b0
-            CAN_BE_WRITTEN = 0b1
-
-        class IsAvailable(OpenIntEnum):
-            IS_UNAVAILABLE = 0b0
-            IS_AVAILABLE = 0b1
-
-        writable: Writable = Writable.CAN_BE_WRITTEN
-        is_available: IsAvailable = IsAvailable.IS_AVAILABLE
-
-        def __bytes__(self) -> bytes:
-            return bytes([self.writable | (self.is_available << 1)])
-
-    index: int
-    name: str
-    properties: Property = field(default_factory=Property)
-
-    def __bytes__(self) -> bytes:
-        return bytes([self.index]) + bytes(self.properties) + self.name.encode('utf-8')
-
-    def is_available(self) -> bool:
-        return (
-            self.properties.is_available
-            == PresetRecord.Property.IsAvailable.IS_AVAILABLE
-        )
-
-
-# -----------------------------------------------------------------------------
-# Server
-# -----------------------------------------------------------------------------
-class HearingAccessService(gatt.TemplateService):
-    UUID = gatt.GATT_HEARING_ACCESS_SERVICE
-
-    hearing_aid_features_characteristic: gatt.Characteristic
-    hearing_aid_preset_control_point: gatt.Characteristic
-    active_preset_index_characteristic: gatt.Characteristic
-    active_preset_index: int
-    active_preset_index_per_device: Dict[Address, int]
-
-    device: Device
-
-    server_features: HearingAidFeatures
-    preset_records: Dict[int, PresetRecord]  # key is the preset index
-    read_presets_request_in_progress: bool
-
-    preset_changed_operations_history_per_device: Dict[
-        Address, List[PresetChangedOperation]
-    ]
-
-    # Keep an updated list of connected client to send notification to
-    currently_connected_clients: Set[Connection]
-
-    def __init__(
-        self, device: Device, features: HearingAidFeatures, presets: List[PresetRecord]
-    ) -> None:
-        self.active_preset_index_per_device = {}
-        self.read_presets_request_in_progress = False
-        self.preset_changed_operations_history_per_device = {}
-        self.currently_connected_clients = set()
-
-        self.device = device
-        self.server_features = features
-        if len(presets) < 1:
-            raise InvalidArgumentError(f'Invalid presets: {presets}')
-
-        self.preset_records = {}
-        for p in presets:
-            if len(p.name.encode()) < 1 or len(p.name.encode()) > 40:
-                raise InvalidArgumentError(f'Invalid name: {p.name}')
-
-            self.preset_records[p.index] = p
-
-        # associate the lowest index as the current active preset at startup
-        self.active_preset_index = sorted(self.preset_records.keys())[0]
-
-        @device.on('connection')  # type: ignore
-        def on_connection(connection: Connection) -> None:
-            @connection.on('disconnection')  # type: ignore
-            def on_disconnection(_reason) -> None:
-                self.currently_connected_clients.remove(connection)
-
-            @connection.on('pairing')  # type: ignore
-            def on_pairing(*_: Any) -> None:
-                self.on_incoming_paired_connection(connection)
-
-            if connection.peer_resolvable_address:
-                self.on_incoming_paired_connection(connection)
-
-        self.hearing_aid_features_characteristic = gatt.Characteristic(
-            uuid=gatt.GATT_HEARING_AID_FEATURES_CHARACTERISTIC,
-            properties=gatt.Characteristic.Properties.READ,
-            permissions=gatt.Characteristic.Permissions.READ_REQUIRES_ENCRYPTION,
-            value=bytes(self.server_features),
-        )
-        self.hearing_aid_preset_control_point = gatt.Characteristic(
-            uuid=gatt.GATT_HEARING_AID_PRESET_CONTROL_POINT_CHARACTERISTIC,
-            properties=(
-                gatt.Characteristic.Properties.WRITE
-                | gatt.Characteristic.Properties.INDICATE
-            ),
-            permissions=gatt.Characteristic.Permissions.WRITE_REQUIRES_ENCRYPTION,
-            value=gatt.CharacteristicValue(
-                write=self._on_write_hearing_aid_preset_control_point
-            ),
-        )
-        self.active_preset_index_characteristic = gatt.Characteristic(
-            uuid=gatt.GATT_ACTIVE_PRESET_INDEX_CHARACTERISTIC,
-            properties=(
-                gatt.Characteristic.Properties.READ
-                | gatt.Characteristic.Properties.NOTIFY
-            ),
-            permissions=gatt.Characteristic.Permissions.READ_REQUIRES_ENCRYPTION,
-            value=gatt.CharacteristicValue(read=self._on_read_active_preset_index),
-        )
-
-        super().__init__(
-            [
-                self.hearing_aid_features_characteristic,
-                self.hearing_aid_preset_control_point,
-                self.active_preset_index_characteristic,
-            ]
-        )
-
-    def on_incoming_paired_connection(self, connection: Connection):
-        '''Setup initial operations to handle a remote bonded HAP device'''
-        # TODO Should we filter on HAP device only ?
-        self.currently_connected_clients.add(connection)
-        if (
-            connection.peer_address
-            not in self.preset_changed_operations_history_per_device
-        ):
-            self.preset_changed_operations_history_per_device[
-                connection.peer_address
-            ] = []
-            return
-
-        async def on_connection_async() -> None:
-            # Send all the PresetChangedOperation that occur when not connected
-            await self._preset_changed_operation(connection)
-            # Update the active preset index if needed
-            await self.notify_active_preset_for_connection(connection)
-
-        connection.abort_on('disconnection', on_connection_async())
-
-    def _on_read_active_preset_index(
-        self, __connection__: Optional[Connection]
-    ) -> bytes:
-        return bytes([self.active_preset_index])
-
-    # TODO this need to be triggered when device is unbonded
-    def on_forget(self, addr: Address) -> None:
-        self.preset_changed_operations_history_per_device.pop(addr)
-
-    async def _on_write_hearing_aid_preset_control_point(
-        self, connection: Optional[Connection], value: bytes
-    ):
-        assert connection
-
-        opcode = HearingAidPresetControlPointOpcode(value[0])
-        handler = getattr(self, '_on_' + opcode.name.lower())
-        await handler(connection, value)
-
-    async def _on_read_presets_request(
-        self, connection: Optional[Connection], value: bytes
-    ):
-        assert connection
-        if connection.att_mtu < 49:  # 2.5. GATT sub-procedure requirements
-            logging.warning(f'HAS require MTU >= 49: {connection}')
-
-        if self.read_presets_request_in_progress:
-            raise att.ATT_Error(att.ErrorCode.PROCEDURE_ALREADY_IN_PROGRESS)
-        self.read_presets_request_in_progress = True
-
-        start_index = value[1]
-        if start_index == 0x00:
-            raise att.ATT_Error(att.ErrorCode.OUT_OF_RANGE)
-
-        num_presets = value[2]
-        if num_presets == 0x00:
-            raise att.ATT_Error(att.ErrorCode.OUT_OF_RANGE)
-
-        # Sending `num_presets` presets ordered by increasing index field, starting from start_index
-        presets = [
-            self.preset_records[key]
-            for key in sorted(self.preset_records.keys())
-            if self.preset_records[key].index >= start_index
-        ]
-        del presets[num_presets:]
-        if len(presets) == 0:
-            raise att.ATT_Error(att.ErrorCode.OUT_OF_RANGE)
-
-        AsyncRunner.spawn(self._read_preset_response(connection, presets))
-
-    async def _read_preset_response(
-        self, connection: Connection, presets: List[PresetRecord]
-    ):
-        # If the ATT bearer is terminated before all notifications or indications are sent, then the server shall consider the Read Presets Request operation aborted and shall not either continue or restart the operation when the client reconnects.
-        try:
-            for i, preset in enumerate(presets):
-                await connection.device.indicate_subscriber(
-                    connection,
-                    self.hearing_aid_preset_control_point,
-                    value=bytes(
-                        [
-                            HearingAidPresetControlPointOpcode.READ_PRESET_RESPONSE,
-                            i == len(presets) - 1,
-                        ]
-                    )
-                    + bytes(preset),
-                )
-
-        finally:
-            # indicate_subscriber can raise a TimeoutError, we need to gracefully terminate the operation
-            self.read_presets_request_in_progress = False
-
-    async def generic_update(self, op: PresetChangedOperation) -> None:
-        '''Server API to perform a generic update. It is the responsibility of the caller to modify the preset_records to match the PresetChangedOperation being sent'''
-        await self._notifyPresetOperations(op)
-
-    async def delete_preset(self, index: int) -> None:
-        '''Server API to delete a preset. It should not be the current active preset'''
-
-        if index == self.active_preset_index:
-            raise InvalidStateError('Cannot delete active preset')
-
-        del self.preset_records[index]
-        await self._notifyPresetOperations(PresetChangedOperationDeleted(index))
-
-    async def available_preset(self, index: int) -> None:
-        '''Server API to make a preset available'''
-
-        preset = self.preset_records[index]
-        preset.properties.is_available = PresetRecord.Property.IsAvailable.IS_AVAILABLE
-        await self._notifyPresetOperations(PresetChangedOperationAvailable(index))
-
-    async def unavailable_preset(self, index: int) -> None:
-        '''Server API to make a preset unavailable. It should not be the current active preset'''
-
-        if index == self.active_preset_index:
-            raise InvalidStateError('Cannot set active preset as unavailable')
-
-        preset = self.preset_records[index]
-        preset.properties.is_available = (
-            PresetRecord.Property.IsAvailable.IS_UNAVAILABLE
-        )
-        await self._notifyPresetOperations(PresetChangedOperationUnavailable(index))
-
-    async def _preset_changed_operation(self, connection: Connection) -> None:
-        '''Send all PresetChangedOperation saved for a given connection'''
-        op_list = self.preset_changed_operations_history_per_device.get(
-            connection.peer_address, []
-        )
-
-        # Notification will be sent in index order
-        def get_op_index(op: PresetChangedOperation) -> int:
-            if isinstance(op.additional_parameters, PresetChangedOperation.Generic):
-                return op.additional_parameters.prev_index
-            return op.additional_parameters
-
-        op_list.sort(key=get_op_index)
-        # If the ATT bearer is terminated before all notifications or indications are sent, then the server shall consider the Preset Changed operation aborted and shall continue the operation when the client reconnects.
-        while len(op_list) > 0:
-            try:
-                await connection.device.indicate_subscriber(
-                    connection,
-                    self.hearing_aid_preset_control_point,
-                    value=op_list[0].to_bytes(len(op_list) == 1),
-                )
-                # Remove item once sent, and keep the non sent item in the list
-                op_list.pop(0)
-            except TimeoutError:
-                break
-
-    async def _notifyPresetOperations(self, op: PresetChangedOperation) -> None:
-        for historyList in self.preset_changed_operations_history_per_device.values():
-            historyList.append(op)
-
-        for connection in self.currently_connected_clients:
-            await self._preset_changed_operation(connection)
-
-    async def _on_write_preset_name(
-        self, connection: Optional[Connection], value: bytes
-    ):
-        assert connection
-
-        if self.read_presets_request_in_progress:
-            raise att.ATT_Error(att.ErrorCode.PROCEDURE_ALREADY_IN_PROGRESS)
-
-        index = value[1]
-        preset = self.preset_records.get(index, None)
-        if (
-            not preset
-            or preset.properties.writable
-            == PresetRecord.Property.Writable.CANNOT_BE_WRITTEN
-        ):
-            raise att.ATT_Error(ErrorCode.WRITE_NAME_NOT_ALLOWED)
-
-        name = value[2:].decode('utf-8')
-        if not name or len(name) > 40:
-            raise att.ATT_Error(ErrorCode.INVALID_PARAMETERS_LENGTH)
-
-        preset.name = name
-
-        await self.generic_update(
-            PresetChangedOperation(
-                PresetChangedOperation.ChangeId.GENERIC_UPDATE,
-                PresetChangedOperation.Generic(index, preset),
-            )
-        )
-
-    async def notify_active_preset_for_connection(self, connection: Connection) -> None:
-        if (
-            self.active_preset_index_per_device.get(connection.peer_address, 0x00)
-            == self.active_preset_index
-        ):
-            # Nothing to do, peer is already updated
-            return
-
-        await connection.device.notify_subscriber(
-            connection,
-            attribute=self.active_preset_index_characteristic,
-            value=bytes([self.active_preset_index]),
-        )
-        self.active_preset_index_per_device[connection.peer_address] = (
-            self.active_preset_index
-        )
-
-    async def notify_active_preset(self) -> None:
-        for connection in self.currently_connected_clients:
-            await self.notify_active_preset_for_connection(connection)
-
-    async def set_active_preset(
-        self, connection: Optional[Connection], value: bytes
-    ) -> None:
-        assert connection
-        index = value[1]
-        preset = self.preset_records.get(index, None)
-        if (
-            not preset
-            or preset.properties.is_available
-            != PresetRecord.Property.IsAvailable.IS_AVAILABLE
-        ):
-            raise att.ATT_Error(ErrorCode.PRESET_OPERATION_NOT_POSSIBLE)
-
-        if index == self.active_preset_index:
-            # Already at correct value
-            return
-
-        self.active_preset_index = index
-        await self.notify_active_preset()
-
-    async def _on_set_active_preset(
-        self, connection: Optional[Connection], value: bytes
-    ):
-        await self.set_active_preset(connection, value)
-
-    async def set_next_or_previous_preset(
-        self, connection: Optional[Connection], is_previous
-    ):
-        '''Set the next or the previous preset as active'''
-        assert connection
-
-        if self.active_preset_index == 0x00:
-            raise att.ATT_Error(ErrorCode.PRESET_OPERATION_NOT_POSSIBLE)
-
-        first_preset: Optional[PresetRecord] = None  # To loop to first preset
-        next_preset: Optional[PresetRecord] = None
-        for index, record in sorted(self.preset_records.items(), reverse=is_previous):
-            if not record.is_available():
-                continue
-            if first_preset == None:
-                first_preset = record
-            if is_previous:
-                if index >= self.active_preset_index:
-                    continue
-            elif index <= self.active_preset_index:
-                continue
-            next_preset = record
-            break
-
-        if not first_preset:  # If no other preset are available
-            raise att.ATT_Error(ErrorCode.PRESET_OPERATION_NOT_POSSIBLE)
-
-        if next_preset:
-            self.active_preset_index = next_preset.index
-        else:
-            self.active_preset_index = first_preset.index
-        await self.notify_active_preset()
-
-    async def _on_set_next_preset(
-        self, connection: Optional[Connection], __value__: bytes
-    ) -> None:
-        await self.set_next_or_previous_preset(connection, False)
-
-    async def _on_set_previous_preset(
-        self, connection: Optional[Connection], __value__: bytes
-    ) -> None:
-        await self.set_next_or_previous_preset(connection, True)
-
-    async def _on_set_active_preset_synchronized_locally(
-        self, connection: Optional[Connection], value: bytes
-    ):
-        if (
-            self.server_features.preset_synchronization_support
-            == PresetSynchronizationSupport.PRESET_SYNCHRONIZATION_IS_SUPPORTED
-        ):
-            raise att.ATT_Error(ErrorCode.PRESET_SYNCHRONIZATION_NOT_SUPPORTED)
-        await self.set_active_preset(connection, value)
-        # TODO (low priority) inform other server of the change
-
-    async def _on_set_next_preset_synchronized_locally(
-        self, connection: Optional[Connection], __value__: bytes
-    ):
-        if (
-            self.server_features.preset_synchronization_support
-            == PresetSynchronizationSupport.PRESET_SYNCHRONIZATION_IS_SUPPORTED
-        ):
-            raise att.ATT_Error(ErrorCode.PRESET_SYNCHRONIZATION_NOT_SUPPORTED)
-        await self.set_next_or_previous_preset(connection, False)
-        # TODO (low priority) inform other server of the change
-
-    async def _on_set_previous_preset_synchronized_locally(
-        self, connection: Optional[Connection], __value__: bytes
-    ):
-        if (
-            self.server_features.preset_synchronization_support
-            == PresetSynchronizationSupport.PRESET_SYNCHRONIZATION_IS_SUPPORTED
-        ):
-            raise att.ATT_Error(ErrorCode.PRESET_SYNCHRONIZATION_NOT_SUPPORTED)
-        await self.set_next_or_previous_preset(connection, True)
-        # TODO (low priority) inform other server of the change
-
-
-# -----------------------------------------------------------------------------
-# Client
-# -----------------------------------------------------------------------------
-class HearingAccessServiceProxy(gatt_client.ProfileServiceProxy):
-    SERVICE_CLASS = HearingAccessService
-
-    hearing_aid_preset_control_point: gatt_client.CharacteristicProxy
-    preset_control_point_indications: asyncio.Queue
-
-    def __init__(self, service_proxy: gatt_client.ServiceProxy) -> None:
-        self.service_proxy = service_proxy
-
-        self.server_features = gatt.PackedCharacteristicAdapter(
-            service_proxy.get_characteristics_by_uuid(
-                gatt.GATT_HEARING_AID_FEATURES_CHARACTERISTIC
-            )[0],
-            'B',
-        )
-
-        self.hearing_aid_preset_control_point = (
-            service_proxy.get_characteristics_by_uuid(
-                gatt.GATT_HEARING_AID_PRESET_CONTROL_POINT_CHARACTERISTIC
-            )[0]
-        )
-
-        self.active_preset_index = gatt.PackedCharacteristicAdapter(
-            service_proxy.get_characteristics_by_uuid(
-                gatt.GATT_ACTIVE_PRESET_INDEX_CHARACTERISTIC
-            )[0],
-            'B',
-        )
-
-    async def setup_subscription(self):
-        self.preset_control_point_indications = asyncio.Queue()
-        self.active_preset_index_notification = asyncio.Queue()
-
-        def on_active_preset_index_notification(data: bytes):
-            self.active_preset_index_notification.put_nowait(data)
-
-        def on_preset_control_point_indication(data: bytes):
-            self.preset_control_point_indications.put_nowait(data)
-
-        await self.hearing_aid_preset_control_point.subscribe(
-            functools.partial(on_preset_control_point_indication), prefer_notify=False
-        )
-
-        await self.active_preset_index.subscribe(
-            functools.partial(on_active_preset_index_notification)
-        )

bumble/profiles/heart_rate_service.py

@@ -19,7 +19,6 @@
 from enum import IntEnum
 import struct
 
-from bumble import core
 from ..gatt_client import ProfileServiceProxy
 from ..att import ATT_Error
 from ..gatt import (
@@ -43,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:
@@ -60,17 +59,17 @@ class HeartRateService(TemplateService):
             rr_intervals=None,
         ):
             if heart_rate < 0 or heart_rate > 0xFFFF:
-                raise core.InvalidArgumentError('heart_rate out of range')
+                raise ValueError('heart_rate out of range')
 
             if energy_expended is not None and (
                 energy_expended < 0 or energy_expended > 0xFFFF
             ):
-                raise core.InvalidArgumentError('energy_expended out of range')
+                raise ValueError('energy_expended out of range')
 
             if rr_intervals:
                 for rr_interval in rr_intervals:
                     if rr_interval < 0 or rr_interval * 1024 > 0xFFFF:
-                        raise core.InvalidArgumentError('rr_intervals out of range')
+                        raise ValueError('rr_intervals out of range')
 
             self.heart_rate = heart_rate
             self.sensor_contact_detected = sensor_contact_detected

bumble/profiles/le_audio.py

@@ -1,83 +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
-# -----------------------------------------------------------------------------
-from __future__ import annotations
-import dataclasses
-import struct
-from typing import List, Type
-from typing_extensions import Self
-
-from bumble import utils
-
-
-# -----------------------------------------------------------------------------
-# Classes
-# -----------------------------------------------------------------------------
-@dataclasses.dataclass
-class Metadata:
-    '''Bluetooth Assigned Numbers, Section 6.12.6 - Metadata LTV structures.
-
-    As Metadata fields may extend, and Spec doesn't forbid duplication, we don't parse
-    Metadata into a key-value style dataclass here. Rather, we encourage users to parse
-    again outside the lib.
-    '''
-
-    class Tag(utils.OpenIntEnum):
-        # fmt: off
-        PREFERRED_AUDIO_CONTEXTS                 = 0x01
-        STREAMING_AUDIO_CONTEXTS                 = 0x02
-        PROGRAM_INFO                             = 0x03
-        LANGUAGE                                 = 0x04
-        CCID_LIST                                = 0x05
-        PARENTAL_RATING                          = 0x06
-        PROGRAM_INFO_URI                         = 0x07
-        AUDIO_ACTIVE_STATE                       = 0x08
-        BROADCAST_AUDIO_IMMEDIATE_RENDERING_FLAG = 0x09
-        ASSISTED_LISTENING_STREAM                = 0x0A
-        BROADCAST_NAME                           = 0x0B
-        EXTENDED_METADATA                        = 0xFE
-        VENDOR_SPECIFIC                          = 0xFF
-
-    @dataclasses.dataclass
-    class Entry:
-        tag: Metadata.Tag
-        data: bytes
-
-        @classmethod
-        def from_bytes(cls: Type[Self], data: bytes) -> Self:
-            return cls(tag=Metadata.Tag(data[0]), data=data[1:])
-
-        def __bytes__(self) -> bytes:
-            return bytes([len(self.data) + 1, self.tag]) + self.data
-
-    entries: List[Entry] = dataclasses.field(default_factory=list)
-
-    @classmethod
-    def from_bytes(cls: Type[Self], data: bytes) -> Self:
-        entries = []
-        offset = 0
-        length = len(data)
-        while offset < length:
-            entry_length = data[offset]
-            offset += 1
-            entries.append(cls.Entry.from_bytes(data[offset : offset + entry_length]))
-            offset += entry_length
-
-        return cls(entries)
-
-    def __bytes__(self) -> bytes:
-        return b''.join([bytes(entry) for entry in self.entries])

bumble/profiles/mcp.py

@@ -1,448 +0,0 @@
-# Copyright 2021-2024 Google LLC
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-
-# -----------------------------------------------------------------------------
-# Imports
-# -----------------------------------------------------------------------------
-from __future__ import annotations
-
-import asyncio
-import dataclasses
-import enum
-import struct
-
-from bumble import core
-from bumble import device
-from bumble import gatt
-from bumble import gatt_client
-from bumble import utils
-
-from typing import Type, Optional, ClassVar, Dict, TYPE_CHECKING
-from typing_extensions import Self
-
-# -----------------------------------------------------------------------------
-# Constants
-# -----------------------------------------------------------------------------
-
-
-class PlayingOrder(utils.OpenIntEnum):
-    '''See Media Control Service 3.15. Playing Order.'''
-
-    SINGLE_ONCE = 0x01
-    SINGLE_REPEAT = 0x02
-    IN_ORDER_ONCE = 0x03
-    IN_ORDER_REPEAT = 0x04
-    OLDEST_ONCE = 0x05
-    OLDEST_REPEAT = 0x06
-    NEWEST_ONCE = 0x07
-    NEWEST_REPEAT = 0x08
-    SHUFFLE_ONCE = 0x09
-    SHUFFLE_REPEAT = 0x0A
-
-
-class PlayingOrderSupported(enum.IntFlag):
-    '''See Media Control Service 3.16. Playing Orders Supported.'''
-
-    SINGLE_ONCE = 0x0001
-    SINGLE_REPEAT = 0x0002
-    IN_ORDER_ONCE = 0x0004
-    IN_ORDER_REPEAT = 0x0008
-    OLDEST_ONCE = 0x0010
-    OLDEST_REPEAT = 0x0020
-    NEWEST_ONCE = 0x0040
-    NEWEST_REPEAT = 0x0080
-    SHUFFLE_ONCE = 0x0100
-    SHUFFLE_REPEAT = 0x0200
-
-
-class MediaState(utils.OpenIntEnum):
-    '''See Media Control Service 3.17. Media State.'''
-
-    INACTIVE = 0x00
-    PLAYING = 0x01
-    PAUSED = 0x02
-    SEEKING = 0x03
-
-
-class MediaControlPointOpcode(utils.OpenIntEnum):
-    '''See Media Control Service 3.18. Media Control Point.'''
-
-    PLAY = 0x01
-    PAUSE = 0x02
-    FAST_REWIND = 0x03
-    FAST_FORWARD = 0x04
-    STOP = 0x05
-    MOVE_RELATIVE = 0x10
-    PREVIOUS_SEGMENT = 0x20
-    NEXT_SEGMENT = 0x21
-    FIRST_SEGMENT = 0x22
-    LAST_SEGMENT = 0x23
-    GOTO_SEGMENT = 0x24
-    PREVIOUS_TRACK = 0x30
-    NEXT_TRACK = 0x31
-    FIRST_TRACK = 0x32
-    LAST_TRACK = 0x33
-    GOTO_TRACK = 0x34
-    PREVIOUS_GROUP = 0x40
-    NEXT_GROUP = 0x41
-    FIRST_GROUP = 0x42
-    LAST_GROUP = 0x43
-    GOTO_GROUP = 0x44
-
-
-class MediaControlPointResultCode(enum.IntFlag):
-    '''See Media Control Service 3.18.2. Media Control Point Notification.'''
-
-    SUCCESS = 0x01
-    OPCODE_NOT_SUPPORTED = 0x02
-    MEDIA_PLAYER_INACTIVE = 0x03
-    COMMAND_CANNOT_BE_COMPLETED = 0x04
-
-
-class MediaControlPointOpcodeSupported(enum.IntFlag):
-    '''See Media Control Service 3.19. Media Control Point Opcodes Supported.'''
-
-    PLAY = 0x00000001
-    PAUSE = 0x00000002
-    FAST_REWIND = 0x00000004
-    FAST_FORWARD = 0x00000008
-    STOP = 0x00000010
-    MOVE_RELATIVE = 0x00000020
-    PREVIOUS_SEGMENT = 0x00000040
-    NEXT_SEGMENT = 0x00000080
-    FIRST_SEGMENT = 0x00000100
-    LAST_SEGMENT = 0x00000200
-    GOTO_SEGMENT = 0x00000400
-    PREVIOUS_TRACK = 0x00000800
-    NEXT_TRACK = 0x00001000
-    FIRST_TRACK = 0x00002000
-    LAST_TRACK = 0x00004000
-    GOTO_TRACK = 0x00008000
-    PREVIOUS_GROUP = 0x00010000
-    NEXT_GROUP = 0x00020000
-    FIRST_GROUP = 0x00040000
-    LAST_GROUP = 0x00080000
-    GOTO_GROUP = 0x00100000
-
-
-class SearchControlPointItemType(utils.OpenIntEnum):
-    '''See Media Control Service 3.20. Search Control Point.'''
-
-    TRACK_NAME = 0x01
-    ARTIST_NAME = 0x02
-    ALBUM_NAME = 0x03
-    GROUP_NAME = 0x04
-    EARLIEST_YEAR = 0x05
-    LATEST_YEAR = 0x06
-    GENRE = 0x07
-    ONLY_TRACKS = 0x08
-    ONLY_GROUPS = 0x09
-
-
-class ObjectType(utils.OpenIntEnum):
-    '''See Media Control Service 4.4.1. Object Type field.'''
-
-    TASK = 0
-    GROUP = 1
-
-
-# -----------------------------------------------------------------------------
-# Classes
-# -----------------------------------------------------------------------------
-
-
-class ObjectId(int):
-    '''See Media Control Service 4.4.2. Object ID field.'''
-
-    @classmethod
-    def create_from_bytes(cls: Type[Self], data: bytes) -> Self:
-        return cls(int.from_bytes(data, byteorder='little', signed=False))
-
-    def __bytes__(self) -> bytes:
-        return self.to_bytes(6, 'little')
-
-
-@dataclasses.dataclass
-class GroupObjectType:
-    '''See Media Control Service 4.4. Group Object Type.'''
-
-    object_type: ObjectType
-    object_id: ObjectId
-
-    @classmethod
-    def from_bytes(cls: Type[Self], data: bytes) -> Self:
-        return cls(
-            object_type=ObjectType(data[0]),
-            object_id=ObjectId.create_from_bytes(data[1:]),
-        )
-
-    def __bytes__(self) -> bytes:
-        return bytes([self.object_type]) + bytes(self.object_id)
-
-
-# -----------------------------------------------------------------------------
-# Server
-# -----------------------------------------------------------------------------
-class MediaControlService(gatt.TemplateService):
-    '''Media Control Service server implementation, only for testing currently.'''
-
-    UUID = gatt.GATT_MEDIA_CONTROL_SERVICE
-
-    def __init__(self, media_player_name: Optional[str] = None) -> None:
-        self.track_position = 0
-
-        self.media_player_name_characteristic = gatt.Characteristic(
-            uuid=gatt.GATT_MEDIA_PLAYER_NAME_CHARACTERISTIC,
-            properties=gatt.Characteristic.Properties.READ
-            | gatt.Characteristic.Properties.NOTIFY,
-            permissions=gatt.Characteristic.Permissions.READ_REQUIRES_ENCRYPTION,
-            value=media_player_name or 'Bumble Player',
-        )
-        self.track_changed_characteristic = gatt.Characteristic(
-            uuid=gatt.GATT_TRACK_CHANGED_CHARACTERISTIC,
-            properties=gatt.Characteristic.Properties.NOTIFY,
-            permissions=gatt.Characteristic.Permissions.READ_REQUIRES_ENCRYPTION,
-            value=b'',
-        )
-        self.track_title_characteristic = gatt.Characteristic(
-            uuid=gatt.GATT_TRACK_TITLE_CHARACTERISTIC,
-            properties=gatt.Characteristic.Properties.READ
-            | gatt.Characteristic.Properties.NOTIFY,
-            permissions=gatt.Characteristic.Permissions.READ_REQUIRES_ENCRYPTION,
-            value=b'',
-        )
-        self.track_duration_characteristic = gatt.Characteristic(
-            uuid=gatt.GATT_TRACK_DURATION_CHARACTERISTIC,
-            properties=gatt.Characteristic.Properties.READ
-            | gatt.Characteristic.Properties.NOTIFY,
-            permissions=gatt.Characteristic.Permissions.READ_REQUIRES_ENCRYPTION,
-            value=b'',
-        )
-        self.track_position_characteristic = gatt.Characteristic(
-            uuid=gatt.GATT_TRACK_POSITION_CHARACTERISTIC,
-            properties=gatt.Characteristic.Properties.READ
-            | gatt.Characteristic.Properties.WRITE
-            | gatt.Characteristic.Properties.WRITE_WITHOUT_RESPONSE
-            | gatt.Characteristic.Properties.NOTIFY,
-            permissions=gatt.Characteristic.Permissions.READ_REQUIRES_ENCRYPTION
-            | gatt.Characteristic.Permissions.WRITE_REQUIRES_ENCRYPTION,
-            value=b'',
-        )
-        self.media_state_characteristic = gatt.Characteristic(
-            uuid=gatt.GATT_MEDIA_STATE_CHARACTERISTIC,
-            properties=gatt.Characteristic.Properties.READ
-            | gatt.Characteristic.Properties.NOTIFY,
-            permissions=gatt.Characteristic.Permissions.READ_REQUIRES_ENCRYPTION,
-            value=b'',
-        )
-        self.media_control_point_characteristic = gatt.Characteristic(
-            uuid=gatt.GATT_MEDIA_CONTROL_POINT_CHARACTERISTIC,
-            properties=gatt.Characteristic.Properties.WRITE
-            | gatt.Characteristic.Properties.WRITE_WITHOUT_RESPONSE
-            | gatt.Characteristic.Properties.NOTIFY,
-            permissions=gatt.Characteristic.Permissions.READ_REQUIRES_ENCRYPTION
-            | gatt.Characteristic.Permissions.WRITE_REQUIRES_ENCRYPTION,
-            value=gatt.CharacteristicValue(write=self.on_media_control_point),
-        )
-        self.media_control_point_opcodes_supported_characteristic = gatt.Characteristic(
-            uuid=gatt.GATT_MEDIA_CONTROL_POINT_OPCODES_SUPPORTED_CHARACTERISTIC,
-            properties=gatt.Characteristic.Properties.READ
-            | gatt.Characteristic.Properties.NOTIFY,
-            permissions=gatt.Characteristic.Permissions.READ_REQUIRES_ENCRYPTION,
-            value=b'',
-        )
-        self.content_control_id_characteristic = gatt.Characteristic(
-            uuid=gatt.GATT_CONTENT_CONTROL_ID_CHARACTERISTIC,
-            properties=gatt.Characteristic.Properties.READ,
-            permissions=gatt.Characteristic.Permissions.READ_REQUIRES_ENCRYPTION,
-            value=b'',
-        )
-
-        super().__init__(
-            [
-                self.media_player_name_characteristic,
-                self.track_changed_characteristic,
-                self.track_title_characteristic,
-                self.track_duration_characteristic,
-                self.track_position_characteristic,
-                self.media_state_characteristic,
-                self.media_control_point_characteristic,
-                self.media_control_point_opcodes_supported_characteristic,
-                self.content_control_id_characteristic,
-            ]
-        )
-
-    async def on_media_control_point(
-        self, connection: Optional[device.Connection], data: bytes
-    ) -> None:
-        if not connection:
-            raise core.InvalidStateError()
-
-        opcode = MediaControlPointOpcode(data[0])
-
-        await connection.device.notify_subscriber(
-            connection,
-            self.media_control_point_characteristic,
-            value=bytes([opcode, MediaControlPointResultCode.SUCCESS]),
-        )
-
-
-class GenericMediaControlService(MediaControlService):
-    UUID = gatt.GATT_GENERIC_MEDIA_CONTROL_SERVICE
-
-
-# -----------------------------------------------------------------------------
-# Client
-# -----------------------------------------------------------------------------
-class MediaControlServiceProxy(
-    gatt_client.ProfileServiceProxy, utils.CompositeEventEmitter
-):
-    SERVICE_CLASS = MediaControlService
-
-    _CHARACTERISTICS: ClassVar[Dict[str, core.UUID]] = {
-        'media_player_name': gatt.GATT_MEDIA_PLAYER_NAME_CHARACTERISTIC,
-        'media_player_icon_object_id': gatt.GATT_MEDIA_PLAYER_ICON_OBJECT_ID_CHARACTERISTIC,
-        'media_player_icon_url': gatt.GATT_MEDIA_PLAYER_ICON_URL_CHARACTERISTIC,
-        'track_changed': gatt.GATT_TRACK_CHANGED_CHARACTERISTIC,
-        'track_title': gatt.GATT_TRACK_TITLE_CHARACTERISTIC,
-        'track_duration': gatt.GATT_TRACK_DURATION_CHARACTERISTIC,
-        'track_position': gatt.GATT_TRACK_POSITION_CHARACTERISTIC,
-        'playback_speed': gatt.GATT_PLAYBACK_SPEED_CHARACTERISTIC,
-        'seeking_speed': gatt.GATT_SEEKING_SPEED_CHARACTERISTIC,
-        'current_track_segments_object_id': gatt.GATT_CURRENT_TRACK_SEGMENTS_OBJECT_ID_CHARACTERISTIC,
-        'current_track_object_id': gatt.GATT_CURRENT_TRACK_OBJECT_ID_CHARACTERISTIC,
-        'next_track_object_id': gatt.GATT_NEXT_TRACK_OBJECT_ID_CHARACTERISTIC,
-        'parent_group_object_id': gatt.GATT_PARENT_GROUP_OBJECT_ID_CHARACTERISTIC,
-        'current_group_object_id': gatt.GATT_CURRENT_GROUP_OBJECT_ID_CHARACTERISTIC,
-        'playing_order': gatt.GATT_PLAYING_ORDER_CHARACTERISTIC,
-        'playing_orders_supported': gatt.GATT_PLAYING_ORDERS_SUPPORTED_CHARACTERISTIC,
-        'media_state': gatt.GATT_MEDIA_STATE_CHARACTERISTIC,
-        'media_control_point': gatt.GATT_MEDIA_CONTROL_POINT_CHARACTERISTIC,
-        'media_control_point_opcodes_supported': gatt.GATT_MEDIA_CONTROL_POINT_OPCODES_SUPPORTED_CHARACTERISTIC,
-        'search_control_point': gatt.GATT_SEARCH_CONTROL_POINT_CHARACTERISTIC,
-        'search_results_object_id': gatt.GATT_SEARCH_RESULTS_OBJECT_ID_CHARACTERISTIC,
-        'content_control_id': gatt.GATT_CONTENT_CONTROL_ID_CHARACTERISTIC,
-    }
-
-    media_player_name: Optional[gatt_client.CharacteristicProxy] = None
-    media_player_icon_object_id: Optional[gatt_client.CharacteristicProxy] = None
-    media_player_icon_url: Optional[gatt_client.CharacteristicProxy] = None
-    track_changed: Optional[gatt_client.CharacteristicProxy] = None
-    track_title: Optional[gatt_client.CharacteristicProxy] = None
-    track_duration: Optional[gatt_client.CharacteristicProxy] = None
-    track_position: Optional[gatt_client.CharacteristicProxy] = None
-    playback_speed: Optional[gatt_client.CharacteristicProxy] = None
-    seeking_speed: Optional[gatt_client.CharacteristicProxy] = None
-    current_track_segments_object_id: Optional[gatt_client.CharacteristicProxy] = None
-    current_track_object_id: Optional[gatt_client.CharacteristicProxy] = None
-    next_track_object_id: Optional[gatt_client.CharacteristicProxy] = None
-    parent_group_object_id: Optional[gatt_client.CharacteristicProxy] = None
-    current_group_object_id: Optional[gatt_client.CharacteristicProxy] = None
-    playing_order: Optional[gatt_client.CharacteristicProxy] = None
-    playing_orders_supported: Optional[gatt_client.CharacteristicProxy] = None
-    media_state: Optional[gatt_client.CharacteristicProxy] = None
-    media_control_point: Optional[gatt_client.CharacteristicProxy] = None
-    media_control_point_opcodes_supported: Optional[gatt_client.CharacteristicProxy] = (
-        None
-    )
-    search_control_point: Optional[gatt_client.CharacteristicProxy] = None
-    search_results_object_id: Optional[gatt_client.CharacteristicProxy] = None
-    content_control_id: Optional[gatt_client.CharacteristicProxy] = None
-
-    if TYPE_CHECKING:
-        media_control_point_notifications: asyncio.Queue[bytes]
-
-    def __init__(self, service_proxy: gatt_client.ServiceProxy) -> None:
-        utils.CompositeEventEmitter.__init__(self)
-        self.service_proxy = service_proxy
-        self.lock = asyncio.Lock()
-        self.media_control_point_notifications = asyncio.Queue()
-
-        for field, uuid in self._CHARACTERISTICS.items():
-            if characteristics := service_proxy.get_characteristics_by_uuid(uuid):
-                setattr(self, field, characteristics[0])
-
-    async def subscribe_characteristics(self) -> None:
-        if self.media_control_point:
-            await self.media_control_point.subscribe(self._on_media_control_point)
-        if self.media_state:
-            await self.media_state.subscribe(self._on_media_state)
-        if self.track_changed:
-            await self.track_changed.subscribe(self._on_track_changed)
-        if self.track_title:
-            await self.track_title.subscribe(self._on_track_title)
-        if self.track_duration:
-            await self.track_duration.subscribe(self._on_track_duration)
-        if self.track_position:
-            await self.track_position.subscribe(self._on_track_position)
-
-    async def write_control_point(
-        self, opcode: MediaControlPointOpcode
-    ) -> MediaControlPointResultCode:
-        '''Writes a Media Control Point Opcode to peer and waits for the notification.
-
-        The write operation will be executed when there isn't other pending commands.
-
-        Args:
-            opcode: opcode defined in `MediaControlPointOpcode`.
-
-        Returns:
-            Response code provided in `MediaControlPointResultCode`
-
-        Raises:
-            InvalidOperationError: Server does not have Media Control Point Characteristic.
-            InvalidStateError: Server replies a notification with mismatched opcode.
-        '''
-        if not self.media_control_point:
-            raise core.InvalidOperationError("Peer does not have media control point")
-
-        async with self.lock:
-            await self.media_control_point.write_value(
-                bytes([opcode]),
-                with_response=False,
-            )
-
-            (
-                response_opcode,
-                response_code,
-            ) = await self.media_control_point_notifications.get()
-            if response_opcode != opcode:
-                raise core.InvalidStateError(
-                    f"Expected {opcode} notification, but get {response_opcode}"
-                )
-            return MediaControlPointResultCode(response_code)
-
-    def _on_media_control_point(self, data: bytes) -> None:
-        self.media_control_point_notifications.put_nowait(data)
-
-    def _on_media_state(self, data: bytes) -> None:
-        self.emit('media_state', MediaState(data[0]))
-
-    def _on_track_changed(self, data: bytes) -> None:
-        del data
-        self.emit('track_changed')
-
-    def _on_track_title(self, data: bytes) -> None:
-        self.emit('track_title', data.decode("utf-8"))
-
-    def _on_track_duration(self, data: bytes) -> None:
-        self.emit('track_duration', struct.unpack_from('<i', data)[0])
-
-    def _on_track_position(self, data: bytes) -> None:
-        self.emit('track_position', struct.unpack_from('<i', data)[0])
-
-
-class GenericMediaControlServiceProxy(MediaControlServiceProxy):
-    SERVICE_CLASS = GenericMediaControlService

bumble/profiles/pacs.py

@@ -1,210 +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
-
-"""LE Audio - Published Audio Capabilities Service"""
-
-# -----------------------------------------------------------------------------
-# Imports
-# -----------------------------------------------------------------------------
-from __future__ import annotations
-import dataclasses
-import logging
-import struct
-from typing import Optional, Sequence, Union
-
-from bumble.profiles.bap import AudioLocation, CodecSpecificCapabilities, ContextType
-from bumble.profiles import le_audio
-from bumble import gatt
-from bumble import gatt_client
-from bumble import hci
-
-
-# -----------------------------------------------------------------------------
-# Logging
-# -----------------------------------------------------------------------------
-logger = logging.getLogger(__name__)
-
-
-# -----------------------------------------------------------------------------
-@dataclasses.dataclass
-class PacRecord:
-    '''Published Audio Capabilities Service, Table 3.2/3.4.'''
-
-    coding_format: hci.CodingFormat
-    codec_specific_capabilities: Union[CodecSpecificCapabilities, bytes]
-    metadata: le_audio.Metadata = dataclasses.field(default_factory=le_audio.Metadata)
-
-    @classmethod
-    def from_bytes(cls, data: bytes) -> PacRecord:
-        offset, coding_format = hci.CodingFormat.parse_from_bytes(data, 0)
-        codec_specific_capabilities_size = data[offset]
-
-        offset += 1
-        codec_specific_capabilities_bytes = data[
-            offset : offset + codec_specific_capabilities_size
-        ]
-        offset += codec_specific_capabilities_size
-        metadata_size = data[offset]
-        offset += 1
-        metadata = le_audio.Metadata.from_bytes(data[offset : offset + metadata_size])
-
-        codec_specific_capabilities: Union[CodecSpecificCapabilities, bytes]
-        if coding_format.codec_id == hci.CodecID.VENDOR_SPECIFIC:
-            codec_specific_capabilities = codec_specific_capabilities_bytes
-        else:
-            codec_specific_capabilities = CodecSpecificCapabilities.from_bytes(
-                codec_specific_capabilities_bytes
-            )
-
-        return PacRecord(
-            coding_format=coding_format,
-            codec_specific_capabilities=codec_specific_capabilities,
-            metadata=metadata,
-        )
-
-    def __bytes__(self) -> bytes:
-        capabilities_bytes = bytes(self.codec_specific_capabilities)
-        metadata_bytes = bytes(self.metadata)
-        return (
-            bytes(self.coding_format)
-            + bytes([len(capabilities_bytes)])
-            + capabilities_bytes
-            + bytes([len(metadata_bytes)])
-            + metadata_bytes
-        )
-
-
-# -----------------------------------------------------------------------------
-# Server
-# -----------------------------------------------------------------------------
-class PublishedAudioCapabilitiesService(gatt.TemplateService):
-    UUID = gatt.GATT_PUBLISHED_AUDIO_CAPABILITIES_SERVICE
-
-    sink_pac: Optional[gatt.Characteristic]
-    sink_audio_locations: Optional[gatt.Characteristic]
-    source_pac: Optional[gatt.Characteristic]
-    source_audio_locations: Optional[gatt.Characteristic]
-    available_audio_contexts: gatt.Characteristic
-    supported_audio_contexts: gatt.Characteristic
-
-    def __init__(
-        self,
-        supported_source_context: ContextType,
-        supported_sink_context: ContextType,
-        available_source_context: ContextType,
-        available_sink_context: ContextType,
-        sink_pac: Sequence[PacRecord] = (),
-        sink_audio_locations: Optional[AudioLocation] = None,
-        source_pac: Sequence[PacRecord] = (),
-        source_audio_locations: Optional[AudioLocation] = None,
-    ) -> None:
-        characteristics = []
-
-        self.supported_audio_contexts = gatt.Characteristic(
-            uuid=gatt.GATT_SUPPORTED_AUDIO_CONTEXTS_CHARACTERISTIC,
-            properties=gatt.Characteristic.Properties.READ,
-            permissions=gatt.Characteristic.Permissions.READABLE,
-            value=struct.pack('<HH', supported_sink_context, supported_source_context),
-        )
-        characteristics.append(self.supported_audio_contexts)
-
-        self.available_audio_contexts = gatt.Characteristic(
-            uuid=gatt.GATT_AVAILABLE_AUDIO_CONTEXTS_CHARACTERISTIC,
-            properties=gatt.Characteristic.Properties.READ
-            | gatt.Characteristic.Properties.NOTIFY,
-            permissions=gatt.Characteristic.Permissions.READABLE,
-            value=struct.pack('<HH', available_sink_context, available_source_context),
-        )
-        characteristics.append(self.available_audio_contexts)
-
-        if sink_pac:
-            self.sink_pac = gatt.Characteristic(
-                uuid=gatt.GATT_SINK_PAC_CHARACTERISTIC,
-                properties=gatt.Characteristic.Properties.READ,
-                permissions=gatt.Characteristic.Permissions.READABLE,
-                value=bytes([len(sink_pac)]) + b''.join(map(bytes, sink_pac)),
-            )
-            characteristics.append(self.sink_pac)
-
-        if sink_audio_locations is not None:
-            self.sink_audio_locations = gatt.Characteristic(
-                uuid=gatt.GATT_SINK_AUDIO_LOCATION_CHARACTERISTIC,
-                properties=gatt.Characteristic.Properties.READ,
-                permissions=gatt.Characteristic.Permissions.READABLE,
-                value=struct.pack('<I', sink_audio_locations),
-            )
-            characteristics.append(self.sink_audio_locations)
-
-        if source_pac:
-            self.source_pac = gatt.Characteristic(
-                uuid=gatt.GATT_SOURCE_PAC_CHARACTERISTIC,
-                properties=gatt.Characteristic.Properties.READ,
-                permissions=gatt.Characteristic.Permissions.READABLE,
-                value=bytes([len(source_pac)]) + b''.join(map(bytes, source_pac)),
-            )
-            characteristics.append(self.source_pac)
-
-        if source_audio_locations is not None:
-            self.source_audio_locations = gatt.Characteristic(
-                uuid=gatt.GATT_SOURCE_AUDIO_LOCATION_CHARACTERISTIC,
-                properties=gatt.Characteristic.Properties.READ,
-                permissions=gatt.Characteristic.Permissions.READABLE,
-                value=struct.pack('<I', source_audio_locations),
-            )
-            characteristics.append(self.source_audio_locations)
-
-        super().__init__(characteristics)
-
-
-# -----------------------------------------------------------------------------
-# Client
-# -----------------------------------------------------------------------------
-class PublishedAudioCapabilitiesServiceProxy(gatt_client.ProfileServiceProxy):
-    SERVICE_CLASS = PublishedAudioCapabilitiesService
-
-    sink_pac: Optional[gatt_client.CharacteristicProxy] = None
-    sink_audio_locations: Optional[gatt_client.CharacteristicProxy] = None
-    source_pac: Optional[gatt_client.CharacteristicProxy] = None
-    source_audio_locations: Optional[gatt_client.CharacteristicProxy] = None
-    available_audio_contexts: gatt_client.CharacteristicProxy
-    supported_audio_contexts: gatt_client.CharacteristicProxy
-
-    def __init__(self, service_proxy: gatt_client.ServiceProxy):
-        self.service_proxy = service_proxy
-
-        self.available_audio_contexts = service_proxy.get_characteristics_by_uuid(
-            gatt.GATT_AVAILABLE_AUDIO_CONTEXTS_CHARACTERISTIC
-        )[0]
-        self.supported_audio_contexts = service_proxy.get_characteristics_by_uuid(
-            gatt.GATT_SUPPORTED_AUDIO_CONTEXTS_CHARACTERISTIC
-        )[0]
-
-        if characteristics := service_proxy.get_characteristics_by_uuid(
-            gatt.GATT_SINK_PAC_CHARACTERISTIC
-        ):
-            self.sink_pac = characteristics[0]
-
-        if characteristics := service_proxy.get_characteristics_by_uuid(
-            gatt.GATT_SOURCE_PAC_CHARACTERISTIC
-        ):
-            self.source_pac = characteristics[0]
-
-        if characteristics := service_proxy.get_characteristics_by_uuid(
-            gatt.GATT_SINK_AUDIO_LOCATION_CHARACTERISTIC
-        ):
-            self.sink_audio_locations = characteristics[0]
-
-        if characteristics := service_proxy.get_characteristics_by_uuid(
-            gatt.GATT_SOURCE_AUDIO_LOCATION_CHARACTERISTIC
-        ):
-            self.source_audio_locations = characteristics[0]

bumble/profiles/pbp.py

@@ -1,46 +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
-# -----------------------------------------------------------------------------
-from __future__ import annotations
-import dataclasses
-import enum
-from typing_extensions import Self
-
-from bumble.profiles import le_audio
-
-
-# -----------------------------------------------------------------------------
-# Classes
-# -----------------------------------------------------------------------------
-@dataclasses.dataclass
-class PublicBroadcastAnnouncement:
-    class Features(enum.IntFlag):
-        ENCRYPTED = 1 << 0
-        STANDARD_QUALITY_CONFIGURATION = 1 << 1
-        HIGH_QUALITY_CONFIGURATION = 1 << 2
-
-    features: Features
-    metadata: le_audio.Metadata
-
-    @classmethod
-    def from_bytes(cls, data: bytes) -> Self:
-        features = cls.Features(data[0])
-        metadata_length = data[1]
-        metadata_ltv = data[1 : 1 + metadata_length]
-        return cls(
-            features=features, metadata=le_audio.Metadata.from_bytes(metadata_ltv)
-        )

bumble/profiles/tmap.py

@@ -1,89 +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.
-
-"""LE Audio - Telephony and Media Audio Profile"""
-
-# -----------------------------------------------------------------------------
-# Imports
-# -----------------------------------------------------------------------------
-import enum
-import logging
-import struct
-
-from bumble.gatt import (
-    TemplateService,
-    Characteristic,
-    DelegatedCharacteristicAdapter,
-    InvalidServiceError,
-    GATT_TELEPHONY_AND_MEDIA_AUDIO_SERVICE,
-    GATT_TMAP_ROLE_CHARACTERISTIC,
-)
-from bumble.gatt_client import ProfileServiceProxy, ServiceProxy
-
-
-# -----------------------------------------------------------------------------
-# Logging
-# -----------------------------------------------------------------------------
-logger = logging.getLogger(__name__)
-
-
-# -----------------------------------------------------------------------------
-# Classes
-# -----------------------------------------------------------------------------
-class Role(enum.IntFlag):
-    CALL_GATEWAY = 1 << 0
-    CALL_TERMINAL = 1 << 1
-    UNICAST_MEDIA_SENDER = 1 << 2
-    UNICAST_MEDIA_RECEIVER = 1 << 3
-    BROADCAST_MEDIA_SENDER = 1 << 4
-    BROADCAST_MEDIA_RECEIVER = 1 << 5
-
-
-# -----------------------------------------------------------------------------
-class TelephonyAndMediaAudioService(TemplateService):
-    UUID = GATT_TELEPHONY_AND_MEDIA_AUDIO_SERVICE
-
-    def __init__(self, role: Role):
-        self.role_characteristic = Characteristic(
-            GATT_TMAP_ROLE_CHARACTERISTIC,
-            Characteristic.Properties.READ,
-            Characteristic.READABLE,
-            struct.pack('<H', int(role)),
-        )
-
-        super().__init__([self.role_characteristic])
-
-
-# -----------------------------------------------------------------------------
-class TelephonyAndMediaAudioServiceProxy(ProfileServiceProxy):
-    SERVICE_CLASS = TelephonyAndMediaAudioService
-
-    role: DelegatedCharacteristicAdapter
-
-    def __init__(self, service_proxy: ServiceProxy):
-        self.service_proxy = service_proxy
-
-        if not (
-            characteristics := service_proxy.get_characteristics_by_uuid(
-                GATT_TMAP_ROLE_CHARACTERISTIC
-            )
-        ):
-            raise InvalidServiceError('TMAP Role characteristic not found')
-
-        self.role = DelegatedCharacteristicAdapter(
-            characteristics[0],
-            decode=lambda value: Role(
-                struct.unpack_from('<H', value, 0)[0],
-            ),
-        )

bumble/profiles/vcp.py

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

bumble/rfcomm.py

@@ -19,28 +19,30 @@ from __future__ import annotations
 
 import logging
 import asyncio
-import collections
-import dataclasses
 import enum
 from typing import Callable, Dict, List, Optional, Tuple, Union, TYPE_CHECKING
-from typing_extensions import Self
 
 from pyee import EventEmitter
 
-from bumble import core
-from bumble import l2cap
-from bumble import sdp
+from . import core, l2cap
 from .colors import color
 from .core import (
     UUID,
     BT_RFCOMM_PROTOCOL_ID,
     BT_BR_EDR_TRANSPORT,
     BT_L2CAP_PROTOCOL_ID,
-    InvalidArgumentError,
     InvalidStateError,
-    InvalidPacketError,
     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
@@ -57,20 +59,28 @@ logger = logging.getLogger(__name__)
 # fmt: off
 
 RFCOMM_PSM = 0x0003
-DEFAULT_RX_QUEUE_SIZE = 32
 
-class FrameType(enum.IntEnum):
-    SABM = 0x2F  # Control field [1,1,1,1,_,1,0,0] LSB-first
-    UA   = 0x63  # Control field [0,1,1,0,_,0,1,1] LSB-first
-    DM   = 0x0F  # Control field [1,1,1,1,_,0,0,0] LSB-first
-    DISC = 0x43  # Control field [0,1,0,_,0,0,1,1] LSB-first
-    UIH  = 0xEF  # Control field [1,1,1,_,1,1,1,1] LSB-first
-    UI   = 0x03  # Control field [0,0,0,_,0,0,1,1] LSB-first
 
-class MccType(enum.IntEnum):
-    PN  = 0x20
-    MSC = 0x38
+# Frame types
+RFCOMM_SABM_FRAME = 0x2F  # Control field [1,1,1,1,_,1,0,0] LSB-first
+RFCOMM_UA_FRAME   = 0x63  # Control field [0,1,1,0,_,0,1,1] LSB-first
+RFCOMM_DM_FRAME   = 0x0F  # Control field [1,1,1,1,_,0,0,0] LSB-first
+RFCOMM_DISC_FRAME = 0x43  # Control field [0,1,0,_,0,0,1,1] LSB-first
+RFCOMM_UIH_FRAME  = 0xEF  # Control field [1,1,1,_,1,1,1,1] LSB-first
+RFCOMM_UI_FRAME   = 0x03  # Control field [0,0,0,_,0,0,1,1] LSB-first
 
+RFCOMM_FRAME_TYPE_NAMES = {
+    RFCOMM_SABM_FRAME: 'SABM',
+    RFCOMM_UA_FRAME:   'UA',
+    RFCOMM_DM_FRAME:   'DM',
+    RFCOMM_DISC_FRAME: 'DISC',
+    RFCOMM_UIH_FRAME:  'UIH',
+    RFCOMM_UI_FRAME:   'UI'
+}
+
+# MCC Types
+RFCOMM_MCC_PN_TYPE  = 0x20
+RFCOMM_MCC_MSC_TYPE = 0x38
 
 # FCS CRC
 CRC_TABLE = bytes([
@@ -108,11 +118,8 @@ CRC_TABLE = bytes([
     0XBA, 0X2B, 0X59, 0XC8, 0XBD, 0X2C, 0X5E, 0XCF
 ])
 
-RFCOMM_DEFAULT_L2CAP_MTU        = 2048
-RFCOMM_DEFAULT_INITIAL_CREDITS  = 7
-RFCOMM_DEFAULT_MAX_CREDITS      = 32
-RFCOMM_DEFAULT_CREDIT_THRESHOLD = RFCOMM_DEFAULT_MAX_CREDITS // 2
-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
@@ -123,33 +130,29 @@ RFCOMM_DYNAMIC_CHANNEL_NUMBER_END   = 30
 # -----------------------------------------------------------------------------
 def make_service_sdp_records(
     service_record_handle: int, channel: int, uuid: Optional[UUID] = None
-) -> List[sdp.ServiceAttribute]:
+) -> List[ServiceAttribute]:
     """
     Create SDP records for an RFComm service given a channel number and an
     optional UUID. A Service Class Attribute is included only if the UUID is not None.
     """
     records = [
-        sdp.ServiceAttribute(
-            sdp.SDP_SERVICE_RECORD_HANDLE_ATTRIBUTE_ID,
-            sdp.DataElement.unsigned_integer_32(service_record_handle),
+        ServiceAttribute(
+            SDP_SERVICE_RECORD_HANDLE_ATTRIBUTE_ID,
+            DataElement.unsigned_integer_32(service_record_handle),
         ),
-        sdp.ServiceAttribute(
-            sdp.SDP_BROWSE_GROUP_LIST_ATTRIBUTE_ID,
-            sdp.DataElement.sequence(
-                [sdp.DataElement.uuid(sdp.SDP_PUBLIC_BROWSE_ROOT)]
-            ),
+        ServiceAttribute(
+            SDP_BROWSE_GROUP_LIST_ATTRIBUTE_ID,
+            DataElement.sequence([DataElement.uuid(SDP_PUBLIC_BROWSE_ROOT)]),
         ),
-        sdp.ServiceAttribute(
-            sdp.SDP_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID,
-            sdp.DataElement.sequence(
+        ServiceAttribute(
+            SDP_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID,
+            DataElement.sequence(
                 [
-                    sdp.DataElement.sequence(
-                        [sdp.DataElement.uuid(BT_L2CAP_PROTOCOL_ID)]
-                    ),
-                    sdp.DataElement.sequence(
+                    DataElement.sequence([DataElement.uuid(BT_L2CAP_PROTOCOL_ID)]),
+                    DataElement.sequence(
                         [
-                            sdp.DataElement.uuid(BT_RFCOMM_PROTOCOL_ID),
-                            sdp.DataElement.unsigned_integer_8(channel),
+                            DataElement.uuid(BT_RFCOMM_PROTOCOL_ID),
+                            DataElement.unsigned_integer_8(channel),
                         ]
                     ),
                 ]
@@ -159,81 +162,15 @@ def make_service_sdp_records(
 
     if uuid:
         records.append(
-            sdp.ServiceAttribute(
-                sdp.SDP_SERVICE_CLASS_ID_LIST_ATTRIBUTE_ID,
-                sdp.DataElement.sequence([sdp.DataElement.uuid(uuid)]),
+            ServiceAttribute(
+                SDP_SERVICE_CLASS_ID_LIST_ATTRIBUTE_ID,
+                DataElement.sequence([DataElement.uuid(uuid)]),
             )
         )
 
     return records
 
 
-# -----------------------------------------------------------------------------
-async def find_rfcomm_channels(connection: Connection) -> Dict[int, List[UUID]]:
-    """Searches all RFCOMM channels and their associated UUID from SDP service records.
-
-    Args:
-        connection: ACL connection to make SDP search.
-
-    Returns:
-        Dictionary mapping from channel number to service class UUID list.
-    """
-    results = {}
-    async with sdp.Client(connection) as sdp_client:
-        search_result = await sdp_client.search_attributes(
-            uuids=[core.BT_RFCOMM_PROTOCOL_ID],
-            attribute_ids=[
-                sdp.SDP_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID,
-                sdp.SDP_SERVICE_CLASS_ID_LIST_ATTRIBUTE_ID,
-            ],
-        )
-        for attribute_lists in search_result:
-            service_classes: List[UUID] = []
-            channel: Optional[int] = None
-            for attribute in attribute_lists:
-                # The layout is [[L2CAP_PROTOCOL], [RFCOMM_PROTOCOL, RFCOMM_CHANNEL]].
-                if attribute.id == sdp.SDP_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID:
-                    protocol_descriptor_list = attribute.value.value
-                    channel = protocol_descriptor_list[1].value[1].value
-                elif attribute.id == sdp.SDP_SERVICE_CLASS_ID_LIST_ATTRIBUTE_ID:
-                    service_class_id_list = attribute.value.value
-                    service_classes = [
-                        service_class.value for service_class in service_class_id_list
-                    ]
-            if not service_classes or not channel:
-                logger.warning(f"Bad result {attribute_lists}.")
-            else:
-                results[channel] = service_classes
-    return results
-
-
-# -----------------------------------------------------------------------------
-async def find_rfcomm_channel_with_uuid(
-    connection: Connection, uuid: str | UUID
-) -> Optional[int]:
-    """Searches an RFCOMM channel associated with given UUID from service records.
-
-    Args:
-        connection: ACL connection to make SDP search.
-        uuid: UUID of service record to search for.
-
-    Returns:
-        RFCOMM channel number if found, otherwise None.
-    """
-    if isinstance(uuid, str):
-        uuid = UUID(uuid)
-    return next(
-        (
-            channel
-            for channel, class_id_list in (
-                await find_rfcomm_channels(connection)
-            ).items()
-            if uuid in class_id_list
-        ),
-        None,
-    )
-
-
 # -----------------------------------------------------------------------------
 def compute_fcs(buffer: bytes) -> int:
     result = 0xFF
@@ -246,7 +183,7 @@ def compute_fcs(buffer: bytes) -> int:
 class RFCOMM_Frame:
     def __init__(
         self,
-        frame_type: FrameType,
+        frame_type: int,
         c_r: int,
         dlci: int,
         p_f: int,
@@ -269,11 +206,14 @@ class RFCOMM_Frame:
             self.length = bytes([(length << 1) | 1])
         self.address = (dlci << 2) | (c_r << 1) | 1
         self.control = frame_type | (p_f << 4)
-        if frame_type == FrameType.UIH:
+        if frame_type == RFCOMM_UIH_FRAME:
             self.fcs = compute_fcs(bytes([self.address, self.control]))
         else:
             self.fcs = compute_fcs(bytes([self.address, self.control]) + self.length)
 
+    def type_name(self) -> str:
+        return RFCOMM_FRAME_TYPE_NAMES[self.type]
+
     @staticmethod
     def parse_mcc(data) -> Tuple[int, bool, bytes]:
         mcc_type = data[0] >> 2
@@ -297,24 +237,24 @@ class RFCOMM_Frame:
 
     @staticmethod
     def sabm(c_r: int, dlci: int):
-        return RFCOMM_Frame(FrameType.SABM, c_r, dlci, 1)
+        return RFCOMM_Frame(RFCOMM_SABM_FRAME, c_r, dlci, 1)
 
     @staticmethod
     def ua(c_r: int, dlci: int):
-        return RFCOMM_Frame(FrameType.UA, c_r, dlci, 1)
+        return RFCOMM_Frame(RFCOMM_UA_FRAME, c_r, dlci, 1)
 
     @staticmethod
     def dm(c_r: int, dlci: int):
-        return RFCOMM_Frame(FrameType.DM, c_r, dlci, 1)
+        return RFCOMM_Frame(RFCOMM_DM_FRAME, c_r, dlci, 1)
 
     @staticmethod
     def disc(c_r: int, dlci: int):
-        return RFCOMM_Frame(FrameType.DISC, c_r, dlci, 1)
+        return RFCOMM_Frame(RFCOMM_DISC_FRAME, c_r, dlci, 1)
 
     @staticmethod
     def uih(c_r: int, dlci: int, information: bytes, p_f: int = 0):
         return RFCOMM_Frame(
-            FrameType.UIH, c_r, dlci, p_f, information, with_credits=(p_f == 1)
+            RFCOMM_UIH_FRAME, c_r, dlci, p_f, information, with_credits=(p_f == 1)
         )
 
     @staticmethod
@@ -322,7 +262,7 @@ class RFCOMM_Frame:
         # Extract fields
         dlci = (data[0] >> 2) & 0x3F
         c_r = (data[0] >> 1) & 0x01
-        frame_type = FrameType(data[1] & 0xEF)
+        frame_type = data[1] & 0xEF
         p_f = (data[1] >> 4) & 0x01
         length = data[2]
         if length & 0x01:
@@ -337,7 +277,7 @@ class RFCOMM_Frame:
         frame = RFCOMM_Frame(frame_type, c_r, dlci, p_f, information)
         if frame.fcs != fcs:
             logger.warning(f'FCS mismatch: got {fcs:02X}, expected {frame.fcs:02X}')
-            raise InvalidPacketError('fcs mismatch')
+            raise ValueError('fcs mismatch')
 
         return frame
 
@@ -351,7 +291,7 @@ class RFCOMM_Frame:
 
     def __str__(self) -> str:
         return (
-            f'{color(self.type.name, "yellow")}'
+            f'{color(self.type_name(), "yellow")}'
             f'(c/r={self.c_r},'
             f'dlci={self.dlci},'
             f'p/f={self.p_f},'
@@ -361,7 +301,6 @@ class RFCOMM_Frame:
 
 
 # -----------------------------------------------------------------------------
-@dataclasses.dataclass
 class RFCOMM_MCC_PN:
     dlci: int
     cl: int
@@ -369,13 +308,25 @@ class RFCOMM_MCC_PN:
     ack_timer: int
     max_frame_size: int
     max_retransmissions: int
-    initial_credits: int
+    window_size: int
 
-    def __post_init__(self) -> None:
-        if self.initial_credits < 1 or self.initial_credits > 7:
-            logger.warning(
-                f'Initial credits {self.initial_credits} is out of range [1, 7].'
-            )
+    def __init__(
+        self,
+        dlci: int,
+        cl: int,
+        priority: int,
+        ack_timer: int,
+        max_frame_size: int,
+        max_retransmissions: int,
+        window_size: int,
+    ) -> None:
+        self.dlci = dlci
+        self.cl = cl
+        self.priority = priority
+        self.ack_timer = ack_timer
+        self.max_frame_size = max_frame_size
+        self.max_retransmissions = max_retransmissions
+        self.window_size = window_size
 
     @staticmethod
     def from_bytes(data: bytes) -> RFCOMM_MCC_PN:
@@ -386,7 +337,7 @@ class RFCOMM_MCC_PN:
             ack_timer=data[3],
             max_frame_size=data[4] | data[5] << 8,
             max_retransmissions=data[6],
-            initial_credits=data[7] & 0x07,
+            window_size=data[7],
         )
 
     def __bytes__(self) -> bytes:
@@ -399,14 +350,23 @@ class RFCOMM_MCC_PN:
                 self.max_frame_size & 0xFF,
                 (self.max_frame_size >> 8) & 0xFF,
                 self.max_retransmissions & 0xFF,
-                # Only 3 bits are meaningful.
-                self.initial_credits & 0x07,
+                self.window_size & 0xFF,
             ]
         )
 
+    def __str__(self) -> str:
+        return (
+            f'PN(dlci={self.dlci},'
+            f'cl={self.cl},'
+            f'priority={self.priority},'
+            f'ack_timer={self.ack_timer},'
+            f'max_frame_size={self.max_frame_size},'
+            f'max_retransmissions={self.max_retransmissions},'
+            f'window_size={self.window_size})'
+        )
+
 
 # -----------------------------------------------------------------------------
-@dataclasses.dataclass
 class RFCOMM_MCC_MSC:
     dlci: int
     fc: int
@@ -415,6 +375,16 @@ class RFCOMM_MCC_MSC:
     ic: int
     dv: int
 
+    def __init__(
+        self, dlci: int, fc: int, rtc: int, rtr: int, ic: int, dv: int
+    ) -> None:
+        self.dlci = dlci
+        self.fc = fc
+        self.rtc = rtc
+        self.rtr = rtr
+        self.ic = ic
+        self.dv = dv
+
     @staticmethod
     def from_bytes(data: bytes) -> RFCOMM_MCC_MSC:
         return RFCOMM_MCC_MSC(
@@ -439,6 +409,16 @@ class RFCOMM_MCC_MSC:
             ]
         )
 
+    def __str__(self) -> str:
+        return (
+            f'MSC(dlci={self.dlci},'
+            f'fc={self.fc},'
+            f'rtc={self.rtc},'
+            f'rtr={self.rtr},'
+            f'ic={self.ic},'
+            f'dv={self.dv})'
+        )
+
 
 # -----------------------------------------------------------------------------
 class DLC(EventEmitter):
@@ -450,58 +430,35 @@ class DLC(EventEmitter):
         DISCONNECTED = 0x04
         RESET = 0x05
 
+    connection_result: Optional[asyncio.Future]
+    sink: Optional[Callable[[bytes], None]]
+
     def __init__(
         self,
         multiplexer: Multiplexer,
         dlci: int,
-        tx_max_frame_size: int,
-        tx_initial_credits: int,
-        rx_max_frame_size: int,
-        rx_initial_credits: int,
+        max_frame_size: int,
+        initial_tx_credits: int,
     ) -> None:
         super().__init__()
         self.multiplexer = multiplexer
         self.dlci = dlci
-        self.rx_max_frame_size = rx_max_frame_size
-        self.rx_initial_credits = rx_initial_credits
-        self.rx_max_credits = RFCOMM_DEFAULT_MAX_CREDITS
-        self.rx_credits = rx_initial_credits
-        self.rx_credits_threshold = RFCOMM_DEFAULT_CREDIT_THRESHOLD
-        self.tx_max_frame_size = tx_max_frame_size
-        self.tx_credits = tx_initial_credits
+        self.rx_credits = RFCOMM_DEFAULT_INITIAL_RX_CREDITS
+        self.rx_threshold = self.rx_credits // 2
+        self.tx_credits = initial_tx_credits
         self.tx_buffer = b''
         self.state = DLC.State.INIT
         self.role = multiplexer.role
         self.c_r = 1 if self.role == Multiplexer.Role.INITIATOR else 0
-        self.connection_result: Optional[asyncio.Future] = None
-        self.disconnection_result: Optional[asyncio.Future] = None
-        self.drained = asyncio.Event()
-        self.drained.set()
-        # Queued packets when sink is not set.
-        self._enqueued_rx_packets: collections.deque[bytes] = collections.deque(
-            maxlen=DEFAULT_RX_QUEUE_SIZE
-        )
-        self._sink: Optional[Callable[[bytes], None]] = None
+        self.sink = None
+        self.connection_result = None
 
         # Compute the MTU
         max_overhead = 4 + 1  # header with 2-byte length + fcs
         self.mtu = min(
-            tx_max_frame_size, self.multiplexer.l2cap_channel.peer_mtu - max_overhead
+            max_frame_size, self.multiplexer.l2cap_channel.mtu - max_overhead
         )
 
-    @property
-    def sink(self) -> Optional[Callable[[bytes], None]]:
-        return self._sink
-
-    @sink.setter
-    def sink(self, sink: Optional[Callable[[bytes], None]]) -> None:
-        self._sink = sink
-        # Dump queued packets to sink
-        if sink:
-            for packet in self._enqueued_rx_packets:
-                sink(packet)  # pylint: disable=not-callable
-            self._enqueued_rx_packets.clear()
-
     def change_state(self, new_state: State) -> None:
         logger.debug(f'{self} state change -> {color(new_state.name, "magenta")}')
         self.state = new_state
@@ -510,7 +467,7 @@ class DLC(EventEmitter):
         self.multiplexer.send_frame(frame)
 
     def on_frame(self, frame: RFCOMM_Frame) -> None:
-        handler = getattr(self, f'on_{frame.type.name}_frame'.lower())
+        handler = getattr(self, f'on_{frame.type_name()}_frame'.lower())
         handler(frame)
 
     def on_sabm_frame(self, _frame: RFCOMM_Frame) -> None:
@@ -524,7 +481,9 @@ class DLC(EventEmitter):
 
         # Exchange the modem status with the peer
         msc = RFCOMM_MCC_MSC(dlci=self.dlci, fc=0, rtc=1, rtr=1, ic=0, dv=1)
-        mcc = RFCOMM_Frame.make_mcc(mcc_type=MccType.MSC, c_r=1, data=bytes(msc))
+        mcc = RFCOMM_Frame.make_mcc(
+            mcc_type=RFCOMM_MCC_MSC_TYPE, c_r=1, data=bytes(msc)
+        )
         logger.debug(f'>>> MCC MSC Command: {msc}')
         self.send_frame(RFCOMM_Frame.uih(c_r=self.c_r, dlci=0, information=mcc))
 
@@ -532,35 +491,22 @@ class DLC(EventEmitter):
         self.emit('open')
 
     def on_ua_frame(self, _frame: RFCOMM_Frame) -> None:
-        if self.state == DLC.State.CONNECTING:
-            # Exchange the modem status with the peer
-            msc = RFCOMM_MCC_MSC(dlci=self.dlci, fc=0, rtc=1, rtr=1, ic=0, dv=1)
-            mcc = RFCOMM_Frame.make_mcc(mcc_type=MccType.MSC, c_r=1, data=bytes(msc))
-            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)
-            if self.connection_result:
-                self.connection_result.set_result(None)
-                self.connection_result = None
-            self.multiplexer.on_dlc_open_complete(self)
-        elif self.state == DLC.State.DISCONNECTING:
-            self.change_state(DLC.State.DISCONNECTED)
-            if self.disconnection_result:
-                self.disconnection_result.set_result(None)
-                self.disconnection_result = None
-            self.multiplexer.on_dlc_disconnection(self)
-            self.emit('close')
-        else:
+        if self.state != DLC.State.CONNECTING:
             logger.warning(
-                color(
-                    (
-                        '!!! received UA frame when not in '
-                        'CONNECTING or DISCONNECTING state'
-                    ),
-                    'red',
-                )
+                color('!!! received SABM when not in CONNECTING state', 'red')
             )
+            return
+
+        # Exchange the modem status with the peer
+        msc = RFCOMM_MCC_MSC(dlci=self.dlci, fc=0, rtc=1, rtr=1, ic=0, dv=1)
+        mcc = RFCOMM_Frame.make_mcc(
+            mcc_type=RFCOMM_MCC_MSC_TYPE, c_r=1, data=bytes(msc)
+        )
+        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.multiplexer.on_dlc_open_complete(self)
 
     def on_dm_frame(self, frame: RFCOMM_Frame) -> None:
         # TODO: handle all states
@@ -588,22 +534,14 @@ class DLC(EventEmitter):
             f'[{self.dlci}] {len(data)} bytes, '
             f'rx_credits={self.rx_credits}: {data.hex()}'
         )
-        if data:
-            if self._sink:
-                self._sink(data)  # pylint: disable=not-callable
-            else:
-                self._enqueued_rx_packets.append(data)
-            if (
-                self._enqueued_rx_packets.maxlen
-                and len(self._enqueued_rx_packets) >= self._enqueued_rx_packets.maxlen
-            ):
-                logger.warning(f'DLC [{self.dlci}] received packet queue is full')
+        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()
@@ -616,7 +554,9 @@ class DLC(EventEmitter):
             # Command
             logger.debug(f'<<< MCC MSC Command: {msc}')
             msc = RFCOMM_MCC_MSC(dlci=self.dlci, fc=0, rtc=1, rtr=1, ic=0, dv=1)
-            mcc = RFCOMM_Frame.make_mcc(mcc_type=MccType.MSC, c_r=0, data=bytes(msc))
+            mcc = RFCOMM_Frame.make_mcc(
+                mcc_type=RFCOMM_MCC_MSC_TYPE, c_r=0, data=bytes(msc)
+            )
             logger.debug(f'>>> MCC MSC Response: {msc}')
             self.send_frame(RFCOMM_Frame.uih(c_r=self.c_r, dlci=0, information=mcc))
         else:
@@ -631,19 +571,6 @@ class DLC(EventEmitter):
         self.connection_result = asyncio.get_running_loop().create_future()
         self.send_frame(RFCOMM_Frame.sabm(c_r=self.c_r, dlci=self.dlci))
 
-    async def disconnect(self) -> None:
-        if self.state != DLC.State.CONNECTED:
-            raise InvalidStateError('invalid state')
-
-        self.disconnection_result = asyncio.get_running_loop().create_future()
-        self.change_state(DLC.State.DISCONNECTING)
-        self.send_frame(
-            RFCOMM_Frame.disc(
-                c_r=1 if self.role == Multiplexer.Role.INITIATOR else 0, dlci=self.dlci
-            )
-        )
-        await self.disconnection_result
-
     def accept(self) -> None:
         if self.state != DLC.State.INIT:
             raise InvalidStateError('invalid state')
@@ -653,18 +580,18 @@ class DLC(EventEmitter):
             cl=0xE0,
             priority=7,
             ack_timer=0,
-            max_frame_size=self.rx_max_frame_size,
+            max_frame_size=RFCOMM_DEFAULT_PREFERRED_MTU,
             max_retransmissions=0,
-            initial_credits=self.rx_initial_credits,
+            window_size=RFCOMM_DEFAULT_INITIAL_RX_CREDITS,
         )
-        mcc = RFCOMM_Frame.make_mcc(mcc_type=MccType.PN, c_r=0, data=bytes(pn))
+        mcc = RFCOMM_Frame.make_mcc(mcc_type=RFCOMM_MCC_PN_TYPE, c_r=0, data=bytes(pn))
         logger.debug(f'>>> PN Response: {pn}')
         self.send_frame(RFCOMM_Frame.uih(c_r=self.c_r, dlci=0, information=mcc))
         self.change_state(DLC.State.CONNECTING)
 
     def rx_credits_needed(self) -> int:
-        if self.rx_credits <= self.rx_credits_threshold:
-            return self.rx_max_credits - self.rx_credits
+        if self.rx_credits <= self.rx_threshold:
+            return RFCOMM_DEFAULT_INITIAL_RX_CREDITS - self.rx_credits
 
         return 0
 
@@ -704,8 +631,6 @@ class DLC(EventEmitter):
             )
 
             rx_credits_needed = 0
-            if not self.tx_buffer:
-                self.drained.set()
 
     # Stream protocol
     def write(self, data: Union[bytes, str]) -> None:
@@ -715,37 +640,17 @@ class DLC(EventEmitter):
                 # Automatically convert strings to bytes using UTF-8
                 data = data.encode('utf-8')
             else:
-                raise InvalidArgumentError('write only accept bytes or strings')
+                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 abort(self) -> None:
-        logger.debug(f'aborting DLC: {self}')
-        if self.connection_result:
-            self.connection_result.cancel()
-            self.connection_result = None
-        if self.disconnection_result:
-            self.disconnection_result.cancel()
-            self.disconnection_result = None
-        self.change_state(DLC.State.RESET)
-        self.emit('close')
+    def drain(self) -> None:
+        # TODO
+        pass
 
     def __str__(self) -> str:
-        return (
-            f'DLC(dlci={self.dlci}, '
-            f'state={self.state.name}, '
-            f'rx_max_frame_size={self.rx_max_frame_size}, '
-            f'rx_credits={self.rx_credits}, '
-            f'rx_max_credits={self.rx_max_credits}, '
-            f'tx_max_frame_size={self.tx_max_frame_size}, '
-            f'tx_credits={self.tx_credits}'
-            ')'
-        )
+        return f'DLC(dlci={self.dlci},state={self.state.name})'
 
 
 # -----------------------------------------------------------------------------
@@ -766,10 +671,10 @@ class Multiplexer(EventEmitter):
     connection_result: Optional[asyncio.Future]
     disconnection_result: Optional[asyncio.Future]
     open_result: Optional[asyncio.Future]
-    acceptor: Optional[Callable[[int], Optional[Tuple[int, int]]]]
+    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: Role) -> None:
         super().__init__()
         self.role = role
         self.l2cap_channel = l2cap_channel
@@ -778,15 +683,11 @@ class Multiplexer(EventEmitter):
         self.connection_result = None
         self.disconnection_result = None
         self.open_result = None
-        self.open_pn: Optional[RFCOMM_MCC_PN] = None
-        self.open_rx_max_credits = 0
         self.acceptor = None
 
         # Become a sink for the L2CAP channel
         l2cap_channel.sink = self.on_pdu
 
-        l2cap_channel.on('close', self.on_l2cap_channel_close)
-
     def change_state(self, new_state: State) -> None:
         logger.debug(f'{self} state change -> {color(new_state.name, "cyan")}')
         self.state = new_state
@@ -803,7 +704,7 @@ class Multiplexer(EventEmitter):
         if frame.dlci == 0:
             self.on_frame(frame)
         else:
-            if frame.type == FrameType.DM:
+            if frame.type == RFCOMM_DM_FRAME:
                 # DM responses are for a DLCI, but since we only create the dlc when we
                 # receive a PN response (because we need the parameters), we handle DM
                 # frames at the Multiplexer level
@@ -816,7 +717,7 @@ class Multiplexer(EventEmitter):
                 dlc.on_frame(frame)
 
     def on_frame(self, frame: RFCOMM_Frame) -> None:
-        handler = getattr(self, f'on_{frame.type.name}_frame'.lower())
+        handler = getattr(self, f'on_{frame.type_name()}_frame'.lower())
         handler(frame)
 
     def on_sabm_frame(self, _frame: RFCOMM_Frame) -> None:
@@ -850,7 +751,6 @@ class Multiplexer(EventEmitter):
                         'rfcomm',
                     )
                 )
-                self.open_result = None
         else:
             logger.warning(f'unexpected state for DM: {self}')
 
@@ -865,10 +765,10 @@ class Multiplexer(EventEmitter):
     def on_uih_frame(self, frame: RFCOMM_Frame) -> None:
         (mcc_type, c_r, value) = RFCOMM_Frame.parse_mcc(frame.information)
 
-        if mcc_type == MccType.PN:
+        if mcc_type == RFCOMM_MCC_PN_TYPE:
             pn = RFCOMM_MCC_PN.from_bytes(value)
             self.on_mcc_pn(c_r, pn)
-        elif mcc_type == MccType.MSC:
+        elif mcc_type == RFCOMM_MCC_MSC_TYPE:
             mcs = RFCOMM_MCC_MSC.from_bytes(value)
             self.on_mcc_msc(c_r, mcs)
 
@@ -888,16 +788,9 @@ class Multiplexer(EventEmitter):
             else:
                 if self.acceptor:
                     channel_number = pn.dlci >> 1
-                    if dlc_params := self.acceptor(channel_number):
+                    if self.acceptor(channel_number):
                         # Create a new DLC
-                        dlc = DLC(
-                            self,
-                            dlci=pn.dlci,
-                            tx_max_frame_size=pn.max_frame_size,
-                            tx_initial_credits=pn.initial_credits,
-                            rx_max_frame_size=dlc_params[0],
-                            rx_initial_credits=dlc_params[1],
-                        )
+                        dlc = DLC(self, pn.dlci, pn.max_frame_size, pn.window_size)
                         self.dlcs[pn.dlci] = dlc
 
                         # Re-emit the handshake completion event
@@ -915,17 +808,8 @@ class Multiplexer(EventEmitter):
             # Response
             logger.debug(f'>>> PN Response: {pn}')
             if self.state == Multiplexer.State.OPENING:
-                assert self.open_pn
-                dlc = DLC(
-                    self,
-                    dlci=pn.dlci,
-                    tx_max_frame_size=pn.max_frame_size,
-                    tx_initial_credits=pn.initial_credits,
-                    rx_max_frame_size=self.open_pn.max_frame_size,
-                    rx_initial_credits=self.open_pn.initial_credits,
-                )
+                dlc = DLC(self, pn.dlci, pn.max_frame_size, pn.window_size)
                 self.dlcs[pn.dlci] = dlc
-                self.open_pn = None
                 dlc.connect()
             else:
                 logger.warning('ignoring PN response')
@@ -959,31 +843,24 @@ class Multiplexer(EventEmitter):
         )
         await self.disconnection_result
 
-    async def open_dlc(
-        self,
-        channel: int,
-        max_frame_size: int = RFCOMM_DEFAULT_MAX_FRAME_SIZE,
-        initial_credits: int = RFCOMM_DEFAULT_INITIAL_CREDITS,
-    ) -> DLC:
+    async def open_dlc(self, channel: int) -> DLC:
         if self.state != Multiplexer.State.CONNECTED:
             if self.state == Multiplexer.State.OPENING:
                 raise InvalidStateError('open already in progress')
 
             raise InvalidStateError('not connected')
 
-        self.open_pn = RFCOMM_MCC_PN(
+        pn = RFCOMM_MCC_PN(
             dlci=channel << 1,
             cl=0xF0,
             priority=7,
             ack_timer=0,
-            max_frame_size=max_frame_size,
+            max_frame_size=RFCOMM_DEFAULT_PREFERRED_MTU,
             max_retransmissions=0,
-            initial_credits=initial_credits,
+            window_size=RFCOMM_DEFAULT_INITIAL_RX_CREDITS,
         )
-        mcc = RFCOMM_Frame.make_mcc(
-            mcc_type=MccType.PN, c_r=1, data=bytes(self.open_pn)
-        )
-        logger.debug(f'>>> Sending MCC: {self.open_pn}')
+        mcc = RFCOMM_Frame.make_mcc(mcc_type=RFCOMM_MCC_PN_TYPE, c_r=1, data=bytes(pn))
+        logger.debug(f'>>> Sending MCC: {pn}')
         self.open_result = asyncio.get_running_loop().create_future()
         self.change_state(Multiplexer.State.OPENING)
         self.send_frame(
@@ -993,31 +870,15 @@ class Multiplexer(EventEmitter):
                 information=mcc,
             )
         )
-        return await self.open_result
+        result = await self.open_result
+        self.open_result = None
+        return result
 
     def on_dlc_open_complete(self, dlc: DLC) -> None:
         logger.debug(f'DLC [{dlc.dlci}] open complete')
-
         self.change_state(Multiplexer.State.CONNECTED)
-
         if self.open_result:
             self.open_result.set_result(dlc)
-            self.open_result = None
-
-    def on_dlc_disconnection(self, dlc: DLC) -> None:
-        logger.debug(f'DLC [{dlc.dlci}] disconnection')
-        self.dlcs.pop(dlc.dlci, None)
-
-    def on_l2cap_channel_close(self) -> None:
-        logger.debug('L2CAP channel closed, cleaning up')
-        if self.open_result:
-            self.open_result.cancel()
-            self.open_result = None
-        if self.disconnection_result:
-            self.disconnection_result.cancel()
-            self.disconnection_result = None
-        for dlc in self.dlcs.values():
-            dlc.abort()
 
     def __str__(self) -> str:
         return f'Multiplexer(state={self.state.name})'
@@ -1026,28 +887,26 @@ class Multiplexer(EventEmitter):
 # -----------------------------------------------------------------------------
 class Client:
     multiplexer: Optional[Multiplexer]
-    l2cap_channel: Optional[l2cap.ClassicChannel]
+    l2cap_channel: Optional[l2cap.Channel]
 
-    def __init__(
-        self, connection: Connection, l2cap_mtu: int = RFCOMM_DEFAULT_L2CAP_MTU
-    ) -> None:
+    def __init__(self, device: Device, connection: Connection) -> None:
+        self.device = device
         self.connection = connection
-        self.l2cap_mtu = l2cap_mtu
         self.l2cap_channel = None
         self.multiplexer = None
 
     async def start(self) -> Multiplexer:
         # Create a new L2CAP connection
         try:
-            self.l2cap_channel = await self.connection.create_l2cap_channel(
-                spec=l2cap.ClassicChannelSpec(psm=RFCOMM_PSM, mtu=self.l2cap_mtu)
+            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
+        # Create a mutliplexer to manage DLCs with the server
         self.multiplexer = Multiplexer(self.l2cap_channel, Multiplexer.Role.INITIATOR)
 
         # Connect the multiplexer
@@ -1063,40 +922,23 @@ class Client:
         self.multiplexer = None
 
         # Close the L2CAP channel
-        if self.l2cap_channel:
-            await self.l2cap_channel.disconnect()
-            self.l2cap_channel = None
-
-    async def __aenter__(self) -> Multiplexer:
-        return await self.start()
-
-    async def __aexit__(self, *args) -> None:
-        await self.shutdown()
+        # TODO
 
 
 # -----------------------------------------------------------------------------
 class Server(EventEmitter):
-    def __init__(
-        self, device: Device, l2cap_mtu: int = RFCOMM_DEFAULT_L2CAP_MTU
-    ) -> None:
+    acceptors: Dict[int, Callable[[DLC], None]]
+
+    def __init__(self, device: Device) -> None:
         super().__init__()
         self.device = device
-        self.acceptors: Dict[int, Callable[[DLC], None]] = {}
-        self.dlc_configs: Dict[int, Tuple[int, int]] = {}
+        self.multiplexer = None
+        self.acceptors = {}
 
         # Register ourselves with the L2CAP channel manager
-        self.l2cap_server = device.create_l2cap_server(
-            spec=l2cap.ClassicChannelSpec(psm=RFCOMM_PSM, mtu=l2cap_mtu),
-            handler=self.on_connection,
-        )
+        device.register_l2cap_server(RFCOMM_PSM, self.on_connection)
 
-    def listen(
-        self,
-        acceptor: Callable[[DLC], None],
-        channel: int = 0,
-        max_frame_size: int = RFCOMM_DEFAULT_MAX_FRAME_SIZE,
-        initial_credits: int = RFCOMM_DEFAULT_INITIAL_CREDITS,
-    ) -> int:
+    def listen(self, acceptor: Callable[[DLC], None], channel: int = 0) -> int:
         if channel:
             if channel in self.acceptors:
                 # Busy
@@ -1116,15 +958,13 @@ class Server(EventEmitter):
                 return 0
 
         self.acceptors[channel] = acceptor
-        self.dlc_configs[channel] = (max_frame_size, initial_credits)
-
         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
@@ -1135,18 +975,13 @@ class Server(EventEmitter):
         # Notify
         self.emit('start', multiplexer)
 
-    def accept_dlc(self, channel_number: int) -> Optional[Tuple[int, int]]:
-        return self.dlc_configs.get(channel_number)
+    def accept_dlc(self, channel_number: int) -> bool:
+        return channel_number in self.acceptors
 
     def on_dlc(self, dlc: DLC) -> None:
         logger.debug(f'@@@ new DLC connected: {dlc}')
 
         # Let the acceptor know
-        if acceptor := self.acceptors.get(dlc.dlci >> 1):
+        acceptor = self.acceptors.get(dlc.dlci >> 1)
+        if acceptor:
             acceptor(dlc)
-
-    def __enter__(self) -> Self:
-        return self
-
-    def __exit__(self, *args) -> None:
-        self.l2cap_server.close()

bumble/rtp.py

@@ -1,110 +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
-# -----------------------------------------------------------------------------
-from __future__ import annotations
-import struct
-from typing import List
-
-
-# -----------------------------------------------------------------------------
-class MediaPacket:
-    @staticmethod
-    def from_bytes(data: bytes) -> MediaPacket:
-        version = (data[0] >> 6) & 0x03
-        padding = (data[0] >> 5) & 0x01
-        extension = (data[0] >> 4) & 0x01
-        csrc_count = data[0] & 0x0F
-        marker = (data[1] >> 7) & 0x01
-        payload_type = data[1] & 0x7F
-        sequence_number = struct.unpack_from('>H', data, 2)[0]
-        timestamp = struct.unpack_from('>I', data, 4)[0]
-        ssrc = struct.unpack_from('>I', data, 8)[0]
-        csrc_list = [
-            struct.unpack_from('>I', data, 12 + i)[0] for i in range(csrc_count)
-        ]
-        payload = data[12 + csrc_count * 4 :]
-
-        return MediaPacket(
-            version,
-            padding,
-            extension,
-            marker,
-            sequence_number,
-            timestamp,
-            ssrc,
-            csrc_list,
-            payload_type,
-            payload,
-        )
-
-    def __init__(
-        self,
-        version: int,
-        padding: int,
-        extension: int,
-        marker: int,
-        sequence_number: int,
-        timestamp: int,
-        ssrc: int,
-        csrc_list: List[int],
-        payload_type: int,
-        payload: bytes,
-    ) -> None:
-        self.version = version
-        self.padding = padding
-        self.extension = extension
-        self.marker = marker
-        self.sequence_number = sequence_number & 0xFFFF
-        self.timestamp = timestamp & 0xFFFFFFFF
-        self.timestamp_seconds = 0.0
-        self.ssrc = ssrc
-        self.csrc_list = csrc_list
-        self.payload_type = payload_type
-        self.payload = payload
-
-    def __bytes__(self) -> bytes:
-        header = bytes(
-            [
-                self.version << 6
-                | self.padding << 5
-                | self.extension << 4
-                | len(self.csrc_list),
-                self.marker << 7 | self.payload_type,
-            ]
-        ) + struct.pack(
-            '>HII',
-            self.sequence_number,
-            self.timestamp,
-            self.ssrc,
-        )
-        for csrc in self.csrc_list:
-            header += struct.pack('>I', csrc)
-        return header + self.payload
-
-    def __str__(self) -> str:
-        return (
-            f'RTP(v={self.version},'
-            f'p={self.padding},'
-            f'x={self.extension},'
-            f'm={self.marker},'
-            f'pt={self.payload_type},'
-            f'sn={self.sequence_number},'
-            f'ts={self.timestamp},'
-            f'ssrc={self.ssrc},'
-            f'csrcs={self.csrc_list},'
-            f'payload_size={len(self.payload)})'
-        )

bumble/sdp.py

@@ -19,11 +19,10 @@ from __future__ import annotations
 import logging
 import struct
 from typing import Dict, List, Type, Optional, Tuple, Union, NewType, TYPE_CHECKING
-from typing_extensions import Self
 
 from . import core, l2cap
 from .colors import color
-from .core import InvalidStateError, InvalidArgumentError, InvalidPacketError
+from .core import InvalidStateError
 from .hci import HCI_Object, name_or_number, key_with_value
 
 if TYPE_CHECKING:
@@ -98,8 +97,7 @@ SDP_CLIENT_EXECUTABLE_URL_ATTRIBUTE_ID               = 0X000B
 SDP_ICON_URL_ATTRIBUTE_ID                            = 0X000C
 SDP_ADDITIONAL_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID = 0X000D
 
-
-# Profile-specific Attribute Identifiers (cf. Assigned Numbers for Service Discovery)
+# Attribute Identifier (cf. Assigned Numbers for Service Discovery)
 # used by AVRCP, HFP and A2DP
 SDP_SUPPORTED_FEATURES_ATTRIBUTE_ID = 0x0311
 
@@ -117,8 +115,7 @@ SDP_ATTRIBUTE_ID_NAMES = {
     SDP_DOCUMENTATION_URL_ATTRIBUTE_ID:                   'SDP_DOCUMENTATION_URL_ATTRIBUTE_ID',
     SDP_CLIENT_EXECUTABLE_URL_ATTRIBUTE_ID:               'SDP_CLIENT_EXECUTABLE_URL_ATTRIBUTE_ID',
     SDP_ICON_URL_ATTRIBUTE_ID:                            'SDP_ICON_URL_ATTRIBUTE_ID',
-    SDP_ADDITIONAL_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID: 'SDP_ADDITIONAL_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID',
-    SDP_SUPPORTED_FEATURES_ATTRIBUTE_ID:                  'SDP_SUPPORTED_FEATURES_ATTRIBUTE_ID',
+    SDP_ADDITIONAL_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID: 'SDP_ADDITIONAL_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID'
 }
 
 SDP_PUBLIC_BROWSE_ROOT = core.UUID.from_16_bits(0x1002, 'PublicBrowseRoot')
@@ -170,7 +167,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)
@@ -189,9 +186,7 @@ class DataElement:
         self.bytes = None
         if element_type in (DataElement.UNSIGNED_INTEGER, DataElement.SIGNED_INTEGER):
             if value_size is None:
-                raise InvalidArgumentError(
-                    'integer types must have a value size specified'
-                )
+                raise ValueError('integer types must have a value size specified')
 
     @staticmethod
     def nil() -> DataElement:
@@ -234,7 +229,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
@@ -267,7 +262,7 @@ class DataElement:
         if len(data) == 8:
             return struct.unpack('>Q', data)[0]
 
-        raise InvalidPacketError(f'invalid integer length {len(data)}')
+        raise ValueError(f'invalid integer length {len(data)}')
 
     @staticmethod
     def signed_integer_from_bytes(data):
@@ -283,7 +278,7 @@ class DataElement:
         if len(data) == 8:
             return struct.unpack('>q', data)[0]
 
-        raise InvalidPacketError(f'invalid integer length {len(data)}')
+        raise ValueError(f'invalid integer length {len(data)}')
 
     @staticmethod
     def list_from_bytes(data):
@@ -356,7 +351,7 @@ class DataElement:
             data = b''
         elif self.type == DataElement.UNSIGNED_INTEGER:
             if self.value < 0:
-                raise InvalidArgumentError('UNSIGNED_INTEGER cannot be negative')
+                raise ValueError('UNSIGNED_INTEGER cannot be negative')
 
             if self.value_size == 1:
                 data = struct.pack('B', self.value)
@@ -367,7 +362,7 @@ class DataElement:
             elif self.value_size == 8:
                 data = struct.pack('>Q', self.value)
             else:
-                raise InvalidArgumentError('invalid value_size')
+                raise ValueError('invalid value_size')
         elif self.type == DataElement.SIGNED_INTEGER:
             if self.value_size == 1:
                 data = struct.pack('b', self.value)
@@ -378,10 +373,10 @@ class DataElement:
             elif self.value_size == 8:
                 data = struct.pack('>q', self.value)
             else:
-                raise InvalidArgumentError('invalid value_size')
+                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])
@@ -394,7 +389,7 @@ class DataElement:
         size_bytes = b''
         if self.type == DataElement.NIL:
             if size != 0:
-                raise InvalidArgumentError('NIL must be empty')
+                raise ValueError('NIL must be empty')
             size_index = 0
         elif self.type in (
             DataElement.UNSIGNED_INTEGER,
@@ -412,7 +407,7 @@ class DataElement:
             elif size == 16:
                 size_index = 4
             else:
-                raise InvalidArgumentError('invalid data size')
+                raise ValueError('invalid data size')
         elif self.type in (
             DataElement.TEXT_STRING,
             DataElement.SEQUENCE,
@@ -429,10 +424,10 @@ class DataElement:
                 size_index = 7
                 size_bytes = struct.pack('>I', size)
             else:
-                raise InvalidArgumentError('invalid data size')
+                raise ValueError('invalid data size')
         elif self.type == DataElement.BOOLEAN:
             if size != 1:
-                raise InvalidArgumentError('boolean must be 1 byte')
+                raise ValueError('boolean must be 1 byte')
             size_index = 0
 
         self.bytes = bytes([self.type << 3 | size_index]) + size_bytes + data
@@ -763,17 +758,16 @@ class SDP_ServiceSearchAttributeResponse(SDP_PDU):
 
 # -----------------------------------------------------------------------------
 class Client:
-    channel: Optional[l2cap.ClassicChannel]
+    channel: Optional[l2cap.Channel]
 
-    def __init__(self, connection: Connection) -> None:
-        self.connection = connection
+    def __init__(self, device: Device) -> None:
+        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: Connection) -> None:
+        result = await self.device.l2cap_channel_manager.connect(connection, SDP_PSM)
+        self.channel = result
 
     async def disconnect(self) -> None:
         if self.channel:
@@ -827,13 +821,11 @@ class Client:
         )
         attribute_id_list = DataElement.sequence(
             [
-                (
-                    DataElement.unsigned_integer(
-                        attribute_id[0], value_size=attribute_id[1]
-                    )
-                    if isinstance(attribute_id, tuple)
-                    else DataElement.unsigned_integer_16(attribute_id)
+                DataElement.unsigned_integer(
+                    attribute_id[0], value_size=attribute_id[1]
                 )
+                if isinstance(attribute_id, tuple)
+                else DataElement.unsigned_integer_16(attribute_id)
                 for attribute_id in attribute_ids
             ]
         )
@@ -885,13 +877,11 @@ class Client:
 
         attribute_id_list = DataElement.sequence(
             [
-                (
-                    DataElement.unsigned_integer(
-                        attribute_id[0], value_size=attribute_id[1]
-                    )
-                    if isinstance(attribute_id, tuple)
-                    else DataElement.unsigned_integer_16(attribute_id)
+                DataElement.unsigned_integer(
+                    attribute_id[0], value_size=attribute_id[1]
                 )
+                if isinstance(attribute_id, tuple)
+                else DataElement.unsigned_integer_16(attribute_id)
                 for attribute_id in attribute_ids
             ]
         )
@@ -927,18 +917,11 @@ class Client:
 
         return ServiceAttribute.list_from_data_elements(attribute_list_sequence.value)
 
-    async def __aenter__(self) -> Self:
-        await self.connect()
-        return self
-
-    async def __aexit__(self, *args) -> None:
-        await self.disconnect()
-
 
 # -----------------------------------------------------------------------------
 class Server:
     CONTINUATION_STATE = bytes([0x01, 0x43])
-    channel: Optional[l2cap.ClassicChannel]
+    channel: Optional[l2cap.Channel]
     Service = NewType('Service', List[ServiceAttribute])
     service_records: Dict[int, Service]
     current_response: Union[None, bytes, Tuple[int, List[int]]]
@@ -950,9 +933,7 @@ class Server:
         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
-        )
+        l2cap_channel_manager.register_server(SDP_PSM, self.on_connection)
 
     def send_response(self, response):
         logger.debug(f'{color(">>> Sending SDP Response", "blue")}: {response}')
@@ -999,7 +980,7 @@ class Server:
             try:
                 handler(sdp_pdu)
             except Exception as error:
-                logger.exception(f'{color("!!! Exception in handler:", "red")} {error}')
+                logger.warning(f'{color("!!! Exception in handler:", "red")} {error}')
                 self.send_response(
                     SDP_ErrorResponse(
                         transaction_id=sdp_pdu.transaction_id,

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,8 +52,6 @@ from .core import (
     BT_BR_EDR_TRANSPORT,
     BT_CENTRAL_ROLE,
     BT_LE_TRANSPORT,
-    AdvertisingData,
-    InvalidArgumentError,
     ProtocolError,
     name_or_number,
 )
@@ -188,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
@@ -566,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
@@ -678,13 +626,6 @@ class Session:
         },
     }
 
-    ea: bytes
-    eb: bytes
-    ltk: bytes
-    preq: bytes
-    pres: bytes
-    tk: bytes
-
     def __init__(
         self,
         manager: Manager,
@@ -694,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
@@ -710,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()
@@ -738,9 +686,9 @@ class Session:
 
         # Create a future that can be used to wait for the session to complete
         if self.is_initiator:
-            self.pairing_result: Optional[asyncio.Future[None]] = (
-                asyncio.get_running_loop().create_future()
-            )
+            self.pairing_result: Optional[
+                asyncio.Future[None]
+            ] = asyncio.get_running_loop().create_future()
         else:
             self.pairing_result = None
 
@@ -763,17 +711,12 @@ 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 = (
-            1 if pairing_config.oob and pairing_config.oob.peer_data else 0
-        )
+        # OOB (not supported yet)
+        self.oob = False
 
         # Set up addresses
-        self_address = connection.self_resolvable_address or connection.self_address
+        self_address = connection.self_address
         peer_address = connection.peer_resolvable_address or connection.peer_address
-        logger.debug(
-            f"pairing with self_address={self_address}, peer_address={peer_address}"
-        )
         if self.is_initiator:
             self.ia = bytes(self_address)
             self.iat = 1 if self_address.is_random else 0
@@ -785,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 InvalidArgumentError(
-                        "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 InvalidArgumentError(
-                        "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:
@@ -850,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
@@ -994,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,
@@ -1006,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,
@@ -1016,10 +930,8 @@ class Session:
         self.send_command(response)
 
     def send_pairing_confirm_command(self) -> None:
-
-        if self.pairing_method != PairingMethod.OOB:
-            self.r = crypto.r()
-            logger.debug(f'generated random: {self.r.hex()}')
+        self.r = crypto.r()
+        logger.debug(f'generated random: {self.r.hex()}')
 
         if self.sc:
 
@@ -1069,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)),
             )
         )
 
@@ -1082,19 +994,11 @@ class Session:
         )
 
     def send_identity_address_command(self) -> None:
-        if self.pairing_config.identity_address_type == Address.PUBLIC_DEVICE_ADDRESS:
-            identity_address = self.manager.device.public_address
-        elif self.pairing_config.identity_address_type == Address.RANDOM_DEVICE_ADDRESS:
-            identity_address = self.manager.device.static_address
-        else:
-            # No identity address type set. If the controller has a public address, it
-            # will be more responsible to be the identity address.
-            if self.manager.device.public_address != Address.ANY:
-                logger.debug("No identity address type set, using PUBLIC")
-                identity_address = self.manager.device.public_address
-            else:
-                logger.debug("No identity address type set, using RANDOM")
-                identity_address = self.manager.device.static_address
+        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,
@@ -1106,7 +1010,7 @@ class Session:
         # 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,
@@ -1114,56 +1018,18 @@ 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.'''
-        self.link_key = await self.manager.device.get_link_key(
-            self.connection.peer_address
-        )
-        if self.link_key is None:
-            logging.warning(
-                'Try to derive LTK but host does not have the LK. Send a SMP_PAIRING_FAILED but the procedure will not be paused!'
-            )
-            self.send_pairing_failed(
-                SMP_CROSS_TRANSPORT_KEY_DERIVATION_NOT_ALLOWED_ERROR
-            )
-        else:
-            self.ltk = self.derive_ltk(self.link_key, self.ct2)
+        self.ltk = crypto.h6(ilk, b'brle')
 
     def distribute_keys(self) -> None:
+
         # Distribute the keys as required
         if self.is_initiator:
             # CTKD: Derive LTK from LinkKey
@@ -1172,7 +1038,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
@@ -1202,7 +1068,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
@@ -1211,7 +1082,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:
@@ -1241,7 +1112,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
@@ -1419,7 +1295,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
                 )
@@ -1456,28 +1332,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
@@ -1526,26 +1389,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
@@ -1696,13 +1548,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:
@@ -1746,23 +1597,8 @@ class Session:
             assert self.passkey
             ra = self.passkey.to_bytes(16, byteorder='little')
             rb = ra
-        elif self.pairing_method == PairingMethod.OOB:
-            if self.is_initiator:
-                if self.peer_oob_data:
-                    rb = self.peer_oob_data.r
-                    ra = self.r
-                else:
-                    rb = bytes(16)
-                    ra = self.r
-            else:
-                if self.peer_oob_data:
-                    ra = self.peer_oob_data.r
-                    rb = self.r
-                else:
-                    ra = bytes(16)
-                    rb = self.r
-
         else:
+            # OOB not implemented yet
             return
 
         assert self.preq and self.pres
@@ -1814,33 +1650,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()
@@ -1851,7 +1672,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()
@@ -1880,6 +1700,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(
@@ -1929,7 +1750,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,
@@ -1951,26 +1771,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:
@@ -1981,6 +1782,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)
 
@@ -2024,8 +1832,10 @@ class Manager(EventEmitter):
     ) -> None:
         # Store the keys in the key store
         if self.device.keystore and identity_address is not None:
-            # Make sure on_pairing emits after key update.
-            await self.device.update_keys(str(identity_address), keys)
+            self.device.abort_on(
+                'flush', self.device.update_keys(str(identity_address), keys)
+            )
+
         # Notify the device
         self.device.on_pairing(session.connection, identity_address, keys, session.sc)
 

bumble/snoop.py

@@ -23,7 +23,6 @@ import datetime
 from typing import BinaryIO, Generator
 import os
 
-from bumble import core
 from bumble.hci import HCI_COMMAND_PACKET, HCI_EVENT_PACKET
 
 
@@ -139,13 +138,13 @@ def create_snooper(spec: str) -> Generator[Snooper, None, None]:
 
     """
     if ':' not in spec:
-        raise core.InvalidArgumentError('snooper type prefix missing')
+        raise ValueError('snooper type prefix missing')
 
     snooper_type, snooper_args = spec.split(':', maxsplit=1)
 
     if snooper_type == 'btsnoop':
         if ':' not in snooper_args:
-            raise core.InvalidArgumentError('I/O type for btsnoop snooper type missing')
+            raise ValueError('I/O type for btsnoop snooper type missing')
 
         io_type, io_name = snooper_args.split(':', maxsplit=1)
         if io_type == 'file':
@@ -166,6 +165,6 @@ def create_snooper(spec: str) -> Generator[Snooper, None, None]:
                 _SNOOPER_INSTANCE_COUNT -= 1
                 return
 
-        raise core.InvalidArgumentError(f'I/O type {io_type} not supported')
+        raise ValueError(f'I/O type {io_type} not supported')
 
-    raise core.InvalidArgumentError(f'snooper type {snooper_type} not found')
+    raise ValueError(f'snooper type {snooper_type} not found')

bumble/transport/__init__.py

@@ -18,9 +18,8 @@
 from contextlib import asynccontextmanager
 import logging
 import os
-from typing import Optional
 
-from .common import Transport, AsyncPipeSink, SnoopingTransport, TransportSpecError
+from .common import Transport, AsyncPipeSink, SnoopingTransport
 from ..snoop import create_snooper
 
 # -----------------------------------------------------------------------------
@@ -53,16 +52,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
@@ -80,113 +71,89 @@ async def open_transport(name: str) -> Transport:
       * android-netsim
     """
 
-    scheme, *tail = name.split(':', 1)
-    spec = tail[0] if tail else None
-    metadata = None
-    if spec:
-        # Metadata may precede the spec
-        if spec.startswith('['):
-            metadata_str, *tail = spec[1:].split(']')
-            spec = tail[0] if tail else None
-            metadata = dict([entry.split('=') for entry in metadata_str.split(',')])
-
-    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 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)
+        assert spec is not None
+        return await open_usb_transport(spec[0])
 
     if scheme == 'pyusb':
         from .pyusb import open_pyusb_transport
 
-        assert spec
-        return await open_pyusb_transport(spec)
+        assert spec is not None
+        return await open_pyusb_transport(spec[0])
 
     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)
 
-    if scheme == 'unix':
-        from .unix import open_unix_client_transport
-
-        assert spec
-        return await open_unix_client_transport(spec)
-
-    raise TransportSpecError('unknown transport scheme')
+    raise ValueError('unknown transport scheme')
 
 
 # -----------------------------------------------------------------------------
@@ -203,13 +170,12 @@ async def open_transport_or_link(name: str) -> Transport:
 
     """
     if name.startswith('link-relay:'):
-        logger.warning('Link Relay has been deprecated.')
         from ..controller import Controller
         from ..link import RemoteLink  # lazy import
 
         link = RemoteLink(name[11:])
         await link.wait_until_connected()
-        controller = Controller('remote', link=link)  # type:ignore[arg-type]
+        controller = Controller('remote', link=link)
 
         class LinkTransport(Transport):
             async def close(self):

bumble/transport/android_emulator.py

@@ -20,13 +20,7 @@ import grpc.aio
 
 from typing import Optional, Union
 
-from .common import (
-    PumpedTransport,
-    PumpedPacketSource,
-    PumpedPacketSink,
-    Transport,
-    TransportSpecError,
-)
+from .common import PumpedTransport, PumpedPacketSource, PumpedPacketSink, Transport
 
 # pylint: disable=no-name-in-module
 from .grpc_protobuf.emulated_bluetooth_pb2_grpc import EmulatedBluetoothServiceStub
@@ -75,7 +69,7 @@ async def open_android_emulator_transport(spec: Optional[str]) -> Transport:
     mode = 'host'
     server_host = 'localhost'
     server_port = '8554'
-    if spec:
+    if spec is not None:
         params = spec.split(',')
         for param in params:
             if param.startswith('mode='):
@@ -83,7 +77,7 @@ async def open_android_emulator_transport(spec: Optional[str]) -> Transport:
             elif ':' in param:
                 server_host, server_port = param.split(':')
             else:
-                raise TransportSpecError('invalid parameter')
+                raise ValueError('invalid parameter')
 
     # Connect to the gRPC server
     server_address = f'{server_host}:{server_port}'
@@ -100,16 +94,13 @@ async def open_android_emulator_transport(spec: Optional[str]) -> Transport:
         service = VhciForwardingServiceStub(channel)
         hci_device = HciDevice(service.attachVhci())
     else:
-        raise TransportSpecError('invalid mode')
+        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,36 +18,30 @@
 import asyncio
 import atexit
 import logging
+import grpc.aio
 import os
 import pathlib
-import platform
 import sys
-from typing import Dict, Optional
+from typing import Optional
 
-import grpc.aio
-
-import bumble
-from bumble.transport.common import (
+from .common import (
     ParserSource,
     PumpedTransport,
     PumpedPacketSource,
     PumpedPacketSink,
     Transport,
-    TransportSpecError,
-    TransportInitError,
 )
 
 # pylint: disable=no-name-in-module
-from .grpc_protobuf.netsim.packet_streamer_pb2_grpc import (
-    PacketStreamerStub,
+from .grpc_protobuf.packet_streamer_pb2_grpc import PacketStreamerStub
+from .grpc_protobuf.packet_streamer_pb2_grpc import (
     PacketStreamerServicer,
     add_PacketStreamerServicer_to_server,
 )
-from .grpc_protobuf.netsim.packet_streamer_pb2 import PacketRequest, PacketResponse
-from .grpc_protobuf.netsim.hci_packet_pb2 import HCIPacket
-from .grpc_protobuf.netsim.startup_pb2 import Chip, ChipInfo, DeviceInfo
-from .grpc_protobuf.netsim.common_pb2 import ChipKind
-
+from .grpc_protobuf.packet_streamer_pb2 import PacketRequest, PacketResponse
+from .grpc_protobuf.hci_packet_pb2 import HCIPacket
+from .grpc_protobuf.startup_pb2 import Chip, ChipInfo
+from .grpc_protobuf.common_pb2 import ChipKind
 
 # -----------------------------------------------------------------------------
 # Logging
@@ -60,7 +54,6 @@ logger = logging.getLogger(__name__)
 # -----------------------------------------------------------------------------
 DEFAULT_NAME = 'bumble0'
 DEFAULT_MANUFACTURER = 'Bumble'
-DEFAULT_VARIANT = ''
 
 
 # -----------------------------------------------------------------------------
@@ -73,9 +66,6 @@ def get_ini_dir() -> Optional[pathlib.Path]:
     elif sys.platform == 'linux':
         if xdg_runtime_dir := os.environ.get('XDG_RUNTIME_DIR', None):
             return pathlib.Path(xdg_runtime_dir)
-        tmpdir = os.environ.get('TMPDIR', '/tmp')
-        if pathlib.Path(tmpdir).is_dir():
-            return pathlib.Path(tmpdir)
     elif sys.platform == 'win32':
         if local_app_data_dir := os.environ.get('LOCALAPPDATA', None):
             return pathlib.Path(local_app_data_dir) / 'Temp'
@@ -84,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:
@@ -106,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
@@ -122,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}")
@@ -140,15 +122,14 @@ 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]
+    server_host: Optional[str], server_port: int
 ) -> Transport:
     if not server_port:
-        raise TransportSpecError('invalid 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:
@@ -202,14 +183,18 @@ async def open_android_netsim_controller_transport(
                 data = (
                     bytes([request.hci_packet.packet_type]) + request.hci_packet.packet
                 )
+                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()
@@ -243,19 +228,19 @@ 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')
+                logger.debug('busy, already serving a device')
                 return PacketResponse(error='Busy')
 
             # Instantiate a new device
@@ -276,80 +261,43 @@ 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 TransportInitError('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, variant, manufacturer, hci_device):
+        def __init__(self, name, manufacturer, hci_device):
             self.name = name
-            self.variant = variant
             self.manufacturer = manufacturer
             self.hci_device = hci_device
 
         async def start(self):  # Send the startup info
-            device_info = DeviceInfo(
+            chip_info = ChipInfo(
                 name=self.name,
-                kind='BUMBLE',
-                version=bumble.__version__,
-                sdk_version=platform.python_version(),
-                build_id=platform.platform(),
-                arch=platform.machine(),
-                variant=self.variant,
+                chip=Chip(kind=ChipKind.BLUETOOTH, manufacturer=self.manufacturer),
             )
-            chip = Chip(kind=ChipKind.BLUETOOTH, manufacturer=self.manufacturer)
-            chip_info = ChipInfo(name=self.name, chip=chip, device_info=device_info)
             logger.debug(f'Sending chip info to netsim: {chip_info}')
             await self.hci_device.write(PacketRequest(initial_info=chip_info))
 
         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 TransportInitError(response.error)
-
-            if response_type == 'hci_packet':
+                raise RuntimeError(response.error)
+            elif response_type == 'hci_packet':
                 return (
                     bytes([response.hci_packet.packet_type])
                     + response.hci_packet.packet
                 )
 
-            raise TransportSpecError('unsupported response type')
+            raise ValueError('unsupported response type')
 
         async def write(self, packet):
             await self.hci_device.write(
@@ -358,31 +306,38 @@ async def open_android_netsim_host_transport_with_channel(
                 )
             )
 
-    name = DEFAULT_NAME if options is None else options.get('name', DEFAULT_NAME)
-    variant = (
-        DEFAULT_VARIANT if options is None else options.get('variant', DEFAULT_VARIANT)
-    )
+    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(
         name=name,
-        variant=variant,
         manufacturer=manufacturer,
         hci_device=service.StreamPackets(),
     )
     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()
 
@@ -390,7 +345,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.
@@ -404,11 +359,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,9 +368,6 @@ async def open_android_netsim_transport(spec: Optional[str]) -> Transport:
           The "chip" name, used to identify the "chip" instance. This
           may be useful when several clients are connected, since each needs to use a
           different name.
-        variant=<variant>
-          The device info variant field, which may be used to convey a device or
-          application type (ex: "virtual-speaker", or "keyboard")
 
     In `controller` mode:
       The <host>:<port> part is required. <host> may be the address of a local network
@@ -440,29 +387,26 @@ 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 TransportSpecError('invalid parameter, expected <name>=<value>')
+            raise ValueError('invalid parameter, expected <name>=<value>')
         option_name, option_value = param.split('=')
         options[option_name] = option_value
 
     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 TransportSpecError('<host>:<port> missing')
-        return await open_android_netsim_controller_transport(host, port, options)
+            raise ValueError('<host>:<port> missing')
+        return await open_android_netsim_controller_transport(host, port)
 
-    raise TransportSpecError('invalid mode option')
+    raise ValueError('invalid mode option')

bumble/transport/common.py

@@ -21,9 +21,8 @@ import struct
 import asyncio
 import logging
 import io
-from typing import Any, ContextManager, Tuple, Optional, Protocol, Dict
+from typing import ContextManager, Tuple, Optional, Protocol, Dict
 
-from bumble import core
 from bumble import hci
 from bumble.colors import color
 from bumble.snoop import Snooper
@@ -43,36 +42,31 @@ HCI_PACKET_INFO: Dict[int, Tuple[int, int, str]] = {
     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(core.BaseBumbleError, RuntimeError):
-    """The Transport has been lost/disconnected."""
-
-
-class TransportInitError(core.BaseBumbleError, RuntimeError):
-    """Error raised when the transport cannot be initialized."""
-
-
-class TransportSpecError(core.BaseBumbleError, ValueError):
-    """Error raised when the transport spec is invalid."""
+class TransportLostError(Exception):
+    """
+    The Transport has been lost/disconnected.
+    """
 
 
 # -----------------------------------------------------------------------------
 # Typing Protocols
 # -----------------------------------------------------------------------------
 class TransportSink(Protocol):
-    def on_packet(self, packet: bytes) -> None: ...
+    def on_packet(self, packet: bytes) -> None:
+        ...
 
 
 class TransportSource(Protocol):
     terminated: asyncio.Future[None]
 
-    def set_packet_sink(self, sink: TransportSink) -> None: ...
+    def set_packet_sink(self, sink: TransportSink) -> None:
+        ...
 
 
 # -----------------------------------------------------------------------------
@@ -139,9 +133,7 @@ class PacketParser:
                         packet_type
                     ) or self.extended_packet_info.get(packet_type)
                     if self.packet_info is None:
-                        raise core.InvalidPacketError(
-                            f'invalid packet type {packet_type}'
-                        )
+                        raise ValueError(f'invalid packet type {packet_type}')
                     self.state = PacketParser.NEED_LENGTH
                     self.bytes_needed = self.packet_info[0] + self.packet_info[1]
                 elif self.state == PacketParser.NEED_LENGTH:
@@ -158,7 +150,7 @@ 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()
@@ -175,31 +167,29 @@ class PacketReader:
 
     def __init__(self, source: io.BufferedReader) -> None:
         self.source = source
-        self.at_end = False
 
     def next_packet(self) -> Optional[bytes]:
         # Get the packet type
         packet_type = self.source.read(1)
         if len(packet_type) != 1:
-            self.at_end = True
             return None
 
         # Get the packet info based on its type
         packet_info = HCI_PACKET_INFO.get(packet_type[0])
         if packet_info is None:
-            raise core.InvalidPacketError(f'invalid packet type {packet_type[0]} found')
+            raise ValueError(f'invalid packet type {packet_type[0]} found')
 
         # Read the header (that includes the length)
         header_size = packet_info[0] + packet_info[1]
         header = self.source.read(header_size)
         if len(header) != header_size:
-            raise core.InvalidPacketError('packet too short')
+            raise ValueError('packet too short')
 
         # Read the body
         body_length = struct.unpack_from(packet_info[2], header, packet_info[1])[0]
         body = self.source.read(body_length)
         if len(body) != body_length:
-            raise core.InvalidPacketError('packet too short')
+            raise ValueError('packet too short')
 
         return packet_type + header + body
 
@@ -220,7 +210,7 @@ class AsyncPacketReader:
         # Get the packet info based on its type
         packet_info = HCI_PACKET_INFO.get(packet_type[0])
         if packet_info is None:
-            raise core.InvalidPacketError(f'invalid packet type {packet_type[0]} found')
+            raise ValueError(f'invalid packet type {packet_type[0]} found')
 
         # Read the header (that includes the length)
         header_size = packet_info[0] + packet_info[1]
@@ -248,28 +238,26 @@ class AsyncPipeSink:
 
 
 # -----------------------------------------------------------------------------
-class BaseSource:
+class ParserSource:
     """
     Base class designed to be subclassed by transport-specific source classes
     """
 
     terminated: asyncio.Future[None]
-    sink: Optional[TransportSink]
+    parser: PacketParser
 
     def __init__(self) -> None:
+        self.parser = PacketParser()
         self.terminated = asyncio.get_running_loop().create_future()
-        self.sink = None
 
     def set_packet_sink(self, sink: TransportSink) -> None:
-        self.sink = sink
+        self.parser.set_packet_sink(sink)
 
     def on_transport_lost(self) -> None:
-        if not self.terminated.done():
-            self.terminated.set_result(None)
-
-        if self.sink:
-            if hasattr(self.sink, 'on_transport_lost'):
-                self.sink.on_transport_lost()
+        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:
         """
@@ -282,23 +270,6 @@ class BaseSource:
         pass
 
 
-# -----------------------------------------------------------------------------
-class ParserSource(BaseSource):
-    """
-    Base class for sources that use an HCI parser.
-    """
-
-    parser: PacketParser
-
-    def __init__(self) -> None:
-        super().__init__()
-        self.parser = PacketParser()
-
-    def set_packet_sink(self, sink: TransportSink) -> None:
-        super().set_packet_sink(sink)
-        self.parser.set_packet_sink(sink)
-
-
 # -----------------------------------------------------------------------------
 class StreamPacketSource(asyncio.Protocol, ParserSource):
     def data_received(self, data: bytes) -> None:
@@ -368,9 +339,8 @@ class PumpedPacketSource(ParserSource):
                 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}')
@@ -400,7 +370,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:
@@ -423,13 +393,19 @@ class PumpedTransport(Transport):
         self,
         source: PumpedPacketSource,
         sink: PumpedPacketSink,
+        close_function,
     ) -> None:
         super().__init__(source, sink)
+        self.close_function = close_function
 
     def start(self) -> None:
         self.source.start()
         self.sink.start()
 
+    async def close(self) -> None:
+        await super().close()
+        await self.close_function()
+
 
 # -----------------------------------------------------------------------------
 class SnoopingTransport(Transport):
@@ -448,15 +424,11 @@ class SnoopingTransport(Transport):
             return SnoopingTransport(
                 transport, exit_stack.enter_context(snooper), exit_stack.pop_all().close
             )
-        raise core.UnreachableError()  # Satisfy the type checker
+        raise RuntimeError('unexpected code path')  # Satisfy the type checker
 
     class Source:
         sink: TransportSink
 
-        @property
-        def metadata(self) -> dict[str, Any]:
-            return getattr(self.source, 'metadata', {})
-
         def __init__(self, source: TransportSource, snooper: Snooper):
             self.source = source
             self.snooper = snooper

bumble/transport/grpc_protobuf/common_pb2.py

@@ -1,12 +1,11 @@
 # -*- coding: utf-8 -*-
 # Generated by the protocol buffer compiler.  DO NOT EDIT!
-# source: netsim/common.proto
-# Protobuf Python Version: 4.25.1
+# source: common.proto
 """Generated protocol buffer code."""
+from google.protobuf.internal import builder as _builder
 from google.protobuf import descriptor as _descriptor
 from google.protobuf import descriptor_pool as _descriptor_pool
 from google.protobuf import symbol_database as _symbol_database
-from google.protobuf.internal import builder as _builder
 # @@protoc_insertion_point(imports)
 
 _sym_db = _symbol_database.Default()
@@ -14,13 +13,13 @@ _sym_db = _symbol_database.Default()
 
 
 
-DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x13netsim/common.proto\x12\rnetsim.common*S\n\x08\x43hipKind\x12\x0f\n\x0bUNSPECIFIED\x10\x00\x12\r\n\tBLUETOOTH\x10\x01\x12\x08\n\x04WIFI\x10\x02\x12\x07\n\x03UWB\x10\x03\x12\x14\n\x10\x42LUETOOTH_BEACON\x10\x04\x62\x06proto3')
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x0c\x63ommon.proto\x12\rnetsim.common*=\n\x08\x43hipKind\x12\x0f\n\x0bUNSPECIFIED\x10\x00\x12\r\n\tBLUETOOTH\x10\x01\x12\x08\n\x04WIFI\x10\x02\x12\x07\n\x03UWB\x10\x03\x62\x06proto3')
 
-_globals = globals()
-_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
-_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'netsim.common_pb2', _globals)
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals())
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'common_pb2', globals())
 if _descriptor._USE_C_DESCRIPTORS == False:
+
   DESCRIPTOR._options = None
-  _globals['_CHIPKIND']._serialized_start=38
-  _globals['_CHIPKIND']._serialized_end=121
+  _CHIPKIND._serialized_start=31
+  _CHIPKIND._serialized_end=92
 # @@protoc_insertion_point(module_scope)

bumble/transport/grpc_protobuf/common_pb2.pyi

@@ -2,17 +2,11 @@ from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper
 from google.protobuf import descriptor as _descriptor
 from typing import ClassVar as _ClassVar
 
+BLUETOOTH: ChipKind
 DESCRIPTOR: _descriptor.FileDescriptor
+UNSPECIFIED: ChipKind
+UWB: ChipKind
+WIFI: ChipKind
 
 class ChipKind(int, metaclass=_enum_type_wrapper.EnumTypeWrapper):
-    __slots__ = ()
-    UNSPECIFIED: _ClassVar[ChipKind]
-    BLUETOOTH: _ClassVar[ChipKind]
-    WIFI: _ClassVar[ChipKind]
-    UWB: _ClassVar[ChipKind]
-    BLUETOOTH_BEACON: _ClassVar[ChipKind]
-UNSPECIFIED: ChipKind
-BLUETOOTH: ChipKind
-WIFI: ChipKind
-UWB: ChipKind
-BLUETOOTH_BEACON: ChipKind
+    __slots__ = []

bumble/transport/grpc_protobuf/hci_packet_pb2.py

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: hci_packet.proto
+"""Generated protocol buffer code."""
+from google.protobuf.internal import builder as _builder
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import symbol_database as _symbol_database
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x10hci_packet.proto\x12\rnetsim.packet\"\xb2\x01\n\tHCIPacket\x12\x38\n\x0bpacket_type\x18\x01 \x01(\x0e\x32#.netsim.packet.HCIPacket.PacketType\x12\x0e\n\x06packet\x18\x02 \x01(\x0c\"[\n\nPacketType\x12\x1a\n\x16HCI_PACKET_UNSPECIFIED\x10\x00\x12\x0b\n\x07\x43OMMAND\x10\x01\x12\x07\n\x03\x41\x43L\x10\x02\x12\x07\n\x03SCO\x10\x03\x12\t\n\x05\x45VENT\x10\x04\x12\x07\n\x03ISO\x10\x05\x42J\n\x1f\x63om.android.emulation.bluetoothP\x01\xf8\x01\x01\xa2\x02\x03\x41\x45\x42\xaa\x02\x1b\x41ndroid.Emulation.Bluetoothb\x06proto3')
+
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals())
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'hci_packet_pb2', globals())
+if _descriptor._USE_C_DESCRIPTORS == False:
+
+  DESCRIPTOR._options = None
+  DESCRIPTOR._serialized_options = b'\n\037com.android.emulation.bluetoothP\001\370\001\001\242\002\003AEB\252\002\033Android.Emulation.Bluetooth'
+  _HCIPACKET._serialized_start=36
+  _HCIPACKET._serialized_end=214
+  _HCIPACKET_PACKETTYPE._serialized_start=123
+  _HCIPACKET_PACKETTYPE._serialized_end=214
+# @@protoc_insertion_point(module_scope)

bumble/transport/grpc_protobuf/hci_packet_pb2.pyi

@@ -6,23 +6,17 @@ from typing import ClassVar as _ClassVar, Optional as _Optional, Union as _Union
 DESCRIPTOR: _descriptor.FileDescriptor
 
 class HCIPacket(_message.Message):
-    __slots__ = ("packet_type", "packet")
+    __slots__ = ["packet", "packet_type"]
     class PacketType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper):
-        __slots__ = ()
-        HCI_PACKET_UNSPECIFIED: _ClassVar[HCIPacket.PacketType]
-        COMMAND: _ClassVar[HCIPacket.PacketType]
-        ACL: _ClassVar[HCIPacket.PacketType]
-        SCO: _ClassVar[HCIPacket.PacketType]
-        EVENT: _ClassVar[HCIPacket.PacketType]
-        ISO: _ClassVar[HCIPacket.PacketType]
-    HCI_PACKET_UNSPECIFIED: HCIPacket.PacketType
-    COMMAND: HCIPacket.PacketType
+        __slots__ = []
     ACL: HCIPacket.PacketType
-    SCO: HCIPacket.PacketType
+    COMMAND: HCIPacket.PacketType
     EVENT: HCIPacket.PacketType
+    HCI_PACKET_UNSPECIFIED: HCIPacket.PacketType
     ISO: HCIPacket.PacketType
-    PACKET_TYPE_FIELD_NUMBER: _ClassVar[int]
     PACKET_FIELD_NUMBER: _ClassVar[int]
-    packet_type: HCIPacket.PacketType
+    PACKET_TYPE_FIELD_NUMBER: _ClassVar[int]
+    SCO: HCIPacket.PacketType
     packet: bytes
+    packet_type: HCIPacket.PacketType
     def __init__(self, packet_type: _Optional[_Union[HCIPacket.PacketType, str]] = ..., packet: _Optional[bytes] = ...) -> None: ...

bumble/transport/grpc_protobuf/netsim/hci_packet_pb2.py

@@ -1,29 +0,0 @@
-# -*- coding: utf-8 -*-
-# Generated by the protocol buffer compiler.  DO NOT EDIT!
-# source: netsim/hci_packet.proto
-# Protobuf Python Version: 4.25.1
-"""Generated protocol buffer code."""
-from google.protobuf import descriptor as _descriptor
-from google.protobuf import descriptor_pool as _descriptor_pool
-from google.protobuf import symbol_database as _symbol_database
-from google.protobuf.internal import builder as _builder
-# @@protoc_insertion_point(imports)
-
-_sym_db = _symbol_database.Default()
-
-
-
-
-DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x17netsim/hci_packet.proto\x12\rnetsim.packet\"\xb2\x01\n\tHCIPacket\x12\x38\n\x0bpacket_type\x18\x01 \x01(\x0e\x32#.netsim.packet.HCIPacket.PacketType\x12\x0e\n\x06packet\x18\x02 \x01(\x0c\"[\n\nPacketType\x12\x1a\n\x16HCI_PACKET_UNSPECIFIED\x10\x00\x12\x0b\n\x07\x43OMMAND\x10\x01\x12\x07\n\x03\x41\x43L\x10\x02\x12\x07\n\x03SCO\x10\x03\x12\t\n\x05\x45VENT\x10\x04\x12\x07\n\x03ISO\x10\x05\x42J\n\x1f\x63om.android.emulation.bluetoothP\x01\xf8\x01\x01\xa2\x02\x03\x41\x45\x42\xaa\x02\x1b\x41ndroid.Emulation.Bluetoothb\x06proto3')
-
-_globals = globals()
-_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
-_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'netsim.hci_packet_pb2', _globals)
-if _descriptor._USE_C_DESCRIPTORS == False:
-  _globals['DESCRIPTOR']._options = None
-  _globals['DESCRIPTOR']._serialized_options = b'\n\037com.android.emulation.bluetoothP\001\370\001\001\242\002\003AEB\252\002\033Android.Emulation.Bluetooth'
-  _globals['_HCIPACKET']._serialized_start=43
-  _globals['_HCIPACKET']._serialized_end=221
-  _globals['_HCIPACKET_PACKETTYPE']._serialized_start=130
-  _globals['_HCIPACKET_PACKETTYPE']._serialized_end=221
-# @@protoc_insertion_point(module_scope)