def connect_over_bredr(self): """Perform GATT connection over BREDR""" self.bluetooth_gatt, self.gatt_callback = setup_gatt_connection( self.dut, self.target_mac_addr, False, transport=gatt_transport['bredr'])
def connect_over_le(self, autoconnect): """Perform GATT connection over LE""" self.bluetooth_gatt, self.gatt_callback = setup_gatt_connection( self.dut, self.target_mac_addr, autoconnect, transport=gatt_transport['le']) self.discovered_services_index = None
def test_gatt_connect_iterate_uuids(self): """Test the discovery of uuids of a peripheral This test will prompt the user to press "Enter" when the peripheral is in a connecable advertisement state. Once the user presses enter, this script connects an Android device to the periphal and attempt to discover all services, characteristics, and descriptors. Steps: 1. Wait for user input to confirm peripheral is advertising. 2. Perform GATT connection to peripheral 3. Upon successful connection, iterate through all services, characteristics, and descriptors. 5. Disconnect from peripheral Expected Result: Device services, characteristics, and descriptors should all be read. Returns: Pass if True Fail if False TAGS: LE, GATT Priority: 2 """ try: bluetooth_gatt, gatt_callback = (setup_gatt_connection( self.cen_ad, self.ble_mac_address, self.AUTOCONNECT, gatt_transport['le'])) except GattTestUtilsError as err: self.log.error(err) return False if self.cen_ad.droid.gattClientDiscoverServices(bluetooth_gatt): expected_event = gatt_cb_strings['gatt_serv_disc'].format( gatt_callback) try: event = self.cen_ad.ed.pop_event(expected_event, self.DEFAULT_TIMEOUT) discovered_services_index = event['data']['ServicesIndex'] except Empty: self.log.error( gatt_cb_err['gatt_serv_disc'].format(expected_event)) return False log_gatt_server_uuids(self.cen_ad, discovered_services_index) try: disconnect_gatt_connection(self.cen_ad, bluetooth_gatt, gatt_callback) self.cen_ad.droid.gattClientClose(bluetooth_gatt) except GattTestUtilsError as err: self.log.error(err) return False self.cen_ad.droid.gattClientClose(bluetooth_gatt) return True
def test_gatt_connect_stress(self): """Test the round trip speed of connecting to a peripheral many times This test will prompt the user to press "Enter" when the peripheral is in a connecable advertisement state. Once the user presses enter, this script will measure the amount of time it takes to establish a GATT connection to the peripheral. The test will then disconnect. It will attempt to repeat this process multiple times. Steps: 1. Wait for user input to confirm peripheral is advertising. 2. Start timer 3. Perform GATT connection to peripheral 4. Upon successful connection, stop timer 5. Disconnect from peripheral 6. Repeat steps 2-5 1000 times. Expected Result: Test should measure 1000 iterations of connect/disconnect cycles. Returns: Pass if True Fail if False TAGS: LE, GATT Priority: 2 """ filter_list, scan_settings, scan_callback = generate_ble_scan_objects( self.cen_ad.droid) self.cen_ad.droid.bleStartBleScan(filter_list, scan_settings, scan_callback) self.AUTOCONNECT = False iterations = 1000 n = 0 while n < iterations: self.start_timer() try: bluetooth_gatt, gatt_callback = (setup_gatt_connection( self.cen_ad, self.ble_mac_address, self.AUTOCONNECT, gatt_transport['le'])) except GattTestUtilsError as err: self.log.error(err) return False self.log.info("Total time (ms): {}".format(self.end_timer())) try: disconnect_gatt_connection(self.cen_ad, bluetooth_gatt, gatt_callback) self.cen_ad.droid.gattClientClose(bluetooth_gatt) except GattTestUtilsError as err: self.log.error(err) return False n += 1 return True
def test_concurrent_gatt_connections(self): """Test max concurrent GATT connections Connect to all peripherals. Steps: 1. Scan 2. Save addresses 3. Connect all addresses of the peripherals Expected Result: All connections successful. Returns: Pass if True Fail if False TAGS: Bluetooth, GATT Priority: 2 """ address_list = self.obtain_address_list_from_scan() if address_list is None: return False # Connect to all addresses for address_tuple in address_list: address = address_tuple[1] try: autoconnect = False bluetooth_gatt, gatt_callback = setup_gatt_connection( self.pri_dut, address, autoconnect) self.log.info("Successfully connected to {}".format(address)) except Exception as err: self.log.error( "Failed to establish connection to {}".format(address)) return False if (len( self.pri_dut.droid.bluetoothGetConnectedLeDevices( bt_profile_constants['gatt_server'])) != self.max_connections): self.log.error("Did not reach max connection count.") return False return True
def test_gatt_connect_without_scanning(self): """Test the round trip speed of connecting to a peripheral This test will prompt the user to press "Enter" when the peripheral is in a connecable advertisement state. Once the user presses enter, this script will measure the amount of time it takes to establish a GATT connection to the peripheral. The test will then disconnect Steps: 1. Wait for user input to confirm peripheral is advertising. 2. Start timer 3. Perform GATT connection to peripheral 4. Upon successful connection, stop timer 5. Disconnect from peripheral Expected Result: Device should be connected successfully Returns: Pass if True Fail if False TAGS: LE, GATT Priority: 1 """ self.AUTOCONNECT = False start_time = self._get_time_in_milliseconds() try: bluetooth_gatt, gatt_callback = (setup_gatt_connection( self.cen_ad, self.ble_mac_address, self.AUTOCONNECT, gatt_transport['le'])) except GattTestUtilsError as err: self.log.error(err) return False end_time = self._get_time_in_milliseconds() self.log.info("Total time (ms): {}".format(end_time - start_time)) try: disconnect_gatt_connection(self.cen_ad, bluetooth_gatt, gatt_callback) self.cen_ad.droid.gattClientClose(bluetooth_gatt) except GattTestUtilsError as err: self.log.error(err) return False self.cen_ad.droid.gattClientClose(bluetooth_gatt)
def connect_over_le_based_off_name(self, autoconnect, name): """Perform GATT connection over LE""" self.dut.droid.bleSetScanSettingsScanMode( ble_scan_settings_modes['low_latency']) filter_list = self.dut.droid.bleGenFilterList() scan_settings = self.dut.droid.bleBuildScanSetting() scan_callback = self.dut.droid.bleGenScanCallback() event_name = scan_result.format(scan_callback) self.dut.droid.bleSetScanFilterDeviceName("BLE Rect") self.dut.droid.bleBuildScanFilter(filter_list) self.dut.droid.bleStartBleScan(filter_list, scan_settings, scan_callback) try: event = self.dut.ed.pop_event(event_name, 10) self.log.info("Found scan result: {}".format(event)) except Exception: self.log.info("Didn't find any scan results.") mac_addr = event['data']['Result']['deviceInfo']['address'] self.bluetooth_gatt, self.gatt_callback = setup_gatt_connection( self.dut, mac_addr, autoconnect, transport=gatt_transport['le']) self.dut.droid.bleStopBleScan(scan_callback) self.discovered_services_index = None
def test_data_transfer_to_concurrent_gatt_connections(self): """Test writing GATT descriptors concurrently to many peripherals. Connect to all peripherals and write gatt descriptors concurrently. Steps: 1. Scan the addresses by names 2. Save mac addresses of the peripherals 3. Connect all addresses of the peripherals and write gatt descriptors Expected Result: All connections and data transfers are successful. Returns: Pass if True Fail if False TAGS: Bluetooth, GATT Priority: 2 """ address_list = self.obtain_address_list_from_scan() if address_list is None: return False # Connect to all addresses executor = concurrent.futures.ThreadPoolExecutor(max_workers=10) for address_tuple in address_list: ad, address = address_tuple gatts = GattServerLib(log=self.log, dut=ad) gatt_server, gatt_server_callback = gatts.setup_gatts_db( database=gatt_server_read_descriptor_sample) try: bluetooth_gatt, gatt_callback = setup_gatt_connection( self.pri_dut, address, autoconnect=False) self.log.info("Successfully connected to {}".format(address)) except Exception as err: self.log.error( "Failed to establish connection to {}".format(address)) return False if self.pri_dut.droid.gattClientDiscoverServices(bluetooth_gatt): event = self.pri_dut.ed.pop_event( "GattConnect{}onServicesDiscovered".format(bluetooth_gatt), self.bt_default_timeout) discovered_services_index = event['data']['ServicesIndex'] else: self.log.info("Failed to discover services.") return False services_count = self.pri_dut.droid.gattClientGetDiscoveredServicesCount( discovered_services_index) arguments_list = [ self.pri_dut.droid, self.pri_dut.ed, ad.droid, ad.ed, gatt_server, gatt_server_callback, bluetooth_gatt, services_count, discovered_services_index, 100 ] self.list_of_arguments_list.append(arguments_list) for arguments_list in self.list_of_arguments_list: executor.submit(run_continuous_write_descriptor, *arguments_list) executor.shutdown(wait=True) if (len( self.pri_dut.droid.bluetoothGetConnectedLeDevices( bt_profile_constants['gatt_server'])) != self.max_connections): self.log.error("Failed to write concurrently.") return False return True
def orchestrate_coc_connection( client_ad, server_ad, is_ble, secured_conn=False, le_connection_interval=0, le_tx_data_length=default_le_data_length, accept_timeout_ms=default_bluetooth_socket_timeout_ms, le_min_ce_len=0, le_max_ce_len=0, gatt_disconnection=True): """Sets up the CoC connection between two Android devices. Args: client_ad: the Android device performing the connection. server_ad: the Android device accepting the connection. is_ble: using LE transport. secured_conn: using secured connection le_connection_interval: LE Connection interval. 0 means use default. le_tx_data_length: LE Data Length used by BT Controller to transmit. accept_timeout_ms: timeout while waiting for incoming connection. gatt_disconnection: LE GATT disconnection, default is True, False will return bluetooth_gatt and gatt_callback Returns: True if connection was successful or false if unsuccessful, client connection ID, and server connection ID """ server_ad.droid.bluetoothStartPairingHelper() client_ad.droid.bluetoothStartPairingHelper() adv_callback = None mac_address = None if is_ble: try: # This will start advertising and scanning. Will fail if it could # not find the advertisements from server_ad client_ad.log.info( "Orchestrate_coc_connection: Start BLE advertisement and" "scanning. Secured Connection={}".format(secured_conn)) mac_address, adv_callback, scan_callback = ( get_mac_address_of_generic_advertisement(client_ad, server_ad)) except BtTestUtilsError as err: raise BtCoCTestUtilsError( "Orchestrate_coc_connection: Error in getting mac address: {}". format(err)) else: mac_address = server_ad.droid.bluetoothGetLocalAddress() adv_callback = None # Adjust the Connection Interval (if necessary) bluetooth_gatt_1 = -1 gatt_callback_1 = -1 gatt_connected = False if is_ble and (le_connection_interval != 0 or le_min_ce_len != 0 or le_max_ce_len != 0): client_ad.log.info( "Adjusting connection interval={}, le_min_ce_len={}, le_max_ce_len={}" .format(le_connection_interval, le_min_ce_len, le_max_ce_len)) try: bluetooth_gatt_1, gatt_callback_1 = setup_gatt_connection( client_ad, mac_address, False, transport=gatt_transport['le'], opportunistic=False) client_ad.droid.bleStopBleScan(scan_callback) except GattTestUtilsError as err: client_ad.log.error(err) if (adv_callback != None): server_ad.droid.bleStopBleAdvertising(adv_callback) return False, None, None client_ad.log.info("setup_gatt_connection returns success") if (le_connection_interval != 0): minInterval = le_connection_interval / le_connection_interval_time_step_ms maxInterval = le_connection_interval / le_connection_interval_time_step_ms else: minInterval = default_le_connection_interval_ms / le_connection_interval_time_step_ms maxInterval = default_le_connection_interval_ms / le_connection_interval_time_step_ms if (le_min_ce_len != 0): le_min_ce_len = le_min_ce_len / le_connection_event_time_step_ms if (le_max_ce_len != 0): le_max_ce_len = le_max_ce_len / le_connection_event_time_step_ms return_status = client_ad.droid.gattClientRequestLeConnectionParameters( bluetooth_gatt_1, minInterval, maxInterval, 0, le_default_supervision_timeout, le_min_ce_len, le_max_ce_len) if not return_status: client_ad.log.error( "gattClientRequestLeConnectionParameters returns failure") if (adv_callback != None): server_ad.droid.bleStopBleAdvertising(adv_callback) return False, None, None client_ad.log.info( "gattClientRequestLeConnectionParameters returns success. Interval={}" .format(minInterval)) gatt_connected = True # For now, we will only test with 1 Mbit Phy. # TODO: Add explicit tests with 2 MBit Phy. client_ad.droid.gattClientSetPreferredPhy(bluetooth_gatt_1, gatt_phy['1m'], gatt_phy['1m'], 0) server_ad.droid.bluetoothSocketConnBeginAcceptThreadPsm( accept_timeout_ms, is_ble, secured_conn) psm_value = server_ad.droid.bluetoothSocketConnGetPsm() client_ad.log.info("Assigned PSM value={}".format(psm_value)) client_ad.droid.bluetoothSocketConnBeginConnectThreadPsm( mac_address, is_ble, psm_value, secured_conn) if (le_tx_data_length != default_le_data_length) and is_ble: client_ad.log.info("orchestrate_coc_connection: call " "bluetoothSocketRequestMaximumTxDataLength") client_ad.droid.bluetoothSocketRequestMaximumTxDataLength() end_time = time.time() + bt_default_timeout test_result = False while time.time() < end_time: if len(server_ad.droid.bluetoothSocketConnActiveConnections()) > 0: server_ad.log.info("CoC Server Connection Active") if len(client_ad.droid.bluetoothSocketConnActiveConnections()) > 0: client_ad.log.info("CoC Client Connection Active") test_result = True break time.sleep(1) if (adv_callback != None): server_ad.droid.bleStopBleAdvertising(adv_callback) if not test_result: client_ad.log.error("Failed to establish an CoC connection") return False, None, None if len(client_ad.droid.bluetoothSocketConnActiveConnections()) > 0: server_ad.log.info( "CoC client_ad Connection Active, num=%d", len(client_ad.droid.bluetoothSocketConnActiveConnections())) else: server_ad.log.info("Error CoC client_ad Connection Inactive") client_ad.log.info("Error CoC client_ad Connection Inactive") # Wait for the client to be ready client_conn_id = None while (client_conn_id == None): client_conn_id = client_ad.droid.bluetoothGetLastConnId() if (client_conn_id != None): break time.sleep(1) # Wait for the server to be ready server_conn_id = None while (server_conn_id == None): server_conn_id = server_ad.droid.bluetoothGetLastConnId() if (server_conn_id != None): break time.sleep(1) client_ad.log.info( "orchestrate_coc_connection: client conn id={}, server conn id={}". format(client_conn_id, server_conn_id)) if gatt_disconnection: if gatt_connected: disconnect_gatt_connection(client_ad, bluetooth_gatt_1, gatt_callback_1) client_ad.droid.gattClientClose(bluetooth_gatt_1) return True, client_conn_id, server_conn_id else: return True, client_conn_id, server_conn_id, bluetooth_gatt_1, gatt_callback_1
def test_gatt_notification_longev(self): """Test GATT characterisitic notifications for long periods of time This test will prompt the user to press "Enter" when the peripheral is in a connecable advertisement state. Once the user presses enter, this script aims to set characteristic notification to true on the config file's SERVICE_UUID, NOTIFIABLE_CHAR_UUID, and CCC_DESC_UUID. This test assumes the peripheral will constantly write data to a notifiable characteristic. Steps: 1. Wait for user input to confirm peripheral is advertising. 2. Perform Bluetooth pairing to GATT mac address 3. Perform a GATT connection to the periheral 4. Get the discovered service uuid that matches the user's input in the config file 4. Write to the CCC descriptor to enable notifications 5. Enable notifications on the user's input Characteristic UUID 6. Continuously wait for Characteristic Changed events which equate to recieving notifications for 15 minutes. Expected Result: There should be no disconnects and we should constantly receive Characteristic Changed information. Values should vary upon user interaction with the peripheral. Returns: Pass if True Fail if False TAGS: LE, GATT Priority: 1 """ #pair devices if not self._pair_with_peripheral(): return False try: bluetooth_gatt, gatt_callback = (setup_gatt_connection( self.cen_ad, self.ble_mac_address, self.AUTOCONNECT, gatt_transport['le'])) except GattTestUtilsError as err: self.log.error(err) return False if self.cen_ad.droid.gattClientDiscoverServices(bluetooth_gatt): expected_event = gatt_cb_strings['gatt_serv_disc'].format( gatt_callback) try: event = self.cen_ad.ed.pop_event(expected_event, self.DEFAULT_TIMEOUT) discovered_services_index = event['data']['ServicesIndex'] except Empty: self.log.error( gatt_cb_err['gatt_serv_disc'].format(expected_event)) return False # TODO: in setup save service_cound and discovered_services_index # programatically services_count = self.cen_ad.droid.gattClientGetDiscoveredServicesCount( discovered_services_index) test_service_index = None for i in range(services_count): disc_service_uuid = ( self.cen_ad.droid.gattClientGetDiscoveredServiceUuid( discovered_services_index, i)) if disc_service_uuid == self.SERVICE_UUID: test_service_index = i break if not test_service_index: self.log.error("Service not found.") return False self.cen_ad.droid.gattClientDescriptorSetValue( bluetooth_gatt, discovered_services_index, test_service_index, self.NOTIFIABLE_CHAR_UUID, self.CCC_DESC_UUID, gatt_descriptor['enable_notification_value']) self.cen_ad.droid.gattClientWriteDescriptor(bluetooth_gatt, discovered_services_index, test_service_index, self.NOTIFIABLE_CHAR_UUID, self.CCC_DESC_UUID) self.cen_ad.droid.gattClientSetCharacteristicNotification( bluetooth_gatt, discovered_services_index, test_service_index, self.NOTIFIABLE_CHAR_UUID, True) # set 15 minute notification test time notification_test_time = 900 end_time = time.time() + notification_test_time expected_event = gatt_cb_strings['char_change'].format(gatt_callback) while time.time() < end_time: try: event = self.cen_ad.ed.pop_event(expected_event, self.DEFAULT_TIMEOUT) self.log.info(event) except Empty as err: print(err) self.log.error( gatt_cb_err['char_change_err'].format(expected_event)) return False return True