Merge pull request #135 from google/gbg/snoop

add snoop support

.vscode/settings.json

@@ -71,5 +71,10 @@
         "editor.rulers": [88]
     },
     "python.formatting.provider": "black",
-    "pylint.importStrategy": "useBundled"
+    "pylint.importStrategy": "useBundled",
+    "python.testing.pytestArgs": [
+        "."
+    ],
+    "python.testing.unittestEnabled": false,
+    "python.testing.pytestEnabled": true
 }

apps/console.py

@@ -27,7 +27,6 @@ import re
 from collections import OrderedDict
 
 import click
-import colors
 
 from prompt_toolkit import Application
 from prompt_toolkit.history import FileHistory
@@ -53,11 +52,12 @@ from prompt_toolkit.layout import (
 
 from bumble import __version__
 import bumble.core
+from bumble import colors
 from bumble.core import UUID, AdvertisingData, BT_LE_TRANSPORT
 from bumble.device import ConnectionParametersPreferences, Device, Connection, Peer
 from bumble.utils import AsyncRunner
 from bumble.transport import open_transport_or_link
-from bumble.gatt import Characteristic
+from bumble.gatt import Characteristic, Service, CharacteristicDeclaration, Descriptor
 from bumble.hci import (
     HCI_Constant,
     HCI_LE_1M_PHY,
@@ -154,10 +154,10 @@ class ConsoleApp:
                     'rssi': {'on': None, 'off': None},
                     'show': {
                         'scan': None,
-                        'services': None,
-                        'attributes': None,
                         'log': None,
                         'device': None,
+                        'local-services': None,
+                        'remote-services': None,
                     },
                     'filter': {
                         'address': None,
@@ -197,8 +197,8 @@ class ConsoleApp:
         )
         self.output_max_lines = 20
         self.scan_results_text = FormattedTextControl()
-        self.services_text = FormattedTextControl()
-        self.attributes_text = FormattedTextControl()
+        self.local_services_text = FormattedTextControl()
+        self.remote_services_text = FormattedTextControl()
         self.device_text = FormattedTextControl()
         self.log_text = FormattedTextControl(
             get_cursor_position=lambda: Point(0, max(0, len(self.log_lines) - 1))
@@ -214,12 +214,12 @@ class ConsoleApp:
                     filter=Condition(lambda: self.top_tab == 'scan'),
                 ),
                 ConditionalContainer(
-                    Frame(Window(self.services_text), title='Services'),
-                    filter=Condition(lambda: self.top_tab == 'services'),
+                    Frame(Window(self.local_services_text), title='Local Services'),
+                    filter=Condition(lambda: self.top_tab == 'local-services'),
                 ),
                 ConditionalContainer(
-                    Frame(Window(self.attributes_text), title='Attributes'),
-                    filter=Condition(lambda: self.top_tab == 'attributes'),
+                    Frame(Window(self.remote_services_text), title='Remove Services'),
+                    filter=Condition(lambda: self.top_tab == 'remote-services'),
                 ),
                 ConditionalContainer(
                     Frame(Window(self.log_text, height=self.log_height), title='Log'),
@@ -281,6 +281,7 @@ class ConsoleApp:
             self.device.listener = DeviceListener(self)
             await self.device.power_on()
             self.show_device(self.device)
+            self.show_local_services(self.device.gatt_server.attributes)
 
             # Run the UI
             await self.ui.run_async()
@@ -359,32 +360,38 @@ class ConsoleApp:
         self.scan_results_text.text = ANSI('\n'.join(lines))
         self.ui.invalidate()
 
-    def show_services(self, services):
+    def show_remote_services(self, services):
         lines = []
         del self.known_attributes[:]
         for service in services:
-            lines.append(('ansicyan', str(service) + '\n'))
+            lines.append(("ansicyan", f"{service}\n"))
 
             for characteristic in service.characteristics:
-                lines.append(('ansimagenta', '  ' + str(characteristic) + '\n'))
+                lines.append(('ansimagenta', f'  {characteristic} + \n'))
                 self.known_attributes.append(
                     f'{service.uuid.to_hex_str()}.{characteristic.uuid.to_hex_str()}'
                 )
                 self.known_attributes.append(f'*.{characteristic.uuid.to_hex_str()}')
                 self.known_attributes.append(f'#{characteristic.handle:X}')
                 for descriptor in characteristic.descriptors:
-                    lines.append(('ansigreen', '    ' + str(descriptor) + '\n'))
+                    lines.append(("ansigreen", f"    {descriptor}\n"))
 
-        self.services_text.text = lines
+        self.remote_services_text.text = lines
         self.ui.invalidate()
 
-    def show_attributes(self, attributes):
+    def show_local_services(self, attributes):
         lines = []
-
         for attribute in attributes:
-            lines.append(('ansicyan', f'{attribute}\n'))
+            if isinstance(attribute, Service):
+                lines.append(("ansicyan", f"{attribute}\n"))
+            elif isinstance(attribute, (Characteristic, CharacteristicDeclaration)):
+                lines.append(("ansimagenta", f"  {attribute}\n"))
+            elif isinstance(attribute, Descriptor):
+                lines.append(("ansigreen", f"    {attribute}\n"))
+            else:
+                lines.append(("ansiyellow", f"{attribute}\n"))
 
-        self.attributes_text.text = lines
+        self.local_services_text.text = lines
         self.ui.invalidate()
 
     def show_device(self, device):
@@ -469,7 +476,7 @@ class ConsoleApp:
                 await self.connected_peer.discover_descriptors(characteristic)
         self.append_to_output('discovery completed')
 
-        self.show_services(self.connected_peer.services)
+        self.show_remote_services(self.connected_peer.services)
 
     async def discover_attributes(self):
         if not self.connected_peer:
@@ -655,7 +662,13 @@ class ConsoleApp:
 
     async def do_show(self, params):
         if params:
-            if params[0] in {'scan', 'services', 'attributes', 'log', 'device'}:
+            if params[0] in {
+                'scan',
+                'log',
+                'device',
+                'local-services',
+                'remote-services',
+            }:
                 self.top_tab = params[0]
                 self.ui.invalidate()
 

apps/controller_info.py

@@ -19,9 +19,9 @@ import asyncio
 import os
 import logging
 import click
-from colors import color
 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,

apps/gatt_dump.py

@@ -19,9 +19,9 @@ import asyncio
 import os
 import logging
 import click
-from colors import color
 
 import bumble.core
+from bumble.colors import color
 from bumble.device import Device, Peer
 from bumble.gatt import show_services
 from bumble.transport import open_transport_or_link

apps/gg_bridge.py

@@ -20,8 +20,8 @@ import os
 import struct
 import logging
 import click
-from colors import color
 
+from bumble.colors import color
 from bumble.device import Device, Peer
 from bumble.core import AdvertisingData
 from bumble.gatt import Service, Characteristic, CharacteristicValue

apps/l2cap_bridge.py

@@ -19,8 +19,8 @@ import asyncio
 import logging
 import os
 import click
-from colors import color
 
+from bumble.colors import color
 from bumble.transport import open_transport_or_link
 from bumble.device import Device
 from bumble.utils import FlowControlAsyncPipe

apps/link_relay/link_relay.py

@@ -23,9 +23,10 @@ import argparse
 import uuid
 import os
 from urllib.parse import urlparse
-from colors import color
 import websockets
 
+from bumble.colors import color
+
 # -----------------------------------------------------------------------------
 # Logging
 # -----------------------------------------------------------------------------

apps/pair.py

@@ -19,9 +19,9 @@ import asyncio
 import os
 import logging
 import click
-import aioconsole
-from colors import color
+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.smp import PairingDelegate, PairingConfig
@@ -42,9 +42,23 @@ from bumble.att import (
 )
 
 
+# -----------------------------------------------------------------------------
+class Waiter:
+    instance = None
+
+    def __init__(self):
+        self.done = asyncio.get_running_loop().create_future()
+
+    def terminate(self):
+        self.done.set_result(None)
+
+    async def wait_until_terminated(self):
+        return await self.done
+
+
 # -----------------------------------------------------------------------------
 class Delegate(PairingDelegate):
-    def __init__(self, mode, connection, capability_string, prompt):
+    def __init__(self, mode, connection, capability_string, do_prompt):
         super().__init__(
             {
                 'keyboard': PairingDelegate.KEYBOARD_INPUT_ONLY,
@@ -58,7 +72,18 @@ class Delegate(PairingDelegate):
         self.mode = mode
         self.peer = Peer(connection)
         self.peer_name = None
-        self.prompt = prompt
+        self.do_prompt = do_prompt
+
+    def print(self, message):
+        print(color(message, 'yellow'))
+
+    async def prompt(self, message):
+        # Wait a bit to allow some of the log lines to print before we prompt
+        await asyncio.sleep(1)
+
+        session = PromptSession(message)
+        response = await session.prompt_async()
+        return response.lower().strip()
 
     async def update_peer_name(self):
         if self.peer_name is not None:
@@ -73,19 +98,15 @@ class Delegate(PairingDelegate):
             self.peer_name = '[?]'
 
     async def accept(self):
-        if self.prompt:
+        if self.do_prompt:
             await self.update_peer_name()
 
-            # Wait a bit to allow some of the log lines to print before we prompt
-            await asyncio.sleep(1)
-
             # Prompt for acceptance
-            print(color('###-----------------------------------', 'yellow'))
-            print(color(f'### Pairing request from {self.peer_name}', 'yellow'))
-            print(color('###-----------------------------------', 'yellow'))
+            self.print('###-----------------------------------')
+            self.print(f'### Pairing request from {self.peer_name}')
+            self.print('###-----------------------------------')
             while True:
-                response = await aioconsole.ainput(color('>>> Accept? ', 'yellow'))
-                response = response.lower().strip()
+                response = await self.prompt('>>> Accept? ')
 
                 if response == 'yes':
                     return True
@@ -96,23 +117,17 @@ class Delegate(PairingDelegate):
         # Accept silently
         return True
 
-    async def compare_numbers(self, number, digits=6):
+    async def compare_numbers(self, number, digits):
         await self.update_peer_name()
 
-        # Wait a bit to allow some of the log lines to print before we prompt
-        await asyncio.sleep(1)
-
         # Prompt for a numeric comparison
-        print(color('###-----------------------------------', 'yellow'))
-        print(color(f'### Pairing with {self.peer_name}', 'yellow'))
-        print(color('###-----------------------------------', 'yellow'))
+        self.print('###-----------------------------------')
+        self.print(f'### Pairing with {self.peer_name}')
+        self.print('###-----------------------------------')
         while True:
-            response = await aioconsole.ainput(
-                color(
-                    f'>>> Does the other device display {number:0{digits}}? ', 'yellow'
-                )
+            response = await self.prompt(
+                f'>>> Does the other device display {number:0{digits}}? '
             )
-            response = response.lower().strip()
 
             if response == 'yes':
                 return True
@@ -123,30 +138,24 @@ class Delegate(PairingDelegate):
     async def get_number(self):
         await self.update_peer_name()
 
-        # Wait a bit to allow some of the log lines to print before we prompt
-        await asyncio.sleep(1)
-
         # Prompt for a PIN
         while True:
             try:
-                print(color('###-----------------------------------', 'yellow'))
-                print(color(f'### Pairing with {self.peer_name}', 'yellow'))
-                print(color('###-----------------------------------', 'yellow'))
-                return int(await aioconsole.ainput(color('>>> Enter PIN: ', 'yellow')))
+                self.print('###-----------------------------------')
+                self.print(f'### Pairing with {self.peer_name}')
+                self.print('###-----------------------------------')
+                return int(await self.prompt('>>> Enter PIN: '))
             except ValueError:
                 pass
 
-    async def display_number(self, number, digits=6):
+    async def display_number(self, number, digits):
         await self.update_peer_name()
 
-        # Wait a bit to allow some of the log lines to print before we prompt
-        await asyncio.sleep(1)
-
         # Display a PIN code
-        print(color('###-----------------------------------', 'yellow'))
-        print(color(f'### Pairing with {self.peer_name}', 'yellow'))
-        print(color(f'### PIN: {number:0{digits}}', 'yellow'))
-        print(color('###-----------------------------------', 'yellow'))
+        self.print('###-----------------------------------')
+        self.print(f'### Pairing with {self.peer_name}')
+        self.print(f'### PIN: {number:0{digits}}')
+        self.print('###-----------------------------------')
 
 
 # -----------------------------------------------------------------------------
@@ -238,6 +247,7 @@ def on_pairing(keys):
     print(color('*** Paired!', 'cyan'))
     keys.print(prefix=color('*** ', 'cyan'))
     print(color('***-----------------------------------', 'cyan'))
+    Waiter.instance.terminate()
 
 
 # -----------------------------------------------------------------------------
@@ -245,6 +255,7 @@ def on_pairing_failure(reason):
     print(color('***-----------------------------------', 'red'))
     print(color(f'*** Pairing failed: {smp_error_name(reason)}', 'red'))
     print(color('***-----------------------------------', 'red'))
+    Waiter.instance.terminate()
 
 
 # -----------------------------------------------------------------------------
@@ -262,6 +273,8 @@ async def pair(
     hci_transport,
     address_or_name,
 ):
+    Waiter.instance = Waiter()
+
     print('<<< connecting to HCI...')
     async with await open_transport_or_link(hci_transport) as (hci_source, hci_sink):
         print('<<< connected')
@@ -332,7 +345,19 @@ async def pair(
             # Advertise so that peers can find us and connect
             await device.start_advertising(auto_restart=True)
 
-        await hci_source.wait_for_termination()
+        # Run until the user asks to exit
+        await Waiter.instance.wait_until_terminated()
+
+
+# -----------------------------------------------------------------------------
+class LogHandler(logging.Handler):
+    def __init__(self):
+        super().__init__()
+        self.setFormatter(logging.Formatter('%(levelname)s:%(name)s:%(message)s'))
+
+    def emit(self, record):
+        message = self.format(record)
+        print(message)
 
 
 # -----------------------------------------------------------------------------
@@ -366,7 +391,11 @@ async def pair(
     '--request', is_flag=True, help='Request that the connecting peer initiate pairing'
 )
 @click.option('--print-keys', is_flag=True, help='Print the bond keys before pairing')
-@click.option('--keystore-file', help='File in which to store the pairing keys')
+@click.option(
+    '--keystore-file',
+    metavar='<filename>',
+    help='File in which to store the pairing keys',
+)
 @click.argument('device-config')
 @click.argument('hci_transport')
 @click.argument('address-or-name', required=False)
@@ -384,7 +413,13 @@ def main(
     hci_transport,
     address_or_name,
 ):
-    logging.basicConfig(level=os.environ.get('BUMBLE_LOGLEVEL', 'INFO').upper())
+    # Setup logging
+    log_handler = LogHandler()
+    root_logger = logging.getLogger()
+    root_logger.addHandler(log_handler)
+    root_logger.setLevel(os.environ.get('BUMBLE_LOGLEVEL', 'INFO').upper())
+
+    # Pair
     asyncio.run(
         pair(
             mode,

apps/scan.py

@@ -19,8 +19,8 @@ import asyncio
 import os
 import logging
 import click
-from colors import color
 
+from bumble.colors import color
 from bumble.device import Device
 from bumble.transport import open_transport_or_link
 from bumble.keys import JsonKeyStore

apps/show.py

@@ -17,8 +17,8 @@
 # -----------------------------------------------------------------------------
 import struct
 import click
-from colors import color
 
+from bumble.colors import color
 from bumble import hci
 from bumble.transport.common import PacketReader
 from bumble.helpers import PacketTracer

apps/usb_probe.py

@@ -30,8 +30,8 @@ import os
 import logging
 import click
 import usb1
-from colors import color
 
+from bumble.colors import color
 from bumble.transport.usb import load_libusb
 
 

bumble/a2dp.py

@@ -18,7 +18,6 @@
 import struct
 import logging
 from collections import namedtuple
-import bitstruct
 
 from .company_ids import COMPANY_IDENTIFIERS
 from .sdp import (
@@ -258,7 +257,6 @@ class SbcMediaCodecInformation(
     A2DP spec - 4.3.2 Codec Specific Information Elements
     '''
 
-    BIT_FIELDS = 'u4u4u4u2u2u8u8'
     SAMPLING_FREQUENCY_BITS = {16000: 1 << 3, 32000: 1 << 2, 44100: 1 << 1, 48000: 1}
     CHANNEL_MODE_BITS = {
         SBC_MONO_CHANNEL_MODE: 1 << 3,
@@ -274,9 +272,22 @@ class SbcMediaCodecInformation(
     }
 
     @staticmethod
-    def from_bytes(data):
+    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 SbcMediaCodecInformation(
-            *bitstruct.unpack(SbcMediaCodecInformation.BIT_FIELDS, data)
+            sampling_frequency,
+            channel_mode,
+            block_length,
+            subbands,
+            allocation_method,
+            minimum_bitpool_value,
+            maximum_bitpool_value,
         )
 
     @classmethod
@@ -325,8 +336,17 @@ class SbcMediaCodecInformation(
             maximum_bitpool_value=maximum_bitpool_value,
         )
 
-    def __bytes__(self):
-        return bitstruct.pack(self.BIT_FIELDS, *self)
+    def __bytes__(self) -> bytes:
+        return bytes(
+            [
+                (self.sampling_frequency << 4) | self.channel_mode,
+                (self.block_length << 4)
+                | (self.subbands << 2)
+                | self.allocation_method,
+                self.minimum_bitpool_value,
+                self.maximum_bitpool_value,
+            ]
+        )
 
     def __str__(self):
         channel_modes = ['MONO', 'DUAL_CHANNEL', 'STEREO', 'JOINT_STEREO']
@@ -350,14 +370,13 @@ class SbcMediaCodecInformation(
 class AacMediaCodecInformation(
     namedtuple(
         'AacMediaCodecInformation',
-        ['object_type', 'sampling_frequency', 'channels', 'vbr', 'bitrate'],
+        ['object_type', 'sampling_frequency', 'channels', 'rfa', 'vbr', 'bitrate'],
     )
 ):
     '''
     A2DP spec - 4.5.2 Codec Specific Information Elements
     '''
 
-    BIT_FIELDS = 'u8u12u2p2u1u23'
     OBJECT_TYPE_BITS = {
         MPEG_2_AAC_LC_OBJECT_TYPE: 1 << 7,
         MPEG_4_AAC_LC_OBJECT_TYPE: 1 << 6,
@@ -381,9 +400,15 @@ class AacMediaCodecInformation(
     CHANNELS_BITS = {1: 1 << 1, 2: 1}
 
     @staticmethod
-    def from_bytes(data):
+    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(
-            *bitstruct.unpack(AacMediaCodecInformation.BIT_FIELDS, data)
+            object_type, sampling_frequency, channels, rfa, vbr, bitrate
         )
 
     @classmethod
@@ -394,6 +419,7 @@ class 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,
         )
@@ -410,8 +436,17 @@ class AacMediaCodecInformation(
             bitrate=bitrate,
         )
 
-    def __bytes__(self):
-        return bitstruct.pack(self.BIT_FIELDS, *self)
+    def __bytes__(self) -> bytes:
+        return bytes(
+            [
+                self.object_type & 0xFF,
+                (self.sampling_frequency >> 4) & 0xFF,
+                (((self.sampling_frequency & 0x0F) << 4) | (self.channels << 2)) & 0xFF,
+                ((self.vbr << 7) | ((self.bitrate >> 16) & 0x7F)) & 0xFF,
+                ((self.bitrate >> 8) & 0xFF) & 0xFF,
+                self.bitrate & 0xFF,
+            ]
+        )
 
     def __str__(self):
         object_types = [

bumble/att.py

@@ -22,13 +22,17 @@
 # -----------------------------------------------------------------------------
 # Imports
 # -----------------------------------------------------------------------------
+from __future__ import annotations
 import struct
-from colors import color
 from pyee import EventEmitter
+from typing import Dict, Type, TYPE_CHECKING
 
 from bumble.core import UUID, name_or_number
 from bumble.hci import HCI_Object, key_with_value
+from bumble.colors import color
 
+if TYPE_CHECKING:
+    from bumble.device import Connection
 
 # -----------------------------------------------------------------------------
 # Constants
@@ -197,7 +201,7 @@ class ATT_PDU:
     See Bluetooth spec @ Vol 3, Part F - 3.3 ATTRIBUTE PDU
     '''
 
-    pdu_classes = {}
+    pdu_classes: Dict[int, Type[ATT_PDU]] = {}
     op_code = 0
     name = None
 
@@ -747,7 +751,25 @@ class Attribute(EventEmitter):
     def decode_value(self, value_bytes):
         return value_bytes
 
-    def read_value(self, connection):
+    def read_value(self, connection: Connection):
+        if (
+            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 not connection.authenticated:
+            raise ATT_Error(
+                error_code=ATT_INSUFFICIENT_AUTHENTICATION_ERROR, att_handle=self.handle
+            )
+        if self.permissions & self.READ_REQUIRES_AUTHORIZATION:
+            # TODO: handle authorization better
+            raise ATT_Error(
+                error_code=ATT_INSUFFICIENT_AUTHORIZATION_ERROR, att_handle=self.handle
+            )
+
         if read := getattr(self.value, 'read', None):
             try:
                 value = read(connection)  # pylint: disable=not-callable
@@ -760,7 +782,25 @@ class Attribute(EventEmitter):
 
         return self.encode_value(value)
 
-    def write_value(self, connection, value_bytes):
+    def write_value(self, connection: Connection, value_bytes):
+        if (
+            self.permissions & self.WRITE_REQUIRES_ENCRYPTION
+        ) and not connection.encryption:
+            raise ATT_Error(
+                error_code=ATT_INSUFFICIENT_ENCRYPTION_ERROR, att_handle=self.handle
+            )
+        if (
+            self.permissions & self.WRITE_REQUIRES_AUTHENTICATION
+        ) and not connection.authenticated:
+            raise ATT_Error(
+                error_code=ATT_INSUFFICIENT_AUTHENTICATION_ERROR, att_handle=self.handle
+            )
+        if self.permissions & self.WRITE_REQUIRES_AUTHORIZATION:
+            # TODO: handle authorization better
+            raise ATT_Error(
+                error_code=ATT_INSUFFICIENT_AUTHORIZATION_ERROR, att_handle=self.handle
+            )
+
         value = self.decode_value(value_bytes)
 
         if write := getattr(self.value, 'write', None):

bumble/avdtp.py

@@ -15,12 +15,13 @@
 # -----------------------------------------------------------------------------
 # Imports
 # -----------------------------------------------------------------------------
+from __future__ import annotations
 import asyncio
 import struct
 import time
 import logging
-from colors import color
 from pyee import EventEmitter
+from typing import Dict, Type
 
 from .core import (
     BT_ADVANCED_AUDIO_DISTRIBUTION_SERVICE,
@@ -38,6 +39,7 @@ from .a2dp import (
     VendorSpecificMediaCodecInformation,
 )
 from . import sdp
+from .colors import color
 
 # -----------------------------------------------------------------------------
 # Logging
@@ -627,7 +629,8 @@ class Message:  # pylint:disable=attribute-defined-outside-init
         RESPONSE_REJECT: 'RESPONSE_REJECT',
     }
 
-    subclasses = {}  # Subclasses, by signal identifier and message type
+    # Subclasses, by signal identifier and message type
+    subclasses: Dict[int, Dict[int, Type[Message]]] = {}
 
     @staticmethod
     def message_type_name(message_type):

bumble/colors.py

@@ -0,0 +1,103 @@
+# Copyright (c) 2012 Giorgos Verigakis <verigak@gmail.com>
+#
+# Permission to use, copy, modify, and distribute this software for any
+# purpose with or without fee is hereby granted, provided that the above
+# copyright notice and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+from functools import partial
+from typing import List, Optional, Union
+
+
+# ANSI color names. There is also a "default"
+COLORS = ('black', 'red', 'green', 'yellow', 'blue', 'magenta', 'cyan', 'white')
+
+# ANSI style names
+STYLES = (
+    'none',
+    'bold',
+    'faint',
+    'italic',
+    'underline',
+    'blink',
+    'blink2',
+    'negative',
+    'concealed',
+    'crossed',
+)
+
+
+ColorSpec = Union[str, int]
+
+
+def _join(*values: ColorSpec) -> str:
+    return ';'.join(str(v) for v in values)
+
+
+def _color_code(spec: ColorSpec, base: int) -> str:
+    if isinstance(spec, str):
+        spec = spec.strip().lower()
+
+    if spec == 'default':
+        return _join(base + 9)
+    elif spec in COLORS:
+        return _join(base + COLORS.index(spec))
+    elif isinstance(spec, int) and 0 <= spec <= 255:
+        return _join(base + 8, 5, spec)
+    else:
+        raise ValueError('Invalid color spec "%s"' % spec)
+
+
+def color(
+    s: str,
+    fg: Optional[ColorSpec] = None,
+    bg: Optional[ColorSpec] = None,
+    style: Optional[str] = None,
+) -> str:
+    codes: List[ColorSpec] = []
+
+    if fg:
+        codes.append(_color_code(fg, 30))
+    if bg:
+        codes.append(_color_code(bg, 40))
+    if style:
+        for style_part in style.split('+'):
+            if style_part in STYLES:
+                codes.append(STYLES.index(style_part))
+            else:
+                raise ValueError('Invalid style "%s"' % style_part)
+
+    if codes:
+        return '\x1b[{0}m{1}\x1b[0m'.format(_join(*codes), s)
+    else:
+        return s
+
+
+# Foreground color shortcuts
+black = partial(color, fg='black')
+red = partial(color, fg='red')
+green = partial(color, fg='green')
+yellow = partial(color, fg='yellow')
+blue = partial(color, fg='blue')
+magenta = partial(color, fg='magenta')
+cyan = partial(color, fg='cyan')
+white = partial(color, fg='white')
+
+# Style shortcuts
+bold = partial(color, style='bold')
+none = partial(color, style='none')
+faint = partial(color, style='faint')
+italic = partial(color, style='italic')
+underline = partial(color, style='underline')
+blink = partial(color, style='blink')
+blink2 = partial(color, style='blink2')
+negative = partial(color, style='negative')
+concealed = partial(color, style='concealed')
+crossed = partial(color, style='crossed')

bumble/controller.py

@@ -20,7 +20,7 @@ import asyncio
 import itertools
 import random
 import struct
-from colors import color
+from bumble.colors import color
 from bumble.core import BT_CENTRAL_ROLE, BT_PERIPHERAL_ROLE
 
 from bumble.hci import (
@@ -46,7 +46,6 @@ from bumble.hci import (
     HCI_LE_Connection_Complete_Event,
     HCI_LE_Read_Remote_Features_Complete_Event,
     HCI_Number_Of_Completed_Packets_Event,
-    HCI_Object,
     HCI_Packet,
 )
 
@@ -1029,7 +1028,7 @@ class Controller:
         }
         return bytes([HCI_SUCCESS])
 
-    def on_hci_le_read_transmit_power_command(self, command):
+    def on_hci_le_read_transmit_power_command(self, _command):
         '''
         See Bluetooth spec Vol 2, Part E - 7.8.74 LE Read Transmit Power Command
         '''

bumble/core.py

@@ -15,7 +15,9 @@
 # -----------------------------------------------------------------------------
 # Imports
 # -----------------------------------------------------------------------------
+from __future__ import annotations
 import struct
+from typing import List, Optional, Tuple, Union, cast
 
 from .company_ids import COMPANY_IDENTIFIERS
 
@@ -142,10 +144,13 @@ class ConnectionError(BaseError):  # pylint: disable=redefined-builtin
 class UUID:
     '''
     See Bluetooth spec Vol 3, Part B - 2.5.1 UUID
+
+    Note that this class expects and works in little-endian byte-order throughout.
+    The exception is when interacting with strings, which are in big-endian byte-order.
     '''
 
-    BASE_UUID = bytes.fromhex('00001000800000805F9B34FB')
-    UUIDS = []  # Registry of all instances created
+    BASE_UUID = bytes.fromhex('00001000800000805F9B34FB')[::-1]  # little-endian
+    UUIDS: List[UUID] = []  # Registry of all instances created
 
     def __init__(self, uuid_str_or_int, name=None):
         if isinstance(uuid_str_or_int, int):
@@ -180,7 +185,7 @@ class UUID:
         return self
 
     @classmethod
-    def from_bytes(cls, uuid_bytes, name=None):
+    def from_bytes(cls, uuid_bytes: bytes, name: Optional[str] = None) -> UUID:
         if len(uuid_bytes) in (2, 4, 16):
             self = cls.__new__(cls)
             self.uuid_bytes = uuid_bytes
@@ -207,13 +212,20 @@ class UUID:
         return offset + 2, cls.from_bytes(uuid_as_bytes[offset : offset + 2])
 
     def to_bytes(self, force_128=False):
-        if len(self.uuid_bytes) == 16 or not force_128:
+        '''
+        Serialize UUID in little-endian byte-order
+        '''
+        if not force_128:
             return self.uuid_bytes
 
-        if len(self.uuid_bytes) == 4:
-            return self.uuid_bytes + UUID.BASE_UUID
-
-        return self.uuid_bytes + bytes([0, 0]) + UUID.BASE_UUID
+        if len(self.uuid_bytes) == 2:
+            return self.BASE_UUID + self.uuid_bytes + bytes([0, 0])
+        elif len(self.uuid_bytes) == 4:
+            return self.BASE_UUID + self.uuid_bytes
+        elif len(self.uuid_bytes) == 16:
+            return self.uuid_bytes
+        else:
+            assert False, "unreachable"
 
     def to_pdu_bytes(self):
         '''
@@ -224,7 +236,7 @@ class UUID:
         '''
         return self.to_bytes(force_128=(len(self.uuid_bytes) == 4))
 
-    def to_hex_str(self):
+    def to_hex_str(self) -> str:
         if len(self.uuid_bytes) == 2 or len(self.uuid_bytes) == 4:
             return bytes(reversed(self.uuid_bytes)).hex().upper()
 
@@ -606,6 +618,11 @@ class DeviceClass:
 # -----------------------------------------------------------------------------
 # Advertising Data
 # -----------------------------------------------------------------------------
+AdvertisingObject = Union[
+    List[UUID], Tuple[UUID, bytes], bytes, str, int, Tuple[int, int], Tuple[int, bytes]
+]
+
+
 class AdvertisingData:
     # fmt: off
     # pylint: disable=line-too-long
@@ -721,10 +738,12 @@ class AdvertisingData:
     BR_EDR_CONTROLLER_FLAG            = 0x08
     BR_EDR_HOST_FLAG                  = 0x10
 
+    ad_structures: List[Tuple[int, bytes]]
+
     # fmt: on
     # pylint: enable=line-too-long
 
-    def __init__(self, ad_structures=None):
+    def __init__(self, ad_structures: Optional[List[Tuple[int, bytes]]] = None) -> None:
         if ad_structures is None:
             ad_structures = []
         self.ad_structures = ad_structures[:]
@@ -751,7 +770,7 @@ class AdvertisingData:
         return ','.join(bit_flags_to_strings(flags, flag_names))
 
     @staticmethod
-    def uuid_list_to_objects(ad_data, uuid_size):
+    def uuid_list_to_objects(ad_data: bytes, uuid_size: int) -> List[UUID]:
         uuids = []
         offset = 0
         while (uuid_size * (offset + 1)) <= len(ad_data):
@@ -828,7 +847,7 @@ class AdvertisingData:
 
     # pylint: disable=too-many-return-statements
     @staticmethod
-    def ad_data_to_object(ad_type, ad_data):
+    def ad_data_to_object(ad_type: int, ad_data: bytes) -> AdvertisingObject:
         if ad_type in (
             AdvertisingData.COMPLETE_LIST_OF_16_BIT_SERVICE_CLASS_UUIDS,
             AdvertisingData.INCOMPLETE_LIST_OF_16_BIT_SERVICE_CLASS_UUIDS,
@@ -867,22 +886,22 @@ class AdvertisingData:
             return ad_data.decode("utf-8")
 
         if ad_type in (AdvertisingData.TX_POWER_LEVEL, AdvertisingData.FLAGS):
-            return ad_data[0]
+            return cast(int, struct.unpack('B', ad_data)[0])
 
         if ad_type in (
             AdvertisingData.APPEARANCE,
             AdvertisingData.ADVERTISING_INTERVAL,
         ):
-            return struct.unpack('<H', ad_data)[0]
+            return cast(int, struct.unpack('<H', ad_data)[0])
 
         if ad_type == AdvertisingData.CLASS_OF_DEVICE:
-            return struct.unpack('<I', bytes([*ad_data, 0]))[0]
+            return cast(int, struct.unpack('<I', bytes([*ad_data, 0]))[0])
 
         if ad_type == AdvertisingData.PERIPHERAL_CONNECTION_INTERVAL_RANGE:
-            return struct.unpack('<HH', ad_data)
+            return cast(Tuple[int, int], struct.unpack('<HH', ad_data))
 
         if ad_type == AdvertisingData.MANUFACTURER_SPECIFIC_DATA:
-            return (struct.unpack_from('<H', ad_data, 0)[0], ad_data[2:])
+            return (cast(int, struct.unpack_from('<H', ad_data, 0)[0]), ad_data[2:])
 
         return ad_data
 
@@ -897,26 +916,27 @@ class AdvertisingData:
                 self.ad_structures.append((ad_type, ad_data))
             offset += length
 
-    def get(self, type_id, return_all=False, raw=False):
+    def get_all(self, type_id: int, raw: bool = False) -> List[AdvertisingObject]:
         '''
         Get Advertising Data Structure(s) with a given type
 
-        If return_all is True, returns a (possibly empty) list of matches,
-        else returns the first entry, or None if no structure matches.
+        Returns a (possibly empty) list of matches.
         '''
 
-        def process_ad_data(ad_data):
+        def process_ad_data(ad_data: bytes) -> AdvertisingObject:
             return ad_data if raw else self.ad_data_to_object(type_id, ad_data)
 
-        if return_all:
-            return [
-                process_ad_data(ad[1]) for ad in self.ad_structures if ad[0] == type_id
-            ]
+        return [process_ad_data(ad[1]) for ad in self.ad_structures if ad[0] == type_id]
 
-        return next(
-            (process_ad_data(ad[1]) for ad in self.ad_structures if ad[0] == type_id),
-            None,
-        )
+    def get(self, type_id: int, raw: bool = False) -> Optional[AdvertisingObject]:
+        '''
+        Get Advertising Data Structure(s) with a given type
+
+        Returns the first entry, or None if no structure matches.
+        '''
+
+        all = self.get_all(type_id, raw=raw)
+        return all[0] if all else None
 
     def __bytes__(self):
         return b''.join(

bumble/device.py

@@ -15,6 +15,7 @@
 # -----------------------------------------------------------------------------
 # Imports
 # -----------------------------------------------------------------------------
+from __future__ import annotations
 from enum import IntEnum
 import functools
 import json
@@ -22,8 +23,9 @@ import asyncio
 import logging
 from contextlib import asynccontextmanager, AsyncExitStack
 from dataclasses import dataclass
-from colors import color
+from typing import Any, ClassVar, Dict, List, Optional, Tuple, Union
 
+from .colors import color
 from .att import ATT_CID, ATT_DEFAULT_MTU, ATT_PDU
 from .gatt import Characteristic, Descriptor, Service
 from .hci import (
@@ -46,6 +48,7 @@ from .hci import (
     HCI_LE_CODED_PHY_LE_SUPPORTED_FEATURE,
     HCI_LE_EXTENDED_ADVERTISING_LE_SUPPORTED_FEATURE,
     HCI_LE_EXTENDED_CREATE_CONNECTION_COMMAND,
+    HCI_LE_RAND_COMMAND,
     HCI_LE_READ_PHY_COMMAND,
     HCI_MITM_NOT_REQUIRED_GENERAL_BONDING_AUTHENTICATION_REQUIREMENTS,
     HCI_MITM_NOT_REQUIRED_NO_BONDING_AUTHENTICATION_REQUIREMENTS,
@@ -78,6 +81,7 @@ from .hci import (
     HCI_LE_Enable_Encryption_Command,
     HCI_LE_Extended_Advertising_Report_Event,
     HCI_LE_Extended_Create_Connection_Command,
+    HCI_LE_Rand_Command,
     HCI_LE_Read_PHY_Command,
     HCI_LE_Set_Advertising_Data_Command,
     HCI_LE_Set_Advertising_Enable_Command,
@@ -192,6 +196,8 @@ DEVICE_DEFAULT_L2CAP_COC_MAX_CREDITS          = l2cap.L2CAP_LE_CREDIT_BASED_CONN
 
 # -----------------------------------------------------------------------------
 class Advertisement:
+    address: Address
+
     TX_POWER_NOT_AVAILABLE = (
         HCI_LE_Extended_Advertising_Report_Event.TX_POWER_INFORMATION_NOT_AVAILABLE
     )
@@ -492,6 +498,7 @@ class Peer:
 # -----------------------------------------------------------------------------
 @dataclass
 class ConnectionParametersPreferences:
+    default: ClassVar[ConnectionParametersPreferences]
     connection_interval_min: int = DEVICE_DEFAULT_CONNECTION_INTERVAL_MIN
     connection_interval_max: int = DEVICE_DEFAULT_CONNECTION_INTERVAL_MAX
     max_latency: int = DEVICE_DEFAULT_CONNECTION_MAX_LATENCY
@@ -505,6 +512,17 @@ ConnectionParametersPreferences.default = ConnectionParametersPreferences()
 
 # -----------------------------------------------------------------------------
 class Connection(CompositeEventEmitter):
+    device: Device
+    handle: int
+    transport: int
+    self_address: Address
+    peer_address: Address
+    role: int
+    encryption: int
+    authenticated: bool
+    sc: bool
+    link_key_type: int
+
     @composite_listener
     class Listener:
         def on_disconnection(self, reason):
@@ -516,6 +534,9 @@ class Connection(CompositeEventEmitter):
         def on_connection_parameters_update_failure(self, error):
             pass
 
+        def on_connection_data_length_change(self):
+            pass
+
         def on_connection_phy_update(self):
             pass
 
@@ -605,6 +626,10 @@ class Connection(CompositeEventEmitter):
     def is_encrypted(self):
         return self.encryption != 0
 
+    @property
+    def is_incomplete(self) -> bool:
+        return self.handle == None
+
     def send_l2cap_pdu(self, cid, pdu):
         self.device.send_l2cap_pdu(self.handle, cid, pdu)
 
@@ -620,20 +645,22 @@ class Connection(CompositeEventEmitter):
     ):
         return await self.device.open_l2cap_channel(self, psm, max_credits, mtu, mps)
 
-    async def disconnect(self, reason=HCI_REMOTE_USER_TERMINATED_CONNECTION_ERROR):
-        return await self.device.disconnect(self, reason)
+    async def disconnect(
+        self, reason: int = HCI_REMOTE_USER_TERMINATED_CONNECTION_ERROR
+    ) -> None:
+        await self.device.disconnect(self, reason)
 
-    async def pair(self):
+    async def pair(self) -> None:
         return await self.device.pair(self)
 
-    def request_pairing(self):
+    def request_pairing(self) -> None:
         return self.device.request_pairing(self)
 
     # [Classic only]
-    async def authenticate(self):
+    async def authenticate(self) -> None:
         return await self.device.authenticate(self)
 
-    async def encrypt(self, enable=True):
+    async def encrypt(self, enable: bool = True) -> None:
         return await self.device.encrypt(self, enable)
 
     async def sustain(self, timeout=None):
@@ -701,10 +728,10 @@ class Connection(CompositeEventEmitter):
 
 # -----------------------------------------------------------------------------
 class DeviceConfiguration:
-    def __init__(self):
+    def __init__(self) -> None:
         # Setup defaults
         self.name = DEVICE_DEFAULT_NAME
-        self.address = DEVICE_DEFAULT_ADDRESS
+        self.address = Address(DEVICE_DEFAULT_ADDRESS)
         self.class_of_device = DEVICE_DEFAULT_CLASS_OF_DEVICE
         self.scan_response_data = DEVICE_DEFAULT_SCAN_RESPONSE_DATA
         self.advertising_interval_min = DEVICE_DEFAULT_ADVERTISING_INTERVAL
@@ -724,12 +751,13 @@ class DeviceConfiguration:
         )
         self.irk = bytes(16)  # This really must be changed for any level of security
         self.keystore = None
-        self.gatt_services = []
+        self.gatt_services: List[Dict[str, Any]] = []
 
-    def load_from_dict(self, config):
+    def load_from_dict(self, config: Dict[str, Any]) -> None:
         # Load simple properties
         self.name = config.get('name', self.name)
-        self.address = Address(config.get('address', self.address))
+        if address := config.get('address', None):
+            self.address = Address(address)
         self.class_of_device = config.get('class_of_device', self.class_of_device)
         self.advertising_interval_min = config.get(
             'advertising_interval', self.advertising_interval_min
@@ -831,11 +859,27 @@ def host_event_handler(function):
 # List of host event handlers for the Device class.
 # (we define this list outside the class, because referencing a class in method
 #  decorators is not straightforward)
-device_host_event_handlers = []
+device_host_event_handlers: list[str] = []
 
 
 # -----------------------------------------------------------------------------
 class Device(CompositeEventEmitter):
+    # incomplete list of fields.
+    random_address: Address
+    public_address: Address
+    classic_enabled: bool
+    name: str
+    class_of_device: int
+    gatt_server: gatt_server.Server
+    advertising_data: bytes
+    scan_response_data: bytes
+    connections: Dict[int, Connection]
+    pending_connections: Dict[Address, Connection]
+    classic_pending_accepts: Dict[
+        Address, List[asyncio.Future[Union[Connection, Tuple[Address, int, int]]]]
+    ]
+    advertisement_accumulators: Dict[Address, AdvertisementDataAccumulator]
+
     @composite_listener
     class Listener:
         def on_advertisement(self, advertisement):
@@ -882,12 +926,12 @@ class Device(CompositeEventEmitter):
 
     def __init__(
         self,
-        name=None,
-        address=None,
-        config=None,
-        host=None,
-        generic_access_service=True,
-    ):
+        name: Optional[str] = None,
+        address: Optional[Address] = None,
+        config: Optional[DeviceConfiguration] = None,
+        host: Optional[Host] = None,
+        generic_access_service: bool = True,
+    ) -> None:
         super().__init__()
 
         self._host = None
@@ -989,10 +1033,12 @@ class Device(CompositeEventEmitter):
         setup_event_forwarding(self.gatt_server, self, 'characteristic_subscription')
 
         # Set the initial host
-        self.host = host
+        if host:
+            self.host = host
 
     @property
-    def host(self):
+    def host(self) -> Host:
+        assert self._host
         return self._host
 
     @host.setter
@@ -1026,15 +1072,18 @@ class Device(CompositeEventEmitter):
     def sdp_service_records(self, service_records):
         self.sdp_server.service_records = service_records
 
-    def lookup_connection(self, connection_handle):
+    def lookup_connection(self, connection_handle: int) -> Optional[Connection]:
         if connection := self.connections.get(connection_handle):
             return connection
 
         return None
 
     def find_connection_by_bd_addr(
-        self, bd_addr, transport=None, check_address_type=False
-    ):
+        self,
+        bd_addr: Address,
+        transport: Optional[int] = None,
+        check_address_type: bool = False,
+    ) -> Optional[Connection]:
         for connection in self.connections.values():
             if connection.peer_address.to_bytes() == bd_addr.to_bytes():
                 if (
@@ -1092,11 +1141,11 @@ class Device(CompositeEventEmitter):
             logger.warning('!!! Command timed out')
             raise CommandTimeoutError() from error
 
-    async def power_on(self):
+    async def power_on(self) -> None:
         # Reset the controller
         await self.host.reset()
 
-        response = await self.send_command(HCI_Read_BD_ADDR_Command())
+        response = await self.send_command(HCI_Read_BD_ADDR_Command())  # type: ignore[call-arg]
         if response.return_parameters.status == HCI_SUCCESS:
             logger.debug(
                 color(f'BD_ADDR: {response.return_parameters.bd_addr}', 'yellow')
@@ -1108,21 +1157,46 @@ class Device(CompositeEventEmitter):
                 HCI_Write_LE_Host_Support_Command(
                     le_supported_host=int(self.le_enabled),
                     simultaneous_le_host=int(self.le_simultaneous_enabled),
-                )
+                )  # type: ignore[call-arg]
             )
 
         if self.le_enabled:
             # Set the controller address
-            await self.send_command(
-                HCI_LE_Set_Random_Address_Command(random_address=self.random_address),
-                check_result=True,
-            )
+            if self.random_address == Address.ANY_RANDOM:
+                # Try to use an address generated at random by the controller
+                if self.host.supports_command(HCI_LE_RAND_COMMAND):
+                    # Get 8 random bytes
+                    response = await self.send_command(
+                        HCI_LE_Rand_Command(), check_result=True  # type: ignore[call-arg]
+                    )
+
+                    # Ensure the address bytes can be a static random address
+                    address_bytes = response.return_parameters.random_number[
+                        :5
+                    ] + bytes([response.return_parameters.random_number[5] | 0xC0])
+
+                    # Create a static random address from the random bytes
+                    self.random_address = Address(address_bytes)
+
+            if self.random_address != Address.ANY_RANDOM:
+                logger.debug(
+                    color(
+                        f'LE Random Address: {self.random_address}',
+                        'yellow',
+                    )
+                )
+                await self.send_command(
+                    HCI_LE_Set_Random_Address_Command(
+                        random_address=self.random_address
+                    ),  # type: ignore[call-arg]
+                    check_result=True,
+                )
 
             # Load the address resolving list
             if self.keystore and self.host.supports_command(
                 HCI_LE_CLEAR_RESOLVING_LIST_COMMAND
             ):
-                await self.send_command(HCI_LE_Clear_Resolving_List_Command())
+                await self.send_command(HCI_LE_Clear_Resolving_List_Command())  # type: ignore[call-arg]
 
                 resolving_keys = await self.keystore.get_resolving_keys()
                 for (irk, address) in resolving_keys:
@@ -1132,7 +1206,7 @@ class Device(CompositeEventEmitter):
                             peer_identity_address=address,
                             peer_irk=irk,
                             local_irk=self.irk,
-                        )
+                        )  # type: ignore[call-arg]
                     )
 
                 # Enable address resolution
@@ -1147,28 +1221,24 @@ class Device(CompositeEventEmitter):
 
         if self.classic_enabled:
             await self.send_command(
-                HCI_Write_Local_Name_Command(local_name=self.name.encode('utf8'))
+                HCI_Write_Local_Name_Command(local_name=self.name.encode('utf8'))  # type: ignore[call-arg]
             )
             await self.send_command(
-                HCI_Write_Class_Of_Device_Command(class_of_device=self.class_of_device)
+                HCI_Write_Class_Of_Device_Command(class_of_device=self.class_of_device)  # type: ignore[call-arg]
             )
             await self.send_command(
                 HCI_Write_Simple_Pairing_Mode_Command(
                     simple_pairing_mode=int(self.classic_ssp_enabled)
-                )
+                )  # type: ignore[call-arg]
             )
             await self.send_command(
                 HCI_Write_Secure_Connections_Host_Support_Command(
                     secure_connections_host_support=int(self.classic_sc_enabled)
-                )
+                )  # type: ignore[call-arg]
             )
             await self.set_connectable(self.connectable)
             await self.set_discoverable(self.discoverable)
 
-        # Let the SMP manager know about the address
-        # TODO: allow using a public address
-        self.smp_manager.address = self.random_address
-
         # Done
         self.powered_on = True
 
@@ -1190,11 +1260,11 @@ class Device(CompositeEventEmitter):
 
     async def start_advertising(
         self,
-        advertising_type=AdvertisingType.UNDIRECTED_CONNECTABLE_SCANNABLE,
-        target=None,
-        own_address_type=OwnAddressType.RANDOM,
-        auto_restart=False,
-    ):
+        advertising_type: AdvertisingType = AdvertisingType.UNDIRECTED_CONNECTABLE_SCANNABLE,
+        target: Optional[Address] = None,
+        own_address_type: int = OwnAddressType.RANDOM,
+        auto_restart: bool = False,
+    ) -> None:
         # If we're advertising, stop first
         if self.advertising:
             await self.stop_advertising()
@@ -1204,7 +1274,7 @@ class Device(CompositeEventEmitter):
             await self.send_command(
                 HCI_LE_Set_Advertising_Data_Command(
                     advertising_data=self.advertising_data
-                ),
+                ),  # type: ignore[call-arg]
                 check_result=True,
             )
 
@@ -1213,7 +1283,7 @@ class Device(CompositeEventEmitter):
             await self.send_command(
                 HCI_LE_Set_Scan_Response_Data_Command(
                     scan_response_data=self.scan_response_data
-                ),
+                ),  # type: ignore[call-arg]
                 check_result=True,
             )
 
@@ -1239,13 +1309,13 @@ class Device(CompositeEventEmitter):
                 peer_address=peer_address,
                 advertising_channel_map=7,
                 advertising_filter_policy=0,
-            ),
+            ),  # type: ignore[call-arg]
             check_result=True,
         )
 
         # Enable advertising
         await self.send_command(
-            HCI_LE_Set_Advertising_Enable_Command(advertising_enable=1),
+            HCI_LE_Set_Advertising_Enable_Command(advertising_enable=1),  # type: ignore[call-arg]
             check_result=True,
         )
 
@@ -1254,11 +1324,11 @@ class Device(CompositeEventEmitter):
         self.advertising_type = advertising_type
         self.advertising = True
 
-    async def stop_advertising(self):
+    async def stop_advertising(self) -> None:
         # Disable advertising
         if self.advertising:
             await self.send_command(
-                HCI_LE_Set_Advertising_Enable_Command(advertising_enable=0),
+                HCI_LE_Set_Advertising_Enable_Command(advertising_enable=0),  # type: ignore[call-arg]
                 check_result=True,
             )
 
@@ -1273,14 +1343,14 @@ class Device(CompositeEventEmitter):
 
     async def start_scanning(
         self,
-        legacy=False,
-        active=True,
-        scan_interval=DEVICE_DEFAULT_SCAN_INTERVAL,  # Scan interval in ms
-        scan_window=DEVICE_DEFAULT_SCAN_WINDOW,  # Scan window in ms
-        own_address_type=OwnAddressType.RANDOM,
-        filter_duplicates=False,
-        scanning_phys=(HCI_LE_1M_PHY, HCI_LE_CODED_PHY),
-    ):
+        legacy: bool = False,
+        active: bool = True,
+        scan_interval: int = DEVICE_DEFAULT_SCAN_INTERVAL,  # Scan interval in ms
+        scan_window: int = DEVICE_DEFAULT_SCAN_WINDOW,  # Scan window in ms
+        own_address_type: int = OwnAddressType.RANDOM,
+        filter_duplicates: bool = False,
+        scanning_phys: Tuple[int, int] = (HCI_LE_1M_PHY, HCI_LE_CODED_PHY),
+    ) -> None:
         # Check that the arguments are legal
         if scan_interval < scan_window:
             raise ValueError('scan_interval must be >= scan_window')
@@ -1330,7 +1400,7 @@ class Device(CompositeEventEmitter):
                     scan_types=[scan_type] * scanning_phy_count,
                     scan_intervals=[int(scan_window / 0.625)] * scanning_phy_count,
                     scan_windows=[int(scan_window / 0.625)] * scanning_phy_count,
-                ),
+                ),  # type: ignore[call-arg]
                 check_result=True,
             )
 
@@ -1341,7 +1411,7 @@ class Device(CompositeEventEmitter):
                     filter_duplicates=1 if filter_duplicates else 0,
                     duration=0,  # TODO allow other values
                     period=0,  # TODO allow other values
-                ),
+                ),  # type: ignore[call-arg]
                 check_result=True,
             )
         else:
@@ -1359,7 +1429,7 @@ class Device(CompositeEventEmitter):
                     le_scan_window=int(scan_window / 0.625),
                     own_address_type=own_address_type,
                     scanning_filter_policy=HCI_LE_Set_Scan_Parameters_Command.BASIC_UNFILTERED_POLICY,
-                ),
+                ),  # type: ignore[call-arg]
                 check_result=True,
             )
 
@@ -1367,25 +1437,25 @@ class Device(CompositeEventEmitter):
             await self.send_command(
                 HCI_LE_Set_Scan_Enable_Command(
                     le_scan_enable=1, filter_duplicates=1 if filter_duplicates else 0
-                ),
+                ),  # type: ignore[call-arg]
                 check_result=True,
             )
 
         self.scanning_is_passive = not active
         self.scanning = True
 
-    async def stop_scanning(self):
+    async def stop_scanning(self) -> None:
         # Disable scanning
         if self.supports_le_feature(HCI_LE_EXTENDED_ADVERTISING_LE_SUPPORTED_FEATURE):
             await self.send_command(
                 HCI_LE_Set_Extended_Scan_Enable_Command(
                     enable=0, filter_duplicates=0, duration=0, period=0
-                ),
+                ),  # type: ignore[call-arg]
                 check_result=True,
             )
         else:
             await self.send_command(
-                HCI_LE_Set_Scan_Enable_Command(le_scan_enable=0, filter_duplicates=0),
+                HCI_LE_Set_Scan_Enable_Command(le_scan_enable=0, filter_duplicates=0),  # type: ignore[call-arg]
                 check_result=True,
             )
 
@@ -1403,9 +1473,9 @@ class Device(CompositeEventEmitter):
         if advertisement := accumulator.update(report):
             self.emit('advertisement', advertisement)
 
-    async def start_discovery(self, auto_restart=True):
+    async def start_discovery(self, auto_restart: bool = True) -> None:
         await self.send_command(
-            HCI_Write_Inquiry_Mode_Command(inquiry_mode=HCI_EXTENDED_INQUIRY_MODE),
+            HCI_Write_Inquiry_Mode_Command(inquiry_mode=HCI_EXTENDED_INQUIRY_MODE),  # type: ignore[call-arg]
             check_result=True,
         )
 
@@ -1414,7 +1484,7 @@ class Device(CompositeEventEmitter):
                 lap=HCI_GENERAL_INQUIRY_LAP,
                 inquiry_length=DEVICE_DEFAULT_INQUIRY_LENGTH,
                 num_responses=0,  # Unlimited number of responses.
-            )
+            )  # type: ignore[call-arg]
         )
         if response.status != HCI_Command_Status_Event.PENDING:
             self.discovering = False
@@ -1423,9 +1493,9 @@ class Device(CompositeEventEmitter):
         self.auto_restart_inquiry = auto_restart
         self.discovering = True
 
-    async def stop_discovery(self):
+    async def stop_discovery(self) -> None:
         if self.discovering:
-            await self.send_command(HCI_Inquiry_Cancel_Command(), check_result=True)
+            await self.send_command(HCI_Inquiry_Cancel_Command(), check_result=True)  # type: ignore[call-arg]
         self.auto_restart_inquiry = True
         self.discovering = False
 
@@ -1453,7 +1523,7 @@ class Device(CompositeEventEmitter):
             HCI_Write_Scan_Enable_Command(scan_enable=scan_enable)
         )
 
-    async def set_discoverable(self, discoverable=True):
+    async def set_discoverable(self, discoverable: bool = True) -> None:
         self.discoverable = discoverable
         if self.classic_enabled:
             # Synthesize an inquiry response if none is set already
@@ -1473,7 +1543,7 @@ class Device(CompositeEventEmitter):
             await self.send_command(
                 HCI_Write_Extended_Inquiry_Response_Command(
                     fec_required=0, extended_inquiry_response=self.inquiry_response
-                ),
+                ),  # type: ignore[call-arg]
                 check_result=True,
             )
             await self.set_scan_enable(
@@ -1481,7 +1551,7 @@ class Device(CompositeEventEmitter):
                 page_scan_enabled=self.connectable,
             )
 
-    async def set_connectable(self, connectable=True):
+    async def set_connectable(self, connectable: bool = True) -> None:
         self.connectable = connectable
         if self.classic_enabled:
             await self.set_scan_enable(
@@ -1491,12 +1561,14 @@ class Device(CompositeEventEmitter):
 
     async def connect(
         self,
-        peer_address,
-        transport=BT_LE_TRANSPORT,
-        connection_parameters_preferences=None,
-        own_address_type=OwnAddressType.RANDOM,
-        timeout=DEVICE_DEFAULT_CONNECT_TIMEOUT,
-    ):
+        peer_address: Union[Address, str],
+        transport: int = BT_LE_TRANSPORT,
+        connection_parameters_preferences: Optional[
+            Dict[int, ConnectionParametersPreferences]
+        ] = None,
+        own_address_type: int = OwnAddressType.RANDOM,
+        timeout: Optional[float] = DEVICE_DEFAULT_CONNECT_TIMEOUT,
+    ) -> Connection:
         '''
         Request a connection to a peer.
         When transport is BLE, this method cannot be called if there is already a
@@ -1543,6 +1615,8 @@ class Device(CompositeEventEmitter):
             ):
                 raise ValueError('BR/EDR addresses must be PUBLIC')
 
+        assert isinstance(peer_address, Address)
+
         def on_connection(connection):
             if transport == BT_LE_TRANSPORT or (
                 # match BR/EDR connection event against peer address
@@ -1660,7 +1734,7 @@ class Device(CompositeEventEmitter):
                             supervision_timeouts=supervision_timeouts,
                             min_ce_lengths=min_ce_lengths,
                             max_ce_lengths=max_ce_lengths,
-                        )
+                        )  # type: ignore[call-arg]
                     )
                 else:
                     if HCI_LE_1M_PHY not in connection_parameters_preferences:
@@ -1689,7 +1763,7 @@ class Device(CompositeEventEmitter):
                             supervision_timeout=int(prefs.supervision_timeout / 10),
                             min_ce_length=int(prefs.min_ce_length / 0.625),
                             max_ce_length=int(prefs.max_ce_length / 0.625),
-                        )
+                        )  # type: ignore[call-arg]
                     )
             else:
                 # Save pending connection
@@ -1706,7 +1780,7 @@ class Device(CompositeEventEmitter):
                         clock_offset=0x0000,
                         allow_role_switch=0x01,
                         reserved=0,
-                    )
+                    )  # type: ignore[call-arg]
                 )
 
             if result.status != HCI_Command_Status_Event.PENDING:
@@ -1725,10 +1799,10 @@ class Device(CompositeEventEmitter):
                 )
             except asyncio.TimeoutError:
                 if transport == BT_LE_TRANSPORT:
-                    await self.send_command(HCI_LE_Create_Connection_Cancel_Command())
+                    await self.send_command(HCI_LE_Create_Connection_Cancel_Command())  # type: ignore[call-arg]
                 else:
                     await self.send_command(
-                        HCI_Create_Connection_Cancel_Command(bd_addr=peer_address)
+                        HCI_Create_Connection_Cancel_Command(bd_addr=peer_address)  # type: ignore[call-arg]
                     )
 
                 try:
@@ -1746,16 +1820,16 @@ class Device(CompositeEventEmitter):
 
     async def accept(
         self,
-        peer_address=Address.ANY,
-        role=BT_PERIPHERAL_ROLE,
-        timeout=DEVICE_DEFAULT_CONNECT_TIMEOUT,
-    ):
+        peer_address: Union[Address, str] = Address.ANY,
+        role: int = BT_PERIPHERAL_ROLE,
+        timeout: Optional[float] = DEVICE_DEFAULT_CONNECT_TIMEOUT,
+    ) -> Connection:
         '''
         Wait and accept any incoming connection or a connection from `peer_address` when
         set.
 
         Notes:
-          * A `connect` to the same peer will also complete this call.
+          * A `connect` to the same peer will not complete this call.
           * The `timeout` parameter is only handled while waiting for the connection
             request, once received and accepted, the controller shall issue a connection
             complete event.
@@ -1771,22 +1845,24 @@ class Device(CompositeEventEmitter):
                     peer_address, BT_BR_EDR_TRANSPORT
                 )  # TODO: timeout
 
+        assert isinstance(peer_address, Address)
+
         if peer_address == Address.NIL:
             raise ValueError('accept on nil address')
 
         # Create a future so that we can wait for the request
-        pending_request = asyncio.get_running_loop().create_future()
+        pending_request_fut = asyncio.get_running_loop().create_future()
 
         if peer_address == Address.ANY:
-            self.classic_pending_accepts[Address.ANY].append(pending_request)
+            self.classic_pending_accepts[Address.ANY].append(pending_request_fut)
         elif peer_address in self.classic_pending_accepts:
             raise InvalidStateError('accept connection already pending')
         else:
-            self.classic_pending_accepts[peer_address] = pending_request
+            self.classic_pending_accepts[peer_address] = [pending_request_fut]
 
         try:
             # Wait for a request or a completed connection
-            pending_request = self.abort_on('flush', pending_request)
+            pending_request = self.abort_on('flush', pending_request_fut)
             result = await (
                 asyncio.wait_for(pending_request, timeout)
                 if timeout
@@ -1795,7 +1871,7 @@ class Device(CompositeEventEmitter):
         except Exception:
             # Remove future from device context
             if peer_address == Address.ANY:
-                self.classic_pending_accepts[Address.ANY].remove(pending_request)
+                self.classic_pending_accepts[Address.ANY].remove(pending_request_fut)
             else:
                 self.classic_pending_accepts.pop(peer_address)
             raise
@@ -1807,6 +1883,7 @@ class Device(CompositeEventEmitter):
 
         # Otherwise, result came from `on_connection_request`
         peer_address, _class_of_device, _link_type = result
+        assert isinstance(peer_address, Address)
 
         # Create a future so that we can wait for the connection's result
         pending_connection = asyncio.get_running_loop().create_future()
@@ -1836,7 +1913,7 @@ class Device(CompositeEventEmitter):
         try:
             # Accept connection request
             await self.send_command(
-                HCI_Accept_Connection_Request_Command(bd_addr=peer_address, role=role)
+                HCI_Accept_Connection_Request_Command(bd_addr=peer_address, role=role)  # type: ignore[call-arg]
             )
 
             # Wait for connection complete
@@ -1934,7 +2011,7 @@ class Device(CompositeEventEmitter):
         NOTE: the name of the parameters may look odd, but it just follows the names
         used in the Bluetooth spec.
         '''
-        await self.send_command(
+        result = await self.send_command(
             HCI_LE_Connection_Update_Command(
                 connection_handle=connection.handle,
                 connection_interval_min=connection_interval_min,
@@ -1943,9 +2020,10 @@ class Device(CompositeEventEmitter):
                 supervision_timeout=supervision_timeout,
                 min_ce_length=min_ce_length,
                 max_ce_length=max_ce_length,
-            ),
-            check_result=True,
+            )
         )
+        if result.status != HCI_Command_Status_Event.PENDING:
+            raise HCI_StatusError(result)
 
     async def get_connection_rssi(self, connection):
         result = await self.send_command(
@@ -2212,7 +2290,7 @@ class Device(CompositeEventEmitter):
             )
 
     # [Classic only]
-    async def request_remote_name(self, remote):  # remote: Connection | Address
+    async def request_remote_name(self, remote: Union[Address, Connection]) -> str:
         # Set up event handlers
         pending_name = asyncio.get_running_loop().create_future()
 
@@ -2240,7 +2318,7 @@ class Device(CompositeEventEmitter):
                     page_scan_repetition_mode=HCI_Remote_Name_Request_Command.R2,
                     reserved=0,
                     clock_offset=0,  # TODO investigate non-0 values
-                )
+                )  # type: ignore[call-arg]
             )
 
             if result.status != HCI_COMMAND_STATUS_PENDING:
@@ -2328,22 +2406,12 @@ class Device(CompositeEventEmitter):
 
         if transport == BT_BR_EDR_TRANSPORT:
             # Create a new connection
-            connection: Connection = self.pending_connections.pop(peer_address)
+            connection = self.pending_connections.pop(peer_address)
             connection.complete(
                 connection_handle, peer_resolvable_address, role, connection_parameters
             )
             self.connections[connection_handle] = connection
 
-            # We may have an accept ongoing waiting for a connection request for
-            # `peer_address`.
-            # Typically happen when using `connect` to the same `peer_address` we are
-            # waiting for with an `accept`.
-            # In this case, set the completed `connection` to the `accept` future
-            # result.
-            if peer_address in self.classic_pending_accepts:
-                future = self.classic_pending_accepts.pop(peer_address)
-                future.set_result(connection)
-
             # Emit an event to notify listeners of the new connection
             self.emit('connection', connection)
         else:
@@ -2442,7 +2510,7 @@ class Device(CompositeEventEmitter):
 
         # match a pending future using `bd_addr`
         if bd_addr in self.classic_pending_accepts:
-            future = self.classic_pending_accepts.pop(bd_addr)
+            future, *_ = self.classic_pending_accepts.pop(bd_addr)
             future.set_result((bd_addr, class_of_device, link_type))
 
         # match first pending future for ANY address

bumble/gatt.py

@@ -28,9 +28,9 @@ import enum
 import functools
 import logging
 import struct
-from typing import Sequence
-from colors import color
+from typing import Optional, Sequence
 
+from .colors import color
 from .core import UUID, get_dict_key_by_value
 from .att import Attribute
 
@@ -204,6 +204,8 @@ class Service(Attribute):
     See Vol 3, Part G - 3.1 SERVICE DEFINITION
     '''
 
+    uuid: UUID
+
     def __init__(self, uuid, characteristics: list[Characteristic], primary=True):
         # Convert the uuid to a UUID object if it isn't already
         if isinstance(uuid, str):
@@ -217,11 +219,11 @@ class Service(Attribute):
             uuid.to_pdu_bytes(),
         )
         self.uuid = uuid
-        self.included_services = []
+        # self.included_services = []
         self.characteristics = characteristics[:]
         self.primary = primary
 
-    def get_advertising_data(self):
+    def get_advertising_data(self) -> Optional[bytes]:
         """
         Get Service specific advertising data
         Defined by each Service, default value is empty

bumble/gatt_client.py

@@ -27,9 +27,9 @@ import asyncio
 import logging
 import struct
 
-from colors import color
 from pyee import EventEmitter
 
+from .colors import color
 from .hci import HCI_Constant
 from .att import (
     ATT_ATTRIBUTE_NOT_FOUND_ERROR,

bumble/gatt_server.py

@@ -27,10 +27,10 @@ import asyncio
 import logging
 from collections import defaultdict
 import struct
-from typing import Tuple, Optional
+from typing import List, Tuple, Optional
 from pyee import EventEmitter
-from colors import color
 
+from .colors import color
 from .core import UUID
 from .att import (
     ATT_ATTRIBUTE_NOT_FOUND_ERROR,
@@ -61,7 +61,6 @@ from .att import (
 from .gatt import (
     GATT_CHARACTERISTIC_ATTRIBUTE_TYPE,
     GATT_CLIENT_CHARACTERISTIC_CONFIGURATION_DESCRIPTOR,
-    GATT_INCLUDE_ATTRIBUTE_TYPE,
     GATT_MAX_ATTRIBUTE_VALUE_SIZE,
     GATT_PRIMARY_SERVICE_ATTRIBUTE_TYPE,
     GATT_REQUEST_TIMEOUT,
@@ -90,6 +89,8 @@ GATT_SERVER_DEFAULT_MAX_MTU = 517
 # GATT Server
 # -----------------------------------------------------------------------------
 class Server(EventEmitter):
+    attributes: List[Attribute]
+
     def __init__(self, device):
         super().__init__()
         self.device = device
@@ -140,6 +141,7 @@ class Server(EventEmitter):
                 attribute
                 for attribute in self.attributes
                 if attribute.type == GATT_PRIMARY_SERVICE_ATTRIBUTE_TYPE
+                and isinstance(attribute, Service)
                 and attribute.uuid == service_uuid
             ),
             None,
@@ -540,8 +542,6 @@ class Server(EventEmitter):
             if attribute.handle >= request.starting_handle
             and attribute.handle <= request.ending_handle
         ):
-            # TODO: check permissions
-
             this_uuid_size = len(attribute.type.to_pdu_bytes())
 
             if attributes:
@@ -635,6 +635,13 @@ class Server(EventEmitter):
         '''
 
         pdu_space_available = connection.att_mtu - 2
+
+        response = ATT_Error_Response(
+            request_opcode_in_error=request.op_code,
+            attribute_handle_in_error=request.starting_handle,
+            error_code=ATT_ATTRIBUTE_NOT_FOUND_ERROR,
+        )
+
         attributes = []
         for attribute in (
             attribute
@@ -644,10 +651,21 @@ class Server(EventEmitter):
             and attribute.handle <= request.ending_handle
             and pdu_space_available
         ):
-            # TODO: check permissions
+
+            try:
+                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
+                if not attributes:
+                    response = ATT_Error_Response(
+                        request_opcode_in_error=request.op_code,
+                        attribute_handle_in_error=attribute.handle,
+                        error_code=error.error_code,
+                    )
+                break
 
             # Check the attribute value size
-            attribute_value = attribute.read_value(connection)
             max_attribute_size = min(connection.att_mtu - 4, 253)
             if len(attribute_value) > max_attribute_size:
                 # We need to truncate
@@ -673,11 +691,7 @@ class Server(EventEmitter):
                 length=entry_size, attribute_data_list=b''.join(attribute_data_list)
             )
         else:
-            response = ATT_Error_Response(
-                request_opcode_in_error=request.op_code,
-                attribute_handle_in_error=request.starting_handle,
-                error_code=ATT_ATTRIBUTE_NOT_FOUND_ERROR,
-            )
+            logging.warning(f"not found {request}")
 
         self.send_response(connection, response)
 
@@ -687,10 +701,17 @@ class Server(EventEmitter):
         '''
 
         if attribute := self.get_attribute(request.attribute_handle):
-            # TODO: check permissions
-            value = attribute.read_value(connection)
-            value_size = min(connection.att_mtu - 1, len(value))
-            response = ATT_Read_Response(attribute_value=value[:value_size])
+            try:
+                value = attribute.read_value(connection)
+            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:
+                value_size = min(connection.att_mtu - 1, len(value))
+                response = ATT_Read_Response(attribute_value=value[:value_size])
         else:
             response = ATT_Error_Response(
                 request_opcode_in_error=request.op_code,
@@ -705,29 +726,36 @@ class Server(EventEmitter):
         '''
 
         if attribute := self.get_attribute(request.attribute_handle):
-            # TODO: check permissions
-            value = attribute.read_value(connection)
-            if request.value_offset > len(value):
+            try:
+                value = attribute.read_value(connection)
+            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=ATT_INVALID_OFFSET_ERROR,
-                )
-            elif len(value) <= connection.att_mtu - 1:
-                response = ATT_Error_Response(
-                    request_opcode_in_error=request.op_code,
-                    attribute_handle_in_error=request.attribute_handle,
-                    error_code=ATT_ATTRIBUTE_NOT_LONG_ERROR,
+                    error_code=error.error_code,
                 )
             else:
-                part_size = min(
-                    connection.att_mtu - 1, len(value) - request.value_offset
-                )
-                response = ATT_Read_Blob_Response(
-                    part_attribute_value=value[
-                        request.value_offset : request.value_offset + part_size
-                    ]
-                )
+                if request.value_offset > len(value):
+                    response = ATT_Error_Response(
+                        request_opcode_in_error=request.op_code,
+                        attribute_handle_in_error=request.attribute_handle,
+                        error_code=ATT_INVALID_OFFSET_ERROR,
+                    )
+                elif len(value) <= connection.att_mtu - 1:
+                    response = ATT_Error_Response(
+                        request_opcode_in_error=request.op_code,
+                        attribute_handle_in_error=request.attribute_handle,
+                        error_code=ATT_ATTRIBUTE_NOT_LONG_ERROR,
+                    )
+                else:
+                    part_size = min(
+                        connection.att_mtu - 1, len(value) - request.value_offset
+                    )
+                    response = ATT_Read_Blob_Response(
+                        part_attribute_value=value[
+                            request.value_offset : request.value_offset + part_size
+                        ]
+                    )
         else:
             response = ATT_Error_Response(
                 request_opcode_in_error=request.op_code,
@@ -743,7 +771,6 @@ class Server(EventEmitter):
         if request.attribute_group_type not in (
             GATT_PRIMARY_SERVICE_ATTRIBUTE_TYPE,
             GATT_SECONDARY_SERVICE_ATTRIBUTE_TYPE,
-            GATT_INCLUDE_ATTRIBUTE_TYPE,
         ):
             response = ATT_Error_Response(
                 request_opcode_in_error=request.op_code,
@@ -763,8 +790,10 @@ class Server(EventEmitter):
             and attribute.handle <= request.ending_handle
             and pdu_space_available
         ):
-            # Check the attribute value size
+            # No need to catch permission errors here, since these attributes
+            # must all be world-readable
             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:
                 # We need to truncate

bumble/hci.py

@@ -15,12 +15,14 @@
 # -----------------------------------------------------------------------------
 # Imports
 # -----------------------------------------------------------------------------
+from __future__ import annotations
 import struct
 import collections
 import logging
 import functools
-from colors import color
+from typing import Dict, Type, Union
 
+from .colors import color
 from .core import (
     BT_BR_EDR_TRANSPORT,
     AdvertisingData,
@@ -1419,7 +1421,11 @@ class HCI_Constant:
 # -----------------------------------------------------------------------------
 class HCI_Error(ProtocolError):
     def __init__(self, error_code):
-        super().__init__(error_code, 'hci', HCI_Constant.error_name(error_code))
+        super().__init__(
+            error_code,
+            error_namespace='hci',
+            error_name=HCI_Constant.error_name(error_code),
+        )
 
 
 # -----------------------------------------------------------------------------
@@ -1638,8 +1644,8 @@ class HCI_Object:
             # Map the value if needed
             if value_mappers:
                 value_mapper = value_mappers.get(key, value_mapper)
-                if value_mapper is not None:
-                    value = value_mapper(value)
+            if value_mapper is not None:
+                value = value_mapper(value)
 
             # Get the string representation of the value
             value_str = HCI_Object.format_field_value(
@@ -1690,6 +1696,11 @@ class Address:
         RANDOM_IDENTITY_ADDRESS: 'RANDOM_IDENTITY_ADDRESS',
     }
 
+    # Type declarations
+    NIL: Address
+    ANY: Address
+    ANY_RANDOM: Address
+
     # pylint: disable-next=unnecessary-lambda
     ADDRESS_TYPE_SPEC = {'size': 1, 'mapper': lambda x: Address.address_type_name(x)}
 
@@ -1722,7 +1733,9 @@ class Address:
         address_type = data[offset - 1]
         return Address.parse_address_with_type(data, offset, address_type)
 
-    def __init__(self, address, address_type=RANDOM_DEVICE_ADDRESS):
+    def __init__(
+        self, address: Union[bytes, str], address_type: int = RANDOM_DEVICE_ADDRESS
+    ):
         '''
         Initialize an instance. `address` may be a byte array in little-endian
         format, or a hex string in big-endian format (with optional ':'
@@ -1807,6 +1820,7 @@ class Address:
 # Predefined address values
 Address.NIL = Address(b"\xff\xff\xff\xff\xff\xff", Address.PUBLIC_DEVICE_ADDRESS)
 Address.ANY = Address(b"\x00\x00\x00\x00\x00\x00", Address.PUBLIC_DEVICE_ADDRESS)
+Address.ANY_RANDOM = Address(b"\x00\x00\x00\x00\x00\x00", Address.RANDOM_DEVICE_ADDRESS)
 
 # -----------------------------------------------------------------------------
 class OwnAddressType:
@@ -1836,6 +1850,8 @@ class HCI_Packet:
     Abstract Base class for HCI packets
     '''
 
+    hci_packet_type: int
+
     @staticmethod
     def from_bytes(packet):
         packet_type = packet[0]
@@ -1854,6 +1870,9 @@ class HCI_Packet:
     def __init__(self, name):
         self.name = name
 
+    def __bytes__(self) -> bytes:
+        raise NotImplementedError
+
     def __repr__(self) -> str:
         return self.name
 
@@ -1865,6 +1884,9 @@ class HCI_CustomPacket(HCI_Packet):
         self.hci_packet_type = payload[0]
         self.payload = payload
 
+    def __bytes__(self) -> bytes:
+        return self.payload
+
 
 # -----------------------------------------------------------------------------
 class HCI_Command(HCI_Packet):
@@ -1873,7 +1895,7 @@ class HCI_Command(HCI_Packet):
     '''
 
     hci_packet_type = HCI_COMMAND_PACKET
-    command_classes = {}
+    command_classes: Dict[int, Type[HCI_Command]] = {}
 
     @staticmethod
     def command(fields=(), return_parameters_fields=()):
@@ -3104,6 +3126,16 @@ class HCI_LE_Read_Remote_Features_Command(HCI_Command):
     '''
 
 
+# -----------------------------------------------------------------------------
+@HCI_Command.command(
+    return_parameters_fields=[("status", STATUS_SPEC), ("random_number", 8)]
+)
+class HCI_LE_Rand_Command(HCI_Command):
+    """
+    See Bluetooth spec @ 7.8.23 LE Rand Command
+    """
+
+
 # -----------------------------------------------------------------------------
 @HCI_Command.command(
     [
@@ -4009,8 +4041,8 @@ class HCI_Event(HCI_Packet):
     '''
 
     hci_packet_type = HCI_EVENT_PACKET
-    event_classes = {}
-    meta_event_classes = {}
+    event_classes: Dict[int, Type[HCI_Event]] = {}
+    meta_event_classes: Dict[int, Type[HCI_LE_Meta_Event]] = {}
 
     @staticmethod
     def event(fields=()):

bumble/helpers.py

@@ -16,8 +16,8 @@
 # Imports
 # -----------------------------------------------------------------------------
 import logging
-from colors import color
 
+from .colors import color
 from .att import ATT_CID, ATT_PDU
 from .smp import SMP_CID, SMP_Command
 from .core import name_or_number

bumble/hfp.py

@@ -18,7 +18,8 @@
 import logging
 import asyncio
 import collections
-from colors import color
+
+from .colors import color
 
 
 # -----------------------------------------------------------------------------

bumble/host.py

@@ -20,9 +20,9 @@ import collections
 import logging
 import struct
 
-from colors import color
-
+from bumble.colors import color
 from bumble.l2cap import L2CAP_PDU
+from bumble.snoop import Snooper
 
 from .hci import (
     HCI_ACL_DATA_PACKET,
@@ -134,6 +134,7 @@ class Host(AbortableEventEmitter):
         self.long_term_key_provider = None
         self.link_key_provider = None
         self.pairing_io_capability_provider = None  # Classic only
+        self.snooper = None
 
         # Connect to the source and sink if specified
         if controller_source:
@@ -141,7 +142,7 @@ class Host(AbortableEventEmitter):
         if controller_sink:
             self.set_packet_sink(controller_sink)
 
-    async def flush(self):
+    async def flush(self) -> None:
         # Make sure no command is pending
         await self.command_semaphore.acquire()
 
@@ -274,6 +275,9 @@ class Host(AbortableEventEmitter):
         self.hci_sink = sink
 
     def send_hci_packet(self, packet):
+        if self.snooper:
+            self.snooper.snoop(packet, Snooper.Direction.HOST_TO_CONTROLLER)
+
         self.hci_sink.on_packet(packet.to_bytes())
 
     async def send_command(self, command, check_result=False):
@@ -420,6 +424,9 @@ class Host(AbortableEventEmitter):
     def on_hci_packet(self, packet):
         logger.debug(f'{color("### CONTROLLER -> HOST", "green")}: {packet}')
 
+        if self.snooper:
+            self.snooper.snoop(packet, Snooper.Direction.CONTROLLER_TO_HOST)
+
         # If the packet is a command, invoke the handler for this packet
         if packet.hci_packet_type == HCI_COMMAND_PACKET:
             self.on_hci_command_packet(packet)
@@ -660,7 +667,7 @@ class Host(AbortableEventEmitter):
                 connection_handle=event.connection_handle,
                 interval_min=event.interval_min,
                 interval_max=event.interval_max,
-                latency=event.latency,
+                max_latency=event.max_latency,
                 timeout=event.timeout,
                 min_ce_length=0,
                 max_ce_length=0,

bumble/keys.py

@@ -24,8 +24,9 @@ import asyncio
 import logging
 import os
 import json
-from colors import color
+from typing import Optional
 
+from .colors import color
 from .hci import Address
 
 
@@ -129,7 +130,7 @@ class PairingKeys:
                 for (key_property, key_value) in value.items():
                     print(f'{prefix}  {color(key_property, "green")}: {key_value}')
             else:
-                print(f'{prefix}{color(property, "cyan")}: {value}')
+                print(f'{prefix}{color(container_property, "cyan")}: {value}')
 
 
 # -----------------------------------------------------------------------------
@@ -216,7 +217,7 @@ class JsonKeyStore(KeyStore):
         params = device_config.keystore.split(':', 1)[1:]
         namespace = str(device_config.address)
         if params:
-            filename = params[1]
+            filename = params[0]
         else:
             filename = None
 
@@ -242,7 +243,7 @@ class JsonKeyStore(KeyStore):
         # Atomically replace the previous file
         os.rename(temp_filename, self.filename)
 
-    async def delete(self, name):
+    async def delete(self, name: str) -> None:
         db = await self.load()
 
         namespace = db.get(self.namespace)
@@ -278,7 +279,7 @@ class JsonKeyStore(KeyStore):
 
         await self.save(db)
 
-    async def get(self, name):
+    async def get(self, name: str) -> Optional[PairingKeys]:
         db = await self.load()
 
         namespace = db.get(self.namespace)

bumble/l2cap.py

@@ -15,14 +15,16 @@
 # -----------------------------------------------------------------------------
 # Imports
 # -----------------------------------------------------------------------------
+from __future__ import annotations
 import asyncio
 import logging
 import struct
 
 from collections import deque
-from colors import color
 from pyee import EventEmitter
+from typing import Dict, Type
 
+from .colors import color
 from .core import BT_CENTRAL_ROLE, InvalidStateError, ProtocolError
 from .hci import (
     HCI_LE_Connection_Update_Command,
@@ -184,7 +186,7 @@ class L2CAP_Control_Frame:
     See Bluetooth spec @ Vol 3, Part A - 4 SIGNALING PACKET FORMATS
     '''
 
-    classes = {}
+    classes: Dict[int, Type[L2CAP_Control_Frame]] = {}
     code = 0
     name = None
 
@@ -383,7 +385,7 @@ class L2CAP_Connection_Response(L2CAP_Control_Frame):
 
     CONNECTION_SUCCESSFUL = 0x0000
     CONNECTION_PENDING = 0x0001
-    CONNECTION_REFUSED_LE_PSM_NOT_SUPPORTED = 0x0002
+    CONNECTION_REFUSED_PSM_NOT_SUPPORTED = 0x0002
     CONNECTION_REFUSED_SECURITY_BLOCK = 0x0003
     CONNECTION_REFUSED_NO_RESOURCES_AVAILABLE = 0x0004
     CONNECTION_REFUSED_INVALID_SOURCE_CID = 0x0006
@@ -394,7 +396,7 @@ class L2CAP_Connection_Response(L2CAP_Control_Frame):
     RESULT_NAMES = {
         CONNECTION_SUCCESSFUL: 'CONNECTION_SUCCESSFUL',
         CONNECTION_PENDING: 'CONNECTION_PENDING',
-        CONNECTION_REFUSED_LE_PSM_NOT_SUPPORTED: 'CONNECTION_REFUSED_LE_PSM_NOT_SUPPORTED',
+        CONNECTION_REFUSED_PSM_NOT_SUPPORTED: 'CONNECTION_REFUSED_PSM_NOT_SUPPORTED',
         CONNECTION_REFUSED_SECURITY_BLOCK: 'CONNECTION_REFUSED_SECURITY_BLOCK',
         CONNECTION_REFUSED_NO_RESOURCES_AVAILABLE: 'CONNECTION_REFUSED_NO_RESOURCES_AVAILABLE',
         CONNECTION_REFUSED_INVALID_SOURCE_CID: 'CONNECTION_REFUSED_INVALID_SOURCE_CID',
@@ -1619,7 +1621,7 @@ class ChannelManager:
                     destination_cid=request.source_cid,
                     source_cid=0,
                     # pylint: disable=line-too-long
-                    result=L2CAP_Connection_Response.CONNECTION_REFUSED_LE_PSM_NOT_SUPPORTED,
+                    result=L2CAP_Connection_Response.CONNECTION_REFUSED_PSM_NOT_SUPPORTED,
                     status=0x0000,
                 ),
             )

bumble/link.py

@@ -19,9 +19,7 @@ import logging
 import asyncio
 from functools import partial
 
-from colors import color
-import websockets
-
+from bumble.colors import color
 from bumble.hci import (
     Address,
     HCI_SUCCESS,
@@ -220,6 +218,8 @@ class RemoteLink:
                 )
 
     async def run_connection(self):
+        import websockets  # lazy import
+
         # Connect to the relay
         logger.debug(f'connecting to {self.uri}')
         # pylint: disable-next=no-member

bumble/profiles/asha_service.py

@@ -31,6 +31,7 @@ from ..gatt import (
     Characteristic,
     CharacteristicValue,
 )
+from ..device import Device
 
 # -----------------------------------------------------------------------------
 # Logging
@@ -50,9 +51,13 @@ class AshaService(TemplateService):
     SUPPORTED_CODEC_ID = [0x02, 0x01]  # Codec IDs [G.722 at 16 kHz]
     RENDER_DELAY = [00, 00]
 
-    def __init__(self, capability: int, hisyncid: List[int]):
+    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.emitted_data_name = 'ASHA_data_' + str(self.capability)
+        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):
@@ -116,9 +121,18 @@ class AshaService(TemplateService):
             CharacteristicValue(write=on_volume_write),
         )
 
-        # TODO add real psm value
-        self.psm = 0x0080
-        # self.psm = device.register_l2cap_channel_server(0, on_coc, 8)
+        # Register an L2CAP CoC server
+        def on_coc(channel):
+            def on_data(data):
+                logging.debug(f'<<< data received:{data}')
+
+                self.emit(self.emitted_data_name, 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.READ,

bumble/profiles/device_information_service.py

@@ -17,7 +17,7 @@
 # Imports
 # -----------------------------------------------------------------------------
 import struct
-from typing import Tuple
+from typing import Optional, Tuple
 
 from ..gatt_client import ProfileServiceProxy
 from ..gatt import (
@@ -52,14 +52,14 @@ class DeviceInformationService(TemplateService):
 
     def __init__(
         self,
-        manufacturer_name: str = None,
-        model_number: str = None,
-        serial_number: str = None,
-        hardware_revision: str = None,
-        firmware_revision: str = None,
-        software_revision: str = None,
-        system_id: Tuple[int, int] = None,  # (OUI, Manufacturer ID)
-        ieee_regulatory_certification_data_list: bytes = None
+        manufacturer_name: Optional[str] = None,
+        model_number: Optional[str] = None,
+        serial_number: Optional[str] = None,
+        hardware_revision: Optional[str] = None,
+        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
         # TODO: pnp_id
     ):
         characteristics = [

bumble/rfcomm.py

@@ -18,10 +18,10 @@
 import logging
 import asyncio
 
-from colors import color
 from pyee import EventEmitter
 
 from . import core
+from .colors import color
 from .core import BT_BR_EDR_TRANSPORT, InvalidStateError, ProtocolError
 
 # -----------------------------------------------------------------------------

bumble/sdp.py

@@ -15,12 +15,13 @@
 # -----------------------------------------------------------------------------
 # Imports
 # -----------------------------------------------------------------------------
+from __future__ import annotations
 import logging
 import struct
-from colors import color
-import colors
+from typing import Dict, List, Type
 
 from . import core
+from .colors import color
 from .core import InvalidStateError
 from .hci import HCI_Object, name_or_number, key_with_value
 
@@ -181,63 +182,63 @@ class DataElement:
                 raise ValueError('integer types must have a value size specified')
 
     @staticmethod
-    def nil():
+    def nil() -> DataElement:
         return DataElement(DataElement.NIL, None)
 
     @staticmethod
-    def unsigned_integer(value, value_size):
+    def unsigned_integer(value: int, value_size: int) -> DataElement:
         return DataElement(DataElement.UNSIGNED_INTEGER, value, value_size)
 
     @staticmethod
-    def unsigned_integer_8(value):
+    def unsigned_integer_8(value: int) -> DataElement:
         return DataElement(DataElement.UNSIGNED_INTEGER, value, value_size=1)
 
     @staticmethod
-    def unsigned_integer_16(value):
+    def unsigned_integer_16(value: int) -> DataElement:
         return DataElement(DataElement.UNSIGNED_INTEGER, value, value_size=2)
 
     @staticmethod
-    def unsigned_integer_32(value):
+    def unsigned_integer_32(value: int) -> DataElement:
         return DataElement(DataElement.UNSIGNED_INTEGER, value, value_size=4)
 
     @staticmethod
-    def signed_integer(value, value_size):
+    def signed_integer(value: int, value_size: int) -> DataElement:
         return DataElement(DataElement.SIGNED_INTEGER, value, value_size)
 
     @staticmethod
-    def signed_integer_8(value):
+    def signed_integer_8(value: int) -> DataElement:
         return DataElement(DataElement.SIGNED_INTEGER, value, value_size=1)
 
     @staticmethod
-    def signed_integer_16(value):
+    def signed_integer_16(value: int) -> DataElement:
         return DataElement(DataElement.SIGNED_INTEGER, value, value_size=2)
 
     @staticmethod
-    def signed_integer_32(value):
+    def signed_integer_32(value: int) -> DataElement:
         return DataElement(DataElement.SIGNED_INTEGER, value, value_size=4)
 
     @staticmethod
-    def uuid(value):
+    def uuid(value: core.UUID) -> DataElement:
         return DataElement(DataElement.UUID, value)
 
     @staticmethod
-    def text_string(value):
+    def text_string(value: str) -> DataElement:
         return DataElement(DataElement.TEXT_STRING, value)
 
     @staticmethod
-    def boolean(value):
+    def boolean(value: bool) -> DataElement:
         return DataElement(DataElement.BOOLEAN, value)
 
     @staticmethod
-    def sequence(value):
+    def sequence(value: List[DataElement]) -> DataElement:
         return DataElement(DataElement.SEQUENCE, value)
 
     @staticmethod
-    def alternative(value):
+    def alternative(value: List[DataElement]) -> DataElement:
         return DataElement(DataElement.ALTERNATIVE, value)
 
     @staticmethod
-    def url(value):
+    def url(value: str) -> DataElement:
         return DataElement(DataElement.URL, value)
 
     @staticmethod
@@ -456,7 +457,7 @@ class DataElement:
 
 # -----------------------------------------------------------------------------
 class ServiceAttribute:
-    def __init__(self, attribute_id, value):
+    def __init__(self, attribute_id: int, value: DataElement) -> None:
         self.id = attribute_id
         self.value = value
 
@@ -504,7 +505,7 @@ class ServiceAttribute:
     def to_string(self, with_colors=False):
         if with_colors:
             return (
-                f'Attribute(id={colors.color(self.id_name(self.id),"magenta")},'
+                f'Attribute(id={color(self.id_name(self.id),"magenta")},'
                 f'value={self.value})'
             )
 
@@ -520,7 +521,7 @@ class SDP_PDU:
     See Bluetooth spec @ Vol 3, Part B - 4.2 PROTOCOL DATA UNIT FORMAT
     '''
 
-    sdp_pdu_classes = {}
+    sdp_pdu_classes: Dict[int, Type[SDP_PDU]] = {}
     name = None
     pdu_id = 0
 

bumble/smp.py

@@ -22,12 +22,15 @@
 # -----------------------------------------------------------------------------
 # Imports
 # -----------------------------------------------------------------------------
+from __future__ import annotations
 import logging
 import asyncio
 import secrets
-from pyee import EventEmitter
-from colors import color
+from typing import Dict, Optional, Type
 
+from pyee import EventEmitter
+
+from .colors import color
 from .hci import Address, HCI_LE_Enable_Encryption_Command, HCI_Object, key_with_value
 from .core import (
     BT_BR_EDR_TRANSPORT,
@@ -184,7 +187,7 @@ class SMP_Command:
     See Bluetooth spec @ Vol 3, Part H - 3 SECURITY MANAGER PROTOCOL
     '''
 
-    smp_classes = {}
+    smp_classes: Dict[int, Type[SMP_Command]] = {}
     code = 0
     name = ''
 
@@ -495,33 +498,35 @@ class PairingDelegate:
     DISPLAY_OUTPUT_ONLY = SMP_DISPLAY_ONLY_IO_CAPABILITY
     DISPLAY_OUTPUT_AND_YES_NO_INPUT = SMP_DISPLAY_YES_NO_IO_CAPABILITY
     DISPLAY_OUTPUT_AND_KEYBOARD_INPUT = SMP_KEYBOARD_DISPLAY_IO_CAPABILITY
-    DEFAULT_KEY_DISTRIBUTION = (
+    DEFAULT_KEY_DISTRIBUTION: int = (
         SMP_ENC_KEY_DISTRIBUTION_FLAG | SMP_ID_KEY_DISTRIBUTION_FLAG
     )
 
     def __init__(
         self,
-        io_capability=NO_OUTPUT_NO_INPUT,
-        local_initiator_key_distribution=DEFAULT_KEY_DISTRIBUTION,
-        local_responder_key_distribution=DEFAULT_KEY_DISTRIBUTION,
-    ):
+        io_capability: int = NO_OUTPUT_NO_INPUT,
+        local_initiator_key_distribution: int = DEFAULT_KEY_DISTRIBUTION,
+        local_responder_key_distribution: int = DEFAULT_KEY_DISTRIBUTION,
+    ) -> None:
         self.io_capability = io_capability
         self.local_initiator_key_distribution = local_initiator_key_distribution
         self.local_responder_key_distribution = local_responder_key_distribution
 
-    async def accept(self):
+    async def accept(self) -> bool:
         return True
 
-    async def confirm(self):
+    async def confirm(self) -> bool:
         return True
 
-    async def compare_numbers(self, _number, _digits=6):
+    # pylint: disable-next=unused-argument
+    async def compare_numbers(self, number: int, digits: int) -> bool:
         return True
 
-    async def get_number(self):
+    async def get_number(self) -> int:
         return 0
 
-    async def display_number(self, _number, _digits=6):
+    # pylint: disable-next=unused-argument
+    async def display_number(self, number: int, digits: int) -> None:
         pass
 
     async def key_distribution_response(
@@ -535,7 +540,13 @@ class PairingDelegate:
 
 # -----------------------------------------------------------------------------
 class PairingConfig:
-    def __init__(self, sc=True, mitm=True, bonding=True, delegate=None):
+    def __init__(
+        self,
+        sc: bool = True,
+        mitm: bool = True,
+        bonding: bool = True,
+        delegate: Optional[PairingDelegate] = None,
+    ) -> None:
         self.sc = sc
         self.mitm = mitm
         self.bonding = bonding
@@ -652,7 +663,8 @@ class Session:
         self.peer_expected_distributions = []
         self.dh_key = None
         self.confirm_value = None
-        self.passkey = 0
+        self.passkey = None
+        self.passkey_ready = asyncio.Event()
         self.passkey_step = 0
         self.passkey_display = False
         self.pairing_method = 0
@@ -830,6 +842,7 @@ class Session:
         # Generate random Passkey/PIN code
         self.passkey = secrets.randbelow(1000000)
         logger.debug(f'Pairing PIN CODE: {self.passkey:06}')
+        self.passkey_ready.set()
 
         # The value of TK is computed from the PIN code
         if not self.sc:
@@ -850,6 +863,8 @@ class Session:
                 self.tk = passkey.to_bytes(16, byteorder='little')
                 logger.debug(f'TK from passkey = {self.tk.hex()}')
 
+            self.passkey_ready.set()
+
             if next_steps is not None:
                 next_steps()
 
@@ -901,17 +916,29 @@ class Session:
         logger.debug(f'generated random: {self.r.hex()}')
 
         if self.sc:
-            if self.pairing_method in (self.JUST_WORKS, self.NUMERIC_COMPARISON):
-                z = 0
-            elif self.pairing_method == self.PASSKEY:
-                z = 0x80 + ((self.passkey >> self.passkey_step) & 1)
-            else:
-                return
 
-            if self.is_initiator:
-                confirm_value = crypto.f4(self.pka, self.pkb, self.r, bytes([z]))
-            else:
-                confirm_value = crypto.f4(self.pkb, self.pka, self.r, bytes([z]))
+            async def next_steps():
+                if self.pairing_method in (self.JUST_WORKS, self.NUMERIC_COMPARISON):
+                    z = 0
+                elif self.pairing_method == self.PASSKEY:
+                    # We need a passkey
+                    await self.passkey_ready.wait()
+
+                    z = 0x80 + ((self.passkey >> self.passkey_step) & 1)
+                else:
+                    return
+
+                if self.is_initiator:
+                    confirm_value = crypto.f4(self.pka, self.pkb, self.r, bytes([z]))
+                else:
+                    confirm_value = crypto.f4(self.pkb, self.pka, self.r, bytes([z]))
+
+                self.send_command(
+                    SMP_Pairing_Confirm_Command(confirm_value=confirm_value)
+                )
+
+            # Perform the next steps asynchronously in case we need to wait for input
+            self.connection.abort_on('disconnection', next_steps())
         else:
             confirm_value = crypto.c1(
                 self.tk,
@@ -924,7 +951,7 @@ class Session:
                 self.ra,
             )
 
-        self.send_command(SMP_Pairing_Confirm_Command(confirm_value=confirm_value))
+            self.send_command(SMP_Pairing_Confirm_Command(confirm_value=confirm_value))
 
     def send_pairing_random_command(self):
         self.send_command(SMP_Pairing_Random_Command(random_value=self.r))
@@ -1355,8 +1382,8 @@ class Session:
 
         # Start phase 2
         if self.sc:
-            if self.pairing_method == self.PASSKEY and self.passkey_display:
-                self.display_passkey()
+            if self.pairing_method == self.PASSKEY:
+                self.display_or_input_passkey()
 
             self.send_public_key_command()
         else:
@@ -1417,18 +1444,22 @@ class Session:
         else:
             srand = self.r
             mrand = command.random_value
-        stk = crypto.s1(self.tk, srand, mrand)
-        logger.debug(f'STK = {stk.hex()}')
+        self.stk = crypto.s1(self.tk, srand, mrand)
+        logger.debug(f'STK = {self.stk.hex()}')
 
         # Generate LTK
         self.ltk = crypto.r()
 
         if self.is_initiator:
-            self.start_encryption(stk)
+            self.start_encryption(self.stk)
         else:
             self.send_pairing_random_command()
 
     def on_smp_pairing_random_command_secure_connections(self, command):
+        if self.pairing_method == self.PASSKEY and self.passkey is None:
+            logger.warning('no passkey entered, ignoring command')
+            return
+
         # pylint: disable=too-many-return-statements
         if self.is_initiator:
             if self.pairing_method in (self.JUST_WORKS, self.NUMERIC_COMPARISON):
@@ -1556,17 +1587,13 @@ class Session:
         logger.debug(f'DH key: {self.dh_key.hex()}')
 
         if self.is_initiator:
-            if self.pairing_method == self.PASSKEY:
-                if self.passkey_display:
-                    self.send_pairing_confirm_command()
-                else:
-                    self.input_passkey(self.send_pairing_confirm_command)
+            self.send_pairing_confirm_command()
         else:
-            # Send our public key back to the initiator
             if self.pairing_method == self.PASSKEY:
-                self.display_or_input_passkey(self.send_public_key_command)
-            else:
-                self.send_public_key_command()
+                self.display_or_input_passkey()
+
+            # Send our public key back to the initiator
+            self.send_public_key_command()
 
             if self.pairing_method in (self.JUST_WORKS, self.NUMERIC_COMPARISON):
                 # We can now send the confirmation value

bumble/snoop.py

@@ -0,0 +1,93 @@
+# 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 enum import IntEnum
+import struct
+import datetime
+from typing import BinaryIO
+
+from bumble.hci import HCI_Packet, HCI_COMMAND_PACKET, HCI_EVENT_PACKET
+
+
+# -----------------------------------------------------------------------------
+# Classes
+# -----------------------------------------------------------------------------
+class Snooper:
+    """
+    Base class for snooper implementations.
+
+    A snooper is an object that will be provided with HCI packets as they are
+    exchanged between a host and a controller.
+    """
+
+    class Direction(IntEnum):
+        HOST_TO_CONTROLLER = 0
+        CONTROLLER_TO_HOST = 1
+
+    class DataLinkType(IntEnum):
+        H1 = 1001
+        H4 = 1002
+        HCI_BSCP = 1003
+        H5 = 1004
+
+    def snoop(self, hci_packet: HCI_Packet, direction: Direction) -> None:
+        """Snoop on an HCI packet."""
+
+
+# -----------------------------------------------------------------------------
+class BtSnooper(Snooper):
+    """
+    Snooper that saves HCI packets using the BTSnoop format, based on RFC 1761.
+    """
+
+    IDENTIFICATION_PATTERN = b'btsnoop\0'
+    TIMESTAMP_ANCHOR = datetime.datetime(2000, 1, 1)
+    TIMESTAMP_DELTA = 0x00E03AB44A676000
+    ONE_MS = datetime.timedelta(microseconds=1)
+
+    def __init__(self, output: BinaryIO):
+        self.output = output
+
+        # Write the header
+        self.output.write(
+            self.IDENTIFICATION_PATTERN + struct.pack('>LL', 1, self.DataLinkType.H4)
+        )
+
+    def snoop(self, hci_packet: HCI_Packet, direction: Snooper.Direction) -> None:
+        flags = int(direction)
+        if hci_packet.hci_packet_type in (HCI_EVENT_PACKET, HCI_COMMAND_PACKET):
+            flags |= 0x10
+
+        # Compute the current timestamp
+        timestamp = (
+            int((datetime.datetime.utcnow() - self.TIMESTAMP_ANCHOR) / self.ONE_MS)
+            + self.TIMESTAMP_DELTA
+        )
+
+        # Emit the record
+        packet_data = bytes(hci_packet)
+        self.output.write(
+            struct.pack(
+                '>IIIIQ',
+                len(packet_data),  # Original Length
+                len(packet_data),  # Included Length
+                flags,  # Packet Flags
+                0,  # Cumulative Drops
+                timestamp,  # Timestamp
+            )
+            + packet_data
+        )

bumble/transport/__init__.py

@@ -18,7 +18,6 @@
 import logging
 
 from .common import Transport, AsyncPipeSink
-from ..link import RemoteLink
 from ..controller import Controller
 
 # -----------------------------------------------------------------------------
@@ -28,7 +27,7 @@ logger = logging.getLogger(__name__)
 
 
 # -----------------------------------------------------------------------------
-async def open_transport(name):
+async def open_transport(name: str) -> Transport:
     '''
     Open a transport by name.
     The name must be <type>:<parameters>
@@ -110,6 +109,8 @@ async def open_transport(name):
 # -----------------------------------------------------------------------------
 async def open_transport_or_link(name):
     if name.startswith('link-relay:'):
+        from ..link import RemoteLink  # lazy import
+
         link = RemoteLink(name[11:])
         await link.wait_until_connected()
         controller = Controller('remote', link=link)

bumble/transport/android_emulator.py

@@ -1,4 +1,4 @@
-# Copyright 2021-2022 Google LLC
+# 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.
@@ -20,9 +20,11 @@ import grpc
 
 from .common import PumpedTransport, PumpedPacketSource, PumpedPacketSink
 from .emulated_bluetooth_pb2_grpc import EmulatedBluetoothServiceStub
-from .emulated_bluetooth_packets_pb2 import HCIPacket
 from .emulated_bluetooth_vhci_pb2_grpc import VhciForwardingServiceStub
 
+# pylint: disable-next=no-name-in-module
+from .emulated_bluetooth_packets_pb2 import HCIPacket
+
 
 # -----------------------------------------------------------------------------
 # Logging

bumble/transport/common.py

@@ -18,9 +18,9 @@
 import struct
 import asyncio
 import logging
-from colors import color
 
 from .. import hci
+from ..colors import color
 
 
 # -----------------------------------------------------------------------------
@@ -259,7 +259,7 @@ class Transport:
     def __iter__(self):
         return iter((self.source, self.sink))
 
-    async def close(self):
+    async def close(self) -> None:
         self.source.close()
         self.sink.close()
 

bumble/transport/emulated_bluetooth_packets_pb2.py

@@ -1,4 +1,4 @@
-# Copyright 2021-2022 Google LLC
+# 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.
@@ -16,10 +16,9 @@
 # Generated by the protocol buffer compiler.  DO NOT EDIT!
 # source: emulated_bluetooth_packets.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 message as _message
-from google.protobuf import reflection as _reflection
 from google.protobuf import symbol_database as _symbol_database
 
 # @@protoc_insertion_point(imports)
@@ -31,20 +30,10 @@ DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(
     b'\n emulated_bluetooth_packets.proto\x12\x1b\x61ndroid.emulation.bluetooth\"\xfb\x01\n\tHCIPacket\x12?\n\x04type\x18\x01 \x01(\x0e\x32\x31.android.emulation.bluetooth.HCIPacket.PacketType\x12\x0e\n\x06packet\x18\x02 \x01(\x0c\"\x9c\x01\n\nPacketType\x12\x1b\n\x17PACKET_TYPE_UNSPECIFIED\x10\x00\x12\x1b\n\x17PACKET_TYPE_HCI_COMMAND\x10\x01\x12\x13\n\x0fPACKET_TYPE_ACL\x10\x02\x12\x13\n\x0fPACKET_TYPE_SCO\x10\x03\x12\x15\n\x11PACKET_TYPE_EVENT\x10\x04\x12\x13\n\x0fPACKET_TYPE_ISO\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'
 )
 
-
-_HCIPACKET = DESCRIPTOR.message_types_by_name['HCIPacket']
-_HCIPACKET_PACKETTYPE = _HCIPACKET.enum_types_by_name['PacketType']
-HCIPacket = _reflection.GeneratedProtocolMessageType(
-    'HCIPacket',
-    (_message.Message,),
-    {
-        'DESCRIPTOR': _HCIPACKET,
-        '__module__': 'emulated_bluetooth_packets_pb2'
-        # @@protoc_insertion_point(class_scope:android.emulation.bluetooth.HCIPacket)
-    },
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals())
+_builder.BuildTopDescriptorsAndMessages(
+    DESCRIPTOR, 'emulated_bluetooth_packets_pb2', globals()
 )
-_sym_db.RegisterMessage(HCIPacket)
-
 if _descriptor._USE_C_DESCRIPTORS == False:
 
     DESCRIPTOR._options = None

bumble/transport/emulated_bluetooth_packets_pb2.pyi

@@ -0,0 +1,41 @@
+# 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.
+
+from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from typing import ClassVar as _ClassVar, Optional as _Optional, Union as _Union
+
+DESCRIPTOR: _descriptor.FileDescriptor
+
+class HCIPacket(_message.Message):
+    __slots__ = ["packet", "type"]
+
+    class PacketType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper):
+        __slots__ = []
+    PACKET_FIELD_NUMBER: _ClassVar[int]
+    PACKET_TYPE_ACL: HCIPacket.PacketType
+    PACKET_TYPE_EVENT: HCIPacket.PacketType
+    PACKET_TYPE_HCI_COMMAND: HCIPacket.PacketType
+    PACKET_TYPE_ISO: HCIPacket.PacketType
+    PACKET_TYPE_SCO: HCIPacket.PacketType
+    PACKET_TYPE_UNSPECIFIED: HCIPacket.PacketType
+    TYPE_FIELD_NUMBER: _ClassVar[int]
+    packet: bytes
+    type: HCIPacket.PacketType
+    def __init__(
+        self,
+        type: _Optional[_Union[HCIPacket.PacketType, str]] = ...,
+        packet: _Optional[bytes] = ...,
+    ) -> None: ...

bumble/transport/emulated_bluetooth_packets_pb2_grpc.py

@@ -0,0 +1,17 @@
+# 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.
+
+# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
+"""Client and server classes corresponding to protobuf-defined services."""
+import grpc

bumble/transport/emulated_bluetooth_pb2.py

@@ -1,4 +1,4 @@
-# Copyright 2021-2022 Google LLC
+# 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.
@@ -16,10 +16,9 @@
 # Generated by the protocol buffer compiler.  DO NOT EDIT!
 # source: emulated_bluetooth.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 message as _message
-from google.protobuf import reflection as _reflection
 from google.protobuf import symbol_database as _symbol_database
 
 # @@protoc_insertion_point(imports)
@@ -34,20 +33,8 @@ DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(
     b'\n\x18\x65mulated_bluetooth.proto\x12\x1b\x61ndroid.emulation.bluetooth\x1a emulated_bluetooth_packets.proto\"\x19\n\x07RawData\x12\x0e\n\x06packet\x18\x01 \x01(\x0c\x32\xcb\x02\n\x18\x45mulatedBluetoothService\x12\x64\n\x12registerClassicPhy\x12$.android.emulation.bluetooth.RawData\x1a$.android.emulation.bluetooth.RawData(\x01\x30\x01\x12`\n\x0eregisterBlePhy\x12$.android.emulation.bluetooth.RawData\x1a$.android.emulation.bluetooth.RawData(\x01\x30\x01\x12g\n\x11registerHCIDevice\x12&.android.emulation.bluetooth.HCIPacket\x1a&.android.emulation.bluetooth.HCIPacket(\x01\x30\x01\x42\"\n\x1e\x63om.android.emulator.bluetoothP\x01\x62\x06proto3'
 )
 
-
-_RAWDATA = DESCRIPTOR.message_types_by_name['RawData']
-RawData = _reflection.GeneratedProtocolMessageType(
-    'RawData',
-    (_message.Message,),
-    {
-        'DESCRIPTOR': _RAWDATA,
-        '__module__': 'emulated_bluetooth_pb2'
-        # @@protoc_insertion_point(class_scope:android.emulation.bluetooth.RawData)
-    },
-)
-_sym_db.RegisterMessage(RawData)
-
-_EMULATEDBLUETOOTHSERVICE = DESCRIPTOR.services_by_name['EmulatedBluetoothService']
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals())
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'emulated_bluetooth_pb2', globals())
 if _descriptor._USE_C_DESCRIPTORS == False:
 
     DESCRIPTOR._options = None

bumble/transport/emulated_bluetooth_pb2.pyi

@@ -0,0 +1,26 @@
+# 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.
+
+import emulated_bluetooth_packets_pb2 as _emulated_bluetooth_packets_pb2
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from typing import ClassVar as _ClassVar, Optional as _Optional
+
+DESCRIPTOR: _descriptor.FileDescriptor
+
+class RawData(_message.Message):
+    __slots__ = ["packet"]
+    PACKET_FIELD_NUMBER: _ClassVar[int]
+    packet: bytes
+    def __init__(self, packet: _Optional[bytes] = ...) -> None: ...

bumble/transport/emulated_bluetooth_pb2_grpc.py

@@ -1,4 +1,4 @@
-# Copyright 2021-2022 Google LLC
+# 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.

bumble/transport/emulated_bluetooth_vhci_pb2.py

@@ -1,4 +1,4 @@
-# Copyright 2021-2022 Google LLC
+# 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.
@@ -16,10 +16,9 @@
 # Generated by the protocol buffer compiler.  DO NOT EDIT!
 # source: emulated_bluetooth_vhci.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 message as _message
-from google.protobuf import reflection as _reflection
 from google.protobuf import symbol_database as _symbol_database
 
 # @@protoc_insertion_point(imports)
@@ -27,15 +26,17 @@ from google.protobuf import symbol_database as _symbol_database
 _sym_db = _symbol_database.Default()
 
 
-import emulated_bluetooth_packets_pb2 as emulated__bluetooth__packets__pb2
+from . import emulated_bluetooth_packets_pb2 as emulated__bluetooth__packets__pb2
 
 
 DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(
     b'\n\x1d\x65mulated_bluetooth_vhci.proto\x12\x1b\x61ndroid.emulation.bluetooth\x1a emulated_bluetooth_packets.proto2y\n\x15VhciForwardingService\x12`\n\nattachVhci\x12&.android.emulation.bluetooth.HCIPacket\x1a&.android.emulation.bluetooth.HCIPacket(\x01\x30\x01\x42J\n\x1f\x63om.android.emulation.bluetoothP\x01\xf8\x01\x01\xa2\x02\x03\x41\x45\x42\xaa\x02\x1b\x41ndroid.Emulation.Bluetoothb\x06proto3'
 )
 
-
-_VHCIFORWARDINGSERVICE = DESCRIPTOR.services_by_name['VhciForwardingService']
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals())
+_builder.BuildTopDescriptorsAndMessages(
+    DESCRIPTOR, 'emulated_bluetooth_vhci_pb2', globals()
+)
 if _descriptor._USE_C_DESCRIPTORS == False:
 
     DESCRIPTOR._options = None

bumble/transport/emulated_bluetooth_vhci_pb2.pyi

@@ -0,0 +1,19 @@
+# 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.
+
+import emulated_bluetooth_packets_pb2 as _emulated_bluetooth_packets_pb2
+from google.protobuf import descriptor as _descriptor
+from typing import ClassVar as _ClassVar
+
+DESCRIPTOR: _descriptor.FileDescriptor

bumble/transport/emulated_bluetooth_vhci_pb2_grpc.py

@@ -1,4 +1,4 @@
-# Copyright 2021-2022 Google LLC
+# 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.

bumble/transport/pyusb.py

@@ -20,13 +20,12 @@ import logging
 import threading
 import time
 
-import libusb_package
 import usb.core
 import usb.util
-from colors import color
 
 from .common import Transport, ParserSource
 from .. import hci
+from ..colors import color
 
 
 # -----------------------------------------------------------------------------
@@ -205,16 +204,22 @@ async def open_pyusb_transport(spec):
             await self.sink.stop()
             usb.util.release_interface(self.device, 0)
 
+    usb_find = usb.core.find
+    try:
+        import libusb_package
+    except ImportError:
+        logger.debug('libusb_package is not available')
+    else:
+        usb_find = libusb_package.find
+
     # Find the device according to the spec moniker
     if ':' in spec:
         vendor_id, product_id = spec.split(':')
-        device = libusb_package.find(
-            idVendor=int(vendor_id, 16), idProduct=int(product_id, 16)
-        )
+        device = usb_find(idVendor=int(vendor_id, 16), idProduct=int(product_id, 16))
     else:
         device_index = int(spec)
         devices = list(
-            libusb_package.find(
+            usb_find(
                 find_all=1,
                 bDeviceClass=USB_DEVICE_CLASS_WIRELESS_CONTROLLER,
                 bDeviceSubClass=USB_DEVICE_SUBCLASS_RF_CONTROLLER,

bumble/transport/usb.py

@@ -22,12 +22,11 @@ import collections
 import ctypes
 import platform
 
-import libusb_package
 import usb1
-from colors import color
 
 from .common import Transport, ParserSource
 from .. import hci
+from ..colors import color
 
 
 # -----------------------------------------------------------------------------
@@ -45,11 +44,20 @@ def load_libusb():
     If the library does not exists, do nothing and usb1 will search default system paths
     when usb1.USBContext is created.
     '''
-    if libusb_path := libusb_package.get_library_path():
-        logger.debug(f'loading libusb library at {libusb_path}')
-        dll_loader = ctypes.WinDLL if platform.system() == 'Windows' else ctypes.CDLL
-        libusb_dll = dll_loader(str(libusb_path), use_errno=True, use_last_error=True)
-        usb1.loadLibrary(libusb_dll)
+    try:
+        import libusb_package
+    except ImportError:
+        logger.debug('libusb_package is not available')
+    else:
+        if libusb_path := libusb_package.get_library_path():
+            logger.debug(f'loading libusb library at {libusb_path}')
+            dll_loader = (
+                ctypes.WinDLL if platform.system() == 'Windows' else ctypes.CDLL
+            )
+            libusb_dll = dll_loader(
+                str(libusb_path), use_errno=True, use_last_error=True
+            )
+            usb1.loadLibrary(libusb_dll)
 
 
 async def open_usb_transport(spec):

bumble/utils.py

@@ -20,11 +20,11 @@ import logging
 import traceback
 import collections
 import sys
-from typing import Awaitable
+from typing import Awaitable, TypeVar
 from functools import wraps
-from colors import color
 from pyee import EventEmitter
 
+from .colors import color
 
 # -----------------------------------------------------------------------------
 # Logging
@@ -65,8 +65,11 @@ def composite_listener(cls):
 
 
 # -----------------------------------------------------------------------------
+_T = TypeVar('_T')
+
+
 class AbortableEventEmitter(EventEmitter):
-    def abort_on(self, event: str, awaitable: Awaitable):
+    def abort_on(self, event: str, awaitable: Awaitable[_T]) -> Awaitable[_T]:
         """
         Set a coroutine or future to abort when an event occur.
         """
@@ -75,6 +78,8 @@ class AbortableEventEmitter(EventEmitter):
             return future
 
         def on_event(*_):
+            if future.done():
+                return
             msg = f'abort: {event} event occurred.'
             if isinstance(future, asyncio.Task):
                 # python < 3.9 does not support passing a message on `Task.cancel`

examples/battery_client.py

@@ -19,7 +19,7 @@ import asyncio
 import sys
 import os
 import logging
-from colors import color
+from bumble.colors import color
 from bumble.device import Device
 from bumble.transport import open_transport
 from bumble.profiles.battery_service import BatteryServiceProxy

examples/device_information_client.py

@@ -19,7 +19,7 @@ import asyncio
 import sys
 import os
 import logging
-from colors import color
+from bumble.colors import color
 from bumble.device import Device, Peer
 from bumble.profiles.device_information_service import DeviceInformationServiceProxy
 from bumble.transport import open_transport

examples/heart_rate_client.py

@@ -19,7 +19,7 @@ import asyncio
 import sys
 import os
 import logging
-from colors import color
+from bumble.colors import color
 from bumble.device import Device
 from bumble.transport import open_transport
 from bumble.profiles.heart_rate_service import HeartRateServiceProxy

examples/keyboard.py

@@ -22,7 +22,7 @@ import logging
 import struct
 import json
 import websockets
-from colors import color
+from bumble.colors import color
 
 from bumble.core import AdvertisingData
 from bumble.device import Device, Connection, Peer

examples/run_a2dp_info.py

@@ -20,7 +20,7 @@ import sys
 import os
 import logging
 
-from colors import color
+from bumble.colors import color
 from bumble.device import Device
 from bumble.transport import open_transport_or_link
 from bumble.core import (

examples/run_a2dp_source.py

@@ -20,7 +20,7 @@ import sys
 import os
 import logging
 
-from colors import color
+from bumble.colors import color
 from bumble.device import Device
 from bumble.transport import open_transport_or_link
 from bumble.core import BT_BR_EDR_TRANSPORT

examples/run_classic_connect.py

@@ -19,7 +19,7 @@ import asyncio
 import sys
 import os
 import logging
-from colors import color
+from bumble.colors import color
 
 from bumble.device import Device
 from bumble.transport import open_transport_or_link

examples/run_classic_discovery.py

@@ -19,7 +19,7 @@ import asyncio
 import sys
 import os
 import logging
-from colors import color
+from bumble.colors import color
 
 from bumble.device import Device
 from bumble.transport import open_transport_or_link

examples/run_controller_with_scanner.py

@@ -19,7 +19,7 @@ import logging
 import asyncio
 import sys
 import os
-from colors import color
+from bumble.colors import color
 
 from bumble.device import Device
 from bumble.controller import Controller

examples/run_device_with_snooper.py

@@ -0,0 +1,51 @@
+# Copyright 2021-2023 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import asyncio
+import sys
+import os
+import logging
+from bumble.colors import color
+
+from bumble.device import Device
+from bumble.transport import open_transport_or_link
+from bumble.snoop import BtSnooper
+
+# -----------------------------------------------------------------------------
+async def main():
+    if len(sys.argv) != 3:
+        print('Usage: run_device_with_snooper.py <transport-spec> <snoop-file>')
+        print('example: run_device_with_snooper.py usb:0 btsnoop.log')
+        return
+
+    print('<<< connecting to HCI...')
+    async with await open_transport_or_link(sys.argv[1]) as (hci_source, hci_sink):
+        print('<<< connected')
+
+        device = Device.with_hci('Bumble', 'F0:F1:F2:F3:F4:F5', hci_source, hci_sink)
+
+        with open(sys.argv[2], "wb") as snoop_file:
+            device.host.snooper = BtSnooper(snoop_file)
+            await device.power_on()
+            await device.start_scanning()
+
+            await hci_source.wait_for_termination()
+
+
+# -----------------------------------------------------------------------------
+logging.basicConfig(level=os.environ.get('BUMBLE_LOGLEVEL', 'DEBUG').upper())
+asyncio.run(main())

examples/run_gatt_client.py

@@ -19,7 +19,7 @@ import asyncio
 import sys
 import os
 import logging
-from colors import color
+from bumble.colors import color
 
 from bumble.core import ProtocolError
 from bumble.device import Device, Peer

examples/run_gatt_client_and_server.py

@@ -18,7 +18,7 @@
 import asyncio
 import os
 import logging
-from colors import color
+from bumble.colors import color
 
 from bumble.core import ProtocolError
 from bumble.controller import Controller

examples/run_hfp_gateway.py

@@ -20,7 +20,7 @@ import sys
 import os
 import logging
 
-from colors import color
+from bumble.colors import color
 
 import bumble.core
 from bumble.device import Device

examples/run_rfcomm_client.py

@@ -20,7 +20,7 @@ import sys
 import os
 import logging
 
-from colors import color
+from bumble.colors import color
 
 import bumble.core
 from bumble.device import Device

examples/run_scanner.py

@@ -19,7 +19,7 @@ import asyncio
 import sys
 import os
 import logging
-from colors import color
+from bumble.colors import color
 
 from bumble.device import Device
 from bumble.transport import open_transport_or_link

pyproject.toml

@@ -50,3 +50,44 @@ signature-mutators="AsyncRunner.run_in_task"
 
 [tool.black]
 skip-string-normalization = true
+
+[[tool.mypy.overrides]]
+module = "bumble.transport.emulated_bluetooth_pb2_grpc"
+ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+module = "bumble.transport.emulated_bluetooth_packets_pb2"
+ignore_errors = true
+
+[[tool.mypy.overrides]]
+module = "aioconsole.*"
+ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+module = "colors.*"
+ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+module = "construct.*"
+ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+module = "emulated_bluetooth_packets_pb2.*"
+ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+module = "grpc.*"
+ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+module = "serial_asyncio.*"
+ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+module = "usb.*"
+ignore_missing_imports = true
+
+[[tool.mypy.overrides]]
+module = "usb1.*"
+ignore_missing_imports = true
+

scripts/process_android_emulator_protos.sh

@@ -0,0 +1,27 @@
+# Invoke this script with an argument pointing to where the Android emulator .proto files are.
+# The .proto files should be slightly modified from their original version (as distributed with
+# the Android emulator):
+# --> Remove unused types/methods from emulated_bluetooth.proto
+
+PROTOC_OUT=bumble/transport
+LICENSE_FILE_INPUT=bumble/transport/android_emulator.py
+
+proto_files=(emulated_bluetooth.proto emulated_bluetooth_vhci.proto emulated_bluetooth_packets.proto)
+for proto_file in "${proto_files[@]}"
+do
+    python -m grpc_tools.protoc -I$1 --proto_path=bumble/transport --python_out=$PROTOC_OUT --pyi_out=$PROTOC_OUT --grpc_python_out=$PROTOC_OUT $1/$proto_file
+done
+
+python_files=(emulated_bluetooth_pb2.py emulated_bluetooth_pb2_grpc.py emulated_bluetooth_packets_pb2.py emulated_bluetooth_packets_pb2_grpc.py emulated_bluetooth_vhci_pb2_grpc.py emulated_bluetooth_vhci_pb2.py)
+for python_file in "${python_files[@]}"
+do
+    sed -i '' 's/^import .*_pb2 as/from . &/' $PROTOC_OUT/$python_file
+done
+
+stub_files=(emulated_bluetooth_pb2.pyi emulated_bluetooth_packets_pb2.pyi emulated_bluetooth_vhci_pb2.pyi)
+for source_file in "${python_files[@]}" "${stub_files[@]}"
+do
+    head -14 $LICENSE_FILE_INPUT > $PROTOC_OUT/${source_file}.lic
+    cat $PROTOC_OUT/$source_file >> $PROTOC_OUT/${source_file}.lic
+    mv $PROTOC_OUT/${source_file}.lic $PROTOC_OUT/$source_file
+done

setup.cfg

@@ -28,16 +28,14 @@ packages = bumble, bumble.transport, bumble.profiles, bumble.apps, bumble.apps.l
 package_dir =
     bumble = bumble
     bumble.apps = apps
+include-package-data = True
 install_requires =
-    aioconsole >= 0.4.1
-    ansicolors >= 1.1
     appdirs >= 1.4
-    bitstruct >= 8.12
     click >= 7.1.2; platform_system!='Emscripten'
     cryptography == 35; platform_system!='Emscripten'
     grpcio >= 1.46; platform_system!='Emscripten'
     libusb1 >= 2.0.1; platform_system!='Emscripten'
-    libusb-package == 1.0.26.0; platform_system!='Emscripten'
+    libusb-package == 1.0.26.1; platform_system!='Emscripten'
     prompt_toolkit >= 3.0.16; platform_system!='Emscripten'
     protobuf >= 3.12.4
     pyee >= 8.2.2
@@ -60,6 +58,9 @@ console_scripts =
     bumble-usb-probe = bumble.apps.usb_probe:main
     bumble-link-relay = bumble.apps.link_relay.link_relay:main
 
+[options.package_data]
+* = py.typed, *.pyi
+
 [options.extras_require]
 build =
     build >= 0.7
@@ -69,10 +70,14 @@ test =
     pytest-html >= 3.2.0
     coverage >= 6.4
 development =
-    black >= 22.10
+    black == 22.10
     invoke >= 1.7.3
+    mypy == 0.991
     nox >= 2022
-    pylint >= 2.15.8
+    pylint == 2.15.8
+    types-appdirs >= 1.4.3
+    types-invoke >= 1.7.3
+    types-protobuf >= 4.21.0
 documentation =
     mkdocs >= 1.4.0
     mkdocs-material >= 8.5.6

tasks.py

@@ -22,7 +22,7 @@ Invoke tasks
 import os
 
 from invoke import task, call, Collection
-from invoke.exceptions import UnexpectedExit
+from invoke.exceptions import Exit, UnexpectedExit
 
 
 # -----------------------------------------------------------------------------
@@ -126,9 +126,9 @@ def lint(ctx, disable='C,R', errors_only=False):
     try:
         ctx.run(f"pylint {' '.join(options)} bumble apps examples tasks.py")
         print("The linter is happy. ✅ 😊 🐝'")
-    except UnexpectedExit:
+    except UnexpectedExit as exc:
         print("Please check your code against the linter messages. ❌")
-    print(">>> Linter done.")
+        raise Exit(code=1) from exc
 
 
 # -----------------------------------------------------------------------------
@@ -143,13 +143,31 @@ def format_code(ctx, check=False, diff=False):
     print(">>> Running the formatter...")
     try:
         ctx.run(f"black -S {' '.join(options)} .")
-    except UnexpectedExit:
+    except UnexpectedExit as exc:
         print("Please run 'invoke project.format' or 'black .' to format the code. ❌")
-    print(">>> formatter done.")
+        raise Exit(code=1) from exc
 
 
 # -----------------------------------------------------------------------------
-@task(pre=[call(format_code, check=True), call(lint, errors_only=True), test])
+@task
+def check_types(ctx):
+    checklist = ["apps", "bumble", "examples", "tests", "tasks.py"]
+    try:
+        ctx.run(f"mypy {' '.join(checklist)}")
+    except UnexpectedExit as exc:
+        print("Please check your code against the mypy messages.")
+        raise Exit(code=1) from exc
+
+
+# -----------------------------------------------------------------------------
+@task(
+    pre=[
+        call(format_code, check=True),
+        call(lint, errors_only=True),
+        call(check_types),
+        test,
+    ]
+)
 def pre_commit(_ctx):
     print("All good!")
 
@@ -157,4 +175,5 @@ def pre_commit(_ctx):
 # -----------------------------------------------------------------------------
 project_tasks.add_task(lint)
 project_tasks.add_task(format_code, name="format")
+project_tasks.add_task(check_types, name="check-types")
 project_tasks.add_task(pre_commit)

tests/core_test.py

@@ -25,10 +25,8 @@ def test_ad_data():
     assert data == ad_bytes
     assert ad.get(AdvertisingData.COMPLETE_LOCAL_NAME, raw=True) is None
     assert ad.get(AdvertisingData.TX_POWER_LEVEL, raw=True) == bytes([123])
-    assert ad.get(AdvertisingData.COMPLETE_LOCAL_NAME, return_all=True, raw=True) == []
-    assert ad.get(AdvertisingData.TX_POWER_LEVEL, return_all=True, raw=True) == [
-        bytes([123])
-    ]
+    assert ad.get_all(AdvertisingData.COMPLETE_LOCAL_NAME, raw=True) == []
+    assert ad.get_all(AdvertisingData.TX_POWER_LEVEL, raw=True) == [bytes([123])]
 
     data2 = bytes([2, AdvertisingData.TX_POWER_LEVEL, 234])
     ad.append(data2)
@@ -36,8 +34,8 @@ def test_ad_data():
     assert ad_bytes == data + data2
     assert ad.get(AdvertisingData.COMPLETE_LOCAL_NAME, raw=True) is None
     assert ad.get(AdvertisingData.TX_POWER_LEVEL, raw=True) == bytes([123])
-    assert ad.get(AdvertisingData.COMPLETE_LOCAL_NAME, return_all=True, raw=True) == []
-    assert ad.get(AdvertisingData.TX_POWER_LEVEL, return_all=True, raw=True) == [
+    assert ad.get_all(AdvertisingData.COMPLETE_LOCAL_NAME, raw=True) == []
+    assert ad.get_all(AdvertisingData.TX_POWER_LEVEL, raw=True) == [
         bytes([123]),
         bytes([234]),
     ]

tests/device_test.py

@@ -197,7 +197,7 @@ async def test_device_connect_parallel():
     d1.host.set_packet_sink(Sink(d1_flow()))
     d2.host.set_packet_sink(Sink(d2_flow()))
 
-    [c01, c02, a10, a20, a01] = await asyncio.gather(
+    [c01, c02, a10, a20] = await asyncio.gather(
         *[
             asyncio.create_task(
                 d0.connect(d1.public_address, transport=BT_BR_EDR_TRANSPORT)
@@ -207,7 +207,6 @@ async def test_device_connect_parallel():
             ),
             asyncio.create_task(d1.accept(peer_address=d0.public_address)),
             asyncio.create_task(d2.accept()),
-            asyncio.create_task(d0.accept(peer_address=d1.public_address)),
         ]
     )
 
@@ -215,11 +214,9 @@ async def test_device_connect_parallel():
     assert type(c02) == Connection
     assert type(a10) == Connection
     assert type(a20) == Connection
-    assert type(a01) == Connection
 
     assert c01.handle == a10.handle and c01.handle == 0x100
     assert c02.handle == a20.handle and c02.handle == 0x101
-    assert a01 == c01
 
 
 # -----------------------------------------------------------------------------

tests/self_test.py

@@ -32,7 +32,6 @@ from bumble.smp import (
     PairingDelegate,
     SMP_PAIRING_NOT_SUPPORTED_ERROR,
     SMP_CONFIRM_VALUE_FAILED_ERROR,
-    SMP_ID_KEY_DISTRIBUTION_FLAG,
 )
 from bumble.core import ProtocolError
 
@@ -273,9 +272,15 @@ KEY_DIST = range(16)
 
 @pytest.mark.asyncio
 @pytest.mark.parametrize(
-    'io_cap, sc, mitm, key_dist', itertools.product(IO_CAP, SC, MITM, KEY_DIST)
+    'io_caps, sc, mitm, key_dist',
+    itertools.chain(
+        itertools.product([IO_CAP], SC, MITM, [15]),
+        itertools.product(
+            [[PairingDelegate.DISPLAY_OUTPUT_AND_KEYBOARD_INPUT]], SC, MITM, KEY_DIST
+        ),
+    ),
 )
-async def test_self_smp(io_cap, sc, mitm, key_dist):
+async def test_self_smp(io_caps, sc, mitm, key_dist):
     class Delegate(PairingDelegate):
         def __init__(
             self,
@@ -296,6 +301,7 @@ async def test_self_smp(io_cap, sc, mitm, key_dist):
             self.peer_delegate = None
             self.number = asyncio.get_running_loop().create_future()
 
+        # pylint: disable-next=unused-argument
         async def compare_numbers(self, number, digits):
             if self.peer_delegate is None:
                 logger.warning(f'[{self.name}] no peer delegate')
@@ -331,8 +337,9 @@ async def test_self_smp(io_cap, sc, mitm, key_dist):
 
     pairing_config_sets = [('Initiator', [None]), ('Responder', [None])]
     for pairing_config_set in pairing_config_sets:
-        delegate = Delegate(pairing_config_set[0], io_cap, key_dist, key_dist)
-        pairing_config_set[1].append(PairingConfig(sc, mitm, True, delegate))
+        for io_cap in io_caps:
+            delegate = Delegate(pairing_config_set[0], io_cap, key_dist, key_dist)
+            pairing_config_set[1].append(PairingConfig(sc, mitm, True, delegate))
 
     for pairing_config1 in pairing_config_sets[0][1]:
         for pairing_config2 in pairing_config_sets[1][1]:

web/scanner.py

@@ -16,7 +16,7 @@
 # Imports
 # -----------------------------------------------------------------------------
 from bumble.device import Device
-from bumble.transport import PacketParser
+from bumble.transport.common import PacketParser
 
 
 # -----------------------------------------------------------------------------