Merge changes I6ec4610b,I0955b21d (2f573ec4) · Commits · e / os / android_packages_modules_Bluetooth

system/bta/csis/csis_client.cc

+15 −25

Original line number	Original line	Diff line number	Diff line
	@@ -1737,30 +1737,22 @@ class CsisClientImpl : public CsisClient {
	device->conn_id = evt.conn_id;		device->conn_id = evt.conn_id;

	/* Verify bond */		/* Verify bond */
	uint8_t sec_flag = 0;		if (BTM_SecIsSecurityPending(device->addr)) {
	BTM_GetSecurityFlagsByTransport(evt.remote_bda, &sec_flag, BT_TRANSPORT_LE);		/* if security collision happened, wait for encryption done
			* (BTA_GATTC_ENC_CMPL_CB_EVT) */
	/* If link has been encrypted look for the service or report */		return;
	if (sec_flag & BTM_SEC_FLAG_ENCRYPTED) {
	if (device->is_gatt_service_valid) {
	instance->OnEncrypted(device);
	} else {
	BTA_GATTC_ServiceSearchRequest(device->conn_id, &kCsisServiceUuid);
	}		}

			/* verify bond */
			if (BTM_IsEncrypted(device->addr, BT_TRANSPORT_LE)) {
			/* if link has been encrypted */
			OnEncrypted(device);
	return;		return;
	}		}

	int result = BTM_SetEncryption(		int result = BTM_SetEncryption(device->addr, BT_TRANSPORT_LE, nullptr,
	evt.remote_bda, BT_TRANSPORT_LE,
	[](const RawAddress* bd_addr, tBT_TRANSPORT transport, void* p_ref_data,
	tBTM_STATUS status) {
	if (instance) instance->OnLeEncryptionComplete(*bd_addr, status);
	},
	nullptr, BTM_BLE_SEC_ENCRYPT);		nullptr, BTM_BLE_SEC_ENCRYPT);
			LOG_INFO("Encryption required. Request result: 0x%02x", result);
	DLOG(INFO) << __func__
	<< " Encryption required. Request result: " << result;
	}		}

	void OnGattDisconnected(const tBTA_GATTC_CLOSE& evt) {		void OnGattDisconnected(const tBTA_GATTC_CLOSE& evt) {
	@@ -1892,17 +1884,15 @@ class CsisClientImpl : public CsisClient {
	}		}

	void OnLeEncryptionComplete(const RawAddress& address, uint8_t status) {		void OnLeEncryptionComplete(const RawAddress& address, uint8_t status) {
	DLOG(INFO) << __func__ << " " << ADDRESS_TO_LOGGABLE_STR(address);		LOG_INFO("%s", ADDRESS_TO_LOGGABLE_CSTR(address));
	auto device = FindDeviceByAddress(address);		auto device = FindDeviceByAddress(address);
	if (device == nullptr) {		if (device == nullptr) {
	LOG(WARNING) << "Skipping unknown device"		LOG_WARN("Skipping unknown device %s", ADDRESS_TO_LOGGABLE_CSTR(address));
	<< ADDRESS_TO_LOGGABLE_STR(address);
	return;		return;
	}		}

	if (status != BTM_SUCCESS) {		if (status != BTM_SUCCESS) {
	LOG(ERROR) << "encryption failed"		LOG_ERROR("encryption failed. status: 0x%02x", status);
	<< " status: " << status;

	BTA_GATTC_Close(device->conn_id);		BTA_GATTC_Close(device->conn_id);
	return;		return;

system/bta/csis/csis_client_test.cc

+18 −9

Original line number	Original line	Diff line number	Diff line
	@@ -460,6 +460,15 @@ class CsisClientTest : public ::testing::Test {
	CsisClient::AddFromStorage(address, storage_buf, true);		CsisClient::AddFromStorage(address, storage_buf, true);
	}		}

			void InjectEncryptionEvent(const RawAddress& test_address, uint16_t conn_id) {
			tBTA_GATTC_ENC_CMPL_CB event_data = {
			.client_if = static_cast<tGATT_IF>(conn_id),
			.remote_bda = test_address,
			};

			gatt_callback(BTA_GATTC_ENC_CMPL_CB_EVT, (tBTA_GATTC*)&event_data);
			}

	void InjectConnectedEvent(const RawAddress& address, uint16_t conn_id) {		void InjectConnectedEvent(const RawAddress& address, uint16_t conn_id) {
	tBTA_GATTC_OPEN event_data = {		tBTA_GATTC_OPEN event_data = {
	.status = GATT_SUCCESS,		.status = GATT_SUCCESS,
	@@ -526,17 +535,17 @@ class CsisClientTest : public ::testing::Test {
	gatt_callback(BTA_GATTC_CLOSE_EVT, (tBTA_GATTC*)&event_data);		gatt_callback(BTA_GATTC_CLOSE_EVT, (tBTA_GATTC*)&event_data);
	}		}

	void SetEncryptionResult(const RawAddress& address, bool success) {		void SetEncryptionResult(const RawAddress& address, uint16_t conn_id,
	ON_CALL(btm_interface, GetSecurityFlagsByTransport(address, NotNull(), _))		bool success) {
	.WillByDefault(DoAll(SetArgPointee<1>(0), Return(true)));		ON_CALL(btm_interface, BTM_IsEncrypted(address, _))
	EXPECT_CALL(btm_interface,		.WillByDefault(DoAll(Return(success)));
	SetEncryption(address, _, NotNull(), _, BTM_BLE_SEC_ENCRYPT))
	.WillOnce(Invoke(		ON_CALL(btm_interface, SetEncryption(address, _, _, _, _))
	[&success](const RawAddress& bd_addr, tBT_TRANSPORT transport,		.WillByDefault(
			Invoke([&](const RawAddress& bd_addr, tBT_TRANSPORT transport,
	tBTM_SEC_CALLBACK* p_callback, void* p_ref_data,		tBTM_SEC_CALLBACK* p_callback, void* p_ref_data,
	tBTM_BLE_SEC_ACT sec_act) -> tBTM_STATUS {		tBTM_BLE_SEC_ACT sec_act) -> tBTM_STATUS {
	p_callback(&bd_addr, transport, p_ref_data,		InjectEncryptionEvent(bd_addr, conn_id);
	success ? BTM_SUCCESS : BTM_FAILED_ON_SECURITY);
	return BTM_SUCCESS;		return BTM_SUCCESS;
	}));		}));
	}		}

system/bta/has/has_client.cc

+4 −16

Original line number	Original line	Diff line number	Diff line
	@@ -1874,25 +1874,13 @@ class HasClientImpl : public HasClient {
	/* verify bond */		/* verify bond */
	if (BTM_IsEncrypted(device->addr, BT_TRANSPORT_LE)) {		if (BTM_IsEncrypted(device->addr, BT_TRANSPORT_LE)) {
	/* if link has been encrypted */		/* if link has been encrypted */
	if (device->isGattServiceValid()) {		OnEncrypted(*device);
	instance->OnEncrypted(*device);
	} else {
	BTA_GATTC_ServiceSearchRequest(device->conn_id,
	&kUuidHearingAccessService);
	}
	return;		return;
	}		}

	int result = BTM_SetEncryption(		int result = BTM_SetEncryption(device->addr, BT_TRANSPORT_LE, nullptr,
	evt.remote_bda, BT_TRANSPORT_LE,
	[](const RawAddress* bd_addr, tBT_TRANSPORT transport, void* p_ref_data,
	tBTM_STATUS status) {
	if (instance)
	instance->OnLeEncryptionComplete(*bd_addr, status == BTM_SUCCESS);
	},
	nullptr, BTM_BLE_SEC_ENCRYPT);		nullptr, BTM_BLE_SEC_ENCRYPT);
			LOG_INFO("Encryption required. Request result: 0x%02x", result);
	DLOG(INFO) << __func__ << ": Encryption request result: " << result;
	}		}

	void OnGattDisconnected(const tBTA_GATTC_CLOSE& evt) {		void OnGattDisconnected(const tBTA_GATTC_CLOSE& evt) {

system/bta/has/has_client_test.cc

+20 −17

Original line number	Original line	Diff line number	Diff line
	@@ -654,6 +654,15 @@ class HasClientTestBase : public ::testing::Test {

	encryption_result = true;		encryption_result = true;

			ON_CALL(btm_interface, SetEncryption(_, _, _, _, _))
			.WillByDefault(
			Invoke([this](const RawAddress& bd_addr, tBT_TRANSPORT transport,
			tBTM_SEC_CALLBACK* p_callback, void* p_ref_data,
			tBTM_BLE_SEC_ACT sec_act) -> tBTM_STATUS {
			InjectEncryptionEvent(bd_addr);
			return BTM_SUCCESS;
			}));

	MockCsisClient::SetMockInstanceForTesting(&mock_csis_client_module_);		MockCsisClient::SetMockInstanceForTesting(&mock_csis_client_module_);
	ON_CALL(mock_csis_client_module_, Get())		ON_CALL(mock_csis_client_module_, Get())
	.WillByDefault(Return(&mock_csis_client_module_));		.WillByDefault(Return(&mock_csis_client_module_));
	@@ -868,26 +877,20 @@ class HasClientTestBase : public ::testing::Test {
	gatt_callback(BTA_GATTC_NOTIF_EVT, (tBTA_GATTC*)&event_data);		gatt_callback(BTA_GATTC_NOTIF_EVT, (tBTA_GATTC*)&event_data);
	}		}

			void InjectEncryptionEvent(const RawAddress& test_address) {
			tBTA_GATTC_ENC_CMPL_CB event_data = {
			.client_if = static_cast<tGATT_IF>(GetTestConnId(test_address)),
			.remote_bda = test_address,
			};

			gatt_callback(BTA_GATTC_ENC_CMPL_CB_EVT, (tBTA_GATTC*)&event_data);
			}

	void SetEncryptionResult(const RawAddress& address, bool success) {		void SetEncryptionResult(const RawAddress& address, bool success) {
	encryption_result = success;		encryption_result = success;

	ON_CALL(btm_interface, BTM_IsEncrypted(address, _))		ON_CALL(btm_interface, BTM_IsEncrypted(address, _))
	.WillByDefault(Return(success));		.WillByDefault(DoAll(Return(encryption_result)));
	ON_CALL(btm_interface, GetSecurityFlagsByTransport(address, NotNull(), _))
	.WillByDefault(
	DoAll(SetArgPointee<1>(success ? BTM_SEC_FLAG_ENCRYPTED : 0),
	Return(true)));
	if (!success) {
	EXPECT_CALL(btm_interface,
	SetEncryption(address, _, NotNull(), _, BTM_BLE_SEC_ENCRYPT))
	.WillOnce(Invoke(
	[success](const RawAddress& bd_addr, tBT_TRANSPORT transport,
	tBTM_SEC_CALLBACK* p_callback, void* p_ref_data,
	tBTM_BLE_SEC_ACT sec_act) -> tBTM_STATUS {
	p_callback(&bd_addr, transport, p_ref_data,
	success ? BTM_SUCCESS : BTM_FAILED_ON_SECURITY);
	return BTM_SUCCESS;
	}));
	}
	}		}

	void InjectNotifyReadPresetResponse(uint16_t conn_id,		void InjectNotifyReadPresetResponse(uint16_t conn_id,