Tweaks based on feedback from Dan and Thea

This renames Smart* to BLE* and removes the smart recognition. It
is replaced by knowing the type of what we're interested at use
time only. Only printing Service lists is now dumber.

Interal variables to _bleio classes are now public as bleio_*
instead so that other classes in the library can access them and
its clearer what they are.

Author: tannewt

adafruit_ble/__init__.py

@@ -46,75 +46,61 @@
 import _bleio
 import board
 
-from .services.core import Service
+from .services import Service
 from .advertising import Advertisement
 
 __version__ = "0.0.0-auto.0"
 __repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_BLE.git"
 
-# These are internal data structures used throughout the library to recognize certain Services and
-# Advertisements.
-# pylint: disable=invalid-name
-all_services_by_name = {}
-all_services_by_uuid = {}
-known_advertisements = set()
-# pylint: enable=invalid-name
-
-def recognize_services(*service_classes):
-    """Instruct the adafruit_ble library to recognize the given Services.
-
-       This will cause the Service related advertisements to show the corresponding class.
-       `SmartConnection` will automatically have attributes for any recognized service available
-       from the peer."""
-    for service_class in service_classes:
-        if not issubclass(service_class, Service):
-            raise ValueError("Can only detect subclasses of Service")
-        all_services_by_name[service_class.default_field_name] = service_class
-        all_services_by_uuid[service_class.uuid] = service_class
-
-def recognize_advertisement(*advertisements):
-    """Instruct the adafruit_ble library to recognize the given `Advertisement` types.
-
-       When an advertisement is recognized by the `SmartAdapter`, it will be returned from the
-       start_scan iterator instead of a generic `Advertisement`."""
-    known_advertisements.add(*advertisements)
-
-class SmartConnection:
+class BLEConnection:
     """This represents a connection to a peer BLE device.
 
-       Its smarts come from its ability to recognize Services available on the peer and make them
-       available as attributes on the Connection. Use `recognize_services` to register all services
-       of interest. All subsequent Connections will then recognize the service.
-
-       ``dir(connection)`` will show all attributes including recognized Services.
-       """
+       It acts as a map from a Service type to a Service instance for the connection.
+    """
     def __init__(self, connection):
         self._connection = connection
-
-    def __dir__(self):
-        discovered = []
-        results = self._connection.discover_remote_services()
-        for service in results:
-            uuid = service.uuid
-            if uuid in all_services_by_uuid:
-                service = all_services_by_uuid[uuid]
-                discovered.append(service.default_field_name)
-        super_dir = dir(super())
-        super_dir.extend(discovered)
-        return super_dir
-
-    def __getattr__(self, name):
-        if name in self.__dict__:
-            return self.__dict__[name]
-        if name in all_services_by_name:
-            service = all_services_by_name[name]
-            uuid = service.uuid._uuid
-            results = self._connection.discover_remote_services((uuid,))
+        self._discovered_services = {}
+        """These are the bare remote services from _bleio."""
+
+        self._constructed_services = {}
+        """These are the Service instances from the library that wrap the remote services."""
+
+    def _discover_remote(self, uuid):
+        remote_service = None
+        if uuid in self._discovered_services:
+            remote_service = self._discovered_services[uuid]
+        else:
+            results = self._connection.discover_remote_services((uuid.bleio_uuid,))
             if results:
-                remote_service = service(service=results[0])
-                setattr(self, name, remote_service)
-                return remote_service
-        raise AttributeError()
+                remote_service = results[0]
+                self._discovered_services[uuid] = remote_service
+        return remote_service
+
+    def __contains__(self, key):
+        uuid = key
+        if hasattr(key, "uuid"):
+            uuid = key.uuid
+        return self._discover_remote(uuid) is not None
+
+    def __getitem__(self, key):
+        uuid = key
+        maybe_service = False
+        if hasattr(key, "uuid"):
+            uuid = key.uuid
+            maybe_service = True
+
+        remote_service = self._discover_remote(uuid)
+
+        if uuid in self._constructed_services:
+            return self._constructed_services[uuid]
+        if remote_service:
+            constructed_service = None
+            if maybe_service:
+                constructed_service = key(service=remote_service)
+                self._constructed_services[uuid] = constructed_service
+            return constructed_service
+
+        raise KeyError("{!r} object has no service {}".format(self, key))
 
     @property
     def connected(self):
@@ -125,10 +111,11 @@ def disconnect(self):
         """Disconnect from peer."""
         self._connection.disconnect()
 
-class SmartAdapter:
-    """This BLE Adapter class enhances the normal `_bleio.Adapter`.
+class BLERadio:
+    """The BLERadio class enhances the normal `_bleio.Adapter`.
+
+       It uses the library's `Advertisement` classes and the `BLEConnection` class."""
 
-       It uses the library's `Advertisement` classes and the `SmartConnection` class."""
     def __init__(self, adapter=None):
         if not adapter:
             adapter = _bleio.adapter
@@ -143,7 +130,6 @@ def start_advertising(self, advertisement, scan_response=None, **kwargs):
         scan_response_data = None
         if scan_response:
             scan_response_data = bytes(scan_response)
-        print(advertisement.connectable)
         self._adapter.start_advertising(bytes(advertisement),
                                         scan_response=scan_response_data,
                                         connectable=advertisement.connectable,
@@ -153,21 +139,20 @@ def stop_advertising(self):
         """Stops advertising."""
         self._adapter.stop_advertising()
 
-    def start_scan(self, advertisement_types=None, **kwargs):
-        """Starts scanning. Returns an iterator of Advertisements that are either recognized or
-           in advertisment_types (which will be subsequently recognized.) The iterator will block
-           until an advertisement is heard or the scan times out.
+    def start_scan(self, *advertisement_types, **kwargs):
+        """Starts scanning. Returns an iterator of advertisement objects of the types given in
+           advertisement_types. The iterator will block until an advertisement is heard or the scan
+           times out.
 
-           If a list ``advertisement_types`` is given, only Advertisements of that type are produced
-           by the returned iterator."""
+           If any ``advertisement_types`` are given, only Advertisements of those types are produced
+           by the returned iterator. If none are given then `Advertisement` objects will be
+           returned."""
         prefixes = b""
         if advertisement_types:
-            recognize_advertisement(*advertisement_types)
-            if len(advertisement_types) == 1:
-                prefixes = advertisement_types[0].prefix
+            prefixes = b"".join(adv.prefix for adv in advertisement_types)
         for entry in self._adapter.start_scan(prefixes=prefixes, **kwargs):
             adv_type = Advertisement
-            for possible_type in known_advertisements:
+            for possible_type in advertisement_types:
                 if possible_type.matches(entry) and issubclass(possible_type, adv_type):
                     adv_type = possible_type
             advertisement = adv_type.from_entry(entry)
@@ -182,9 +167,9 @@ def stop_scan(self):
         self._adapter.stop_scan()
 
     def connect(self, advertisement, *, timeout=4):
-        """Initiates a `SmartConnection` to the peer that advertised the given advertisement."""
+        """Initiates a `BLEConnection` to the peer that advertised the given advertisement."""
         connection = self._adapter.connect(advertisement.address, timeout=timeout)
-        self._connection_cache[connection] = SmartConnection(connection)
+        self._connection_cache[connection] = BLEConnection(connection)
         return self._connection_cache[connection]
 
     @property
@@ -194,12 +179,12 @@ def connected(self):
 
     @property
     def connections(self):
-        """A tuple of active `SmartConnection` objects."""
+        """A tuple of active `BLEConnection` objects."""
         connections = self._adapter.connections
-        smart_connections = [None] * len(connections)
+        wrapped_connections = [None] * len(connections)
         for i, connection in enumerate(self._adapter.connections):
             if connection not in self._connection_cache:
-                self._connection_cache[connection] = SmartConnection(connection)
-            smart_connections[i] = self._connection_cache[connection]
+                self._connection_cache[connection] = BLEConnection(connection)
+            wrapped_connections[i] = self._connection_cache[connection]
 
-        return tuple(smart_connections)
+        return tuple(wrapped_connections)

adafruit_ble/advertising/__init__.py

@@ -24,7 +24,6 @@
 """
 
 import struct
-import gc
 
 def to_hex(b):
     """Pretty prints a byte sequence as hex values."""
@@ -41,9 +40,6 @@ def decode_data(data, *, key_encoding="B"):
        encoding."""
     i = 0
     data_dict = {}
-    if len(data) > 255:
-        print("original", data)
-        raise RuntimeError()
     key_size = struct.calcsize(key_encoding)
     while i < len(data):
         item_length = data[i]
@@ -128,6 +124,9 @@ def __init__(self, advertisement, advertising_data_type):
         else:
             self.flags = 0
 
+    def __len__(self):
+        return 1
+
     def __bytes__(self):
         encoded = bytearray(1)
         encoded[0] = self.flags
@@ -185,7 +184,6 @@ def __get__(self, obj, cls):
         # Return None if our object is immutable and the data is not present.
         if not obj.mutable and self._adt not in obj.data_dict:
             return None
-        print(self._adt, self._cls, repr(obj))
         bound_class = self._cls(obj, advertising_data_type=self._adt, **self._kwargs)
         setattr(obj, self._attribute_name, bound_class)
         obj.data_dict[self._adt] = bound_class
@@ -196,7 +194,7 @@ def __get__(self, obj, cls):
 
 class Advertisement:
     """Core Advertisement type"""
-    prefix = b"\x00"
+    prefix = b"\x00" # This is an empty prefix and will match everything.
     flags = LazyField(AdvertisingFlags, "flags", advertising_data_type=0x01)
     short_name = String(advertising_data_type=0x08)
     """Short local device name (shortened to fit)."""
@@ -240,7 +238,7 @@ def __init__(self):
     @classmethod
     def from_entry(cls, entry):
         """Create an Advertisement based on the given ScanEntry. This is done automatically by
-           `SmartAdapter` for all scan results."""
+           `BLERadio` for all scan results."""
         self = cls()
         self.data_dict = decode_data(entry.advertisement_bytes)
         self.address = entry.address
@@ -258,10 +256,10 @@ def rssi(self):
 
     @classmethod
     def matches(cls, entry):
-        """Returns true if the given `_bleio.ScanEntry` matches all portions of the Advertisement type's
-           prefix."""
+        """Returns true if the given `_bleio.ScanEntry` matches all portions of the Advertisement
+           type's prefix."""
         if not hasattr(cls, "prefix"):
-            return False
+            return True
 
         return entry.matches(cls.prefix)
 

adafruit_ble/advertising/adafruit.py

@@ -31,21 +31,35 @@
 
 """
 
+import struct
+from micropython import const
+
 from . import Advertisement, LazyField
 from .standard import ManufacturerData, ManufacturerDataField
 
 __version__ = "0.0.0-auto.0"
 __repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_BLE.git"
 
+_MANUFACTURING_DATA_ADT = const(0xff)
+_ADAFRUIT_COMPANY_ID = const(0x0822)
+_COLOR_DATA_ID = const(0x0000)
+
 class AdafruitColor(Advertisement):
     """Broadcast a single RGB color."""
-    prefix = b"\x06\xff\xff\xff\x06\x00\x00"
+    # This prefix matches all
+    prefix = struct.pack("<BBHBH",
+                         0x6,
+                         _MANUFACTURING_DATA_ADT,
+                         _ADAFRUIT_COMPANY_ID,
+                         struct.calcsize("<HI"),
+                         _COLOR_DATA_ID)
     manufacturer_data = LazyField(ManufacturerData,
                                   "manufacturer_data",
-                                  advertising_data_type=0xff,
-                                  company_id=0x0822,
+                                  advertising_data_type=_MANUFACTURING_DATA_ADT,
+                                  company_id=_ADAFRUIT_COMPANY_ID,
                                   key_encoding="<H")
-    color = ManufacturerDataField(0x0000, "<I")
+    color = ManufacturerDataField(_COLOR_DATA_ID, "<I")
+    """Color to broadcast as RGB integer."""
 
 # TODO: Add radio packets.
 #