Update to use new bleio API

Author: dhalbert

adafruit_ble/beacon.py

@@ -41,7 +41,7 @@ def __init__(self, advertising_packet):
 
         :param AdvertisingPacket advertising_packet
         """
-        self._broadcaster = bleio.Peripheral(name=None)
+        self._broadcaster = bleio.Peripheral()
         self._advertising_packet = advertising_packet
 
     def start(self, interval=1.0):

adafruit_ble/current_time_client.py

@@ -66,7 +66,7 @@ class CurrentTimeClient:
     LOCAL_TIME_INFORMATION_UUID = UUID(0x2A0F)
 
     def __init__(self, name=None, tx_power=0):
-        self._periph = Peripheral(name=name)
+        self._periph = Peripheral(name)
         self._advertisement = SolicitationAdvertisement(self._periph.name,
                                                         (self.CTS_UUID,), tx_power=tx_power)
         self._current_time_char = self._local_time_char = None

adafruit_ble/device_information_service.py

@@ -28,65 +28,69 @@
 * Author(s): Dan Halbert for Adafruit Industries
 
 """
-from bleio import Attribute, Characteristic, Service, UUID
+from bleio import Attribute, Characteristic, UUID
 
-# pylint: disable=invalid-name
-def DeviceInformationService(*, model_number=None, serial_number=None, firmware_revision=None,
-                             hardware_revision='', software_revision='', manufacturer=''):
-    """
-    Set up a Service with fixed Device Information Service charcteristics.
-    All values are optional.
+class DeviceInformationService:
+    """This is a factory class only, and has no instances."""
 
-    Note that this is a pseudo class: It returns a Service, but is not a subclass of Service,
-    because Service is a native class and doesn't handle subclassing.
+    @staticmethod
+    def add_to_peripheral(peripheral, *, model_number=None, serial_number=None,
+                          firmware_revision=None, hardware_revision='',
+                          software_revision='', manufacturer=''):
+        """
+        Add a Service with fixed Device Information Service characteristics to the given Peripheral.
+        All values are optional.
 
-      :param str model_number: Device model number. If None use `sys.platform`.
-      :param str serial_number: Device serial number. If None use a hex representation of
-         ``microcontroller.cpu.id``.
-      :param str firmware_revision: Device firmware revision. If None use ``os.uname().version``.
-      :param str hardware_revision: Device hardware revision.
-      :param str software_revision: Device software revision.
-      :param str manufacturer: Device manufacturer name
+          :param str model_number: Device model number. If None use `sys.platform`.
+          :param str serial_number: Device serial number. If None use a hex representation of
+             ``microcontroller.cpu.id``.
+          :param str firmware_revision: Device firmware revision.
+             If None use ``os.uname().version``.
+          :param str hardware_revision: Device hardware revision.
+          :param str software_revision: Device software revision.
+          :param str manufacturer: Device manufacturer name
+          :return: the created Service
 
-    Example::
+        Example::
 
-        dis = DeviceInformationService(software_revision="1.2.4", manufacturer="Acme Corp")
-    """
+            peripheral = Peripheral()
+            dis = DeviceInformationService.add_to_peripheral(
+                peripheral, software_revision="1.2.4", manufacturer="Acme Corp")
+        """
 
-    # Avoid creating constants with names if not necessary. Just takes up space.
-    # Device Information Service UUID = 0x180A
-    # Module Number UUID = 0x2A24
-    # Serial Number UUID = 0x2A25
-    # Firmware Revision UUID = 0x2A26
-    # Hardware Revision UUID = 0x2A27
-    # Software Revision UUID = 0x2A28
-    # Manufacturer Name UUID = 0x2A29
+        # Avoid creating constants with names if not necessary. Just takes up space.
+        # Device Information Service UUID = 0x180A
+        # Module Number UUID = 0x2A24
+        # Serial Number UUID = 0x2A25
+        # Firmware Revision UUID = 0x2A26
+        # Hardware Revision UUID = 0x2A27
+        # Software Revision UUID = 0x2A28
+        # Manufacturer Name UUID = 0x2A29
 
-    characteristics = []
-    # Values must correspond to UUID numbers.
+        service = peripheral.add_service(UUID(0x180A))
 
-    if model_number is None:
-        import sys
-        model_number = sys.platform
-    if serial_number is None:
-        import microcontroller
-        import binascii
-        serial_number = binascii.hexlify(microcontroller.cpu.uid).decode('utf-8') # pylint: disable=no-member
+        if model_number is None:
+            import sys
+            model_number = sys.platform
+        if serial_number is None:
+            import microcontroller
+            import binascii
+            serial_number = binascii.hexlify(microcontroller.cpu.uid).decode('utf-8') # pylint: disable=no-member
 
-    if firmware_revision is None:
-        import os
-        firmware_revision = os.uname().version
+        if firmware_revision is None:
+            import os
+            firmware_revision = os.uname().version
 
-    for uuid_num, string in zip(
-            range(0x2A24, 0x2A29+1),
-            (model_number, serial_number,
-             firmware_revision, hardware_revision, software_revision,
-             manufacturer)):
+        # Values must correspond to UUID numbers.
+        for uuid_num, value in zip(
+                range(0x2A24, 0x2A29+1),
+                (model_number, serial_number,
+                 firmware_revision, hardware_revision, software_revision,
+                 manufacturer)):
 
-        char = Characteristic(UUID(uuid_num), properties=Characteristic.READ,
-                              read_perm=Attribute.OPEN, write_perm=Attribute.NO_ACCESS,
-                              fixed_length=True, max_length=len(string))
-        char.value = string
-        characteristics.append(char)
+            service.add_characteristic(UUID(uuid_num), properties=Characteristic.READ,
+                                       read_perm=Attribute.OPEN, write_perm=Attribute.NO_ACCESS,
+                                       fixed_length=True, max_length=len(value),
+                                       initial_value=value)
 
-    return Service(UUID(0x180A), characteristics)
+        return service

adafruit_ble/hid_server.py

@@ -35,7 +35,7 @@
 # for __version__
 import adafruit_ble
 
-from bleio import Attribute, Characteristic, Descriptor, Peripheral, Service, UUID
+from bleio import Attribute, Characteristic, Peripheral, UUID
 from .advertising import ServerAdvertisement
 from .device_information_service import DeviceInformationService
 
@@ -208,89 +208,83 @@ class HIDServer:
     }
 
     def __init__(self, name=None, tx_power=0):
+        self._periph = Peripheral(name)
+
+        # iOS requires Device Information Service. Android does not.
+        DeviceInformationService.add_to_peripheral(
+            self._periph, software_revision=adafruit_ble.__version__,
+            manufacturer="Adafruit Industries")
+
+        service = self._periph.add_service(UUID(_HID_SERVICE_UUID_NUM))
+
         self._input_chars = {}
         for report_id in sorted(self._INPUT_REPORT_SIZES.keys()):
-            desc = Descriptor(self._REPORT_REF_DESCR_UUID,
-                              read_perm=Attribute.ENCRYPT_NO_MITM, write_perm=Attribute.NO_ACCESS)
-            desc.value = struct.pack('<BB', report_id, _REPORT_TYPE_INPUT)
-            report_size = self._INPUT_REPORT_SIZES[report_id]
-            self._input_chars[report_id] = Characteristic(
+            input_char = service.add_characteristic(
                 self._REPORT_UUID, properties=Characteristic.READ | Characteristic.NOTIFY,
                 read_perm=Attribute.ENCRYPT_NO_MITM, write_perm=Attribute.NO_ACCESS,
-                max_length=report_size, fixed_length=True,
-                descriptors=(desc,))
-            self._input_chars[report_id].value = bytes(report_size)
+                max_length=self._INPUT_REPORT_SIZES[report_id], fixed_length=True)
+            input_char.add_descriptor(
+                self._REPORT_REF_DESCR_UUID,
+                read_perm=Attribute.ENCRYPT_NO_MITM, write_perm=Attribute.NO_ACCESS,
+                initial_value=struct.pack('<BB', report_id, _REPORT_TYPE_INPUT))
+            self._input_chars[report_id] = input_char
 
         self._output_chars = {}
         for report_id in sorted(self._OUTPUT_REPORT_SIZES.keys()):
-            desc = Descriptor(self._REPORT_REF_DESCR_UUID,
-                              read_perm=Attribute.ENCRYPT_NO_MITM, write_perm=Attribute.NO_ACCESS)
-            desc.value = struct.pack('<BB', report_id, _REPORT_TYPE_OUTPUT)
-            report_size = self._OUTPUT_REPORT_SIZES[report_id]
-            self._output_chars[report_id] = Characteristic(
+            output_char = service.add_characteristic(
                 self._REPORT_UUID,
                 properties=(Characteristic.READ | Characteristic.WRITE |
                             Characteristic.WRITE_NO_RESPONSE),
                 read_perm=Attribute.ENCRYPT_NO_MITM, write_perm=Attribute.ENCRYPT_NO_MITM,
-                max_length=report_size, fixed_length=True,
-                descriptors=(desc,))
-            self._output_chars[report_id].value = bytes(report_size)
+                max_length=self._OUTPUT_REPORT_SIZES[report_id], fixed_length=True)
+            output_char.add_descriptor(
+                self._REPORT_REF_DESCR_UUID,
+                read_perm=Attribute.ENCRYPT_NO_MITM, write_perm=Attribute.NO_ACCESS,
+                initial_value=struct.pack('<BB', report_id, _REPORT_TYPE_OUTPUT))
+            self._output_chars[report_id] = output_char
 
         # Protocol mode: boot or report. Make it read-only for now because
         # it can't be changed
 
-        protocol_mode_char = Characteristic(
-            UUID(_PROTOCOL_MODE_UUID_NUM), properties=Characteristic.READ | Characteristic.WRITE_NO_RESPONSE,
+        service.add_characteristic(
+            UUID(_PROTOCOL_MODE_UUID_NUM),
+            properties=Characteristic.READ | Characteristic.WRITE_NO_RESPONSE,
             read_perm=Attribute.OPEN, write_perm=Attribute.OPEN,
-            max_length=1, fixed_length=True)
-        protocol_mode_char.value = _PROTOCOL_MODE_REPORT
+            max_length=1, fixed_length=True,
+            initial_value=_PROTOCOL_MODE_REPORT)
 
-        boot_keyboard_input_report = Characteristic(
+        service.add_characteristic(
             UUID(_BOOT_KEYBOARD_INPUT_REPORT_UUID_NUM),
             properties=Characteristic.READ | Characteristic.NOTIFY,
             read_perm=Attribute.ENCRYPT_NO_MITM, write_perm=Attribute.NO_ACCESS,
             max_length=self._INPUT_REPORT_SIZES[self.REPORT_ID_KEYBOARD], fixed_length=True)
 
-        boot_keyboard_output_report = Characteristic(
+        service.add_characteristic(
             UUID(_BOOT_KEYBOARD_OUTPUT_REPORT_UUID_NUM),
             properties=(Characteristic.READ | Characteristic.WRITE |
                         Characteristic.WRITE_NO_RESPONSE),
             read_perm=Attribute.ENCRYPT_NO_MITM, write_perm=Attribute.ENCRYPT_NO_MITM,
             max_length=self._OUTPUT_REPORT_SIZES[self.REPORT_ID_KEYBOARD], fixed_length=True)
 
         # This is the USB HID descriptor (not to be confused with a BLE Descriptor).
-        report_map_char = Characteristic(
+        service.add_characteristic(
             UUID(_REPORT_MAP_UUID_NUM), properties=Characteristic.READ,
             read_perm=Attribute.ENCRYPT_NO_MITM, write_perm=Attribute.NO_ACCESS,
-            max_length=len(self.HID_DESCRIPTOR), fixed_length=True)
-        report_map_char.value = self.HID_DESCRIPTOR
+            max_length=len(self.HID_DESCRIPTOR), fixed_length=True,
+            initial_value=self.HID_DESCRIPTOR)
 
         # bcdHID (version), bCountryCode (0 not localized), Flags: RemoteWake, NormallyConnectable
-        hid_information_char = Characteristic(
-            UUID(_HID_INFORMATION_UUID_NUM), properties=Characteristic.READ,
-            read_perm=Attribute.ENCRYPT_NO_MITM, write_perm=Attribute.NO_ACCESS)
         # bcd1.1, country = 0, flag = normal connect
-        hid_information_char.value = b'\x01\x01\x00\x02'
+        service.add_characteristic(
+            UUID(_HID_INFORMATION_UUID_NUM), properties=Characteristic.READ,
+            read_perm=Attribute.ENCRYPT_NO_MITM, write_perm=Attribute.NO_ACCESS,
+            initial_value=b'\x01\x01\x00\x02')
 
         # 0 = suspend; 1 = exit suspend
-        self._hid_control_point_char = Characteristic(
+        service.add_characteristic(
             UUID(_HID_CONTROL_POINT_UUID_NUM), properties=Characteristic.WRITE_NO_RESPONSE,
             read_perm=Attribute.NO_ACCESS, write_perm=Attribute.ENCRYPT_NO_MITM)
 
-        # iOS requires Device Information Service. Android does not.
-        dis = DeviceInformationService(software_revision=adafruit_ble.__version__,
-                                       manufacturer="Adafruit Industries")
-        hid_service = Service(UUID(_HID_SERVICE_UUID_NUM),
-                              tuple(self._input_chars.values()) +
-                              tuple(self._output_chars.values()) +
-                              (boot_keyboard_input_report,
-                               boot_keyboard_output_report,
-                               protocol_mode_char,
-                               report_map_char,
-                               hid_information_char,
-                               self._hid_control_point_char,
-                              ))
-        self._periph = Peripheral((dis, hid_service), name=name)
         self._advertisement = ServerAdvertisement(self._periph, tx_power=tx_power,
                                                   appearance=_APPEARANCE_HID_KEYBOARD)
 

adafruit_ble/uart_server.py

@@ -28,7 +28,7 @@
 * Author(s): Dan Halbert for Adafruit Industries
 
 """
-from bleio import Attribute, Characteristic, CharacteristicBuffer, Peripheral, Service
+from bleio import Attribute, Characteristic, CharacteristicBuffer, Peripheral
 from .advertising import ServerAdvertisement
 from .uart import NUS_SERVICE_UUID, NUS_RX_CHAR_UUID, NUS_TX_CHAR_UUID
 
@@ -56,20 +56,23 @@ class UARTServer:
     """
 
     def __init__(self, *, timeout=1.0, buffer_size=64, name=None):
-        self._read_char = Characteristic(
+        self._periph = Peripheral(name)
+        service = self._periph.add_service(NUS_SERVICE_UUID)
+
+        self._read_char = service.add_characteristic(
             NUS_RX_CHAR_UUID,
             properties=Characteristic.WRITE | Characteristic.WRITE_NO_RESPONSE,
             read_perm=Attribute.NO_ACCESS, write_perm=Attribute.OPEN)
-        self._write_char = Characteristic(
+
+        self._write_char = service.add_characteristic(
             NUS_TX_CHAR_UUID,
             properties=Characteristic.NOTIFY,
             read_perm=Attribute.OPEN, write_perm=Attribute.NO_ACCESS)
+
         self._read_buffer = CharacteristicBuffer(self._read_char,
                                                  timeout=timeout, buffer_size=buffer_size)
 
-        nus_uart_service = Service(NUS_SERVICE_UUID, (self._read_char, self._write_char))
 
-        self._periph = Peripheral((nus_uart_service,), name=name)
         self._advertisement = ServerAdvertisement(self._periph)
 
     def start_advertising(self):