wip

Author: dhalbert

adafruit_ble/__init__.py

@@ -231,7 +231,7 @@ def start_scan(
         """
         if not advertisement_types:
             advertisement_types = (Advertisement,)
-        prefixes = b"".join(adv.prefix for adv in advertisement_types)
+        prefixes = b"".join(adv.get_prefix_bytes() for adv in advertisement_types)
         for entry in self._adapter.start_scan(
             prefixes=prefixes,
             buffer_size=buffer_size,

adafruit_ble/advertising/__init__.py

@@ -214,9 +214,17 @@ def advertising_data_type(self):
 
 
 class Advertisement:
-    """Core Advertisement type"""
+    """Core Advertisement type.
+
+    The class attribute ``match_prefixes``, if not ``None``, is a tuple of
+    bytestring prefixes to match against the multiple data structures in the advertisement.
+    """
+
+    match_prefixes = ()
+    """For Advertisement, `matches` will always return True. Subclasses may override this value."""
+    # cached bytes of merged prefixes.
+    _prefix_bytes = None
 
-    prefix = b"\x00"  # This is an empty prefix and will match everything.
     flags = LazyObjectField(AdvertisingFlags, "flags", advertising_data_type=0x01)
     short_name = String(advertising_data_type=0x08)
     """Short local device name (shortened to fit)."""
@@ -257,7 +265,11 @@ def from_entry(cls, entry):
         """Create an Advertisement based on the given ScanEntry. This is done automatically by
            `BLERadio` for all scan results."""
         self = cls()
-        self.data_dict = decode_data(entry.advertisement_bytes)
+        # If data_dict is available, use it directly. Otherwise decode the bytestring.
+        if hasattr(entry, "data_dict"):
+            self.data_dict = entry.data_dict
+        else:
+            self.data_dict = decode_data(entry.advertisement_bytes)
         self.address = entry.address
         self._rssi = entry.rssi  # pylint: disable=protected-access
         self.connectable = entry.connectable
@@ -272,13 +284,32 @@ def rssi(self):
         return self._rssi
 
     @classmethod
-    def matches(cls, entry):
-        """Returns true if the given `_bleio.ScanEntry` matches all portions of the Advertisement
-           type's prefix."""
-        if not hasattr(cls, "prefix"):
-            return True
+    def get_prefix_bytes(cls):
+        """Return a merged version of match_prefixes as a single bytes object,
+        with length headers.
+        """
+        # Do merge once and memoize it.
+        if cls._prefix_bytes is None:
+            cls._prefix_bytes = (
+                b""
+                if cls.match_prefixes is None
+                else b"".join(
+                    len(prefix).to_bytes(1, "little") + prefix
+                    for prefix in cls.match_prefixes
+                )
+            )
+
+        return cls._prefix_bytes
 
-        return entry.matches(cls.prefix)
+    @classmethod
+    def matches(cls, entry, all_=True):
+        """Returns ``True`` if the given `_bleio.ScanEntry` advertisement fields
+        match any or all of the given prefixes in the `match_prefixes` tuple attribute.
+        If `all_` is ``True``, all the prefixes must match. If ``all_`` is ``False``,
+        returns ``True`` if at least one of the prefixes match.
+        """
+        # Returns True if cls.get_prefix_bytes() is empty.
+        return entry.matches(cls.get_prefix_bytes(), all=all_)
 
     def __bytes__(self):
         """The raw packet bytes."""

adafruit_ble/advertising/adafruit.py

@@ -48,14 +48,15 @@
 class AdafruitColor(Advertisement):
     """Broadcast a single RGB color."""
 
-    # This prefix matches all
-    prefix = struct.pack(
-        "<BBHBH",
-        0x6,
-        _MANUFACTURING_DATA_ADT,
-        _ADAFRUIT_COMPANY_ID,
-        struct.calcsize("<HI"),
-        _COLOR_DATA_ID,
+    # This single prefix matches all color advertisements.
+    match_prefixes = (
+        struct.pack(
+            "<BHBH",
+            _MANUFACTURING_DATA_ADT,
+            _ADAFRUIT_COMPANY_ID,
+            struct.calcsize("<HI"),
+            _COLOR_DATA_ID,
+        ),
     )
     manufacturer_data = LazyObjectField(
         ManufacturerData,

adafruit_ble/advertising/apple.py

@@ -1,5 +1,6 @@
 # class iBeacon(Advertisement):
-#     prefix = b"\xff\x00\x4c\x02" # Apple manufacturer data with subtype 2
+#     # Apple manufacturer data with subtype 2
+#     match_prefixes = (b"\xff\x00\x4c\x02",)
 #
 #     proximity_uuid =
 #     major =

adafruit_ble/advertising/standard.py

@@ -135,7 +135,7 @@ def __str__(self):
             data.append(str(service_uuid))
         for service_uuid in self._vendor_services:
             data.append(str(service_uuid))
-        return " ".join(data)
+        return "<BoundServiceList: {}>".format(", ".join(data))
 
 
 class ServiceList(AdvertisingDataField):
@@ -156,7 +156,7 @@ def _present(self, obj):
 
     def __get__(self, obj, cls):
         if not self._present(obj) and not obj.mutable:
-            return None
+            return ()
         if not hasattr(obj, "adv_service_lists"):
             obj.adv_service_lists = {}
         first_adt = self.standard_services[0]
@@ -168,8 +168,8 @@ def __get__(self, obj, cls):
 class ProvideServicesAdvertisement(Advertisement):
     """Advertise what services that the device makes available upon connection."""
 
-    # This is four prefixes, one for each ADT that can carry service UUIDs.
-    prefix = b"\x01\x02\x01\x03\x01\x06\x01\x07"
+    # Prefixes that match each ADT that can carry service UUIDs.
+    match_prefixes = (b"\x02", b"\x03", b"\x06", b"\x07")
     services = ServiceList(standard_services=[0x02, 0x03], vendor_services=[0x06, 0x07])
     """List of services the device can provide."""
 
@@ -182,15 +182,15 @@ def __init__(self, *services):
         self.flags.le_only = True
 
     @classmethod
-    def matches(cls, entry):
-        return entry.matches(cls.prefix, all=False)
+    def matches(cls, entry, all_=False):
+        return super().matches(entry, all_=all_)
 
 
 class SolicitServicesAdvertisement(Advertisement):
     """Advertise what services the device would like to use over a connection."""
 
-    # This is two prefixes, one for each ADT that can carry solicited service UUIDs.
-    prefix = b"\x01\x14\x01\x15"
+    # Prefixes that match each ADT that can carry solicited service UUIDs.
+    match_prefixes = (b"\x14", b"\x15")
 
     solicited_services = ServiceList(standard_services=[0x14], vendor_services=[0x15])
     """List of services the device would like to use."""

adafruit_ble/services/standard/device_info.py

@@ -29,7 +29,6 @@
 import binascii
 import os
 import sys
-import microcontroller
 
 from .. import Service
 from ...uuid import StandardUUID
@@ -65,11 +64,18 @@ def __init__(
             if model_number is None:
                 model_number = sys.platform
             if serial_number is None:
-                serial_number = binascii.hexlify(
-                    microcontroller.cpu.uid  # pylint: disable=no-member
-                ).decode("utf-8")
+                try:
+                    import microcontroller
+                    serial_number = binascii.hexlify(
+                        microcontroller.cpu.uid  # pylint: disable=no-member
+                    ).decode("utf-8")
+                except ImportError:
+                    pass
             if firmware_revision is None:
-                firmware_revision = os.uname().version
+                try:
+                    firmware_revision = os.uname().version
+                except AttributeError:
+                    pass
         super().__init__(
             manufacturer=manufacturer,
             software_revision=software_revision,