support with_response on adapters

use arg-less main() functions in all scripts

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,72 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ main ]
+  schedule:
+    - cron: '39 21 * * 4'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'python' ]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
+        # Learn more about CodeQL language support at https://aka.ms/codeql-docs/language-support
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v3
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v2
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+        
+        # Details on CodeQL's query packs refer to : https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
+        # queries: security-extended,security-and-quality
+
+        
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v2
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
+
+    #   If the Autobuild fails above, remove it and uncomment the following three lines. 
+    #   modify them (or add more) to build your code if your project, please refer to the EXAMPLE below for guidance.
+
+    # - run: |
+    #   echo "Run, Build Application using script"
+    #   ./location_of_script_within_repo/buildscript.sh
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v2

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

@@ -0,0 +1,39 @@
+# Build and test the python package
+name: Python build and test
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Check out from Git
+      uses: actions/checkout@v3
+    - name: Get history and tags for SCM versioning to work
+      run: |
+        git fetch --prune --unshallow
+        git fetch --depth=1 origin +refs/tags/*:refs/tags/*      
+    - name: Set up Python 3.10
+      uses: actions/setup-python@v3
+      with:
+        python-version: "3.10"
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        python -m pip install ".[build,test,development,documentation]"
+    - name: Test with pytest
+      run: |
+        pytest
+    - name: Build
+      run: |
+        inv build
+        inv build.mkdocs

.github/workflows/python-publish.yml

@@ -0,0 +1,37 @@
+name: Upload Python Package
+
+on:
+  release:
+    types: [published]
+    
+permissions:
+  contents: read
+
+jobs:
+  deploy:
+    name: Build and publish Python 🐍 distributions 📦 to PyPI and TestPyPI
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Check out from Git
+      uses: actions/checkout@v3
+    - name: Get history and tags for SCM versioning to work
+      run: |
+        git fetch --prune --unshallow
+        git fetch --depth=1 origin +refs/tags/*:refs/tags/*
+    - name: Set up Python
+      uses: actions/setup-python@v3
+      with:
+        python-version: '3.10'
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        python -m pip install build
+    - name: Build package
+      run: python -m build
+    - name: Publish package to PyPI
+      if: github.event_name == 'release' && startsWith(github.ref, 'refs/tags')
+      uses: pypa/gh-action-pypi-publish@release/v1
+      with:
+        user: __token__
+        password: ${{ secrets.PYPI_API_TOKEN }}

.gitignore

@@ -0,0 +1,11 @@
+.eggs/
+build/
+dist/
+*.egg-info/
+*~
+bumble/__pycache__
+docs/mkdocs/site
+tests/__pycache__
+test-results.xml
+bumble/transport/__pycache__
+bumble/profiles/__pycache__

CONTRIBUTING.md

@@ -0,0 +1,29 @@
+# How to Contribute
+
+We'd love to accept your patches and contributions to this project. There are
+just a few small guidelines you need to follow.
+
+## Contributor License Agreement
+
+Contributions to this project must be accompanied by a Contributor License
+Agreement (CLA). You (or your employer) retain the copyright to your
+contribution; this simply gives us permission to use and redistribute your
+contributions as part of the project. Head over to
+<https://cla.developers.google.com/> to see your current agreements on file or
+to sign a new one.
+
+You generally only need to submit a CLA once, so if you've already submitted one
+(even if it was for a different project), you probably don't need to do it
+again.
+
+## Code Reviews
+
+All submissions, including submissions by project members, require review. We
+use GitHub pull requests for this purpose. Consult
+[GitHub Help](https://help.github.com/articles/about-pull-requests/) for more
+information on using pull requests.
+
+## Community Guidelines
+
+This project follows
+[Google's Open Source Community Guidelines](https://opensource.google/conduct/).

LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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
+
+       http://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.

README.md

@@ -0,0 +1,65 @@
+
+     _                 _     _
+    | |               | |   | |
+    | |__  _   _ ____ | |__ | | _____
+    |  _ \| | | |    \|  _ \| || ___ |
+    | |_) ) |_| | | | | |_) ) || ____|
+    |____/|____/|_|_|_|____/ \_)_____)
+
+Bluetooth Stack for Apps, Emulation, Test and Experimentation
+=============================================================
+
+<img src="docs/mkdocs/src/images/logo_framed.png" alt="Logo" width="200" height="200"/>
+
+Bumble is a full-featured Bluetooth stack written entirely in Python. It supports most of the common Bluetooth Low Energy (BLE) and Bluetooth Classic (BR/EDR) protocols and profiles, including GAP, L2CAP, ATT, GATT, SMP, SDP, RFCOMM, HFP, HID and A2DP. The stack can be used with physical radios via HCI over USB, UART, or the Linux VHCI, as well as virtual radios, including the virtual Bluetooth support of the Android emulator.
+
+## Documentation
+
+Browse the pre-built [Online Documentation](https://google.github.io/bumble/), 
+or see the documentation source under `docs/mkdocs/src`, or build the static HTML site from the markdown text with:
+```
+mkdocs build -f docs/mkdocs/mkdocs.yml 
+```
+
+## Usage
+
+### Getting Started
+
+For a quick start to using Bumble, see the [Getting Started](docs/mkdocs/src/getting_started.md) guide.
+
+### Dependencies
+
+To install package dependencies needed to run the bumble examples execute the following commands:
+
+```
+python -m pip install --upgrade pip
+python -m pip install ".[test,development,documentation]"
+```
+
+### Examples
+
+Refer to the [Examples Documentation](examples/README.md) for details on the included example scripts and how to run them.
+
+The complete [list of Examples](/docs/mkdocs/src/examples/index.md), and what they are designed to do is here.
+
+There are also a set of [Apps and Tools](docs/mkdocs/src/apps_and_tools/index.md) that show the utility of Bumble.
+
+### Using Bumble With a USB Dongle
+
+Bumble is easiest to use with a dedicated USB dongle.
+This is because internal Bluetooth interfaces tend to be locked down by the operating system.
+You can use the [usb_probe](/docs/mkdocs/src/apps_and_tools/usb_probe.md) tool (all platforms) or `lsusb` (Linux or macOS) to list the available USB devices on your system.
+
+See the [USB Transport](/docs/mkdocs/src/transports/usb.md) page for details on how to refer to USB devices.
+
+## License
+
+Licensed under the [Apache 2.0](LICENSE) License.
+
+## Disclaimer
+
+This is not an official Google product.
+
+This library is in alpha and will be going through a lot of breaking changes. While releases will be stable enough for prototyping, experimentation and research, we do not recommend using it in any production environment yet.
+Expect bugs and sharp edges.
+Please help by trying it out, reporting bugs, and letting us know what you think!

apps/README.md

@@ -0,0 +1,51 @@
+Bumble Apps
+===========
+
+NOTE:
+To run python scripts from this directory when the Bumble package isn't installed in your environment,
+put .. in your PYTHONPATH: `export PYTHONPATH=..`
+
+
+Apps
+----
+
+## `show.py`
+Parse a file with HCI packets and print the details of each packet in a human readable form
+
+## `link_relay.py`
+Simple WebSocket relay for virtual RemoteLink instances to communicate with each other through.
+
+## `hci_bridge.py`
+This app acts as a simple bridge between two HCI transports, with a host on one side and
+a controller on the other. All the HCI packets bridged between the two are printed on the console
+for logging. This bridge also has the ability to short-circuit some HCI packets (respond to them
+with a fixed response instead of bridging them to the other side), which may be useful when used with
+a host that send custom HCI commands that the controller may not understand.
+
+### Usage
+```
+python hci_bridge.py <host-transport-spec> <controller-transport-spec> [command-short-circuit-list]
+```
+
+### Examples
+
+#### UDP to HCI UART
+```
+python hci_bridge.py udp:0.0.0.0:9000,127.0.0.1:9001 serial:/dev/tty.usbmodem0006839912171,1000000 0x3f:0x0070,0x3f:0x0074,0x3f:0x0077,0x3f:0x0078
+```
+
+#### PTY to Link Relay
+```
+python hci_bridge.py serial:emulated_uart_pty,1000000 link-relay:ws://127.0.0.1:10723/test
+```
+
+In this example, an emulator that exposes a PTY as an interface to its HCI UART is running as
+a Bluetooth host, and we are connecting it to a virtual controller attached to a link relay
+(through which the communication with other virtual controllers will be mediated).
+
+NOTE: this assumes you're running a Link Relay on port `10723`.
+
+## `console.py`
+A simple text-based-ui interactive Bluetooth device with GATT client capabilities.
+
+

apps/console.py

@@ -0,0 +1,669 @@
+# Copyright 2021-2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# Bumble Tool
+# -----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import asyncio
+from bumble.hci import HCI_Constant
+import os
+import os.path
+import logging
+import click
+from collections import OrderedDict
+import colors
+
+from bumble.core import UUID, AdvertisingData
+from bumble.device import Device, Connection, Peer
+from bumble.utils import AsyncRunner
+from bumble.transport import open_transport_or_link
+from bumble.gatt import Characteristic
+
+from prompt_toolkit import Application
+from prompt_toolkit.history import FileHistory
+from prompt_toolkit.completion import Completer, Completion, NestedCompleter
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.formatted_text import ANSI
+from prompt_toolkit.styles import Style
+from prompt_toolkit.filters import Condition
+from prompt_toolkit.widgets import TextArea, Frame
+from prompt_toolkit.widgets.toolbars import FormattedTextToolbar
+from prompt_toolkit.layout import (
+    Layout,
+    HSplit,
+    Window,
+    CompletionsMenu,
+    Float,
+    FormattedTextControl,
+    FloatContainer,
+    ConditionalContainer
+)
+
+# -----------------------------------------------------------------------------
+# Constants
+# -----------------------------------------------------------------------------
+BUMBLE_USER_DIR        = os.path.expanduser('~/.bumble')
+DEFAULT_PROMPT_HEIGHT  = 20
+DEFAULT_RSSI_BAR_WIDTH = 20
+DISPLAY_MIN_RSSI       = -100
+DISPLAY_MAX_RSSI       = -30
+
+# -----------------------------------------------------------------------------
+# Globals
+# -----------------------------------------------------------------------------
+App = None
+
+
+# -----------------------------------------------------------------------------
+# Console App
+# -----------------------------------------------------------------------------
+class ConsoleApp:
+    def __init__(self):
+        self.known_addresses = set()
+        self.known_attributes = []
+        self.device = None
+        self.connected_peer = None
+        self.top_tab = 'scan'
+
+        style = Style.from_dict({
+            'output-field': 'bg:#000044 #ffffff',
+            'input-field':  'bg:#000000 #ffffff',
+            'line':         '#004400',
+            'error':        'fg:ansired'
+        })
+
+        class LiveCompleter(Completer):
+            def __init__(self, words):
+                self.words = words
+
+            def get_completions(self, document, complete_event):
+                prefix = document.text_before_cursor.upper()
+                for word in [x for x in self.words if x.upper().startswith(prefix)]:
+                    yield Completion(word, start_position=-len(prefix))
+
+        def make_completer():
+            return NestedCompleter.from_nested_dict({
+                'scan': {
+                    'on': None,
+                    'off': None
+                },
+                'advertise': {
+                    'on': None,
+                    'off': None
+                },
+                'show': {
+                    'scan': None,
+                    'services': None,
+                    'attributes': None,
+                    'log': None
+                },
+                'connect': LiveCompleter(self.known_addresses),
+                'update-parameters': None,
+                'encrypt': None,
+                'disconnect': None,
+                'discover': {
+                    'services': None,
+                    'attributes': None
+                },
+                'read': LiveCompleter(self.known_attributes),
+                'write': LiveCompleter(self.known_attributes),
+                'subscribe': LiveCompleter(self.known_attributes),
+                'unsubscribe': LiveCompleter(self.known_attributes),
+                'quit': None,
+                'exit': None
+            })
+
+        self.input_field = TextArea(
+            height=1,
+            prompt="> ",
+            multiline=False,
+            wrap_lines=False,
+            completer=make_completer(),
+            history=FileHistory(os.path.join(BUMBLE_USER_DIR, 'history'))
+        )
+
+        self.input_field.accept_handler = self.accept_input
+
+        self.output_height = 7
+        self.output_lines = []
+        self.output = FormattedTextControl()
+        self.scan_results_text = FormattedTextControl()
+        self.services_text = FormattedTextControl()
+        self.attributes_text = FormattedTextControl()
+        self.log_text = FormattedTextControl()
+        self.log_height = 20
+        self.log_lines = []
+
+        container = HSplit([
+            ConditionalContainer(
+                Frame(Window(self.scan_results_text), title='Scan Results'),
+                filter=Condition(lambda: self.top_tab == 'scan')
+            ),
+            ConditionalContainer(
+                Frame(Window(self.services_text), title='Services'),
+                filter=Condition(lambda: self.top_tab == 'services')
+            ),
+            ConditionalContainer(
+                Frame(Window(self.attributes_text), title='Attributes'),
+                filter=Condition(lambda: self.top_tab == 'attributes')
+            ),
+            ConditionalContainer(
+                Frame(Window(self.log_text), title='Log'),
+                filter=Condition(lambda: self.top_tab == 'log')
+            ),
+            Frame(Window(self.output), height=self.output_height),
+            # HorizontalLine(),
+            FormattedTextToolbar(text=self.get_status_bar_text, style='reverse'),
+            self.input_field
+        ])
+
+        container = FloatContainer(
+            container,
+            floats=[
+                Float(
+                    xcursor=True,
+                    ycursor=True,
+                    content=CompletionsMenu(max_height=16, scroll_offset=1),
+                ),
+            ],
+        )
+
+        layout = Layout(container, focused_element=self.input_field)
+
+        kb = KeyBindings()
+        @kb.add("c-c")
+        @kb.add("c-q")
+        def _(event):
+            event.app.exit()
+
+        self.ui = Application(
+            layout=layout,
+            style=style,
+            key_bindings=kb,
+            full_screen=True
+        )
+
+    async def run_async(self, device_config, transport):
+        async with await open_transport_or_link(transport) as (hci_source, hci_sink):
+            if device_config:
+                self.device = Device.from_config_file_with_hci(device_config, hci_source, hci_sink)
+            else:
+                self.device = Device.with_hci('Bumble', 'F0:F1:F2:F3:F4:F5', hci_source, hci_sink)
+            self.device.listener = DeviceListener(self)
+            await self.device.power_on()
+
+            # Run the UI
+            await self.ui.run_async()
+
+    def add_known_address(self, address):
+        self.known_addresses.add(address)
+
+    def accept_input(self, buff):
+        if len(self.input_field.text) == 0:
+            return
+        self.append_to_output([('', '* '), ('ansicyan', self.input_field.text)], False)
+        self.ui.create_background_task(self.command(self.input_field.text))
+
+    def get_status_bar_text(self):
+        scanning = "ON" if self.device and self.device.is_scanning else "OFF"
+
+        connection_state = 'NONE'
+        encryption_state = ''
+
+        if self.device:
+            if self.device.is_connecting:
+                connection_state = 'CONNECTING'
+            elif self.connected_peer:
+                connection = self.connected_peer.connection
+                connection_parameters = f'{connection.parameters.connection_interval}/{connection.parameters.connection_latency}/{connection.parameters.supervision_timeout}'
+                connection_state = f'{connection.peer_address} {connection_parameters} {connection.data_length}'
+                encryption_state = 'ENCRYPTED' if connection.is_encrypted else 'NOT ENCRYPTED'
+
+        return [
+            ('ansigreen', f' SCAN: {scanning} '),
+            ('', '  '),
+            ('ansiblue', f' CONNECTION: {connection_state} '),
+            ('', '  '),
+            ('ansimagenta', f' {encryption_state} ')
+        ]
+
+    def show_error(self, title, details = None):
+        appended = [('class:error', title)]
+        if details:
+            appended.append(('', f' {details}'))
+        self.append_to_output(appended)
+
+    def show_scan_results(self, scan_results):
+        max_lines = 40  # TEMP
+        lines = []
+        keys = list(scan_results.keys())[:max_lines]
+        for key in keys:
+            lines.append(scan_results[key].to_display_string())
+        self.scan_results_text.text = ANSI('\n'.join(lines))
+        self.ui.invalidate()
+
+    def show_services(self, services):
+        lines = []
+        del self.known_attributes[:]
+        for service in services:
+            lines.append(('ansicyan', str(service) + '\n'))
+
+            for characteristic in service.characteristics:
+                lines.append(('ansimagenta', '  ' + str(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'))
+
+        self.services_text.text = lines
+        self.ui.invalidate()
+
+    async def show_attributes(self, attributes):
+        lines = []
+
+        for attribute in attributes:
+            lines.append(('ansicyan', f'{attribute}\n'))
+
+        self.attributes_text.text = lines
+        self.ui.invalidate()
+
+    def append_to_output(self, line, invalidate=True):
+        if type(line) is str:
+            line = [('', line)]
+        self.output_lines = self.output_lines[-(self.output_height - 3):]
+        self.output_lines.append(line)
+        formatted_text = []
+        for line in self.output_lines:
+            formatted_text += line
+            formatted_text.append(('', '\n'))
+        self.output.text = formatted_text
+        if invalidate:
+            self.ui.invalidate()
+
+    def append_to_log(self, lines, invalidate=True):
+        self.log_lines.extend(lines.split('\n'))
+        self.log_lines = self.log_lines[-(self.log_height - 3):]
+        self.log_text.text = ANSI('\n'.join(self.log_lines))
+        if invalidate:
+            self.ui.invalidate()
+
+    async def discover_services(self):
+        if not self.connected_peer:
+            self.show_error('not connected')
+            return
+
+        # Discover all services, characteristics and descriptors
+        self.append_to_output('discovering services...')
+        await self.connected_peer.discover_services()
+        self.append_to_output(f'found {len(self.connected_peer.services)} services, discovering charateristics...')
+        await self.connected_peer.discover_characteristics()
+        self.append_to_output('found characteristics, discovering descriptors...')
+        for service in self.connected_peer.services:
+            for characteristic in service.characteristics:
+                await self.connected_peer.discover_descriptors(characteristic)
+        self.append_to_output('discovery completed')
+
+        self.show_services(self.connected_peer.services)
+
+    async def discover_attributes(self):
+        if not self.connected_peer:
+            self.show_error('not connected')
+            return
+
+        # Discover all attributes
+        self.append_to_output('discovering attributes...')
+        attributes = await self.connected_peer.discover_attributes()
+        self.append_to_output(f'discovered {len(attributes)} attributes...')
+
+        await self.show_attributes(attributes)
+
+    def find_characteristic(self, param):
+        parts = param.split('.')
+        if len(parts) == 2:
+            service_uuid = UUID(parts[0]) if parts[0] != '*' else None
+            characteristic_uuid = UUID(parts[1])
+            for service in self.connected_peer.services:
+                if service_uuid is None or service.uuid == service_uuid:
+                    for characteristic in service.characteristics:
+                        if characteristic.uuid == characteristic_uuid:
+                            return characteristic
+        elif len(parts) == 1:
+            if parts[0].startswith('#'):
+                attribute_handle = int(f'{parts[0][1:]}', 16)
+                for service in self.connected_peer.services:
+                    for characteristic in service.characteristics:
+                        if characteristic.handle == attribute_handle:
+                            return characteristic
+
+    async def command(self, command):
+        try:
+            (keyword, *params) = command.strip().split(' ')
+            keyword = keyword.replace('-', '_').lower()
+            handler = getattr(self, f'do_{keyword}', None)
+            if handler:
+                await handler(params)
+                self.ui.invalidate()
+            else:
+                self.show_error('unknown command', keyword)
+        except Exception as error:
+            self.show_error(str(error))
+
+    async def do_scan(self, params):
+        if len(params) == 0:
+            # Toggle scanning
+            if self.device.is_scanning:
+                await self.device.stop_scanning()
+            else:
+                await self.device.start_scanning()
+        elif params[0] == 'on':
+            await self.device.start_scanning()
+            self.top_tab = 'scan'
+        elif params[0] == 'off':
+            await self.device.stop_scanning()
+        else:
+            self.show_error('unsupported arguments for scan command')
+
+    async def do_connect(self, params):
+        if len(params) != 1:
+            self.show_error('invalid syntax', 'expected connect <address>')
+            return
+
+        self.append_to_output('connecting...')
+        await self.device.connect(params[0])
+        self.top_tab = 'services'
+
+    async def do_disconnect(self, params):
+        if not self.connected_peer:
+            self.show_error('not connected')
+            return
+
+        await self.connected_peer.connection.disconnect()
+
+    async def do_update_parameters(self, params):
+        if len(params) != 1 or len(params[0].split('/')) != 3:
+            self.show_error('invalid syntax', 'expected update-parameters <interval-min>-<interval-max>/<latency>/<supervision>')
+            return
+
+        if not self.connected_peer:
+            self.show_error('not connected')
+            return
+
+        connection_intervals, connection_latency, supervision_timeout = params[0].split('/')
+        connection_interval_min, connection_interval_max = [int(x) for x in connection_intervals.split('-')]
+        connection_latency = int(connection_latency)
+        supervision_timeout = int(supervision_timeout)
+        await self.connected_peer.connection.update_parameters(
+            connection_interval_min,
+            connection_interval_max,
+            connection_latency,
+            supervision_timeout
+        )
+
+    async def do_encrypt(self, params):
+        if not self.connected_peer:
+            self.show_error('not connected')
+            return
+
+        await self.connected_peer.connection.encrypt()
+
+    async def do_advertise(self, params):
+        if len(params) == 0:
+            # Toggle advertising
+            if self.device.is_advertising:
+                await self.device.stop_advertising()
+            else:
+                await self.device.start_advertising()
+        elif params[0] == 'on':
+            await self.device.start_advertising()
+        elif params[0] == 'off':
+            await self.device.stop_advertising()
+        else:
+            self.show_error('unsupported arguments for advertise command')
+
+    async def do_show(self, params):
+        if params:
+            if params[0] in {'scan', 'services', 'attributes', 'log'}:
+                self.top_tab = params[0]
+                self.ui.invalidate()
+
+    async def do_discover(self, params):
+        if not params:
+            self.show_error('invalid syntax', 'expected discover services|attributes')
+            return
+
+        discovery_type = params[0]
+        if discovery_type == 'services':
+            await self.discover_services()
+        elif discovery_type == 'attributes':
+            await self.discover_attributes()
+
+    async def do_read(self, params):
+        if not self.connected_peer:
+            self.show_error('not connected')
+            return
+
+        if len(params) != 1:
+            self.show_error('invalid syntax', 'expected read <attribute>')
+            return
+
+        characteristic = self.find_characteristic(params[0])
+        if characteristic is None:
+            self.show_error('no such characteristic')
+            return
+
+        value = await characteristic.read_value()
+        self.append_to_output(f'VALUE: 0x{value.hex()}')
+
+    async def do_write(self, params):
+        if not self.connected_peer:
+            self.show_error('not connected')
+            return
+
+        if len(params) != 2:
+            self.show_error('invalid syntax', 'expected write <attribute> <value>')
+            return
+
+        if params[1].upper().startswith("0X"):
+            value = bytes.fromhex(params[1][2:])  # parse as hex string
+        else:
+            try:
+                value = int(params[1])  # try as integer
+            except ValueError:
+                value = str.encode(params[1])  # must be a string
+
+        characteristic = self.find_characteristic(params[0])
+        if characteristic is None:
+            self.show_error('no such characteristic')
+            return
+
+        # use write with response if supported
+        with_response = characteristic.properties & Characteristic.WRITE
+        await characteristic.write_value(value, with_response=with_response)
+
+    async def do_subscribe(self, params):
+        if not self.connected_peer:
+            self.show_error('not connected')
+            return
+
+        if len(params) != 1:
+            self.show_error('invalid syntax', 'expected subscribe <attribute>')
+            return
+
+        characteristic = self.find_characteristic(params[0])
+        if characteristic is None:
+            self.show_error('no such characteristic')
+            return
+
+        await characteristic.subscribe(
+            lambda value: self.append_to_output(f"{characteristic} VALUE: 0x{value.hex()}"),
+        )
+
+    async def do_unsubscribe(self, params):
+        if not self.connected_peer:
+            self.show_error('not connected')
+            return
+
+        if len(params) != 1:
+            self.show_error('invalid syntax', 'expected subscribe <attribute>')
+            return
+
+        characteristic = self.find_characteristic(params[0])
+        if characteristic is None:
+            self.show_error('no such characteristic')
+            return
+
+        await characteristic.unsubscribe()
+
+    async def do_exit(self, params):
+        self.ui.exit()
+
+    async def do_quit(self, params):
+        self.ui.exit()
+
+
+# -----------------------------------------------------------------------------
+# Device and Connection Listener
+# -----------------------------------------------------------------------------
+class DeviceListener(Device.Listener, Connection.Listener):
+    def __init__(self, app):
+        self.app = app
+        self.scan_results = OrderedDict()
+
+    @AsyncRunner.run_in_task()
+    async def on_connection(self, connection):
+        self.app.connected_peer = Peer(connection)
+        self.app.append_to_output(f'connected to {self.app.connected_peer}')
+        connection.listener = self
+
+    def on_disconnection(self, reason):
+        self.app.append_to_output(f'disconnected from {self.app.connected_peer}, reason: {HCI_Constant.error_name(reason)}')
+        self.app.connected_peer = None
+
+    def on_connection_parameters_update(self):
+        self.app.append_to_output(f'connection parameters update: {self.app.connected_peer.connection.parameters}')
+
+    def on_connection_phy_update(self):
+        self.app.append_to_output(f'connection phy update: {self.app.connected_peer.connection.phy}')
+
+    def on_connection_att_mtu_update(self):
+        self.app.append_to_output(f'connection att mtu update: {self.app.connected_peer.connection.att_mtu}')
+
+    def on_connection_encryption_change(self):
+        self.app.append_to_output(f'connection encryption change: {"encrypted" if self.app.connected_peer.connection.is_encrypted else "not encrypted"}')
+
+    def on_connection_data_length_change(self):
+        self.app.append_to_output(f'connection data length change: {self.app.connected_peer.connection.data_length}')
+
+    def on_advertisement(self, address, ad_data, rssi, connectable):
+        entry_key = f'{address}/{address.address_type}'
+        entry = self.scan_results.get(entry_key)
+        if entry:
+            entry.ad_data     = ad_data
+            entry.rssi        = rssi
+            entry.connectable = connectable
+        else:
+            self.app.add_known_address(str(address))
+            self.scan_results[entry_key] = ScanResult(address, address.address_type, ad_data, rssi, connectable)
+
+        self.app.show_scan_results(self.scan_results)
+
+
+# -----------------------------------------------------------------------------
+# Scanning
+# -----------------------------------------------------------------------------
+class ScanResult:
+    def __init__(self, address, address_type, ad_data, rssi, connectable):
+        self.address      = address
+        self.address_type = address_type
+        self.ad_data      = ad_data
+        self.rssi         = rssi
+        self.connectable  = connectable
+
+    def to_display_string(self):
+        address_type_string = ('P', 'R', 'PI', 'RI')[self.address_type]
+        address_color = colors.yellow if self.connectable else colors.red
+        if address_type_string.startswith('P'):
+            type_color = colors.green
+        else:
+            type_color = colors.cyan
+
+        name = self.ad_data.get(AdvertisingData.COMPLETE_LOCAL_NAME)
+        if name is None:
+            name = self.ad_data.get(AdvertisingData.SHORTENED_LOCAL_NAME)
+        if name:
+            # Convert to string
+            try:
+                name = name.decode()
+            except UnicodeDecodeError:
+                name = name.hex()
+        else:
+            name = ''
+
+        # RSSI bar
+        blocks = ['', '▏', '▎', '▍', '▌', '▋', '▊', '▉']
+        bar_width = (self.rssi - DISPLAY_MIN_RSSI) / (DISPLAY_MAX_RSSI - DISPLAY_MIN_RSSI)
+        bar_width = min(max(bar_width, 0), 1)
+        bar_ticks = int(bar_width * DEFAULT_RSSI_BAR_WIDTH * 8)
+        bar_blocks = ('█' * int(bar_ticks / 8)) + blocks[bar_ticks % 8]
+        bar_string = f'{self.rssi} {bar_blocks}'
+        bar_padding = ' ' * (DEFAULT_RSSI_BAR_WIDTH + 5 - len(bar_string))
+        return f'{address_color(str(self.address))} [{type_color(address_type_string)}] {bar_string} {bar_padding} {name}'
+
+
+# -----------------------------------------------------------------------------
+# Logging
+# -----------------------------------------------------------------------------
+class LogHandler(logging.Handler):
+    def __init__(self, app):
+        super().__init__()
+        self.app = app
+
+    def emit(self, record):
+        message = self.format(record)
+        self.app.append_to_log(message)
+
+
+# -----------------------------------------------------------------------------
+# Main
+# -----------------------------------------------------------------------------
+@click.command()
+@click.option('--device-config', help='Device configuration file')
+@click.argument('transport')
+def main(device_config, transport):
+    # Ensure that the BUMBLE_USER_DIR directory exists
+    if not os.path.isdir(BUMBLE_USER_DIR):
+        os.mkdir(BUMBLE_USER_DIR)
+
+    # Create an instane of the app
+    app = ConsoleApp()
+
+    # Setup logging
+    # logging.basicConfig(level = 'FATAL')
+    # logging.basicConfig(level = 'DEBUG')
+    root_logger = logging.getLogger()
+    root_logger.addHandler(LogHandler(app))
+    root_logger.setLevel(logging.DEBUG)
+
+    # Run until the user exits
+    asyncio.run(app.run_async(device_config, transport))
+
+
+# -----------------------------------------------------------------------------
+if __name__ == "__main__":
+    main()

apps/controller_info.py

@@ -0,0 +1,105 @@
+# Copyright 2021-2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import asyncio
+import os
+import logging
+import click
+from colors import color
+from bumble.company_ids import COMPANY_IDENTIFIERS
+
+from bumble.core import name_or_number
+from bumble.hci import (
+    map_null_terminated_utf8_string,
+    HCI_LE_SUPPORTED_FEATURES_NAMES,
+    HCI_SUCCESS,
+    HCI_VERSION_NAMES,
+    LMP_VERSION_NAMES,
+    HCI_Command,
+    HCI_Read_BD_ADDR_Command,
+    HCI_READ_BD_ADDR_COMMAND,
+    HCI_Read_Local_Name_Command,
+    HCI_READ_LOCAL_NAME_COMMAND
+)
+from bumble.host import Host
+from bumble.transport import open_transport_or_link
+
+
+# -----------------------------------------------------------------------------
+async def get_classic_info(host):
+    if host.supports_command(HCI_READ_BD_ADDR_COMMAND):
+        response = await host.send_command(HCI_Read_BD_ADDR_Command())
+        if response.return_parameters.status == HCI_SUCCESS:
+            print()
+            print(color('Classic Address:', 'yellow'), response.return_parameters.bd_addr)
+
+    if host.supports_command(HCI_READ_LOCAL_NAME_COMMAND):
+        response = await host.send_command(HCI_Read_Local_Name_Command())
+        if response.return_parameters.status == HCI_SUCCESS:
+            print()
+            print(color('Local Name:', 'yellow'), map_null_terminated_utf8_string(response.return_parameters.local_name))
+
+
+# -----------------------------------------------------------------------------
+async def get_le_info(host):
+    print()
+    print(color('LE Features:', 'yellow'))
+    for feature in host.supported_le_features:
+        print('  ', name_or_number(HCI_LE_SUPPORTED_FEATURES_NAMES, feature))
+
+
+# -----------------------------------------------------------------------------
+async def async_main(transport):
+    print('<<< connecting to HCI...')
+    async with await open_transport_or_link(transport) as (hci_source, hci_sink):
+        print('<<< connected')
+
+        host = Host(hci_source, hci_sink)
+        await host.reset()
+
+        # Print version
+        print(color('Version:', 'yellow'))
+        print(color('  Manufacturer:  ', 'green'), name_or_number(COMPANY_IDENTIFIERS, host.local_version.company_identifier))
+        print(color('  HCI Version:   ', 'green'), name_or_number(HCI_VERSION_NAMES, host.local_version.hci_version))
+        print(color('  HCI Subversion:', 'green'), host.local_version.hci_subversion)
+        print(color('  LMP Version:   ', 'green'), name_or_number(LMP_VERSION_NAMES, host.local_version.lmp_version))
+        print(color('  LMP Subversion:', 'green'), host.local_version.lmp_subversion)
+
+        # Get the Classic info
+        await get_classic_info(host)
+
+        # Get the LE info
+        await get_le_info(host)
+
+        # Print the list of commands supported by the controller
+        print()
+        print(color('Supported Commands:', 'yellow'))
+        for command in host.supported_commands:
+            print('  ', HCI_Command.command_name(command))
+
+
+# -----------------------------------------------------------------------------
+@click.command()
+@click.argument('transport')
+def main(transport):
+    logging.basicConfig(level = os.environ.get('BUMBLE_LOGLEVEL', 'WARNING').upper())
+    asyncio.run(async_main(transport))
+
+
+# -----------------------------------------------------------------------------
+if __name__ == '__main__':
+    main()

apps/controllers.py

@@ -0,0 +1,63 @@
+# Copyright 2021-2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import logging
+import asyncio
+import sys
+import os
+
+from bumble.controller import Controller
+from bumble.link import LocalLink
+from bumble.transport import open_transport_or_link
+
+
+# -----------------------------------------------------------------------------
+async def async_main():
+    if len(sys.argv) != 3:
+        print('Usage: controllers.py <hci-transport-1> <hci-transport-2> [<hci-transport-3> ...]')
+        print('example: python controllers.py pty:ble1 pty:ble2')
+        return
+
+    # Create a loccal link to attach the controllers to
+    link = LocalLink()
+
+    # Create a transport and controller for all requested names
+    transports = []
+    controllers = []
+    for index, transport_name in enumerate(sys.argv[1:]):
+        transport = await open_transport_or_link(transport_name)
+        transports.append(transport)
+        controller = Controller(f'C{index}', host_source = transport.source, host_sink = transport.sink, link = link)
+        controllers.append(controller)
+
+    # Wait until the user interrupts
+    await asyncio.get_running_loop().create_future()
+
+    # Cleanup
+    for transport in transports:
+        transport.close()
+
+
+# -----------------------------------------------------------------------------
+def main():
+    logging.basicConfig(level = os.environ.get('BUMBLE_LOGLEVEL', 'INFO').upper())
+    asyncio.run(async_main())
+
+
+# -----------------------------------------------------------------------------
+if __name__ == '__main__':
+    main()

apps/gatt_dump.py

@@ -0,0 +1,108 @@
+# Copyright 2021-2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import asyncio
+import os
+import logging
+import click
+from colors import color
+
+from bumble.core import ProtocolError, TimeoutError
+from bumble.device import Device, Peer
+from bumble.gatt import show_services
+from bumble.transport import open_transport_or_link
+
+
+# -----------------------------------------------------------------------------
+async def dump_gatt_db(peer, done):
+    # Discover all services
+    print(color('### Discovering Services and Characteristics', 'magenta'))
+    await peer.discover_services()
+    for service in peer.services:
+        await service.discover_characteristics()
+        for characteristic in service.characteristics:
+            await characteristic.discover_descriptors()
+
+    print(color('=== Services ===', 'yellow'))
+    show_services(peer.services)
+    print()
+
+    # Discover all attributes
+    print(color('=== All Attributes ===', 'yellow'))
+    attributes = await peer.discover_attributes()
+    for attribute in attributes:
+        print(attribute)
+        try:
+            value = await attribute.read_value()
+            print(color(f'{value.hex()}', 'green'))
+        except ProtocolError as error:
+            print(color(error, 'red'))
+        except TimeoutError:
+            print(color('read timeout', 'red'))
+
+    if done is not None:
+        done.set_result(None)
+
+
+# -----------------------------------------------------------------------------
+async def async_main(device_config, encrypt, transport, address_or_name):
+    async with await open_transport_or_link(transport) as (hci_source, hci_sink):
+
+        # Create a device
+        if device_config:
+            device = Device.from_config_file_with_hci(device_config, hci_source, hci_sink)
+        else:
+            device = Device.with_hci('Bumble', 'F0:F1:F2:F3:F4:F5', hci_source, hci_sink)
+        await device.power_on()
+
+        if address_or_name:
+            # Connect to the target peer
+            connection = await device.connect(address_or_name)
+
+            # Encrypt the connection if required
+            if encrypt:
+                await connection.encrypt()
+
+            await dump_gatt_db(Peer(connection), None)
+        else:
+            # Wait for a connection
+            done = asyncio.get_running_loop().create_future()
+            device.on('connection', lambda connection: asyncio.create_task(dump_gatt_db(Peer(connection), done)))
+            await device.start_advertising(auto_restart=True)
+
+            print(color('### Waiting for connection...', 'blue'))
+            await done
+
+
+# -----------------------------------------------------------------------------
+@click.command()
+@click.option('--device-config', help='Device configuration', type=click.Path())
+@click.option('--encrypt', help='Encrypt the connection', is_flag=True, default=False)
+@click.argument('transport')
+@click.argument('address-or-name', required=False)
+def main(device_config, encrypt, transport, address_or_name):
+    """
+    Dump the GATT database on a remote device. If ADDRESS_OR_NAME is not specified,
+    wait for an incoming connection.
+    """
+    logging.basicConfig(level = os.environ.get('BUMBLE_LOGLEVEL', 'INFO').upper())
+    asyncio.run(async_main(device_config, encrypt, transport, address_or_name))
+
+
+# -----------------------------------------------------------------------------
+if __name__ == '__main__':
+    main()

apps/gg_bridge.py

@@ -0,0 +1,211 @@
+# Copyright 2021-2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import asyncio
+import os
+import logging
+import click
+from colors import color
+
+from bumble.device import Device, Peer
+from bumble.core import AdvertisingData
+from bumble.gatt import Service, Characteristic
+from bumble.utils import AsyncRunner
+from bumble.transport import open_transport_or_link
+from bumble.hci import HCI_Constant
+
+
+# -----------------------------------------------------------------------------
+# Constants
+# -----------------------------------------------------------------------------
+GG_GATTLINK_SERVICE_UUID                          = 'ABBAFF00-E56A-484C-B832-8B17CF6CBFE8'
+GG_GATTLINK_RX_CHARACTERISTIC_UUID                = 'ABBAFF01-E56A-484C-B832-8B17CF6CBFE8'
+GG_GATTLINK_TX_CHARACTERISTIC_UUID                = 'ABBAFF02-E56A-484C-B832-8B17CF6CBFE8'
+GG_GATTLINK_L2CAP_CHANNEL_PSM_CHARACTERISTIC_UUID = 'ABBAFF03-E56A-484C-B832-8B17CF6CBFE8'
+
+GG_PREFERRED_MTU = 256
+
+
+# -----------------------------------------------------------------------------
+class GattlinkHubBridge(Device.Listener):
+    def __init__(self):
+        self.peer              = None
+        self.rx_socket         = None
+        self.tx_socket         = None
+        self.rx_characteristic = None
+        self.tx_characteristic = None
+
+    @AsyncRunner.run_in_task()
+    async def on_connection(self, connection):
+        print(f'=== Connected to {connection}')
+        self.peer = Peer(connection)
+
+        # Request a larger MTU than the default
+        server_mtu = await self.peer.request_mtu(GG_PREFERRED_MTU)
+        print(f'### Server MTU = {server_mtu}')
+
+        # Discover all services
+        print(color('=== Discovering services', 'yellow'))
+        await self.peer.discover_service(GG_GATTLINK_SERVICE_UUID)
+        print(color('=== Services discovered', 'yellow'), self.peer.services)
+        for service in self.peer.services:
+            print(service)
+        services = self.peer.get_services_by_uuid(GG_GATTLINK_SERVICE_UUID)
+        if not services:
+            print(color('!!! Gattlink service not found', 'red'))
+            return
+
+        # Use the first Gattlink (there should only be one anyway)
+        gattlink_service = services[0]
+
+        # Discover all the characteristics for the service
+        characteristics = await gattlink_service.discover_characteristics()
+        print(color('=== Characteristics discovered', 'yellow'))
+        for characteristic in characteristics:
+            if characteristic.uuid == GG_GATTLINK_RX_CHARACTERISTIC_UUID:
+                self.rx_characteristic = characteristic
+            elif characteristic.uuid == GG_GATTLINK_TX_CHARACTERISTIC_UUID:
+                self.tx_characteristic = characteristic
+        print('RX:', self.rx_characteristic)
+        print('TX:', self.tx_characteristic)
+
+        # Subscribe to TX
+        if self.tx_characteristic:
+            await self.peer.subscribe(self.tx_characteristic, self.on_tx_received)
+            print(color('=== Subscribed to Gattlink TX', 'yellow'))
+        else:
+            print(color('!!! Gattlink TX not found', 'red'))
+
+    def on_connection_failure(self, error):
+        print(color(f'!!! Connection failed: {error}'))
+
+    def on_disconnection(self, reason):
+        print(color(f'!!! Disconnected from {self.peer}, reason={HCI_Constant.error_name(reason)}', 'red'))
+        self.tx_characteristic = None
+        self.rx_characteristic = None
+        self.peer = None
+
+    # Called by the GATT client when a notification is received
+    def on_tx_received(self, value):
+        print(color('>>> TX:', 'magenta'), value.hex())
+        if self.tx_socket:
+            self.tx_socket.sendto(value)
+
+    # Called by asyncio when the UDP socket is created
+    def connection_made(self, transport):
+        pass
+
+    # Called by asyncio when a UDP datagram is received
+    def datagram_received(self, data, address):
+        print(color('<<< RX:', 'magenta'), data.hex())
+
+        # TODO: use a queue instead of creating a task everytime
+        if self.peer and self.rx_characteristic:
+            asyncio.create_task(self.peer.write_value(self.rx_characteristic, data))
+
+
+# -----------------------------------------------------------------------------
+class GattlinkNodeBridge(Device.Listener):
+    def __init__(self):
+        self.peer      = None
+        self.rx_socket = None
+        self.tx_socket = None
+
+    # Called by asyncio when the UDP socket is created
+    def connection_made(self, transport):
+        pass
+
+    # Called by asyncio when a UDP datagram is received
+    def datagram_received(self, data, address):
+        print(color('<<< RX:', 'magenta'), data.hex())
+
+        # TODO: use a queue instead of creating a task everytime
+        if self.peer and self.rx_characteristic:
+            asyncio.create_task(self.peer.write_value(self.rx_characteristic, data))
+
+
+# -----------------------------------------------------------------------------
+async def run(hci_transport, device_address, send_host, send_port, receive_host, receive_port):
+    print('<<< connecting to HCI...')
+    async with await open_transport_or_link(hci_transport) as (hci_source, hci_sink):
+        print('<<< connected')
+
+        # Instantiate a bridge object
+        bridge = GattlinkNodeBridge()
+
+        # Create a UDP to RX bridge (receive from UDP, send to RX)
+        loop = asyncio.get_running_loop()
+        await loop.create_datagram_endpoint(
+            lambda: bridge,
+            local_addr=(receive_host, receive_port)
+        )
+
+        # Create a UDP to TX bridge (receive from TX, send to UDP)
+        bridge.tx_socket, _ = await loop.create_datagram_endpoint(
+            lambda: asyncio.DatagramProtocol(),
+            remote_addr=(send_host, send_port)
+        )
+
+        # Create a device to manage the host, with a custom listener
+        device = Device.with_hci('Bumble', 'F0:F1:F2:F3:F4:F5', hci_source, hci_sink)
+        device.listener = bridge
+        await device.power_on()
+
+        # Connect to the peer
+        # print(f'=== Connecting to {device_address}...')
+        # await device.connect(device_address)
+
+        # TODO move to class
+        gattlink_service = Service(
+            GG_GATTLINK_SERVICE_UUID,
+            [
+                Characteristic(
+                    GG_GATTLINK_L2CAP_CHANNEL_PSM_CHARACTERISTIC_UUID,
+                    Characteristic.READ,
+                    Characteristic.READABLE,
+                    bytes([193, 0])
+                )
+            ]
+        )
+        device.add_services([gattlink_service])
+        device.advertising_data = bytes(
+            AdvertisingData([
+                (AdvertisingData.COMPLETE_LOCAL_NAME, bytes('Bumble GG', 'utf-8')),
+                (AdvertisingData.INCOMPLETE_LIST_OF_128_BIT_SERVICE_CLASS_UUIDS, bytes(reversed(bytes.fromhex('ABBAFF00E56A484CB8328B17CF6CBFE8'))))
+            ])
+        )
+        await device.start_advertising()
+
+        # Wait until the source terminates
+        await hci_source.wait_for_termination()
+
+
+@click.command()
+@click.argument('hci_transport')
+@click.argument('device_address')
+@click.option('-sh', '--send-host', type=str, default='127.0.0.1', help='UDP host to send to')
+@click.option('-sp', '--send-port', type=int, default=9001, help='UDP port to send to')
+@click.option('-rh', '--receive-host', type=str, default='127.0.0.1', help='UDP host to receive on')
+@click.option('-rp', '--receive-port', type=int, default=9000, help='UDP port to receive on')
+def main(hci_transport, device_address, send_host, send_port, receive_host, receive_port):
+    logging.basicConfig(level = os.environ.get('BUMBLE_LOGLEVEL', 'INFO').upper())
+    asyncio.run(run(hci_transport, device_address, send_host, send_port, receive_host, receive_port))
+
+
+# -----------------------------------------------------------------------------
+if __name__ == '__main__':
+    main()

apps/hci_bridge.py

@@ -0,0 +1,89 @@
+# Copyright 2021-2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import logging
+import asyncio
+import os
+import sys
+
+from bumble import hci, transport
+from bumble.bridge import HCI_Bridge
+
+# -----------------------------------------------------------------------------
+# Logging
+# -----------------------------------------------------------------------------
+logger = logging.getLogger(__name__)
+
+
+# -----------------------------------------------------------------------------
+# Main
+# -----------------------------------------------------------------------------
+async def async_main():
+    if len(sys.argv) < 3:
+        print('Usage: hci_bridge.py <host-transport-spec> <controller-transport-spec> [command-short-circuit-list]')
+        print('example: python hci_bridge.py udp:0.0.0.0:9000,127.0.0.1:9001 serial:/dev/tty.usbmodem0006839912171,1000000 0x3f:0x0070,0x3f:0x0074,0x3f:0x0077,0x3f:0x0078')
+        return
+
+    print('>>> connecting to HCI...')
+    async with await transport.open_transport_or_link(sys.argv[1]) as (hci_host_source, hci_host_sink):
+        print('>>> connected')
+
+        print('>>> connecting to HCI...')
+        async with await transport.open_transport_or_link(sys.argv[2]) as (hci_controller_source, hci_controller_sink):
+            print('>>> connected')
+
+            command_short_circuits = []
+            if len(sys.argv) >= 4:
+                for op_code_str in sys.argv[3].split(','):
+                    if ':' in op_code_str:
+                        ogf, ocf = op_code_str.split(':')
+                        command_short_circuits.append(hci.hci_command_op_code(int(ogf, 16), int(ocf, 16)))
+                    else:
+                        command_short_circuits.append(int(op_code_str, 16))
+
+            def host_to_controller_filter(hci_packet):
+                if hci_packet.hci_packet_type == hci.HCI_COMMAND_PACKET and hci_packet.op_code in command_short_circuits:
+                    # Respond with a success response
+                    logger.debug('short-circuiting packet')
+                    response = hci.HCI_Command_Complete_Event(
+                        num_hci_command_packets = 1,
+                        command_opcode          = hci_packet.op_code,
+                        return_parameters       = bytes([hci.HCI_SUCCESS])
+                    )
+                    # Return a packet with 'respond to sender' set to True
+                    return (response.to_bytes(), True)
+
+            _ = HCI_Bridge(
+                hci_host_source,
+                hci_host_sink,
+                hci_controller_source,
+                hci_controller_sink,
+                host_to_controller_filter,
+                None
+            )
+            await asyncio.get_running_loop().create_future()
+
+
+# -----------------------------------------------------------------------------
+def main():
+    logging.basicConfig(level = os.environ.get('BUMBLE_LOGLEVEL', 'INFO').upper())
+    asyncio.run(async_main())
+
+
+# -----------------------------------------------------------------------------
+if __name__ == '__main__':
+    main()

apps/link_relay/link_relay.py

@@ -0,0 +1,276 @@
+# Copyright 2021-2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# ----------------------------------------------------------------------------
+# Imports
+# ----------------------------------------------------------------------------
+import sys
+import websockets
+import logging
+import json
+import asyncio
+import argparse
+import uuid
+import os
+from urllib.parse import urlparse
+from colors import color
+
+# -----------------------------------------------------------------------------
+# Logging
+# -----------------------------------------------------------------------------
+logger = logging.getLogger(__name__)
+
+
+# ----------------------------------------------------------------------------
+# Constants
+# ----------------------------------------------------------------------------
+DEFAULT_RELAY_PORT = 10723
+
+
+# ----------------------------------------------------------------------------
+# Utils
+# ----------------------------------------------------------------------------
+def error_to_json(error):
+    return json.dumps({'error': error})
+
+
+def error_to_result(error):
+    return f'result:{error_to_json(error)}'
+
+
+async def broadcast_message(message, connections):
+    # Send to all the connections
+    tasks = [connection.send_message(message) for connection in connections]
+    if tasks:
+        await asyncio.gather(*tasks)
+
+
+# ----------------------------------------------------------------------------
+# Connection class
+# ----------------------------------------------------------------------------
+class Connection:
+    """
+    A Connection represents a client connected to the relay over a websocket
+    """
+
+    def __init__(self, room, websocket):
+        self.room      = room
+        self.websocket = websocket
+        self.address   = str(uuid.uuid4())
+
+    async def send_message(self, message):
+        try:
+            logger.debug(color(f'->{self.address}: {message}', 'yellow'))
+            return await self.websocket.send(message)
+        except websockets.exceptions.WebSocketException as error:
+            logger.info(f'! client "{self}" disconnected: {error}')
+            await self.cleanup()
+
+    async def send_error(self, error):
+        return await self.send_message(f'result:{error_to_json(error)}')
+
+    async def receive_message(self):
+        try:
+            message = await self.websocket.recv()
+            logger.debug(color(f'<-{self.address}: {message}', 'blue'))
+            return message
+        except websockets.exceptions.WebSocketException as error:
+            logger.info(color(f'! client "{self}" disconnected: {error}', 'red'))
+            await self.cleanup()
+
+    async def cleanup(self):
+        if self.room:
+            await self.room.remove_connection(self)
+
+    def set_address(self, address):
+        logger.info(f'Connection address changed: {self.address} -> {address}')
+        self.address = address
+
+    def __str__(self):
+        return f'Connection(address="{self.address}", client={self.websocket.remote_address[0]}:{self.websocket.remote_address[1]})'
+
+
+# ----------------------------------------------------------------------------
+# Room class
+# ----------------------------------------------------------------------------
+class Room:
+    """
+    A Room is a collection of bridged connections
+    """
+
+    def __init__(self, relay, name):
+        self.relay       = relay
+        self.name        = name
+        self.observers   = []
+        self.connections = []
+
+    async def add_connection(self, connection):
+        logger.info(f'New participant in {self.name}: {connection}')
+        self.connections.append(connection)
+        await self.broadcast_message(connection, f'joined:{connection.address}')
+
+    async def remove_connection(self, connection):
+        if connection in self.connections:
+            self.connections.remove(connection)
+            await self.broadcast_message(connection, f'left:{connection.address}')
+
+    def find_connections_by_address(self, address):
+        return [c for c in self.connections if c.address == address]
+
+    async def bridge_connection(self, connection):
+        while True:
+            # Wait for a message
+            message = await connection.receive_message()
+
+            # Skip empty messages
+            if message is None:
+                return
+
+            # Parse the message to decide how to handle it
+            if message.startswith('@'):
+                # This is a targetted message
+                await self.on_targetted_message(connection, message)
+            elif message.startswith('/'):
+                # This is an RPC request
+                await self.on_rpc_request(connection, message)
+            else:
+                await connection.send_message(f'result:{error_to_json("error: invalid message")}')
+
+    async def broadcast_message(self, sender, message):
+        '''
+        Send to all connections in the room except back to the sender
+        '''
+        await broadcast_message(message, [c for c in self.connections if c != sender])
+
+    async def on_rpc_request(self, connection, message):
+        command, *params = message.split(' ', 1)
+        if handler := getattr(self, f'on_{command[1:].lower().replace("-","_")}_command', None):
+            try:
+                result = await handler(connection, params)
+            except Exception as error:
+                result = error_to_result(error)
+        else:
+            result = error_to_result('unknown command')
+
+        await connection.send_message(result or 'result:{}')
+
+    async def on_targetted_message(self, connection, message):
+        target, *payload = message.split(' ', 1)
+        if not payload:
+            return error_to_json('missing arguments')
+        payload = payload[0]
+        target = target[1:]
+
+        # Determine what targets to send to
+        if target == '*':
+            # Send to all connections in the room except the connection from which the message was received
+            connections = [c for c in self.connections if c != connection]
+        else:
+            connections = self.find_connections_by_address(target)
+            if not connections:
+                # Unicast with no recipient, let the sender know
+                await connection.send_message(f'unreachable:{target}')
+
+        # Send to targets
+        await broadcast_message(f'message:{connection.address}/{payload}', connections)
+
+    async def on_set_address_command(self, connection, params):
+        if not params:
+            return error_to_result('missing address')
+
+        current_address = connection.address
+        new_address = params[0]
+        connection.set_address(new_address)
+        await self.broadcast_message(connection, f'address-changed:from={current_address},to={new_address}')
+
+
+# ----------------------------------------------------------------------------
+class Relay:
+    """
+    A relay accepts connections with the following url: ws://<hostname>/<room>.
+    Participants in a room can communicate with each other
+    """
+
+    def __init__(self, port):
+        self.port = port
+        self.rooms = {}
+        self.observers = []
+
+    def start(self):
+        logger.info(f'Starting Relay on port {self.port}')
+
+        return websockets.serve(self.serve, '0.0.0.0', self.port, ping_interval=None)
+
+    async def serve_as_controller(connection):
+        pass
+
+    async def serve(self, websocket, path):
+        logger.debug(f'New connection with path {path}')
+
+        # Parse the path
+        parsed = urlparse(path)
+
+        # Check if this is a controller client
+        if parsed.path == '/':
+            return await self.serve_as_controller(Connection('', websocket))
+
+        # Find or create a room for this connection
+        room_name = parsed.path[1:].split('/')[0]
+        if room_name not in self.rooms:
+            self.rooms[room_name] = Room(self, room_name)
+        room = self.rooms[room_name]
+
+        # Add the connection to the room
+        connection = Connection(room, websocket)
+        await room.add_connection(connection)
+
+        # Bridge until the connection is closed
+        await room.bridge_connection(connection)
+
+
+# ----------------------------------------------------------------------------
+def main():
+    # Check the Python version
+    if sys.version_info < (3, 6, 1):
+        print('ERROR: Python 3.6.1 or higher is required')
+        sys.exit(1)
+
+    logging.basicConfig(level = os.environ.get('BUMBLE_LOGLEVEL', 'INFO').upper())
+
+    # Parse arguments
+    arg_parser = argparse.ArgumentParser(description='Bumble Link Relay')
+    arg_parser.add_argument('--log-level', default='INFO', help='logger level')
+    arg_parser.add_argument('--log-config', help='logger config file (YAML)')
+    arg_parser.add_argument('--port',
+                            type = int,
+                            default = DEFAULT_RELAY_PORT,
+                            help = 'Port to listen on')
+    args = arg_parser.parse_args()
+
+    # Setup logger
+    if args.log_config:
+        from logging import config
+        config.fileConfig(args.log_config)
+    else:
+        logging.basicConfig(level = getattr(logging, args.log_level.upper()))
+
+    # Start a relay
+    relay = Relay(args.port)
+    asyncio.get_event_loop().run_until_complete(relay.start())
+    asyncio.get_event_loop().run_forever()
+
+
+# ----------------------------------------------------------------------------
+if __name__ == '__main__':
+    main()

apps/link_relay/logging.yml

@@ -0,0 +1,21 @@
+[loggers]
+keys=root
+
+[handlers]
+keys=stream_handler
+
+[formatters]
+keys=formatter
+
+[logger_root]
+level=DEBUG
+handlers=stream_handler
+
+[handler_stream_handler]
+class=StreamHandler
+level=DEBUG
+formatter=formatter
+args=(sys.stderr,)
+
+[formatter_formatter]
+format=%(asctime)s %(name)-12s %(levelname)-8s %(message)s

apps/pair.py

@@ -0,0 +1,341 @@
+# Copyright 2021-2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import asyncio
+import os
+import logging
+import click
+import aioconsole
+from colors import color
+
+from bumble.device import Device, Peer
+from bumble.transport import open_transport_or_link
+from bumble.smp import PairingDelegate, PairingConfig
+from bumble.smp import error_name as smp_error_name
+from bumble.keys import JsonKeyStore
+from bumble.core import ProtocolError
+from bumble.gatt import (
+    GATT_DEVICE_NAME_CHARACTERISTIC,
+    GATT_GENERIC_ACCESS_SERVICE,
+    Service,
+    Characteristic,
+    CharacteristicValue
+)
+from bumble.att import (
+    ATT_Error,
+    ATT_INSUFFICIENT_AUTHENTICATION_ERROR,
+    ATT_INSUFFICIENT_ENCRYPTION_ERROR
+)
+
+
+# -----------------------------------------------------------------------------
+class Delegate(PairingDelegate):
+    def __init__(self, mode, connection, capability_string, prompt):
+        super().__init__({
+            'keyboard':         PairingDelegate.KEYBOARD_INPUT_ONLY,
+            'display':          PairingDelegate.DISPLAY_OUTPUT_ONLY,
+            'display+keyboard': PairingDelegate.DISPLAY_OUTPUT_AND_KEYBOARD_INPUT,
+            'display+yes/no':   PairingDelegate.DISPLAY_OUTPUT_AND_YES_NO_INPUT,
+            'none':             PairingDelegate.NO_OUTPUT_NO_INPUT
+        }[capability_string.lower()])
+
+        self.mode      = mode
+        self.peer      = Peer(connection)
+        self.peer_name = None
+        self.prompt    = prompt
+
+    async def update_peer_name(self):
+        if self.peer_name is not None:
+            # We already asked the peer
+            return
+
+        # Try to get the peer's name
+        if self.peer:
+            peer_name = await get_peer_name(self.peer, self.mode)
+            self.peer_name = f'{peer_name or ""} [{self.peer.connection.peer_address}]'
+        else:
+            self.peer_name = '[?]'
+
+    async def accept(self):
+        if self.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'))
+            while True:
+                response = await aioconsole.ainput(color('>>> Accept? ', 'yellow'))
+                response = response.lower().strip()
+                if response == 'yes':
+                    return True
+                elif response == 'no':
+                    return False
+        else:
+            # Accept silently
+            return True
+
+    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'))
+        while True:
+            response = await aioconsole.ainput(color(f'>>> Does the other device display {number:0{digits}}? ', 'yellow'))
+            response = response.lower().strip()
+            if response == 'yes':
+                return True
+            elif response == 'no':
+                return False
+
+    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')))
+            except ValueError:
+                pass
+
+    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'))
+
+
+# -----------------------------------------------------------------------------
+async def get_peer_name(peer, mode):
+    if mode == 'classic':
+        return await peer.request_name()
+    else:
+        # Try to get the peer name from GATT
+        services = await peer.discover_service(GATT_GENERIC_ACCESS_SERVICE)
+        if not services:
+            return None
+
+        values = await peer.read_characteristics_by_uuid(GATT_DEVICE_NAME_CHARACTERISTIC, services[0])
+        if values:
+            return values[0].decode('utf-8')
+
+
+# -----------------------------------------------------------------------------
+AUTHENTICATION_ERROR_RETURNED = [False, False]
+
+
+def read_with_error(connection):
+    if not connection.is_encrypted:
+        raise ATT_Error(ATT_INSUFFICIENT_ENCRYPTION_ERROR)
+
+    if AUTHENTICATION_ERROR_RETURNED[0]:
+        return bytes([1])
+    else:
+        AUTHENTICATION_ERROR_RETURNED[0] = True
+        raise ATT_Error(ATT_INSUFFICIENT_AUTHENTICATION_ERROR)
+
+
+def write_with_error(connection, value):
+    if not connection.is_encrypted:
+        raise ATT_Error(ATT_INSUFFICIENT_ENCRYPTION_ERROR)
+
+    if not AUTHENTICATION_ERROR_RETURNED[1]:
+        AUTHENTICATION_ERROR_RETURNED[1] = True
+        raise ATT_Error(ATT_INSUFFICIENT_AUTHENTICATION_ERROR)
+
+
+# -----------------------------------------------------------------------------
+def on_connection(connection, request):
+    print(color(f'<<< Connection: {connection}', 'green'))
+
+    # Listen for pairing events
+    connection.on('pairing_start',   on_pairing_start)
+    connection.on('pairing',         on_pairing)
+    connection.on('pairing_failure', on_pairing_failure)
+
+    # Listen for encryption changes
+    connection.on(
+        'connection_encryption_change',
+        lambda: on_connection_encryption_change(connection)
+    )
+
+    # Request pairing if needed
+    if request:
+        print(color('>>> Requesting pairing', 'green'))
+        connection.request_pairing()
+
+
+# -----------------------------------------------------------------------------
+def on_connection_encryption_change(connection):
+    print(color('@@@-----------------------------------', 'blue'))
+    print(color(f'@@@ Connection is {"" if connection.is_encrypted else "not"}encrypted', 'blue'))
+    print(color('@@@-----------------------------------', 'blue'))
+
+
+# -----------------------------------------------------------------------------
+def on_pairing_start():
+    print(color('***-----------------------------------', 'magenta'))
+    print(color('*** Pairing starting', 'magenta'))
+    print(color('***-----------------------------------', 'magenta'))
+
+
+# -----------------------------------------------------------------------------
+def on_pairing(keys):
+    print(color('***-----------------------------------', 'cyan'))
+    print(color('*** Paired!', 'cyan'))
+    keys.print(prefix=color('*** ', 'cyan'))
+    print(color('***-----------------------------------', 'cyan'))
+
+
+# -----------------------------------------------------------------------------
+def on_pairing_failure(reason):
+    print(color('***-----------------------------------', 'red'))
+    print(color(f'*** Pairing failed: {smp_error_name(reason)}', 'red'))
+    print(color('***-----------------------------------', 'red'))
+
+
+# -----------------------------------------------------------------------------
+async def pair(
+    mode,
+    sc,
+    mitm,
+    bond,
+    io,
+    prompt,
+    request,
+    print_keys,
+    keystore_file,
+    device_config,
+    hci_transport,
+    address_or_name
+):
+    print('<<< connecting to HCI...')
+    async with await open_transport_or_link(hci_transport) as (hci_source, hci_sink):
+        print('<<< connected')
+
+        # Create a device to manage the host
+        device = Device.from_config_file_with_hci(device_config, hci_source, hci_sink)
+
+        # Set a custom keystore if specified on the command line
+        if keystore_file:
+            device.keystore = JsonKeyStore(namespace=None, filename=keystore_file)
+
+        # Print the existing keys before pairing
+        if print_keys and device.keystore:
+            print(color('@@@-----------------------------------', 'blue'))
+            print(color('@@@ Pairing Keys:', 'blue'))
+            await device.keystore.print(prefix=color('@@@ ', 'blue'))
+            print(color('@@@-----------------------------------', 'blue'))
+
+        # Expose a GATT characteristic that can be used to trigger pairing by
+        # responding with an authentication error when read
+        if mode == 'le':
+            device.add_service(
+                Service(
+                    '50DB505C-8AC4-4738-8448-3B1D9CC09CC5',
+                    [
+                        Characteristic(
+                            '552957FB-CF1F-4A31-9535-E78847E1A714',
+                            Characteristic.READ | Characteristic.WRITE,
+                            Characteristic.READABLE | Characteristic.WRITEABLE,
+                            CharacteristicValue(read=read_with_error, write=write_with_error)
+                        )
+                    ]
+                )
+            )
+
+        # Select LE or Classic
+        if mode == 'classic':
+            device.classic_enabled = True
+            device.le_enabled = False
+
+        # Get things going
+        await device.power_on()
+
+        # Set up a pairing config factory
+        device.pairing_config_factory = lambda connection: PairingConfig(
+            sc,
+            mitm,
+            bond,
+            Delegate(mode, connection, io, prompt)
+        )
+
+        # Connect to a peer or wait for a connection
+        device.on('connection', lambda connection: on_connection(connection, request))
+        if address_or_name is not None:
+            print(color(f'=== Connecting to {address_or_name}...', 'green'))
+            connection = await device.connect(address_or_name)
+
+            if not request:
+                try:
+                    if mode == 'le':
+                        await connection.pair()
+                    else:
+                        await connection.authenticate()
+                    return
+                except ProtocolError as error:
+                    print(color(f'Pairing failed: {error}', 'red'))
+                    return
+        else:
+            # Advertise so that peers can find us and connect
+            await device.start_advertising(auto_restart=True)
+
+        await hci_source.wait_for_termination()
+
+
+# -----------------------------------------------------------------------------
+@click.command()
+@click.option('--mode', type=click.Choice(['le', 'classic']), default='le', show_default=True)
+@click.option('--sc', type=bool, default=True, help='Use the Secure Connections protocol', show_default=True)
+@click.option('--mitm', type=bool, default=True, help='Request MITM protection', show_default=True)
+@click.option('--bond', type=bool, default=True, help='Enable bonding', show_default=True)
+@click.option('--io', type=click.Choice(['keyboard', 'display', 'display+keyboard', 'display+yes/no', 'none']), default='display+keyboard', show_default=True)
+@click.option('--prompt', is_flag=True, help='Prompt to accept/reject pairing request')
+@click.option('--request', is_flag=True, help='Request that the connecting peer initiate pairing')
+@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.argument('device-config')
+@click.argument('hci_transport')
+@click.argument('address-or-name', required=False)
+def main(mode, sc, mitm, bond, io, prompt, request, print_keys, keystore_file, device_config, hci_transport, address_or_name):
+    logging.basicConfig(level = os.environ.get('BUMBLE_LOGLEVEL', 'INFO').upper())
+    asyncio.run(pair(mode, sc, mitm, bond, io, prompt, request, print_keys, keystore_file, device_config, hci_transport, address_or_name))
+
+
+# -----------------------------------------------------------------------------
+if __name__ == '__main__':
+    main()

apps/scan.py

@@ -0,0 +1,157 @@
+# Copyright 2021-2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import asyncio
+import os
+import logging
+import click
+from colors import color
+
+from bumble.device import Device
+from bumble.transport import open_transport_or_link
+from bumble.keys import JsonKeyStore
+from bumble.smp import AddressResolver
+from bumble.hci import HCI_LE_Advertising_Report_Event
+from bumble.core import AdvertisingData
+
+
+# -----------------------------------------------------------------------------
+def make_rssi_bar(rssi):
+    DISPLAY_MIN_RSSI       = -105
+    DISPLAY_MAX_RSSI       = -30
+    DEFAULT_RSSI_BAR_WIDTH = 30
+
+    blocks = ['', '▏', '▎', '▍', '▌', '▋', '▊', '▉']
+    bar_width = (rssi - DISPLAY_MIN_RSSI) / (DISPLAY_MAX_RSSI - DISPLAY_MIN_RSSI)
+    bar_width = min(max(bar_width, 0), 1)
+    bar_ticks = int(bar_width * DEFAULT_RSSI_BAR_WIDTH * 8)
+    return ('█' * int(bar_ticks / 8)) + blocks[bar_ticks % 8]
+
+
+# -----------------------------------------------------------------------------
+class AdvertisementPrinter:
+    def __init__(self, min_rssi, resolver):
+        self.min_rssi = min_rssi
+        self.resolver = resolver
+
+    def print_advertisement(self, address, address_color, ad_data, rssi):
+        if self.min_rssi is not None and rssi < self.min_rssi:
+            return
+
+        address_qualifier = ''
+        resolution_qualifier = ''
+        if self.resolver and address.is_resolvable:
+            resolved = self.resolver.resolve(address)
+            if resolved is not None:
+                resolution_qualifier = f'(resolved from {address})'
+                address = resolved
+
+        address_type_string = ('PUBLIC', 'RANDOM', 'PUBLIC_ID', 'RANDOM_ID')[address.address_type]
+        if address.is_public:
+            type_color = 'cyan'
+        else:
+            if address.is_static:
+                type_color = 'green'
+                address_qualifier = '(static)'
+            elif address.is_resolvable:
+                type_color = 'magenta'
+                address_qualifier = '(resolvable)'
+            else:
+                type_color = 'blue'
+                address_qualifier = '(non-resolvable)'
+
+        rssi_bar = make_rssi_bar(rssi)
+        separator = '\n  '
+        print(f'>>> {color(address, address_color)} [{color(address_type_string, type_color)}]{address_qualifier}{resolution_qualifier}:{separator}RSSI:{rssi:4} {rssi_bar}{separator}{ad_data.to_string(separator)}\n')
+
+    def on_advertisement(self, address, ad_data, rssi, connectable):
+        address_color = 'yellow' if connectable else 'red'
+        self.print_advertisement(address, address_color, ad_data, rssi)
+
+    def on_advertising_report(self, address, ad_data, rssi, event_type):
+        print(f'{color("EVENT", "green")}: {HCI_LE_Advertising_Report_Event.event_type_name(event_type)}')
+        ad_data = AdvertisingData.from_bytes(ad_data)
+        self.print_advertisement(address, 'yellow', ad_data, rssi)
+
+
+# -----------------------------------------------------------------------------
+async def scan(
+    min_rssi,
+    passive,
+    scan_interval,
+    scan_window,
+    filter_duplicates,
+    raw,
+    keystore_file,
+    device_config,
+    transport
+):
+    print('<<< connecting to HCI...')
+    async with await open_transport_or_link(transport) as (hci_source, hci_sink):
+        print('<<< connected')
+
+        if device_config:
+            device = Device.from_config_file_with_hci(device_config, hci_source, hci_sink)
+        else:
+            device = Device.with_hci('Bumble', 'F0:F1:F2:F3:F4:F5', hci_source, hci_sink)
+
+        if keystore_file:
+            keystore = JsonKeyStore(namespace=None, filename=keystore_file)
+            device.keystore = keystore
+        else:
+            resolver = None
+
+        if device.keystore:
+            resolving_keys = await device.keystore.get_resolving_keys()
+            resolver = AddressResolver(resolving_keys)
+
+        printer = AdvertisementPrinter(min_rssi, resolver)
+        if raw:
+            device.host.on('advertising_report', printer.on_advertising_report)
+        else:
+            device.on('advertisement', printer.on_advertisement)
+
+        await device.power_on()
+        await device.start_scanning(
+            active=(not passive),
+            scan_interval=scan_interval,
+            scan_window=scan_window,
+            filter_duplicates=filter_duplicates
+        )
+
+        await hci_source.wait_for_termination()
+
+
+# -----------------------------------------------------------------------------
+@click.command()
+@click.option('--min-rssi', type=int, help='Minimum RSSI value')
+@click.option('--passive', is_flag=True, default=False, help='Perform passive scanning')
+@click.option('--scan-interval', type=int, default=60, help='Scan interval')
+@click.option('--scan-window', type=int, default=60, help='Scan window')
+@click.option('--filter-duplicates', type=bool, default=True, help='Filter duplicates at the controller level')
+@click.option('--raw', is_flag=True, default=False, help='Listen for raw advertising reports instead of processed ones')
+@click.option('--keystore-file', help='Keystore file to use when resolving addresses')
+@click.option('--device-config', help='Device config file for the scanning device')
+@click.argument('transport')
+def main(min_rssi, passive, scan_interval, scan_window, filter_duplicates, raw, keystore_file, device_config, transport):
+    logging.basicConfig(level = os.environ.get('BUMBLE_LOGLEVEL', 'WARNING').upper())
+    asyncio.run(scan(min_rssi, passive, scan_interval, scan_window, filter_duplicates, raw, keystore_file, device_config, transport))
+
+
+# -----------------------------------------------------------------------------
+if __name__ == '__main__':
+    main()

apps/show.py

@@ -0,0 +1,120 @@
+# Copyright 2021-2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import struct
+import click
+from colors import color
+
+from bumble import hci
+from bumble.transport.common import PacketReader
+from bumble.helpers import PacketTracer
+
+
+# -----------------------------------------------------------------------------
+class SnoopPacketReader:
+    '''
+    Reader that reads HCI packets from a "snoop" file (based on RFC 1761, but not exactly the same...)
+    '''
+
+    DATALINK_H1   = 1001
+    DATALINK_H4   = 1002
+    DATALINK_BSCP = 1003
+    DATALINK_H5   = 1004
+
+    def __init__(self, source):
+        self.source = source
+
+        # Read the header
+        identification_pattern = source.read(8)
+        if identification_pattern.hex().lower() != '6274736e6f6f7000':
+            raise ValueError('not a valid snoop file, unexpected identification pattern')
+        (self.version_number, self.data_link_type) = struct.unpack('>II', source.read(8))
+        if self.data_link_type != self.DATALINK_H4 and self.data_link_type != self.DATALINK_H1:
+            raise ValueError(f'datalink type {self.data_link_type} not supported')
+
+    def next_packet(self):
+        # Read the record header
+        header = self.source.read(24)
+        if len(header) < 24:
+            return (0, None)
+        (
+            original_length,
+            included_length,
+            packet_flags,
+            cumulative_drops,
+            timestamp_seconds,
+            timestamp_microsecond
+        ) = struct.unpack('>IIIIII', header)
+
+        # Abort on truncated packets
+        if original_length != included_length:
+            return (0, None)
+
+        if self.data_link_type == self.DATALINK_H1:
+            # The packet is un-encapsulated, look at the flags to figure out its type
+            if packet_flags & 1:
+                # Controller -> Host
+                if packet_flags & 2:
+                    packet_type = hci.HCI_EVENT_PACKET
+                else:
+                    packet_type = hci.HCI_ACL_DATA_PACKET
+            else:
+                # Host -> Controller
+                if packet_flags & 2:
+                    packet_type = hci.HCI_COMMAND_PACKET
+                else:
+                    packet_type = hci.HCI_ACL_DATA_PACKET
+
+            return (packet_flags & 1, bytes([packet_type]) + self.source.read(included_length))
+        else:
+            return (packet_flags & 1, self.source.read(included_length))
+
+
+# -----------------------------------------------------------------------------
+# Main
+# -----------------------------------------------------------------------------
+@click.command()
+@click.option('--format', type=click.Choice(['h4', 'snoop']), default='h4', help='Format of the input file')
+@click.argument('filename')
+def main(format, filename):
+    input = open(filename, 'rb')
+    if format == 'h4':
+        packet_reader = PacketReader(input)
+
+        def read_next_packet():
+            (0, packet_reader.next_packet())
+    else:
+        packet_reader = SnoopPacketReader(input)
+        read_next_packet = packet_reader.next_packet
+
+    tracer = PacketTracer(emit_message=print)
+
+    while True:
+        try:
+            (direction, packet) = read_next_packet()
+            if packet is None:
+                break
+            tracer.trace(hci.HCI_Packet.from_bytes(packet), direction)
+
+        except Exception as error:
+            print(color(f'!!! {error}', 'red'))
+            pass
+
+
+# -----------------------------------------------------------------------------
+if __name__ == '__main__':
+    main()

apps/unbond.py

@@ -0,0 +1,63 @@
+# Copyright 2021-2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import asyncio
+import os
+import logging
+import click
+
+from bumble.device import Device
+from bumble.keys import JsonKeyStore
+
+
+# -----------------------------------------------------------------------------
+async def unbond(keystore_file, device_config, address):
+    # Create a device to manage the host
+    device = Device.from_config_file(device_config)
+
+    # Get all entries in the keystore
+    if keystore_file:
+        keystore = JsonKeyStore(None, keystore_file)
+    else:
+        keystore = device.keystore
+
+    if keystore is None:
+        print('no keystore')
+        return
+
+    if address is None:
+        await keystore.print()
+    else:
+        try:
+            await keystore.delete(address)
+        except KeyError:
+            print('!!! pairing not found')
+
+
+# -----------------------------------------------------------------------------
+@click.command()
+@click.option('--keystore-file', help='File in which to store the pairing keys')
+@click.argument('device-config')
+@click.argument('address', required=False)
+def main(keystore_file, device_config, address):
+    logging.basicConfig(level = os.environ.get('BUMBLE_LOGLEVEL', 'INFO').upper())
+    asyncio.run(unbond(keystore_file, device_config, address))
+
+
+# -----------------------------------------------------------------------------
+if __name__ == '__main__':
+    main()

apps/usb_probe.py

@@ -0,0 +1,239 @@
+# Copyright 2021-2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# This tool lists all the USB devices, with details about each device.
+# For each device, the different possible Bumble transport strings that can
+# refer to it are listed. If the device is known to be a Bluetooth HCI device,
+# its identifier is printed in reverse colors, and the transport names in cyan color.
+# For other devices, regardless of their type, the transport names are printed
+# in red. Whether that device is actually a Bluetooth device or not depends on
+# whether it is a Bluetooth device that uses a non-standard Class, or some other
+# type of device (there's no way to tell).
+# -----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import os
+import logging
+import sys
+import click
+import usb1
+from colors import color
+
+
+# -----------------------------------------------------------------------------
+# Constants
+# -----------------------------------------------------------------------------
+USB_DEVICE_CLASS_DEVICE                          = 0x00
+USB_DEVICE_CLASS_WIRELESS_CONTROLLER             = 0xE0
+USB_DEVICE_SUBCLASS_RF_CONTROLLER                = 0x01
+USB_DEVICE_PROTOCOL_BLUETOOTH_PRIMARY_CONTROLLER = 0x01
+
+USB_DEVICE_CLASSES = {
+    0x00: 'Device',
+    0x01: 'Audio',
+    0x02: 'Communications and CDC Control',
+    0x03: 'Human Interface Device',
+    0x05: 'Physical',
+    0x06: 'Still Imaging',
+    0x07: 'Printer',
+    0x08: 'Mass Storage',
+    0x09: 'Hub',
+    0x0A: 'CDC Data',
+    0x0B: 'Smart Card',
+    0x0D: 'Content Security',
+    0x0E: 'Video',
+    0x0F: 'Personal Healthcare',
+    0x10: 'Audio/Video',
+    0x11: 'Billboard',
+    0x12: 'USB Type-C Bridge',
+    0x3C: 'I3C',
+    0xDC: 'Diagnostic',
+    USB_DEVICE_CLASS_WIRELESS_CONTROLLER: (
+        'Wireless Controller',
+        {
+            0x01: {
+                0x01: 'Bluetooth',
+                0x02: 'UWB',
+                0x03: 'Remote NDIS',
+                0x04: 'Bluetooth AMP'
+            }
+        }
+    ),
+    0xEF: 'Miscellaneous',
+    0xFE: 'Application Specific',
+    0xFF: 'Vendor Specific'
+}
+
+USB_ENDPOINT_IN    = 0x80
+USB_ENDPOINT_TYPES = ['CONTROL', 'ISOCHRONOUS', 'BULK', 'INTERRUPT']
+
+USB_BT_HCI_CLASS_TUPLE = (
+    USB_DEVICE_CLASS_WIRELESS_CONTROLLER,
+    USB_DEVICE_SUBCLASS_RF_CONTROLLER,
+    USB_DEVICE_PROTOCOL_BLUETOOTH_PRIMARY_CONTROLLER
+)
+
+
+# -----------------------------------------------------------------------------
+def show_device_details(device):
+    for configuration in device:
+        print(f'  Configuration {configuration.getConfigurationValue()}')
+        for interface in configuration:
+            for setting in interface:
+                alternateSetting = setting.getAlternateSetting()
+                suffix = f'/{alternateSetting}' if interface.getNumSettings() > 1 else ''
+                (class_string, subclass_string) = get_class_info(
+                    setting.getClass(),
+                    setting.getSubClass(),
+                    setting.getProtocol()
+                )
+                details = f'({class_string}, {subclass_string})'
+                print(f'      Interface: {setting.getNumber()}{suffix} {details}')
+                for endpoint in setting:
+                    endpoint_type = USB_ENDPOINT_TYPES[endpoint.getAttributes() & 3]
+                    endpoint_direction = 'OUT' if (endpoint.getAddress() & USB_ENDPOINT_IN == 0) else 'IN'
+                    print(f'        Endpoint 0x{endpoint.getAddress():02X}: {endpoint_type} {endpoint_direction}')
+
+
+# -----------------------------------------------------------------------------
+def get_class_info(cls, subclass, protocol):
+    class_info = USB_DEVICE_CLASSES.get(cls)
+    protocol_string = ''
+    if class_info is None:
+        class_string = f'0x{cls:02X}'
+    else:
+        if type(class_info) is tuple:
+            class_string = class_info[0]
+            subclass_info = class_info[1].get(subclass)
+            if subclass_info:
+                protocol_string = subclass_info.get(protocol)
+                if protocol_string is not None:
+                    protocol_string = f' [{protocol_string}]'
+
+        else:
+            class_string = class_info
+
+    subclass_string = f'{subclass}/{protocol}{protocol_string}'
+
+    return (class_string, subclass_string)
+
+
+# -----------------------------------------------------------------------------
+def is_bluetooth_hci(device):
+    # Check if the device class indicates a match
+    if (device.getDeviceClass(), device.getDeviceSubClass(), device.getDeviceProtocol()) == USB_BT_HCI_CLASS_TUPLE:
+        return True
+
+    # If the device class is 'Device', look for a matching interface
+    if device.getDeviceClass() == USB_DEVICE_CLASS_DEVICE:
+        for configuration in device:
+            for interface in configuration:
+                for setting in interface:
+                    if (setting.getClass(), setting.getSubClass(), setting.getProtocol()) == USB_BT_HCI_CLASS_TUPLE:
+                        return True
+
+    return False
+
+
+# -----------------------------------------------------------------------------
+@click.command()
+@click.option('--verbose', is_flag=True, default=False, help='Print more details')
+def main(verbose):
+    logging.basicConfig(level = os.environ.get('BUMBLE_LOGLEVEL', 'WARNING').upper())
+
+    with usb1.USBContext() as context:
+        bluetooth_device_count = 0
+        devices = {}
+
+        for device in context.getDeviceIterator(skip_on_error=True):
+            device_class    = device.getDeviceClass()
+            device_subclass = device.getDeviceSubClass()
+            device_protocol = device.getDeviceProtocol()
+
+            device_id = (device.getVendorID(), device.getProductID())
+
+            (device_class_string, device_subclass_string) = get_class_info(
+                device_class,
+                device_subclass,
+                device_protocol
+            )
+
+            try:
+                device_serial_number = device.getSerialNumber()
+            except usb1.USBError:
+                device_serial_number = None
+
+            try:
+                device_manufacturer = device.getManufacturer()
+            except usb1.USBError:
+                device_manufacturer = None
+
+            try:
+                device_product = device.getProduct()
+            except usb1.USBError:
+                device_product = None
+
+            device_is_bluetooth_hci = is_bluetooth_hci(device)
+            if device_is_bluetooth_hci:
+                bluetooth_device_count += 1
+                fg_color = 'black'
+                bg_color = 'yellow'
+            else:
+                fg_color = 'yellow'
+                bg_color = 'black'
+
+            # Compute the different ways this can be referenced as a Bumble transport
+            bumble_transport_names = []
+            basic_transport_name = f'usb:{device.getVendorID():04X}:{device.getProductID():04X}'
+
+            if device_is_bluetooth_hci:
+                bumble_transport_names.append(f'usb:{bluetooth_device_count - 1}')
+
+            if device_id not in devices:
+                bumble_transport_names.append(basic_transport_name)
+            else:
+                bumble_transport_names.append(f'{basic_transport_name}#{len(devices[device_id])}')
+
+            if device_serial_number is not None:
+                if device_id not in devices or device_serial_number not in devices[device_id]:
+                    bumble_transport_names.append(f'{basic_transport_name}/{device_serial_number}')
+
+            # Print the results
+            print(color(f'ID {device.getVendorID():04X}:{device.getProductID():04X}', fg=fg_color, bg=bg_color))
+            if bumble_transport_names:
+                print(color('  Bumble Transport Names:', 'blue'), ' or '.join(color(x, 'cyan' if device_is_bluetooth_hci else 'red') for x in bumble_transport_names))
+            print(color('  Bus/Device:            ', 'green'), f'{device.getBusNumber():03}/{device.getDeviceAddress():03}')
+            print(color('  Class:                 ', 'green'), device_class_string)
+            print(color('  Subclass/Protocol:     ', 'green'), device_subclass_string)
+            if device_serial_number is not None:
+                print(color('  Serial:                ', 'green'), device_serial_number)
+            if device_manufacturer is not None:
+                print(color('  Manufacturer:          ', 'green'), device_manufacturer)
+            if device_product is not None:
+                print(color('  Product:               ', 'green'), device_product)
+
+            if verbose:
+                show_device_details(device)
+
+            print()
+
+            devices.setdefault(device_id, []).append(device_serial_number)
+
+
+# -----------------------------------------------------------------------------
+if __name__ == '__main__':
+    main()

assets/_mkdocstrings.css

@@ -1,143 +0,0 @@
-
-/* Avoid breaking parameter names, etc. in table cells. */
-.doc-contents td code {
-  word-break: normal !important;
-}
-
-/* No line break before first paragraph of descriptions. */
-.doc-md-description,
-.doc-md-description>p:first-child {
-  display: inline;
-}
-
-/* Max width for docstring sections tables. */
-.doc .md-typeset__table,
-.doc .md-typeset__table table {
-  display: table !important;
-  width: 100%;
-}
-
-.doc .md-typeset__table tr {
-  display: table-row;
-}
-
-/* Defaults in Spacy table style. */
-.doc-param-default {
-  float: right;
-}
-
-/* Parameter headings must be inline, not blocks. */
-.doc-heading-parameter {
-  display: inline;
-}
-
-/* Prefer space on the right, not the left of parameter permalinks. */
-.doc-heading-parameter .headerlink {
-  margin-left: 0 !important;
-  margin-right: 0.2rem;
-}
-
-/* Backward-compatibility: docstring section titles in bold. */
-.doc-section-title {
-  font-weight: bold;
-}
-
-/* Symbols in Navigation and ToC. */
-:root, :host,
-[data-md-color-scheme="default"] {
-  --doc-symbol-parameter-fg-color: #df50af;
-  --doc-symbol-attribute-fg-color: #953800;
-  --doc-symbol-function-fg-color: #8250df;
-  --doc-symbol-method-fg-color: #8250df;
-  --doc-symbol-class-fg-color: #0550ae;
-  --doc-symbol-module-fg-color: #5cad0f;
-
-  --doc-symbol-parameter-bg-color: #df50af1a;
-  --doc-symbol-attribute-bg-color: #9538001a;
-  --doc-symbol-function-bg-color: #8250df1a;
-  --doc-symbol-method-bg-color: #8250df1a;
-  --doc-symbol-class-bg-color: #0550ae1a;
-  --doc-symbol-module-bg-color: #5cad0f1a;
-}
-
-[data-md-color-scheme="slate"] {
-  --doc-symbol-parameter-fg-color: #ffa8cc;
-  --doc-symbol-attribute-fg-color: #ffa657;
-  --doc-symbol-function-fg-color: #d2a8ff;
-  --doc-symbol-method-fg-color: #d2a8ff;
-  --doc-symbol-class-fg-color: #79c0ff;
-  --doc-symbol-module-fg-color: #baff79;
-
-  --doc-symbol-parameter-bg-color: #ffa8cc1a;
-  --doc-symbol-attribute-bg-color: #ffa6571a;
-  --doc-symbol-function-bg-color: #d2a8ff1a;
-  --doc-symbol-method-bg-color: #d2a8ff1a;
-  --doc-symbol-class-bg-color: #79c0ff1a;
-  --doc-symbol-module-bg-color: #baff791a;
-}
-
-code.doc-symbol {
-  border-radius: .1rem;
-  font-size: .85em;
-  padding: 0 .3em;
-  font-weight: bold;
-}
-
-code.doc-symbol-parameter {
-  color: var(--doc-symbol-parameter-fg-color);
-  background-color: var(--doc-symbol-parameter-bg-color);
-}
-
-code.doc-symbol-parameter::after {
-  content: "param";
-}
-
-code.doc-symbol-attribute {
-  color: var(--doc-symbol-attribute-fg-color);
-  background-color: var(--doc-symbol-attribute-bg-color);
-}
-
-code.doc-symbol-attribute::after {
-  content: "attr";
-}
-
-code.doc-symbol-function {
-  color: var(--doc-symbol-function-fg-color);
-  background-color: var(--doc-symbol-function-bg-color);
-}
-
-code.doc-symbol-function::after {
-  content: "func";
-}
-
-code.doc-symbol-method {
-  color: var(--doc-symbol-method-fg-color);
-  background-color: var(--doc-symbol-method-bg-color);
-}
-
-code.doc-symbol-method::after {
-  content: "meth";
-}
-
-code.doc-symbol-class {
-  color: var(--doc-symbol-class-fg-color);
-  background-color: var(--doc-symbol-class-bg-color);
-}
-
-code.doc-symbol-class::after {
-  content: "class";
-}
-
-code.doc-symbol-module {
-  color: var(--doc-symbol-module-fg-color);
-  background-color: var(--doc-symbol-module-bg-color);
-}
-
-code.doc-symbol-module::after {
-  content: "mod";
-}
-
-.doc-signature .autorefs {
-  color: inherit;
-  border-bottom: 1px dotted currentcolor;
-}

assets/javascripts/lunr/min/lunr.da.min.js

@@ -1,18 +0,0 @@
-/*!
- * Lunr languages, `Danish` language
- * https://github.com/MihaiValentin/lunr-languages
- *
- * Copyright 2014, Mihai Valentin
- * http://www.mozilla.org/MPL/
- */
-/*!
- * based on
- * Snowball JavaScript Library v0.3
- * http://code.google.com/p/urim/
- * http://snowball.tartarus.org/
- *
- * Copyright 2010, Oleg Mazko
- * http://www.mozilla.org/MPL/
- */
-
-!function(e,r){"function"==typeof define&&define.amd?define(r):"object"==typeof exports?module.exports=r():r()(e.lunr)}(this,function(){return function(e){if(void 0===e)throw new Error("Lunr is not present. Please include / require Lunr before this script.");if(void 0===e.stemmerSupport)throw new Error("Lunr stemmer support is not present. Please include / require Lunr stemmer support before this script.");e.da=function(){this.pipeline.reset(),this.pipeline.add(e.da.trimmer,e.da.stopWordFilter,e.da.stemmer),this.searchPipeline&&(this.searchPipeline.reset(),this.searchPipeline.add(e.da.stemmer))},e.da.wordCharacters="A-Za-zªºÀ-ÖØ-öø-ʸˠ-ˤᴀ-ᴥᴬ-ᵜᵢ-ᵥᵫ-ᵷᵹ-ᶾḀ-ỿⁱⁿₐ-ₜKÅℲⅎⅠ-ↈⱠ-ⱿꜢ-ꞇꞋ-ꞭꞰ-ꞷꟷ-ꟿꬰ-ꭚꭜ-ꭤff-stＡ-Ｚａ-ｚ",e.da.trimmer=e.trimmerSupport.generateTrimmer(e.da.wordCharacters),e.Pipeline.registerFunction(e.da.trimmer,"trimmer-da"),e.da.stemmer=function(){var r=e.stemmerSupport.Among,i=e.stemmerSupport.SnowballProgram,n=new function(){function e(){var e,r=f.cursor+3;if(d=f.limit,0<=r&&r<=f.limit){for(a=r;;){if(e=f.cursor,f.in_grouping(w,97,248)){f.cursor=e;break}if(f.cursor=e,e>=f.limit)return;f.cursor++}for(;!f.out_grouping(w,97,248);){if(f.cursor>=f.limit)return;f.cursor++}d=f.cursor,d<a&&(d=a)}}function n(){var e,r;if(f.cursor>=d&&(r=f.limit_backward,f.limit_backward=d,f.ket=f.cursor,e=f.find_among_b(c,32),f.limit_backward=r,e))switch(f.bra=f.cursor,e){case 1:f.slice_del();break;case 2:f.in_grouping_b(p,97,229)&&f.slice_del()}}function t(){var e,r=f.limit-f.cursor;f.cursor>=d&&(e=f.limit_backward,f.limit_backward=d,f.ket=f.cursor,f.find_among_b(l,4)?(f.bra=f.cursor,f.limit_backward=e,f.cursor=f.limit-r,f.cursor>f.limit_backward&&(f.cursor--,f.bra=f.cursor,f.slice_del())):f.limit_backward=e)}function s(){var e,r,i,n=f.limit-f.cursor;if(f.ket=f.cursor,f.eq_s_b(2,"st")&&(f.bra=f.cursor,f.eq_s_b(2,"ig")&&f.slice_del()),f.cursor=f.limit-n,f.cursor>=d&&(r=f.limit_backward,f.limit_backward=d,f.ket=f.cursor,e=f.find_among_b(m,5),f.limit_backward=r,e))switch(f.bra=f.cursor,e){case 1:f.slice_del(),i=f.limit-f.cursor,t(),f.cursor=f.limit-i;break;case 2:f.slice_from("løs")}}function o(){var e;f.cursor>=d&&(e=f.limit_backward,f.limit_backward=d,f.ket=f.cursor,f.out_grouping_b(w,97,248)?(f.bra=f.cursor,u=f.slice_to(u),f.limit_backward=e,f.eq_v_b(u)&&f.slice_del()):f.limit_backward=e)}var a,d,u,c=[new r("hed",-1,1),new r("ethed",0,1),new r("ered",-1,1),new r("e",-1,1),new r("erede",3,1),new r("ende",3,1),new r("erende",5,1),new r("ene",3,1),new r("erne",3,1),new r("ere",3,1),new r("en",-1,1),new r("heden",10,1),new r("eren",10,1),new r("er",-1,1),new r("heder",13,1),new r("erer",13,1),new r("s",-1,2),new r("heds",16,1),new r("es",16,1),new r("endes",18,1),new r("erendes",19,1),new r("enes",18,1),new r("ernes",18,1),new r("eres",18,1),new r("ens",16,1),new r("hedens",24,1),new r("erens",24,1),new r("ers",16,1),new r("ets",16,1),new r("erets",28,1),new r("et",-1,1),new r("eret",30,1)],l=[new r("gd",-1,-1),new r("dt",-1,-1),new r("gt",-1,-1),new r("kt",-1,-1)],m=[new r("ig",-1,1),new r("lig",0,1),new r("elig",1,1),new r("els",-1,1),new r("løst",-1,2)],w=[17,65,16,1,0,0,0,0,0,0,0,0,0,0,0,0,48,0,128],p=[239,254,42,3,0,0,0,0,0,0,0,0,0,0,0,0,16],f=new i;this.setCurrent=function(e){f.setCurrent(e)},this.getCurrent=function(){return f.getCurrent()},this.stem=function(){var r=f.cursor;return e(),f.limit_backward=r,f.cursor=f.limit,n(),f.cursor=f.limit,t(),f.cursor=f.limit,s(),f.cursor=f.limit,o(),!0}};return function(e){return"function"==typeof e.update?e.update(function(e){return n.setCurrent(e),n.stem(),n.getCurrent()}):(n.setCurrent(e),n.stem(),n.getCurrent())}}(),e.Pipeline.registerFunction(e.da.stemmer,"stemmer-da"),e.da.stopWordFilter=e.generateStopWordFilter("ad af alle alt anden at blev blive bliver da de dem den denne der deres det dette dig din disse dog du efter eller en end er et for fra ham han hans har havde have hende hendes her hos hun hvad hvis hvor i ikke ind jeg jer jo kunne man mange med meget men mig min mine mit mod ned noget nogle nu når og også om op os over på selv sig sin sine sit skal skulle som sådan thi til ud under var vi vil ville vor være været".split(" ")),e.Pipeline.registerFunction(e.da.stopWordFilter,"stopWordFilter-da")}});

assets/javascripts/lunr/min/lunr.hi.min.js

@@ -1 +0,0 @@
-!function(e,r){"function"==typeof define&&define.amd?define(r):"object"==typeof exports?module.exports=r():r()(e.lunr)}(this,function(){return function(e){if(void 0===e)throw new Error("Lunr is not present. Please include / require Lunr before this script.");if(void 0===e.stemmerSupport)throw new Error("Lunr stemmer support is not present. Please include / require Lunr stemmer support before this script.");e.hi=function(){this.pipeline.reset(),this.pipeline.add(e.hi.trimmer,e.hi.stopWordFilter,e.hi.stemmer),this.searchPipeline&&(this.searchPipeline.reset(),this.searchPipeline.add(e.hi.stemmer))},e.hi.wordCharacters="ऀ-ःऄ-एऐ-टठ-यर-िी-ॏॐ-य़ॠ-९॰-ॿa-zA-Zａ-ｚＡ-Ｚ0-9０-９",e.hi.trimmer=e.trimmerSupport.generateTrimmer(e.hi.wordCharacters),e.Pipeline.registerFunction(e.hi.trimmer,"trimmer-hi"),e.hi.stopWordFilter=e.generateStopWordFilter("अत अपना अपनी अपने अभी अंदर आदि आप इत्यादि इन इनका इन्हीं इन्हें इन्हों इस इसका इसकी इसके इसमें इसी इसे उन उनका उनकी उनके उनको उन्हीं उन्हें उन्हों उस उसके उसी उसे एक एवं एस ऐसे और कई कर करता करते करना करने करें कहते कहा का काफ़ी कि कितना किन्हें किन्हों किया किर किस किसी किसे की कुछ कुल के को कोई कौन कौनसा गया घर जब जहाँ जा जितना जिन जिन्हें जिन्हों जिस जिसे जीधर जैसा जैसे जो तक तब तरह तिन तिन्हें तिन्हों तिस तिसे तो था थी थे दबारा दिया दुसरा दूसरे दो द्वारा न नके नहीं ना निहायत नीचे ने पर पहले पूरा पे फिर बनी बही बहुत बाद बाला बिलकुल भी भीतर मगर मानो मे में यदि यह यहाँ यही या यिह ये रखें रहा रहे ऱ्वासा लिए लिये लेकिन व वग़ैरह वर्ग वह वहाँ वहीं वाले वुह वे वो सकता सकते सबसे सभी साथ साबुत साभ सारा से सो संग ही हुआ हुई हुए है हैं हो होता होती होते होना होने".split(" ")),e.hi.stemmer=function(){return function(e){return"function"==typeof e.update?e.update(function(e){return e}):e}}();var r=e.wordcut;r.init(),e.hi.tokenizer=function(i){if(!arguments.length||null==i||void 0==i)return[];if(Array.isArray(i))return i.map(function(r){return isLunr2?new e.Token(r.toLowerCase()):r.toLowerCase()});var t=i.toString().toLowerCase().replace(/^\s+/,"");return r.cut(t).split("|")},e.Pipeline.registerFunction(e.hi.stemmer,"stemmer-hi"),e.Pipeline.registerFunction(e.hi.stopWordFilter,"stopWordFilter-hi")}});

assets/javascripts/lunr/min/lunr.hy.min.js

@@ -1 +0,0 @@
-!function(e,r){"function"==typeof define&&define.amd?define(r):"object"==typeof exports?module.exports=r():r()(e.lunr)}(this,function(){return function(e){if(void 0===e)throw new Error("Lunr is not present. Please include / require Lunr before this script.");if(void 0===e.stemmerSupport)throw new Error("Lunr stemmer support is not present. Please include / require Lunr stemmer support before this script.");e.hy=function(){this.pipeline.reset(),this.pipeline.add(e.hy.trimmer,e.hy.stopWordFilter)},e.hy.wordCharacters="[A-Za-z԰-֏ff-ﭏ]",e.hy.trimmer=e.trimmerSupport.generateTrimmer(e.hy.wordCharacters),e.Pipeline.registerFunction(e.hy.trimmer,"trimmer-hy"),e.hy.stopWordFilter=e.generateStopWordFilter("դու և եք էիր էիք հետո նաև նրանք որը վրա է որ պիտի են այս մեջ ն իր ու ի այդ որոնք այն կամ էր մի ես համար այլ իսկ էին ենք հետ ին թ էինք մենք նրա նա դուք եմ էի ըստ որպես ում".split(" ")),e.Pipeline.registerFunction(e.hy.stopWordFilter,"stopWordFilter-hy"),e.hy.stemmer=function(){return function(e){return"function"==typeof e.update?e.update(function(e){return e}):e}}(),e.Pipeline.registerFunction(e.hy.stemmer,"stemmer-hy")}});

assets/javascripts/lunr/min/lunr.ja.min.js

@@ -1 +0,0 @@
-!function(e,r){"function"==typeof define&&define.amd?define(r):"object"==typeof exports?module.exports=r():r()(e.lunr)}(this,function(){return function(e){if(void 0===e)throw new Error("Lunr is not present. Please include / require Lunr before this script.");if(void 0===e.stemmerSupport)throw new Error("Lunr stemmer support is not present. Please include / require Lunr stemmer support before this script.");var r="2"==e.version[0];e.ja=function(){this.pipeline.reset(),this.pipeline.add(e.ja.trimmer,e.ja.stopWordFilter,e.ja.stemmer),r?this.tokenizer=e.ja.tokenizer:(e.tokenizer&&(e.tokenizer=e.ja.tokenizer),this.tokenizerFn&&(this.tokenizerFn=e.ja.tokenizer))};var t=new e.TinySegmenter;e.ja.tokenizer=function(i){var n,o,s,p,a,u,m,l,c,f;if(!arguments.length||null==i||void 0==i)return[];if(Array.isArray(i))return i.map(function(t){return r?new e.Token(t.toLowerCase()):t.toLowerCase()});for(o=i.toString().toLowerCase().replace(/^\s+/,""),n=o.length-1;n>=0;n--)if(/\S/.test(o.charAt(n))){o=o.substring(0,n+1);break}for(a=[],s=o.length,c=0,l=0;c<=s;c++)if(u=o.charAt(c),m=c-l,u.match(/\s/)||c==s){if(m>0)for(p=t.segment(o.slice(l,c)).filter(function(e){return!!e}),f=l,n=0;n<p.length;n++)r?a.push(new e.Token(p[n],{position:[f,p[n].length],index:a.length})):a.push(p[n]),f+=p[n].length;l=c+1}return a},e.ja.stemmer=function(){return function(e){return e}}(),e.Pipeline.registerFunction(e.ja.stemmer,"stemmer-ja"),e.ja.wordCharacters="一二三四五六七八九十百千万億兆一-龠々〆ヵヶぁ-んァ-ヴーｱ-ﾝﾞa-zA-Zａ-ｚＡ-Ｚ0-9０-９",e.ja.trimmer=e.trimmerSupport.generateTrimmer(e.ja.wordCharacters),e.Pipeline.registerFunction(e.ja.trimmer,"trimmer-ja"),e.ja.stopWordFilter=e.generateStopWordFilter("これ それ あれ この その あの ここ そこ あそこ こちら どこ だれ なに なん 何 私 貴方 貴方方 我々 私達 あの人 あのかた 彼女 彼 です あります おります います は が の に を で え から まで より も どの と し それで しかし".split(" ")),e.Pipeline.registerFunction(e.ja.stopWordFilter,"stopWordFilter-ja"),e.jp=e.ja,e.Pipeline.registerFunction(e.jp.stemmer,"stemmer-jp"),e.Pipeline.registerFunction(e.jp.trimmer,"trimmer-jp"),e.Pipeline.registerFunction(e.jp.stopWordFilter,"stopWordFilter-jp")}});

assets/javascripts/lunr/min/lunr.jp.min.js

@@ -1 +0,0 @@
-module.exports=require("./lunr.ja");

assets/javascripts/lunr/min/lunr.kn.min.js

@@ -1 +0,0 @@
-!function(e,r){"function"==typeof define&&define.amd?define(r):"object"==typeof exports?module.exports=r():r()(e.lunr)}(this,function(){return function(e){if(void 0===e)throw new Error("Lunr is not present. Please include / require Lunr before this script.");if(void 0===e.stemmerSupport)throw new Error("Lunr stemmer support is not present. Please include / require Lunr stemmer support before this script.");e.kn=function(){this.pipeline.reset(),this.pipeline.add(e.kn.trimmer,e.kn.stopWordFilter,e.kn.stemmer),this.searchPipeline&&(this.searchPipeline.reset(),this.searchPipeline.add(e.kn.stemmer))},e.kn.wordCharacters="ಀ-಄ಅ-ಔಕ-ಹಾ-ೌ಼-ಽೕ-ೖೝ-ೞೠ-ೡೢ-ೣ೤೥೦-೯ೱ-ೳ",e.kn.trimmer=e.trimmerSupport.generateTrimmer(e.kn.wordCharacters),e.Pipeline.registerFunction(e.kn.trimmer,"trimmer-kn"),e.kn.stopWordFilter=e.generateStopWordFilter("ಮತ್ತು ಈ ಒಂದು ರಲ್ಲಿ ಹಾಗೂ ಎಂದು ಅಥವಾ ಇದು ರ ಅವರು ಎಂಬ ಮೇಲೆ ಅವರ ತನ್ನ ಆದರೆ ತಮ್ಮ ನಂತರ ಮೂಲಕ ಹೆಚ್ಚು ನ ಆ ಕೆಲವು ಅನೇಕ ಎರಡು ಹಾಗು ಪ್ರಮುಖ ಇದನ್ನು ಇದರ ಸುಮಾರು ಅದರ ಅದು ಮೊದಲ ಬಗ್ಗೆ ನಲ್ಲಿ ರಂದು ಇತರ ಅತ್ಯಂತ ಹೆಚ್ಚಿನ ಸಹ ಸಾಮಾನ್ಯವಾಗಿ ನೇ ಹಲವಾರು ಹೊಸ ದಿ ಕಡಿಮೆ ಯಾವುದೇ ಹೊಂದಿದೆ ದೊಡ್ಡ ಅನ್ನು ಇವರು ಪ್ರಕಾರ ಇದೆ ಮಾತ್ರ ಕೂಡ ಇಲ್ಲಿ ಎಲ್ಲಾ ವಿವಿಧ ಅದನ್ನು ಹಲವು ರಿಂದ ಕೇವಲ ದ ದಕ್ಷಿಣ ಗೆ ಅವನ ಅತಿ ನೆಯ ಬಹಳ ಕೆಲಸ ಎಲ್ಲ ಪ್ರತಿ ಇತ್ಯಾದಿ ಇವು ಬೇರೆ ಹೀಗೆ ನಡುವೆ ಇದಕ್ಕೆ ಎಸ್ ಇವರ ಮೊದಲು ಶ್ರೀ ಮಾಡುವ ಇದರಲ್ಲಿ ರೀತಿಯ ಮಾಡಿದ ಕಾಲ ಅಲ್ಲಿ ಮಾಡಲು ಅದೇ ಈಗ ಅವು ಗಳು ಎ ಎಂಬುದು ಅವನು ಅಂದರೆ ಅವರಿಗೆ ಇರುವ ವಿಶೇಷ ಮುಂದೆ ಅವುಗಳ ಮುಂತಾದ ಮೂಲ ಬಿ ಮೀ ಒಂದೇ ಇನ್ನೂ ಹೆಚ್ಚಾಗಿ ಮಾಡಿ ಅವರನ್ನು ಇದೇ ಯ ರೀತಿಯಲ್ಲಿ ಜೊತೆ ಅದರಲ್ಲಿ ಮಾಡಿದರು ನಡೆದ ಆಗ ಮತ್ತೆ ಪೂರ್ವ ಆತ ಬಂದ ಯಾವ ಒಟ್ಟು ಇತರೆ ಹಿಂದೆ ಪ್ರಮಾಣದ ಗಳನ್ನು ಕುರಿತು ಯು ಆದ್ದರಿಂದ ಅಲ್ಲದೆ ನಗರದ ಮೇಲಿನ ಏಕೆಂದರೆ ರಷ್ಟು ಎಂಬುದನ್ನು ಬಾರಿ ಎಂದರೆ ಹಿಂದಿನ ಆದರೂ ಆದ ಸಂಬಂಧಿಸಿದ ಮತ್ತೊಂದು ಸಿ ಆತನ ".split(" ")),e.kn.stemmer=function(){return function(e){return"function"==typeof e.update?e.update(function(e){return e}):e}}();var r=e.wordcut;r.init(),e.kn.tokenizer=function(t){if(!arguments.length||null==t||void 0==t)return[];if(Array.isArray(t))return t.map(function(r){return isLunr2?new e.Token(r.toLowerCase()):r.toLowerCase()});var n=t.toString().toLowerCase().replace(/^\s+/,"");return r.cut(n).split("|")},e.Pipeline.registerFunction(e.kn.stemmer,"stemmer-kn"),e.Pipeline.registerFunction(e.kn.stopWordFilter,"stopWordFilter-kn")}});

assets/javascripts/lunr/min/lunr.multi.min.js

@@ -1 +0,0 @@
-!function(e,t){"function"==typeof define&&define.amd?define(t):"object"==typeof exports?module.exports=t():t()(e.lunr)}(this,function(){return function(e){e.multiLanguage=function(){for(var t=Array.prototype.slice.call(arguments),i=t.join("-"),r="",n=[],s=[],p=0;p<t.length;++p)"en"==t[p]?(r+="\\w",n.unshift(e.stopWordFilter),n.push(e.stemmer),s.push(e.stemmer)):(r+=e[t[p]].wordCharacters,e[t[p]].stopWordFilter&&n.unshift(e[t[p]].stopWordFilter),e[t[p]].stemmer&&(n.push(e[t[p]].stemmer),s.push(e[t[p]].stemmer)));var o=e.trimmerSupport.generateTrimmer(r);return e.Pipeline.registerFunction(o,"lunr-multi-trimmer-"+i),n.unshift(o),function(){this.pipeline.reset(),this.pipeline.add.apply(this.pipeline,n),this.searchPipeline&&(this.searchPipeline.reset(),this.searchPipeline.add.apply(this.searchPipeline,s))}}}});

assets/javascripts/lunr/min/lunr.no.min.js

@@ -1,18 +0,0 @@
-/*!
- * Lunr languages, `Norwegian` language
- * https://github.com/MihaiValentin/lunr-languages
- *
- * Copyright 2014, Mihai Valentin
- * http://www.mozilla.org/MPL/
- */
-/*!
- * based on
- * Snowball JavaScript Library v0.3
- * http://code.google.com/p/urim/
- * http://snowball.tartarus.org/
- *
- * Copyright 2010, Oleg Mazko
- * http://www.mozilla.org/MPL/
- */
-
-!function(e,r){"function"==typeof define&&define.amd?define(r):"object"==typeof exports?module.exports=r():r()(e.lunr)}(this,function(){return function(e){if(void 0===e)throw new Error("Lunr is not present. Please include / require Lunr before this script.");if(void 0===e.stemmerSupport)throw new Error("Lunr stemmer support is not present. Please include / require Lunr stemmer support before this script.");e.no=function(){this.pipeline.reset(),this.pipeline.add(e.no.trimmer,e.no.stopWordFilter,e.no.stemmer),this.searchPipeline&&(this.searchPipeline.reset(),this.searchPipeline.add(e.no.stemmer))},e.no.wordCharacters="A-Za-zªºÀ-ÖØ-öø-ʸˠ-ˤᴀ-ᴥᴬ-ᵜᵢ-ᵥᵫ-ᵷᵹ-ᶾḀ-ỿⁱⁿₐ-ₜKÅℲⅎⅠ-ↈⱠ-ⱿꜢ-ꞇꞋ-ꞭꞰ-ꞷꟷ-ꟿꬰ-ꭚꭜ-ꭤff-stＡ-Ｚａ-ｚ",e.no.trimmer=e.trimmerSupport.generateTrimmer(e.no.wordCharacters),e.Pipeline.registerFunction(e.no.trimmer,"trimmer-no"),e.no.stemmer=function(){var r=e.stemmerSupport.Among,n=e.stemmerSupport.SnowballProgram,i=new function(){function e(){var e,r=w.cursor+3;if(a=w.limit,0<=r||r<=w.limit){for(s=r;;){if(e=w.cursor,w.in_grouping(d,97,248)){w.cursor=e;break}if(e>=w.limit)return;w.cursor=e+1}for(;!w.out_grouping(d,97,248);){if(w.cursor>=w.limit)return;w.cursor++}a=w.cursor,a<s&&(a=s)}}function i(){var e,r,n;if(w.cursor>=a&&(r=w.limit_backward,w.limit_backward=a,w.ket=w.cursor,e=w.find_among_b(m,29),w.limit_backward=r,e))switch(w.bra=w.cursor,e){case 1:w.slice_del();break;case 2:n=w.limit-w.cursor,w.in_grouping_b(c,98,122)?w.slice_del():(w.cursor=w.limit-n,w.eq_s_b(1,"k")&&w.out_grouping_b(d,97,248)&&w.slice_del());break;case 3:w.slice_from("er")}}function t(){var e,r=w.limit-w.cursor;w.cursor>=a&&(e=w.limit_backward,w.limit_backward=a,w.ket=w.cursor,w.find_among_b(u,2)?(w.bra=w.cursor,w.limit_backward=e,w.cursor=w.limit-r,w.cursor>w.limit_backward&&(w.cursor--,w.bra=w.cursor,w.slice_del())):w.limit_backward=e)}function o(){var e,r;w.cursor>=a&&(r=w.limit_backward,w.limit_backward=a,w.ket=w.cursor,e=w.find_among_b(l,11),e?(w.bra=w.cursor,w.limit_backward=r,1==e&&w.slice_del()):w.limit_backward=r)}var s,a,m=[new r("a",-1,1),new r("e",-1,1),new r("ede",1,1),new r("ande",1,1),new r("ende",1,1),new r("ane",1,1),new r("ene",1,1),new r("hetene",6,1),new r("erte",1,3),new r("en",-1,1),new r("heten",9,1),new r("ar",-1,1),new r("er",-1,1),new r("heter",12,1),new r("s",-1,2),new r("as",14,1),new r("es",14,1),new r("edes",16,1),new r("endes",16,1),new r("enes",16,1),new r("hetenes",19,1),new r("ens",14,1),new r("hetens",21,1),new r("ers",14,1),new r("ets",14,1),new r("et",-1,1),new r("het",25,1),new r("ert",-1,3),new r("ast",-1,1)],u=[new r("dt",-1,-1),new r("vt",-1,-1)],l=[new r("leg",-1,1),new r("eleg",0,1),new r("ig",-1,1),new r("eig",2,1),new r("lig",2,1),new r("elig",4,1),new r("els",-1,1),new r("lov",-1,1),new r("elov",7,1),new r("slov",7,1),new r("hetslov",9,1)],d=[17,65,16,1,0,0,0,0,0,0,0,0,0,0,0,0,48,0,128],c=[119,125,149,1],w=new n;this.setCurrent=function(e){w.setCurrent(e)},this.getCurrent=function(){return w.getCurrent()},this.stem=function(){var r=w.cursor;return e(),w.limit_backward=r,w.cursor=w.limit,i(),w.cursor=w.limit,t(),w.cursor=w.limit,o(),!0}};return function(e){return"function"==typeof e.update?e.update(function(e){return i.setCurrent(e),i.stem(),i.getCurrent()}):(i.setCurrent(e),i.stem(),i.getCurrent())}}(),e.Pipeline.registerFunction(e.no.stemmer,"stemmer-no"),e.no.stopWordFilter=e.generateStopWordFilter("alle at av bare begge ble blei bli blir blitt både båe da de deg dei deim deira deires dem den denne der dere deres det dette di din disse ditt du dykk dykkar då eg ein eit eitt eller elles en enn er et ett etter for fordi fra før ha hadde han hans har hennar henne hennes her hjå ho hoe honom hoss hossen hun hva hvem hver hvilke hvilken hvis hvor hvordan hvorfor i ikke ikkje ikkje ingen ingi inkje inn inni ja jeg kan kom korleis korso kun kunne kva kvar kvarhelst kven kvi kvifor man mange me med medan meg meget mellom men mi min mine mitt mot mykje ned no noe noen noka noko nokon nokor nokre nå når og også om opp oss over på samme seg selv si si sia sidan siden sin sine sitt sjøl skal skulle slik so som som somme somt så sånn til um upp ut uten var vart varte ved vere verte vi vil ville vore vors vort vår være være vært å".split(" ")),e.Pipeline.registerFunction(e.no.stopWordFilter,"stopWordFilter-no")}});

assets/javascripts/lunr/min/lunr.sa.min.js

@@ -1 +0,0 @@
-!function(e,r){"function"==typeof define&&define.amd?define(r):"object"==typeof exports?module.exports=r():r()(e.lunr)}(this,function(){return function(e){if(void 0===e)throw new Error("Lunr is not present. Please include / require Lunr before this script.");if(void 0===e.stemmerSupport)throw new Error("Lunr stemmer support is not present. Please include / require Lunr stemmer support before this script.");e.sa=function(){this.pipeline.reset(),this.pipeline.add(e.sa.trimmer,e.sa.stopWordFilter,e.sa.stemmer),this.searchPipeline&&(this.searchPipeline.reset(),this.searchPipeline.add(e.sa.stemmer))},e.sa.wordCharacters="ऀ-ःऄ-एऐ-टठ-यर-िी-ॏॐ-य़ॠ-९॰-ॿ꣠-꣱ꣲ-ꣷ꣸-ꣻ꣼-ꣽꣾ-ꣿᆰ0-ᆰ9",e.sa.trimmer=e.trimmerSupport.generateTrimmer(e.sa.wordCharacters),e.Pipeline.registerFunction(e.sa.trimmer,"trimmer-sa"),e.sa.stopWordFilter=e.generateStopWordFilter('तथा अयम्‌ एकम्‌ इत्यस्मिन्‌ तथा तत्‌ वा अयम्‌ इत्यस्य ते आहूत उपरि तेषाम्‌  किन्तु तेषाम्‌ तदा इत्यनेन अधिकः इत्यस्य तत्‌ केचन बहवः द्वि तथा महत्वपूर्णः अयम्‌ अस्य  विषये अयं अस्ति तत्‌ प्रथमः विषये इत्युपरि इत्युपरि इतर अधिकतमः अधिकः अपि सामान्यतया ठ इतरेतर नूतनम्‌ द  न्यूनम्‌ कश्चित्‌ वा विशालः द  सः अस्ति तदनुसारम् तत्र अस्ति केवलम्‌ अपि अत्र सर्वे विविधाः तत्‌ बहवः यतः इदानीम्‌ द  दक्षिण इत्यस्मै तस्य उपरि नथ अतीव कार्यम्‌ सर्वे एकैकम्‌ इत्यादि। एते सन्ति  उत इत्थम्‌ मध्ये एतदर्थं . स कस्य प्रथमः श्री. करोति अस्मिन् प्रकारः निर्मिता कालः तत्र कर्तुं  समान अधुना ते सन्ति स एकः अस्ति सः अर्थात् तेषां कृते . स्थितम्  विशेषः अग्रिम तेषाम्‌ समान स्रोतः ख म समान इदानीमपि अधिकतया करोतु ते समान इत्यस्य वीथी सह यस्मिन्  कृतवान्‌ धृतः तदा पुनः पूर्वं सः आगतः किम्‌ कुल इतर पुरा  मात्रा स विषये उ अतएव अपि नगरस्य  उपरि यतः प्रतिशतं  कतरः कालः साधनानि भूत तथापि जात सम्बन्धि अन्यत्‌ ग अतः अस्माकं स्वकीयाः अस्माकं इदानीं अन्तः इत्यादयः भवन्तः इत्यादयः एते एताः तस्य अस्य इदम् एते तेषां तेषां तेषां तान् तेषां तेषां तेषां समानः सः एकः च तादृशाः बहवः अन्ये च वदन्ति यत् कियत् कस्मै  कस्मै  यस्मै  यस्मै  यस्मै  यस्मै न अतिनीचः किन्तु प्रथमं सम्पूर्णतया  ततः चिरकालानन्तरं पुस्तकं सम्पूर्णतया अन्तः  किन्तु अत्र वा इह इव श्रद्धाय अवशिष्यते  परन्तु अन्ये वर्गाः सन्ति ते सन्ति शक्नुवन्ति सर्वे मिलित्वा सर्वे एकत्र"'.split(" ")),e.sa.stemmer=function(){return function(e){return"function"==typeof e.update?e.update(function(e){return e}):e}}();var r=e.wordcut;r.init(),e.sa.tokenizer=function(t){if(!arguments.length||null==t||void 0==t)return[];if(Array.isArray(t))return t.map(function(r){return isLunr2?new e.Token(r.toLowerCase()):r.toLowerCase()});var i=t.toString().toLowerCase().replace(/^\s+/,"");return r.cut(i).split("|")},e.Pipeline.registerFunction(e.sa.stemmer,"stemmer-sa"),e.Pipeline.registerFunction(e.sa.stopWordFilter,"stopWordFilter-sa")}});

assets/javascripts/lunr/min/lunr.stemmer.support.min.js

@@ -1 +0,0 @@
-!function(r,t){"function"==typeof define&&define.amd?define(t):"object"==typeof exports?module.exports=t():t()(r.lunr)}(this,function(){return function(r){r.stemmerSupport={Among:function(r,t,i,s){if(this.toCharArray=function(r){for(var t=r.length,i=new Array(t),s=0;s<t;s++)i[s]=r.charCodeAt(s);return i},!r&&""!=r||!t&&0!=t||!i)throw"Bad Among initialisation: s:"+r+", substring_i: "+t+", result: "+i;this.s_size=r.length,this.s=this.toCharArray(r),this.substring_i=t,this.result=i,this.method=s},SnowballProgram:function(){var r;return{bra:0,ket:0,limit:0,cursor:0,limit_backward:0,setCurrent:function(t){r=t,this.cursor=0,this.limit=t.length,this.limit_backward=0,this.bra=this.cursor,this.ket=this.limit},getCurrent:function(){var t=r;return r=null,t},in_grouping:function(t,i,s){if(this.cursor<this.limit){var e=r.charCodeAt(this.cursor);if(e<=s&&e>=i&&(e-=i,t[e>>3]&1<<(7&e)))return this.cursor++,!0}return!1},in_grouping_b:function(t,i,s){if(this.cursor>this.limit_backward){var e=r.charCodeAt(this.cursor-1);if(e<=s&&e>=i&&(e-=i,t[e>>3]&1<<(7&e)))return this.cursor--,!0}return!1},out_grouping:function(t,i,s){if(this.cursor<this.limit){var e=r.charCodeAt(this.cursor);if(e>s||e<i)return this.cursor++,!0;if(e-=i,!(t[e>>3]&1<<(7&e)))return this.cursor++,!0}return!1},out_grouping_b:function(t,i,s){if(this.cursor>this.limit_backward){var e=r.charCodeAt(this.cursor-1);if(e>s||e<i)return this.cursor--,!0;if(e-=i,!(t[e>>3]&1<<(7&e)))return this.cursor--,!0}return!1},eq_s:function(t,i){if(this.limit-this.cursor<t)return!1;for(var s=0;s<t;s++)if(r.charCodeAt(this.cursor+s)!=i.charCodeAt(s))return!1;return this.cursor+=t,!0},eq_s_b:function(t,i){if(this.cursor-this.limit_backward<t)return!1;for(var s=0;s<t;s++)if(r.charCodeAt(this.cursor-t+s)!=i.charCodeAt(s))return!1;return this.cursor-=t,!0},find_among:function(t,i){for(var s=0,e=i,n=this.cursor,u=this.limit,o=0,h=0,c=!1;;){for(var a=s+(e-s>>1),f=0,l=o<h?o:h,_=t[a],m=l;m<_.s_size;m++){if(n+l==u){f=-1;break}if(f=r.charCodeAt(n+l)-_.s[m])break;l++}if(f<0?(e=a,h=l):(s=a,o=l),e-s<=1){if(s>0||e==s||c)break;c=!0}}for(;;){var _=t[s];if(o>=_.s_size){if(this.cursor=n+_.s_size,!_.method)return _.result;var b=_.method();if(this.cursor=n+_.s_size,b)return _.result}if((s=_.substring_i)<0)return 0}},find_among_b:function(t,i){for(var s=0,e=i,n=this.cursor,u=this.limit_backward,o=0,h=0,c=!1;;){for(var a=s+(e-s>>1),f=0,l=o<h?o:h,_=t[a],m=_.s_size-1-l;m>=0;m--){if(n-l==u){f=-1;break}if(f=r.charCodeAt(n-1-l)-_.s[m])break;l++}if(f<0?(e=a,h=l):(s=a,o=l),e-s<=1){if(s>0||e==s||c)break;c=!0}}for(;;){var _=t[s];if(o>=_.s_size){if(this.cursor=n-_.s_size,!_.method)return _.result;var b=_.method();if(this.cursor=n-_.s_size,b)return _.result}if((s=_.substring_i)<0)return 0}},replace_s:function(t,i,s){var e=s.length-(i-t),n=r.substring(0,t),u=r.substring(i);return r=n+s+u,this.limit+=e,this.cursor>=i?this.cursor+=e:this.cursor>t&&(this.cursor=t),e},slice_check:function(){if(this.bra<0||this.bra>this.ket||this.ket>this.limit||this.limit>r.length)throw"faulty slice operation"},slice_from:function(r){this.slice_check(),this.replace_s(this.bra,this.ket,r)},slice_del:function(){this.slice_from("")},insert:function(r,t,i){var s=this.replace_s(r,t,i);r<=this.bra&&(this.bra+=s),r<=this.ket&&(this.ket+=s)},slice_to:function(){return this.slice_check(),r.substring(this.bra,this.ket)},eq_v_b:function(r){return this.eq_s_b(r.length,r)}}}},r.trimmerSupport={generateTrimmer:function(r){var t=new RegExp("^[^"+r+"]+"),i=new RegExp("[^"+r+"]+$");return function(r){return"function"==typeof r.update?r.update(function(r){return r.replace(t,"").replace(i,"")}):r.replace(t,"").replace(i,"")}}}}});

assets/javascripts/lunr/min/lunr.sv.min.js

@@ -1,18 +0,0 @@
-/*!
- * Lunr languages, `Swedish` language
- * https://github.com/MihaiValentin/lunr-languages
- *
- * Copyright 2014, Mihai Valentin
- * http://www.mozilla.org/MPL/
- */
-/*!
- * based on
- * Snowball JavaScript Library v0.3
- * http://code.google.com/p/urim/
- * http://snowball.tartarus.org/
- *
- * Copyright 2010, Oleg Mazko
- * http://www.mozilla.org/MPL/
- */
-
-!function(e,r){"function"==typeof define&&define.amd?define(r):"object"==typeof exports?module.exports=r():r()(e.lunr)}(this,function(){return function(e){if(void 0===e)throw new Error("Lunr is not present. Please include / require Lunr before this script.");if(void 0===e.stemmerSupport)throw new Error("Lunr stemmer support is not present. Please include / require Lunr stemmer support before this script.");e.sv=function(){this.pipeline.reset(),this.pipeline.add(e.sv.trimmer,e.sv.stopWordFilter,e.sv.stemmer),this.searchPipeline&&(this.searchPipeline.reset(),this.searchPipeline.add(e.sv.stemmer))},e.sv.wordCharacters="A-Za-zªºÀ-ÖØ-öø-ʸˠ-ˤᴀ-ᴥᴬ-ᵜᵢ-ᵥᵫ-ᵷᵹ-ᶾḀ-ỿⁱⁿₐ-ₜKÅℲⅎⅠ-ↈⱠ-ⱿꜢ-ꞇꞋ-ꞭꞰ-ꞷꟷ-ꟿꬰ-ꭚꭜ-ꭤff-stＡ-Ｚａ-ｚ",e.sv.trimmer=e.trimmerSupport.generateTrimmer(e.sv.wordCharacters),e.Pipeline.registerFunction(e.sv.trimmer,"trimmer-sv"),e.sv.stemmer=function(){var r=e.stemmerSupport.Among,n=e.stemmerSupport.SnowballProgram,t=new function(){function e(){var e,r=w.cursor+3;if(o=w.limit,0<=r||r<=w.limit){for(a=r;;){if(e=w.cursor,w.in_grouping(l,97,246)){w.cursor=e;break}if(w.cursor=e,w.cursor>=w.limit)return;w.cursor++}for(;!w.out_grouping(l,97,246);){if(w.cursor>=w.limit)return;w.cursor++}o=w.cursor,o<a&&(o=a)}}function t(){var e,r=w.limit_backward;if(w.cursor>=o&&(w.limit_backward=o,w.cursor=w.limit,w.ket=w.cursor,e=w.find_among_b(u,37),w.limit_backward=r,e))switch(w.bra=w.cursor,e){case 1:w.slice_del();break;case 2:w.in_grouping_b(d,98,121)&&w.slice_del()}}function i(){var e=w.limit_backward;w.cursor>=o&&(w.limit_backward=o,w.cursor=w.limit,w.find_among_b(c,7)&&(w.cursor=w.limit,w.ket=w.cursor,w.cursor>w.limit_backward&&(w.bra=--w.cursor,w.slice_del())),w.limit_backward=e)}function s(){var e,r;if(w.cursor>=o){if(r=w.limit_backward,w.limit_backward=o,w.cursor=w.limit,w.ket=w.cursor,e=w.find_among_b(m,5))switch(w.bra=w.cursor,e){case 1:w.slice_del();break;case 2:w.slice_from("lös");break;case 3:w.slice_from("full")}w.limit_backward=r}}var a,o,u=[new r("a",-1,1),new r("arna",0,1),new r("erna",0,1),new r("heterna",2,1),new r("orna",0,1),new r("ad",-1,1),new r("e",-1,1),new r("ade",6,1),new r("ande",6,1),new r("arne",6,1),new r("are",6,1),new r("aste",6,1),new r("en",-1,1),new r("anden",12,1),new r("aren",12,1),new r("heten",12,1),new r("ern",-1,1),new r("ar",-1,1),new r("er",-1,1),new r("heter",18,1),new r("or",-1,1),new r("s",-1,2),new r("as",21,1),new r("arnas",22,1),new r("ernas",22,1),new r("ornas",22,1),new r("es",21,1),new r("ades",26,1),new r("andes",26,1),new r("ens",21,1),new r("arens",29,1),new r("hetens",29,1),new r("erns",21,1),new r("at",-1,1),new r("andet",-1,1),new r("het",-1,1),new r("ast",-1,1)],c=[new r("dd",-1,-1),new r("gd",-1,-1),new r("nn",-1,-1),new r("dt",-1,-1),new r("gt",-1,-1),new r("kt",-1,-1),new r("tt",-1,-1)],m=[new r("ig",-1,1),new r("lig",0,1),new r("els",-1,1),new r("fullt",-1,3),new r("löst",-1,2)],l=[17,65,16,1,0,0,0,0,0,0,0,0,0,0,0,0,24,0,32],d=[119,127,149],w=new n;this.setCurrent=function(e){w.setCurrent(e)},this.getCurrent=function(){return w.getCurrent()},this.stem=function(){var r=w.cursor;return e(),w.limit_backward=r,w.cursor=w.limit,t(),w.cursor=w.limit,i(),w.cursor=w.limit,s(),!0}};return function(e){return"function"==typeof e.update?e.update(function(e){return t.setCurrent(e),t.stem(),t.getCurrent()}):(t.setCurrent(e),t.stem(),t.getCurrent())}}(),e.Pipeline.registerFunction(e.sv.stemmer,"stemmer-sv"),e.sv.stopWordFilter=e.generateStopWordFilter("alla allt att av blev bli blir blivit de dem den denna deras dess dessa det detta dig din dina ditt du där då efter ej eller en er era ert ett från för ha hade han hans har henne hennes hon honom hur här i icke ingen inom inte jag ju kan kunde man med mellan men mig min mina mitt mot mycket ni nu när någon något några och om oss på samma sedan sig sin sina sitta själv skulle som så sådan sådana sådant till under upp ut utan vad var vara varför varit varje vars vart vem vi vid vilka vilkas vilken vilket vår våra vårt än är åt över".split(" ")),e.Pipeline.registerFunction(e.sv.stopWordFilter,"stopWordFilter-sv")}});

assets/javascripts/lunr/min/lunr.ta.min.js

@@ -1 +0,0 @@
-!function(e,t){"function"==typeof define&&define.amd?define(t):"object"==typeof exports?module.exports=t():t()(e.lunr)}(this,function(){return function(e){if(void 0===e)throw new Error("Lunr is not present. Please include / require Lunr before this script.");if(void 0===e.stemmerSupport)throw new Error("Lunr stemmer support is not present. Please include / require Lunr stemmer support before this script.");e.ta=function(){this.pipeline.reset(),this.pipeline.add(e.ta.trimmer,e.ta.stopWordFilter,e.ta.stemmer),this.searchPipeline&&(this.searchPipeline.reset(),this.searchPipeline.add(e.ta.stemmer))},e.ta.wordCharacters="஀-உஊ-ஏஐ-ஙச-ட஠-னப-யர-ஹ஺-ிீ-௉ொ-௏ௐ-௙௚-௟௠-௩௪-௯௰-௹௺-௿a-zA-Zａ-ｚＡ-Ｚ0-9０-９",e.ta.trimmer=e.trimmerSupport.generateTrimmer(e.ta.wordCharacters),e.Pipeline.registerFunction(e.ta.trimmer,"trimmer-ta"),e.ta.stopWordFilter=e.generateStopWordFilter("அங்கு அங்கே அது அதை அந்த அவர் அவர்கள் அவள் அவன் அவை ஆக ஆகவே ஆகையால் ஆதலால் ஆதலினால் ஆனாலும் ஆனால் இங்கு இங்கே இது இதை இந்த இப்படி இவர் இவர்கள் இவள் இவன் இவை இவ்வளவு உனக்கு உனது உன் உன்னால் எங்கு எங்கே எது எதை எந்த எப்படி எவர் எவர்கள் எவள் எவன் எவை எவ்வளவு எனக்கு எனது எனவே என் என்ன என்னால் ஏது ஏன் தனது தன்னால் தானே தான் நாங்கள் நாம் நான் நீ நீங்கள்".split(" ")),e.ta.stemmer=function(){return function(e){return"function"==typeof e.update?e.update(function(e){return e}):e}}();var t=e.wordcut;t.init(),e.ta.tokenizer=function(r){if(!arguments.length||null==r||void 0==r)return[];if(Array.isArray(r))return r.map(function(t){return isLunr2?new e.Token(t.toLowerCase()):t.toLowerCase()});var i=r.toString().toLowerCase().replace(/^\s+/,"");return t.cut(i).split("|")},e.Pipeline.registerFunction(e.ta.stemmer,"stemmer-ta"),e.Pipeline.registerFunction(e.ta.stopWordFilter,"stopWordFilter-ta")}});

assets/javascripts/lunr/min/lunr.te.min.js

@@ -1 +0,0 @@
-!function(e,t){"function"==typeof define&&define.amd?define(t):"object"==typeof exports?module.exports=t():t()(e.lunr)}(this,function(){return function(e){if(void 0===e)throw new Error("Lunr is not present. Please include / require Lunr before this script.");if(void 0===e.stemmerSupport)throw new Error("Lunr stemmer support is not present. Please include / require Lunr stemmer support before this script.");e.te=function(){this.pipeline.reset(),this.pipeline.add(e.te.trimmer,e.te.stopWordFilter,e.te.stemmer),this.searchPipeline&&(this.searchPipeline.reset(),this.searchPipeline.add(e.te.stemmer))},e.te.wordCharacters="ఀ-ఄఅ-ఔక-హా-ౌౕ-ౖౘ-ౚౠ-ౡౢ-ౣ౦-౯౸-౿఼ఽ్ౝ౷౤౥",e.te.trimmer=e.trimmerSupport.generateTrimmer(e.te.wordCharacters),e.Pipeline.registerFunction(e.te.trimmer,"trimmer-te"),e.te.stopWordFilter=e.generateStopWordFilter("అందరూ అందుబాటులో అడగండి అడగడం అడ్డంగా అనుగుణంగా అనుమతించు అనుమతిస్తుంది అయితే ఇప్పటికే ఉన్నారు ఎక్కడైనా ఎప్పుడు ఎవరైనా ఎవరో ఏ ఏదైనా ఏమైనప్పటికి ఒక ఒకరు కనిపిస్తాయి కాదు కూడా గా గురించి చుట్టూ చేయగలిగింది తగిన తర్వాత దాదాపు దూరంగా నిజంగా పై ప్రకారం ప్రక్కన మధ్య మరియు మరొక మళ్ళీ మాత్రమే మెచ్చుకో వద్ద వెంట వేరుగా వ్యతిరేకంగా సంబంధం".split(" ")),e.te.stemmer=function(){return function(e){return"function"==typeof e.update?e.update(function(e){return e}):e}}();var t=e.wordcut;t.init(),e.te.tokenizer=function(r){if(!arguments.length||null==r||void 0==r)return[];if(Array.isArray(r))return r.map(function(t){return isLunr2?new e.Token(t.toLowerCase()):t.toLowerCase()});var i=r.toString().toLowerCase().replace(/^\s+/,"");return t.cut(i).split("|")},e.Pipeline.registerFunction(e.te.stemmer,"stemmer-te"),e.Pipeline.registerFunction(e.te.stopWordFilter,"stopWordFilter-te")}});

assets/javascripts/lunr/min/lunr.th.min.js

@@ -1 +0,0 @@
-!function(e,r){"function"==typeof define&&define.amd?define(r):"object"==typeof exports?module.exports=r():r()(e.lunr)}(this,function(){return function(e){if(void 0===e)throw new Error("Lunr is not present. Please include / require Lunr before this script.");if(void 0===e.stemmerSupport)throw new Error("Lunr stemmer support is not present. Please include / require Lunr stemmer support before this script.");var r="2"==e.version[0];e.th=function(){this.pipeline.reset(),this.pipeline.add(e.th.trimmer),r?this.tokenizer=e.th.tokenizer:(e.tokenizer&&(e.tokenizer=e.th.tokenizer),this.tokenizerFn&&(this.tokenizerFn=e.th.tokenizer))},e.th.wordCharacters="[฀-๿]",e.th.trimmer=e.trimmerSupport.generateTrimmer(e.th.wordCharacters),e.Pipeline.registerFunction(e.th.trimmer,"trimmer-th");var t=e.wordcut;t.init(),e.th.tokenizer=function(i){if(!arguments.length||null==i||void 0==i)return[];if(Array.isArray(i))return i.map(function(t){return r?new e.Token(t):t});var n=i.toString().replace(/^\s+/,"");return t.cut(n).split("|")}}});

assets/javascripts/lunr/min/lunr.vi.min.js

@@ -1 +0,0 @@
-!function(e,r){"function"==typeof define&&define.amd?define(r):"object"==typeof exports?module.exports=r():r()(e.lunr)}(this,function(){return function(e){if(void 0===e)throw new Error("Lunr is not present. Please include / require Lunr before this script.");if(void 0===e.stemmerSupport)throw new Error("Lunr stemmer support is not present. Please include / require Lunr stemmer support before this script.");e.vi=function(){this.pipeline.reset(),this.pipeline.add(e.vi.stopWordFilter,e.vi.trimmer)},e.vi.wordCharacters="[A-Za-ẓ̀͐́͑̉̃̓ÂâÊêÔôĂ-ăĐ-đƠ-ơƯ-ư]",e.vi.trimmer=e.trimmerSupport.generateTrimmer(e.vi.wordCharacters),e.Pipeline.registerFunction(e.vi.trimmer,"trimmer-vi"),e.vi.stopWordFilter=e.generateStopWordFilter("là cái nhưng mà".split(" "))}});

assets/javascripts/lunr/min/lunr.zh.min.js

@@ -1 +0,0 @@
-!function(e,r){"function"==typeof define&&define.amd?define(r):"object"==typeof exports?module.exports=r(require("@node-rs/jieba")):r()(e.lunr)}(this,function(e){return function(r,t){if(void 0===r)throw new Error("Lunr is not present. Please include / require Lunr before this script.");if(void 0===r.stemmerSupport)throw new Error("Lunr stemmer support is not present. Please include / require Lunr stemmer support before this script.");var i="2"==r.version[0];r.zh=function(){this.pipeline.reset(),this.pipeline.add(r.zh.trimmer,r.zh.stopWordFilter,r.zh.stemmer),i?this.tokenizer=r.zh.tokenizer:(r.tokenizer&&(r.tokenizer=r.zh.tokenizer),this.tokenizerFn&&(this.tokenizerFn=r.zh.tokenizer))},r.zh.tokenizer=function(n){if(!arguments.length||null==n||void 0==n)return[];if(Array.isArray(n))return n.map(function(e){return i?new r.Token(e.toLowerCase()):e.toLowerCase()});t&&e.load(t);var o=n.toString().trim().toLowerCase(),s=[];e.cut(o,!0).forEach(function(e){s=s.concat(e.split(" "))}),s=s.filter(function(e){return!!e});var u=0;return s.map(function(e,t){if(i){var n=o.indexOf(e,u),s={};return s.position=[n,e.length],s.index=t,u=n,new r.Token(e,s)}return e})},r.zh.wordCharacters="\\w一-龥",r.zh.trimmer=r.trimmerSupport.generateTrimmer(r.zh.wordCharacters),r.Pipeline.registerFunction(r.zh.trimmer,"trimmer-zh"),r.zh.stemmer=function(){return function(e){return e}}(),r.Pipeline.registerFunction(r.zh.stemmer,"stemmer-zh"),r.zh.stopWordFilter=r.generateStopWordFilter("的 一 不 在 人 有 是 为 為 以 于 於 上 他 而 后 後 之 来 來 及 了 因 下 可 到 由 这 這 与 與 也 此 但 并 並 个 個 其 已 无 無 小 我 们 們 起 最 再 今 去 好 只 又 或 很 亦 某 把 那 你 乃 它 吧 被 比 别 趁 当 當 从 從 得 打 凡 儿 兒 尔 爾 该 該 各 给 給 跟 和 何 还 還 即 几 幾 既 看 据 據 距 靠 啦 另 么 麽 每 嘛 拿 哪 您 凭 憑 且 却 卻 让 讓 仍 啥 如 若 使 谁 誰 虽 雖 随 隨 同 所 她 哇 嗡 往 些 向 沿 哟 喲 用 咱 则 則 怎 曾 至 致 着 著 诸 諸 自".split(" ")),r.Pipeline.registerFunction(r.zh.stopWordFilter,"stopWordFilter-zh")}});

assets/javascripts/lunr/tinyseg.js

@@ -1,206 +0,0 @@
-/**
- * export the module via AMD, CommonJS or as a browser global
- * Export code from https://github.com/umdjs/umd/blob/master/returnExports.js
- */
-;(function (root, factory) {
-    if (typeof define === 'function' && define.amd) {
-        // AMD. Register as an anonymous module.
-        define(factory)
-    } else if (typeof exports === 'object') {
-        /**
-         * Node. Does not work with strict CommonJS, but
-         * only CommonJS-like environments that support module.exports,
-         * like Node.
-         */
-        module.exports = factory()
-    } else {
-        // Browser globals (root is window)
-        factory()(root.lunr);
-    }
-}(this, function () {
-    /**
-     * Just return a value to define the module export.
-     * This example returns an object, but the module
-     * can return a function as the exported value.
-     */
-
-    return function(lunr) {
-        // TinySegmenter 0.1 -- Super compact Japanese tokenizer in Javascript
-        // (c) 2008 Taku Kudo <taku@chasen.org>
-        // TinySegmenter is freely distributable under the terms of a new BSD licence.
-        // For details, see http://chasen.org/~taku/software/TinySegmenter/LICENCE.txt
-
-        function TinySegmenter() {
-          var patterns = {
-            "[一二三四五六七八九十百千万億兆]":"M",
-            "[一-龠々〆ヵヶ]":"H",
-            "[ぁ-ん]":"I",
-            "[ァ-ヴーｱ-ﾝﾞｰ]":"K",
-            "[a-zA-Zａ-ｚＡ-Ｚ]":"A",
-            "[0-9０-９]":"N"
-          }
-          this.chartype_ = [];
-          for (var i in patterns) {
-            var regexp = new RegExp(i);
-            this.chartype_.push([regexp, patterns[i]]);
-          }
-
-          this.BIAS__ = -332
-          this.BC1__ = {"HH":6,"II":2461,"KH":406,"OH":-1378};
-          this.BC2__ = {"AA":-3267,"AI":2744,"AN":-878,"HH":-4070,"HM":-1711,"HN":4012,"HO":3761,"IA":1327,"IH":-1184,"II":-1332,"IK":1721,"IO":5492,"KI":3831,"KK":-8741,"MH":-3132,"MK":3334,"OO":-2920};
-          this.BC3__ = {"HH":996,"HI":626,"HK":-721,"HN":-1307,"HO":-836,"IH":-301,"KK":2762,"MK":1079,"MM":4034,"OA":-1652,"OH":266};
-          this.BP1__ = {"BB":295,"OB":304,"OO":-125,"UB":352};
-          this.BP2__ = {"BO":60,"OO":-1762};
-          this.BQ1__ = {"BHH":1150,"BHM":1521,"BII":-1158,"BIM":886,"BMH":1208,"BNH":449,"BOH":-91,"BOO":-2597,"OHI":451,"OIH":-296,"OKA":1851,"OKH":-1020,"OKK":904,"OOO":2965};
-          this.BQ2__ = {"BHH":118,"BHI":-1159,"BHM":466,"BIH":-919,"BKK":-1720,"BKO":864,"OHH":-1139,"OHM":-181,"OIH":153,"UHI":-1146};
-          this.BQ3__ = {"BHH":-792,"BHI":2664,"BII":-299,"BKI":419,"BMH":937,"BMM":8335,"BNN":998,"BOH":775,"OHH":2174,"OHM":439,"OII":280,"OKH":1798,"OKI":-793,"OKO":-2242,"OMH":-2402,"OOO":11699};
-          this.BQ4__ = {"BHH":-3895,"BIH":3761,"BII":-4654,"BIK":1348,"BKK":-1806,"BMI":-3385,"BOO":-12396,"OAH":926,"OHH":266,"OHK":-2036,"ONN":-973};
-          this.BW1__ = {",と":660,",同":727,"B1あ":1404,"B1同":542,"、と":660,"、同":727,"」と":1682,"あっ":1505,"いう":1743,"いっ":-2055,"いる":672,"うし":-4817,"うん":665,"から":3472,"がら":600,"こう":-790,"こと":2083,"こん":-1262,"さら":-4143,"さん":4573,"した":2641,"して":1104,"すで":-3399,"そこ":1977,"それ":-871,"たち":1122,"ため":601,"った":3463,"つい":-802,"てい":805,"てき":1249,"でき":1127,"です":3445,"では":844,"とい":-4915,"とみ":1922,"どこ":3887,"ない":5713,"なっ":3015,"など":7379,"なん":-1113,"にし":2468,"には":1498,"にも":1671,"に対":-912,"の一":-501,"の中":741,"ませ":2448,"まで":1711,"まま":2600,"まる":-2155,"やむ":-1947,"よっ":-2565,"れた":2369,"れで":-913,"をし":1860,"を見":731,"亡く":-1886,"京都":2558,"取り":-2784,"大き":-2604,"大阪":1497,"平方":-2314,"引き":-1336,"日本":-195,"本当":-2423,"毎日":-2113,"目指":-724,"Ｂ１あ":1404,"Ｂ１同":542,"｣と":1682};
-          this.BW2__ = {"..":-11822,"11":-669,"――":-5730,"−−":-13175,"いう":-1609,"うか":2490,"かし":-1350,"かも":-602,"から":-7194,"かれ":4612,"がい":853,"がら":-3198,"きた":1941,"くな":-1597,"こと":-8392,"この":-4193,"させ":4533,"され":13168,"さん":-3977,"しい":-1819,"しか":-545,"した":5078,"して":972,"しな":939,"その":-3744,"たい":-1253,"たた":-662,"ただ":-3857,"たち":-786,"たと":1224,"たは":-939,"った":4589,"って":1647,"っと":-2094,"てい":6144,"てき":3640,"てく":2551,"ては":-3110,"ても":-3065,"でい":2666,"でき":-1528,"でし":-3828,"です":-4761,"でも":-4203,"とい":1890,"とこ":-1746,"とと":-2279,"との":720,"とみ":5168,"とも":-3941,"ない":-2488,"なが":-1313,"など":-6509,"なの":2614,"なん":3099,"にお":-1615,"にし":2748,"にな":2454,"によ":-7236,"に対":-14943,"に従":-4688,"に関":-11388,"のか":2093,"ので":-7059,"のに":-6041,"のの":-6125,"はい":1073,"はが":-1033,"はず":-2532,"ばれ":1813,"まし":-1316,"まで":-6621,"まれ":5409,"めて":-3153,"もい":2230,"もの":-10713,"らか":-944,"らし":-1611,"らに":-1897,"りし":651,"りま":1620,"れた":4270,"れて":849,"れば":4114,"ろう":6067,"われ":7901,"を通":-11877,"んだ":728,"んな":-4115,"一人":602,"一方":-1375,"一日":970,"一部":-1051,"上が":-4479,"会社":-1116,"出て":2163,"分の":-7758,"同党":970,"同日":-913,"大阪":-2471,"委員":-1250,"少な":-1050,"年度":-8669,"年間":-1626,"府県":-2363,"手権":-1982,"新聞":-4066,"日新":-722,"日本":-7068,"日米":3372,"曜日":-601,"朝鮮":-2355,"本人":-2697,"東京":-1543,"然と":-1384,"社会":-1276,"立て":-990,"第に":-1612,"米国":-4268,"１１":-669};
-          this.BW3__ = {"あた":-2194,"あり":719,"ある":3846,"い.":-1185,"い。":-1185,"いい":5308,"いえ":2079,"いく":3029,"いた":2056,"いっ":1883,"いる":5600,"いわ":1527,"うち":1117,"うと":4798,"えと":1454,"か.":2857,"か。":2857,"かけ":-743,"かっ":-4098,"かに":-669,"から":6520,"かり":-2670,"が,":1816,"が、":1816,"がき":-4855,"がけ":-1127,"がっ":-913,"がら":-4977,"がり":-2064,"きた":1645,"けど":1374,"こと":7397,"この":1542,"ころ":-2757,"さい":-714,"さを":976,"し,":1557,"し、":1557,"しい":-3714,"した":3562,"して":1449,"しな":2608,"しま":1200,"す.":-1310,"す。":-1310,"する":6521,"ず,":3426,"ず、":3426,"ずに":841,"そう":428,"た.":8875,"た。":8875,"たい":-594,"たの":812,"たり":-1183,"たる":-853,"だ.":4098,"だ。":4098,"だっ":1004,"った":-4748,"って":300,"てい":6240,"てお":855,"ても":302,"です":1437,"でに":-1482,"では":2295,"とう":-1387,"とし":2266,"との":541,"とも":-3543,"どう":4664,"ない":1796,"なく":-903,"など":2135,"に,":-1021,"に、":-1021,"にし":1771,"にな":1906,"には":2644,"の,":-724,"の、":-724,"の子":-1000,"は,":1337,"は、":1337,"べき":2181,"まし":1113,"ます":6943,"まっ":-1549,"まで":6154,"まれ":-793,"らし":1479,"られ":6820,"るる":3818,"れ,":854,"れ、":854,"れた":1850,"れて":1375,"れば":-3246,"れる":1091,"われ":-605,"んだ":606,"んで":798,"カ月":990,"会議":860,"入り":1232,"大会":2217,"始め":1681,"市":965,"新聞":-5055,"日,":974,"日、":974,"社会":2024,"ｶ月":990};
-          this.TC1__ = {"AAA":1093,"HHH":1029,"HHM":580,"HII":998,"HOH":-390,"HOM":-331,"IHI":1169,"IOH":-142,"IOI":-1015,"IOM":467,"MMH":187,"OOI":-1832};
-          this.TC2__ = {"HHO":2088,"HII":-1023,"HMM":-1154,"IHI":-1965,"KKH":703,"OII":-2649};
-          this.TC3__ = {"AAA":-294,"HHH":346,"HHI":-341,"HII":-1088,"HIK":731,"HOH":-1486,"IHH":128,"IHI":-3041,"IHO":-1935,"IIH":-825,"IIM":-1035,"IOI":-542,"KHH":-1216,"KKA":491,"KKH":-1217,"KOK":-1009,"MHH":-2694,"MHM":-457,"MHO":123,"MMH":-471,"NNH":-1689,"NNO":662,"OHO":-3393};
-          this.TC4__ = {"HHH":-203,"HHI":1344,"HHK":365,"HHM":-122,"HHN":182,"HHO":669,"HIH":804,"HII":679,"HOH":446,"IHH":695,"IHO":-2324,"IIH":321,"III":1497,"IIO":656,"IOO":54,"KAK":4845,"KKA":3386,"KKK":3065,"MHH":-405,"MHI":201,"MMH":-241,"MMM":661,"MOM":841};
-          this.TQ1__ = {"BHHH":-227,"BHHI":316,"BHIH":-132,"BIHH":60,"BIII":1595,"BNHH":-744,"BOHH":225,"BOOO":-908,"OAKK":482,"OHHH":281,"OHIH":249,"OIHI":200,"OIIH":-68};
-          this.TQ2__ = {"BIHH":-1401,"BIII":-1033,"BKAK":-543,"BOOO":-5591};
-          this.TQ3__ = {"BHHH":478,"BHHM":-1073,"BHIH":222,"BHII":-504,"BIIH":-116,"BIII":-105,"BMHI":-863,"BMHM":-464,"BOMH":620,"OHHH":346,"OHHI":1729,"OHII":997,"OHMH":481,"OIHH":623,"OIIH":1344,"OKAK":2792,"OKHH":587,"OKKA":679,"OOHH":110,"OOII":-685};
-          this.TQ4__ = {"BHHH":-721,"BHHM":-3604,"BHII":-966,"BIIH":-607,"BIII":-2181,"OAAA":-2763,"OAKK":180,"OHHH":-294,"OHHI":2446,"OHHO":480,"OHIH":-1573,"OIHH":1935,"OIHI":-493,"OIIH":626,"OIII":-4007,"OKAK":-8156};
-          this.TW1__ = {"につい":-4681,"東京都":2026};
-          this.TW2__ = {"ある程":-2049,"いった":-1256,"ころが":-2434,"しょう":3873,"その後":-4430,"だって":-1049,"ていた":1833,"として":-4657,"ともに":-4517,"もので":1882,"一気に":-792,"初めて":-1512,"同時に":-8097,"大きな":-1255,"対して":-2721,"社会党":-3216};
-          this.TW3__ = {"いただ":-1734,"してい":1314,"として":-4314,"につい":-5483,"にとっ":-5989,"に当た":-6247,"ので,":-727,"ので、":-727,"のもの":-600,"れから":-3752,"十二月":-2287};
-          this.TW4__ = {"いう.":8576,"いう。":8576,"からな":-2348,"してい":2958,"たが,":1516,"たが、":1516,"ている":1538,"という":1349,"ました":5543,"ません":1097,"ようと":-4258,"よると":5865};
-          this.UC1__ = {"A":484,"K":93,"M":645,"O":-505};
-          this.UC2__ = {"A":819,"H":1059,"I":409,"M":3987,"N":5775,"O":646};
-          this.UC3__ = {"A":-1370,"I":2311};
-          this.UC4__ = {"A":-2643,"H":1809,"I":-1032,"K":-3450,"M":3565,"N":3876,"O":6646};
-          this.UC5__ = {"H":313,"I":-1238,"K":-799,"M":539,"O":-831};
-          this.UC6__ = {"H":-506,"I":-253,"K":87,"M":247,"O":-387};
-          this.UP1__ = {"O":-214};
-          this.UP2__ = {"B":69,"O":935};
-          this.UP3__ = {"B":189};
-          this.UQ1__ = {"BH":21,"BI":-12,"BK":-99,"BN":142,"BO":-56,"OH":-95,"OI":477,"OK":410,"OO":-2422};
-          this.UQ2__ = {"BH":216,"BI":113,"OK":1759};
-          this.UQ3__ = {"BA":-479,"BH":42,"BI":1913,"BK":-7198,"BM":3160,"BN":6427,"BO":14761,"OI":-827,"ON":-3212};
-          this.UW1__ = {",":156,"、":156,"「":-463,"あ":-941,"う":-127,"が":-553,"き":121,"こ":505,"で":-201,"と":-547,"ど":-123,"に":-789,"の":-185,"は":-847,"も":-466,"や":-470,"よ":182,"ら":-292,"り":208,"れ":169,"を":-446,"ん":-137,"・":-135,"主":-402,"京":-268,"区":-912,"午":871,"国":-460,"大":561,"委":729,"市":-411,"日":-141,"理":361,"生":-408,"県":-386,"都":-718,"｢":-463,"･":-135};
-          this.UW2__ = {",":-829,"、":-829,"〇":892,"「":-645,"」":3145,"あ":-538,"い":505,"う":134,"お":-502,"か":1454,"が":-856,"く":-412,"こ":1141,"さ":878,"ざ":540,"し":1529,"す":-675,"せ":300,"そ":-1011,"た":188,"だ":1837,"つ":-949,"て":-291,"で":-268,"と":-981,"ど":1273,"な":1063,"に":-1764,"の":130,"は":-409,"ひ":-1273,"べ":1261,"ま":600,"も":-1263,"や":-402,"よ":1639,"り":-579,"る":-694,"れ":571,"を":-2516,"ん":2095,"ア":-587,"カ":306,"キ":568,"ッ":831,"三":-758,"不":-2150,"世":-302,"中":-968,"主":-861,"事":492,"人":-123,"会":978,"保":362,"入":548,"初":-3025,"副":-1566,"北":-3414,"区":-422,"大":-1769,"天":-865,"太":-483,"子":-1519,"学":760,"実":1023,"小":-2009,"市":-813,"年":-1060,"強":1067,"手":-1519,"揺":-1033,"政":1522,"文":-1355,"新":-1682,"日":-1815,"明":-1462,"最":-630,"朝":-1843,"本":-1650,"東":-931,"果":-665,"次":-2378,"民":-180,"気":-1740,"理":752,"発":529,"目":-1584,"相":-242,"県":-1165,"立":-763,"第":810,"米":509,"自":-1353,"行":838,"西":-744,"見":-3874,"調":1010,"議":1198,"込":3041,"開":1758,"間":-1257,"｢":-645,"｣":3145,"ｯ":831,"ｱ":-587,"ｶ":306,"ｷ":568};
-          this.UW3__ = {",":4889,"1":-800,"−":-1723,"、":4889,"々":-2311,"〇":5827,"」":2670,"〓":-3573,"あ":-2696,"い":1006,"う":2342,"え":1983,"お":-4864,"か":-1163,"が":3271,"く":1004,"け":388,"げ":401,"こ":-3552,"ご":-3116,"さ":-1058,"し":-395,"す":584,"せ":3685,"そ":-5228,"た":842,"ち":-521,"っ":-1444,"つ":-1081,"て":6167,"で":2318,"と":1691,"ど":-899,"な":-2788,"に":2745,"の":4056,"は":4555,"ひ":-2171,"ふ":-1798,"へ":1199,"ほ":-5516,"ま":-4384,"み":-120,"め":1205,"も":2323,"や":-788,"よ":-202,"ら":727,"り":649,"る":5905,"れ":2773,"わ":-1207,"を":6620,"ん":-518,"ア":551,"グ":1319,"ス":874,"ッ":-1350,"ト":521,"ム":1109,"ル":1591,"ロ":2201,"ン":278,"・":-3794,"一":-1619,"下":-1759,"世":-2087,"両":3815,"中":653,"主":-758,"予":-1193,"二":974,"人":2742,"今":792,"他":1889,"以":-1368,"低":811,"何":4265,"作":-361,"保":-2439,"元":4858,"党":3593,"全":1574,"公":-3030,"六":755,"共":-1880,"円":5807,"再":3095,"分":457,"初":2475,"別":1129,"前":2286,"副":4437,"力":365,"動":-949,"務":-1872,"化":1327,"北":-1038,"区":4646,"千":-2309,"午":-783,"協":-1006,"口":483,"右":1233,"各":3588,"合":-241,"同":3906,"和":-837,"員":4513,"国":642,"型":1389,"場":1219,"外":-241,"妻":2016,"学":-1356,"安":-423,"実":-1008,"家":1078,"小":-513,"少":-3102,"州":1155,"市":3197,"平":-1804,"年":2416,"広":-1030,"府":1605,"度":1452,"建":-2352,"当":-3885,"得":1905,"思":-1291,"性":1822,"戸":-488,"指":-3973,"政":-2013,"教":-1479,"数":3222,"文":-1489,"新":1764,"日":2099,"旧":5792,"昨":-661,"時":-1248,"曜":-951,"最":-937,"月":4125,"期":360,"李":3094,"村":364,"東":-805,"核":5156,"森":2438,"業":484,"氏":2613,"民":-1694,"決":-1073,"法":1868,"海":-495,"無":979,"物":461,"特":-3850,"生":-273,"用":914,"町":1215,"的":7313,"直":-1835,"省":792,"県":6293,"知":-1528,"私":4231,"税":401,"立":-960,"第":1201,"米":7767,"系":3066,"約":3663,"級":1384,"統":-4229,"総":1163,"線":1255,"者":6457,"能":725,"自":-2869,"英":785,"見":1044,"調":-562,"財":-733,"費":1777,"車":1835,"軍":1375,"込":-1504,"通":-1136,"選":-681,"郎":1026,"郡":4404,"部":1200,"金":2163,"長":421,"開":-1432,"間":1302,"関":-1282,"雨":2009,"電":-1045,"非":2066,"駅":1620,"１":-800,"｣":2670,"･":-3794,"ｯ":-1350,"ｱ":551,"ｸﾞ":1319,"ｽ":874,"ﾄ":521,"ﾑ":1109,"ﾙ":1591,"ﾛ":2201,"ﾝ":278};
-          this.UW4__ = {",":3930,".":3508,"―":-4841,"、":3930,"。":3508,"〇":4999,"「":1895,"」":3798,"〓":-5156,"あ":4752,"い":-3435,"う":-640,"え":-2514,"お":2405,"か":530,"が":6006,"き":-4482,"ぎ":-3821,"く":-3788,"け":-4376,"げ":-4734,"こ":2255,"ご":1979,"さ":2864,"し":-843,"じ":-2506,"す":-731,"ず":1251,"せ":181,"そ":4091,"た":5034,"だ":5408,"ち":-3654,"っ":-5882,"つ":-1659,"て":3994,"で":7410,"と":4547,"な":5433,"に":6499,"ぬ":1853,"ね":1413,"の":7396,"は":8578,"ば":1940,"ひ":4249,"び":-4134,"ふ":1345,"へ":6665,"べ":-744,"ほ":1464,"ま":1051,"み":-2082,"む":-882,"め":-5046,"も":4169,"ゃ":-2666,"や":2795,"ょ":-1544,"よ":3351,"ら":-2922,"り":-9726,"る":-14896,"れ":-2613,"ろ":-4570,"わ":-1783,"を":13150,"ん":-2352,"カ":2145,"コ":1789,"セ":1287,"ッ":-724,"ト":-403,"メ":-1635,"ラ":-881,"リ":-541,"ル":-856,"ン":-3637,"・":-4371,"ー":-11870,"一":-2069,"中":2210,"予":782,"事":-190,"井":-1768,"人":1036,"以":544,"会":950,"体":-1286,"作":530,"側":4292,"先":601,"党":-2006,"共":-1212,"内":584,"円":788,"初":1347,"前":1623,"副":3879,"力":-302,"動":-740,"務":-2715,"化":776,"区":4517,"協":1013,"参":1555,"合":-1834,"和":-681,"員":-910,"器":-851,"回":1500,"国":-619,"園":-1200,"地":866,"場":-1410,"塁":-2094,"士":-1413,"多":1067,"大":571,"子":-4802,"学":-1397,"定":-1057,"寺":-809,"小":1910,"屋":-1328,"山":-1500,"島":-2056,"川":-2667,"市":2771,"年":374,"庁":-4556,"後":456,"性":553,"感":916,"所":-1566,"支":856,"改":787,"政":2182,"教":704,"文":522,"方":-856,"日":1798,"時":1829,"最":845,"月":-9066,"木":-485,"来":-442,"校":-360,"業":-1043,"氏":5388,"民":-2716,"気":-910,"沢":-939,"済":-543,"物":-735,"率":672,"球":-1267,"生":-1286,"産":-1101,"田":-2900,"町":1826,"的":2586,"目":922,"省":-3485,"県":2997,"空":-867,"立":-2112,"第":788,"米":2937,"系":786,"約":2171,"経":1146,"統":-1169,"総":940,"線":-994,"署":749,"者":2145,"能":-730,"般":-852,"行":-792,"規":792,"警":-1184,"議":-244,"谷":-1000,"賞":730,"車":-1481,"軍":1158,"輪":-1433,"込":-3370,"近":929,"道":-1291,"選":2596,"郎":-4866,"都":1192,"野":-1100,"銀":-2213,"長":357,"間":-2344,"院":-2297,"際":-2604,"電":-878,"領":-1659,"題":-792,"館":-1984,"首":1749,"高":2120,"｢":1895,"｣":3798,"･":-4371,"ｯ":-724,"ｰ":-11870,"ｶ":2145,"ｺ":1789,"ｾ":1287,"ﾄ":-403,"ﾒ":-1635,"ﾗ":-881,"ﾘ":-541,"ﾙ":-856,"ﾝ":-3637};
-          this.UW5__ = {",":465,".":-299,"1":-514,"E2":-32768,"]":-2762,"、":465,"。":-299,"「":363,"あ":1655,"い":331,"う":-503,"え":1199,"お":527,"か":647,"が":-421,"き":1624,"ぎ":1971,"く":312,"げ":-983,"さ":-1537,"し":-1371,"す":-852,"だ":-1186,"ち":1093,"っ":52,"つ":921,"て":-18,"で":-850,"と":-127,"ど":1682,"な":-787,"に":-1224,"の":-635,"は":-578,"べ":1001,"み":502,"め":865,"ゃ":3350,"ょ":854,"り":-208,"る":429,"れ":504,"わ":419,"を":-1264,"ん":327,"イ":241,"ル":451,"ン":-343,"中":-871,"京":722,"会":-1153,"党":-654,"務":3519,"区":-901,"告":848,"員":2104,"大":-1296,"学":-548,"定":1785,"嵐":-1304,"市":-2991,"席":921,"年":1763,"思":872,"所":-814,"挙":1618,"新":-1682,"日":218,"月":-4353,"査":932,"格":1356,"機":-1508,"氏":-1347,"田":240,"町":-3912,"的":-3149,"相":1319,"省":-1052,"県":-4003,"研":-997,"社":-278,"空":-813,"統":1955,"者":-2233,"表":663,"語":-1073,"議":1219,"選":-1018,"郎":-368,"長":786,"間":1191,"題":2368,"館":-689,"１":-514,"Ｅ２":-32768,"｢":363,"ｲ":241,"ﾙ":451,"ﾝ":-343};
-          this.UW6__ = {",":227,".":808,"1":-270,"E1":306,"、":227,"。":808,"あ":-307,"う":189,"か":241,"が":-73,"く":-121,"こ":-200,"じ":1782,"す":383,"た":-428,"っ":573,"て":-1014,"で":101,"と":-105,"な":-253,"に":-149,"の":-417,"は":-236,"も":-206,"り":187,"る":-135,"を":195,"ル":-673,"ン":-496,"一":-277,"中":201,"件":-800,"会":624,"前":302,"区":1792,"員":-1212,"委":798,"学":-960,"市":887,"広":-695,"後":535,"業":-697,"相":753,"社":-507,"福":974,"空":-822,"者":1811,"連":463,"郎":1082,"１":-270,"Ｅ１":306,"ﾙ":-673,"ﾝ":-496};
-          
-          return this;
-        }
-        TinySegmenter.prototype.ctype_ = function(str) {
-          for (var i in this.chartype_) {
-            if (str.match(this.chartype_[i][0])) {
-              return this.chartype_[i][1];
-            }
-          }
-          return "O";
-        }
-
-        TinySegmenter.prototype.ts_ = function(v) {
-          if (v) { return v; }
-          return 0;
-        }
-
-        TinySegmenter.prototype.segment = function(input) {
-          if (input == null || input == undefined || input == "") {
-            return [];
-          }
-          var result = [];
-          var seg = ["B3","B2","B1"];
-          var ctype = ["O","O","O"];
-          var o = input.split("");
-          for (i = 0; i < o.length; ++i) {
-            seg.push(o[i]);
-            ctype.push(this.ctype_(o[i]))
-          }
-          seg.push("E1");
-          seg.push("E2");
-          seg.push("E3");
-          ctype.push("O");
-          ctype.push("O");
-          ctype.push("O");
-          var word = seg[3];
-          var p1 = "U";
-          var p2 = "U";
-          var p3 = "U";
-          for (var i = 4; i < seg.length - 3; ++i) {
-            var score = this.BIAS__;
-            var w1 = seg[i-3];
-            var w2 = seg[i-2];
-            var w3 = seg[i-1];
-            var w4 = seg[i];
-            var w5 = seg[i+1];
-            var w6 = seg[i+2];
-            var c1 = ctype[i-3];
-            var c2 = ctype[i-2];
-            var c3 = ctype[i-1];
-            var c4 = ctype[i];
-            var c5 = ctype[i+1];
-            var c6 = ctype[i+2];
-            score += this.ts_(this.UP1__[p1]);
-            score += this.ts_(this.UP2__[p2]);
-            score += this.ts_(this.UP3__[p3]);
-            score += this.ts_(this.BP1__[p1 + p2]);
-            score += this.ts_(this.BP2__[p2 + p3]);
-            score += this.ts_(this.UW1__[w1]);
-            score += this.ts_(this.UW2__[w2]);
-            score += this.ts_(this.UW3__[w3]);
-            score += this.ts_(this.UW4__[w4]);
-            score += this.ts_(this.UW5__[w5]);
-            score += this.ts_(this.UW6__[w6]);
-            score += this.ts_(this.BW1__[w2 + w3]);
-            score += this.ts_(this.BW2__[w3 + w4]);
-            score += this.ts_(this.BW3__[w4 + w5]);
-            score += this.ts_(this.TW1__[w1 + w2 + w3]);
-            score += this.ts_(this.TW2__[w2 + w3 + w4]);
-            score += this.ts_(this.TW3__[w3 + w4 + w5]);
-            score += this.ts_(this.TW4__[w4 + w5 + w6]);
-            score += this.ts_(this.UC1__[c1]);
-            score += this.ts_(this.UC2__[c2]);
-            score += this.ts_(this.UC3__[c3]);
-            score += this.ts_(this.UC4__[c4]);
-            score += this.ts_(this.UC5__[c5]);
-            score += this.ts_(this.UC6__[c6]);
-            score += this.ts_(this.BC1__[c2 + c3]);
-            score += this.ts_(this.BC2__[c3 + c4]);
-            score += this.ts_(this.BC3__[c4 + c5]);
-            score += this.ts_(this.TC1__[c1 + c2 + c3]);
-            score += this.ts_(this.TC2__[c2 + c3 + c4]);
-            score += this.ts_(this.TC3__[c3 + c4 + c5]);
-            score += this.ts_(this.TC4__[c4 + c5 + c6]);
-        //  score += this.ts_(this.TC5__[c4 + c5 + c6]);    
-            score += this.ts_(this.UQ1__[p1 + c1]);
-            score += this.ts_(this.UQ2__[p2 + c2]);
-            score += this.ts_(this.UQ3__[p3 + c3]);
-            score += this.ts_(this.BQ1__[p2 + c2 + c3]);
-            score += this.ts_(this.BQ2__[p2 + c3 + c4]);
-            score += this.ts_(this.BQ3__[p3 + c2 + c3]);
-            score += this.ts_(this.BQ4__[p3 + c3 + c4]);
-            score += this.ts_(this.TQ1__[p2 + c1 + c2 + c3]);
-            score += this.ts_(this.TQ2__[p2 + c2 + c3 + c4]);
-            score += this.ts_(this.TQ3__[p3 + c1 + c2 + c3]);
-            score += this.ts_(this.TQ4__[p3 + c2 + c3 + c4]);
-            var p = "O";
-            if (score > 0) {
-              result.push(word);
-              word = "";
-              p = "B";
-            }
-            p1 = p2;
-            p2 = p3;
-            p3 = p;
-            word += seg[i];
-          }
-          result.push(word);
-
-          return result;
-        }
-
-        lunr.TinySegmenter = TinySegmenter;
-    };
-
-}));

assets/stylesheets/palette.06af60db.min.css.map

@@ -1 +0,0 @@
-{"version":3,"sources":["src/templates/assets/stylesheets/palette/_scheme.scss","../../../../src/templates/assets/stylesheets/palette.scss","src/templates/assets/stylesheets/palette/_accent.scss","src/templates/assets/stylesheets/palette/_primary.scss","src/templates/assets/stylesheets/utilities/_break.scss"],"names":[],"mappings":"AA2BA,cAGE,6BAME,sDAAA,CACA,6DAAA,CACA,+DAAA,CACA,gEAAA,CACA,mDAAA,CACA,6DAAA,CACA,+DAAA,CACA,gEAAA,CAGA,mDAAA,CACA,gDAAA,CAGA,0BAAA,CACA,mCAAA,CAGA,iCAAA,CACA,kCAAA,CACA,mCAAA,CACA,mCAAA,CACA,kCAAA,CACA,iCAAA,CACA,+CAAA,CACA,6DAAA,CACA,gEAAA,CACA,4DAAA,CACA,4DAAA,CACA,6DAAA,CAGA,6CAAA,CAGA,+CAAA,CAGA,uDAAA,CACA,6DAAA,CACA,2DAAA,CAGA,iCAAA,CAGA,yDAAA,CACA,iEAAA,CAGA,mDAAA,CACA,mDAAA,CAGA,qDAAA,CACA,uDAAA,CAGA,8DAAA,CAKA,8DAAA,CAKA,0DAAA,CAvEA,iBCeF,CD6DE,kHAEE,YC3DJ,CDkFE,yDACE,4BChFJ,CD+EE,2DACE,4BC7EJ,CD4EE,gEACE,4BC1EJ,CDyEE,2DACE,4BCvEJ,CDsEE,yDACE,4BCpEJ,CDmEE,0DACE,4BCjEJ,CDgEE,gEACE,4BC9DJ,CD6DE,0DACE,4BC3DJ,CD0DE,2OACE,4BC/CJ,CDsDA,+FAGE,iCCpDF,CACF,CC/CE,2BACE,4BAAA,CACA,2CAAA,CAOE,yBAAA,CACA,qCD2CN,CCrDE,4BACE,4BAAA,CACA,2CAAA,CAOE,yBAAA,CACA,qCDkDN,CC5DE,8BACE,4BAAA,CACA,2CAAA,CAOE,yBAAA,CACA,qCDyDN,CCnEE,mCACE,4BAAA,CACA,2CAAA,CAOE,yBAAA,CACA,qCDgEN,CC1EE,8BACE,4BAAA,CACA,2CAAA,CAOE,yBAAA,CACA,qCDuEN,CCjFE,4BACE,4BAAA,CACA,2CAAA,CAOE,yBAAA,CACA,qCD8EN,CCxFE,kCACE,4BAAA,CACA,2CAAA,CAOE,yBAAA,CACA,qCDqFN,CC/FE,4BACE,4BAAA,CACA,2CAAA,CAOE,yBAAA,CACA,qCD4FN,CCtGE,4BACE,4BAAA,CACA,2CAAA,CAOE,yBAAA,CACA,qCDmGN,CC7GE,6BACE,4BAAA,CACA,2CAAA,CAOE,yBAAA,CACA,qCD0GN,CCpHE,mCACE,4BAAA,CACA,2CAAA,CAOE,yBAAA,CACA,qCDiHN,CC3HE,4BACE,4BAAA,CACA,2CAAA,CAIE,8BAAA,CACA,qCD2HN,CClIE,8BACE,4BAAA,CACA,2CAAA,CAIE,8BAAA,CACA,qCDkIN,CCzIE,6BACE,yBAAA,CACA,2CAAA,CAIE,8BAAA,CACA,qCDyIN,CChJE,8BACE,4BAAA,CACA,2CAAA,CAIE,8BAAA,CACA,qCDgJN,CCvJE,mCACE,4BAAA,CACA,2CAAA,CAOE,yBAAA,CACA,qCDoJN,CEzJE,4BACE,6BAAA,CACA,oCAAA,CACA,mCAAA,CAOE,0BAAA,CACA,sCFsJN,CEjKE,6BACE,6BAAA,CACA,oCAAA,CACA,mCAAA,CAOE,0BAAA,CACA,sCF8JN,CEzKE,+BACE,6BAAA,CACA,oCAAA,CACA,mCAAA,CAOE,0BAAA,CACA,sCFsKN,CEjLE,oCACE,6BAAA,CACA,oCAAA,CACA,mCAAA,CAOE,0BAAA,CACA,sCF8KN,CEzLE,+BACE,6BAAA,CACA,oCAAA,CACA,mCAAA,CAOE,0BAAA,CACA,sCFsLN,CEjME,6BACE,6BAAA,CACA,oCAAA,CACA,mCAAA,CAOE,0BAAA,CACA,sCF8LN,CEzME,mCACE,6BAAA,CACA,oCAAA,CACA,mCAAA,CAOE,0BAAA,CACA,sCFsMN,CEjNE,6BACE,6BAAA,CACA,oCAAA,CACA,mCAAA,CAOE,0BAAA,CACA,sCF8MN,CEzNE,6BACE,6BAAA,CACA,oCAAA,CACA,mCAAA,CAOE,0BAAA,CACA,sCFsNN,CEjOE,8BACE,6BAAA,CACA,oCAAA,CACA,mCAAA,CAOE,0BAAA,CACA,sCF8NN,CEzOE,oCACE,6BAAA,CACA,oCAAA,CACA,mCAAA,CAOE,0BAAA,CACA,sCFsON,CEjPE,6BACE,6BAAA,CACA,oCAAA,CACA,mCAAA,CAIE,+BAAA,CACA,sCFiPN,CEzPE,+BACE,6BAAA,CACA,oCAAA,CACA,mCAAA,CAIE,+BAAA,CACA,sCFyPN,CEjQE,8BACE,6BAAA,CACA,oCAAA,CACA,mCAAA,CAIE,+BAAA,CACA,sCFiQN,CEzQE,+BACE,6BAAA,CACA,oCAAA,CACA,mCAAA,CAIE,+BAAA,CACA,sCFyQN,CEjRE,oCACE,6BAAA,CACA,oCAAA,CACA,mCAAA,CAOE,0BAAA,CACA,sCF8QN,CEzRE,8BACE,6BAAA,CACA,oCAAA,CACA,mCAAA,CAOE,0BAAA,CACA,sCFsRN,CEjSE,6BACE,6BAAA,CACA,oCAAA,CACA,mCAAA,CAOE,0BAAA,CACA,sCAAA,CAKA,4BF0RN,CE1SE,kCACE,6BAAA,CACA,oCAAA,CACA,mCAAA,CAOE,0BAAA,CACA,sCAAA,CAKA,4BFmSN,CEpRE,sEACE,4BFuRJ,CExRE,+DACE,4BF2RJ,CE5RE,iEACE,4BF+RJ,CEhSE,gEACE,4BFmSJ,CEpSE,iEACE,4BFuSJ,CE9RA,8BACE,mDAAA,CACA,4DAAA,CACA,0DAAA,CACA,oDAAA,CACA,2DAAA,CAGA,4BF+RF,CE5RE,yCACE,+BF8RJ,CE3RI,kDAEE,0CAAA,CACA,sCAAA,CAFA,mCF+RN,CG3MI,mCD1EA,+CACE,8CFwRJ,CErRI,qDACE,8CFuRN,CElRE,iEACE,mCFoRJ,CACF,CGtNI,sCDvDA,uCACE,oCFgRJ,CACF,CEvQA,8BACE,kDAAA,CACA,4DAAA,CACA,wDAAA,CACA,oDAAA,CACA,6DAAA,CAGA,4BFwQF,CErQE,yCACE,+BFuQJ,CEpQI,kDAEE,0CAAA,CACA,sCAAA,CAFA,mCFwQN,CEjQE,yCACE,6CFmQJ,CG5NI,0CDhCA,8CACE,gDF+PJ,CACF,CGjOI,0CDvBA,iFACE,6CF2PJ,CACF,CGzPI,sCDKA,uCACE,6CFuPJ,CACF","file":"palette.css"}

bumble/a2dp.py

@@ -0,0 +1,554 @@
+# Copyright 2021-2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import struct
+import bitstruct
+import logging
+from collections import namedtuple
+from colors import color
+
+from .company_ids import COMPANY_IDENTIFIERS
+from .sdp import (
+    DataElement,
+    ServiceAttribute,
+    SDP_PUBLIC_BROWSE_ROOT,
+    SDP_BROWSE_GROUP_LIST_ATTRIBUTE_ID,
+    SDP_SERVICE_RECORD_HANDLE_ATTRIBUTE_ID,
+    SDP_SERVICE_CLASS_ID_LIST_ATTRIBUTE_ID,
+    SDP_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID,
+    SDP_BLUETOOTH_PROFILE_DESCRIPTOR_LIST_ATTRIBUTE_ID
+)
+from .core import (
+    BT_L2CAP_PROTOCOL_ID,
+    BT_AUDIO_SOURCE_SERVICE,
+    BT_AUDIO_SINK_SERVICE,
+    BT_AVDTP_PROTOCOL_ID,
+    BT_ADVANCED_AUDIO_DISTRIBUTION_SERVICE,
+    name_or_number
+)
+
+
+# -----------------------------------------------------------------------------
+# Logging
+# -----------------------------------------------------------------------------
+logger = logging.getLogger(__name__)
+
+
+# -----------------------------------------------------------------------------
+# Constants
+# -----------------------------------------------------------------------------
+
+A2DP_SBC_CODEC_TYPE            = 0x00
+A2DP_MPEG_1_2_AUDIO_CODEC_TYPE = 0x01
+A2DP_MPEG_2_4_AAC_CODEC_TYPE   = 0x02
+A2DP_ATRAC_FAMILY_CODEC_TYPE   = 0x03
+A2DP_NON_A2DP_CODEC_TYPE       = 0xFF
+
+A2DP_CODEC_TYPE_NAMES = {
+    A2DP_SBC_CODEC_TYPE:            'A2DP_SBC_CODEC_TYPE',
+    A2DP_MPEG_1_2_AUDIO_CODEC_TYPE: 'A2DP_MPEG_1_2_AUDIO_CODEC_TYPE',
+    A2DP_MPEG_2_4_AAC_CODEC_TYPE:   'A2DP_MPEG_2_4_AAC_CODEC_TYPE',
+    A2DP_ATRAC_FAMILY_CODEC_TYPE:   'A2DP_ATRAC_FAMILY_CODEC_TYPE',
+    A2DP_NON_A2DP_CODEC_TYPE:       'A2DP_NON_A2DP_CODEC_TYPE'
+}
+
+
+SBC_SYNC_WORD = 0x9C
+
+SBC_SAMPLING_FREQUENCIES = [
+    16000,
+    22050,
+    44100,
+    48000
+]
+
+SBC_MONO_CHANNEL_MODE         = 0x00
+SBC_DUAL_CHANNEL_MODE         = 0x01
+SBC_STEREO_CHANNEL_MODE       = 0x02
+SBC_JOINT_STEREO_CHANNEL_MODE = 0x03
+
+SBC_CHANNEL_MODE_NAMES = {
+    SBC_MONO_CHANNEL_MODE:         'SBC_MONO_CHANNEL_MODE',
+    SBC_DUAL_CHANNEL_MODE:         'SBC_DUAL_CHANNEL_MODE',
+    SBC_STEREO_CHANNEL_MODE:       'SBC_STEREO_CHANNEL_MODE',
+    SBC_JOINT_STEREO_CHANNEL_MODE: 'SBC_JOINT_STEREO_CHANNEL_MODE'
+}
+
+SBC_BLOCK_LENGTHS = [4, 8, 12, 16]
+
+SBC_SUBBANDS = [4, 8]
+
+SBC_SNR_ALLOCATION_METHOD      = 0x00
+SBC_LOUDNESS_ALLOCATION_METHOD = 0x01
+
+SBC_ALLOCATION_METHOD_NAMES = {
+    SBC_SNR_ALLOCATION_METHOD:      'SBC_SNR_ALLOCATION_METHOD',
+    SBC_LOUDNESS_ALLOCATION_METHOD: 'SBC_LOUDNESS_ALLOCATION_METHOD'
+}
+
+MPEG_2_4_AAC_SAMPLING_FREQUENCIES = [
+    8000,
+    11025,
+    12000,
+    16000,
+    22050,
+    24000,
+    32000,
+    44100,
+    48000,
+    64000,
+    88200,
+    96000
+]
+
+MPEG_2_AAC_LC_OBJECT_TYPE       = 0x00
+MPEG_4_AAC_LC_OBJECT_TYPE       = 0x01
+MPEG_4_AAC_LTP_OBJECT_TYPE      = 0x02
+MPEG_4_AAC_SCALABLE_OBJECT_TYPE = 0x03
+
+MPEG_2_4_OBJECT_TYPE_NAMES = {
+    MPEG_2_AAC_LC_OBJECT_TYPE:       'MPEG_2_AAC_LC_OBJECT_TYPE',
+    MPEG_4_AAC_LC_OBJECT_TYPE:       'MPEG_4_AAC_LC_OBJECT_TYPE',
+    MPEG_4_AAC_LTP_OBJECT_TYPE:      'MPEG_4_AAC_LTP_OBJECT_TYPE',
+    MPEG_4_AAC_SCALABLE_OBJECT_TYPE: 'MPEG_4_AAC_SCALABLE_OBJECT_TYPE'
+}
+
+
+# -----------------------------------------------------------------------------
+def flags_to_list(flags, values):
+    result = []
+    for i in range(len(values)):
+        if flags & (1 << (len(values) - i - 1)):
+            result.append(values[i])
+    return result
+
+
+# -----------------------------------------------------------------------------
+def make_audio_source_service_sdp_records(service_record_handle, version=(1, 3)):
+    from .avdtp import AVDTP_PSM
+    version_int = version[0] << 8 | version[1]
+    return [
+        ServiceAttribute(SDP_SERVICE_RECORD_HANDLE_ATTRIBUTE_ID, DataElement.unsigned_integer_32(service_record_handle)),
+        ServiceAttribute(SDP_BROWSE_GROUP_LIST_ATTRIBUTE_ID, DataElement.sequence([
+            DataElement.uuid(SDP_PUBLIC_BROWSE_ROOT)
+        ])),
+        ServiceAttribute(SDP_SERVICE_CLASS_ID_LIST_ATTRIBUTE_ID, DataElement.sequence([
+            DataElement.uuid(BT_AUDIO_SOURCE_SERVICE)
+        ])),
+        ServiceAttribute(SDP_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID, DataElement.sequence([
+            DataElement.sequence([
+                DataElement.uuid(BT_L2CAP_PROTOCOL_ID),
+                DataElement.unsigned_integer_16(AVDTP_PSM)
+            ]),
+            DataElement.sequence([
+                DataElement.uuid(BT_AVDTP_PROTOCOL_ID),
+                DataElement.unsigned_integer_16(version_int)
+            ])
+        ])),
+        ServiceAttribute(SDP_BLUETOOTH_PROFILE_DESCRIPTOR_LIST_ATTRIBUTE_ID, DataElement.sequence([
+            DataElement.uuid(BT_ADVANCED_AUDIO_DISTRIBUTION_SERVICE),
+            DataElement.unsigned_integer_16(version_int)
+        ])),
+    ]
+
+
+# -----------------------------------------------------------------------------
+def make_audio_sink_service_sdp_records(service_record_handle, version=(1, 3)):
+    from .avdtp import AVDTP_PSM
+    version_int = version[0] << 8 | version[1]
+    return [
+        ServiceAttribute(SDP_SERVICE_RECORD_HANDLE_ATTRIBUTE_ID, DataElement.unsigned_integer_32(service_record_handle)),
+        ServiceAttribute(SDP_BROWSE_GROUP_LIST_ATTRIBUTE_ID, DataElement.sequence([
+            DataElement.uuid(SDP_PUBLIC_BROWSE_ROOT)
+        ])),
+        ServiceAttribute(SDP_SERVICE_CLASS_ID_LIST_ATTRIBUTE_ID, DataElement.sequence([
+            DataElement.uuid(BT_AUDIO_SINK_SERVICE)
+        ])),
+        ServiceAttribute(SDP_PROTOCOL_DESCRIPTOR_LIST_ATTRIBUTE_ID, DataElement.sequence([
+            DataElement.sequence([
+                DataElement.uuid(BT_L2CAP_PROTOCOL_ID),
+                DataElement.unsigned_integer_16(AVDTP_PSM)
+            ]),
+            DataElement.sequence([
+                DataElement.uuid(BT_AVDTP_PROTOCOL_ID),
+                DataElement.unsigned_integer_16(version_int)
+            ])
+        ])),
+        ServiceAttribute(SDP_BLUETOOTH_PROFILE_DESCRIPTOR_LIST_ATTRIBUTE_ID, DataElement.sequence([
+            DataElement.uuid(BT_ADVANCED_AUDIO_DISTRIBUTION_SERVICE),
+            DataElement.unsigned_integer_16(version_int)
+        ])),
+    ]
+
+
+# -----------------------------------------------------------------------------
+class SbcMediaCodecInformation(
+    namedtuple(
+        'SbcMediaCodecInformation',
+        [
+            'sampling_frequency',
+            'channel_mode',
+            'block_length',
+            'subbands',
+            'allocation_method',
+            'minimum_bitpool_value',
+            'maximum_bitpool_value'
+        ]
+    )
+):
+    '''
+    A2DP spec - 4.3.2 Codec Specific Information Elements
+    '''
+
+    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,
+        SBC_DUAL_CHANNEL_MODE:         1 << 2,
+        SBC_STEREO_CHANNEL_MODE:       1 << 1,
+        SBC_JOINT_STEREO_CHANNEL_MODE: 1
+    }
+    BLOCK_LENGTH_BITS = {
+        4:  1 << 3,
+        8:  1 << 2,
+        12: 1 << 1,
+        16: 1
+    }
+    SUBBANDS_BITS = {
+        4: 1 << 1,
+        8: 1
+    }
+    ALLOCATION_METHOD_BITS = {
+        SBC_SNR_ALLOCATION_METHOD:      1 << 1,
+        SBC_LOUDNESS_ALLOCATION_METHOD: 1
+    }
+
+    @staticmethod
+    def from_bytes(data):
+        return SbcMediaCodecInformation(*bitstruct.unpack(SbcMediaCodecInformation.BIT_FIELDS, data))
+
+    @classmethod
+    def from_discrete_values(
+        cls,
+        sampling_frequency,
+        channel_mode,
+        block_length,
+        subbands,
+        allocation_method,
+        minimum_bitpool_value,
+        maximum_bitpool_value
+    ):
+        return SbcMediaCodecInformation(
+            sampling_frequency    = cls.SAMPLING_FREQUENCY_BITS[sampling_frequency],
+            channel_mode          = cls.CHANNEL_MODE_BITS[channel_mode],
+            block_length          = cls.BLOCK_LENGTH_BITS[block_length],
+            subbands              = cls.SUBBANDS_BITS[subbands],
+            allocation_method     = cls.ALLOCATION_METHOD_BITS[allocation_method],
+            minimum_bitpool_value = minimum_bitpool_value,
+            maximum_bitpool_value = maximum_bitpool_value
+        )
+
+    @classmethod
+    def from_lists(
+        cls,
+        sampling_frequencies,
+        channel_modes,
+        block_lengths,
+        subbands,
+        allocation_methods,
+        minimum_bitpool_value,
+        maximum_bitpool_value
+    ):
+        return SbcMediaCodecInformation(
+            sampling_frequency    = sum(cls.SAMPLING_FREQUENCY_BITS[x] for x in sampling_frequencies),
+            channel_mode          = sum(cls.CHANNEL_MODE_BITS[x] for x in channel_modes),
+            block_length          = sum(cls.BLOCK_LENGTH_BITS[x] for x in block_lengths),
+            subbands              = sum(cls.SUBBANDS_BITS[x] for x in subbands),
+            allocation_method     = sum(cls.ALLOCATION_METHOD_BITS[x] for x in allocation_methods),
+            minimum_bitpool_value = minimum_bitpool_value,
+            maximum_bitpool_value = maximum_bitpool_value
+        )
+
+    def __bytes__(self):
+        return bitstruct.pack(self.BIT_FIELDS, *self)
+
+    def __str__(self):
+        channel_modes = ['MONO', 'DUAL_CHANNEL', 'STEREO', 'JOINT_STEREO']
+        allocation_methods = ['SNR', 'Loudness']
+        return '\n'.join([
+            'SbcMediaCodecInformation(',
+            f'  sampling_frequency:    {",".join([str(x) for x in flags_to_list(self.sampling_frequency, SBC_SAMPLING_FREQUENCIES)])}',
+            f'  channel_mode:          {",".join([str(x) for x in flags_to_list(self.channel_mode, channel_modes)])}',
+            f'  block_length:          {",".join([str(x) for x in flags_to_list(self.block_length, SBC_BLOCK_LENGTHS)])}',
+            f'  subbands:              {",".join([str(x) for x in flags_to_list(self.subbands, SBC_SUBBANDS)])}',
+            f'  allocation_method:     {",".join([str(x) for x in flags_to_list(self.allocation_method, allocation_methods)])}',
+            f'  minimum_bitpool_value: {self.minimum_bitpool_value}',
+            f'  maximum_bitpool_value: {self.maximum_bitpool_value}'
+            ')'
+        ])
+
+
+# -----------------------------------------------------------------------------
+class AacMediaCodecInformation(
+    namedtuple(
+        'AacMediaCodecInformation',
+        [
+            'object_type',
+            'sampling_frequency',
+            'channels',
+            '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,
+        MPEG_4_AAC_LTP_OBJECT_TYPE:      1 << 5,
+        MPEG_4_AAC_SCALABLE_OBJECT_TYPE: 1 << 4
+    }
+    SAMPLING_FREQUENCY_BITS = {
+        8000:  1 << 11,
+        11025: 1 << 10,
+        12000: 1 << 9,
+        16000: 1 << 8,
+        22050: 1 << 7,
+        24000: 1 << 6,
+        32000: 1 << 5,
+        44100: 1 << 4,
+        48000: 1 << 3,
+        64000: 1 << 2,
+        88200: 1 << 1,
+        96000: 1
+    }
+    CHANNELS_BITS = {
+        1: 1 << 1,
+        2: 1
+    }
+
+    @staticmethod
+    def from_bytes(data):
+        return AacMediaCodecInformation(*bitstruct.unpack(AacMediaCodecInformation.BIT_FIELDS, data))
+
+    @classmethod
+    def from_discrete_values(
+        cls,
+        object_type,
+        sampling_frequency,
+        channels,
+        vbr,
+        bitrate
+    ):
+        return AacMediaCodecInformation(
+            object_type           = cls.OBJECT_TYPE_BITS[object_type],
+            sampling_frequency    = cls.SAMPLING_FREQUENCY_BITS[sampling_frequency],
+            channels              = cls.CHANNELS_BITS[channels],
+            vbr                   = vbr,
+            bitrate               = bitrate
+        )
+
+    @classmethod
+    def from_lists(
+        cls,
+        object_types,
+        sampling_frequencies,
+        channels,
+        vbr,
+        bitrate
+    ):
+        return AacMediaCodecInformation(
+            object_type           = sum(cls.OBJECT_TYPE_BITS[x] for x in object_types),
+            sampling_frequency    = sum(cls.SAMPLING_FREQUENCY_BITS[x] for x in sampling_frequencies),
+            channels              = sum(cls.CHANNELS_BITS[x] for x in channels),
+            vbr                   = vbr,
+            bitrate               = bitrate
+        )
+
+    def __bytes__(self):
+        return bitstruct.pack(self.BIT_FIELDS, *self)
+
+    def __str__(self):
+        object_types = ['MPEG_2_AAC_LC', 'MPEG_4_AAC_LC', 'MPEG_4_AAC_LTP', 'MPEG_4_AAC_SCALABLE', '[4]', '[5]', '[6]', '[7]']
+        channels = [1, 2]
+        return '\n'.join([
+            'AacMediaCodecInformation(',
+            f'  object_type:        {",".join([str(x) for x in flags_to_list(self.object_type, object_types)])}',
+            f'  sampling_frequency: {",".join([str(x) for x in flags_to_list(self.sampling_frequency, MPEG_2_4_AAC_SAMPLING_FREQUENCIES)])}',
+            f'  channels:           {",".join([str(x) for x in flags_to_list(self.channels, channels)])}',
+            f'  vbr:                {self.vbr}',
+            f'  bitrate:            {self.bitrate}'
+            ')'
+        ])
+
+
+# -----------------------------------------------------------------------------
+class VendorSpecificMediaCodecInformation:
+    '''
+    A2DP spec - 4.7.2 Codec Specific Information Elements
+    '''
+
+    @staticmethod
+    def from_bytes(data):
+        (vendor_id, codec_id) = struct.unpack_from('<IH', data, 0)
+        return VendorSpecificMediaCodecInformation(vendor_id, codec_id, data[6:])
+
+    def __init__(self, vendor_id, codec_id, value):
+        self.vendor_id = vendor_id
+        self.codec_id  = codec_id
+        self.value     = value
+
+    def __bytes__(self):
+        return struct.pack('<IH', self.vendor_id, self.codec_id, self.value)
+
+    def __str__(self):
+        return '\n'.join([
+            'VendorSpecificMediaCodecInformation(',
+            f'  vendor_id: {self.vendor_id:08X} ({name_or_number(COMPANY_IDENTIFIERS, self.vendor_id & 0xFFFF)})',
+            f'  codec_id:  {self.codec_id:04X}',
+            f'  value:     {self.value.hex()}'
+            ')'
+        ])
+
+
+# -----------------------------------------------------------------------------
+class SbcFrame:
+    def __init__(
+        self,
+        sampling_frequency,
+        block_count,
+        channel_mode,
+        subband_count,
+        payload
+    ):
+        self.sampling_frequency = sampling_frequency
+        self.block_count        = block_count
+        self.channel_mode       = channel_mode
+        self.subband_count      = subband_count
+        self.payload            = payload
+
+    @property
+    def sample_count(self):
+        return self.subband_count * self.block_count
+
+    @property
+    def bitrate(self):
+        return 8 * ((len(self.payload) * self.sampling_frequency) // self.sample_count)
+
+    @property
+    def duration(self):
+        return self.sample_count / self.sampling_frequency
+
+    def __str__(self):
+        return f'SBC(sf={self.sampling_frequency},cm={self.channel_mode},br={self.bitrate},sc={self.sample_count},size={len(self.payload)})'
+
+
+# -----------------------------------------------------------------------------
+class SbcParser:
+    def __init__(self, read):
+        self.read = read
+
+    @property
+    def frames(self):
+        async def generate_frames():
+            while True:
+                # Read 4 bytes of header
+                header = await self.read(4)
+                if len(header) != 4:
+                    return
+
+                # Check the sync word
+                if header[0] != SBC_SYNC_WORD:
+                    logger.debug('invalid sync word')
+                    return
+
+                # Extract some of the header fields
+                sampling_frequency = SBC_SAMPLING_FREQUENCIES[(header[1] >> 6) & 3]
+                blocks             = 4 * (1 + ((header[1] >> 4) & 3))
+                channel_mode       = (header[1] >> 2) & 3
+                channels           = 1 if channel_mode == SBC_MONO_CHANNEL_MODE else 2
+                subbands           = 8 if ((header[1]) & 1) else 4
+                bitpool            = header[2]
+
+                # Compute the frame length
+                frame_length = 4 + (4 * subbands * channels) // 8
+                if channel_mode in (SBC_MONO_CHANNEL_MODE, SBC_DUAL_CHANNEL_MODE):
+                    frame_length += (blocks * channels * bitpool) // 8
+                else:
+                    frame_length += ((1 if channel_mode == SBC_JOINT_STEREO_CHANNEL_MODE else 0) * subbands + blocks * bitpool) // 8
+
+                # Read the rest of the frame
+                payload = header + await self.read(frame_length - 4)
+
+                # Emit the next frame
+                yield SbcFrame(sampling_frequency, blocks, channel_mode, subbands, payload)
+
+        return generate_frames()
+
+
+# -----------------------------------------------------------------------------
+class SbcPacketSource:
+    def __init__(self, read, mtu, codec_capabilities):
+        self.read               = read
+        self.mtu                = mtu
+        self.codec_capabilities = codec_capabilities
+
+    @property
+    def packets(self):
+        async def generate_packets():
+            from .avdtp import MediaPacket  # Import here to avoid a circular reference
+
+            sequence_number = 0
+            timestamp       = 0
+            frames          = []
+            frames_size     = 0
+            max_rtp_payload = self.mtu - 12 - 1
+
+            # NOTE: this doesn't support frame fragments
+            sbc_parser = SbcParser(self.read)
+            async for frame in sbc_parser.frames:
+                print(frame)
+
+                if frames_size + len(frame.payload) > max_rtp_payload or len(frames) == 16:
+                    # Need to flush what has been accumulated so far
+
+                    # Emit a packet
+                    sbc_payload = bytes([len(frames)]) + b''.join([frame.payload for frame in frames])
+                    packet = MediaPacket(2, 0, 0, 0, sequence_number, timestamp, 0, [], 96, sbc_payload)
+                    packet.timestamp_seconds = timestamp / frame.sampling_frequency
+                    yield packet
+
+                    # Prepare for next packets
+                    sequence_number += 1
+                    timestamp += sum([frame.sample_count for frame in frames])
+                    frames = [frame]
+                    frames_size = len(frame.payload)
+                else:
+                    # Accumulate
+                    frames.append(frame)
+                    frames_size += len(frame.payload)
+
+        return generate_packets()

bumble/att.py

@@ -0,0 +1,742 @@
+# Copyright 2021-2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# ATT - Attribute Protocol
+#
+# See Bluetooth spec @ Vol 3, Part F
+#
+# -----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+from colors import color
+from pyee import EventEmitter
+
+from .core import *
+from .hci import *
+
+# -----------------------------------------------------------------------------
+# Constants
+# -----------------------------------------------------------------------------
+ATT_CID = 0x04
+
+ATT_ERROR_RESPONSE              = 0x01
+ATT_EXCHANGE_MTU_REQUEST        = 0x02
+ATT_EXCHANGE_MTU_RESPONSE       = 0x03
+ATT_FIND_INFORMATION_REQUEST    = 0x04
+ATT_FIND_INFORMATION_RESPONSE   = 0x05
+ATT_FIND_BY_TYPE_VALUE_REQUEST  = 0x06
+ATT_FIND_BY_TYPE_VALUE_RESPONSE = 0x07
+ATT_READ_BY_TYPE_REQUEST        = 0x08
+ATT_READ_BY_TYPE_RESPONSE       = 0x09
+ATT_READ_REQUEST                = 0x0A
+ATT_READ_RESPONSE               = 0x0B
+ATT_READ_BLOB_REQUEST           = 0x0C
+ATT_READ_BLOB_RESPONSE          = 0x0D
+ATT_READ_MULTIPLE_REQUEST       = 0x0E
+ATT_READ_MULTIPLE_RESPONSE      = 0x0F
+ATT_READ_BY_GROUP_TYPE_REQUEST  = 0x10
+ATT_READ_BY_GROUP_TYPE_RESPONSE = 0x11
+ATT_WRITE_REQUEST               = 0x12
+ATT_WRITE_RESPONSE              = 0x13
+ATT_WRITE_COMMAND               = 0x52
+ATT_SIGNED_WRITE_COMMAND        = 0xD2
+ATT_PREPARE_WRITE_REQUEST       = 0x16
+ATT_PREPARE_WRITE_RESPONSE      = 0x17
+ATT_EXECUTE_WRITE_REQUEST       = 0x18
+ATT_EXECUTE_WRITE_RESPONSE      = 0x19
+ATT_HANDLE_VALUE_NOTIFICATION   = 0x1B
+ATT_HANDLE_VALUE_INDICATION     = 0x1D
+ATT_HANDLE_VALUE_CONFIRMATION   = 0x1E
+
+ATT_PDU_NAMES = {
+    ATT_ERROR_RESPONSE:              'ATT_ERROR_RESPONSE',
+    ATT_EXCHANGE_MTU_REQUEST:        'ATT_EXCHANGE_MTU_REQUEST',
+    ATT_EXCHANGE_MTU_RESPONSE:       'ATT_EXCHANGE_MTU_RESPONSE',
+    ATT_FIND_INFORMATION_REQUEST:    'ATT_FIND_INFORMATION_REQUEST',
+    ATT_FIND_INFORMATION_RESPONSE:   'ATT_FIND_INFORMATION_RESPONSE',
+    ATT_FIND_BY_TYPE_VALUE_REQUEST:  'ATT_FIND_BY_TYPE_VALUE_REQUEST',
+    ATT_FIND_BY_TYPE_VALUE_RESPONSE: 'ATT_FIND_BY_TYPE_VALUE_RESPONSE',
+    ATT_READ_BY_TYPE_REQUEST:        'ATT_READ_BY_TYPE_REQUEST',
+    ATT_READ_BY_TYPE_RESPONSE:       'ATT_READ_BY_TYPE_RESPONSE',
+    ATT_READ_REQUEST:                'ATT_READ_REQUEST',
+    ATT_READ_RESPONSE:               'ATT_READ_RESPONSE',
+    ATT_READ_BLOB_REQUEST:           'ATT_READ_BLOB_REQUEST',
+    ATT_READ_BLOB_RESPONSE:          'ATT_READ_BLOB_RESPONSE',
+    ATT_READ_MULTIPLE_REQUEST:       'ATT_READ_MULTIPLE_REQUEST',
+    ATT_READ_MULTIPLE_RESPONSE:      'ATT_READ_MULTIPLE_RESPONSE',
+    ATT_READ_BY_GROUP_TYPE_REQUEST:  'ATT_READ_BY_GROUP_TYPE_REQUEST',
+    ATT_READ_BY_GROUP_TYPE_RESPONSE: 'ATT_READ_BY_GROUP_TYPE_RESPONSE',
+    ATT_WRITE_REQUEST:               'ATT_WRITE_REQUEST',
+    ATT_WRITE_RESPONSE:              'ATT_WRITE_RESPONSE',
+    ATT_WRITE_COMMAND:               'ATT_WRITE_COMMAND',
+    ATT_SIGNED_WRITE_COMMAND:        'ATT_SIGNED_WRITE_COMMAND',
+    ATT_PREPARE_WRITE_REQUEST:       'ATT_PREPARE_WRITE_REQUEST',
+    ATT_PREPARE_WRITE_RESPONSE:      'ATT_PREPARE_WRITE_RESPONSE',
+    ATT_EXECUTE_WRITE_REQUEST:       'ATT_EXECUTE_WRITE_REQUEST',
+    ATT_EXECUTE_WRITE_RESPONSE:      'ATT_EXECUTE_WRITE_RESPONSE',
+    ATT_HANDLE_VALUE_NOTIFICATION:   'ATT_HANDLE_VALUE_NOTIFICATION',
+    ATT_HANDLE_VALUE_INDICATION:     'ATT_HANDLE_VALUE_INDICATION',
+    ATT_HANDLE_VALUE_CONFIRMATION:   'ATT_HANDLE_VALUE_CONFIRMATION'
+}
+
+ATT_REQUESTS = [
+    ATT_EXCHANGE_MTU_REQUEST,
+    ATT_FIND_INFORMATION_REQUEST,
+    ATT_FIND_BY_TYPE_VALUE_REQUEST,
+    ATT_READ_BY_TYPE_REQUEST,
+    ATT_READ_REQUEST,
+    ATT_READ_BLOB_REQUEST,
+    ATT_READ_MULTIPLE_REQUEST,
+    ATT_READ_BY_GROUP_TYPE_REQUEST,
+    ATT_WRITE_REQUEST,
+    ATT_PREPARE_WRITE_REQUEST,
+    ATT_EXECUTE_WRITE_REQUEST
+]
+
+ATT_RESPONSES = [
+    ATT_ERROR_RESPONSE,
+    ATT_EXCHANGE_MTU_RESPONSE,
+    ATT_FIND_INFORMATION_RESPONSE,
+    ATT_FIND_BY_TYPE_VALUE_RESPONSE,
+    ATT_READ_BY_TYPE_RESPONSE,
+    ATT_READ_RESPONSE,
+    ATT_READ_BLOB_RESPONSE,
+    ATT_READ_MULTIPLE_RESPONSE,
+    ATT_READ_BY_GROUP_TYPE_RESPONSE,
+    ATT_WRITE_RESPONSE,
+    ATT_PREPARE_WRITE_RESPONSE,
+    ATT_EXECUTE_WRITE_RESPONSE
+]
+
+ATT_INVALID_HANDLE_ERROR                   = 0x01
+ATT_READ_NOT_PERMITTED_ERROR               = 0x02
+ATT_WRITE_NOT_PERMITTED_ERROR              = 0x03
+ATT_INVALID_PDU_ERROR                      = 0x04
+ATT_INSUFFICIENT_AUTHENTICATION_ERROR      = 0x05
+ATT_REQUEST_NOT_SUPPORTED_ERROR            = 0x06
+ATT_INVALID_OFFSET_ERROR                   = 0x07
+ATT_INSUFFICIENT_AUTHORIZATION_ERROR       = 0x08
+ATT_PREPARE_QUEUE_FULL_ERROR               = 0x09
+ATT_ATTRIBUTE_NOT_FOUND_ERROR              = 0x0A
+ATT_ATTRIBUTE_NOT_LONG_ERROR               = 0x0B
+ATT_INSUFFICIENT_ENCRYPTION_KEY_SIZE_ERROR = 0x0C
+ATT_INVALID_ATTRIBUTE_LENGTH_ERROR         = 0x0D
+ATT_UNLIKELY_ERROR_ERROR                   = 0x0E
+ATT_INSUFFICIENT_ENCRYPTION_ERROR          = 0x0F
+ATT_UNSUPPORTED_GROUP_TYPE_ERROR           = 0x10
+ATT_INSUFFICIENT_RESOURCES_ERROR           = 0x11
+
+ATT_ERROR_NAMES = {
+    ATT_INVALID_HANDLE_ERROR:                   'ATT_INVALID_HANDLE_ERROR',
+    ATT_READ_NOT_PERMITTED_ERROR:               'ATT_READ_NOT_PERMITTED_ERROR',
+    ATT_WRITE_NOT_PERMITTED_ERROR:              'ATT_WRITE_NOT_PERMITTED_ERROR',
+    ATT_INVALID_PDU_ERROR:                      'ATT_INVALID_PDU_ERROR',
+    ATT_INSUFFICIENT_AUTHENTICATION_ERROR:      'ATT_INSUFFICIENT_AUTHENTICATION_ERROR',
+    ATT_REQUEST_NOT_SUPPORTED_ERROR:            'ATT_REQUEST_NOT_SUPPORTED_ERROR',
+    ATT_INVALID_OFFSET_ERROR:                   'ATT_INVALID_OFFSET_ERROR',
+    ATT_INSUFFICIENT_AUTHORIZATION_ERROR:       'ATT_INSUFFICIENT_AUTHORIZATION_ERROR',
+    ATT_PREPARE_QUEUE_FULL_ERROR:               'ATT_PREPARE_QUEUE_FULL_ERROR',
+    ATT_ATTRIBUTE_NOT_FOUND_ERROR:              'ATT_ATTRIBUTE_NOT_FOUND_ERROR',
+    ATT_ATTRIBUTE_NOT_LONG_ERROR:               'ATT_ATTRIBUTE_NOT_LONG_ERROR',
+    ATT_INSUFFICIENT_ENCRYPTION_KEY_SIZE_ERROR: 'ATT_INSUFFICIENT_ENCRYPTION_KEY_SIZE_ERROR',
+    ATT_INVALID_ATTRIBUTE_LENGTH_ERROR:         'ATT_INVALID_ATTRIBUTE_LENGTH_ERROR',
+    ATT_UNLIKELY_ERROR_ERROR:                   'ATT_UNLIKELY_ERROR_ERROR',
+    ATT_INSUFFICIENT_ENCRYPTION_ERROR:          'ATT_INSUFFICIENT_ENCRYPTION_ERROR',
+    ATT_UNSUPPORTED_GROUP_TYPE_ERROR:           'ATT_UNSUPPORTED_GROUP_TYPE_ERROR',
+    ATT_INSUFFICIENT_RESOURCES_ERROR:           'ATT_INSUFFICIENT_RESOURCES_ERROR'
+}
+
+ATT_DEFAULT_MTU = 23
+
+HANDLE_FIELD_SPEC    = {'size': 2, 'mapper': lambda x: f'0x{x:04X}'}
+UUID_2_16_FIELD_SPEC = lambda x, y: UUID.parse_uuid(x, y)    # noqa: E731
+UUID_2_FIELD_SPEC    = lambda x, y: UUID.parse_uuid_2(x, y)  # noqa: E731
+
+
+# -----------------------------------------------------------------------------
+# Utils
+# -----------------------------------------------------------------------------
+def key_with_value(dictionary, target_value):
+    for key, value in dictionary.items():
+        if value == target_value:
+            return key
+    return None
+
+
+# -----------------------------------------------------------------------------
+# Exceptions
+# -----------------------------------------------------------------------------
+class ATT_Error(Exception):
+    def __init__(self, error_code, att_handle=0x0000):
+        self.error_code = error_code
+        self.att_handle = att_handle
+
+    def __str__(self):
+        return f'ATT_Error({ATT_PDU.error_name(self.error_code)})'
+
+
+# -----------------------------------------------------------------------------
+# Attribute Protocol
+# -----------------------------------------------------------------------------
+class ATT_PDU:
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.3 ATTRIBUTE PDU
+    '''
+    pdu_classes = {}
+    op_code = 0
+
+    @staticmethod
+    def from_bytes(pdu):
+        op_code = pdu[0]
+
+        cls = ATT_PDU.pdu_classes.get(op_code)
+        if cls is None:
+            instance = ATT_PDU(pdu)
+            instance.name = ATT_PDU.pdu_name(op_code)
+            instance.op_code = op_code
+            return instance
+        self = cls.__new__(cls)
+        ATT_PDU.__init__(self, pdu)
+        if hasattr(self, 'fields'):
+            self.init_from_bytes(pdu, 1)
+        return self
+
+    @staticmethod
+    def pdu_name(op_code):
+        return name_or_number(ATT_PDU_NAMES, op_code, 2)
+
+    @staticmethod
+    def error_name(error_code):
+        return name_or_number(ATT_ERROR_NAMES, error_code, 2)
+
+    @staticmethod
+    def subclass(fields):
+        def inner(cls):
+            cls.name = cls.__name__.upper()
+            cls.op_code = key_with_value(ATT_PDU_NAMES, cls.name)
+            if cls.op_code is None:
+                raise KeyError(f'PDU name {cls.name} not found in ATT_PDU_NAMES')
+            cls.fields = fields
+
+            # Register a factory for this class
+            ATT_PDU.pdu_classes[cls.op_code] = cls
+
+            return cls
+
+        return inner
+
+    def __init__(self, pdu=None, **kwargs):
+        if hasattr(self, 'fields') and kwargs:
+            HCI_Object.init_from_fields(self, self.fields, kwargs)
+        if pdu is None:
+            pdu = bytes([self.op_code]) + HCI_Object.dict_to_bytes(kwargs, self.fields)
+        self.pdu = pdu
+
+    def init_from_bytes(self, pdu, offset):
+        return HCI_Object.init_from_bytes(self, pdu, offset, self.fields)
+
+    def to_bytes(self):
+        return self.pdu
+
+    @property
+    def is_command(self):
+        return ((self.op_code >> 6) & 1) == 1
+
+    @property
+    def has_authentication_signature(self):
+        return ((self.op_code >> 7) & 1) == 1
+
+    def __bytes__(self):
+        return self.to_bytes()
+
+    def __str__(self):
+        result = color(self.name, 'yellow')
+        if fields := getattr(self, 'fields', None):
+            result += ':\n' + HCI_Object.format_fields(self.__dict__, fields, '  ')
+        else:
+            if len(self.pdu) > 1:
+                result += f': {self.pdu.hex()}'
+        return result
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass([
+    ('request_opcode_in_error',   {'size': 1, 'mapper': ATT_PDU.pdu_name}),
+    ('attribute_handle_in_error', HANDLE_FIELD_SPEC),
+    ('error_code',                {'size': 1, 'mapper': ATT_PDU.error_name})
+])
+class ATT_Error_Response(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.1.1 Error Response
+    '''
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass([
+    ('client_rx_mtu', 2)
+])
+class ATT_Exchange_MTU_Request(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.2.1 Exchange MTU Request
+    '''
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass([
+    ('server_rx_mtu', 2)
+])
+class ATT_Exchange_MTU_Response(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.2.2 Exchange MTU Response
+    '''
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass([
+    ('starting_handle', HANDLE_FIELD_SPEC),
+    ('ending_handle',   HANDLE_FIELD_SPEC)
+])
+class ATT_Find_Information_Request(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.3.1 Find Information Request
+    '''
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass([
+    ('format',           1),
+    ('information_data', '*')
+])
+class ATT_Find_Information_Response(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.3.2 Find Information Response
+    '''
+
+    def parse_information_data(self):
+        self.information = []
+        offset = 0
+        uuid_size = 2 if self.format == 1 else 16
+        while offset + uuid_size <= len(self.information_data):
+            handle = struct.unpack_from('<H', self.information_data, offset)[0]
+            uuid   = self.information_data[2 + offset:2 + offset + uuid_size]
+            self.information.append((handle, uuid))
+            offset += 2 + uuid_size
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.parse_information_data()
+
+    def init_from_bytes(self, pdu, offset):
+        super().init_from_bytes(pdu, offset)
+        self.parse_information_data()
+
+    def __str__(self):
+        result = color(self.name, 'yellow')
+        result += ':\n' + HCI_Object.format_fields(self.__dict__, [
+            ('format',       1),
+            ('information', {'mapper': lambda x: ', '.join([f'0x{handle:04X}:{uuid.hex()}' for handle, uuid in x])})
+        ], '  ')
+        return result
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass([
+    ('starting_handle', HANDLE_FIELD_SPEC),
+    ('ending_handle',   HANDLE_FIELD_SPEC),
+    ('attribute_type',  UUID_2_FIELD_SPEC),
+    ('attribute_value', '*')
+])
+class ATT_Find_By_Type_Value_Request(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.3.3 Find By Type Value Request
+    '''
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass([
+    ('handles_information_list', '*')
+])
+class ATT_Find_By_Type_Value_Response(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.3.4 Find By Type Value Response
+    '''
+
+    def parse_handles_information_list(self):
+        self.handles_information = []
+        offset = 0
+        while offset + 4 <= len(self.handles_information_list):
+            found_attribute_handle, group_end_handle = struct.unpack_from('<HH', self.handles_information_list, offset)
+            self.handles_information.append((found_attribute_handle, group_end_handle))
+            offset += 4
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.parse_handles_information_list()
+
+    def init_from_bytes(self, pdu, offset):
+        super().init_from_bytes(pdu, offset)
+        self.parse_handles_information_list()
+
+    def __str__(self):
+        result = color(self.name, 'yellow')
+        result += ':\n' + HCI_Object.format_fields(self.__dict__, [
+            ('handles_information', {'mapper': lambda x: ', '.join([f'0x{handle1:04X}-0x{handle2:04X}' for handle1, handle2 in x])})
+        ], '  ')
+        return result
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass([
+    ('starting_handle', HANDLE_FIELD_SPEC),
+    ('ending_handle',   HANDLE_FIELD_SPEC),
+    ('attribute_type',  UUID_2_16_FIELD_SPEC)
+])
+class ATT_Read_By_Type_Request(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.4.1 Read By Type Request
+    '''
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass([
+    ('length',              1),
+    ('attribute_data_list', '*')
+])
+class ATT_Read_By_Type_Response(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.4.2 Read By Type Response
+    '''
+
+    def parse_attribute_data_list(self):
+        self.attributes = []
+        offset = 0
+        while self.length != 0 and offset + self.length <= len(self.attribute_data_list):
+            attribute_handle, = struct.unpack_from('<H', self.attribute_data_list, offset)
+            attribute_value = self.attribute_data_list[offset + 2:offset + self.length]
+            self.attributes.append((attribute_handle, attribute_value))
+            offset += self.length
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.parse_attribute_data_list()
+
+    def init_from_bytes(self, pdu, offset):
+        super().init_from_bytes(pdu, offset)
+        self.parse_attribute_data_list()
+
+    def __str__(self):
+        result = color(self.name, 'yellow')
+        result += ':\n' + HCI_Object.format_fields(self.__dict__, [
+            ('length',     1),
+            ('attributes', {'mapper': lambda x: ', '.join([f'0x{handle:04X}:{value.hex()}' for handle, value in x])})
+        ], '  ')
+        return result
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass([
+    ('attribute_handle', HANDLE_FIELD_SPEC)
+])
+class ATT_Read_Request(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.4.3 Read Request
+    '''
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass([
+    ('attribute_value', '*')
+])
+class ATT_Read_Response(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.4.4 Read Response
+    '''
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass([
+    ('attribute_handle', HANDLE_FIELD_SPEC),
+    ('value_offset',     2)
+])
+class ATT_Read_Blob_Request(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.4.5 Read Blob Request
+    '''
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass([
+    ('part_attribute_value', '*')
+])
+class ATT_Read_Blob_Response(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.4.6 Read Blob Response
+    '''
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass([
+    ('set_of_handles', '*')
+])
+class ATT_Read_Multiple_Request(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.4.7 Read Multiple Request
+    '''
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass([
+    ('set_of_values', '*')
+])
+class ATT_Read_Multiple_Response(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.4.8 Read Multiple Response
+    '''
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass([
+    ('starting_handle',      HANDLE_FIELD_SPEC),
+    ('ending_handle',        HANDLE_FIELD_SPEC),
+    ('attribute_group_type', UUID_2_16_FIELD_SPEC)
+])
+class ATT_Read_By_Group_Type_Request(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.4.9 Read by Group Type Request
+    '''
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass([
+    ('length',              1),
+    ('attribute_data_list', '*')
+])
+class ATT_Read_By_Group_Type_Response(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.4.10 Read by Group Type Response
+    '''
+
+    def parse_attribute_data_list(self):
+        self.attributes = []
+        offset = 0
+        while self.length != 0 and offset + self.length <= len(self.attribute_data_list):
+            attribute_handle, end_group_handle = struct.unpack_from('<HH', self.attribute_data_list, offset)
+            attribute_value = self.attribute_data_list[offset + 4:offset + self.length]
+            self.attributes.append((attribute_handle, end_group_handle, attribute_value))
+            offset += self.length
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.parse_attribute_data_list()
+
+    def init_from_bytes(self, pdu, offset):
+        super().init_from_bytes(pdu, offset)
+        self.parse_attribute_data_list()
+
+    def __str__(self):
+        result = color(self.name, 'yellow')
+        result += ':\n' + HCI_Object.format_fields(self.__dict__, [
+            ('length',     1),
+            ('attributes', {'mapper': lambda x: ', '.join([f'0x{handle:04X}-0x{end:04X}:{value.hex()}' for handle, end, value in x])})
+        ], '  ')
+        return result
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass([
+    ('attribute_handle', HANDLE_FIELD_SPEC),
+    ('attribute_value',  '*')
+])
+class ATT_Write_Request(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.5.1 Write Request
+    '''
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass([])
+class ATT_Write_Response(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.5.2 Write Response
+    '''
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass([
+    ('attribute_handle', HANDLE_FIELD_SPEC),
+    ('attribute_value',  '*')
+])
+class ATT_Write_Command(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.5.3 Write Command
+    '''
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass([
+    ('attribute_handle', HANDLE_FIELD_SPEC),
+    ('attribute_value',  '*')
+    # ('authentication_signature', 'TODO')
+])
+class ATT_Signed_Write_Command(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.5.4 Signed Write Command
+    '''
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass([
+    ('attribute_handle',     HANDLE_FIELD_SPEC),
+    ('value_offset',         2),
+    ('part_attribute_value', '*')
+])
+class ATT_Prepare_Write_Request(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.6.1 Prepare Write Request
+    '''
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass([
+    ('attribute_handle',     HANDLE_FIELD_SPEC),
+    ('value_offset',         2),
+    ('part_attribute_value', '*')
+])
+class ATT_Prepare_Write_Response(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.6.2 Prepare Write Response
+    '''
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass([])
+class ATT_Execute_Write_Request(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.6.3 Execute Write Request
+    '''
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass([])
+class ATT_Execute_Write_Response(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.6.4 Execute Write Response
+    '''
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass([
+    ('attribute_handle', HANDLE_FIELD_SPEC),
+    ('attribute_value',  '*')
+])
+class ATT_Handle_Value_Notification(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.7.1 Handle Value Notification
+    '''
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass([
+    ('attribute_handle', HANDLE_FIELD_SPEC),
+    ('attribute_value',  '*')
+])
+class ATT_Handle_Value_Indication(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.7.2 Handle Value Indication
+    '''
+
+
+# -----------------------------------------------------------------------------
+@ATT_PDU.subclass([])
+class ATT_Handle_Value_Confirmation(ATT_PDU):
+    '''
+    See Bluetooth spec @ Vol 3, Part F - 3.4.7.3 Handle Value Confirmation
+    '''
+
+
+# -----------------------------------------------------------------------------
+class Attribute(EventEmitter):
+    # Permission flags
+    READABLE                      = 0x01
+    WRITEABLE                     = 0x02
+    READ_REQUIRES_ENCRYPTION      = 0x04
+    WRITE_REQUIRES_ENCRYPTION     = 0x08
+    READ_REQUIRES_AUTHENTICATION  = 0x10
+    WRITE_REQUIRES_AUTHENTICATION = 0x20
+    READ_REQUIRES_AUTHORIZATION   = 0x40
+    WRITE_REQUIRES_AUTHORIZATION  = 0x80
+
+    def __init__(self, attribute_type, permissions, value = b''):
+        EventEmitter.__init__(self)
+        self.handle           = 0
+        self.end_group_handle = 0
+        self.permissions      = permissions
+
+        # Convert the type to a UUID object if it isn't already
+        if type(attribute_type) is str:
+            self.type = UUID(attribute_type)
+        elif type(attribute_type) is bytes:
+            self.type = UUID.from_bytes(attribute_type)
+        else:
+            self.type = attribute_type
+
+        # Convert the value to a byte array
+        if type(value) is str:
+            self.value = bytes(value, 'utf-8')
+        else:
+            self.value = value
+
+    def encode_value(self, value):
+        return value
+
+    def decode_value(self, value_bytes):
+        return value_bytes
+
+    def read_value(self, connection):
+        if read := getattr(self.value, 'read', None):
+            try:
+                value = read(connection)
+            except ATT_Error as error:
+                raise ATT_Error(error_code=error.error_code, att_handle=self.handle)
+        else:
+            value = self.value
+
+        return self.encode_value(value)
+
+    def write_value(self, connection, value_bytes):
+        value = self.decode_value(value_bytes)
+
+        if write := getattr(self.value, 'write', None):
+            try:
+                write(connection, value)
+            except ATT_Error as error:
+                raise ATT_Error(error_code=error.error_code, att_handle=self.handle)
+        else:
+            self.value = value
+
+        self.emit('write', connection, value)
+
+    def __repr__(self):
+        if type(self.value) is bytes:
+            value_str = self.value.hex()
+        else:
+            value_str = str(self.value)
+        if value_str:
+            value_string = f', value={self.value.hex()}'
+        else:
+            value_string = ''
+        return f'Attribute(handle=0x{self.handle:04X}, type={self.type}, permissions={self.permissions}{value_string})'

bumble/bridge.py

@@ -0,0 +1,82 @@
+# Copyright 2021-2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import logging
+
+from .hci import HCI_Packet
+from .helpers import PacketTracer
+
+# -----------------------------------------------------------------------------
+# Logging
+# -----------------------------------------------------------------------------
+logger = logging.getLogger(__name__)
+
+
+# -----------------------------------------------------------------------------
+class HCI_Bridge:
+    class Forwarder:
+        def __init__(self, hci_sink, sender_hci_sink, packet_filter, trace):
+            self.hci_sink        = hci_sink
+            self.sender_hci_sink = sender_hci_sink
+            self.packet_filter   = packet_filter
+            self.trace           = trace
+
+        def on_packet(self, packet):
+            # Convert the packet bytes to an object
+            hci_packet = HCI_Packet.from_bytes(packet)
+
+            # Filter the packet
+            if self.packet_filter is not None:
+                filtered = self.packet_filter(hci_packet)
+                if filtered is not None:
+                    packet, respond_to_sender = filtered
+                    hci_packet = HCI_Packet.from_bytes(packet)
+                    if respond_to_sender:
+                        self.sender_hci_sink.on_packet(packet)
+                        return
+
+            # Analyze the packet
+            self.trace(hci_packet)
+
+            # Bridge the packet
+            self.hci_sink.on_packet(packet)
+
+    def __init__(
+        self,
+        hci_host_source,
+        hci_host_sink,
+        hci_controller_source,
+        hci_controller_sink,
+        host_to_controller_filter = None,
+        controller_to_host_filter = None
+    ):
+        tracer = PacketTracer(emit_message=logger.info)
+        host_to_controller_forwarder = HCI_Bridge.Forwarder(
+            hci_controller_sink,
+            hci_host_sink,
+            host_to_controller_filter,
+            lambda packet: tracer.trace(packet, 0)
+        )
+        hci_host_source.set_packet_sink(host_to_controller_forwarder)
+
+        controller_to_host_forwarder = HCI_Bridge.Forwarder(
+            hci_host_sink,
+            hci_controller_sink,
+            controller_to_host_filter,
+            lambda packet: tracer.trace(packet, 1)
+        )
+        hci_controller_source.set_packet_sink(controller_to_host_forwarder)

bumble/controller.py

@@ -0,0 +1,895 @@
+# Copyright 2021-2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import logging
+import asyncio
+import itertools
+import random
+
+from .hci import *
+from .l2cap import *
+
+# -----------------------------------------------------------------------------
+# Logging
+# -----------------------------------------------------------------------------
+logger = logging.getLogger(__name__)
+
+
+# -----------------------------------------------------------------------------
+# Utils
+# -----------------------------------------------------------------------------
+class DataObject:
+    pass
+
+
+# -----------------------------------------------------------------------------
+class Connection:
+    def __init__(self, controller, handle, role, peer_address, link):
+        self.controller   = controller
+        self.handle       = handle
+        self.role         = role
+        self.peer_address = peer_address
+        self.link         = link
+        self.assembler    = HCI_AclDataPacketAssembler(self.on_acl_pdu)
+
+    def on_hci_acl_data_packet(self, packet):
+        self.assembler.feed_packet(packet)
+        self.controller.send_hci_packet(HCI_Number_Of_Completed_Packets_Event([(self.handle, 1)]))
+
+    def on_acl_pdu(self, data):
+        if self.link:
+            self.link.send_acl_data(self.controller.random_address, self.peer_address, data)
+
+
+# -----------------------------------------------------------------------------
+class Controller:
+    def __init__(self, name, host_source = None, host_sink = None, link = None):
+        self.name     = name
+        self.hci_sink = None
+        self.link     = link
+
+        self.central_connections    = {}  # Connections where this controller is the central
+        self.peripheral_connections = {}  # Connections where this controller is the peripheral
+
+        self.hci_version                  = HCI_VERSION_BLUETOOTH_CORE_5_0
+        self.hci_revision                 = 0
+        self.lmp_version                  = HCI_VERSION_BLUETOOTH_CORE_5_0
+        self.lmp_subversion               = 0
+        self.lmp_features                 = bytes.fromhex('0000000060000000')  # BR/EDR Not Supported, LE Supported (Controller)
+        self.manufacturer_name            = 0xFFFF
+        self.hc_le_data_packet_length     = 27
+        self.hc_total_num_le_data_packets = 64
+        self.supported_commands           = bytes.fromhex('2000800000c000000000e40000002822000000000000040000f7ffff7f00000030f0f9ff01008004000000000000000000000000000000000000000000000000')
+        self.le_features                  = bytes.fromhex('ff49010000000000')
+        self.le_states                    = bytes.fromhex('ffff3fffff030000')
+        self.avertising_channel_tx_power  = 0
+        self.filter_accept_list_size      = 8
+        self.resolving_list_size          = 8
+        self.supported_max_tx_octets      = 27
+        self.supported_max_tx_time        = 10000  # microseconds
+        self.supported_max_rx_octets      = 27
+        self.supported_max_rx_time        = 10000  # microseconds
+        self.suggested_max_tx_octets      = 27
+        self.suggested_max_tx_time        = 0x0148  # microseconds
+        self.default_phy                  = bytes([0, 0, 0])
+        self.le_scan_type                 = 0
+        self.le_scan_interval             = 0x10
+        self.le_scan_window               = 0x10
+        self.le_scan_enable               = 0
+        self.le_scan_own_address_type     = Address.RANDOM_DEVICE_ADDRESS
+        self.le_scanning_filter_policy    = 0
+        self.le_scan_response_data        = None
+        self.le_address_resolution        = False
+        self.le_rpa_timeout               = 0
+        self.sync_flow_control            = False
+        self.local_name                   = 'Bumble'
+
+        self.advertising_interval     = 2000  # Fixed for now
+        self.advertising_data         = None
+        self.advertising_timer_handle = None
+
+        self._random_address = Address('00:00:00:00:00:00')
+        self._public_address = None
+
+        # Set the source and sink interfaces
+        if host_source:
+            host_source.set_packet_sink(self)
+        self.host = host_sink
+
+        # Add this controller to the link if specified
+        if link:
+            link.add_controller(self)
+
+    @property
+    def host(self):
+        return self.hci_sink
+
+    @host.setter
+    def host(self, host):
+        '''
+        Sets the host (sink) for this controller, and set this controller as the controller (sink) for the host
+        '''
+        self.set_packet_sink(host)
+        if host:
+            host.controller = self
+
+    def set_packet_sink(self, sink):
+        '''
+        Method from the Packet Source interface
+        '''
+        self.hci_sink = sink
+
+    @property
+    def public_address(self):
+        return self._public_address
+
+    @public_address.setter
+    def public_address(self, address):
+        if type(address) is str:
+            address = Address(address)
+        self._public_address = address
+
+    @property
+    def random_address(self):
+        return self._random_address
+
+    @random_address.setter
+    def random_address(self, address):
+        if type(address) is str:
+            address = Address(address)
+        self._random_address = address
+        logger.debug(f'new random address: {address}')
+
+        if self.link:
+            self.link.on_address_changed(self)
+
+    # Packet Sink protocol (packets coming from the host via HCI)
+    def on_packet(self, packet):
+        self.on_hci_packet(HCI_Packet.from_bytes(packet))
+
+    def on_hci_packet(self, packet):
+        logger.debug(f'{color("<<<", "blue")} [{self.name}] {color("HOST -> CONTROLLER", "blue")}: {packet}')
+
+        # 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)
+        elif packet.hci_packet_type == HCI_EVENT_PACKET:
+            self.on_hci_event_packet(packet)
+        elif packet.hci_packet_type == HCI_ACL_DATA_PACKET:
+            self.on_hci_acl_data_packet(packet)
+        else:
+            logger.warning(f'!!! unknown packet type {packet.hci_packet_type}')
+
+    def on_hci_command_packet(self, command):
+        handler_name = f'on_{command.name.lower()}'
+        handler = getattr(self, handler_name, self.on_hci_command)
+        result = handler(command)
+        if type(result) is bytes:
+            self.send_hci_packet(HCI_Command_Complete_Event(
+                num_hci_command_packets = 1,
+                command_opcode          = command.op_code,
+                return_parameters       = result
+            ))
+
+    def on_hci_event_packet(self, event):
+        logger.warning('!!! unexpected event packet')
+
+    def on_hci_acl_data_packet(self, packet):
+        # Look for the connection to which this data belongs
+        connection = self.find_connection_by_handle(packet.connection_handle)
+        if connection is None:
+            logger.warning(f'!!! no connection for handle 0x{packet.connection_handle:04X}')
+            return
+
+        # Pass the packet to the connection
+        connection.on_hci_acl_data_packet(packet)
+
+    def send_hci_packet(self, packet):
+        logger.debug(f'{color(">>>", "green")} [{self.name}] {color("CONTROLLER -> HOST", "green")}: {packet}')
+        if self.host:
+            self.host.on_packet(packet.to_bytes())
+
+    # This method allow the controller to emulate the same API as a transport source
+    async def wait_for_termination(self):
+        # For now, just wait forever
+        await asyncio.get_running_loop().create_future()
+
+    ############################################################
+    # Link connections
+    ############################################################
+    def allocate_connection_handle(self):
+        handle = 0
+        max_handle = 0
+        for connection in itertools.chain(
+            self.central_connections.values(),
+            self.peripheral_connections.values()
+        ):
+            max_handle = max(max_handle, connection.handle)
+            if connection.handle == handle:
+                # Already used, continue searching after the current max
+                handle = max_handle + 1
+        return handle
+
+    def find_connection_by_address(self, address):
+        return self.central_connections.get(address) or self.peripheral_connections.get(address)
+
+    def find_connection_by_handle(self, handle):
+        for connection in itertools.chain(
+            self.central_connections.values(),
+            self.peripheral_connections.values()
+        ):
+            if connection.handle == handle:
+                return connection
+        return None
+
+    def find_central_connection_by_handle(self, handle):
+        for connection in self.central_connections.values():
+            if connection.handle == handle:
+                return connection
+        return None
+
+    def on_link_central_connected(self, central_address):
+        '''
+        Called when an incoming connection occurs from a central on the link
+        '''
+
+        # Allocate (or reuse) a connection handle
+        peer_address = central_address
+        peer_address_type = central_address.address_type
+        connection = self.peripheral_connections.get(peer_address)
+        if connection is None:
+            connection_handle = self.allocate_connection_handle()
+            connection = Connection(self, connection_handle, BT_PERIPHERAL_ROLE, peer_address, self.link)
+            self.peripheral_connections[peer_address] = connection
+            logger.debug(f'New PERIPHERAL connection handle: 0x{connection_handle:04X}')
+
+        # Then say that the connection has completed
+        self.send_hci_packet(HCI_LE_Connection_Complete_Event(
+            status                = HCI_SUCCESS,
+            connection_handle     = connection.handle,
+            role                  = connection.role,
+            peer_address_type     = peer_address_type,
+            peer_address          = peer_address,
+            conn_interval         = 10,  # FIXME
+            conn_latency          = 0,   # FIXME
+            supervision_timeout   = 10,  # FIXME
+            master_clock_accuracy = 7    # FIXME
+        ))
+
+    def on_link_central_disconnected(self, peer_address, reason):
+        '''
+        Called when an active disconnection occurs from a peer
+        '''
+
+        # Send a disconnection complete event
+        if connection := self.peripheral_connections.get(peer_address):
+            self.send_hci_packet(HCI_Disconnection_Complete_Event(
+                status            = HCI_SUCCESS,
+                connection_handle = connection.handle,
+                reason            = reason
+            ))
+
+            # Remove the connection
+            del self.peripheral_connections[peer_address]
+        else:
+            logger.warn(f'!!! No peripheral connection found for {peer_address}')
+
+    def on_link_peripheral_connection_complete(self, le_create_connection_command, status):
+        '''
+        Called by the link when a connection has been made or has failed to be made
+        '''
+
+        if status == HCI_SUCCESS:
+            # Allocate (or reuse) a connection handle
+            peer_address = le_create_connection_command.peer_address
+            connection = self.central_connections.get(peer_address)
+            if connection is None:
+                connection_handle = self.allocate_connection_handle()
+                connection = Connection(
+                    self,
+                    connection_handle,
+                    BT_CENTRAL_ROLE,
+                    peer_address,
+                    self.link
+                )
+                self.central_connections[peer_address] = connection
+                logger.debug(f'New CENTRAL connection handle: 0x{connection_handle:04X}')
+        else:
+            connection = None
+
+        # Say that the connection has completed
+        self.send_hci_packet(HCI_LE_Connection_Complete_Event(
+            status                = status,
+            connection_handle     = connection.handle if connection else 0,
+            role                  = BT_CENTRAL_ROLE,
+            peer_address_type     = le_create_connection_command.peer_address_type,
+            peer_address          = le_create_connection_command.peer_address,
+            conn_interval         = le_create_connection_command.conn_interval_min,
+            conn_latency          = le_create_connection_command.conn_latency,
+            supervision_timeout   = le_create_connection_command.supervision_timeout,
+            master_clock_accuracy = 0
+        ))
+
+    def on_link_peripheral_disconnection_complete(self, disconnection_command, status):
+        '''
+        Called when a disconnection has been completed
+        '''
+
+        # Send a disconnection complete event
+        self.send_hci_packet(HCI_Disconnection_Complete_Event(
+            status            = status,
+            connection_handle = disconnection_command.connection_handle,
+            reason            = disconnection_command.reason
+        ))
+
+        # Remove the connection
+        if connection := self.find_central_connection_by_handle(disconnection_command.connection_handle):
+            logger.debug(f'CENTRAL Connection removed: {connection}')
+            del self.central_connections[connection.peer_address]
+
+    def on_link_peripheral_disconnected(self, peer_address):
+        '''
+        Called when a connection to a peripheral is broken
+        '''
+
+        # Send a disconnection complete event
+        if connection := self.central_connections.get(peer_address):
+            self.send_hci_packet(HCI_Disconnection_Complete_Event(
+                status            = HCI_SUCCESS,
+                connection_handle = connection.handle,
+                reason            = HCI_CONNECTION_TIMEOUT_ERROR
+            ))
+
+            # Remove the connection
+            del self.central_connections[peer_address]
+        else:
+            logger.warn(f'!!! No central connection found for {peer_address}')
+
+    def on_link_encrypted(self, peer_address, rand, ediv, ltk):
+        # For now, just setup the encryption without asking the host
+        if connection := self.find_connection_by_address(peer_address):
+            self.send_hci_packet(
+                HCI_Encryption_Change_Event(
+                    status             = 0,
+                    connection_handle  = connection.handle,
+                    encryption_enabled = 1
+                )
+            )
+
+    def on_link_acl_data(self, sender_address, data):
+        # Look for the connection to which this data belongs
+        connection = self.find_connection_by_address(sender_address)
+        if connection is None:
+            logger.warning(f'!!! no connection for {sender_address}')
+            return
+
+        # Send the data to the host
+        # TODO: should fragment
+        acl_packet = HCI_AclDataPacket(connection.handle, 2, 0, len(data), data)
+        self.send_hci_packet(acl_packet)
+
+    def on_link_advertising_data(self, sender_address, data):
+        # Ignore if we're not scanning
+        if self.le_scan_enable == 0:
+            return
+
+        # Send a scan report
+        report = HCI_Object(
+            HCI_LE_Advertising_Report_Event.REPORT_FIELDS,
+            event_type   = HCI_LE_Advertising_Report_Event.ADV_IND,
+            address_type = sender_address.address_type,
+            address      = sender_address,
+            data         = data,
+            rssi         = -50
+        )
+        self.send_hci_packet(HCI_LE_Advertising_Report_Event([report]))
+
+        # Simulate a scan response
+        report = HCI_Object(
+            HCI_LE_Advertising_Report_Event.REPORT_FIELDS,
+            event_type   = HCI_LE_Advertising_Report_Event.SCAN_RSP,
+            address_type = sender_address.address_type,
+            address      = sender_address,
+            data         = data,
+            rssi         = -50
+        )
+        self.send_hci_packet(HCI_LE_Advertising_Report_Event([report]))
+
+    ############################################################
+    # Advertising support
+    ############################################################
+    def on_advertising_timer_fired(self):
+        self.send_advertising_data()
+        self.advertising_timer_handle = asyncio.get_running_loop().call_later(self.advertising_interval / 1000.0, self.on_advertising_timer_fired)
+
+    def start_advertising(self):
+        # Stop any ongoing advertising before we start again
+        self.stop_advertising()
+
+        # Advertise now
+        self.advertising_timer_handle = asyncio.get_running_loop().call_soon(self.on_advertising_timer_fired)
+
+    def stop_advertising(self):
+        if self.advertising_timer_handle is not None:
+            self.advertising_timer_handle.cancel()
+            self.advertising_timer_handle = None
+
+    def send_advertising_data(self):
+        if self.link and self.advertising_data:
+            self.link.send_advertising_data(self.random_address, self.advertising_data)
+
+    @property
+    def is_advertising(self):
+        return self.advertising_timer_handle is not None
+
+    ############################################################
+    # HCI handlers
+    ############################################################
+    def on_hci_command(self, command):
+        logger.warning(color(f'--- Unsupported command {command}', 'red'))
+        return bytes([HCI_UNKNOWN_HCI_COMMAND_ERROR])
+
+    def on_hci_create_connection_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.1.5 Create Connection command
+        '''
+
+        # TODO: classic mode not supported yet
+
+    def on_hci_disconnect_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.1.6 Disconnect Command
+        '''
+        # First, say that the disconnection is pending
+        self.send_hci_packet(HCI_Command_Status_Event(
+            status                  = HCI_COMMAND_STATUS_PENDING,
+            num_hci_command_packets = 1,
+            command_opcode          = command.op_code
+        ))
+
+        # Notify the link of the disconnection
+        if not (connection := self.find_central_connection_by_handle(command.connection_handle)):
+            logger.warn('connection not found')
+            return
+
+        if self.link:
+            self.link.disconnect(self.random_address, connection.peer_address, command)
+        else:
+            # Remove the connection
+            del self.central_connections[connection.peer_address]
+
+    def on_hci_set_event_mask_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.3.1 Set Event Mask Command
+        '''
+        self.event_mask = command.event_mask
+        return bytes([HCI_SUCCESS])
+
+    def on_hci_reset_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.3.2 Reset Command
+        '''
+        # TODO: cleanup what needs to be reset
+        return bytes([HCI_SUCCESS])
+
+    def on_hci_write_local_name_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.3.11 Write Local Name Command
+        '''
+        local_name = command.local_name
+        if len(local_name):
+            try:
+                first_null = local_name.find(0)
+                if first_null >= 0:
+                    local_name = local_name[:first_null]
+                self.local_name = str(local_name, 'utf-8')
+            except UnicodeDecodeError:
+                pass
+        return bytes([HCI_SUCCESS])
+
+    def on_hci_read_local_name_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.3.12 Read Local Name Command
+        '''
+        local_name = bytes(self.local_name, 'utf-8')[:248]
+        if len(local_name) < 248:
+            local_name = local_name + bytes(248 - len(local_name))
+
+        return bytes([HCI_SUCCESS]) + local_name
+
+    def on_hci_read_class_of_device_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.3.25 Read Class of Device Command
+        '''
+        return bytes([HCI_SUCCESS, 0, 0, 0])
+
+    def on_hci_write_class_of_device_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.3.26 Write Class of Device Command
+        '''
+        return bytes([HCI_SUCCESS])
+
+    def on_hci_read_synchronous_flow_control_enable_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.3.36 Read Synchronous Flow Control Enable Command
+        '''
+        if self.sync_flow_control:
+            ret = 1
+        else:
+            ret = 0
+        return bytes([HCI_SUCCESS, ret])
+
+    def on_hci_write_synchronous_flow_control_enable_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.3.37 Write Synchronous Flow Control Enable Command
+        '''
+        ret = HCI_SUCCESS
+        if command.synchronous_flow_control_enable == 1:
+            self.sync_flow_control = True
+        elif command.synchronous_flow_control_enable == 0:
+            self.sync_flow_control = False
+        else:
+            ret = HCI_INVALID_HCI_COMMAND_PARAMETERS_ERROR
+        return bytes([ret])
+
+    def on_hci_write_simple_pairing_mode_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.3.59 Write Simple Pairing Mode Command
+        '''
+        return bytes([HCI_SUCCESS])
+
+    def on_hci_set_event_mask_page_2_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.3.69 Set Event Mask Page 2 Command
+        '''
+        self.event_mask_page_2 = command.event_mask_page_2
+        return bytes([HCI_SUCCESS])
+
+    def on_hci_read_le_host_support_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.3.78 Write LE Host Support Command
+        '''
+        return bytes([HCI_SUCCESS, 1, 0])
+
+    def on_hci_write_le_host_support_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.3.79 Write LE Host Support Command
+        '''
+        # TODO / Just ignore for now
+        return bytes([HCI_SUCCESS])
+
+    def on_hci_write_authenticated_payload_timeout_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.3.94 Write Authenticated Payload Timeout Command
+        '''
+        # TODO
+        return struct.pack('<BH', HCI_SUCCESS, command.connection_handle)
+
+    def on_hci_read_local_version_information_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.4.1 Read Local Version Information Command
+        '''
+        return struct.pack('<BBHBHH',
+                           HCI_SUCCESS,
+                           self.hci_version,
+                           self.hci_revision,
+                           self.lmp_version,
+                           self.manufacturer_name,
+                           self.lmp_subversion)
+
+    def on_hci_read_local_supported_commands_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.4.2 Read Local Supported Commands Command
+        '''
+        return bytes([HCI_SUCCESS]) + self.supported_commands
+
+    def on_hci_read_local_supported_features_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.4.3 Read Local Supported Features Command
+        '''
+        return bytes([HCI_SUCCESS]) + self.lmp_features
+
+    def on_hci_read_bd_addr_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.4.6 Read BD_ADDR Command
+        '''
+        bd_addr = self._public_address.to_bytes() if self._public_address is not None else bytes(6)
+        return bytes([HCI_SUCCESS]) + bd_addr
+
+    def on_hci_le_set_event_mask_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.8.1 LE Set Event Mask Command
+        '''
+        self.le_event_mask = command.le_event_mask
+        return bytes([HCI_SUCCESS])
+
+    def on_hci_le_read_buffer_size_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.8.2 LE Read Buffer Size Command
+        '''
+        return struct.pack('<BHB',
+                           HCI_SUCCESS,
+                           self.hc_le_data_packet_length,
+                           self.hc_total_num_le_data_packets)
+
+    def on_hci_le_read_local_supported_features_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.8.3 LE Read Local Supported Features Command
+        '''
+        return bytes([HCI_SUCCESS]) + self.le_features
+
+    def on_hci_le_set_random_address_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.8.4 LE Set Random Address Command
+        '''
+        self.random_address = command.random_address
+        return bytes([HCI_SUCCESS])
+
+    def on_hci_le_set_advertising_parameters_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.8.5 LE Set Advertising Parameters Command
+        '''
+        self.advertising_parameters = command
+        return bytes([HCI_SUCCESS])
+
+    def on_hci_le_read_advertising_channel_tx_power_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.8.6 LE Read Advertising Channel Tx Power Command
+        '''
+        return bytes([HCI_SUCCESS, self.avertising_channel_tx_power])
+
+    def on_hci_le_set_advertising_data_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.8.7 LE Set Advertising Data Command
+        '''
+        self.advertising_data = command.advertising_data
+        return bytes([HCI_SUCCESS])
+
+    def on_hci_le_set_scan_response_data_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.8.8 LE Set Scan Response Data Command
+        '''
+        self.le_scan_response_data = command.scan_response_data
+        return bytes([HCI_SUCCESS])
+
+    def on_hci_le_set_advertising_enable_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.8.9 LE Set Advertising Enable Command
+        '''
+        if command.advertising_enable:
+            self.start_advertising()
+        else:
+            self.stop_advertising()
+
+        return bytes([HCI_SUCCESS])
+
+    def on_hci_le_set_scan_parameters_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.8.10 LE Set Scan Parameters Command
+        '''
+        self.le_scan_type              = command.le_scan_type
+        self.le_scan_interval          = command.le_scan_interval
+        self.le_scan_window            = command.le_scan_window
+        self.le_scan_own_address_type  = command.own_address_type
+        self.le_scanning_filter_policy = command.scanning_filter_policy
+        return bytes([HCI_SUCCESS])
+
+    def on_hci_le_set_scan_enable_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.8.11 LE Set Scan Enable Command
+        '''
+        self.le_scan_enable    = command.le_scan_enable
+        self.filter_duplicates = command.filter_duplicates
+        return bytes([HCI_SUCCESS])
+
+    def on_hci_le_create_connection_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.8.12 LE Create Connection Command
+        '''
+
+        if not self.link:
+            return
+
+        logger.debug(f'Connection request to {command.peer_address}')
+
+        # Check that we don't already have a pending connection
+        if self.link.get_pending_connection():
+            self.send_hci_packet(HCI_Command_Status_Event(
+                status                  = HCI_COMMAND_DISALLOWED_ERROR,
+                num_hci_command_packets = 1,
+                command_opcode          = command.op_code
+            ))
+            return
+
+        # Initiate the connection
+        self.link.connect(self.random_address, command)
+
+        # Say that the connection is pending
+        self.send_hci_packet(HCI_Command_Status_Event(
+            status                  = HCI_COMMAND_STATUS_PENDING,
+            num_hci_command_packets = 1,
+            command_opcode          = command.op_code
+        ))
+
+    def on_hci_le_create_connection_cancel_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.8.13 LE Create Connection Cancel Command
+        '''
+        return bytes([HCI_SUCCESS])
+
+    def on_hci_le_read_filter_accept_list_size_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.8.14 LE Read Filter Accept List Size Command
+        '''
+        return bytes([HCI_SUCCESS, self.filter_accept_list_size])
+
+    def on_hci_le_clear_filter_accept_list_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.8.15 LE Clear Filter Accept List Command
+        '''
+        return bytes([HCI_SUCCESS])
+
+    def on_hci_le_add_device_to_filter_accept_list_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.8.16 LE Add Device To Filter Accept List Command
+        '''
+        return bytes([HCI_SUCCESS])
+
+    def on_hci_le_remove_device_from_filter_accept_list_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.8.17 LE Remove Device From Filter Accept List Command
+        '''
+        return bytes([HCI_SUCCESS])
+
+    def on_hci_le_read_remote_features_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.8.21 LE Read Remote Features Command
+        '''
+
+        # First, say that the command is pending
+        self.send_hci_packet(HCI_Command_Status_Event(
+            status                  = HCI_COMMAND_STATUS_PENDING,
+            num_hci_command_packets = 1,
+            command_opcode          = command.op_code
+        ))
+
+        # Then send the remote features
+        self.send_hci_packet(HCI_LE_Read_Remote_Features_Complete_Event(
+            status            = HCI_SUCCESS,
+            connection_handle = 0,
+            le_features       = bytes.fromhex('dd40000000000000')
+        ))
+
+    def on_hci_le_rand_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.8.23 LE Rand Command
+        '''
+        return bytes([HCI_SUCCESS]) + struct.pack('Q', random.randint(0, 1 << 64))
+
+    def on_hci_le_enable_encryption_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.8.24 LE Enable Encryption Command
+        '''
+
+        # Check the parameters
+        if not (connection := self.find_central_connection_by_handle(command.connection_handle)):
+            logger.warn('connection not found')
+            return bytes([HCI_INVALID_HCI_COMMAND_PARAMETERS_ERROR])
+
+        # Notify that the connection is now encrypted
+        self.link.on_connection_encrypted(
+            self.random_address,
+            connection.peer_address,
+            command.random_number,
+            command.encrypted_diversifier,
+            command.long_term_key
+        )
+
+        self.send_hci_packet(HCI_Command_Status_Event(
+            status                  = HCI_COMMAND_STATUS_PENDING,
+            num_hci_command_packets = 1,
+            command_opcode          = command.op_code
+        ))
+
+    def on_hci_le_read_supported_states_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.8.27 LE Read Supported States Command
+        '''
+        return bytes([HCI_SUCCESS]) + self.le_states
+
+    def on_hci_le_read_suggested_default_data_length_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.8.34 LE Read Suggested Default Data Length Command
+        '''
+        return struct.pack('<BHH',
+                           HCI_SUCCESS,
+                           self.suggested_max_tx_octets,
+                           self.suggested_max_tx_time)
+
+    def on_hci_le_write_suggested_default_data_length_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.8.35 LE Write Suggested Default Data Length Command
+        '''
+        self.suggested_max_tx_octets, self.suggested_max_tx_time = struct.unpack('<HH', command.parameters[:4])
+        return bytes([HCI_SUCCESS])
+
+    def on_hci_le_read_local_p_256_public_key_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.8.36 LE Read P-256 Public Key Command
+        '''
+        # TODO create key and send HCI_LE_Read_Local_P-256_Public_Key_Complete event
+        return bytes([HCI_SUCCESS])
+
+    def on_hci_le_add_device_to_resolving_list_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.8.38 LE Add Device To Resolving List Command
+        '''
+        return bytes([HCI_SUCCESS])
+
+    def on_hci_le_clear_resolving_list_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.8.40 LE Clear Resolving List Command
+        '''
+        return bytes([HCI_SUCCESS])
+
+    def on_hci_le_read_resolving_list_size_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.8.41 LE Read Resolving List Size Command
+        '''
+        return bytes([HCI_SUCCESS, self.resolving_list_size])
+
+    def on_hci_le_set_address_resolution_enable_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.8.44 LE Set Address Resolution Enable Command
+        '''
+        ret = HCI_SUCCESS
+        if command.address_resolution == 1:
+            self.le_address_resolution = True
+        elif command.address_resolution == 0:
+            self.le_address_resolution = False
+        else:
+            ret = HCI_INVALID_HCI_COMMAND_PARAMETERS_ERROR
+        return bytes([ret])
+
+    def on_hci_le_set_resolvable_private_address_timeout_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.8.45 LE Set Resolvable Private Address Timeout Command
+        '''
+        self.le_rpa_timeout = command.rpa_timeout
+        return bytes([HCI_SUCCESS])
+
+    def on_hci_le_read_maximum_data_length_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.8.46 LE Read Maximum Data Length Command
+        '''
+        return struct.pack('<BHHHH',
+                           HCI_SUCCESS,
+                           self.supported_max_tx_octets,
+                           self.supported_max_tx_time,
+                           self.supported_max_rx_octets,
+                           self.supported_max_rx_time)
+
+    def on_hci_le_set_default_phy_command(self, command):
+        '''
+        See Bluetooth spec Vol 2, Part E - 7.8.48 LE Set Default PHY Command
+        '''
+        self.default_phy = {
+            'all_phys': command.all_phys,
+            'tx_phys':  command.tx_phys,
+            'rx_phys':  command.rx_phys
+        }
+        return bytes([HCI_SUCCESS])

bumble/core.py

@@ -0,0 +1,852 @@
+# Copyright 2021-2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import struct
+
+from .company_ids import COMPANY_IDENTIFIERS
+
+
+# -----------------------------------------------------------------------------
+# Constants
+# -----------------------------------------------------------------------------
+BT_CENTRAL_ROLE    = 0
+BT_PERIPHERAL_ROLE = 1
+
+BT_BR_EDR_TRANSPORT = 0
+BT_LE_TRANSPORT     = 1
+
+
+# -----------------------------------------------------------------------------
+# Utils
+# -----------------------------------------------------------------------------
+def bit_flags_to_strings(bits, bit_flag_names):
+    names = []
+    index = 0
+    while bits != 0:
+        if bits & 1:
+            name = bit_flag_names[index] if index < len(bit_flag_names) else f'#{index}'
+            names.append(name)
+        bits >>= 1
+        index += 1
+
+    return names
+
+
+def name_or_number(dictionary, number, width=2):
+    name = dictionary.get(number)
+    if name is not None:
+        return name
+    return f'[0x{number:0{width}X}]'
+
+
+def padded_bytes(buffer, size):
+    padding_size = max(size - len(buffer), 0)
+    return buffer + bytes(padding_size)
+
+
+# -----------------------------------------------------------------------------
+# Exceptions
+# -----------------------------------------------------------------------------
+class BaseError(Exception):
+    """ Base class for errors with an error code, error name and namespace"""
+    def __init__(self, error_code, error_namespace='', error_name='', details=''):
+        super().__init__()
+        self.error_code      = error_code
+        self.error_namespace = error_namespace
+        self.error_name      = error_name
+        self.details         = details
+
+    def __str__(self):
+        if self.error_namespace:
+            namespace = f'{self.error_namespace}/'
+        else:
+            namespace = ''
+        if self.error_name:
+            name = f'{self.error_name} [0x{self.error_code:X}]'
+        else:
+            name = f'0x{self.error_code:X}'
+
+        return f'{type(self).__name__}({namespace}{name})'
+
+
+class ProtocolError(BaseError):
+    """ Protocol Error """
+
+
+class TimeoutError(Exception):
+    """ Timeout Error """
+
+
+class InvalidStateError(Exception):
+    """ Invalid State Error """
+
+
+class ConnectionError(BaseError):
+    """ Connection Error """
+    FAILURE            = 0x01
+    CONNECTION_REFUSED = 0x02
+
+
+# -----------------------------------------------------------------------------
+# UUID
+#
+# NOTE: the internal byte representation is in little-endian byte order
+#
+# Base UUID: 00000000-0000-1000-8000- 00805F9B34FB
+# -----------------------------------------------------------------------------
+class UUID:
+    '''
+    See Bluetooth spec Vol 3, Part B - 2.5.1 UUID
+    '''
+    BASE_UUID = bytes.fromhex('00001000800000805F9B34FB')
+    UUIDS = []  # Registry of all instances created
+
+    def __init__(self, uuid_str_or_int, name = None):
+        if type(uuid_str_or_int) is int:
+            self.uuid_bytes = struct.pack('<H', uuid_str_or_int)
+        else:
+            if len(uuid_str_or_int) == 36:
+                if uuid_str_or_int[8] != '-' or uuid_str_or_int[13] != '-' or uuid_str_or_int[18] != '-' or uuid_str_or_int[23] != '-':
+                    raise ValueError('invalid UUID format')
+                uuid_str = uuid_str_or_int.replace('-', '')
+            else:
+                uuid_str = uuid_str_or_int
+            if len(uuid_str) != 32 and len(uuid_str) != 8 and len(uuid_str) != 4:
+                raise ValueError('invalid UUID format')
+            self.uuid_bytes = bytes(reversed(bytes.fromhex(uuid_str)))
+        self.name = name
+
+    def register(self):
+        # Register this object in the class registry, and update the entry's name if it wasn't set already
+        for uuid in self.UUIDS:
+            if self == uuid:
+                if uuid.name is None:
+                    uuid.name = self.name
+                return uuid
+
+        self.UUIDS.append(self)
+        return self
+
+    @classmethod
+    def from_bytes(cls, uuid_bytes, name = None):
+        if len(uuid_bytes) in {2, 4, 16}:
+            self = cls.__new__(cls)
+            self.uuid_bytes = uuid_bytes
+            self.name = name
+
+            return self.register()
+        else:
+            raise ValueError('only 2, 4 and 16 bytes are allowed')
+
+    @classmethod
+    def from_16_bits(cls, uuid_16, name = None):
+        return cls.from_bytes(struct.pack('<H', uuid_16), name)
+
+    @classmethod
+    def from_32_bits(cls, uuid_32, name = None):
+        return cls.from_bytes(struct.pack('<I', uuid_32), name)
+
+    @classmethod
+    def parse_uuid(cls, bytes, offset):
+        return len(bytes), cls.from_bytes(bytes[offset:])
+
+    @classmethod
+    def parse_uuid_2(cls, bytes, offset):
+        return offset + 2, cls.from_bytes(bytes[offset:offset + 2])
+
+    def to_bytes(self, force_128 = False):
+        if len(self.uuid_bytes) == 16 or not force_128:
+            return self.uuid_bytes
+        elif len(self.uuid_bytes) == 4:
+            return self.uuid_bytes + UUID.BASE_UUID
+        else:
+            return self.uuid_bytes + bytes([0, 0]) + UUID.BASE_UUID
+
+    def to_pdu_bytes(self):
+        '''
+        Convert to bytes for use in an ATT PDU.
+        According to Vol 3, Part F - 3.2.1 Attribute Type:
+        "All 32-bit Attribute UUIDs shall be converted to 128-bit UUIDs when the
+         Attribute UUID is contained in an ATT PDU."
+        '''
+        return self.to_bytes(force_128 = (len(self.uuid_bytes) == 4))
+
+    def to_hex_str(self):
+        if len(self.uuid_bytes) == 2 or len(self.uuid_bytes) == 4:
+            return bytes(reversed(self.uuid_bytes)).hex().upper()
+        else:
+            return ''.join([
+                bytes(reversed(self.uuid_bytes[12:16])).hex(),
+                bytes(reversed(self.uuid_bytes[10:12])).hex(),
+                bytes(reversed(self.uuid_bytes[8:10])).hex(),
+                bytes(reversed(self.uuid_bytes[6:8])).hex(),
+                bytes(reversed(self.uuid_bytes[0:6])).hex()
+            ]).upper()
+
+    def __bytes__(self):
+        return self.to_bytes()
+
+    def __eq__(self, other):
+        if isinstance(other, UUID):
+            return self.to_bytes(force_128 = True) == other.to_bytes(force_128 = True)
+        elif type(other) is str:
+            return UUID(other) == self
+
+        return False
+
+    def __hash__(self):
+        return hash(self.uuid_bytes)
+
+    def __str__(self):
+        if len(self.uuid_bytes) == 2:
+            v = struct.unpack('<H', self.uuid_bytes)[0]
+            result = f'UUID-16:{v:04X}'
+        elif len(self.uuid_bytes) == 4:
+            v = struct.unpack('<I', self.uuid_bytes)[0]
+            result = f'UUID-32:{v:08X}'
+        else:
+            result = '-'.join([
+                bytes(reversed(self.uuid_bytes[12:16])).hex(),
+                bytes(reversed(self.uuid_bytes[10:12])).hex(),
+                bytes(reversed(self.uuid_bytes[8:10])).hex(),
+                bytes(reversed(self.uuid_bytes[6:8])).hex(),
+                bytes(reversed(self.uuid_bytes[0:6])).hex()
+            ]).upper()
+        if self.name is not None:
+            return result + f' ({self.name})'
+        else:
+            return result
+
+    def __repr__(self):
+        return str(self)
+
+
+# -----------------------------------------------------------------------------
+# Common UUID constants
+# -----------------------------------------------------------------------------
+
+# Protocol Identifiers
+BT_SDP_PROTOCOL_ID                      = UUID.from_16_bits(0x0001, 'SDP')
+BT_UDP_PROTOCOL_ID                      = UUID.from_16_bits(0x0002, 'UDP')
+BT_RFCOMM_PROTOCOL_ID                   = UUID.from_16_bits(0x0003, 'RFCOMM')
+BT_TCP_PROTOCOL_ID                      = UUID.from_16_bits(0x0004, 'TCP')
+BT_TCS_BIN_PROTOCOL_ID                  = UUID.from_16_bits(0x0005, 'TCP-BIN')
+BT_TCS_AT_PROTOCOL_ID                   = UUID.from_16_bits(0x0006, 'TCS-AT')
+BT_ATT_PROTOCOL_ID                      = UUID.from_16_bits(0x0007, 'ATT')
+BT_OBEX_PROTOCOL_ID                     = UUID.from_16_bits(0x0008, 'OBEX')
+BT_IP_PROTOCOL_ID                       = UUID.from_16_bits(0x0009, 'IP')
+BT_FTP_PROTOCOL_ID                      = UUID.from_16_bits(0x000A, 'FTP')
+BT_HTTP_PROTOCOL_ID                     = UUID.from_16_bits(0x000C, 'HTTP')
+BT_WSP_PROTOCOL_ID                      = UUID.from_16_bits(0x000E, 'WSP')
+BT_BNEP_PROTOCOL_ID                     = UUID.from_16_bits(0x000F, 'BNEP')
+BT_UPNP_PROTOCOL_ID                     = UUID.from_16_bits(0x0010, 'UPNP')
+BT_HIDP_PROTOCOL_ID                     = UUID.from_16_bits(0x0011, 'HIDP')
+BT_HARDCOPY_CONTROL_CHANNEL_PROTOCOL_ID = UUID.from_16_bits(0x0012, 'HardcopyControlChannel')
+BT_HARDCOPY_DATA_CHANNEL_PROTOCOL_ID    = UUID.from_16_bits(0x0014, 'HardcopyDataChannel')
+BT_HARDCOPY_NOTIFICATION_PROTOCOL_ID    = UUID.from_16_bits(0x0016, 'HardcopyNotification')
+BT_AVTCP_PROTOCOL_ID                    = UUID.from_16_bits(0x0017, 'AVCTP')
+BT_AVDTP_PROTOCOL_ID                    = UUID.from_16_bits(0x0019, 'AVDTP')
+BT_CMTP_PROTOCOL_ID                     = UUID.from_16_bits(0x001B, 'CMTP')
+BT_MCAP_CONTROL_CHANNEL_PROTOCOL_ID     = UUID.from_16_bits(0x001E, 'MCAPControlChannel')
+BT_MCAP_DATA_CHANNEL_PROTOCOL_ID        = UUID.from_16_bits(0x001F, 'MCAPDataChannel')
+BT_L2CAP_PROTOCOL_ID                    = UUID.from_16_bits(0x0100, 'L2CAP')
+
+# Service Classes and Profiles
+BT_SERVICE_DISCOVERY_SERVER_SERVICE_CLASS_ID_SERVICE = UUID.from_16_bits(0x1000, 'ServiceDiscoveryServerServiceClassID')
+BT_BROWSE_GROUP_DESCRIPTOR_SERVICE_CLASS_ID_SERVICE  = UUID.from_16_bits(0x1001, 'BrowseGroupDescriptorServiceClassID')
+BT_SERIAL_PORT_SERVICE                               = UUID.from_16_bits(0x1101, 'SerialPort')
+BT_LAN_ACCESS_USING_PPP_SERVICE                      = UUID.from_16_bits(0x1102, 'LANAccessUsingPPP')
+BT_DIALUP_NETWORKING_SERVICE                         = UUID.from_16_bits(0x1103, 'DialupNetworking')
+BT_IR_MCSYNC_SERVICE                                 = UUID.from_16_bits(0x1104, 'IrMCSync')
+BT_OBEX_OBJECT_PUSH_SERVICE                          = UUID.from_16_bits(0x1105, 'OBEXObjectPush')
+BT_OBEX_FILE_TRANSFER_SERVICE                        = UUID.from_16_bits(0x1106, 'OBEXFileTransfer')
+BT_IR_MCSYNC_COMMAND_SERVICE                         = UUID.from_16_bits(0x1107, 'IrMCSyncCommand')
+BT_HEADSET_SERVICE                                   = UUID.from_16_bits(0x1108, 'Headset')
+BT_CORDLESS_TELEPHONY_SERVICE                        = UUID.from_16_bits(0x1109, 'CordlessTelephony')
+BT_AUDIO_SOURCE_SERVICE                              = UUID.from_16_bits(0x110A, 'AudioSource')
+BT_AUDIO_SINK_SERVICE                                = UUID.from_16_bits(0x110B, 'AudioSink')
+BT_AV_REMOTE_CONTROL_TARGET_SERVICE                  = UUID.from_16_bits(0x110C, 'A/V_RemoteControlTarget')
+BT_ADVANCED_AUDIO_DISTRIBUTION_SERVICE               = UUID.from_16_bits(0x110D, 'AdvancedAudioDistribution')
+BT_AV_REMOTE_CONTROL_SERVICE                         = UUID.from_16_bits(0x110E, 'A/V_RemoteControl')
+BT_AV_REMOTE_CONTROL_CONTROLLER_SERVICE              = UUID.from_16_bits(0x110F, 'A/V_RemoteControlController')
+BT_INTERCOM_SERVICE                                  = UUID.from_16_bits(0x1110, 'Intercom')
+BT_FAX_SERVICE                                       = UUID.from_16_bits(0x1111, 'Fax')
+BT_HEADSET_AUDIO_GATEWAY_SERVICE                     = UUID.from_16_bits(0x1112, 'Headset - Audio Gateway')
+BT_WAP_SERVICE                                       = UUID.from_16_bits(0x1113, 'WAP')
+BT_WAP_CLIENT_SERVICE                                = UUID.from_16_bits(0x1114, 'WAP_CLIENT')
+BT_PANU_SERVICE                                      = UUID.from_16_bits(0x1115, 'PANU')
+BT_NAP_SERVICE                                       = UUID.from_16_bits(0x1116, 'NAP')
+BT_GN_SERVICE                                        = UUID.from_16_bits(0x1117, 'GN')
+BT_DIRECT_PRINTING_SERVICE                           = UUID.from_16_bits(0x1118, 'DirectPrinting')
+BT_REFERENCE_PRINTING_SERVICE                        = UUID.from_16_bits(0x1119, 'ReferencePrinting')
+BT_BASIC_IMAGING_PROFILE_SERVICE                     = UUID.from_16_bits(0x111A, 'Basic Imaging Profile')
+BT_IMAGING_RESPONDER_SERVICE                         = UUID.from_16_bits(0x111B, 'ImagingResponder')
+BT_IMAGING_AUTOMATIC_ARCHIVE_SERVICE                 = UUID.from_16_bits(0x111C, 'ImagingAutomaticArchive')
+BT_IMAGING_REFERENCED_OBJECTS_SERVICE                = UUID.from_16_bits(0x111D, 'ImagingReferencedObjects')
+BT_HANDSFREE_SERVICE                                 = UUID.from_16_bits(0x111E, 'Handsfree')
+BT_HANDSFREE_AUDIO_GATEWAY_SERVICE                   = UUID.from_16_bits(0x111F, 'HandsfreeAudioGateway')
+BT_DIRECT_PRINTING_REFERENCE_OBJECTS_SERVICE         = UUID.from_16_bits(0x1120, 'DirectPrintingReferenceObjectsService')
+BT_REFLECTED_UI_SERVICE                              = UUID.from_16_bits(0x1121, 'ReflectedUI')
+BT_BASIC_PRINTING_SERVICE                            = UUID.from_16_bits(0x1122, 'BasicPrinting')
+BT_PRINTING_STATUS_SERVICE                           = UUID.from_16_bits(0x1123, 'PrintingStatus')
+BT_HUMAN_INTERFACE_DEVICE_SERVICE                    = UUID.from_16_bits(0x1124, 'HumanInterfaceDeviceService')
+BT_HARDCOPY_CABLE_REPLACEMENT_SERVICE                = UUID.from_16_bits(0x1125, 'HardcopyCableReplacement')
+BT_HCR_PRINT_SERVICE                                 = UUID.from_16_bits(0x1126, 'HCR_Print')
+BT_HCR_SCAN_SERVICE                                  = UUID.from_16_bits(0x1127, 'HCR_Scan')
+BT_COMMON_ISDN_ACCESS_SERVICE                        = UUID.from_16_bits(0x1128, 'Common_ISDN_Access')
+BT_SIM_ACCESS_SERVICE                                = UUID.from_16_bits(0x112D, 'SIM_Access')
+BT_PHONEBOOK_ACCESS_PCE_SERVICE                      = UUID.from_16_bits(0x112E, 'Phonebook Access - PCE')
+BT_PHONEBOOK_ACCESS_PSE_SERVICE                      = UUID.from_16_bits(0x112F, 'Phonebook Access - PSE')
+BT_PHONEBOOK_ACCESS_SERVICE                          = UUID.from_16_bits(0x1130, 'Phonebook Access')
+BT_HEADSET_HS_SERVICE                                = UUID.from_16_bits(0x1131, 'Headset - HS')
+BT_MESSAGE_ACCESS_SERVER_SERVICE                     = UUID.from_16_bits(0x1132, 'Message Access Server')
+BT_MESSAGE_NOTIFICATION_SERVER_SERVICE               = UUID.from_16_bits(0x1133, 'Message Notification Server')
+BT_MESSAGE_ACCESS_PROFILE_SERVICE                    = UUID.from_16_bits(0x1134, 'Message Access Profile')
+BT_GNSS_SERVICE                                      = UUID.from_16_bits(0x1135, 'GNSS')
+BT_GNSS_SERVER_SERVICE                               = UUID.from_16_bits(0x1136, 'GNSS_Server')
+BT_3D_DISPLAY_SERVICE                                = UUID.from_16_bits(0x1137, '3D Display')
+BT_3D_GLASSES_SERVICE                                = UUID.from_16_bits(0x1138, '3D Glasses')
+BT_3D_SYNCHRONIZATION_SERVICE                        = UUID.from_16_bits(0x1139, '3D Synchronization')
+BT_MPS_PROFILE_SERVICE                               = UUID.from_16_bits(0x113A, 'MPS Profile')
+BT_MPS_SC_SERVICE                                    = UUID.from_16_bits(0x113B, 'MPS SC')
+BT_ACCESS_SERVICE_SERVICE                            = UUID.from_16_bits(0x113C, 'CTN Access Service')
+BT_CTN_NOTIFICATION_SERVICE_SERVICE                  = UUID.from_16_bits(0x113D, 'CTN Notification Service')
+BT_CTN_PROFILE_SERVICE                               = UUID.from_16_bits(0x113E, 'CTN Profile')
+BT_PNP_INFORMATION_SERVICE                           = UUID.from_16_bits(0x1200, 'PnPInformation')
+BT_GENERIC_NETWORKING_SERVICE                        = UUID.from_16_bits(0x1201, 'GenericNetworking')
+BT_GENERIC_FILE_TRANSFER_SERVICE                     = UUID.from_16_bits(0x1202, 'GenericFileTransfer')
+BT_GENERIC_AUDIO_SERVICE                             = UUID.from_16_bits(0x1203, 'GenericAudio')
+BT_GENERIC_TELEPHONY_SERVICE                         = UUID.from_16_bits(0x1204, 'GenericTelephony')
+BT_UPNP_SERVICE                                      = UUID.from_16_bits(0x1205, 'UPNP_Service')
+BT_UPNP_IP_SERVICE                                   = UUID.from_16_bits(0x1206, 'UPNP_IP_Service')
+BT_ESDP_UPNP_IP_PAN_SERVICE                          = UUID.from_16_bits(0x1300, 'ESDP_UPNP_IP_PAN')
+BT_ESDP_UPNP_IP_LAP_SERVICE                          = UUID.from_16_bits(0x1301, 'ESDP_UPNP_IP_LAP')
+BT_ESDP_UPNP_L2CAP_SERVICE                           = UUID.from_16_bits(0x1302, 'ESDP_UPNP_L2CAP')
+BT_VIDEO_SOURCE_SERVICE                              = UUID.from_16_bits(0x1303, 'VideoSource')
+BT_VIDEO_SINK_SERVICE                                = UUID.from_16_bits(0x1304, 'VideoSink')
+BT_VIDEO_DISTRIBUTION_SERVICE                        = UUID.from_16_bits(0x1305, 'VideoDistribution')
+BT_HDP_SERVICE                                       = UUID.from_16_bits(0x1400, 'HDP')
+BT_HDP_SOURCE_SERVICE                                = UUID.from_16_bits(0x1401, 'HDP Source')
+BT_HDP_SINK_SERVICE                                  = UUID.from_16_bits(0x1402, 'HDP Sink')
+
+
+# -----------------------------------------------------------------------------
+# DeviceClass
+# -----------------------------------------------------------------------------
+class DeviceClass:
+    # Major Service Classes (flags combined with OR)
+    LIMITED_DISCOVERABLE_MODE_SERVICE_CLASS = (1 << 0)
+    LE_AUDIO_SERVICE_CLASS                  = (1 << 1)
+    RESERVED                                = (1 << 2)
+    POSITIONING_SERVICE_CLASS               = (1 << 3)
+    NETWORKING_SERVICE_CLASS                = (1 << 4)
+    RENDERING_SERVICE_CLASS                 = (1 << 5)
+    CAPTURING_SERVICE_CLASS                 = (1 << 6)
+    OBJECT_TRANSFER_SERVICE_CLASS           = (1 << 7)
+    AUDIO_SERVICE_CLASS                     = (1 << 8)
+    TELEPHONY_SERVICE_CLASS                 = (1 << 9)
+    INFORMATION_SERVICE_CLASS               = (1 << 10)
+
+    SERVICE_CLASS_LABELS = [
+        'Limited Discoverable Mode',
+        'LE audio',
+        '(reserved)',
+        'Positioning',
+        'Networking',
+        'Rendering',
+        'Capturing',
+        'Object Transfer',
+        'Audio',
+        'Telephony',
+        'Information'
+    ]
+
+    # Major Device Classes
+    MISCELLANEOUS_MAJOR_DEVICE_CLASS            = 0x00
+    COMPUTER_MAJOR_DEVICE_CLASS                 = 0x01
+    PHONE_MAJOR_DEVICE_CLASS                    = 0x02
+    LAN_NETWORK_ACCESS_POINT_MAJOR_DEVICE_CLASS = 0x03
+    AUDIO_VIDEO_MAJOR_DEVICE_CLASS              = 0x04
+    PERIPHERAL_MAJOR_DEVICE_CLASS               = 0x05
+    IMAGING_MAJOR_DEVICE_CLASS                  = 0x06
+    WEARABLE_MAJOR_DEVICE_CLASS                 = 0x07
+    TOY_MAJOR_DEVICE_CLASS                      = 0x08
+    HEALTH_MAJOR_DEVICE_CLASS                   = 0x09
+    UNCATEGORIZED_MAJOR_DEVICE_CLASS            = 0x1F
+
+    MAJOR_DEVICE_CLASS_NAMES = {
+        MISCELLANEOUS_MAJOR_DEVICE_CLASS:            'Miscellaneous',
+        COMPUTER_MAJOR_DEVICE_CLASS:                 'Computer',
+        PHONE_MAJOR_DEVICE_CLASS:                    'Phone',
+        LAN_NETWORK_ACCESS_POINT_MAJOR_DEVICE_CLASS: 'LAN/Network Access Point',
+        AUDIO_VIDEO_MAJOR_DEVICE_CLASS:              'Audio/Video',
+        PERIPHERAL_MAJOR_DEVICE_CLASS:               'Peripheral',
+        IMAGING_MAJOR_DEVICE_CLASS:                  'Imaging',
+        WEARABLE_MAJOR_DEVICE_CLASS:                 'Wearable',
+        TOY_MAJOR_DEVICE_CLASS:                      'Toy',
+        HEALTH_MAJOR_DEVICE_CLASS:                   'Health',
+        UNCATEGORIZED_MAJOR_DEVICE_CLASS:            'Uncategorized'
+    }
+
+    COMPUTER_UNCATEGORIZED_MINOR_DEVICE_CLASS         = 0x00
+    COMPUTER_DESKTOP_WORKSTATION_MINOR_DEVICE_CLASS   = 0x01
+    COMPUTER_SERVER_CLASS_COMPUTER_MINOR_DEVICE_CLASS = 0x02
+    COMPUTER_LAPTOP_COMPUTER_MINOR_DEVICE_CLASS       = 0x03
+    COMPUTER_HANDHELD_PC_PDA_MINOR_DEVICE_CLASS       = 0x04
+    COMPUTER_PALM_SIZE_PC_PDA_MINOR_DEVICE_CLASS      = 0x05
+    COMPUTER_WEARABLE_COMPUTER_MINOR_DEVICE_CLASS     = 0x06
+    COMPUTER_TABLET_MINOR_DEVICE_CLASS                = 0x07
+
+    COMPUTER_MINOR_DEVICE_CLASS_NAMES = {
+        COMPUTER_UNCATEGORIZED_MINOR_DEVICE_CLASS:         'Uncategorized',
+        COMPUTER_DESKTOP_WORKSTATION_MINOR_DEVICE_CLASS:   'Desktop workstation',
+        COMPUTER_SERVER_CLASS_COMPUTER_MINOR_DEVICE_CLASS: 'Server-class computer',
+        COMPUTER_LAPTOP_COMPUTER_MINOR_DEVICE_CLASS:       'Laptop',
+        COMPUTER_HANDHELD_PC_PDA_MINOR_DEVICE_CLASS:       'Handheld PC/PDA',
+        COMPUTER_PALM_SIZE_PC_PDA_MINOR_DEVICE_CLASS:      'Palm-size PC/PDA',
+        COMPUTER_WEARABLE_COMPUTER_MINOR_DEVICE_CLASS:     'Wearable computer',
+        COMPUTER_TABLET_MINOR_DEVICE_CLASS:                'Tablet'
+    }
+
+    PHONE_UNCATEGORIZED_MINOR_DEVICE_CLASS                = 0x00
+    PHONE_CELLULAR_MINOR_DEVICE_CLASS                     = 0x01
+    PHONE_CORDLESS_MINOR_DEVICE_CLASS                     = 0x02
+    PHONE_SMARTPHONE_MINOR_DEVICE_CLASS                   = 0x03
+    PHONE_WIRED_MODEM_OR_VOICE_GATEWAY_MINOR_DEVICE_CLASS = 0x04
+    PHONE_COMMON_ISDN_MINOR_DEVICE_CLASS                  = 0x05
+
+    PHONE_MINOR_DEVICE_CLASS_NAMES = {
+        PHONE_UNCATEGORIZED_MINOR_DEVICE_CLASS:                'Uncategorized',
+        PHONE_CELLULAR_MINOR_DEVICE_CLASS:                     'Cellular',
+        PHONE_CORDLESS_MINOR_DEVICE_CLASS:                     'Cordless',
+        PHONE_SMARTPHONE_MINOR_DEVICE_CLASS:                   'Smartphone',
+        PHONE_WIRED_MODEM_OR_VOICE_GATEWAY_MINOR_DEVICE_CLASS: 'Wired modem or voice gateway',
+        PHONE_COMMON_ISDN_MINOR_DEVICE_CLASS:                  'Common ISDN access'
+    }
+
+    AUDIO_VIDEO_UNCATEGORIZED_MINOR_DEVICE_CLASS                 = 0x00
+    AUDIO_VIDEO_WEARABLE_HEADSET_DEVICE_MINOR_DEVICE_CLASS       = 0x01
+    AUDIO_VIDEO_HANDS_FREE_DEVICE_MINOR_DEVICE_CLASS             = 0x02
+    # (RESERVED)                                                 = 0x03
+    AUDIO_VIDEO_MICROPHONE_MINOR_DEVICE_CLASS                    = 0x04
+    AUDIO_VIDEO_LOUDSPEAKER_MINOR_DEVICE_CLASS                   = 0x05
+    AUDIO_VIDEO_HEADPHONES_MINOR_DEVICE_CLASS                    = 0x06
+    AUDIO_VIDEO_PORTABLE_AUDIO_MINOR_DEVICE_CLASS                = 0x07
+    AUDIO_VIDEO_CAR_AUDIO_MINOR_DEVICE_CLASS                     = 0x08
+    AUDIO_VIDEO_SET_TOP_BOX_MINOR_DEVICE_CLASS                   = 0x09
+    AUDIO_VIDEO_HIFI_AUDIO_DEVICE_MINOR_DEVICE_CLASS             = 0x0A
+    AUDIO_VIDEO_VCR_MINOR_DEVICE_CLASS                           = 0x0B
+    AUDIO_VIDEO_VIDEO_CAMERA_MINOR_DEVICE_CLASS                  = 0x0C
+    AUDIO_VIDEO_CAMCORDER_MINOR_DEVICE_CLASS                     = 0x0D
+    AUDIO_VIDEO_VIDEO_MONITOR_MINOR_DEVICE_CLASS                 = 0x0E
+    AUDIO_VIDEO_VIDEO_DISPLAY_AND_LOUDSPEAKER_MINOR_DEVICE_CLASS = 0x0F
+    AUDIO_VIDEO_VIDEO_CONFERENCING_MINOR_DEVICE_CLASS            = 0x10
+    # (RESERVED)                                                 = 0x11
+    AUDIO_VIDEO_GAMING_OR_TOY_MINOR_DEVICE_CLASS                 = 0x12
+
+    AUDIO_VIDEO_MINOR_DEVICE_CLASS_NAMES = {
+        AUDIO_VIDEO_UNCATEGORIZED_MINOR_DEVICE_CLASS:                 'Uncategorized',
+        AUDIO_VIDEO_WEARABLE_HEADSET_DEVICE_MINOR_DEVICE_CLASS:       'Wearable Headset Device',
+        AUDIO_VIDEO_HANDS_FREE_DEVICE_MINOR_DEVICE_CLASS:             'Hands-free Device',
+        AUDIO_VIDEO_MICROPHONE_MINOR_DEVICE_CLASS:                    'Microphone',
+        AUDIO_VIDEO_LOUDSPEAKER_MINOR_DEVICE_CLASS:                   'Loudspeaker',
+        AUDIO_VIDEO_HEADPHONES_MINOR_DEVICE_CLASS:                    'Headphones',
+        AUDIO_VIDEO_PORTABLE_AUDIO_MINOR_DEVICE_CLASS:                'Portable Audio',
+        AUDIO_VIDEO_CAR_AUDIO_MINOR_DEVICE_CLASS:                     'Car audio',
+        AUDIO_VIDEO_SET_TOP_BOX_MINOR_DEVICE_CLASS:                   'Set-top box',
+        AUDIO_VIDEO_HIFI_AUDIO_DEVICE_MINOR_DEVICE_CLASS:             'HiFi Audio Device',
+        AUDIO_VIDEO_VCR_MINOR_DEVICE_CLASS:                           'VCR',
+        AUDIO_VIDEO_VIDEO_CAMERA_MINOR_DEVICE_CLASS:                  'Video Camera',
+        AUDIO_VIDEO_CAMCORDER_MINOR_DEVICE_CLASS:                     'Camcorder',
+        AUDIO_VIDEO_VIDEO_MONITOR_MINOR_DEVICE_CLASS:                 'Video Monitor',
+        AUDIO_VIDEO_VIDEO_DISPLAY_AND_LOUDSPEAKER_MINOR_DEVICE_CLASS: 'Video Display and Loudspeaker',
+        AUDIO_VIDEO_VIDEO_CONFERENCING_MINOR_DEVICE_CLASS:            'Video Conferencing',
+        AUDIO_VIDEO_GAMING_OR_TOY_MINOR_DEVICE_CLASS:                 'Gaming/Toy'
+    }
+
+    PERIPHERAL_UNCATEGORIZED_MINOR_DEVICE_CLASS                  = 0x00
+    PERIPHERAL_KEYBOARD_MINOR_DEVICE_CLASS                       = 0x10
+    PERIPHERAL_POINTING_DEVICE_MINOR_DEVICE_CLASS                = 0x20
+    PERIPHERAL_COMBO_KEYBOARD_POINTING_DEVICE_MINOR_DEVICE_CLASS = 0x30
+    PERIPHERAL_JOYSTICK_MINOR_DEVICE_CLASS                       = 0x01
+    PERIPHERAL_GAMEPAD_MINOR_DEVICE_CLASS                        = 0x02
+    PERIPHERAL_REMOTE_CONTROL_MINOR_DEVICE_CLASS                 = 0x03
+    PERIPHERAL_SENSING_DEVICE_MINOR_DEVICE_CLASS                 = 0x04
+    PERIPHERAL_DIGITIZER_TABLET_MINOR_DEVICE_CLASS               = 0x05
+    PERIPHERAL_CARD_READER_MINOR_DEVICE_CLASS                    = 0x06
+    PERIPHERAL_DIGITAL_PEN_MINOR_DEVICE_CLASS                    = 0x07
+    PERIPHERAL_HANDHELD_SCANNER_MINOR_DEVICE_CLASS               = 0x08
+    PERIPHERAL_HANDHELD_GESTURAL_INPUT_DEVICE_MINOR_DEVICE_CLASS = 0x09
+
+    PERIPHERAL_MINOR_DEVICE_CLASS_NAMES = {
+        PERIPHERAL_UNCATEGORIZED_MINOR_DEVICE_CLASS:                  'Uncategorized',
+        PERIPHERAL_KEYBOARD_MINOR_DEVICE_CLASS:                       'Keyboard',
+        PERIPHERAL_POINTING_DEVICE_MINOR_DEVICE_CLASS:                'Pointing device',
+        PERIPHERAL_COMBO_KEYBOARD_POINTING_DEVICE_MINOR_DEVICE_CLASS: 'Combo keyboard/pointing device',
+        PERIPHERAL_JOYSTICK_MINOR_DEVICE_CLASS:                       'Joystick',
+        PERIPHERAL_GAMEPAD_MINOR_DEVICE_CLASS:                        'Gamepad',
+        PERIPHERAL_REMOTE_CONTROL_MINOR_DEVICE_CLASS:                 'Remote control',
+        PERIPHERAL_SENSING_DEVICE_MINOR_DEVICE_CLASS:                 'Sensing device',
+        PERIPHERAL_DIGITIZER_TABLET_MINOR_DEVICE_CLASS:               'Digitizer tablet',
+        PERIPHERAL_CARD_READER_MINOR_DEVICE_CLASS:                    'Card Reader',
+        PERIPHERAL_DIGITAL_PEN_MINOR_DEVICE_CLASS:                    'Digital Pen',
+        PERIPHERAL_HANDHELD_SCANNER_MINOR_DEVICE_CLASS:               'Handheld scanner',
+        PERIPHERAL_HANDHELD_GESTURAL_INPUT_DEVICE_MINOR_DEVICE_CLASS: 'Handheld gestural input device'
+    }
+
+    MINOR_DEVICE_CLASS_NAMES = {
+        COMPUTER_MAJOR_DEVICE_CLASS:    COMPUTER_MINOR_DEVICE_CLASS_NAMES,
+        PHONE_MAJOR_DEVICE_CLASS:       PHONE_MINOR_DEVICE_CLASS_NAMES,
+        AUDIO_VIDEO_MAJOR_DEVICE_CLASS: AUDIO_VIDEO_MINOR_DEVICE_CLASS_NAMES,
+        PERIPHERAL_MAJOR_DEVICE_CLASS:  PERIPHERAL_MINOR_DEVICE_CLASS_NAMES
+    }
+
+    @staticmethod
+    def split_class_of_device(class_of_device):
+        # Split the bit fields of the composite class of device value into:
+        # (service_classes, major_device_class, minor_device_class)
+        return ((class_of_device >> 13 & 0x7FF), (class_of_device >> 8 & 0x1F), (class_of_device >> 2 & 0x3F))
+
+    @staticmethod
+    def pack_class_of_device(service_classes, major_device_class, minor_device_class):
+        return service_classes << 13 | major_device_class << 8 | minor_device_class << 2
+
+    @staticmethod
+    def service_class_labels(service_class_flags):
+        return bit_flags_to_strings(service_class_flags, DeviceClass.SERVICE_CLASS_LABELS)
+
+    @staticmethod
+    def major_device_class_name(device_class):
+        return name_or_number(DeviceClass.MAJOR_DEVICE_CLASS_NAMES, device_class)
+
+    @staticmethod
+    def minor_device_class_name(major_device_class, minor_device_class):
+        class_names = DeviceClass.MINOR_DEVICE_CLASS_NAMES.get(major_device_class)
+        if class_names is None:
+            return f'#{minor_device_class:02X}'
+        return name_or_number(class_names, minor_device_class)
+
+
+# -----------------------------------------------------------------------------
+# Advertising Data
+# -----------------------------------------------------------------------------
+class AdvertisingData:
+    # This list is only partial, it still needs to be filled in from the spec
+    FLAGS                                          = 0x01
+    INCOMPLETE_LIST_OF_16_BIT_SERVICE_CLASS_UUIDS  = 0x02
+    COMPLETE_LIST_OF_16_BIT_SERVICE_CLASS_UUIDS    = 0x03
+    INCOMPLETE_LIST_OF_32_BIT_SERVICE_CLASS_UUIDS  = 0x04
+    COMPLETE_LIST_OF_32_BIT_SERVICE_CLASS_UUIDS    = 0x05
+    INCOMPLETE_LIST_OF_128_BIT_SERVICE_CLASS_UUIDS = 0x06
+    COMPLETE_LIST_OF_128_BIT_SERVICE_CLASS_UUIDS   = 0x07
+    SHORTENED_LOCAL_NAME                           = 0x08
+    COMPLETE_LOCAL_NAME                            = 0x09
+    TX_POWER_LEVEL                                 = 0x0A
+    CLASS_OF_DEVICE                                = 0x0D
+    SIMPLE_PAIRING_HASH_C                          = 0x0E
+    SIMPLE_PAIRING_HASH_C_192                      = 0x0E
+    SIMPLE_PAIRING_RANDOMIZER_R                    = 0x0F
+    SIMPLE_PAIRING_RANDOMIZER_R_192                = 0x0F
+    DEVICE_ID                                      = 0x10
+    SECURITY_MANAGER_TK_VALUE                      = 0x10
+    SECURITY_MANAGER_OUT_OF_BAND_FLAGS             = 0x11
+    PERIPHERAL_CONNECTION_INTERVAL_RANGE           = 0x12
+    LIST_OF_16_BIT_SERVICE_SOLICITATION_UUIDS      = 0x14
+    LIST_OF_128_BIT_SERVICE_SOLICITATION_UUIDS     = 0x15
+    SERVICE_DATA                                   = 0x16
+    SERVICE_DATA_16_BIT_UUID                       = 0x16
+    PUBLIC_TARGET_ADDRESS                          = 0x17
+    RANDOM_TARGET_ADDRESS                          = 0x18
+    APPEARANCE                                     = 0x19
+    ADVERTISING_INTERVAL                           = 0x1A
+    LE_BLUETOOTH_DEVICE_ADDRESS                    = 0x1B
+    LE_ROLE                                        = 0x1C
+    SIMPLE_PAIRING_HASH_C_256                      = 0x1D
+    SIMPLE_PAIRING_RANDOMIZER_R_256                = 0x1E
+    LIST_OF_32_BIT_SERVICE_SOLICITATION_UUIDS      = 0x1F
+    SERVICE_DATA_32_BIT_UUID                       = 0x20
+    SERVICE_DATA_128_BIT_UUID                      = 0x21
+    LE_SECURE_CONNECTIONS_CONFIRMATION_VALUE       = 0x22
+    LE_SECURE_CONNECTIONS_RANDOM_VALUE             = 0x23
+    URI                                            = 0x24
+    INDOOR_POSITIONING                             = 0x25
+    TRANSPORT_DISCOVERY_DATA                       = 0x26
+    LE_SUPPORTED_FEATURES                          = 0x27
+    CHANNEL_MAP_UPDATE_INDICATION                  = 0x28
+    PB_ADV                                         = 0x29
+    MESH_MESSAGE                                   = 0x2A
+    MESH_BEACON                                    = 0x2B
+    BIGINFO                                        = 0x2C
+    BROADCAST_CODE                                 = 0x2D
+    RESOLVABLE_SET_IDENTIFIER                      = 0x2E
+    ADVERTISING_INTERVAL_LONG                      = 0x2F
+    THREE_D_INFORMATION_DATA                       = 0x3D
+    MANUFACTURER_SPECIFIC_DATA                     = 0xFF
+
+    AD_TYPE_NAMES = {
+        FLAGS:                                          'FLAGS',
+        INCOMPLETE_LIST_OF_16_BIT_SERVICE_CLASS_UUIDS:  'INCOMPLETE_LIST_OF_16_BIT_SERVICE_CLASS_UUIDS',
+        COMPLETE_LIST_OF_16_BIT_SERVICE_CLASS_UUIDS:    'COMPLETE_LIST_OF_16_BIT_SERVICE_CLASS_UUIDS',
+        INCOMPLETE_LIST_OF_32_BIT_SERVICE_CLASS_UUIDS:  'INCOMPLETE_LIST_OF_32_BIT_SERVICE_CLASS_UUIDS',
+        COMPLETE_LIST_OF_32_BIT_SERVICE_CLASS_UUIDS:    'COMPLETE_LIST_OF_32_BIT_SERVICE_CLASS_UUIDS',
+        INCOMPLETE_LIST_OF_128_BIT_SERVICE_CLASS_UUIDS: 'INCOMPLETE_LIST_OF_128_BIT_SERVICE_CLASS_UUIDS',
+        COMPLETE_LIST_OF_128_BIT_SERVICE_CLASS_UUIDS:   'COMPLETE_LIST_OF_128_BIT_SERVICE_CLASS_UUIDS',
+        SHORTENED_LOCAL_NAME:                           'SHORTENED_LOCAL_NAME',
+        COMPLETE_LOCAL_NAME:                            'COMPLETE_LOCAL_NAME',
+        TX_POWER_LEVEL:                                 'TX_POWER_LEVEL',
+        CLASS_OF_DEVICE:                                'CLASS_OF_DEVICE',
+        SIMPLE_PAIRING_HASH_C:                          'SIMPLE_PAIRING_HASH_C',
+        SIMPLE_PAIRING_HASH_C_192:                      'SIMPLE_PAIRING_HASH_C_192',
+        SIMPLE_PAIRING_RANDOMIZER_R:                    'SIMPLE_PAIRING_RANDOMIZER_R',
+        SIMPLE_PAIRING_RANDOMIZER_R_192:                'SIMPLE_PAIRING_RANDOMIZER_R_192',
+        DEVICE_ID:                                      'DEVICE_ID',
+        SECURITY_MANAGER_TK_VALUE:                      'SECURITY_MANAGER_TK_VALUE',
+        SECURITY_MANAGER_OUT_OF_BAND_FLAGS:             'SECURITY_MANAGER_OUT_OF_BAND_FLAGS',
+        PERIPHERAL_CONNECTION_INTERVAL_RANGE:           'PERIPHERAL_CONNECTION_INTERVAL_RANGE',
+        LIST_OF_16_BIT_SERVICE_SOLICITATION_UUIDS:      'LIST_OF_16_BIT_SERVICE_SOLICITATION_UUIDS',
+        LIST_OF_128_BIT_SERVICE_SOLICITATION_UUIDS:     'LIST_OF_128_BIT_SERVICE_SOLICITATION_UUIDS',
+        SERVICE_DATA:                                   'SERVICE_DATA',
+        SERVICE_DATA_16_BIT_UUID:                       'SERVICE_DATA_16_BIT_UUID',
+        PUBLIC_TARGET_ADDRESS:                          'PUBLIC_TARGET_ADDRESS',
+        RANDOM_TARGET_ADDRESS:                          'RANDOM_TARGET_ADDRESS',
+        APPEARANCE:                                     'APPEARANCE',
+        ADVERTISING_INTERVAL:                           'ADVERTISING_INTERVAL',
+        LE_BLUETOOTH_DEVICE_ADDRESS:                    'LE_BLUETOOTH_DEVICE_ADDRESS',
+        LE_ROLE:                                        'LE_ROLE',
+        SIMPLE_PAIRING_HASH_C_256:                      'SIMPLE_PAIRING_HASH_C_256',
+        SIMPLE_PAIRING_RANDOMIZER_R_256:                'SIMPLE_PAIRING_RANDOMIZER_R_256',
+        LIST_OF_32_BIT_SERVICE_SOLICITATION_UUIDS:      'LIST_OF_32_BIT_SERVICE_SOLICITATION_UUIDS',
+        SERVICE_DATA_32_BIT_UUID:                       'SERVICE_DATA_32_BIT_UUID',
+        SERVICE_DATA_128_BIT_UUID:                      'SERVICE_DATA_128_BIT_UUID',
+        LE_SECURE_CONNECTIONS_CONFIRMATION_VALUE:       'LE_SECURE_CONNECTIONS_CONFIRMATION_VALUE',
+        LE_SECURE_CONNECTIONS_RANDOM_VALUE:             'LE_SECURE_CONNECTIONS_RANDOM_VALUE',
+        URI:                                            'URI',
+        INDOOR_POSITIONING:                             'INDOOR_POSITIONING',
+        TRANSPORT_DISCOVERY_DATA:                       'TRANSPORT_DISCOVERY_DATA',
+        LE_SUPPORTED_FEATURES:                          'LE_SUPPORTED_FEATURES',
+        CHANNEL_MAP_UPDATE_INDICATION:                  'CHANNEL_MAP_UPDATE_INDICATION',
+        PB_ADV:                                         'PB_ADV',
+        MESH_MESSAGE:                                   'MESH_MESSAGE',
+        MESH_BEACON:                                    'MESH_BEACON',
+        BIGINFO:                                        'BIGINFO',
+        BROADCAST_CODE:                                 'BROADCAST_CODE',
+        RESOLVABLE_SET_IDENTIFIER:                      'RESOLVABLE_SET_IDENTIFIER',
+        ADVERTISING_INTERVAL_LONG:                      'ADVERTISING_INTERVAL_LONG',
+        THREE_D_INFORMATION_DATA:                       'THREE_D_INFORMATION_DATA',
+        MANUFACTURER_SPECIFIC_DATA:                     'MANUFACTURER_SPECIFIC_DATA'
+    }
+
+    LE_LIMITED_DISCOVERABLE_MODE_FLAG = 0x01
+    LE_GENERAL_DISCOVERABLE_MODE_FLAG = 0x02
+    BR_EDR_NOT_SUPPORTED_FLAG         = 0x04
+    BR_EDR_CONTROLLER_FLAG            = 0x08
+    BR_EDR_HOST_FLAG                  = 0x10
+
+    def __init__(self, ad_structures = []):
+        self.ad_structures = ad_structures[:]
+
+    @staticmethod
+    def from_bytes(data):
+        instance = AdvertisingData()
+        instance.append(data)
+        return instance
+
+    @staticmethod
+    def flags_to_string(flags, short=False):
+        flag_names = [
+            'LE Limited',
+            'LE General',
+            'No BR/EDR',
+            'BR/EDR C',
+            'BR/EDR H'
+        ] if short else [
+            'LE Limited Discoverable Mode',
+            'LE General Discoverable Mode',
+            'BR/EDR Not Supported',
+            'Simultaneous LE and BR/EDR (Controller)',
+            'Simultaneous LE and BR/EDR (Host)'
+        ]
+        return ','.join(bit_flags_to_strings(flags, flag_names))
+
+    @staticmethod
+    def uuid_list_to_objects(ad_data, uuid_size):
+        uuids = []
+        offset = 0
+        while (uuid_size * (offset + 1)) <= len(ad_data):
+            uuids.append(UUID.from_bytes(ad_data[offset:offset + uuid_size]))
+            offset += uuid_size
+        return uuids
+
+    @staticmethod
+    def uuid_list_to_string(ad_data, uuid_size):
+        return ', '.join([
+            str(uuid)
+            for uuid in AdvertisingData.uuid_list_to_objects(ad_data, uuid_size)
+        ])
+
+    @staticmethod
+    def ad_data_to_string(ad_type, ad_data):
+        if ad_type == AdvertisingData.FLAGS:
+            ad_type_str = 'Flags'
+            ad_data_str = AdvertisingData.flags_to_string(ad_data[0], short=True)
+        elif ad_type == AdvertisingData.COMPLETE_LIST_OF_16_BIT_SERVICE_CLASS_UUIDS:
+            ad_type_str = 'Complete List of 16-bit Service Class UUIDs'
+            ad_data_str = AdvertisingData.uuid_list_to_string(ad_data, 2)
+        elif ad_type == AdvertisingData.INCOMPLETE_LIST_OF_16_BIT_SERVICE_CLASS_UUIDS:
+            ad_type_str = 'Incomplete List of 16-bit Service Class UUIDs'
+            ad_data_str = AdvertisingData.uuid_list_to_string(ad_data, 2)
+        elif ad_type == AdvertisingData.COMPLETE_LIST_OF_32_BIT_SERVICE_CLASS_UUIDS:
+            ad_type_str = 'Complete List of 32-bit Service Class UUIDs'
+            ad_data_str = AdvertisingData.uuid_list_to_string(ad_data, 4)
+        elif ad_type == AdvertisingData.INCOMPLETE_LIST_OF_32_BIT_SERVICE_CLASS_UUIDS:
+            ad_type_str = 'Incomplete List of 32-bit Service Class UUIDs'
+            ad_data_str = AdvertisingData.uuid_list_to_string(ad_data, 4)
+        elif ad_type == AdvertisingData.COMPLETE_LIST_OF_128_BIT_SERVICE_CLASS_UUIDS:
+            ad_type_str = 'Complete List of 128-bit Service Class UUIDs'
+            ad_data_str = AdvertisingData.uuid_list_to_string(ad_data, 16)
+        elif ad_type == AdvertisingData.INCOMPLETE_LIST_OF_128_BIT_SERVICE_CLASS_UUIDS:
+            ad_type_str = 'Incomplete List of 128-bit Service Class UUIDs'
+            ad_data_str = AdvertisingData.uuid_list_to_string(ad_data, 16)
+        elif ad_type == AdvertisingData.SERVICE_DATA_16_BIT_UUID:
+            ad_type_str = 'Service Data'
+            uuid = UUID.from_bytes(ad_data[:2])
+            ad_data_str = f'service={uuid}, data={ad_data[2:].hex()}'
+        elif ad_type == AdvertisingData.SERVICE_DATA_32_BIT_UUID:
+            ad_type_str = 'Service Data'
+            uuid = UUID.from_bytes(ad_data[:4])
+            ad_data_str = f'service={uuid}, data={ad_data[4:].hex()}'
+        elif ad_type == AdvertisingData.SERVICE_DATA_128_BIT_UUID:
+            ad_type_str = 'Service Data'
+            uuid = UUID.from_bytes(ad_data[:16])
+            ad_data_str = f'service={uuid}, data={ad_data[16:].hex()}'
+        elif ad_type == AdvertisingData.SHORTENED_LOCAL_NAME:
+            ad_type_str = 'Shortened Local Name'
+            ad_data_str = f'"{ad_data.decode("utf-8")}"'
+        elif ad_type == AdvertisingData.COMPLETE_LOCAL_NAME:
+            ad_type_str = 'Complete Local Name'
+            ad_data_str = f'"{ad_data.decode("utf-8")}"'
+        elif ad_type == AdvertisingData.TX_POWER_LEVEL:
+            ad_type_str = 'TX Power Level'
+            ad_data_str = str(ad_data[0])
+        elif ad_type == AdvertisingData.MANUFACTURER_SPECIFIC_DATA:
+            ad_type_str = 'Manufacturer Specific Data'
+            company_id = struct.unpack_from('<H', ad_data, 0)[0]
+            company_name = COMPANY_IDENTIFIERS.get(company_id, f'0x{company_id:04X}')
+            ad_data_str = f'company={company_name}, data={ad_data[2:].hex()}'
+        elif ad_type == AdvertisingData.APPEARANCE:
+            ad_type_str = 'Appearance'
+            ad_data_str = ad_data.hex()
+        else:
+            ad_type_str = AdvertisingData.AD_TYPE_NAMES.get(ad_type, f'0x{ad_type:02X}')
+            ad_data_str = ad_data.hex()
+
+        return f'[{ad_type_str}]: {ad_data_str}'
+
+    @staticmethod
+    def ad_data_to_object(ad_type, ad_data):
+        if ad_type in {
+            AdvertisingData.COMPLETE_LIST_OF_16_BIT_SERVICE_CLASS_UUIDS,
+            AdvertisingData.INCOMPLETE_LIST_OF_16_BIT_SERVICE_CLASS_UUIDS
+        }:
+            return AdvertisingData.uuid_list_to_objects(ad_data, 2)
+        elif ad_type in {
+            AdvertisingData.COMPLETE_LIST_OF_32_BIT_SERVICE_CLASS_UUIDS,
+            AdvertisingData.INCOMPLETE_LIST_OF_32_BIT_SERVICE_CLASS_UUIDS
+        }:
+            return AdvertisingData.uuid_list_to_objects(ad_data, 4)
+        elif ad_type in {
+            AdvertisingData.COMPLETE_LIST_OF_128_BIT_SERVICE_CLASS_UUIDS,
+            AdvertisingData.INCOMPLETE_LIST_OF_128_BIT_SERVICE_CLASS_UUIDS
+        }:
+            return AdvertisingData.uuid_list_to_objects(ad_data, 16)
+        elif ad_type == AdvertisingData.SERVICE_DATA_16_BIT_UUID:
+            return (UUID.from_bytes(ad_data[:2]), ad_data[2:])
+        elif ad_type == AdvertisingData.SERVICE_DATA_32_BIT_UUID:
+            return (UUID.from_bytes(ad_data[:4]), ad_data[4:])
+        elif ad_type == AdvertisingData.SERVICE_DATA_128_BIT_UUID:
+            return (UUID.from_bytes(ad_data[:16]), ad_data[16:])
+        elif ad_type in {
+            AdvertisingData.SHORTENED_LOCAL_NAME,
+            AdvertisingData.COMPLETE_LOCAL_NAME
+        }:
+            return ad_data.decode("utf-8")
+        elif ad_type == AdvertisingData.TX_POWER_LEVEL:
+            return ad_data[0]
+        elif ad_type == AdvertisingData.MANUFACTURER_SPECIFIC_DATA:
+            return (struct.unpack_from('<H', ad_data, 0)[0], ad_data[2:])
+        else:
+            return ad_data
+
+    def append(self, data):
+        offset = 0
+        while offset + 1 < len(data):
+            length = data[offset]
+            offset += 1
+            if length > 0:
+                ad_type = data[offset]
+                ad_data = data[offset + 1:offset + length]
+                self.ad_structures.append((ad_type, ad_data))
+            offset += length
+
+    def get(self, type_id, return_all=False, raw=True):
+        '''
+        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.
+        '''
+        def process_ad_data(ad_data):
+            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]
+        else:
+            return next((process_ad_data(ad[1]) for ad in self.ad_structures if ad[0] == type_id), None)
+
+    def __bytes__(self):
+        return b''.join([bytes([len(x[1]) + 1, x[0]]) + x[1] for x in self.ad_structures])
+
+    def to_string(self, separator=', '):
+        return separator.join([AdvertisingData.ad_data_to_string(x[0], x[1]) for x in self.ad_structures])
+
+    def __str__(self):
+        return self.to_string()
+
+
+# -----------------------------------------------------------------------------
+# Connection Parameters
+# -----------------------------------------------------------------------------
+class ConnectionParameters:
+    def __init__(self, connection_interval, connection_latency, supervision_timeout):
+        self.connection_interval = connection_interval
+        self.connection_latency  = connection_latency
+        self.supervision_timeout = supervision_timeout
+
+    def __str__(self):
+        return f'ConnectionParameters(connection_interval={self.connection_interval}, connection_latency={self.connection_latency}, supervision_timeout={self.supervision_timeout}'
+
+
+# -----------------------------------------------------------------------------
+# Connection PHY
+# -----------------------------------------------------------------------------
+class ConnectionPHY:
+    def __init__(self, tx_phy, rx_phy):
+        self.tx_phy = tx_phy
+        self.rx_phy = rx_phy
+
+    def __str__(self):
+        return f'ConnectionPHY(tx_phy={self.tx_phy}, rx_phy={self.rx_phy})'

bumble/crypto.py

@@ -0,0 +1,243 @@
+# Copyright 2021-2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# Crypto support
+#
+# See Bluetooth spec Vol 3, Part H - 2.2 CRYPTOGRAPHIC TOOLBOX
+# -----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import logging
+import operator
+import platform
+if platform.system() != 'Emscripten':
+    import secrets
+    from cryptography.hazmat.primitives.ciphers import (
+        Cipher,
+        algorithms,
+        modes
+    )
+    from cryptography.hazmat.primitives.asymmetric.ec import (
+        generate_private_key,
+        ECDH,
+        EllipticCurvePublicNumbers,
+        EllipticCurvePrivateNumbers,
+        SECP256R1
+    )
+    from cryptography.hazmat.primitives import cmac
+else:
+    # TODO: implement stubs
+    pass
+
+# -----------------------------------------------------------------------------
+# Logging
+# -----------------------------------------------------------------------------
+logger = logging.getLogger(__name__)
+
+
+# -----------------------------------------------------------------------------
+# Classes
+# -----------------------------------------------------------------------------
+class EccKey:
+    def __init__(self, private_key):
+        self.private_key = private_key
+
+    @classmethod
+    def generate(cls):
+        private_key = generate_private_key(SECP256R1())
+        return cls(private_key)
+
+    @classmethod
+    def from_private_key_bytes(cls, d_bytes, x_bytes, y_bytes):
+        d = int.from_bytes(d_bytes, byteorder='big', signed=False)
+        x = int.from_bytes(x_bytes, byteorder='big', signed=False)
+        y = int.from_bytes(y_bytes, byteorder='big', signed=False)
+        private_key = EllipticCurvePrivateNumbers(d, EllipticCurvePublicNumbers(x, y, SECP256R1())).private_key()
+        return cls(private_key)
+
+    @property
+    def x(self):
+        return self.private_key.public_key().public_numbers().x.to_bytes(32, byteorder='big')
+
+    @property
+    def y(self):
+        return self.private_key.public_key().public_numbers().y.to_bytes(32, byteorder='big')
+
+    def dh(self, public_key_x, public_key_y):
+        x = int.from_bytes(public_key_x, byteorder='big', signed=False)
+        y = int.from_bytes(public_key_y, byteorder='big', signed=False)
+        public_key = EllipticCurvePublicNumbers(x, y, SECP256R1()).public_key()
+        shared_key = self.private_key.exchange(ECDH(), public_key)
+
+        return shared_key
+
+
+# -----------------------------------------------------------------------------
+# Functions
+# -----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
+def xor(x, y):
+    assert(len(x) == len(y))
+    return bytes(map(operator.xor, x, y))
+
+
+# -----------------------------------------------------------------------------
+def r():
+    '''
+    Generate 16 bytes of random data
+    '''
+    return secrets.token_bytes(16)
+
+
+# -----------------------------------------------------------------------------
+def e(key, data):
+    '''
+    AES-128 ECB, expecting byte-swapped inputs and producing a byte-swapped output.
+
+    See Bluetooth spec Vol 3, Part H - 2.2.1 Security function e
+    '''
+
+    cipher = Cipher(algorithms.AES(bytes(reversed(key))), modes.ECB())
+    encryptor = cipher.encryptor()
+    return bytes(reversed(encryptor.update(bytes(reversed(data)))))
+
+
+# -----------------------------------------------------------------------------
+def ah(k, r):
+    '''
+    See Bluetooth spec Vol 3, Part H - 2.2.2 Random Address Hash function ah
+    '''
+
+    padding = bytes(13)
+    r_prime = r + padding
+    return e(k, r_prime)[0:3]
+
+
+# -----------------------------------------------------------------------------
+def c1(k, r, preq, pres, iat, rat, ia, ra):
+    '''
+    See Bluetooth spec, Vol 3, Part H - 2.2.3 Confirm value generation function c1 for LE Legacy Pairing
+    '''
+
+    p1 = bytes([iat, rat]) + preq + pres
+    p2 = ra + ia + bytes([0, 0, 0, 0])
+    return e(k, xor(e(k, xor(r, p1)), p2))
+
+
+# -----------------------------------------------------------------------------
+def s1(k, r1, r2):
+    '''
+    See Bluetooth spec, Vol 3, Part H - 2.2.4 Key generation function s1 for LE Legacy Pairing
+    '''
+
+    return e(k, r2[0:8] + r1[0:8])
+
+
+# -----------------------------------------------------------------------------
+def aes_cmac(m, k):
+    '''
+    See Bluetooth spec, Vol 3, Part H - 2.2.5 FunctionAES-CMAC
+
+    NOTE: the input and output of this internal function are in big-endian byte order
+    '''
+    mac = cmac.CMAC(algorithms.AES(k))
+    mac.update(m)
+    return mac.finalize()
+
+
+# -----------------------------------------------------------------------------
+def f4(u, v, x, z):
+    '''
+    See Bluetooth spec, Vol 3, Part H - 2.2.6 LE Secure Connections Confirm Value Generation Function f4
+    '''
+    return bytes(reversed(aes_cmac(bytes(reversed(u)) + bytes(reversed(v)) + z, bytes(reversed(x)))))
+
+
+# -----------------------------------------------------------------------------
+def f5(w, n1, n2, a1, a2):
+    '''
+    See Bluetooth spec, Vol 3, Part H - 2.2.7 LE Secure Connections Key Generation Function f5
+
+    NOTE: this returns a tuple: (MacKey, LTK) in little-endian byte order
+    '''
+    salt = bytes.fromhex('6C888391AAF5A53860370BDB5A6083BE')
+    t = aes_cmac(bytes(reversed(w)), salt)
+    key_id = bytes([0x62, 0x74, 0x6c, 0x65])
+    return (
+        bytes(reversed(aes_cmac(
+            bytes([0]) +
+            key_id +
+            bytes(reversed(n1)) +
+            bytes(reversed(n2)) +
+            bytes(reversed(a1)) +
+            bytes(reversed(a2)) +
+            bytes([1, 0]),
+            t
+        ))),
+        bytes(reversed(aes_cmac(
+            bytes([1]) +
+            key_id +
+            bytes(reversed(n1)) +
+            bytes(reversed(n2)) +
+            bytes(reversed(a1)) +
+            bytes(reversed(a2)) +
+            bytes([1, 0]),
+            t
+        )))
+    )
+
+
+# -----------------------------------------------------------------------------
+def f6(w, n1, n2, r, io_cap, a1, a2):
+    '''
+    See Bluetooth spec, Vol 3, Part H - 2.2.8 LE Secure Connections Check Value Generation Function f6
+    '''
+    return bytes(reversed(aes_cmac(
+        bytes(reversed(n1)) +
+        bytes(reversed(n2)) +
+        bytes(reversed(r)) +
+        bytes(reversed(io_cap)) +
+        bytes(reversed(a1)) +
+        bytes(reversed(a2)),
+        bytes(reversed(w))
+    )))
+
+
+# -----------------------------------------------------------------------------
+def g2(u, v, x, y):
+    '''
+    See Bluetooth spec, Vol 3, Part H - 2.2.9 LE Secure Connections Numeric Comparison Value Generation Function g2
+    '''
+    return int.from_bytes(
+        aes_cmac(bytes(reversed(u)) + bytes(reversed(v)) + bytes(reversed(y)), bytes(reversed(x)))[-4:],
+        byteorder='big'
+    )
+
+# -----------------------------------------------------------------------------
+def h6(w, key_id):
+    '''
+    See Bluetooth spec, Vol 3, Part H - 2.2.10 Link key conversion function h6
+    '''
+    return aes_cmac(key_id, w)
+
+# -----------------------------------------------------------------------------
+def h7(salt, w):
+    '''
+    See Bluetooth spec, Vol 3, Part H - 2.2.11 Link key conversion function h7
+    '''
+    return aes_cmac(w, salt)

bumble/gap.py

@@ -0,0 +1,59 @@
+# Copyright 2021-2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import logging
+import struct
+
+from .gatt import (
+    Service,
+    Characteristic,
+    GATT_GENERIC_ACCESS_SERVICE,
+    GATT_DEVICE_NAME_CHARACTERISTIC,
+    GATT_APPEARANCE_CHARACTERISTIC
+)
+
+# -----------------------------------------------------------------------------
+# Logging
+# -----------------------------------------------------------------------------
+logger = logging.getLogger(__name__)
+
+
+# -----------------------------------------------------------------------------
+# Classes
+# -----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
+class GenericAccessService(Service):
+    def __init__(self, device_name, appearance = (0, 0)):
+        device_name_characteristic = Characteristic(
+            GATT_DEVICE_NAME_CHARACTERISTIC,
+            Characteristic.READ,
+            Characteristic.READABLE,
+            device_name.encode('utf-8')[:248]
+        )
+
+        appearance_characteristic = Characteristic(
+            GATT_APPEARANCE_CHARACTERISTIC,
+            Characteristic.READ,
+            Characteristic.READABLE,
+            struct.pack('<H', (appearance[0] << 6) | appearance[1])
+        )
+
+        super().__init__(GATT_GENERIC_ACCESS_SERVICE, [
+            device_name_characteristic,
+            appearance_characteristic
+        ])

bumble/gatt.py

@@ -0,0 +1,475 @@
+# Copyright 2021-2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# GATT - Generic Attribute Profile
+#
+# See Bluetooth spec @ Vol 3, Part G
+#
+# -----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import asyncio
+import types
+import logging
+from colors import color
+
+from .core import *
+from .hci import *
+from .att import *
+
+# -----------------------------------------------------------------------------
+# Logging
+# -----------------------------------------------------------------------------
+logger = logging.getLogger(__name__)
+
+# -----------------------------------------------------------------------------
+# Constants
+# -----------------------------------------------------------------------------
+GATT_REQUEST_TIMEOUT = 30  # seconds
+
+GATT_MAX_ATTRIBUTE_VALUE_SIZE = 512
+
+# Services
+GATT_GENERIC_ACCESS_SERVICE                 = UUID.from_16_bits(0x1800, 'Generic Access')
+GATT_GENERIC_ATTRIBUTE_SERVICE              = UUID.from_16_bits(0x1801, 'Generic Attribute')
+GATT_IMMEDIATE_ALERT_SERVICE                = UUID.from_16_bits(0x1802, 'Immediate Alert')
+GATT_LINK_LOSS_SERVICE                      = UUID.from_16_bits(0x1803, 'Link Loss')
+GATT_TX_POWER_SERVICE                       = UUID.from_16_bits(0x1804, 'TX Power')
+GATT_CURRENT_TIME_SERVICE                   = UUID.from_16_bits(0x1805, 'Current Time')
+GATT_REFERENCE_TIME_UPDATE_SERVICE          = UUID.from_16_bits(0x1806, 'Reference Time Update')
+GATT_NEXT_DST_CHANGE_SERVICE                = UUID.from_16_bits(0x1807, 'Next DST Change')
+GATT_GLUCOSE_SERVICE                        = UUID.from_16_bits(0x1808, 'Glucose')
+GATT_HEALTH_THERMOMETER_SERVICE             = UUID.from_16_bits(0x1809, 'Health Thermometer')
+GATT_DEVICE_INFORMATION_SERVICE             = UUID.from_16_bits(0x180A, 'Device Information')
+GATT_HEART_RATE_SERVICE                     = UUID.from_16_bits(0x180D, 'Heart Rate')
+GATT_PHONE_ALERT_STATUS_SERVICE             = UUID.from_16_bits(0x180E, 'Phone Alert Status')
+GATT_BATTERY_SERVICE                        = UUID.from_16_bits(0x180F, 'Battery')
+GATT_BLOOD_PRESSURE_SERVICE                 = UUID.from_16_bits(0x1810, 'Blood Pressure')
+GATT_ALERT_NOTIFICATION_SERVICE             = UUID.from_16_bits(0x1811, 'Alert Notification')
+GATT_HUMAN_INTERFACE_DEVICE_SERVICE         = UUID.from_16_bits(0x1812, 'Human Interface Device')
+GATT_SCAN_PARAMETERS_SERVICE                = UUID.from_16_bits(0x1813, 'Scan Parameters')
+GATT_RUNNING_SPEED_AND_CADENCE_SERVICE      = UUID.from_16_bits(0x1814, 'Running Speed and Cadence')
+GATT_AUTOMATION_IO_SERVICE                  = UUID.from_16_bits(0x1815, 'Automation IO')
+GATT_CYCLING_SPEED_AND_CADENCE_SERVICE      = UUID.from_16_bits(0x1816, 'Cycling Speed and Cadence')
+GATT_CYCLING_POWER_SERVICE                  = UUID.from_16_bits(0x1818, 'Cycling Power')
+GATT_LOCATION_AND_NAVIGATION_SERVICE        = UUID.from_16_bits(0x1819, 'Location and Navigation')
+GATT_ENVIRONMENTAL_SENSING_SERVICE          = UUID.from_16_bits(0x181A, 'Environmental Sensing')
+GATT_BODY_COMPOSITION_SERVICE               = UUID.from_16_bits(0x181B, 'Body Composition')
+GATT_USER_DATA_SERVICE                      = UUID.from_16_bits(0x181C, 'User Data')
+GATT_WEIGHT_SCALE_SERVICE                   = UUID.from_16_bits(0x181D, 'Weight Scale')
+GATT_BOND_MANAGEMENT_SERVICE                = UUID.from_16_bits(0x181E, 'Bond Management')
+GATT_CONTINUOUS_GLUCOSE_MONITORING_SERVICE  = UUID.from_16_bits(0x181F, 'Continuous Glucose Monitoring')
+GATT_INTERNET_PROTOCOL_SUPPORT_SERVICE      = UUID.from_16_bits(0x1820, 'Internet Protocol Support')
+GATT_INDOOR_POSITIONING_SERVICE             = UUID.from_16_bits(0x1821, 'Indoor Positioning')
+GATT_PULSE_OXIMETER_SERVICE                 = UUID.from_16_bits(0x1822, 'Pulse Oximeter')
+GATT_HTTP_PROXY_SERVICE                     = UUID.from_16_bits(0x1823, 'HTTP Proxy')
+GATT_TRANSPORT_DISCOVERY_SERVICE            = UUID.from_16_bits(0x1824, 'Transport Discovery')
+GATT_OBJECT_TRANSFER_SERVICE                = UUID.from_16_bits(0x1825, 'Object Transfer')
+GATT_FITNESS_MACHINE_SERVICE                = UUID.from_16_bits(0x1826, 'Fitness Machine')
+GATT_MESH_PROVISIONING_SERVICE              = UUID.from_16_bits(0x1827, 'Mesh Provisioning')
+GATT_MESH_PROXY_SERVICE                     = UUID.from_16_bits(0x1828, 'Mesh Proxy')
+GATT_RECONNECTION_CONFIGURATION_SERVICE     = UUID.from_16_bits(0x1829, 'Reconnection Configuration')
+GATT_INSULIN_DELIVERY_SERVICE               = UUID.from_16_bits(0x183A, 'Insulin Delivery')
+GATT_BINARY_SENSOR_SERVICE                  = UUID.from_16_bits(0x183B, 'Binary Sensor')
+GATT_EMERGENCY_CONFIGURATION_SERVICE        = UUID.from_16_bits(0x183C, 'Emergency Configuration')
+GATT_PHYSICAL_ACTIVITY_MONITOR_SERVICE      = UUID.from_16_bits(0x183E, 'Physical Activity Monitor')
+GATT_AUDIO_INPUT_CONTROL_SERVICE            = UUID.from_16_bits(0x1843, 'Audio Input Control')
+GATT_VOLUME_CONTROL_SERVICE                 = UUID.from_16_bits(0x1844, 'Volume Control')
+GATT_VOLUME_OFFSET_CONTROL_SERVICE          = UUID.from_16_bits(0x1845, 'Volume Offset Control')
+GATT_COORDINATED_SET_IDENTIFICATION_SERVICE = UUID.from_16_bits(0x1846, 'Coordinated Set Identification Service')
+GATT_DEVICE_TIME_SERVICE                    = UUID.from_16_bits(0x1847, 'Device Time')
+GATT_MEDIA_CONTROL_SERVICE                  = UUID.from_16_bits(0x1848, 'Media Control Service')
+GATT_GENERIC_MEDIA_CONTROL_SERVICE          = UUID.from_16_bits(0x1849, 'Generic Media Control Service')
+GATT_CONSTANT_TONE_EXTENSION_SERVICE        = UUID.from_16_bits(0x184A, 'Constant Tone Extension')
+GATT_TELEPHONE_BEARER_SERVICE               = UUID.from_16_bits(0x184B, 'Telephone Bearer Service')
+GATT_GENERIC_TELEPHONE_BEARER_SERVICE       = UUID.from_16_bits(0x184C, 'Generic Telephone Bearer Service')
+GATT_MICROPHONE_CONTROL_SERVICE             = UUID.from_16_bits(0x184D, 'Microphone Control')
+
+# Types
+GATT_PRIMARY_SERVICE_ATTRIBUTE_TYPE   = UUID.from_16_bits(0x2800, 'Primary Service')
+GATT_SECONDARY_SERVICE_ATTRIBUTE_TYPE = UUID.from_16_bits(0x2801, 'Secondary Service')
+GATT_INCLUDE_ATTRIBUTE_TYPE           = UUID.from_16_bits(0x2802, 'Include')
+GATT_CHARACTERISTIC_ATTRIBUTE_TYPE    = UUID.from_16_bits(0x2803, 'Characteristic')
+
+# Descriptors
+GATT_CHARACTERISTIC_EXTENDED_PROPERTIES_DESCRIPTOR   = UUID.from_16_bits(0x2900, 'Characteristic Extended Properties')
+GATT_CHARACTERISTIC_USER_DESCRIPTION_DESCRIPTOR      = UUID.from_16_bits(0x2901, 'Characteristic User Description')
+GATT_CLIENT_CHARACTERISTIC_CONFIGURATION_DESCRIPTOR  = UUID.from_16_bits(0x2902, 'Client Characteristic Configuration')
+GATT_SERVER_CHARACTERISTIC_CONFIGURATION_DESCRIPTOR  = UUID.from_16_bits(0x2903, 'Server Characteristic Configuration')
+GATT_CHARACTERISTIC_PRESENTATION_FORMAT_DESCRIPTOR   = UUID.from_16_bits(0x2904, 'Characteristic Format')
+GATT_CHARACTERISTIC_AGGREGATE_FORMAT_DESCRIPTOR      = UUID.from_16_bits(0x2905, 'Characteristic Aggregate Format')
+GATT_VALID_RANGE_DESCRIPTOR                          = UUID.from_16_bits(0x2906, 'Valid Range')
+GATT_EXTERNAL_REPORT_DESCRIPTOR                      = UUID.from_16_bits(0x2907, 'External Report')
+GATT_REPORT_REFERENCE_DESCRIPTOR                     = UUID.from_16_bits(0x2908, 'Report Reference')
+GATT_NUMBER_OF_DIGITALS_DESCRIPTOR                   = UUID.from_16_bits(0x2909, 'Number of Digitals')
+GATT_VALUE_TRIGGER_SETTING_DESCRIPTOR                = UUID.from_16_bits(0x290A, 'Value Trigger Setting')
+GATT_ENVIRONMENTAL_SENSING_CONFIGURATION_DESCRIPTOR  = UUID.from_16_bits(0x290B, 'Environmental Sensing Configuration')
+GATT_ENVIRONMENTAL_SENSING_MEASUREMENT_DESCRIPTOR    = UUID.from_16_bits(0x290C, 'Environmental Sensing Measurement')
+GATT_ENVIRONMENTAL_SENSING_TRIGGER_DESCRIPTOR        = UUID.from_16_bits(0x290D, 'Environmental Sensing Trigger Setting')
+GATT_TIME_TRIGGER_DESCRIPTOR                         = UUID.from_16_bits(0x290E, 'Time Trigger Setting')
+GATT_COMPLETE_BR_EDR_TRANSPORT_BLOCK_DATA_DESCRIPTOR = UUID.from_16_bits(0x290F, 'Complete BR-EDR Transport Block Data')
+
+# Device Information Service
+GATT_SYSTEM_ID_CHARACTERISTIC                          = UUID.from_16_bits(0x2A23, 'System ID')
+GATT_MODEL_NUMBER_STRING_CHARACTERISTIC                = UUID.from_16_bits(0x2A24, 'Model Number String')
+GATT_SERIAL_NUMBER_STRING_CHARACTERISTIC               = UUID.from_16_bits(0x2A25, 'Serial Number String')
+GATT_FIRMWARE_REVISION_STRING_CHARACTERISTIC           = UUID.from_16_bits(0x2A26, 'Firmware Revision String')
+GATT_HARDWARE_REVISION_STRING_CHARACTERISTIC           = UUID.from_16_bits(0x2A27, 'Hardware Revision String')
+GATT_SOFTWARE_REVISION_STRING_CHARACTERISTIC           = UUID.from_16_bits(0x2A28, 'Software Revision String')
+GATT_MANUFACTURER_NAME_STRING_CHARACTERISTIC           = UUID.from_16_bits(0x2A29, 'Manufacturer Name String')
+GATT_REGULATORY_CERTIFICATION_DATA_LIST_CHARACTERISTIC = UUID.from_16_bits(0x2A2A, 'IEEE 11073-20601 Regulatory Certification Data List')
+GATT_PNP_ID_CHARACTERISTIC                             = UUID.from_16_bits(0x2A50, 'PnP ID')
+
+# Human Interface Device Service
+GATT_HID_INFORMATION_CHARACTERISTIC   = UUID.from_16_bits(0x2A4A, 'HID Information')
+GATT_REPORT_MAP_CHARACTERISTIC        = UUID.from_16_bits(0x2A4B, 'Report Map')
+GATT_HID_CONTROL_POINT_CHARACTERISTIC = UUID.from_16_bits(0x2A4C, 'HID Control Point')
+GATT_REPORT_CHARACTERISTIC            = UUID.from_16_bits(0x2A4D, 'Report')
+GATT_PROTOCOL_MODE_CHARACTERISTIC     = UUID.from_16_bits(0x2A4E, 'Protocol Mode')
+
+# Heart Rate Service
+GATT_HEART_RATE_MEASUREMENT_CHARACTERISTIC   = UUID.from_16_bits(0x2A37, 'Heart Rate Measurement')
+GATT_BODY_SENSOR_LOCATION_CHARACTERISTIC     = UUID.from_16_bits(0x2A38, 'Body Sensor Location')
+GATT_HEART_RATE_CONTROL_POINT_CHARACTERISTIC = UUID.from_16_bits(0x2A39, 'Heart Rate Control Point')
+
+# Battery Service
+GATT_BATTERY_LEVEL_CHARACTERISTIC = UUID.from_16_bits(0x2A19, 'Battery Level')
+
+# Misc
+GATT_DEVICE_NAME_CHARACTERISTIC                                = UUID.from_16_bits(0x2A00, 'Device Name')
+GATT_APPEARANCE_CHARACTERISTIC                                 = UUID.from_16_bits(0x2A01, 'Appearance')
+GATT_PERIPHERAL_PRIVACY_FLAG_CHARACTERISTIC                    = UUID.from_16_bits(0x2A02, 'Peripheral Privacy Flag')
+GATT_RECONNECTION_ADDRESS_CHARACTERISTIC                       = UUID.from_16_bits(0x2A03, 'Reconnection Address')
+GATT_PERIPHERAL_PREFERRED_CONNECTION_PARAMETERS_CHARACTERISTIC = UUID.from_16_bits(0x2A04, 'Peripheral Preferred Connection Parameters')
+GATT_SERVICE_CHANGED_CHARACTERISTIC                            = UUID.from_16_bits(0x2A05, 'Service Changed')
+GATT_ALERT_LEVEL_CHARACTERISTIC                                = UUID.from_16_bits(0x2A06, 'Alert Level')
+GATT_TX_POWER_LEVEL_CHARACTERISTIC                             = UUID.from_16_bits(0x2A07, 'Tx Power Level')
+GATT_BOOT_KEYBOARD_INPUT_REPORT_CHARACTERISTIC                 = UUID.from_16_bits(0x2A22, 'Boot Keyboard Input Report')
+GATT_CURRENT_TIME_CHARACTERISTIC                               = UUID.from_16_bits(0x2A2B, 'Current Time')
+GATT_BOOT_KEYBOARD_OUTPUT_REPORT_CHARACTERISTIC                = UUID.from_16_bits(0x2A32, 'Boot Keyboard Output Report')
+GATT_CENTRAL_ADDRESS_RESOLUTION__CHARACTERISTIC                = UUID.from_16_bits(0x2AA6, 'Central Address Resolution')
+
+
+# -----------------------------------------------------------------------------
+# Utils
+# -----------------------------------------------------------------------------
+
+def show_services(services):
+    for service in services:
+        print(color(str(service), 'cyan'))
+
+        for characteristic in service.characteristics:
+            print(color('  ' + str(characteristic), 'magenta'))
+
+            for descriptor in characteristic.descriptors:
+                print(color('    ' + str(descriptor), 'green'))
+
+
+# -----------------------------------------------------------------------------
+class Service(Attribute):
+    '''
+    See Vol 3, Part G - 3.1 SERVICE DEFINITION
+    '''
+
+    def __init__(self, uuid, characteristics, primary=True):
+        # Convert the uuid to a UUID object if it isn't already
+        if type(uuid) is str:
+            uuid = UUID(uuid)
+
+        super().__init__(
+            GATT_PRIMARY_SERVICE_ATTRIBUTE_TYPE if primary else GATT_SECONDARY_SERVICE_ATTRIBUTE_TYPE,
+            Attribute.READABLE,
+            uuid.to_pdu_bytes()
+        )
+        self.uuid              = uuid
+        self.included_services = []
+        self.characteristics   = characteristics[:]
+        self.primary           = primary
+
+    def __str__(self):
+        return f'Service(handle=0x{self.handle:04X}, end=0x{self.end_group_handle:04X}, uuid={self.uuid}){"" if self.primary else "*"}'
+
+
+# -----------------------------------------------------------------------------
+class TemplateService(Service):
+    '''
+    Convenience abstract class that can be used by profile-specific subclasses that want
+    to expose their UUID as a class property
+    '''
+    UUID = None
+
+    def __init__(self, characteristics, primary=True):
+        super().__init__(self.UUID, characteristics, primary)
+
+
+# -----------------------------------------------------------------------------
+class Characteristic(Attribute):
+    '''
+    See Vol 3, Part G - 3.3 CHARACTERISTIC DEFINITION
+    '''
+
+    # Property flags
+    BROADCAST                   = 0x01
+    READ                        = 0x02
+    WRITE_WITHOUT_RESPONSE      = 0x04
+    WRITE                       = 0x08
+    NOTIFY                      = 0x10
+    INDICATE                    = 0X20
+    AUTHENTICATED_SIGNED_WRITES = 0X40
+    EXTENDED_PROPERTIES         = 0X80
+
+    PROPERTY_NAMES = {
+        BROADCAST:                   'BROADCAST',
+        READ:                        'READ',
+        WRITE_WITHOUT_RESPONSE:      'WRITE_WITHOUT_RESPONSE',
+        WRITE:                       'WRITE',
+        NOTIFY:                      'NOTIFY',
+        INDICATE:                    'INDICATE',
+        AUTHENTICATED_SIGNED_WRITES: 'AUTHENTICATED_SIGNED_WRITES',
+        EXTENDED_PROPERTIES:         'EXTENDED_PROPERTIES'
+    }
+
+    @staticmethod
+    def property_name(property):
+        return Characteristic.PROPERTY_NAMES.get(property, '')
+
+    @staticmethod
+    def properties_as_string(properties):
+        return ','.join([
+            Characteristic.property_name(p) for p in Characteristic.PROPERTY_NAMES.keys()
+            if properties & p
+        ])
+
+    def __init__(self, uuid, properties, permissions, value = b'', descriptors = []):
+        super().__init__(uuid, permissions, value)
+        self.uuid        = self.type
+        self.properties  = properties
+        self.descriptors = descriptors
+
+    def get_descriptor(self, descriptor_type):
+        for descriptor in self.descriptors:
+            if descriptor.uuid == descriptor_type:
+                return descriptor
+
+    def __str__(self):
+        return f'Characteristic(handle=0x{self.handle:04X}, end=0x{self.end_group_handle:04X}, uuid={self.uuid}, properties={Characteristic.properties_as_string(self.properties)})'
+
+
+# -----------------------------------------------------------------------------
+class CharacteristicValue:
+    '''
+    Characteristic value where reading and/or writing is delegated to functions
+    passed as arguments to the constructor.
+    '''
+    def __init__(self, read=None, write=None):
+        self._read = read
+        self._write = write
+
+    def read(self, connection):
+        return self._read(connection) if self._read else b''
+
+    def write(self, connection, value):
+        if self._write:
+            self._write(connection, value)
+
+
+# -----------------------------------------------------------------------------
+class CharacteristicAdapter:
+    '''
+    An adapter that can adapt any object with `read_value` and `write_value`
+    methods (like Characteristic and CharacteristicProxy objects) by wrapping
+    those methods with ones that return/accept encoded/decoded values.
+    Objects with async methods are considered proxies, so the adaptation is one
+    where the return value of `read_value` is decoded and the value passed to
+    `write_value` is encoded. Other objects are considered local characteristics
+    so the adaptation is one where the return value of `read_value` is encoded
+    and the value passed to `write_value` is decoded.
+    If the characteristic has a `subscribe` method, it is wrapped with one where
+    the values are decoded before being passed to the subscriber.
+    '''
+    def __init__(self, characteristic):
+        self.wrapped_characteristic = characteristic
+        self.subscribers = {}  # Map from subscriber to proxy subscriber
+
+        if (
+            asyncio.iscoroutinefunction(characteristic.read_value) and
+            asyncio.iscoroutinefunction(characteristic.write_value)
+        ):
+            self.read_value  = self.read_decoded_value
+            self.write_value = self.write_decoded_value
+        else:
+            self.read_value  = self.read_encoded_value
+            self.write_value = self.write_encoded_value
+
+        if hasattr(self.wrapped_characteristic, 'subscribe'):
+            self.subscribe = self.wrapped_subscribe
+
+        if hasattr(self.wrapped_characteristic, 'unsubscribe'):
+            self.unsubscribe = self.wrapped_unsubscribe
+
+    def __getattr__(self, name):
+        return getattr(self.wrapped_characteristic, name)
+
+    def __setattr__(self, name, value):
+        if name in {
+            'wrapped_characteristic',
+            'subscribers',
+            'read_value',
+            'write_value',
+            'subscribe',
+            'unsubscribe'
+        }:
+            super().__setattr__(name, value)
+        else:
+            setattr(self.wrapped_characteristic, name, value)
+
+    def read_encoded_value(self, connection):
+        return self.encode_value(self.wrapped_characteristic.read_value(connection))
+
+    def write_encoded_value(self, connection, value):
+        return self.wrapped_characteristic.write_value(connection, self.decode_value(value))
+
+    async def read_decoded_value(self):
+        return self.decode_value(await self.wrapped_characteristic.read_value())
+
+    async def write_decoded_value(self, value, with_response=False):
+        return await self.wrapped_characteristic.write_value(
+            self.encode_value(value),
+            with_response
+        )
+
+    def encode_value(self, value):
+        return value
+
+    def decode_value(self, value):
+        return value
+
+    def wrapped_subscribe(self, subscriber=None):
+        if subscriber is not None:
+            if subscriber in self.subscribers:
+                # We already have a proxy subscriber
+                subscriber = self.subscribers[subscriber]
+            else:
+                # Create and register a proxy that will decode the value
+                original_subscriber = subscriber
+
+                def on_change(value):
+                    original_subscriber(self.decode_value(value))
+                self.subscribers[subscriber] = on_change
+                subscriber = on_change
+
+        return self.wrapped_characteristic.subscribe(subscriber)
+
+    def wrapped_unsubscribe(self, subscriber=None):
+        if subscriber in self.subscribers:
+            subscriber = self.subscribers.pop(subscriber)
+
+        return self.wrapped_characteristic.unsubscribe(subscriber)
+
+    def __str__(self):
+        wrapped = str(self.wrapped_characteristic)
+        return f'{self.__class__.__name__}({wrapped})'
+
+
+# -----------------------------------------------------------------------------
+class DelegatedCharacteristicAdapter(CharacteristicAdapter):
+    '''
+    Adapter that converts bytes values using an encode and a decode function.
+    '''
+    def __init__(self, characteristic, encode=None, decode=None):
+        super().__init__(characteristic)
+        self.encode = encode
+        self.decode = decode
+
+    def encode_value(self, value):
+        return self.encode(value) if self.encode else value
+
+    def decode_value(self, value):
+        return self.decode(value) if self.decode else value
+
+
+# -----------------------------------------------------------------------------
+class PackedCharacteristicAdapter(CharacteristicAdapter):
+    '''
+    Adapter that packs/unpacks characteristic values according to a standard
+    Python `struct` format.
+    For formats with a single value, the adapted `read_value` and `write_value`
+    methods return/accept single values. For formats with multiple values,
+    they return/accept a tuple with the same number of elements as is required for
+    the format.
+    '''
+    def __init__(self, characteristic, format):
+        super().__init__(characteristic)
+        self.struct = struct.Struct(format)
+
+    def pack(self, *values):
+        return self.struct.pack(*values)
+
+    def unpack(self, buffer):
+        return self.struct.unpack(buffer)
+
+    def encode_value(self, value):
+        return self.pack(*value if type(value) is tuple else (value,))
+
+    def decode_value(self, value):
+        unpacked = self.unpack(value)
+        return unpacked[0] if len(unpacked) == 1 else unpacked
+
+
+# -----------------------------------------------------------------------------
+class MappedCharacteristicAdapter(PackedCharacteristicAdapter):
+    '''
+    Adapter that packs/unpacks characteristic values according to a standard
+    Python `struct` format.
+    The adapted `read_value` and `write_value` methods return/accept aa dictionary which
+    is packed/unpacked according to format, with the arguments extracted from the dictionary
+    by key, in the same order as they occur in the `keys` parameter.
+    '''
+    def __init__(self, characteristic, format, keys):
+        super().__init__(characteristic, format)
+        self.keys = keys
+
+    def pack(self, values):
+        return super().pack(*(values[key] for key in self.keys))
+
+    def unpack(self, buffer):
+        return dict(zip(self.keys, super().unpack(buffer)))
+
+
+# -----------------------------------------------------------------------------
+class UTF8CharacteristicAdapter(CharacteristicAdapter):
+    '''
+    Adapter that converts strings to/from bytes using UTF-8 encoding
+    '''
+    def encode_value(self, value):
+        return value.encode('utf-8')
+
+    def decode_value(self, value):
+        return value.decode('utf-8')
+
+
+# -----------------------------------------------------------------------------
+class Descriptor(Attribute):
+    '''
+    See Vol 3, Part G - 3.3.3 Characteristic Descriptor Declarations
+    '''
+
+    def __init__(self, descriptor_type, permissions, value = b''):
+        super().__init__(descriptor_type, permissions, value)
+
+    def __str__(self):
+        return f'Descriptor(handle=0x{self.handle:04X}, type={self.type}, value={self.read_value(None).hex()})'

bumble/gatt_client.py

@@ -0,0 +1,793 @@
+# Copyright 2021-2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# GATT - Generic Attribute Profile
+# Client
+#
+# See Bluetooth spec @ Vol 3, Part G
+#
+# -----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import asyncio
+import logging
+import struct
+from colors import color
+
+from .core import ProtocolError, TimeoutError
+from .hci import *
+from .att import *
+from .gatt import (
+    GATT_CLIENT_CHARACTERISTIC_CONFIGURATION_DESCRIPTOR,
+    GATT_REQUEST_TIMEOUT,
+    GATT_PRIMARY_SERVICE_ATTRIBUTE_TYPE,
+    GATT_SECONDARY_SERVICE_ATTRIBUTE_TYPE,
+    GATT_CHARACTERISTIC_ATTRIBUTE_TYPE,
+    Characteristic
+)
+
+# -----------------------------------------------------------------------------
+# Logging
+# -----------------------------------------------------------------------------
+logger = logging.getLogger(__name__)
+
+
+# -----------------------------------------------------------------------------
+# Proxies
+# -----------------------------------------------------------------------------
+class AttributeProxy(EventEmitter):
+    def __init__(self, client, handle, end_group_handle, attribute_type):
+        EventEmitter.__init__(self)
+        self.client           = client
+        self.handle           = handle
+        self.end_group_handle = end_group_handle
+        self.type             = attribute_type
+
+    async def read_value(self, no_long_read=False):
+        return self.decode_value(await self.client.read_value(self.handle, no_long_read))
+
+    async def write_value(self, value, with_response=False):
+        return await self.client.write_value(self.handle, self.encode_value(value), with_response)
+
+    def encode_value(self, value):
+        return value
+
+    def decode_value(self, value_bytes):
+        return value_bytes
+
+    def __str__(self):
+        return f'Attribute(handle=0x{self.handle:04X}, type={self.uuid})'
+
+
+class ServiceProxy(AttributeProxy):
+    @staticmethod
+    def from_client(cls, client, service_uuid):
+        # The service and its characteristics are considered to have already been discovered
+        services = client.get_services_by_uuid(service_uuid)
+        service = services[0] if services else None
+        return cls(service) if service else None
+
+    def __init__(self, client, handle, end_group_handle, uuid, primary=True):
+        attribute_type = GATT_PRIMARY_SERVICE_ATTRIBUTE_TYPE if primary else GATT_SECONDARY_SERVICE_ATTRIBUTE_TYPE
+        super().__init__(client, handle, end_group_handle, attribute_type)
+        self.uuid            = uuid
+        self.characteristics = []
+
+    async def discover_characteristics(self, uuids=[]):
+        return await self.client.discover_characteristics(uuids, self)
+
+    def get_characteristics_by_uuid(self, uuid):
+        return self.client.get_characteristics_by_uuid(uuid, self)
+
+    def __str__(self):
+        return f'Service(handle=0x{self.handle:04X}, uuid={self.uuid})'
+
+
+class CharacteristicProxy(AttributeProxy):
+    def __init__(self, client, handle, end_group_handle, uuid, properties):
+        super().__init__(client, handle, end_group_handle, uuid)
+        self.uuid                   = uuid
+        self.properties             = properties
+        self.descriptors            = []
+        self.descriptors_discovered = False
+        self.subscribers            = {}  # Map from subscriber to proxy subscriber
+
+    def get_descriptor(self, descriptor_type):
+        for descriptor in self.descriptors:
+            if descriptor.type == descriptor_type:
+                return descriptor
+
+    async def discover_descriptors(self):
+        return await self.client.discover_descriptors(self)
+
+    async def subscribe(self, subscriber=None):
+        if subscriber is not None:
+            if subscriber in self.subscribers:
+                # We already have a proxy subscriber
+                subscriber = self.subscribers[subscriber]
+            else:
+                # Create and register a proxy that will decode the value
+                original_subscriber = subscriber
+
+                def on_change(value):
+                    original_subscriber(self.decode_value(value))
+                self.subscribers[subscriber] = on_change
+                subscriber = on_change
+
+        return await self.client.subscribe(self, subscriber)
+
+    async def unsubscribe(self, subscriber=None):
+        if subscriber in self.subscribers:
+            subscriber = self.subscribers.pop(subscriber)
+
+        return await self.client.unsubscribe(self, subscriber)
+
+    def __str__(self):
+        return f'Characteristic(handle=0x{self.handle:04X}, uuid={self.uuid}, properties={Characteristic.properties_as_string(self.properties)})'
+
+
+class DescriptorProxy(AttributeProxy):
+    def __init__(self, client, handle, descriptor_type):
+        super().__init__(client, handle, 0, descriptor_type)
+
+    def __str__(self):
+        return f'Descriptor(handle=0x{self.handle:04X}, type={self.type})'
+
+
+class ProfileServiceProxy:
+    '''
+    Base class for profile-specific service proxies
+    '''
+    @classmethod
+    def from_client(cls, client):
+        return ServiceProxy.from_client(cls, client, cls.SERVICE_CLASS.UUID)
+
+
+# -----------------------------------------------------------------------------
+# GATT Client
+# -----------------------------------------------------------------------------
+class Client:
+    def __init__(self, connection):
+        self.connection               = connection
+        self.mtu_exchange_done        = False
+        self.request_semaphore        = asyncio.Semaphore(1)
+        self.pending_request          = None
+        self.pending_response         = None
+        self.notification_subscribers = {}  # Notification subscribers, by attribute handle
+        self.indication_subscribers   = {}  # Indication subscribers, by attribute handle
+        self.services                 = []
+
+    def send_gatt_pdu(self, pdu):
+        self.connection.send_l2cap_pdu(ATT_CID, pdu)
+
+    async def send_command(self, command):
+        logger.debug(f'GATT Command from client: [0x{self.connection.handle:04X}] {command}')
+        self.send_gatt_pdu(command.to_bytes())
+
+    async def send_request(self, request):
+        logger.debug(f'GATT Request from client: [0x{self.connection.handle:04X}] {request}')
+
+        # Wait until we can send (only one pending command at a time for the connection)
+        response = None
+        async with self.request_semaphore:
+            assert self.pending_request is None
+            assert self.pending_response is None
+
+            # Create a future value to hold the eventual response
+            self.pending_response = asyncio.get_running_loop().create_future()
+            self.pending_request  = request
+
+            try:
+                self.send_gatt_pdu(request.to_bytes())
+                response = await asyncio.wait_for(self.pending_response, GATT_REQUEST_TIMEOUT)
+            except asyncio.TimeoutError:
+                logger.warning(color('!!! GATT Request timeout', 'red'))
+                raise TimeoutError(f'GATT timeout for {request.name}')
+            finally:
+                self.pending_request  = None
+                self.pending_response = None
+
+        return response
+
+    def send_confirmation(self, confirmation):
+        logger.debug(f'GATT Confirmation from client: [0x{self.connection.handle:04X}] {confirmation}')
+        self.send_gatt_pdu(confirmation.to_bytes())
+
+    async def request_mtu(self, mtu):
+        # Check the range
+        if mtu < ATT_DEFAULT_MTU:
+            raise ValueError(f'MTU must be >= {ATT_DEFAULT_MTU}')
+        if mtu > 0xFFFF:
+            raise ValueError('MTU must be <= 0xFFFF')
+
+        # We can only send one request per connection
+        if self.mtu_exchange_done:
+            return self.connection.att_mtu
+
+        # Send the request
+        self.mtu_exchange_done = True
+        response = await self.send_request(ATT_Exchange_MTU_Request(client_rx_mtu = mtu))
+        if response.op_code == ATT_ERROR_RESPONSE:
+            raise ProtocolError(
+                response.error_code,
+                'att',
+                ATT_PDU.error_name(response.error_code),
+                response
+            )
+
+        # Compute the final MTU
+        self.connection.att_mtu = min(mtu, response.server_rx_mtu)
+
+        return self.connection.att_mtu
+
+    def get_services_by_uuid(self, uuid):
+        return [service for service in self.services if service.uuid == uuid]
+
+    def get_characteristics_by_uuid(self, uuid, service = None):
+        services = [service] if service else self.services
+        return [c for c in [c for s in services for c in s.characteristics] if c.uuid == uuid]
+
+    def on_service_discovered(self, service):
+        ''' Add a service to the service list if it wasn't already there '''
+        already_known = False
+        for existing_service in self.services:
+            if existing_service.handle == service.handle:
+                already_known = True
+                break
+        if not already_known:
+            self.services.append(service)
+
+    async def discover_services(self, uuids = None):
+        '''
+        See Vol 3, Part G - 4.4.1 Discover All Primary Services
+        '''
+        starting_handle = 0x0001
+        services = []
+        while starting_handle < 0xFFFF:
+            response = await self.send_request(
+                ATT_Read_By_Group_Type_Request(
+                    starting_handle      = starting_handle,
+                    ending_handle        = 0xFFFF,
+                    attribute_group_type = GATT_PRIMARY_SERVICE_ATTRIBUTE_TYPE
+                )
+            )
+            if response is None:
+                # TODO raise appropriate exception
+                return []
+
+            # Check if we reached the end of the iteration
+            if response.op_code == ATT_ERROR_RESPONSE:
+                if response.error_code != ATT_ATTRIBUTE_NOT_FOUND_ERROR:
+                    # Unexpected end
+                    logger.waning(f'!!! unexpected error while discovering services: {HCI_Constant.error_name(response.error_code)}')
+                    # TODO raise appropriate exception
+                    return
+                break
+
+            for attribute_handle, end_group_handle, attribute_value in response.attributes:
+                if attribute_handle < starting_handle or end_group_handle < attribute_handle:
+                    # Something's not right
+                    logger.warning(f'bogus handle values: {attribute_handle} {end_group_handle}')
+                    return
+
+                # Create a service proxy for this service
+                service = ServiceProxy(
+                    self,
+                    attribute_handle,
+                    end_group_handle,
+                    UUID.from_bytes(attribute_value),
+                    True
+                )
+
+                # Filter out returned services based on the given uuids list
+                if (not uuids) or (service.uuid in uuids):
+                    services.append(service)
+
+                # Add the service to the peer's service list
+                self.on_service_discovered(service)
+
+            # Stop if for some reason the list was empty
+            if not response.attributes:
+                break
+
+            # Move on to the next chunk
+            starting_handle = response.attributes[-1][1] + 1
+
+        return services
+
+    async def discover_service(self, uuid):
+        '''
+        See Vol 3, Part G - 4.4.2 Discover Primary Service by Service UUID
+        '''
+
+        # Force uuid to be a UUID object
+        if type(uuid) is str:
+            uuid = UUID(uuid)
+
+        starting_handle = 0x0001
+        services = []
+        while starting_handle < 0xFFFF:
+            response = await self.send_request(
+                ATT_Find_By_Type_Value_Request(
+                    starting_handle = starting_handle,
+                    ending_handle   = 0xFFFF,
+                    attribute_type  = GATT_PRIMARY_SERVICE_ATTRIBUTE_TYPE,
+                    attribute_value = uuid.to_pdu_bytes()
+                )
+            )
+            if response is None:
+                # TODO raise appropriate exception
+                return []
+
+            # Check if we reached the end of the iteration
+            if response.op_code == ATT_ERROR_RESPONSE:
+                if response.error_code != ATT_ATTRIBUTE_NOT_FOUND_ERROR:
+                    # Unexpected end
+                    logger.waning(f'!!! unexpected error while discovering services: {HCI_Constant.error_name(response.error_code)}')
+                    # TODO raise appropriate exception
+                    return
+                break
+
+            for attribute_handle, end_group_handle in response.handles_information:
+                if attribute_handle < starting_handle or end_group_handle < attribute_handle:
+                    # Something's not right
+                    logger.warning(f'bogus handle values: {attribute_handle} {end_group_handle}')
+                    return
+
+                # Create a service proxy for this service
+                service = ServiceProxy(self, attribute_handle, end_group_handle, uuid, True)
+
+                # Add the service to the peer's service list
+                services.append(service)
+                self.on_service_discovered(service)
+
+                # Check if we've reached the end already
+                if end_group_handle == 0xFFFF:
+                    break
+
+            # Stop if for some reason the list was empty
+            if not response.handles_information:
+                break
+
+            # Move on to the next chunk
+            starting_handle = response.handles_information[-1][1] + 1
+
+        return services
+
+    async def discover_included_services(self, service):
+        '''
+        See Vol 3, Part G - 4.5.1 Find Included Services
+        '''
+        # TODO
+        return []
+
+    async def discover_characteristics(self, uuids, service):
+        '''
+        See Vol 3, Part G - 4.6.1 Discover All Characteristics of a Service and 4.6.2 Discover Characteristics by UUID
+        '''
+
+        # Cast the UUIDs type from string to object if needed
+        uuids = [UUID(uuid) if type(uuid) is str else uuid for uuid in uuids]
+
+        # Decide which services to discover for
+        services = [service] if service else self.services
+
+        # Perform characteristic discovery for each service
+        discovered_characteristics = []
+        for service in services:
+            starting_handle = service.handle
+            ending_handle   = service.end_group_handle
+
+            characteristics = []
+            while starting_handle <= ending_handle:
+                response = await self.send_request(
+                    ATT_Read_By_Type_Request(
+                        starting_handle = starting_handle,
+                        ending_handle   = ending_handle,
+                        attribute_type  = GATT_CHARACTERISTIC_ATTRIBUTE_TYPE
+                    )
+                )
+                if response is None:
+                    # TODO raise appropriate exception
+                    return []
+
+                # Check if we reached the end of the iteration
+                if response.op_code == ATT_ERROR_RESPONSE:
+                    if response.error_code != ATT_ATTRIBUTE_NOT_FOUND_ERROR:
+                        # Unexpected end
+                        logger.warning(f'!!! unexpected error while discovering characteristics: {HCI_Constant.error_name(response.error_code)}')
+                        # TODO raise appropriate exception
+                        return
+                    break
+
+                # Stop if for some reason the list was empty
+                if not response.attributes:
+                    break
+
+                # Process all characteristics returned in this iteration
+                for attribute_handle, attribute_value in response.attributes:
+                    if attribute_handle < starting_handle:
+                        # Something's not right
+                        logger.warning(f'bogus handle value: {attribute_handle}')
+                        return []
+
+                    properties, handle = struct.unpack_from('<BH', attribute_value)
+                    characteristic_uuid = UUID.from_bytes(attribute_value[3:])
+                    characteristic = CharacteristicProxy(self, handle, 0, characteristic_uuid, properties)
+
+                    # Set the previous characteristic's end handle
+                    if characteristics:
+                        characteristics[-1].end_group_handle = attribute_handle - 1
+
+                    characteristics.append(characteristic)
+
+                # Move on to the next characteristics
+                starting_handle = response.attributes[-1][0] + 1
+
+            # Set the end handle for the last characteristic
+            if characteristics:
+                characteristics[-1].end_group_handle = service.end_group_handle
+
+            # Set the service's characteristics
+            characteristics = [c for c in characteristics if not uuids or c.uuid in uuids]
+            service.characteristics = characteristics
+            discovered_characteristics.extend(characteristics)
+
+        return discovered_characteristics
+
+    async def discover_descriptors(self, characteristic = None, start_handle = None, end_handle = None):
+        '''
+        See Vol 3, Part G - 4.7.1 Discover All Characteristic Descriptors
+        '''
+        if characteristic:
+            starting_handle = characteristic.handle + 1
+            ending_handle   = characteristic.end_group_handle
+        elif start_handle and end_handle:
+            starting_handle = start_handle
+            ending_handle   = end_handle
+        else:
+            return []
+
+        descriptors = []
+        while starting_handle <= ending_handle:
+            response = await self.send_request(
+                ATT_Find_Information_Request(
+                    starting_handle = starting_handle,
+                    ending_handle   = ending_handle
+                )
+            )
+            if response is None:
+                # TODO raise appropriate exception
+                return []
+
+            # Check if we reached the end of the iteration
+            if response.op_code == ATT_ERROR_RESPONSE:
+                if response.error_code != ATT_ATTRIBUTE_NOT_FOUND_ERROR:
+                    # Unexpected end
+                    logger.warning(f'!!! unexpected error while discovering descriptors: {HCI_Constant.error_name(response.error_code)}')
+                    # TODO raise appropriate exception
+                    return []
+                break
+
+            # Stop if for some reason the list was empty
+            if not response.information:
+                break
+
+            # Process all descriptors returned in this iteration
+            for attribute_handle, attribute_uuid in response.information:
+                if attribute_handle < starting_handle:
+                    # Something's not right
+                    logger.warning(f'bogus handle value: {attribute_handle}')
+                    return []
+
+                descriptor = DescriptorProxy(self, attribute_handle, UUID.from_bytes(attribute_uuid))
+                descriptors.append(descriptor)
+                # TODO: read descriptor value
+
+            # Move on to the next descriptor
+            starting_handle = response.information[-1][0] + 1
+
+        # Set the characteristic's descriptors
+        if characteristic:
+            characteristic.descriptors = descriptors
+
+        return descriptors
+
+    async def discover_attributes(self):
+        '''
+        Discover all attributes, regardless of type
+        '''
+        starting_handle = 0x0001
+        ending_handle   = 0xFFFF
+        attributes = []
+        while True:
+            response = await self.send_request(
+                ATT_Find_Information_Request(
+                    starting_handle = starting_handle,
+                    ending_handle   = ending_handle
+                )
+            )
+            if response is None:
+                return []
+
+            # Check if we reached the end of the iteration
+            if response.op_code == ATT_ERROR_RESPONSE:
+                if response.error_code != ATT_ATTRIBUTE_NOT_FOUND_ERROR:
+                    # Unexpected end
+                    logger.warning(f'!!! unexpected error while discovering attributes: {HCI_Constant.error_name(response.error_code)}')
+                    return []
+                break
+
+            for attribute_handle, attribute_uuid in response.information:
+                if attribute_handle < starting_handle:
+                    # Something's not right
+                    logger.warning(f'bogus handle value: {attribute_handle}')
+                    return []
+
+                attribute = AttributeProxy(self, attribute_handle, 0, UUID.from_bytes(attribute_uuid))
+                attributes.append(attribute)
+
+            # Move on to the next attributes
+            starting_handle = attributes[-1].handle + 1
+
+        return attributes
+
+    async def subscribe(self, characteristic, subscriber=None):
+        # If we haven't already discovered the descriptors for this characteristic, do it now
+        if not characteristic.descriptors_discovered:
+            await self.discover_descriptors(characteristic)
+
+        # Look for the CCCD descriptor
+        cccd = characteristic.get_descriptor(GATT_CLIENT_CHARACTERISTIC_CONFIGURATION_DESCRIPTOR)
+        if not cccd:
+            logger.warning('subscribing to characteristic with no CCCD descriptor')
+            return
+
+        # Set the subscription bits and select the subscriber set
+        bits = 0
+        subscriber_sets = []
+        if characteristic.properties & Characteristic.NOTIFY:
+            bits |= 0x0001
+            subscriber_sets.append(self.notification_subscribers.setdefault(characteristic.handle, set()))
+        if characteristic.properties & Characteristic.INDICATE:
+            bits |= 0x0002
+            subscriber_sets.append(self.indication_subscribers.setdefault(characteristic.handle, set()))
+
+        # Add subscribers to the sets
+        for subscriber_set in subscriber_sets:
+            if subscriber is not None:
+                subscriber_set.add(subscriber)
+            # Add the characteristic as a subscriber, which will result in the characteristic
+            # emitting an 'update' event when a notification or indication is received
+            subscriber_set.add(characteristic)
+
+        await self.write_value(cccd, struct.pack('<H', bits), with_response=True)
+
+    async def unsubscribe(self, characteristic, subscriber=None):
+        # If we haven't already discovered the descriptors for this characteristic, do it now
+        if not characteristic.descriptors_discovered:
+            await self.discover_descriptors(characteristic)
+
+        # Look for the CCCD descriptor
+        cccd = characteristic.get_descriptor(GATT_CLIENT_CHARACTERISTIC_CONFIGURATION_DESCRIPTOR)
+        if not cccd:
+            logger.warning('unsubscribing from characteristic with no CCCD descriptor')
+            return
+
+        if subscriber is not None:
+            # Remove matching subscriber from subscriber sets
+            for subscriber_set in (self.notification_subscribers, self.indication_subscribers):
+                subscribers = subscriber_set.get(characteristic.handle, [])
+                if subscriber in subscribers:
+                    subscribers.remove(subscriber)
+
+                    # Cleanup if we removed the last one
+                    if not subscribers:
+                        subscriber_set.remove(characteristic.handle)
+        else:
+            # Remove all subscribers for this attribute from the sets!
+            self.notification_subscribers.pop(characteristic.handle, None)
+            self.indication_subscribers.pop(characteristic.handle, None)
+
+        if not self.notification_subscribers and not self.indication_subscribers:
+            # No more subscribers left
+            await self.write_value(cccd, b'\x00\x00', with_response=True)
+
+    async def read_value(self, attribute, no_long_read=False):
+        '''
+        See Vol 3, Part G - 4.8.1 Read Characteristic Value
+
+        `attribute` can be an Attribute object, or a handle value
+        '''
+
+        # Send a request to read
+        attribute_handle = attribute if type(attribute) is int else attribute.handle
+        response = await self.send_request(ATT_Read_Request(attribute_handle = attribute_handle))
+        if response is None:
+            raise TimeoutError('read timeout')
+        if response.op_code == ATT_ERROR_RESPONSE:
+            raise ProtocolError(
+                response.error_code,
+                'att',
+                ATT_PDU.error_name(response.error_code),
+                response
+            )
+
+        # If the value is the max size for the MTU, try to read more unless the caller
+        # specifically asked not to do that
+        attribute_value = response.attribute_value
+        if not no_long_read and len(attribute_value) == self.connection.att_mtu - 1:
+            logger.debug('using READ BLOB to get the rest of the value')
+            offset = len(attribute_value)
+            while True:
+                response = await self.send_request(
+                    ATT_Read_Blob_Request(attribute_handle = attribute_handle, value_offset = offset)
+                )
+                if response is None:
+                    raise TimeoutError('read timeout')
+                if response.op_code == ATT_ERROR_RESPONSE:
+                    if response.error_code == ATT_ATTRIBUTE_NOT_LONG_ERROR or response.error_code == ATT_INVALID_OFFSET_ERROR:
+                        break
+                    raise ProtocolError(
+                        response.error_code,
+                        'att',
+                        ATT_PDU.error_name(response.error_code),
+                        response
+                    )
+
+                part = response.part_attribute_value
+                attribute_value += part
+
+                if len(part) < self.connection.att_mtu - 1:
+                    break
+
+                offset += len(part)
+
+        # Return the value as bytes
+        return attribute_value
+
+    async def read_characteristics_by_uuid(self, uuid, service):
+        '''
+        See Vol 3, Part G - 4.8.2 Read Using Characteristic UUID
+        '''
+
+        if service is None:
+            starting_handle = 0x0001
+            ending_handle   = 0xFFFF
+        else:
+            starting_handle = service.handle
+            ending_handle   = service.end_group_handle
+
+        characteristics_values = []
+        while starting_handle <= ending_handle:
+            response = await self.send_request(
+                ATT_Read_By_Type_Request(
+                    starting_handle = starting_handle,
+                    ending_handle   = ending_handle,
+                    attribute_type  = uuid
+                )
+            )
+            if response is None:
+                # TODO raise appropriate exception
+                return []
+
+            # Check if we reached the end of the iteration
+            if response.op_code == ATT_ERROR_RESPONSE:
+                if response.error_code != ATT_ATTRIBUTE_NOT_FOUND_ERROR:
+                    # Unexpected end
+                    logger.warning(f'!!! unexpected error while reading characteristics: {HCI_Constant.error_name(response.error_code)}')
+                    # TODO raise appropriate exception
+                    return []
+                break
+
+            # Stop if for some reason the list was empty
+            if not response.attributes:
+                break
+
+            # Process all characteristics returned in this iteration
+            for attribute_handle, attribute_value in response.attributes:
+                if attribute_handle < starting_handle:
+                    # Something's not right
+                    logger.warning(f'bogus handle value: {attribute_handle}')
+                    return []
+
+                characteristics_values.append(attribute_value)
+
+            # Move on to the next characteristics
+            starting_handle = response.attributes[-1][0] + 1
+
+        return characteristics_values
+
+    async def write_value(self, attribute, value, with_response=False):
+        '''
+        See Vol 3, Part G - 4.9.1 Write Without Response & 4.9.3 Write Characteristic Value
+
+        `attribute` can be an Attribute object, or a handle value
+        '''
+
+        # Send a request or command to write
+        attribute_handle = attribute if type(attribute) is int else attribute.handle
+        if with_response:
+            response = await self.send_request(
+                ATT_Write_Request(
+                    attribute_handle = attribute_handle,
+                    attribute_value  = value
+                )
+            )
+            if response.op_code == ATT_ERROR_RESPONSE:
+                raise ProtocolError(
+                    response.error_code,
+                    'att',
+                    ATT_PDU.error_name(response.error_code), response
+                )
+        else:
+            await self.send_command(
+                ATT_Write_Command(
+                    attribute_handle = attribute_handle,
+                    attribute_value  = value
+                )
+            )
+
+    def on_gatt_pdu(self, att_pdu):
+        logger.debug(f'GATT Response to client: [0x{self.connection.handle:04X}] {att_pdu}')
+        if att_pdu.op_code in ATT_RESPONSES:
+            if self.pending_request is None:
+                # Not expected!
+                logger.warning('!!! unexpected response, there is no pending request')
+                return
+
+            # Sanity check: the response should match the pending request unless it is an error response
+            if att_pdu.op_code != ATT_ERROR_RESPONSE:
+                expected_response_name = self.pending_request.name.replace('_REQUEST', '_RESPONSE')
+                if att_pdu.name != expected_response_name:
+                    logger.warning(f'!!! mismatched response: expected {expected_response_name}')
+                    return
+
+            # Return the response to the coroutine that is waiting for it
+            self.pending_response.set_result(att_pdu)
+        else:
+            handler_name = f'on_{att_pdu.name.lower()}'
+            handler = getattr(self, handler_name, None)
+            if handler is not None:
+                handler(att_pdu)
+            else:
+                logger.warning(f'{color(f"--- Ignoring GATT Response from [0x{self.connection.handle:04X}]:", "red")} {att_pdu}')
+
+    def on_att_handle_value_notification(self, notification):
+        # Call all subscribers
+        subscribers = self.notification_subscribers.get(notification.attribute_handle, [])
+        if not subscribers:
+            logger.warning('!!! received notification with no subscriber')
+        for subscriber in subscribers:
+            if callable(subscriber):
+                subscriber(notification.attribute_value)
+            else:
+                subscriber.emit('update', notification.attribute_value)
+
+    def on_att_handle_value_indication(self, indication):
+        # Call all subscribers
+        subscribers = self.indication_subscribers.get(indication.attribute_handle, [])
+        if not subscribers:
+            logger.warning('!!! received indication with no subscriber')
+        for subscriber in subscribers:
+            if callable(subscriber):
+                subscriber(indication.attribute_value)
+            else:
+                subscriber.emit('update', indication.attribute_value)
+
+        # Confirm that we received the indication
+        self.send_confirmation(ATT_Handle_Value_Confirmation())

bumble/gatt_server.py

@@ -0,0 +1,686 @@
+# Copyright 2021-2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# GATT - Generic Attribute Profile
+# Server
+#
+# See Bluetooth spec @ Vol 3, Part G
+#
+# -----------------------------------------------------------------------------
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import asyncio
+import logging
+from collections import defaultdict
+from pyee import EventEmitter
+from colors import color
+
+from .core import *
+from .hci import *
+from .att import *
+from .gatt import *
+
+# -----------------------------------------------------------------------------
+# Logging
+# -----------------------------------------------------------------------------
+logger = logging.getLogger(__name__)
+
+
+# -----------------------------------------------------------------------------
+# Constants
+# -----------------------------------------------------------------------------
+GATT_SERVER_DEFAULT_MAX_MTU = 517
+
+
+# -----------------------------------------------------------------------------
+# GATT Server
+# -----------------------------------------------------------------------------
+class Server(EventEmitter):
+    def __init__(self, device):
+        super().__init__()
+        self.device                = device
+        self.attributes            = []  # Attributes, ordered by increasing handle values
+        self.attributes_by_handle  = {}  # Map for fast attribute access by handle
+        self.max_mtu               = GATT_SERVER_DEFAULT_MAX_MTU  # The max MTU we're willing to negotiate
+        self.subscribers           = {}  # Map of subscriber states by connection handle and attribute handle
+        self.indication_semaphores = defaultdict(lambda: asyncio.Semaphore(1))
+        self.pending_confirmations = defaultdict(lambda: None)
+
+    def send_gatt_pdu(self, connection_handle, pdu):
+        self.device.send_l2cap_pdu(connection_handle, ATT_CID, pdu)
+
+    def next_handle(self):
+        return 1 + len(self.attributes)
+
+    def get_attribute(self, handle):
+        attribute = self.attributes_by_handle.get(handle)
+        if attribute:
+            return attribute
+
+        # Not in the cached map, perform a linear lookup
+        for attribute in self.attributes:
+            if attribute.handle == handle:
+                # Store in cached map
+                self.attributes_by_handle[handle] = attribute
+                return attribute
+        return None
+
+    def add_attribute(self, attribute):
+        # Assign a handle to this attribute
+        attribute.handle = self.next_handle()
+        attribute.end_group_handle = attribute.handle  # TODO: keep track of descriptors in the group
+
+        # Add this attribute to the list
+        self.attributes.append(attribute)
+
+    def add_service(self, service):
+        # Add the service attribute to the DB
+        self.add_attribute(service)
+
+        # TODO: add included services
+
+        # Add all characteristics
+        for characteristic in service.characteristics:
+            # Add a Characteristic Declaration (Vol 3, Part G - 3.3.1 Characteristic Declaration)
+            declaration_bytes = struct.pack(
+                '<BH',
+                characteristic.properties,
+                self.next_handle() + 1,  # The value will be the next attribute after this declaration
+            ) + characteristic.uuid.to_pdu_bytes()
+            characteristic_declaration = Attribute(
+                GATT_CHARACTERISTIC_ATTRIBUTE_TYPE,
+                Attribute.READABLE,
+                declaration_bytes
+            )
+            self.add_attribute(characteristic_declaration)
+
+            # Add the characteristic value
+            self.add_attribute(characteristic)
+
+            # Add the descriptors
+            for descriptor in characteristic.descriptors:
+                self.add_attribute(descriptor)
+
+            # If the characteristic supports subscriptions, add a CCCD descriptor
+            # unless there is one already
+            if (
+                characteristic.properties & (Characteristic.NOTIFY | Characteristic.INDICATE) and
+                characteristic.get_descriptor(GATT_CLIENT_CHARACTERISTIC_CONFIGURATION_DESCRIPTOR) is None
+            ):
+                self.add_attribute(
+                    Descriptor(
+                        GATT_CLIENT_CHARACTERISTIC_CONFIGURATION_DESCRIPTOR,
+                        Attribute.READABLE | Attribute.WRITEABLE,
+                        CharacteristicValue(
+                            read=lambda connection, characteristic=characteristic: self.read_cccd(connection, characteristic),
+                            write=lambda connection, value, characteristic=characteristic: self.write_cccd(connection, characteristic, value)
+                        )
+                    )
+                )
+
+            # Update the service and characteristic group ends
+            characteristic_declaration.end_group_handle = self.attributes[-1].handle
+            characteristic.end_group_handle = self.attributes[-1].handle
+
+        # Update the service group end
+        service.end_group_handle = self.attributes[-1].handle
+
+    def add_services(self, services):
+        for service in services:
+            self.add_service(service)
+
+    def read_cccd(self, connection, characteristic):
+        if connection is None:
+            return bytes([0, 0])
+
+        subscribers = self.subscribers.get(connection.handle)
+        cccd = None
+        if subscribers:
+            cccd = subscribers.get(characteristic.handle)
+
+        return cccd or bytes([0, 0])
+
+    def write_cccd(self, connection, characteristic, value):
+        logger.debug(f'Subscription update for connection={connection.handle:04X}, handle={characteristic.handle:04X}: {value.hex()}')
+
+        # Sanity check
+        if len(value) != 2:
+            logger.warn('CCCD value not 2 bytes long')
+            return
+
+        cccds = self.subscribers.setdefault(connection.handle, {})
+        cccds[characteristic.handle] = value
+        logger.debug(f'CCCDs: {cccds}')
+        notify_enabled = (value[0] & 0x01 != 0)
+        indicate_enabled = (value[0] & 0x02 != 0)
+        characteristic.emit('subscription', connection, notify_enabled, indicate_enabled)
+        self.emit('characteristic_subscription', connection, characteristic, notify_enabled, indicate_enabled)
+
+    def send_response(self, connection, response):
+        logger.debug(f'GATT Response from server: [0x{connection.handle:04X}] {response}')
+        self.send_gatt_pdu(connection.handle, response.to_bytes())
+
+    async def notify_subscriber(self, connection, attribute, value=None, force=False):
+        # Check if there's a subscriber
+        if not force:
+            subscribers = self.subscribers.get(connection.handle)
+            if not subscribers:
+                logger.debug('not notifying, no subscribers')
+                return
+            cccd = subscribers.get(attribute.handle)
+            if not cccd:
+                logger.debug(f'not notifying, no subscribers for handle {attribute.handle:04X}')
+                return
+            if len(cccd) != 2 or (cccd[0] & 0x01 == 0):
+                logger.debug(f'not notifying, cccd={cccd.hex()}')
+                return
+
+        # Get or encode the value
+        value = attribute.read_value(connection) if value is None else attribute.encode_value(value)
+
+        # Truncate if needed
+        if len(value) > connection.att_mtu - 3:
+            value = value[:connection.att_mtu - 3]
+
+        # Notify
+        notification = ATT_Handle_Value_Notification(
+            attribute_handle = attribute.handle,
+            attribute_value  = value
+        )
+        logger.debug(f'GATT Notify from server: [0x{connection.handle:04X}] {notification}')
+        self.send_gatt_pdu(connection.handle, bytes(notification))
+
+    async def indicate_subscriber(self, connection, attribute, value=None, force=False):
+        # Check if there's a subscriber
+        if not force:
+            subscribers = self.subscribers.get(connection.handle)
+            if not subscribers:
+                logger.debug('not indicating, no subscribers')
+                return
+            cccd = subscribers.get(attribute.handle)
+            if not cccd:
+                logger.debug(f'not indicating, no subscribers for handle {attribute.handle:04X}')
+                return
+            if len(cccd) != 2 or (cccd[0] & 0x02 == 0):
+                logger.debug(f'not indicating, cccd={cccd.hex()}')
+                return
+
+        # Get or encode the value
+        value = attribute.read_value(connection) if value is None else attribute.encode_value(value)
+
+        # Truncate if needed
+        if len(value) > connection.att_mtu - 3:
+            value = value[:connection.att_mtu - 3]
+
+        # Indicate
+        indication = ATT_Handle_Value_Indication(
+            attribute_handle = attribute.handle,
+            attribute_value  = value
+        )
+        logger.debug(f'GATT Indicate from server: [0x{connection.handle:04X}] {indication}')
+
+        # Wait until we can send (only one pending indication at a time per connection)
+        async with self.indication_semaphores[connection.handle]:
+            assert(self.pending_confirmations[connection.handle] is None)
+
+            # Create a future value to hold the eventual response
+            self.pending_confirmations[connection.handle] = asyncio.get_running_loop().create_future()
+
+            try:
+                self.send_gatt_pdu(connection.handle, indication.to_bytes())
+                await asyncio.wait_for(self.pending_confirmations[connection.handle], GATT_REQUEST_TIMEOUT)
+            except asyncio.TimeoutError:
+                logger.warning(color('!!! GATT Indicate timeout', 'red'))
+                raise TimeoutError(f'GATT timeout for {indication.name}')
+            finally:
+                self.pending_confirmations[connection.handle] = None
+
+    async def notify_or_indicate_subscribers(self, indicate, attribute, value=None, force=False):
+        # Get all the connections for which there's at least one subscription
+        connections = [
+            connection for connection in [
+                self.device.lookup_connection(connection_handle)
+                for (connection_handle, subscribers) in self.subscribers.items()
+                if force or subscribers.get(attribute.handle)
+            ]
+            if connection is not None
+        ]
+
+        # Indicate or notify for each connection
+        if connections:
+            coroutine = self.indicate_subscriber if indicate else self.notify_subscriber
+            await asyncio.wait([
+                asyncio.create_task(coroutine(connection, attribute, value, force))
+                for connection in connections
+            ])
+
+    async def notify_subscribers(self, attribute, value=None, force=False):
+        return await self.notify_or_indicate_subscribers(False, attribute, value, force)
+
+    async def indicate_subscribers(self, attribute, value=None, force=False):
+        return await self.notify_or_indicate_subscribers(True, attribute, value, force)
+
+    def on_disconnection(self, connection):
+        if connection.handle in self.subscribers:
+            del self.subscribers[connection.handle]
+        if connection.handle in self.indication_semaphores:
+            del self.indication_semaphores[connection.handle]
+        if connection.handle in self.pending_confirmations:
+            del self.pending_confirmations[connection.handle]
+
+    def on_gatt_pdu(self, connection, att_pdu):
+        logger.debug(f'GATT Request to server: [0x{connection.handle:04X}] {att_pdu}')
+        handler_name = f'on_{att_pdu.name.lower()}'
+        handler = getattr(self, handler_name, None)
+        if handler is not None:
+            try:
+                handler(connection, att_pdu)
+            except ATT_Error as error:
+                logger.debug(f'normal exception returned by handler: {error}')
+                response = ATT_Error_Response(
+                    request_opcode_in_error   = att_pdu.op_code,
+                    attribute_handle_in_error = error.att_handle,
+                    error_code                = error.error_code
+                )
+                self.send_response(connection, response)
+            except Exception as error:
+                logger.warning(f'{color("!!! Exception in handler:", "red")} {error}')
+                response = ATT_Error_Response(
+                    request_opcode_in_error   = att_pdu.op_code,
+                    attribute_handle_in_error = 0x0000,
+                    error_code                = ATT_UNLIKELY_ERROR_ERROR
+                )
+                self.send_response(connection, response)
+                raise error
+        else:
+            # No specific handler registered
+            if att_pdu.op_code in ATT_REQUESTS:
+                # Invoke the generic handler
+                self.on_att_request(connection, att_pdu)
+            else:
+                # Just ignore
+                logger.warning(f'{color("--- Ignoring GATT Request from [0x{connection.handle:04X}]:", "red")}  {att_pdu}')
+
+    #######################################################
+    # ATT handlers
+    #######################################################
+    def on_att_request(self, connection, pdu):
+        '''
+        Handler for requests without a more specific handler
+        '''
+        logger.warning(f'{color(f"--- Unsupported ATT Request from [0x{connection.handle:04X}]:", "red")} {pdu}')
+        response = ATT_Error_Response(
+            request_opcode_in_error   = pdu.op_code,
+            attribute_handle_in_error = 0x0000,
+            error_code                = ATT_REQUEST_NOT_SUPPORTED_ERROR
+        )
+        self.send_response(connection, response)
+
+    def on_att_exchange_mtu_request(self, connection, request):
+        '''
+        See Bluetooth spec Vol 3, Part F - 3.4.2.1 Exchange MTU Request
+        '''
+        self.send_response(connection, ATT_Exchange_MTU_Response(server_rx_mtu = self.max_mtu))
+
+        # Compute the final MTU
+        if request.client_rx_mtu >= ATT_DEFAULT_MTU:
+            mtu = min(self.max_mtu, request.client_rx_mtu)
+
+            # Notify the device
+            self.device.on_connection_att_mtu_update(connection.handle, mtu)
+        else:
+            logger.warning('invalid client_rx_mtu received, MTU not changed')
+
+    def on_att_find_information_request(self, connection, request):
+        '''
+        See Bluetooth spec Vol 3, Part F - 3.4.3.1 Find Information Request
+        '''
+
+        # Check the request parameters
+        if request.starting_handle == 0 or request.starting_handle > request.ending_handle:
+            self.send_response(connection, ATT_Error_Response(
+                request_opcode_in_error   = request.op_code,
+                attribute_handle_in_error = request.starting_handle,
+                error_code                = ATT_INVALID_HANDLE_ERROR
+            ))
+            return
+
+        # Build list of returned attributes
+        pdu_space_available = connection.att_mtu - 2
+        attributes = []
+        uuid_size = 0
+        for attribute in (
+            attribute for attribute in self.attributes 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:
+                # Check if this attribute has the same type size as the previous one
+                if this_uuid_size != uuid_size:
+                    break
+
+            # Check if there's enough space for one more entry
+            uuid_size = this_uuid_size
+            if pdu_space_available < 2 + uuid_size:
+                break
+
+            # Add the attribute to the list
+            attributes.append(attribute)
+            pdu_space_available -= 2 + uuid_size
+
+        # Return the list of attributes
+        if attributes:
+            information_data_list = [
+                struct.pack('<H', attribute.handle) + attribute.type.to_pdu_bytes()
+                for attribute in attributes
+            ]
+            response = ATT_Find_Information_Response(
+                format           = 1 if len(attributes[0].type.to_pdu_bytes()) == 2 else 2,
+                information_data = b''.join(information_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
+            )
+
+        self.send_response(connection, response)
+
+    def on_att_find_by_type_value_request(self, connection, request):
+        '''
+        See Bluetooth spec Vol 3, Part F - 3.4.3.3 Find By Type Value Request
+        '''
+
+        # Build list of returned attributes
+        pdu_space_available = connection.att_mtu - 2
+        attributes = []
+        for attribute in (
+            attribute for attribute in self.attributes if
+            attribute.handle                 >= request.starting_handle and
+            attribute.handle                 <= request.ending_handle   and
+            attribute.type                   == request.attribute_type  and
+            attribute.read_value(connection) == request.attribute_value and
+            pdu_space_available >= 4
+        ):
+            # TODO: check permissions
+
+            # Add the attribute to the list
+            attributes.append(attribute)
+            pdu_space_available -= 4
+
+        # Return the list of attributes
+        if attributes:
+            handles_information_list = []
+            for attribute in attributes:
+                if attribute.type in {
+                    GATT_PRIMARY_SERVICE_ATTRIBUTE_TYPE,
+                    GATT_SECONDARY_SERVICE_ATTRIBUTE_TYPE,
+                    GATT_CHARACTERISTIC_ATTRIBUTE_TYPE
+                }:
+                    # Part of a group
+                    group_end_handle = attribute.end_group_handle
+                else:
+                    # Not part of a group
+                    group_end_handle = attribute.handle
+                handles_information_list.append(struct.pack('<HH', attribute.handle, group_end_handle))
+            response = ATT_Find_By_Type_Value_Response(
+                handles_information_list = b''.join(handles_information_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
+            )
+
+        self.send_response(connection, response)
+
+    def on_att_read_by_type_request(self, connection, request):
+        '''
+        See Bluetooth spec Vol 3, Part F - 3.4.4.1 Read By Type Request
+        '''
+
+        pdu_space_available = connection.att_mtu - 2
+        attributes = []
+        for attribute in (
+            attribute for attribute in self.attributes if
+            attribute.type   == request.attribute_type  and
+            attribute.handle >= request.starting_handle and
+            attribute.handle <= request.ending_handle   and
+            pdu_space_available
+        ):
+            # TODO: check permissions
+
+            # 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
+                attribute_value = attribute_value[:max_attribute_size]
+            if attributes and len(attributes[0][1]) != len(attribute_value):
+                # Not the same size as previous attribute, stop here
+                break
+
+            # Check if there is enough space
+            entry_size = 2 + len(attribute_value)
+            if pdu_space_available < entry_size:
+                break
+
+            # Add the attribute to the list
+            attributes.append((attribute.handle, attribute_value))
+            pdu_space_available -= entry_size
+
+        if attributes:
+            attribute_data_list = [struct.pack('<H', handle) + value for handle, value in attributes]
+            response = ATT_Read_By_Type_Response(
+                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
+            )
+
+        self.send_response(connection, response)
+
+    def on_att_read_request(self, connection, request):
+        '''
+        See Bluetooth spec Vol 3, Part F - 3.4.4.3 Read Request
+        '''
+
+        if attribute := self.get_attribute(request.attribute_handle):
+            # 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]
+            )
+        else:
+            response = ATT_Error_Response(
+                request_opcode_in_error   = request.op_code,
+                attribute_handle_in_error = request.attribute_handle,
+                error_code                = ATT_INVALID_HANDLE_ERROR
+            )
+        self.send_response(connection, response)
+
+    def on_att_read_blob_request(self, connection, request):
+        '''
+        See Bluetooth spec Vol 3, Part F - 3.4.4.5 Read Blob Request
+        '''
+
+        if attribute := self.get_attribute(request.attribute_handle):
+            # TODO: check permissions
+            value = attribute.read_value(connection)
+            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,
+                attribute_handle_in_error = request.attribute_handle,
+                error_code                = ATT_INVALID_HANDLE_ERROR
+            )
+        self.send_response(connection, response)
+
+    def on_att_read_by_group_type_request(self, connection, request):
+        '''
+        See Bluetooth spec Vol 3, Part F - 3.4.4.9 Read by Group Type Request
+        '''
+        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,
+                attribute_handle_in_error = request.starting_handle,
+                error_code                = ATT_UNSUPPORTED_GROUP_TYPE_ERROR
+            )
+            self.send_response(connection, response)
+            return
+
+        pdu_space_available = connection.att_mtu - 2
+        attributes = []
+        for attribute in (
+            attribute for attribute in self.attributes if
+            attribute.type   == request.attribute_group_type and
+            attribute.handle >= request.starting_handle      and
+            attribute.handle <= request.ending_handle        and
+            pdu_space_available
+        ):
+            # Check the attribute value size
+            attribute_value = attribute.read_value(connection)
+            max_attribute_size = min(connection.att_mtu - 6, 251)
+            if len(attribute_value) > max_attribute_size:
+                # We need to truncate
+                attribute_value = attribute_value[:max_attribute_size]
+            if attributes and len(attributes[0][2]) != len(attribute_value):
+                # Not the same size as previous attributes, stop here
+                break
+
+            # Check if there is enough space
+            entry_size = 4 + len(attribute_value)
+            if pdu_space_available < entry_size:
+                break
+
+            # Add the attribute to the list
+            attributes.append((attribute.handle, attribute.end_group_handle, attribute_value))
+            pdu_space_available -= entry_size
+
+        if attributes:
+            attribute_data_list = [
+                struct.pack('<HH', handle, end_group_handle) + value
+                for handle, end_group_handle, value in attributes
+            ]
+            response = ATT_Read_By_Group_Type_Response(
+                length              = len(attribute_data_list[0]),
+                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
+            )
+
+        self.send_response(connection, response)
+
+    def on_att_write_request(self, connection, request):
+        '''
+        See Bluetooth spec Vol 3, Part F - 3.4.5.1 Write Request
+        '''
+
+        # Check  that the attribute exists
+        attribute = self.get_attribute(request.attribute_handle)
+        if attribute is None:
+            self.send_response(connection, ATT_Error_Response(
+                request_opcode_in_error   = request.op_code,
+                attribute_handle_in_error = request.attribute_handle,
+                error_code                = ATT_INVALID_HANDLE_ERROR
+            ))
+            return
+
+        # TODO: check permissions
+
+        # Check the request parameters
+        if len(request.attribute_value) > GATT_MAX_ATTRIBUTE_VALUE_SIZE:
+            self.send_response(connection, ATT_Error_Response(
+                request_opcode_in_error   = request.op_code,
+                attribute_handle_in_error = request.attribute_handle,
+                error_code                = ATT_INVALID_ATTRIBUTE_LENGTH_ERROR
+            ))
+            return
+
+        # Accept the value
+        attribute.write_value(connection, request.attribute_value)
+
+        # Done
+        self.send_response(connection, ATT_Write_Response())
+
+    def on_att_write_command(self, connection, request):
+        '''
+        See Bluetooth spec Vol 3, Part F - 3.4.5.3 Write Command
+        '''
+
+        # Check that the attribute exists
+        attribute = self.get_attribute(request.attribute_handle)
+        if attribute is None:
+            return
+
+        # TODO: check permissions
+
+        # Check the request parameters
+        if len(request.attribute_value) > GATT_MAX_ATTRIBUTE_VALUE_SIZE:
+            return
+
+        # Accept the value
+        try:
+            attribute.write_value(connection, request.attribute_value)
+        except Exception as error:
+            logger.warning(f'!!! ignoring exception: {error}')
+
+    def on_att_handle_value_confirmation(self, connection, confirmation):
+        '''
+        See Bluetooth spec Vol 3, Part F - 3.4.7.3 Handle Value Confirmation
+        '''
+        if self.pending_confirmations[connection.handle] is None:
+            # Not expected!
+            logger.warning('!!! unexpected confirmation, there is no pending indication')
+            return
+
+        self.pending_confirmations[connection.handle].set_result(None)

bumble/helpers.py

@@ -0,0 +1,184 @@
+# Copyright 2021-2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# -----------------------------------------------------------------------------
+# Imports
+# -----------------------------------------------------------------------------
+import logging
+from colors import color
+
+from bumble.smp import SMP_CID, SMP_Command
+
+from .core import name_or_number
+from .gatt import ATT_PDU, ATT_CID
+from .l2cap import (
+    L2CAP_PDU,
+    L2CAP_CONNECTION_REQUEST,
+    L2CAP_CONNECTION_RESPONSE,
+    L2CAP_SIGNALING_CID,
+    L2CAP_LE_SIGNALING_CID,
+    L2CAP_Control_Frame,
+    L2CAP_Connection_Response
+)
+from .hci import (
+    HCI_EVENT_PACKET,
+    HCI_ACL_DATA_PACKET,
+    HCI_DISCONNECTION_COMPLETE_EVENT,
+    HCI_AclDataPacketAssembler
+)
+from .rfcomm import RFCOMM_Frame, RFCOMM_PSM
+from .sdp import SDP_PDU, SDP_PSM
+from .avdtp import (
+    MessageAssembler as AVDTP_MessageAssembler,
+    AVDTP_PSM
+)
+
+# -----------------------------------------------------------------------------
+# Logging
+# -----------------------------------------------------------------------------
+logger = logging.getLogger(__name__)
+
+
+# -----------------------------------------------------------------------------
+PSM_NAMES = {
+    RFCOMM_PSM: 'RFCOMM',
+    SDP_PSM:    'SDP',
+    AVDTP_PSM:  'AVDTP'
+    # TODO: add more PSM values
+}
+
+
+# -----------------------------------------------------------------------------
+class PacketTracer:
+    class AclStream:
+        def __init__(self, analyzer):
+            self.analyzer         = analyzer
+            self.packet_assembler = HCI_AclDataPacketAssembler(self.on_acl_pdu)
+            self.avdtp_assemblers = {}    # AVDTP assemblers, by source_cid
+            self.psms             = {}    # PSM, by source_cid
+            self.peer             = None  # ACL stream in the other direction
+
+        def on_acl_pdu(self, pdu):
+            l2cap_pdu = L2CAP_PDU.from_bytes(pdu)
+
+            if l2cap_pdu.cid == ATT_CID:
+                att_pdu = ATT_PDU.from_bytes(l2cap_pdu.payload)
+                self.analyzer.emit(att_pdu)
+            elif l2cap_pdu.cid == SMP_CID:
+                smp_command = SMP_Command.from_bytes(l2cap_pdu.payload)
+                self.analyzer.emit(smp_command)
+            elif l2cap_pdu.cid == L2CAP_SIGNALING_CID or l2cap_pdu.cid == L2CAP_LE_SIGNALING_CID:
+                control_frame = L2CAP_Control_Frame.from_bytes(l2cap_pdu.payload)
+                self.analyzer.emit(control_frame)
+
+                # Check if this signals a new channel
+                if control_frame.code == L2CAP_CONNECTION_REQUEST:
+                    self.psms[control_frame.source_cid] = control_frame.psm
+                elif control_frame.code == L2CAP_CONNECTION_RESPONSE:
+                    if control_frame.result == L2CAP_Connection_Response.CONNECTION_SUCCESSFUL:
+                        if self.peer:
+                            if psm := self.peer.psms.get(control_frame.source_cid):
+                                # Found a pending connection
+                                self.psms[control_frame.destination_cid] = psm
+
+                                # For AVDTP connections, create a packet assembler for each direction
+                                if psm == AVDTP_PSM:
+                                    self.avdtp_assemblers[control_frame.source_cid] = AVDTP_MessageAssembler(self.on_avdtp_message)
+                                    self.peer.avdtp_assemblers[control_frame.destination_cid] = AVDTP_MessageAssembler(self.peer.on_avdtp_message)
+
+            else:
+                # Try to find the PSM associated with this PDU
+                if self.peer and (psm := self.peer.psms.get(l2cap_pdu.cid)):
+                    if psm == SDP_PSM:
+                        sdp_pdu = SDP_PDU.from_bytes(l2cap_pdu.payload)
+                        self.analyzer.emit(sdp_pdu)
+                    elif psm == RFCOMM_PSM:
+                        rfcomm_frame = RFCOMM_Frame.from_bytes(l2cap_pdu.payload)
+                        self.analyzer.emit(rfcomm_frame)
+                    elif psm == AVDTP_PSM:
+                        self.analyzer.emit(f'{color("L2CAP", "green")} [CID={l2cap_pdu.cid}, PSM=AVDTP]: {l2cap_pdu.payload.hex()}')
+                        assembler = self.avdtp_assemblers.get(l2cap_pdu.cid)
+                        if assembler:
+                            assembler.on_pdu(l2cap_pdu.payload)
+                    else:
+                        psm_string = name_or_number(PSM_NAMES, psm)
+                        self.analyzer.emit(f'{color("L2CAP", "green")} [CID={l2cap_pdu.cid}, PSM={psm_string}]: {l2cap_pdu.payload.hex()}')
+                else:
+                    self.analyzer.emit(l2cap_pdu)
+
+        def on_avdtp_message(self, transaction_label, message):
+            self.analyzer.emit(f'{color("AVDTP", "green")} [{transaction_label}] {message}')
+
+        def feed_packet(self, packet):
+            self.packet_assembler.feed_packet(packet)
+
+    class Analyzer:
+        def __init__(self, label, emit_message):
+            self.label        = label
+            self.emit_message = emit_message
+            self.acl_streams  = {}    # ACL streams, by connection handle
+            self.peer         = None  # Analyzer in the other direction
+
+        def start_acl_stream(self, connection_handle):
+            logger.info(f'[{self.label}] +++ Creating ACL stream for connection 0x{connection_handle:04X}')
+            stream = PacketTracer.AclStream(self)
+            self.acl_streams[connection_handle] = stream
+
+            # Associate with a peer stream if we can
+            if peer_stream := self.peer.acl_streams.get(connection_handle):
+                stream.peer = peer_stream
+                peer_stream.peer = stream
+
+            return stream
+
+        def end_acl_stream(self, connection_handle):
+            if connection_handle in self.acl_streams:
+                logger.info(f'[{self.label}] --- Removing ACL stream for connection 0x{connection_handle:04X}')
+                del self.acl_streams[connection_handle]
+
+                # Let the other forwarder know so it can cleanup its stream as well
+                self.peer.end_acl_stream(connection_handle)
+
+        def on_packet(self, packet):
+            self.emit(packet)
+
+            if packet.hci_packet_type == HCI_ACL_DATA_PACKET:
+                # Look for an existing stream for this handle, create one if it is the
+                # first ACL packet for that connection handle
+                if (stream := self.acl_streams.get(packet.connection_handle)) is None:
+                    stream = self.start_acl_stream(packet.connection_handle)
+                stream.feed_packet(packet)
+            elif packet.hci_packet_type == HCI_EVENT_PACKET:
+                if packet.event_code == HCI_DISCONNECTION_COMPLETE_EVENT:
+                    self.end_acl_stream(packet.connection_handle)
+
+        def emit(self, message):
+            self.emit_message(f'[{self.label}] {message}')
+
+    def trace(self, packet, direction=0):
+        if direction == 0:
+            self.host_to_controller_analyzer.on_packet(packet)
+        else:
+            self.controller_to_host_analyzer.on_packet(packet)
+
+    def __init__(
+        self,
+        host_to_controller_label=color('HOST->CONTROLLER', 'blue'),
+        controller_to_host_label=color('CONTROLLER->HOST', 'cyan'),
+        emit_message=logger.info
+    ):
+        self.host_to_controller_analyzer = PacketTracer.Analyzer(host_to_controller_label, emit_message)
+        self.controller_to_host_analyzer = PacketTracer.Analyzer(controller_to_host_label, emit_message)
+        self.host_to_controller_analyzer.peer = self.controller_to_host_analyzer
+        self.controller_to_host_analyzer.peer = self.host_to_controller_analyzer