| # |
| # Copyright (c) 2015-2017 Nest Labs, Inc. |
| # All rights reserved. |
| # |
| # 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. |
| # |
| |
| # |
| # @file |
| # BLE Central support for Weave Device Manager via OSX CoreBluetooth APIs. |
| # |
| |
| import abc |
| import logging |
| import select |
| import socket |
| import sys |
| import Queue |
| import subprocess |
| import threading |
| import time |
| import binascii |
| from ctypes import * |
| import readline |
| import shlex |
| import optparse |
| from optparse import OptionParser, Option, OptionValueError |
| |
| from Foundation import * |
| import objc |
| from PyObjCTools import AppHelper |
| |
| from WeaveBleUtility import * |
| from WeaveBleUtility import _VoidPtrToByteArray |
| |
| from WeaveBleBase import WeaveBleBase |
| |
| |
| objc.loadBundle("CoreBluetooth", globals(), |
| bundle_path=objc.pathForFramework(u'/System/Library/Frameworks/IOBluetooth.framework/Versions/A/Frameworks/CoreBluetooth.framework')) |
| |
| weave_service = CBUUID.UUIDWithString_(u'0000FEAF-0000-1000-8000-00805F9B34FB') |
| weave_service_short = CBUUID.UUIDWithString_(u'FEAF') |
| weave_tx = CBUUID.UUIDWithString_(u'18EE2EF5-263D-4559-959F-4F9C429F9D11') |
| weave_rx = CBUUID.UUIDWithString_(u'18EE2EF5-263D-4559-959F-4F9C429F9D12') |
| |
| |
| def _VoidPtrToCBUUID(ptr, len): |
| try: |
| ptr = _VoidPtrToByteArray(ptr, len) |
| ptr = binascii.hexlify(ptr) |
| ptr = ptr[:8] + '-' + ptr[8:12] + '-' + ptr[12:16] + '-' + ptr[16:20] + '-' + ptr[20:] |
| ptr = CBUUID.UUIDWithString_(ptr) |
| except: |
| print "ERROR: failed to convert void * to CBUUID" |
| ptr = None |
| |
| return ptr |
| |
| |
| class CoreBluetoothManager(WeaveBleBase): |
| def __init__(self, devMgr, logger=None): |
| if logger: |
| self.logger = logger |
| else: |
| self.logger = logging.getLogger('WeaveBLEMgr') |
| logging.basicConfig( |
| level=logging.INFO, |
| format='%(asctime)s %(name)-12s %(levelname)-8s %(message)s') |
| self.manager = None |
| self.peripheral = None |
| self.service = None |
| self.scan_quiet = False |
| self.characteristics = {} |
| self.peripheral_list = [] |
| self.bg_peripheral_name = None |
| self.weave_queue = Queue.Queue() |
| |
| self.manager = CBCentralManager.alloc() |
| self.manager.initWithDelegate_queue_options_(self, None, None) |
| |
| self.ready_condition = False |
| self.loop_condition = False # indicates whether the cmd requirement has been met in the runloop. |
| self.connect_state = False # reflects whether or not there is a connection. |
| self.send_condition = False |
| self.subscribe_condition = False |
| |
| self.runLoopUntil(("ready", time.time(), 10.0)) |
| |
| self.orig_input_hook = None |
| self.hookFuncPtr = None |
| |
| self.setInputHook(self.readlineCB) |
| self.devMgr = devMgr |
| self.devMgr.SetBlockingCB(self.devMgrCB) |
| |
| def HandleBleEventCB(): |
| return self.GetBleEvent() |
| |
| def HandleBleWriteCharCB(connObj, svcId, charId, buffer, length): |
| return self.WriteBleCharacteristic(connObj, svcId, charId, buffer, length) |
| |
| def HandleBleSubscribeCB(connObj, svcId, charId, subscribe): |
| return self.SubscribeBleCharacteristic(connObj, svcId, charId, subscribe) |
| |
| def HandleBleCloseCB(connObj): |
| return self.CloseBle(connObj) |
| |
| self.devMgr.SetBleEventCB(HandleBleEventCB) |
| self.devMgr.SetBleWriteCharCB(HandleBleWriteCharCB) |
| self.devMgr.SetBleSubscribeCharCB(HandleBleSubscribeCB) |
| self.devMgr.SetBleCloseCB(HandleBleCloseCB) |
| |
| # test if any connections currently exist (left around from a previous run) and disconnect if need be. |
| peripherals = self.manager.retrieveConnectedPeripheralsWithServices_([weave_service_short, weave_service]) |
| |
| if peripherals and len(peripherals): |
| for periph in peripherals: |
| self.logger.info("disconnecting old connection.") |
| self.loop_condition = False |
| self.manager.cancelPeripheralConnection_(periph) |
| self.runLoopUntil(("disconnect", time.time(), 5.0)) |
| |
| self.connect_state = False |
| self.loop_condition = False |
| |
| def __del__(self): |
| self.disconnect() |
| self.setInputHook(self.orig_input_hook) |
| self.devMgr.SetBlockingCB(None) |
| self.devMgr.SetBleEventCB(None) |
| |
| def devMgrCB(self): |
| """ A callback used by WeaveDeviceMgr.py to drive the OSX runloop while the |
| main thread waits for the Weave thread to complete its operation.""" |
| runLoop = NSRunLoop.currentRunLoop() |
| nextfire = runLoop.limitDateForMode_(NSDefaultRunLoopMode) |
| |
| def readlineCB(self): |
| """ A callback used by readline to drive the OSX runloop while the main thread |
| waits for commandline input from the user.""" |
| runLoop = NSRunLoop.currentRunLoop() |
| nextfire = runLoop.limitDateForMode_(NSDefaultRunLoopMode) |
| |
| if self.orig_input_hook: |
| self.orig_input_hook() |
| |
| def setInputHook(self, hookFunc): |
| """Set the PyOS_InputHook to call the specific function.""" |
| hookFunctionType = CFUNCTYPE(None) |
| self.hookFuncPtr = hookFunctionType(hookFunc) |
| pyos_inputhook_ptr = c_void_p.in_dll(pythonapi, "PyOS_InputHook") |
| # save the original so that on del we can revert it back to the way it was. |
| self.orig_input_hook = cast(pyos_inputhook_ptr.value, PYFUNCTYPE(c_int)) |
| # set the new hook. readLine will call this periodically as it polls for input. |
| pyos_inputhook_ptr.value = cast(self.hookFuncPtr, c_void_p).value |
| |
| def shouldLoop(self, should_tuple): |
| """ Used by runLoopUntil to determine whether it should exit the runloop.""" |
| result = False |
| |
| time_expired = time.time() >= should_tuple[1] + should_tuple[2] |
| |
| if should_tuple[0] == "ready": |
| if not self.ready_condition and not time_expired: |
| result = True |
| elif should_tuple[0] == "scan": |
| if not time_expired: |
| result = True |
| |
| for peripheral in self.peripheral_list: |
| if should_tuple[3] and str(peripheral._.name) == should_tuple[3]: |
| result = False |
| break |
| |
| elif should_tuple[0] == "connect": |
| if not self.loop_condition and not time_expired: |
| result = True |
| elif should_tuple[0] == "disconnect": |
| if not self.loop_condition and not time_expired: |
| result = True |
| elif should_tuple[0] == "send": |
| if not self.send_condition and not time_expired: |
| result = True |
| elif should_tuple[0] == "subscribe": |
| if not self.subscribe_condition and not time_expired: |
| result = True |
| elif should_tuple[0] == "unsubscribe": |
| if self.subscribe_condition and not time_expired: |
| result = True |
| |
| return result |
| |
| def runLoopUntil(self, should_tuple): |
| """ Helper function to drive OSX runloop until an expected event is received or |
| the timeout expires.""" |
| runLoop = NSRunLoop.currentRunLoop() |
| nextfire = 1 |
| |
| while nextfire and self.shouldLoop(should_tuple): |
| nextfire = runLoop.limitDateForMode_(NSDefaultRunLoopMode) |
| |
| def centralManagerDidUpdateState_(self, manager): |
| """ IO Bluetooth initialization is successful.""" |
| |
| state = manager.state() |
| string = "BLE is ready!" if state > 4 else "BLE is not ready!" |
| self.logger.info(string) |
| self.manager = manager |
| self.ready_condition = True if state > 4 else False |
| |
| def centralManager_didDiscoverPeripheral_advertisementData_RSSI_(self, manager, peripheral, data, rssi): |
| """ Called for each peripheral discovered during scan.""" |
| if self.bg_peripheral_name is None: |
| if peripheral not in self.peripheral_list: |
| if not self.scan_quiet: |
| self.logger.info("adding to scan list:") |
| self.logger.info("") |
| self.logger.info("{0:<10}{1:<80}".format("Name =", str(peripheral._.name))) |
| self.logger.info("{0:<10}{1:<80}".format("ID =", str(peripheral._.identifier.UUIDString()))) |
| self.logger.info("{0:<10}{1:<80}".format("RSSI =", rssi)) |
| self.logger.info("ADV data: " + repr(data)) |
| self.logger.info("") |
| |
| self.peripheral_list.append(peripheral) |
| else: |
| if peripheral._.name == self.bg_peripheral_name: |
| if len(self.peripheral_list) == 0: |
| self.logger.info("found background peripheral") |
| self.peripheral_list = [peripheral] |
| |
| def centralManager_didConnectPeripheral_(self, manager, peripheral): |
| """Called by CoreBluetooth via runloop when a connection succeeds.""" |
| self.logger.debug(repr(peripheral)) |
| # make this class the delegate for peripheral events. |
| self.peripheral.setDelegate_(self) |
| # invoke service discovery on the periph. |
| self.peripheral.discoverServices_([weave_service_short, weave_service]) |
| |
| def centralManager_didFailToConnectPeripheral_error_(self, manager, peripheral, error): |
| """Called by CoreBluetooth via runloop when a connection fails.""" |
| self.logger.info("Failed to connect error = " + repr(error)) |
| self.loop_condition = True |
| self.connect_state = False |
| |
| def centralManager_didDisconnectPeripheral_error_(self, manager, peripheral, error): |
| """Called by CoreBluetooth via runloop when a disconnect completes. error = None on success.""" |
| self.loop_condition = True |
| self.connect_state = False |
| if self.devMgr: |
| self.logger.info("BLE disconnected, error = " + repr(error)) |
| dcEvent = BleDisconnectEvent(BLE_ERROR_REMOTE_DEVICE_DISCONNECTED) |
| self.weave_queue.put(dcEvent) |
| self.devMgr.DriveBleIO() |
| |
| def peripheral_didDiscoverServices_(self, peripheral, services): |
| """Called by CoreBluetooth via runloop when peripheral services are discovered.""" |
| self.service = self.peripheral.services()[0] |
| self.characteristics[self.service.UUID()] = [] |
| # NOTE: currently limiting discovery to only the pair of Weave characteristics. |
| self.peripheral.discoverCharacteristics_forService_([weave_rx, weave_tx], self.service) |
| |
| def peripheral_didDiscoverCharacteristicsForService_error_(self, peripheral, service, error): |
| """Called by CoreBluetooth via runloop when a characteristic for a service is discovered.""" |
| self.logger.debug(repr(service)) |
| self.logger.debug(repr(error)) |
| |
| if not error: |
| self.characteristics[service.UUID()] = [] |
| |
| for characteristic in self.service.characteristics(): |
| self.characteristics[service.UUID()].append(characteristic) |
| |
| self.connect_state = True |
| |
| else: |
| self.logger.error("ERROR: failed to discover characteristics for service.") |
| self.connect_state = False |
| |
| self.loop_condition = True |
| |
| def peripheral_didWriteValueForCharacteristic_error_(self, peripheral, characteristic, error): |
| """ Called by CoreBluetooth via runloop when a write to characteristic |
| operation completes. error = None on success.""" |
| self.logger.debug("didWriteValue error = " + repr(error)) |
| self.send_condition = True |
| charId = bytearray(characteristic.UUID().data().bytes().tobytes()) |
| svcId = bytearray(weave_service.data().bytes().tobytes()) |
| |
| if self.devMgr: |
| txEvent = BleTxEvent(charId=charId, svcId=svcId, status=True if not error else False) |
| self.weave_queue.put(txEvent) |
| self.devMgr.DriveBleIO() |
| |
| def peripheral_didUpdateNotificationStateForCharacteristic_error_(self, peripheral, characteristic, error): |
| """ Called by CoreBluetooth via runloop when a subscribe for notification operation completes. |
| Error = None on success.""" |
| self.logger.debug("Receiving notifications") |
| charId = bytearray(characteristic.UUID().data().bytes().tobytes()) |
| svcId = bytearray(weave_service.data().bytes().tobytes()) |
| # look at error and send True/False on Success/Failure |
| success = True if not error else False |
| if characteristic.isNotifying(): |
| operation = BleSubscribeOperation_Subscribe |
| self.subscribe_condition = True |
| else: |
| operation = BleSubscribeOperation_Unsubscribe |
| self.subscribe_condition = False |
| |
| self.logger.debug("Operation = " + repr(operation)) |
| self.logger.debug("success = " + repr(success)) |
| |
| if self.devMgr: |
| subscribeEvent = BleSubscribeEvent(charId=charId, svcId=svcId, status=success, operation=operation) |
| self.weave_queue.put(subscribeEvent) |
| self.devMgr.DriveBleIO() |
| |
| def peripheral_didUpdateValueForCharacteristic_error_(self, peripheral, characteristic, error): |
| """ Called by CoreBluetooth via runloop when a new characteristic value is received for a |
| characteristic to which this device has subscribed.""" |
| #len = characteristic.value().length() |
| bytes = bytearray(characteristic.value().bytes().tobytes()) |
| charId = bytearray(characteristic.UUID().data().bytes().tobytes()) |
| svcId = bytearray(weave_service.data().bytes().tobytes()) |
| |
| # Kick Weave thread to retrieve the saved packet. |
| if self.devMgr: |
| # Save buffer, length, service UUID and characteristic UUID |
| rxEvent = BleRxEvent(charId=charId, svcId=svcId, buffer=bytes) |
| self.weave_queue.put(rxEvent) |
| self.devMgr.DriveBleIO() |
| |
| self.logger.debug("received") |
| self.logger.debug("received (" + str(len) + ") bytes: " + repr(characteristic.value().bytes().tobytes())) |
| |
| def GetBleEvent(self): |
| """ Called by WeaveDeviceMgr.py on behalf of Weave to retrieve a queued message.""" |
| if not self.weave_queue.empty(): |
| ev = self.weave_queue.get() |
| |
| if isinstance(ev, BleRxEvent): |
| eventStruct = BleRxEventStruct.fromBleRxEvent(ev) |
| return cast( pointer(eventStruct), c_void_p).value |
| elif isinstance(ev, BleTxEvent): |
| eventStruct = BleTxEventStruct.fromBleTxEvent(ev) |
| return cast( pointer(eventStruct), c_void_p).value |
| elif isinstance(ev, BleSubscribeEvent): |
| eventStruct = BleSubscribeEventStruct.fromBleSubscribeEvent(ev) |
| return cast( pointer(eventStruct), c_void_p).value |
| elif isinstance(ev, BleDisconnectEvent): |
| eventStruct = BleDisconnectEventStruct.fromBleDisconnectEvent(ev) |
| return cast( pointer(eventStruct), c_void_p).value |
| |
| return None |
| |
| def Usage(self, cmd): |
| line = "USAGE: " |
| |
| if cmd == "scan": |
| line += "ble-scan [-t <timeout>] [<name>|<identifier>] [-q <quiet>]" |
| elif cmd == "scan-connect": |
| line += "ble-scan-connect [-t <timeout>] <name> [-q <quiet>]" |
| |
| self.logger.info(line) |
| |
| def ParseInputLine(self, line, cmd): |
| if cmd == "scan" or cmd == "scan-connect": |
| args = shlex.split(line) |
| |
| optParser = OptionParser(usage=optparse.SUPPRESS_USAGE) |
| optParser.add_option("-t", "--timeout", action="store", dest="timeout", type="float", default=10.0) |
| optParser.add_option("-q", "--quiet", action="store_true", dest="quiet") |
| try: |
| (options, remainingArgs) = optParser.parse_args(args) |
| except SystemExit: |
| self.Usage(cmd) |
| return None |
| |
| if len(remainingArgs) > 1: |
| self.Usage(cmd) |
| return None |
| |
| name = None |
| |
| if len(remainingArgs): |
| name = str(remainingArgs[0]) |
| elif cmd == "scan-connect": |
| self.Usage(cmd) |
| return None |
| |
| return (options.timeout, options.quiet, name) |
| |
| return None |
| |
| def scan(self, line): |
| """ API to initiatae BLE scanning for -t user_timeout seconds.""" |
| |
| args = self.ParseInputLine(line, "scan") |
| |
| if not args: |
| return |
| self.scan_quiet = args[1] |
| self.bg_peripheral_name = None |
| del self.peripheral_list[:] |
| self.peripheral_list = [] |
| # Filter on the service UUID Array or None to accept all scan results. |
| self.manager.scanForPeripheralsWithServices_options_([weave_service_short, weave_service], None) |
| #self.manager.scanForPeripheralsWithServices_options_(None, None) |
| |
| self.runLoopUntil(("scan", time.time(), args[0], args[2])) |
| |
| self.manager.stopScan() |
| self.logger.info("scanning stopped") |
| |
| def bgScanStart(self, name): |
| """ API to initiate background BLE scanning.""" |
| self.logger.info("scanning started") |
| self.bg_peripheral_name = name |
| del self.peripheral_list[:] |
| self.peripheral_list = [] |
| # Filter on the service UUID Array or None to accept all scan results. |
| self.manager.scanForPeripheralsWithServices_options_([weave_service_short, weave_service], None) |
| |
| def bgScanStop(self): |
| """ API to stop background BLE scanning.""" |
| self.manager.stopScan() |
| self.bg_peripheral_name = None |
| self.logger.info("scanning stopped") |
| |
| def connect(self, identifier): |
| """ API to initiate BLE connection to peripheral device whose identifier == identifier.""" |
| self.logger.info("trying to connect to " + identifier) |
| |
| if self.connect_state: |
| self.logger.error("ERROR: Connection to a BLE device already exists!") |
| else: |
| for p in self.peripheral_list: |
| p_id = str(p.identifier().UUIDString()) |
| p_name = str(p.name()) |
| |
| self.logger.debug(p_id + " vs " + str(identifier)) |
| self.logger.debug(p_name + " vs " + str(identifier)) |
| |
| if p_id == str(identifier) or p_name == str(identifier): |
| self.loop_condition = False |
| self.peripheral = p |
| self.manager.connectPeripheral_options_(p, None) |
| |
| self.runLoopUntil(("connect", time.time(), 15.0)) |
| # Cleanup when the connect fails due to timeout, |
| # otherwise CoreBluetooth will continue to try to connect after this |
| # API exits. |
| if not self.connect_state: |
| self.manager.cancelPeripheralConnection_(p) |
| self.peripheral = None |
| |
| break |
| |
| ret = True if self.loop_condition and self.connect_state else False |
| |
| resString = "connect " + ("success" if ret else "fail") |
| self.logger.info(resString) |
| |
| return ret |
| |
| def disconnect(self): |
| """ API to initiate BLE disconnect procedure.""" |
| self.logger.info("disconnecting") |
| |
| if self.peripheral and self.peripheral.state() != BlePeripheralState_Disconnected: |
| self.loop_condition = False |
| self.manager.cancelPeripheralConnection_(self.peripheral) |
| |
| self.runLoopUntil(("disconnect", time.time(), 10.0)) |
| |
| resString = "disconnect " + ("success" if self.loop_condition and not self.connect_state else "fail") |
| self.logger.info(resString) |
| |
| self.characteristics = {} |
| #del self.peripheral_list[:] |
| #self.peripheral_list = [] |
| self.peripheral = None |
| self.service = None |
| |
| def scan_connect(self, line): |
| """ API to perform both scan and connect operations in one call.""" |
| |
| args = self.ParseInputLine(line, "scan-connect") |
| |
| if not args: |
| return |
| |
| self.scan_quiet = args[1] |
| self.scan(line) |
| |
| if len(self.peripheral_list): |
| return self.connect(args[2]) |
| else: |
| self.logger.info("Failed to scan device named: " + args[2] + ". Connection skipped.") |
| return False |
| |
| |
| def isConnected(self): |
| if self.peripheral and self.peripheral.state() != BlePeripheralState_Disconnected: |
| return True |
| |
| return False |
| |
| def WriteBleCharacteristic(self, connObj, svcId, charId, buffer, length): |
| """ Called by WeaveDeviceMgr.py to satisfy a request by Weave to transmit a packet over BLE.""" |
| result = False |
| |
| bytes = _VoidPtrToByteArray(buffer, length) |
| bytes = NSData.dataWithBytes_length_(bytes, len(bytes)) # convert bytearray to NSData |
| |
| svcId = _VoidPtrToCBUUID(svcId, 16) |
| charId = _VoidPtrToCBUUID(charId, 16) |
| |
| if self.peripheral and self.peripheral.state() != BlePeripheralState_Disconnected: |
| for char in self.characteristics[svcId]: |
| if char.UUID() == charId: |
| self.peripheral.writeValue_forCharacteristic_type_(bytes, char, CBCharacteristicWriteWithResponse) |
| result = True |
| break |
| else: |
| self.logger.warning("WARNING: peripheral is no longer connected.") |
| |
| return result |
| |
| def SubscribeBleCharacteristic(self, connObj, svcId, charId, subscribe): |
| """ Called by Weave to (un-)subscribe to a characteristic of a service.""" |
| result = False |
| |
| svcId = _VoidPtrToCBUUID(svcId, 16) |
| charId = _VoidPtrToCBUUID(charId, 16) |
| |
| if self.peripheral and self.peripheral.state() != BlePeripheralState_Disconnected: |
| for char in self.characteristics[svcId]: |
| if char.UUID() == charId: |
| self.peripheral.setNotifyValue_forCharacteristic_(True if subscribe else False, char) |
| result = True |
| break |
| else: |
| self.logger.warning("WARNING: peripheral is no longer connected.") |
| |
| return result |
| |
| def ble_debug_log(self, line): |
| args = self.ParseInputLine(line) |
| if int(args[0]) == 1: |
| self.logger.setLevel(logging.DEBUG) |
| self.logger.debug("current logging level is debug") |
| else: |
| self.logger.setLevel(logging.INFO) |
| self.logger.debug("current logging level is info") |
| return True |
| |
| def CloseBle(self, connObj): |
| """ Called by Weave to close the BLE connection.""" |
| if self.peripheral: |
| self.manager.cancelPeripheralConnection_(self.peripheral) |
| self.characteristics = {} |
| #del self.peripheral_list[:] |
| #self.peripheral_list = [] |
| self.peripheral = None |
| self.service = None |
| self.connect_state = False |
| |
| return True |
| |
| def updateCharacteristic(self, bytes, svcId, charId): |
| # TODO: implement this for Peripheral support. |
| return False |
