From 4354abb3ed1d0f91195c10eaab831f909a542d3c Mon Sep 17 00:00:00 2001 From: Jakub Pawlowski Date: Fri, 24 Jul 2020 12:58:56 +0200 Subject: [PATCH] Fix address passing when we accept incoming connection Tag: #gd-refactor Bug: 155399771 Test: gd/cert/run --host LeSecurityTest Change-Id: I21ceb49fe1b69e447e3d2e282db5d02b7a0c1bfe --- gd/hci/acl_manager/le_acl_connection.h | 4 ++ gd/hci/acl_manager/le_impl.h | 13 +++++- gd/hci/le_advertising_manager.cc | 31 ++++++++++---- gd/hci/le_advertising_manager.h | 4 ++ gd/hci/le_advertising_manager_mock.h | 60 +++++++++++++++++++++++++++ gd/l2cap/le/internal/link_manager.cc | 10 +++++ gd/l2cap/le/internal/link_manager.h | 24 ++++++++--- gd/l2cap/le/internal/link_manager_test.cc | 68 +++++++++++++++++++++++++------ gd/l2cap/le/l2cap_le_module.cc | 17 +++++--- 9 files changed, 200 insertions(+), 31 deletions(-) create mode 100644 gd/hci/le_advertising_manager_mock.h diff --git a/gd/hci/acl_manager/le_acl_connection.h b/gd/hci/acl_manager/le_acl_connection.h index 3c4abc266..78ba04c34 100644 --- a/gd/hci/acl_manager/le_acl_connection.h +++ b/gd/hci/acl_manager/le_acl_connection.h @@ -38,6 +38,10 @@ class LeAclConnection : public AclConnection { return local_address_; } + virtual void SetLocalAddress(AddressWithType local_address) { + local_address_ = local_address; + } + virtual AddressWithType GetRemoteAddress() const { return remote_address_; } diff --git a/gd/hci/acl_manager/le_impl.h b/gd/hci/acl_manager/le_impl.h index 5ecbe7d80..6506911bc 100644 --- a/gd/hci/acl_manager/le_impl.h +++ b/gd/hci/acl_manager/le_impl.h @@ -174,7 +174,6 @@ struct le_impl : public bluetooth::hci::LeAddressManagerCallback { auto peer_address_type = connection_complete.GetPeerAddressType(); auto peer_resolvable_address = connection_complete.GetPeerResolvablePrivateAddress(); AddressWithType remote_address(address, peer_address_type); - AddressWithType local_address = le_address_manager_->GetCurrentAddress(); if (!peer_resolvable_address.IsEmpty()) { remote_address = AddressWithType(peer_resolvable_address, AddressType::RANDOM_DEVICE_ADDRESS); } @@ -194,6 +193,17 @@ struct le_impl : public bluetooth::hci::LeAddressManagerCallback { common::Unretained(le_client_callbacks_), remote_address, status)); return; } + + auto role = connection_complete.GetRole(); + AddressWithType local_address; + if (role == hci::Role::MASTER) { + local_address = le_address_manager_->GetCurrentAddress(); + } else { + // when accepting connection, we must obtain the address from the advertiser. + // When we receive "set terminated event", we associate connection handle with advertiser address + local_address = AddressWithType{}; + } + uint16_t conn_interval = connection_complete.GetConnInterval(); uint16_t conn_latency = connection_complete.GetConnLatency(); uint16_t supervision_timeout = connection_complete.GetSupervisionTimeout(); @@ -208,7 +218,6 @@ struct le_impl : public bluetooth::hci::LeAddressManagerCallback { std::forward_as_tuple(remote_address, queue->GetDownEnd(), handler_)); auto& connection_proxy = check_and_get_le_connection(handle); round_robin_scheduler_->Register(RoundRobinScheduler::ConnectionType::LE, handle, queue); - auto role = connection_complete.GetRole(); auto do_disconnect = common::BindOnce(&DisconnectorForLe::handle_disconnect, common::Unretained(disconnector_), handle); std::unique_ptr connection(new LeAclConnection(std::move(queue), le_acl_connection_interface_, diff --git a/gd/hci/le_advertising_manager.cc b/gd/hci/le_advertising_manager.cc index 1ffccc025..59bfd26bc 100644 --- a/gd/hci/le_advertising_manager.cc +++ b/gd/hci/le_advertising_manager.cc @@ -39,6 +39,7 @@ enum class AdvertisingApiType { struct Advertiser { os::Handler* handler; + AddressWithType current_address; common::Callback scan_callback; common::Callback set_terminated_callback; }; @@ -108,6 +109,11 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb return num_instances_; } + void register_set_terminated_callback( + common::ContextualCallback set_terminated_callback) { + set_terminated_callback_ = std::move(set_terminated_callback); + } + void handle_event(LeMetaEventView event) { switch (event.GetSubeventCode()) { case hci::SubeventCode::SCAN_REQUEST_RECEIVED: @@ -135,9 +141,11 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb LOG_INFO("Dropping invalid advertising event"); return; } - registered_handler_->Post(common::BindOnce(set_terminated_callback_, event_view.GetStatus(), - event_view.GetAdvertisingHandle(), - event_view.GetNumCompletedExtendedAdvertisingEvents())); + + AddressWithType advertiser_address = advertising_sets_[event_view.GetAdvertisingHandle()].current_address; + + set_terminated_callback_.InvokeIfNotEmpty( + event_view.GetStatus(), event_view.GetConnectionHandle(), advertiser_address); } AdvertiserId allocate_advertiser() { @@ -175,6 +183,7 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb advertising_sets_[id].scan_callback = scan_callback; advertising_sets_[id].set_terminated_callback = set_terminated_callback; advertising_sets_[id].handler = handler; + advertising_sets_[id].current_address = AddressWithType{}; if (!address_manager_registered) { le_address_manager_->Register(this); @@ -233,8 +242,10 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb hci::LeMultiAdvtSetScanRespBuilder::Create(config.scan_response, id), module_handler_->BindOnce(impl::check_status)); } + + advertising_sets_[id].current_address = le_address_manager_->GetAnotherAddress(); le_advertising_interface_->EnqueueCommand( - hci::LeMultiAdvtSetRandomAddrBuilder::Create(le_address_manager_->GetAnotherAddress().GetAddress(), id), + hci::LeMultiAdvtSetRandomAddrBuilder::Create(advertising_sets_[id].current_address.GetAddress(), id), module_handler_->BindOnce(impl::check_status)); if (!paused) { le_advertising_interface_->EnqueueCommand( @@ -313,9 +324,10 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb module_handler_->BindOnce(impl::check_status)); } + advertising_sets_[id].current_address = le_address_manager_->GetAnotherAddress(); le_advertising_interface_->EnqueueCommand( hci::LeSetExtendedAdvertisingRandomAddressBuilder::Create( - id, le_address_manager_->GetAnotherAddress().GetAddress()), + id, advertising_sets_[id].current_address.GetAddress()), module_handler_->BindOnce(impl::check_status)); if (!config.scan_response.empty()) { le_advertising_interface_->EnqueueCommand( @@ -449,7 +461,7 @@ struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallb } common::Callback scan_callback_; - common::Callback set_terminated_callback_; + common::ContextualCallback set_terminated_callback_; os::Handler* registered_handler_{nullptr}; Module* module_; os::Handler* module_handler_; @@ -566,7 +578,12 @@ AdvertiserId LeAdvertisingManager::ExtendedCreateAdvertiser( } void LeAdvertisingManager::RemoveAdvertiser(AdvertiserId id) { - GetHandler()->Post(common::BindOnce(&impl::remove_advertiser, common::Unretained(pimpl_.get()), id)); + GetHandler()->CallOn(pimpl_.get(), &impl::remove_advertiser, id); +} + +void LeAdvertisingManager::RegisterSetTerminatedCallback( + common::ContextualCallback set_terminated_callback) { + GetHandler()->CallOn(pimpl_.get(), &impl::register_set_terminated_callback, set_terminated_callback); } } // namespace hci diff --git a/gd/hci/le_advertising_manager.h b/gd/hci/le_advertising_manager.h index 08f8ba339..790544fe4 100644 --- a/gd/hci/le_advertising_manager.h +++ b/gd/hci/le_advertising_manager.h @@ -17,6 +17,7 @@ #include +#include "hci/address_with_type.h" #include "hci/hci_packets.h" #include "module.h" @@ -79,6 +80,9 @@ class LeAdvertisingManager : public bluetooth::Module { void RemoveAdvertiser(AdvertiserId id); + virtual void RegisterSetTerminatedCallback( + common::ContextualCallback set_terminated_callback); + static const ModuleFactory Factory; protected: diff --git a/gd/hci/le_advertising_manager_mock.h b/gd/hci/le_advertising_manager_mock.h new file mode 100644 index 000000000..f288dd3e2 --- /dev/null +++ b/gd/hci/le_advertising_manager_mock.h @@ -0,0 +1,60 @@ +/* + * Copyright 2019 The Android Open Source Project + * + * 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. + */ +#pragma once + +#include "hci/le_advertising_manager.h" + +#include + +// Unit test interfaces +namespace bluetooth { +namespace hci { + +struct LeAdvertisingManager::impl : public bluetooth::hci::LeAddressManagerCallback {}; + +namespace testing { + +using hci::AdvertiserId; +using hci::LeAdvertisingManager; + +class MockLeAdvertisingManager : public LeAdvertisingManager { + public: + MOCK_METHOD(size_t, GetNumberOfAdvertisingInstances, (), (const)); + MOCK_METHOD( + AdvertiserId, + CreateAdvertiser, + (const AdvertisingConfig&, + const common::Callback&, + const common::Callback&, + os::Handler*)); + MOCK_METHOD( + AdvertiserId, + ExtendedCreateAdvertiser, + (const ExtendedAdvertisingConfig&, + const common::Callback&, + const common::Callback&, + os::Handler*)); + MOCK_METHOD(void, RemoveAdvertiser, (AdvertiserId)); + MOCK_METHOD( + void, + RegisterSetTerminatedCallback, + (common::ContextualCallback), (override)); + +}; + +} // namespace testing +} // namespace hci +} // namespace bluetooth diff --git a/gd/l2cap/le/internal/link_manager.cc b/gd/l2cap/le/internal/link_manager.cc index e2edcbe6c..e3eb3d796 100644 --- a/gd/l2cap/le/internal/link_manager.cc +++ b/gd/l2cap/le/internal/link_manager.cc @@ -147,6 +147,16 @@ void LinkManager::OnLeConnectFail(hci::AddressWithType address_with_type, hci::E pending_links_.erase(pending_link); } +void LinkManager::OnAdvertisingSetTerminated( + bluetooth::hci::ErrorCode status, uint16_t connection_handle, hci::AddressWithType advertiser_address) { + for (auto& [address, link] : links_) { + if (link.GetAclConnection()->GetHandle() == connection_handle) { + link.GetAclConnection()->SetLocalAddress(advertiser_address); + return; + } + } +} + void LinkManager::OnDisconnect(bluetooth::hci::AddressWithType address_with_type) { auto* link = GetLink(address_with_type); ASSERT_LOG(link != nullptr, "Device %s is disconnected but not in local database", diff --git a/gd/l2cap/le/internal/link_manager.h b/gd/l2cap/le/internal/link_manager.h index 0bcca9436..b51656385 100644 --- a/gd/l2cap/le/internal/link_manager.h +++ b/gd/l2cap/le/internal/link_manager.h @@ -25,6 +25,7 @@ #include "hci/acl_manager/le_acl_connection.h" #include "hci/address.h" #include "hci/address_with_type.h" +#include "hci/le_advertising_manager.h" #include "l2cap/internal/parameter_provider.h" #include "l2cap/internal/scheduler.h" #include "l2cap/le/fixed_channel_manager.h" @@ -39,12 +40,22 @@ namespace internal { class LinkManager : public hci::acl_manager::LeConnectionCallbacks { public: - LinkManager(os::Handler* l2cap_handler, hci::AclManager* acl_manager, FixedChannelServiceManagerImpl* service_manager, - DynamicChannelServiceManagerImpl* dynamic_service_manager, - l2cap::internal::ParameterProvider* parameter_provider) - : l2cap_handler_(l2cap_handler), acl_manager_(acl_manager), fixed_channel_service_manager_(service_manager), - dynamic_channel_service_manager_(dynamic_service_manager), parameter_provider_(parameter_provider) { + LinkManager( + os::Handler* l2cap_handler, + hci::AclManager* acl_manager, + hci::LeAdvertisingManager* le_advertising_manager, + FixedChannelServiceManagerImpl* service_manager, + DynamicChannelServiceManagerImpl* dynamic_service_manager, + l2cap::internal::ParameterProvider* parameter_provider) + : l2cap_handler_(l2cap_handler), + acl_manager_(acl_manager), + le_advertising_manager_(le_advertising_manager), + fixed_channel_service_manager_(service_manager), + dynamic_channel_service_manager_(dynamic_service_manager), + parameter_provider_(parameter_provider) { acl_manager_->RegisterLeCallbacks(this, l2cap_handler_); + le_advertising_manager_->RegisterSetTerminatedCallback( + l2cap_handler->BindOn(this, &LinkManager::OnAdvertisingSetTerminated)); } struct PendingFixedChannelConnection { @@ -62,6 +73,8 @@ class LinkManager : public hci::acl_manager::LeConnectionCallbacks { void OnLeConnectSuccess(hci::AddressWithType connecting_address_with_type, std::unique_ptr acl_connection) override; void OnLeConnectFail(hci::AddressWithType address_with_type, hci::ErrorCode reason) override; + void OnAdvertisingSetTerminated( + bluetooth::hci::ErrorCode status, uint16_t connnection_handle, hci::AddressWithType advertiser_address); // FixedChannelManager methods @@ -79,6 +92,7 @@ class LinkManager : public hci::acl_manager::LeConnectionCallbacks { // Dependencies os::Handler* l2cap_handler_; hci::AclManager* acl_manager_; + hci::LeAdvertisingManager* le_advertising_manager_; FixedChannelServiceManagerImpl* fixed_channel_service_manager_; DynamicChannelServiceManagerImpl* dynamic_channel_service_manager_; l2cap::internal::ParameterProvider* parameter_provider_; diff --git a/gd/l2cap/le/internal/link_manager_test.cc b/gd/l2cap/le/internal/link_manager_test.cc index dd53aab84..0cb928cf0 100644 --- a/gd/l2cap/le/internal/link_manager_test.cc +++ b/gd/l2cap/le/internal/link_manager_test.cc @@ -23,6 +23,7 @@ #include "common/testing/bind_test_util.h" #include "hci/acl_manager_mock.h" #include "hci/address.h" +#include "hci/le_advertising_manager_mock.h" #include "l2cap/cid.h" #include "l2cap/internal/parameter_provider_mock.h" #include "l2cap/le/fixed_channel_manager.h" @@ -42,6 +43,7 @@ namespace { using hci::testing::MockAclManager; using hci::testing::MockLeAclConnection; +using hci::testing::MockLeAdvertisingManager; using l2cap::internal::testing::MockParameterProvider; using ::testing::_; // Matcher to any value using ::testing::ByMove; @@ -91,6 +93,7 @@ class L2capLeLinkManagerTest : public ::testing::Test { TEST_F(L2capLeLinkManagerTest, connect_fixed_channel_service_without_acl) { MockFixedChannelServiceManagerImpl mock_le_fixed_channel_service_manager; MockAclManager mock_acl_manager; + MockLeAdvertisingManager mock_le_advertising_manager; hci::AddressWithType address_with_type({{0x01, 0x02, 0x03, 0x04, 0x05, 0x06}}, hci::AddressType::RANDOM_DEVICE_ADDRESS); @@ -99,8 +102,14 @@ TEST_F(L2capLeLinkManagerTest, connect_fixed_channel_service_without_acl) { os::Handler* hci_callback_handler = nullptr; EXPECT_CALL(mock_acl_manager, RegisterLeCallbacks(_, _)) .WillOnce(DoAll(SaveArg<0>(&hci_le_connection_callbacks), SaveArg<1>(&hci_callback_handler))); - LinkManager le_link_manager(l2cap_handler_, &mock_acl_manager, &mock_le_fixed_channel_service_manager, nullptr, - mock_parameter_provider_); + EXPECT_CALL(mock_le_advertising_manager, RegisterSetTerminatedCallback(_)); + LinkManager le_link_manager( + l2cap_handler_, + &mock_acl_manager, + &mock_le_advertising_manager, + &mock_le_fixed_channel_service_manager, + nullptr, + mock_parameter_provider_); EXPECT_EQ(hci_le_connection_callbacks, &le_link_manager); EXPECT_EQ(hci_callback_handler, l2cap_handler_); @@ -190,6 +199,7 @@ TEST_F(L2capLeLinkManagerTest, connect_fixed_channel_service_without_acl) { TEST_F(L2capLeLinkManagerTest, connect_fixed_channel_service_without_acl_with_no_service) { MockFixedChannelServiceManagerImpl mock_le_fixed_channel_service_manager; MockAclManager mock_acl_manager; + MockLeAdvertisingManager mock_le_advertising_manager; hci::AddressWithType address_with_type({{0x01, 0x02, 0x03, 0x04, 0x05, 0x06}}, hci::AddressType::PUBLIC_DEVICE_ADDRESS); @@ -198,8 +208,14 @@ TEST_F(L2capLeLinkManagerTest, connect_fixed_channel_service_without_acl_with_no os::Handler* hci_callback_handler = nullptr; EXPECT_CALL(mock_acl_manager, RegisterLeCallbacks(_, _)) .WillOnce(DoAll(SaveArg<0>(&hci_le_connection_callbacks), SaveArg<1>(&hci_callback_handler))); - LinkManager le_link_manager(l2cap_handler_, &mock_acl_manager, &mock_le_fixed_channel_service_manager, nullptr, - mock_parameter_provider_); + EXPECT_CALL(mock_le_advertising_manager, RegisterSetTerminatedCallback(_)); + LinkManager le_link_manager( + l2cap_handler_, + &mock_acl_manager, + &mock_le_advertising_manager, + &mock_le_fixed_channel_service_manager, + nullptr, + mock_parameter_provider_); EXPECT_EQ(hci_le_connection_callbacks, &le_link_manager); EXPECT_EQ(hci_callback_handler, l2cap_handler_); @@ -223,6 +239,7 @@ TEST_F(L2capLeLinkManagerTest, connect_fixed_channel_service_without_acl_with_no TEST_F(L2capLeLinkManagerTest, connect_fixed_channel_service_without_acl_with_hci_failure) { MockFixedChannelServiceManagerImpl mock_le_fixed_channel_service_manager; MockAclManager mock_acl_manager; + MockLeAdvertisingManager mock_le_advertising_manager; hci::AddressWithType address_with_type({{0x01, 0x02, 0x03, 0x04, 0x05, 0x06}}, hci::AddressType::RANDOM_DEVICE_ADDRESS); @@ -231,8 +248,14 @@ TEST_F(L2capLeLinkManagerTest, connect_fixed_channel_service_without_acl_with_hc os::Handler* hci_callback_handler = nullptr; EXPECT_CALL(mock_acl_manager, RegisterLeCallbacks(_, _)) .WillOnce(DoAll(SaveArg<0>(&hci_le_connection_callbacks), SaveArg<1>(&hci_callback_handler))); - LinkManager le_link_manager(l2cap_handler_, &mock_acl_manager, &mock_le_fixed_channel_service_manager, nullptr, - mock_parameter_provider_); + EXPECT_CALL(mock_le_advertising_manager, RegisterSetTerminatedCallback(_)); + LinkManager le_link_manager( + l2cap_handler_, + &mock_acl_manager, + &mock_le_advertising_manager, + &mock_le_fixed_channel_service_manager, + nullptr, + mock_parameter_provider_); EXPECT_EQ(hci_le_connection_callbacks, &le_link_manager); EXPECT_EQ(hci_callback_handler, l2cap_handler_); @@ -267,6 +290,7 @@ TEST_F(L2capLeLinkManagerTest, not_acquiring_channels_should_disconnect_acl_afte .WillRepeatedly(Return(kTestIdleDisconnectTimeoutShort)); MockFixedChannelServiceManagerImpl mock_le_fixed_channel_service_manager; MockAclManager mock_acl_manager; + MockLeAdvertisingManager mock_le_advertising_manager; hci::AddressWithType address_with_type({{0x01, 0x02, 0x03, 0x04, 0x05, 0x06}}, hci::AddressType::RANDOM_DEVICE_ADDRESS); @@ -275,8 +299,14 @@ TEST_F(L2capLeLinkManagerTest, not_acquiring_channels_should_disconnect_acl_afte os::Handler* hci_callback_handler = nullptr; EXPECT_CALL(mock_acl_manager, RegisterLeCallbacks(_, _)) .WillOnce(DoAll(SaveArg<0>(&hci_le_connection_callbacks), SaveArg<1>(&hci_callback_handler))); - LinkManager le_link_manager(l2cap_handler_, &mock_acl_manager, &mock_le_fixed_channel_service_manager, nullptr, - mock_parameter_provider_); + EXPECT_CALL(mock_le_advertising_manager, RegisterSetTerminatedCallback(_)); + LinkManager le_link_manager( + l2cap_handler_, + &mock_acl_manager, + &mock_le_advertising_manager, + &mock_le_fixed_channel_service_manager, + nullptr, + mock_parameter_provider_); EXPECT_EQ(hci_le_connection_callbacks, &le_link_manager); EXPECT_EQ(hci_callback_handler, l2cap_handler_); @@ -352,6 +382,7 @@ TEST_F(L2capLeLinkManagerTest, acquiring_channels_should_not_disconnect_acl_afte .WillRepeatedly(Return(kTestIdleDisconnectTimeoutShort)); MockFixedChannelServiceManagerImpl mock_le_fixed_channel_service_manager; MockAclManager mock_acl_manager; + MockLeAdvertisingManager mock_le_advertising_manager; hci::AddressWithType address_with_type({{0x01, 0x02, 0x03, 0x04, 0x05, 0x06}}, hci::AddressType::RANDOM_DEVICE_ADDRESS); @@ -360,8 +391,14 @@ TEST_F(L2capLeLinkManagerTest, acquiring_channels_should_not_disconnect_acl_afte os::Handler* hci_callback_handler = nullptr; EXPECT_CALL(mock_acl_manager, RegisterLeCallbacks(_, _)) .WillOnce(DoAll(SaveArg<0>(&hci_le_connection_callbacks), SaveArg<1>(&hci_callback_handler))); - LinkManager le_link_manager(l2cap_handler_, &mock_acl_manager, &mock_le_fixed_channel_service_manager, nullptr, - mock_parameter_provider_); + EXPECT_CALL(mock_le_advertising_manager, RegisterSetTerminatedCallback(_)); + LinkManager le_link_manager( + l2cap_handler_, + &mock_acl_manager, + &mock_le_advertising_manager, + &mock_le_fixed_channel_service_manager, + nullptr, + mock_parameter_provider_); EXPECT_EQ(hci_le_connection_callbacks, &le_link_manager); EXPECT_EQ(hci_callback_handler, l2cap_handler_); @@ -439,6 +476,7 @@ TEST_F(L2capLeLinkManagerTest, acquiring_and_releasing_channels_should_eventuall .WillRepeatedly(Return(kTestIdleDisconnectTimeoutShort)); MockFixedChannelServiceManagerImpl mock_le_fixed_channel_service_manager; MockAclManager mock_acl_manager; + MockLeAdvertisingManager mock_le_advertising_manager; hci::AddressWithType address_with_type({{0x01, 0x02, 0x03, 0x04, 0x05, 0x06}}, hci::AddressType::PUBLIC_IDENTITY_ADDRESS); @@ -447,8 +485,14 @@ TEST_F(L2capLeLinkManagerTest, acquiring_and_releasing_channels_should_eventuall os::Handler* hci_callback_handler = nullptr; EXPECT_CALL(mock_acl_manager, RegisterLeCallbacks(_, _)) .WillOnce(DoAll(SaveArg<0>(&hci_le_connection_callbacks), SaveArg<1>(&hci_callback_handler))); - LinkManager le_link_manager(l2cap_handler_, &mock_acl_manager, &mock_le_fixed_channel_service_manager, nullptr, - mock_parameter_provider_); + EXPECT_CALL(mock_le_advertising_manager, RegisterSetTerminatedCallback(_)); + LinkManager le_link_manager( + l2cap_handler_, + &mock_acl_manager, + &mock_le_advertising_manager, + &mock_le_fixed_channel_service_manager, + nullptr, + mock_parameter_provider_); EXPECT_EQ(hci_le_connection_callbacks, &le_link_manager); EXPECT_EQ(hci_callback_handler, l2cap_handler_); diff --git a/gd/l2cap/le/l2cap_le_module.cc b/gd/l2cap/le/l2cap_le_module.cc index 97855f46c..de967fde2 100644 --- a/gd/l2cap/le/l2cap_le_module.cc +++ b/gd/l2cap/le/l2cap_le_module.cc @@ -36,17 +36,22 @@ const ModuleFactory L2capLeModule::Factory = ModuleFactory([]() { return new L2c static SecurityEnforcementRejectAllImpl default_security_module_impl_; struct L2capLeModule::impl { - impl(os::Handler* l2cap_handler, hci::AclManager* acl_manager) - : l2cap_handler_(l2cap_handler), acl_manager_(acl_manager) { + impl(os::Handler* l2cap_handler, hci::AclManager* acl_manager, hci::LeAdvertisingManager* le_advertising_manager) + : l2cap_handler_(l2cap_handler), acl_manager_(acl_manager), le_advertising_manager_(le_advertising_manager) { dynamic_channel_service_manager_impl_.SetSecurityEnforcementInterface(&default_security_module_impl_); } os::Handler* l2cap_handler_; hci::AclManager* acl_manager_; + hci::LeAdvertisingManager* le_advertising_manager_; l2cap::internal::ParameterProvider parameter_provider_; internal::FixedChannelServiceManagerImpl fixed_channel_service_manager_impl_{l2cap_handler_}; internal::DynamicChannelServiceManagerImpl dynamic_channel_service_manager_impl_{l2cap_handler_}; - internal::LinkManager link_manager_{l2cap_handler_, acl_manager_, &fixed_channel_service_manager_impl_, - &dynamic_channel_service_manager_impl_, ¶meter_provider_}; + internal::LinkManager link_manager_{l2cap_handler_, + acl_manager_, + le_advertising_manager_, + &fixed_channel_service_manager_impl_, + &dynamic_channel_service_manager_impl_, + ¶meter_provider_}; }; L2capLeModule::L2capLeModule() {} @@ -54,10 +59,12 @@ L2capLeModule::~L2capLeModule() {} void L2capLeModule::ListDependencies(ModuleList* list) { list->add(); + list->add(); } void L2capLeModule::Start() { - pimpl_ = std::make_unique(GetHandler(), GetDependency()); + pimpl_ = std::make_unique( + GetHandler(), GetDependency(), GetDependency()); } void L2capLeModule::Stop() { -- 2.11.0