Do server advertisement construction in Python; fix numerous bugs

Author: dhalbert

adafruit_ble/advertising.py

@@ -31,7 +31,7 @@
 
 import struct
 
-class AdvertisingData:
+class Advertisement:
     """Build up a BLE advertising data packet."""
     # BR/EDR flags not included here, since we don't support BR/EDR.
     FLAG_LIMITED_DISCOVERY = 0x01
@@ -53,7 +53,7 @@ class AdvertisingData:
     """Complete list of 128 bit service UUIDs."""
     SHORT_LOCAL_NAME = 0x08
     """Short local device name (shortened to fit)."""
-    COMPLETE_LOCALNAME = 0x09
+    COMPLETE_LOCAL_NAME = 0x09
     """Complete local device name."""
     TX_POWER = 0x0A
     """Transmit power level"""
@@ -87,9 +87,13 @@ def __init__(self, flags=(FLAG_GENERAL_DISCOVERY | FLAG_LE_ONLY), max_length=MAX
         self._max_length = max_length
         self._check_length()
 
+    @property
+    def bytes_remaining(self):
+        return self._max_length - len(self.data)
+
     def _check_length(self):
         if len(self.data) > self._max_length:
-            raise IndexError("Advertising data exceeds max_length")
+            raise IndexError("Advertising data too long")
 
     def add_field(self, field_type, field_data):
         """Append an advertising data field to the current packet, of the given type.
@@ -101,12 +105,57 @@ def add_field(self, field_type, field_data):
 
     def add_16_bit_uuids(self, uuids):
         """Add a complete list of 16 bit service UUIDs."""
-        self.add_field(self.ALL_16_BIT_SERVICE_UUIDS, bytes(uuid.uuid16 for uuid in uuids))
+        for uuid in uuids:
+            self.add_field(self.ALL_16_BIT_SERVICE_UUIDS, struct.pack("<H", uuid.uuid16))
 
     def add_128_bit_uuids(self, uuids):
         """Add a complete list of 128 bit service UUIDs."""
-        self.add_field(self.ALL_128_BIT_SERVICE_UUIDS, bytes(uuid.uuid128 for uuid in uuids))
+        for uuid in uuids:
+            self.add_field(self.ALL_128_BIT_SERVICE_UUIDS, uuid.uuid128)
 
     def add_mfr_specific_data(self, mfr_id, data):
         """Add manufacturer-specific data bytes."""
         self.add_field(self.MANUFACTURER_SPECIFIC_DATA, struct.pack('<H', mfr_id) + data)
+
+
+class ServerAdvertisement:
+    def __init__(self, peripheral, *, tx_power=0):
+        """Create an advertisement to advertise a peripheral's services.
+
+        :param peripheral Peripheral the Peripheral to advertise. Use its services and name
+        :param int tx_power: transmit power in dBm at 0 meters (8 bit signed value). Default 0 dBm
+        """
+
+        self._peripheral = peripheral
+
+        adv = Advertisement()
+
+        # Need to check service.secondary
+        uuids_16_bits = [service.uuid for service in peripheral.services
+                         if service.uuid.size == 16 and not service.secondary]
+        if uuids_16_bits:
+            adv.add_16_bit_uuids(uuids_16_bits)
+
+        uuids_128_bits = [service.uuid for service in peripheral.services
+                         if service.uuid.size == 128 and not service.secondary]
+        if uuids_128_bits:
+            adv.add_128_bit_uuids(uuids_128_bits)
+
+        adv.add_field(Advertisement.TX_POWER, struct.pack("<b", tx_power))
+
+        # 2 bytes needed for field length and type.
+        bytes_available = adv.bytes_remaining - 2
+        if bytes_available <= 0:
+            raise IndexError("No room for name")
+
+        name_bytes = bytes(peripheral.name, 'utf-8')
+        if bytes_available >= len(name_bytes):
+            adv.add_field(Advertisement.COMPLETE_LOCAL_NAME, name_bytes)
+        else:
+            adv.add_field(Advertisement.SHORT_LOCAL_NAME, name_bytes[:bytes_available])
+
+        self._advertisement = adv
+
+    @property
+    def data(self):
+        return self._advertisement.data

adafruit_ble/beacon.py

@@ -32,22 +32,22 @@
 import struct
 import bleio
 
-from .advertising import AdvertisingData
+from .advertising import Advertisement
 
 class Beacon:
     """Base class for Beacon advertisers."""
-    def __init__(self, advertising_data, interval=1.0):
-        """Set up a beacon with the given AdvertisingData.
+    def __init__(self, advertisement, interval=1.0):
+        """Set up a beacon with the given Advertisement.
 
-        :param AdvertisingData advertising_data: The advertising packet
+        :param Advertisement advertisement: The advertising packet
         :param float interval: Advertising interval in seconds
         """
         self.broadcaster = bleio.Broadcaster(interval)
-        self.advertising_data = advertising_data
+        self.advertisement = advertisement
 
     def start(self):
         """Turn on beacon."""
-        self.broadcaster.start_advertising(self.advertising_data.data)
+        self.broadcaster.start_advertising(self.advertisement.data)
 
     def stop(self):
         """Turn off beacon."""
@@ -81,8 +81,8 @@ def __init__(self, company_id, uuid, major, minor, rssi, interval=1.0):
         b.start()
         """
 
-        adv_data = AdvertisingData()
-        adv_data.add_mfr_specific_data(
+        adv = Advertisement()
+        adv.add_mfr_specific_data(
             company_id,
             b''.join((
                 # 0x02 means a beacon. 0x15 (=21) is length (16 + 2 + 2 + 1)
@@ -91,8 +91,8 @@ def __init__(self, company_id, uuid, major, minor, rssi, interval=1.0):
                 # iBeacon and similar expect big-endian UUIDS. Usually they are little-endian.
                 bytes(reversed(uuid.uuid128)),
                 # major and minor are big-endian.
-                struct.pack(">HHB", major, minor, rssi))))
-        super().__init__(adv_data, interval=interval)
+                struct.pack(">HHb", major, minor, rssi))))
+        super().__init__(adv, interval=interval)
 
 
 class EddystoneURLBeacon(Beacon):
@@ -134,8 +134,8 @@ def __init__(self, url, tx_power=0, interval=1.0):
         :param float interval: Advertising interval in seconds
         """
 
-        adv_data = AdvertisingData()
-        adv_data.add_field(AdvertisingData.ALL_16_BIT_SERVICE_UUIDS, self._EDDYSTONE_ID)
+        adv = Advertisement()
+        adv.add_field(Advertisement.ALL_16_BIT_SERVICE_UUIDS, self._EDDYSTONE_ID)
         short_url = None
         for idx, prefix in enumerate(self._URL_SCHEMES):
             if url.startswith(prefix):
@@ -148,9 +148,9 @@ def __init__(self, url, tx_power=0, interval=1.0):
             short_url = short_url.replace(subst + '/', chr(code))
         for code, subst in enumerate(self._SUBSTITUTIONS, 7):
             short_url = short_url.replace(subst, chr(code))
-        adv_data.add_field(AdvertisingData.SERVICE_DATA_16_BIT_UUID,
-                           b''.join((self._EDDYSTONE_ID,
-                                     b'\x10',
-                                     struct.pack("<BB", tx_power, url_scheme_num),
-                                     bytes(short_url, 'ascii'))))
-        super().__init__(adv_data, interval)
+        adv.add_field(Advertisement.SERVICE_DATA_16_BIT_UUID,
+                      b''.join((self._EDDYSTONE_ID,
+                                b'\x10',
+                                struct.pack("<bB", tx_power, url_scheme_num),
+                                bytes(short_url, 'ascii'))))
+        super().__init__(adv, interval)

adafruit_ble/uart.py

@@ -29,7 +29,7 @@
 
 """
 from bleio import UUID, Characteristic, Service, Peripheral, CharacteristicBuffer
-
+from .advertising import ServerAdvertisement
 
 class UARTServer:
     """
@@ -68,12 +68,13 @@ def __init__(self, timeout=1.0, buffer_size=64):
         self._periph = Peripheral((nus_uart_service,))
         self._rx_buffer = CharacteristicBuffer(self._nus_rx_char,
                                                timeout=timeout, buffer_size=buffer_size)
+        self._advertisement = ServerAdvertisement(self._periph)
 
     def start_advertising(self):
         """Start advertising the service. When a client connects, advertising will stop.
         When the client disconnects, restart advertising by calling ``start_advertising()`` again.
         """
-        self._periph.start_advertising()
+        self._periph.start_advertising(data=self._advertisement.data)
 
     def stop_advertising(self):
         """Stop advertising the service."""