Merge "gd: implement APIs of Advertising for Legacy" (11f82043) · Commits · e / os / android_packages_modules_Bluetooth

system/gd/hci/le_advertising_manager.cc

+44 −4

Original line number	Diff line number	Diff line
		@@ -451,7 +451,18 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb
		void set_parameters(AdvertiserId advertiser_id, ExtendedAdvertisingConfig config) {
		switch (advertising_api_type_) {
		case (AdvertisingApiType::LEGACY): {
		// TODO
		le_advertising_interface_->EnqueueCommand(
		hci::LeSetAdvertisingParametersBuilder::Create(
		config.interval_min,
		config.interval_max,
		config.advertising_type,
		config.own_address_type,
		config.peer_address_type,
		config.peer_address,
		config.channel_map,
		config.filter_policy),
		module_handler_->BindOnceOn(
		this, &impl::check_status_with_id<LeSetAdvertisingParametersCompleteView>, advertiser_id));
		} break;
		case (AdvertisingApiType::ANDROID_HCI): {
		// TODO
		@@ -534,7 +545,17 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb
		void set_data(AdvertiserId advertiser_id, bool set_scan_rsp, std::vector<GapData> data) {
		switch (advertising_api_type_) {
		case (AdvertisingApiType::LEGACY): {
		// TODO
		if (set_scan_rsp) {
		le_advertising_interface_->EnqueueCommand(
		hci::LeSetScanResponseDataBuilder::Create(data),
		module_handler_->BindOnceOn(
		this, &impl::check_status_with_id<LeSetScanResponseDataCompleteView>, advertiser_id));
		} else {
		le_advertising_interface_->EnqueueCommand(
		hci::LeSetAdvertisingDataBuilder::Create(data),
		module_handler_->BindOnceOn(
		this, &impl::check_status_with_id<LeSetAdvertisingDataCompleteView>, advertiser_id));
		}
		} break;
		case (AdvertisingApiType::ANDROID_HCI): {
		// TODO
		@@ -636,7 +657,13 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb

		switch (advertising_api_type_) {
		case (AdvertisingApiType::LEGACY): {
		// TODO
		le_advertising_interface_->EnqueueCommand(
		hci::LeSetAdvertisingEnableBuilder::Create(Enable::DISABLED),
		module_handler_->BindOnceOn(
		this,
		&impl::on_set_advertising_enable_complete<LeSetAdvertisingEnableCompleteView>,
		enable,
		enabled_sets));
		} break;
		case (AdvertisingApiType::ANDROID_HCI): {
		// TODO
		@@ -826,11 +853,20 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb
		return;
		}
		for (EnabledSet enabled_set : enabled_sets) {
		bool started = advertising_sets_[enabled_set.advertising_handle_].started;
		uint8_t id = enabled_set.advertising_handle_;
		if (id == kInvalidHandle) {
		continue;
		}

		if (started) {
		advertising_callbacks_->OnAdvertisingEnabled(id, enable, advertising_status);
		} else {
		int reg_id = id_map_[id];
		advertising_sets_[enabled_set.advertising_handle_].started = true;
		// TODO read tx power
		advertising_callbacks_->OnAdvertisingSetStarted(reg_id, id, 0x00, advertising_status);
		}
		}
		}

		@@ -928,6 +964,10 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb
		OpCode opcode = view.GetCommandOpCode();

		switch (opcode) {
		case OpCode::LE_SET_ADVERTISING_PARAMETERS:
		// TODO read tx power
		advertising_callbacks_->OnAdvertisingParametersUpdated(id, 0x00, advertising_status);
		break;
		case OpCode::LE_SET_ADVERTISING_DATA:
		case OpCode::LE_SET_EXTENDED_ADVERTISING_DATA:
		advertising_callbacks_->OnAdvertisingDataSet(id, advertising_status);

system/gd/hci/le_advertising_manager_test.cc

+135 −3

Original line number	Diff line number	Diff line
		@@ -354,6 +354,55 @@ class LeAdvertisingManagerTest : public ::testing::Test {
		} mock_advertising_callback_;
		};

		class LeAdvertisingAPITest : public LeAdvertisingManagerTest {
		protected:
		void SetUp() override {
		LeAdvertisingManagerTest::SetUp();

		// start advertising set
		ExtendedAdvertisingConfig advertising_config{};
		advertising_config.advertising_type = AdvertisingType::ADV_IND;
		advertising_config.own_address_type = OwnAddressType::PUBLIC_DEVICE_ADDRESS;
		std::vector<GapData> gap_data{};
		GapData data_item{};
		data_item.data_type_ = GapDataType::FLAGS;
		data_item.data_ = {0x34};
		gap_data.push_back(data_item);
		data_item.data_type_ = GapDataType::COMPLETE_LOCAL_NAME;
		data_item.data_ = {'r', 'a', 'n', 'd', 'o', 'm', ' ', 'd', 'e', 'v', 'i', 'c', 'e'};
		gap_data.push_back(data_item);
		advertising_config.advertisement = gap_data;
		advertising_config.scan_response = gap_data;

		auto last_command_future = test_hci_layer_->GetCommandFuture(OpCode::LE_SET_ADVERTISING_ENABLE);
		advertiser_id_ = le_advertising_manager_->ExtendedCreateAdvertiser(
		0x00, advertising_config, scan_callback, set_terminated_callback, client_handler_);
		ASSERT_NE(LeAdvertisingManager::kInvalidId, advertiser_id_);
		EXPECT_CALL(
		mock_advertising_callback_,
		OnAdvertisingSetStarted(0x00, advertiser_id_, 0x00, AdvertisingCallback::AdvertisingStatus::SUCCESS));
		std::vector<OpCode> adv_opcodes = {
		OpCode::LE_SET_ADVERTISING_PARAMETERS,
		OpCode::LE_SET_SCAN_RESPONSE_DATA,
		OpCode::LE_SET_ADVERTISING_DATA,
		OpCode::LE_SET_ADVERTISING_ENABLE,
		};
		auto result = last_command_future.wait_for(std::chrono::duration(std::chrono::milliseconds(100)));
		std::vector<uint8_t> success_vector{static_cast<uint8_t>(ErrorCode::SUCCESS)};
		ASSERT_EQ(std::future_status::ready, result);
		for (size_t i = 0; i < adv_opcodes.size(); i++) {
		auto packet_view = test_hci_layer_->GetCommandPacket(adv_opcodes[i]);
		CommandPacketView command_packet_view = CommandPacketView::Create(packet_view);
		auto command = ConnectionManagementCommandView::Create(AclCommandView::Create(command_packet_view));
		test_hci_layer_->IncomingEvent(
		CommandCompleteBuilder::Create(uint8_t{1}, adv_opcodes[i], std::make_unique<RawBuilder>(success_vector)));
		}
		sync_client_handler();
		}

		AdvertiserId advertiser_id_;
		};

		class LeAndroidHciAdvertisingManagerTest : public LeAdvertisingManagerTest {
		protected:
		void SetUp() override {
		@@ -460,7 +509,8 @@ TEST_F(LeAdvertisingManagerTest, create_advertiser_test) {
		OpCode::LE_SET_ADVERTISING_ENABLE,
		};
		EXPECT_CALL(
		mock_advertising_callback_, OnAdvertisingEnabled(id, true, AdvertisingCallback::AdvertisingStatus::SUCCESS));
		mock_advertising_callback_,
		OnAdvertisingSetStarted(0x00, id, 0x00, AdvertisingCallback::AdvertisingStatus::SUCCESS));

		std::vector<uint8_t> success_vector{static_cast<uint8_t>(ErrorCode::SUCCESS)};
		auto result = last_command_future.wait_for(std::chrono::duration(std::chrono::milliseconds(100)));
		@@ -578,8 +628,32 @@ TEST_F(LeExtendedAdvertisingManagerTest, create_advertiser_test) {
		sync_client_handler();
		}

		TEST_F(LeAdvertisingAPITest, startup_teardown) {}

		TEST_F(LeExtendedAdvertisingAPITest, startup_teardown) {}

		TEST_F(LeAdvertisingAPITest, set_parameter) {
		ExtendedAdvertisingConfig advertising_config{};
		advertising_config.advertising_type = AdvertisingType::ADV_IND;
		advertising_config.own_address_type = OwnAddressType::PUBLIC_DEVICE_ADDRESS;
		std::vector<GapData> gap_data{};
		GapData data_item{};
		data_item.data_type_ = GapDataType::COMPLETE_LOCAL_NAME;
		data_item.data_ = {'r', 'a', 'n', 'd', 'o', 'm', ' ', 'd', 'e', 'v', 'i', 'c', 'e'};
		gap_data.push_back(data_item);
		advertising_config.advertisement = gap_data;
		advertising_config.channel_map = 1;
		le_advertising_manager_->SetParameters(advertiser_id_, advertising_config);
		auto last_command_future = test_hci_layer_->GetCommandFuture(OpCode::LE_SET_ADVERTISING_PARAMETERS);
		auto result = last_command_future.wait_for(std::chrono::duration(std::chrono::milliseconds(100)));
		ASSERT_EQ(std::future_status::ready, result);
		EXPECT_CALL(
		mock_advertising_callback_,
		OnAdvertisingParametersUpdated(advertiser_id_, 0x00, AdvertisingCallback::AdvertisingStatus::SUCCESS));
		test_hci_layer_->IncomingEvent(LeSetAdvertisingParametersCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
		sync_client_handler();
		}

		TEST_F(LeExtendedAdvertisingAPITest, set_parameter) {
		ExtendedAdvertisingConfig advertising_config{};
		advertising_config.advertising_type = AdvertisingType::ADV_IND;
		@@ -605,6 +679,40 @@ TEST_F(LeExtendedAdvertisingAPITest, set_parameter) {
		sync_client_handler();
		}

		TEST_F(LeAdvertisingAPITest, set_data_test) {
		// Set advertising data
		std::vector<GapData> advertising_data{};
		GapData data_item{};
		data_item.data_type_ = GapDataType::TX_POWER_LEVEL;
		data_item.data_ = {0x00};
		advertising_data.push_back(data_item);
		le_advertising_manager_->SetData(advertiser_id_, false, advertising_data);
		auto last_command_future = test_hci_layer_->GetCommandFuture(OpCode::LE_SET_ADVERTISING_DATA);
		auto result = last_command_future.wait_for(std::chrono::duration(std::chrono::milliseconds(100)));
		ASSERT_EQ(std::future_status::ready, result);
		EXPECT_CALL(
		mock_advertising_callback_,
		OnAdvertisingDataSet(advertiser_id_, AdvertisingCallback::AdvertisingStatus::SUCCESS));
		test_hci_layer_->IncomingEvent(LeSetAdvertisingDataCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
		sync_client_handler();

		// Set scan response data
		std::vector<GapData> response_data{};
		GapData data_item2{};
		data_item2.data_type_ = GapDataType::COMPLETE_LOCAL_NAME;
		data_item2.data_ = {'t', 'e', 's', 't', ' ', 'd', 'e', 'v', 'i', 'c', 'e'};
		response_data.push_back(data_item2);
		le_advertising_manager_->SetData(advertiser_id_, true, response_data);
		last_command_future = test_hci_layer_->GetCommandFuture(OpCode::LE_SET_SCAN_RESPONSE_DATA);
		result = last_command_future.wait_for(std::chrono::duration(std::chrono::milliseconds(100)));
		ASSERT_EQ(std::future_status::ready, result);
		EXPECT_CALL(
		mock_advertising_callback_,
		OnScanResponseDataSet(advertiser_id_, AdvertisingCallback::AdvertisingStatus::SUCCESS));
		test_hci_layer_->IncomingEvent(LeSetScanResponseDataCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
		sync_client_handler();
		}

		TEST_F(LeExtendedAdvertisingAPITest, set_data_test) {
		// Set advertising data
		std::vector<GapData> advertising_data{};
		@@ -723,7 +831,7 @@ TEST_F(LeExtendedAdvertisingAPITest, set_scan_response_fragments_test) {
		sync_client_handler();
		}

		TEST_F(LeExtendedAdvertisingAPITest, send_data_with_invalid_ad_structure) {
		TEST_F(LeExtendedAdvertisingAPITest, set_data_with_invalid_ad_structure) {
		// Set advertising data with AD structure that length greater than 251
		std::vector<GapData> advertising_data{};
		GapData data_item{};
		@@ -749,7 +857,7 @@ TEST_F(LeExtendedAdvertisingAPITest, send_data_with_invalid_ad_structure) {
		sync_client_handler();
		}

		TEST_F(LeExtendedAdvertisingAPITest, send_data_with_invalid_length) {
		TEST_F(LeExtendedAdvertisingAPITest, set_data_with_invalid_length) {
		// Set advertising data with data that greater than le_maximum_advertising_data_length_
		std::vector<GapData> advertising_data{};
		for (uint8_t i = 0; i < 10; i++) {
		@@ -776,6 +884,30 @@ TEST_F(LeExtendedAdvertisingAPITest, send_data_with_invalid_length) {
		sync_client_handler();
		}

		TEST_F(LeAdvertisingAPITest, disable_enable_advertiser_test) {
		// disable advertiser
		le_advertising_manager_->EnableAdvertiser(advertiser_id_, false, 0x00, 0x00);
		auto last_command_future = test_hci_layer_->GetCommandFuture(OpCode::LE_SET_ADVERTISING_ENABLE);
		auto result = last_command_future.wait_for(std::chrono::duration(std::chrono::milliseconds(100)));
		ASSERT_EQ(std::future_status::ready, result);
		EXPECT_CALL(
		mock_advertising_callback_,
		OnAdvertisingEnabled(advertiser_id_, false, AdvertisingCallback::AdvertisingStatus::SUCCESS));
		test_hci_layer_->IncomingEvent(LeSetAdvertisingEnableCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
		sync_client_handler();

		// enable advertiser
		le_advertising_manager_->EnableAdvertiser(advertiser_id_, true, 0x00, 0x00);
		last_command_future = test_hci_layer_->GetCommandFuture(OpCode::LE_SET_ADVERTISING_ENABLE);
		result = last_command_future.wait_for(std::chrono::duration(std::chrono::milliseconds(100)));
		ASSERT_EQ(std::future_status::ready, result);
		EXPECT_CALL(
		mock_advertising_callback_,
		OnAdvertisingEnabled(advertiser_id_, true, AdvertisingCallback::AdvertisingStatus::SUCCESS));
		test_hci_layer_->IncomingEvent(LeSetAdvertisingEnableCompleteBuilder::Create(uint8_t{1}, ErrorCode::SUCCESS));
		sync_client_handler();
		}

		TEST_F(LeExtendedAdvertisingAPITest, disable_enable_advertiser_test) {
		// disable advertiser
		le_advertising_manager_->EnableAdvertiser(advertiser_id_, false, 0x00, 0x00);

system/main/shim/hci_layer.cc

+4 −2

Original line number	Diff line number	Diff line
		@@ -266,11 +266,13 @@ static bool subevent_already_registered_in_le_hci_layer(
		case bluetooth::hci::SubeventCode::PHY_UPDATE_COMPLETE:
		case bluetooth::hci::SubeventCode::REMOTE_CONNECTION_PARAMETER_REQUEST:
		return bluetooth::shim::is_gd_acl_enabled() \|\|
		bluetooth::shim::is_gd_l2cap_enabled();
		bluetooth::shim::is_gd_l2cap_enabled() \|\|
		bluetooth::shim::is_gd_advertising_enabled();
		case bluetooth::hci::SubeventCode::ADVERTISING_SET_TERMINATED:
		case bluetooth::hci::SubeventCode::SCAN_REQUEST_RECEIVED:
		return bluetooth::shim::is_gd_acl_enabled() \|\|
		bluetooth::shim::is_gd_l2cap_enabled();
		bluetooth::shim::is_gd_l2cap_enabled() \|\|
		bluetooth::shim::is_gd_advertising_enabled();
		case bluetooth::hci::SubeventCode::ADVERTISING_REPORT:
		case bluetooth::hci::SubeventCode::DIRECTED_ADVERTISING_REPORT:
		case bluetooth::hci::SubeventCode::EXTENDED_ADVERTISING_REPORT: