1 /*
2 * Copyright 2018 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "l2cap/le/internal/link_manager.h"
18
19 #include <future>
20 #include <thread>
21
22 #include "common/bind.h"
23 #include "common/testing/bind_test_util.h"
24 #include "hci/acl_manager_mock.h"
25 #include "hci/address.h"
26 #include "l2cap/cid.h"
27 #include "l2cap/internal/parameter_provider_mock.h"
28 #include "l2cap/le/fixed_channel_manager.h"
29 #include "l2cap/le/internal/fixed_channel_service_impl_mock.h"
30 #include "l2cap/le/internal/fixed_channel_service_manager_impl_mock.h"
31 #include "os/handler.h"
32 #include "os/thread.h"
33
34 #include <gmock/gmock.h>
35 #include <gtest/gtest.h>
36
37 namespace bluetooth {
38 namespace l2cap {
39 namespace le {
40 namespace internal {
41 namespace {
42
43 using hci::testing::MockAclManager;
44 using hci::testing::MockLeAclConnection;
45 using l2cap::internal::testing::MockParameterProvider;
46 using ::testing::_; // Matcher to any value
47 using ::testing::ByMove;
48 using ::testing::DoAll;
49 using testing::MockFixedChannelServiceImpl;
50 using testing::MockFixedChannelServiceManagerImpl;
51 using ::testing::Return;
52 using ::testing::SaveArg;
53
54 constexpr static auto kTestIdleDisconnectTimeoutLong = std::chrono::milliseconds(1000);
55 constexpr static auto kTestIdleDisconnectTimeoutShort = std::chrono::milliseconds(1000);
56
57 class L2capLeLinkManagerTest : public ::testing::Test {
58 public:
SyncHandler(os::Handler * handler)59 static void SyncHandler(os::Handler* handler) {
60 std::promise<void> promise;
61 auto future = promise.get_future();
62 handler->Post(common::BindOnce(&std::promise<void>::set_value, common::Unretained(&promise)));
63 future.wait_for(std::chrono::milliseconds(3));
64 }
65
66 protected:
SetUp()67 void SetUp() override {
68 thread_ = new os::Thread("test_thread", os::Thread::Priority::NORMAL);
69 l2cap_handler_ = new os::Handler(thread_);
70 user_handler_ = new os::Handler(thread_);
71 mock_parameter_provider_ = new MockParameterProvider;
72 EXPECT_CALL(*mock_parameter_provider_, GetLeLinkIdleDisconnectTimeout)
73 .WillRepeatedly(Return(kTestIdleDisconnectTimeoutLong));
74 }
75
TearDown()76 void TearDown() override {
77 delete mock_parameter_provider_;
78 l2cap_handler_->Clear();
79 delete l2cap_handler_;
80 user_handler_->Clear();
81 delete user_handler_;
82 delete thread_;
83 }
84
85 os::Thread* thread_ = nullptr;
86 os::Handler* l2cap_handler_ = nullptr;
87 os::Handler* user_handler_ = nullptr;
88 MockParameterProvider* mock_parameter_provider_ = nullptr;
89 };
90
TEST_F(L2capLeLinkManagerTest,connect_fixed_channel_service_without_acl)91 TEST_F(L2capLeLinkManagerTest, connect_fixed_channel_service_without_acl) {
92 MockFixedChannelServiceManagerImpl mock_le_fixed_channel_service_manager;
93 MockAclManager mock_acl_manager;
94 hci::AddressWithType address_with_type({{0x01, 0x02, 0x03, 0x04, 0x05, 0x06}},
95 hci::AddressType::RANDOM_DEVICE_ADDRESS);
96
97 // Step 1: Verify callback registration with HCI
98 hci::acl_manager::LeConnectionCallbacks* hci_le_connection_callbacks = nullptr;
99 os::Handler* hci_callback_handler = nullptr;
100 EXPECT_CALL(mock_acl_manager, RegisterLeCallbacks(_, _))
101 .WillOnce(DoAll(SaveArg<0>(&hci_le_connection_callbacks), SaveArg<1>(&hci_callback_handler)));
102 LinkManager le_link_manager(
103 l2cap_handler_,
104 &mock_acl_manager,
105 &mock_le_fixed_channel_service_manager,
106 nullptr,
107 mock_parameter_provider_);
108 EXPECT_EQ(hci_le_connection_callbacks, &le_link_manager);
109 EXPECT_EQ(hci_callback_handler, l2cap_handler_);
110
111 // Register fake services
112 MockFixedChannelServiceImpl mock_service_1, mock_service_2;
113 std::vector<std::pair<Cid, FixedChannelServiceImpl*>> results;
114 results.emplace_back(kSmpBrCid, &mock_service_1);
115 results.emplace_back(kConnectionlessCid, &mock_service_2);
116 EXPECT_CALL(mock_le_fixed_channel_service_manager, GetRegisteredServices()).WillRepeatedly(Return(results));
117
118 // Step 2: Connect to fixed channel without ACL connection should trigger ACL connection process
119 EXPECT_CALL(mock_acl_manager, CreateLeConnection(address_with_type, true)).Times(1);
120 LinkManager::PendingFixedChannelConnection pending_fixed_channel_connection{
121 .handler_ = user_handler_,
122 .on_fail_callback_ = common::BindOnce([](FixedChannelManager::ConnectionResult result) { FAIL(); })};
123 le_link_manager.ConnectFixedChannelServices(address_with_type, std::move(pending_fixed_channel_connection));
124
125 // Step 3: ACL connection success event should trigger channel creation for all registered services
126 std::unique_ptr<MockLeAclConnection> acl_connection = std::make_unique<MockLeAclConnection>();
127 EXPECT_CALL(*acl_connection, GetRemoteAddress()).WillRepeatedly(Return(address_with_type));
128 hci::acl_manager::LeConnectionManagementCallbacks* connection_management_callbacks = nullptr;
129 os::Handler* connection_management_handler = nullptr;
130 EXPECT_CALL(*acl_connection, RegisterCallbacks(_, _))
131 .WillOnce(DoAll(SaveArg<0>(&connection_management_callbacks), SaveArg<1>(&connection_management_handler)));
132 std::unique_ptr<FixedChannel> channel_1, channel_2;
133 std::promise<void> promise_1, promise_2;
134 auto future_1 = promise_1.get_future();
135 auto future_2 = promise_2.get_future();
136 EXPECT_CALL(mock_service_1, NotifyChannelCreation(_))
137 .WillOnce([&channel_1, &promise_1](std::unique_ptr<FixedChannel> channel) {
138 channel_1 = std::move(channel);
139 promise_1.set_value();
140 });
141 EXPECT_CALL(mock_service_2, NotifyChannelCreation(_))
142 .WillOnce([&channel_2, &promise_2](std::unique_ptr<FixedChannel> channel) {
143 channel_2 = std::move(channel);
144 promise_2.set_value();
145 });
146 hci_callback_handler->Post(common::BindOnce(&hci::acl_manager::LeConnectionCallbacks::OnLeConnectSuccess,
147 common::Unretained(hci_le_connection_callbacks), address_with_type,
148 std::move(acl_connection)));
149 SyncHandler(hci_callback_handler);
150 connection_management_handler->Post(common::BindOnce(
151 &hci::acl_manager::LeConnectionManagementCallbacks::OnReadRemoteVersionInformationComplete,
152 common::Unretained(connection_management_callbacks),
153 hci::ErrorCode::SUCCESS,
154 0,
155 0,
156 0));
157 auto future_1_status = future_1.wait_for(kTestIdleDisconnectTimeoutShort);
158 EXPECT_EQ(future_1_status, std::future_status::ready);
159 auto future_2_status = future_2.wait_for(kTestIdleDisconnectTimeoutShort);
160 EXPECT_EQ(future_2_status, std::future_status::ready);
161 ASSERT_NE(channel_1, nullptr);
162 ASSERT_NE(channel_2, nullptr);
163
164 // Step 4: Calling ConnectServices() to the same device will not trigger another connection attempt
165 FixedChannelManager::ConnectionResult my_result;
166 LinkManager::PendingFixedChannelConnection pending_fixed_channel_connection_2{
167 .handler_ = user_handler_,
168 .on_fail_callback_ = common::testing::BindLambdaForTesting(
169 [&my_result](FixedChannelManager::ConnectionResult result) { my_result = result; })};
170 le_link_manager.ConnectFixedChannelServices(address_with_type, std::move(pending_fixed_channel_connection_2));
171 SyncHandler(user_handler_);
172 EXPECT_EQ(my_result.connection_result_code,
173 FixedChannelManager::ConnectionResultCode::FAIL_ALL_SERVICES_HAVE_CHANNEL);
174
175 // Step 5: Register new service will cause new channels to be created during ConnectServices()
176 MockFixedChannelServiceImpl mock_service_3;
177 results.emplace_back(kSmpBrCid + 1, &mock_service_3);
178 EXPECT_CALL(mock_le_fixed_channel_service_manager, GetRegisteredServices()).WillRepeatedly(Return(results));
179 LinkManager::PendingFixedChannelConnection pending_fixed_channel_connection_3{
180 .handler_ = user_handler_,
181 .on_fail_callback_ = common::BindOnce([](FixedChannelManager::ConnectionResult result) { FAIL(); })};
182 std::unique_ptr<FixedChannel> channel_3;
183 std::promise<void> promise_3;
184 auto future_3 = promise_3.get_future();
185 EXPECT_CALL(mock_service_3, NotifyChannelCreation(_))
186 .WillOnce([&channel_3, &promise_3](std::unique_ptr<FixedChannel> channel) {
187 channel_3 = std::move(channel);
188 promise_3.set_value();
189 });
190 le_link_manager.ConnectFixedChannelServices(address_with_type, std::move(pending_fixed_channel_connection_3));
191 auto future_3_status = future_3.wait_for(kTestIdleDisconnectTimeoutShort);
192 EXPECT_EQ(future_3_status, std::future_status::ready);
193 EXPECT_NE(channel_3, nullptr);
194
195 connection_management_handler->Post(common::BindOnce(
196 &hci::acl_manager::LeConnectionManagementCallbacks::OnDisconnection,
197 common::Unretained(connection_management_callbacks), hci::ErrorCode::REMOTE_USER_TERMINATED_CONNECTION));
198 SyncHandler(connection_management_handler);
199 }
200
TEST_F(L2capLeLinkManagerTest,connect_fixed_channel_service_without_acl_with_no_service)201 TEST_F(L2capLeLinkManagerTest, connect_fixed_channel_service_without_acl_with_no_service) {
202 MockFixedChannelServiceManagerImpl mock_le_fixed_channel_service_manager;
203 MockAclManager mock_acl_manager;
204 hci::AddressWithType address_with_type({{0x01, 0x02, 0x03, 0x04, 0x05, 0x06}},
205 hci::AddressType::PUBLIC_DEVICE_ADDRESS);
206
207 // Step 1: Verify callback registration with HCI
208 hci::acl_manager::LeConnectionCallbacks* hci_le_connection_callbacks = nullptr;
209 os::Handler* hci_callback_handler = nullptr;
210 EXPECT_CALL(mock_acl_manager, RegisterLeCallbacks(_, _))
211 .WillOnce(DoAll(SaveArg<0>(&hci_le_connection_callbacks), SaveArg<1>(&hci_callback_handler)));
212 LinkManager le_link_manager(
213 l2cap_handler_,
214 &mock_acl_manager,
215 &mock_le_fixed_channel_service_manager,
216 nullptr,
217 mock_parameter_provider_);
218 EXPECT_EQ(hci_le_connection_callbacks, &le_link_manager);
219 EXPECT_EQ(hci_callback_handler, l2cap_handler_);
220
221 // Make sure no service is registered
222 std::vector<std::pair<Cid, FixedChannelServiceImpl*>> results;
223 EXPECT_CALL(mock_le_fixed_channel_service_manager, GetRegisteredServices()).WillRepeatedly(Return(results));
224
225 // Step 2: Connect to fixed channel without any service registered will result in failure
226 EXPECT_CALL(mock_acl_manager, CreateLeConnection(address_with_type, true)).Times(0);
227 FixedChannelManager::ConnectionResult my_result;
228 LinkManager::PendingFixedChannelConnection pending_fixed_channel_connection{
229 .handler_ = user_handler_,
230 .on_fail_callback_ = common::testing::BindLambdaForTesting(
231 [&my_result](FixedChannelManager::ConnectionResult result) { my_result = result; })};
232 le_link_manager.ConnectFixedChannelServices(address_with_type, std::move(pending_fixed_channel_connection));
233 SyncHandler(user_handler_);
234 EXPECT_EQ(my_result.connection_result_code, FixedChannelManager::ConnectionResultCode::FAIL_NO_SERVICE_REGISTERED);
235
236 }
237
TEST_F(L2capLeLinkManagerTest,connect_fixed_channel_service_without_acl_with_hci_failure)238 TEST_F(L2capLeLinkManagerTest, connect_fixed_channel_service_without_acl_with_hci_failure) {
239 MockFixedChannelServiceManagerImpl mock_le_fixed_channel_service_manager;
240 MockAclManager mock_acl_manager;
241 hci::AddressWithType address_with_type({{0x01, 0x02, 0x03, 0x04, 0x05, 0x06}},
242 hci::AddressType::RANDOM_DEVICE_ADDRESS);
243
244 // Step 1: Verify callback registration with HCI
245 hci::acl_manager::LeConnectionCallbacks* hci_le_connection_callbacks = nullptr;
246 os::Handler* hci_callback_handler = nullptr;
247 EXPECT_CALL(mock_acl_manager, RegisterLeCallbacks(_, _))
248 .WillOnce(DoAll(SaveArg<0>(&hci_le_connection_callbacks), SaveArg<1>(&hci_callback_handler)));
249 LinkManager le_link_manager(
250 l2cap_handler_,
251 &mock_acl_manager,
252 &mock_le_fixed_channel_service_manager,
253 nullptr,
254 mock_parameter_provider_);
255 EXPECT_EQ(hci_le_connection_callbacks, &le_link_manager);
256 EXPECT_EQ(hci_callback_handler, l2cap_handler_);
257
258 // Register fake services
259 MockFixedChannelServiceImpl mock_service_1;
260 std::vector<std::pair<Cid, FixedChannelServiceImpl*>> results;
261 results.emplace_back(kSmpBrCid, &mock_service_1);
262 EXPECT_CALL(mock_le_fixed_channel_service_manager, GetRegisteredServices()).WillRepeatedly(Return(results));
263
264 // Step 2: Connect to fixed channel without ACL connection should trigger ACL connection process
265 EXPECT_CALL(mock_acl_manager, CreateLeConnection(address_with_type, true)).Times(1);
266 FixedChannelManager::ConnectionResult my_result;
267 LinkManager::PendingFixedChannelConnection pending_fixed_channel_connection{
268 .handler_ = user_handler_,
269 .on_fail_callback_ = common::testing::BindLambdaForTesting(
270 [&my_result](FixedChannelManager::ConnectionResult result) { my_result = result; })};
271 le_link_manager.ConnectFixedChannelServices(address_with_type, std::move(pending_fixed_channel_connection));
272
273 // Step 3: ACL connection failure event should trigger connection failure callback
274 EXPECT_CALL(mock_service_1, NotifyChannelCreation(_)).Times(0);
275 hci_callback_handler->Post(common::BindOnce(
276 &hci::acl_manager::LeConnectionCallbacks::OnLeConnectFail,
277 common::Unretained(hci_le_connection_callbacks),
278 address_with_type,
279 hci::ErrorCode::PAGE_TIMEOUT));
280 SyncHandler(hci_callback_handler);
281 SyncHandler(user_handler_);
282 EXPECT_EQ(my_result.connection_result_code, FixedChannelManager::ConnectionResultCode::FAIL_HCI_ERROR);
283 EXPECT_EQ(my_result.hci_error, hci::ErrorCode::PAGE_TIMEOUT);
284 }
285
TEST_F(L2capLeLinkManagerTest,not_acquiring_channels_should_disconnect_acl_after_timeout)286 TEST_F(L2capLeLinkManagerTest, not_acquiring_channels_should_disconnect_acl_after_timeout) {
287 EXPECT_CALL(*mock_parameter_provider_, GetLeLinkIdleDisconnectTimeout)
288 .WillRepeatedly(Return(kTestIdleDisconnectTimeoutShort));
289 MockFixedChannelServiceManagerImpl mock_le_fixed_channel_service_manager;
290 MockAclManager mock_acl_manager;
291 hci::AddressWithType address_with_type({{0x01, 0x02, 0x03, 0x04, 0x05, 0x06}},
292 hci::AddressType::RANDOM_DEVICE_ADDRESS);
293
294 // Step 1: Verify callback registration with HCI
295 hci::acl_manager::LeConnectionCallbacks* hci_le_connection_callbacks = nullptr;
296 os::Handler* hci_callback_handler = nullptr;
297 EXPECT_CALL(mock_acl_manager, RegisterLeCallbacks(_, _))
298 .WillOnce(DoAll(SaveArg<0>(&hci_le_connection_callbacks), SaveArg<1>(&hci_callback_handler)));
299 LinkManager le_link_manager(
300 l2cap_handler_,
301 &mock_acl_manager,
302 &mock_le_fixed_channel_service_manager,
303 nullptr,
304 mock_parameter_provider_);
305 EXPECT_EQ(hci_le_connection_callbacks, &le_link_manager);
306 EXPECT_EQ(hci_callback_handler, l2cap_handler_);
307
308 // Register fake services
309 MockFixedChannelServiceImpl mock_service_1, mock_service_2;
310 std::vector<std::pair<Cid, FixedChannelServiceImpl*>> results;
311 results.emplace_back(kSmpBrCid, &mock_service_1);
312 results.emplace_back(kConnectionlessCid, &mock_service_2);
313 EXPECT_CALL(mock_le_fixed_channel_service_manager, GetRegisteredServices()).WillRepeatedly(Return(results));
314
315 // Step 2: Connect to fixed channel without ACL connection should trigger ACL connection process
316 EXPECT_CALL(mock_acl_manager, CreateLeConnection(address_with_type, true)).Times(1);
317 LinkManager::PendingFixedChannelConnection pending_fixed_channel_connection{
318 .handler_ = user_handler_,
319 .on_fail_callback_ = common::BindOnce([](FixedChannelManager::ConnectionResult result) { FAIL(); })};
320 le_link_manager.ConnectFixedChannelServices(address_with_type, std::move(pending_fixed_channel_connection));
321
322 // Step 3: ACL connection success event should trigger channel creation for all registered services
323 auto* raw_acl_connection = new MockLeAclConnection();
324 std::unique_ptr<MockLeAclConnection> acl_connection(raw_acl_connection);
325 EXPECT_CALL(*acl_connection, GetRemoteAddress()).WillRepeatedly(Return(address_with_type));
326 hci::acl_manager::LeConnectionManagementCallbacks* connection_management_callbacks = nullptr;
327 os::Handler* connection_management_handler = nullptr;
328 EXPECT_CALL(*acl_connection, RegisterCallbacks(_, _))
329 .WillOnce(DoAll(SaveArg<0>(&connection_management_callbacks), SaveArg<1>(&connection_management_handler)));
330 std::unique_ptr<FixedChannel> channel_1, channel_2;
331 std::promise<void> promise_1, promise_2;
332 auto future_1 = promise_1.get_future();
333 auto future_2 = promise_2.get_future();
334 EXPECT_CALL(mock_service_1, NotifyChannelCreation(_))
335 .WillOnce([&channel_1, &promise_1](std::unique_ptr<FixedChannel> channel) {
336 channel_1 = std::move(channel);
337 promise_1.set_value();
338 });
339 EXPECT_CALL(mock_service_2, NotifyChannelCreation(_))
340 .WillOnce([&channel_2, &promise_2](std::unique_ptr<FixedChannel> channel) {
341 channel_2 = std::move(channel);
342 promise_2.set_value();
343 });
344 hci_callback_handler->Post(common::BindOnce(&hci::acl_manager::LeConnectionCallbacks::OnLeConnectSuccess,
345 common::Unretained(hci_le_connection_callbacks), address_with_type,
346 std::move(acl_connection)));
347 SyncHandler(hci_callback_handler);
348 connection_management_handler->Post(common::BindOnce(
349 &hci::acl_manager::LeConnectionManagementCallbacks::OnReadRemoteVersionInformationComplete,
350 common::Unretained(connection_management_callbacks),
351 hci::ErrorCode::SUCCESS,
352 0,
353 0,
354 0));
355 auto future_1_status = future_1.wait_for(kTestIdleDisconnectTimeoutShort);
356 EXPECT_EQ(future_1_status, std::future_status::ready);
357 EXPECT_NE(channel_1, nullptr);
358 auto future_2_status = future_2.wait_for(kTestIdleDisconnectTimeoutShort);
359 EXPECT_EQ(future_2_status, std::future_status::ready);
360 EXPECT_NE(channel_2, nullptr);
361 hci::ErrorCode status_1 = hci::ErrorCode::SUCCESS;
362 channel_1->RegisterOnCloseCallback(
363 user_handler_, common::testing::BindLambdaForTesting([&](hci::ErrorCode status) { status_1 = status; }));
364 hci::ErrorCode status_2 = hci::ErrorCode::SUCCESS;
365 channel_2->RegisterOnCloseCallback(
366 user_handler_, common::testing::BindLambdaForTesting([&](hci::ErrorCode status) { status_2 = status; }));
367
368 // Step 4: Leave channel IDLE long enough, they will disconnect
369 EXPECT_CALL(*raw_acl_connection, Disconnect(hci::DisconnectReason::REMOTE_USER_TERMINATED_CONNECTION)).Times(1);
370 std::this_thread::sleep_for(kTestIdleDisconnectTimeoutShort * 1.2);
371 connection_management_handler->Post(common::BindOnce(
372 &hci::acl_manager::LeConnectionManagementCallbacks::OnDisconnection,
373 common::Unretained(connection_management_callbacks), hci::ErrorCode::CONNECTION_TERMINATED_BY_LOCAL_HOST));
374 SyncHandler(connection_management_handler);
375
376 // Step 5: Link disconnect will trigger all callbacks
377 SyncHandler(user_handler_);
378 EXPECT_EQ(hci::ErrorCode::CONNECTION_TERMINATED_BY_LOCAL_HOST, status_1);
379 EXPECT_EQ(hci::ErrorCode::CONNECTION_TERMINATED_BY_LOCAL_HOST, status_2);
380 }
381
TEST_F(L2capLeLinkManagerTest,acquiring_channels_should_not_disconnect_acl_after_timeout)382 TEST_F(L2capLeLinkManagerTest, acquiring_channels_should_not_disconnect_acl_after_timeout) {
383 EXPECT_CALL(*mock_parameter_provider_, GetLeLinkIdleDisconnectTimeout)
384 .WillRepeatedly(Return(kTestIdleDisconnectTimeoutShort));
385 MockFixedChannelServiceManagerImpl mock_le_fixed_channel_service_manager;
386 MockAclManager mock_acl_manager;
387 hci::AddressWithType address_with_type({{0x01, 0x02, 0x03, 0x04, 0x05, 0x06}},
388 hci::AddressType::RANDOM_DEVICE_ADDRESS);
389
390 // Step 1: Verify callback registration with HCI
391 hci::acl_manager::LeConnectionCallbacks* hci_le_connection_callbacks = nullptr;
392 os::Handler* hci_callback_handler = nullptr;
393 EXPECT_CALL(mock_acl_manager, RegisterLeCallbacks(_, _))
394 .WillOnce(DoAll(SaveArg<0>(&hci_le_connection_callbacks), SaveArg<1>(&hci_callback_handler)));
395 LinkManager le_link_manager(
396 l2cap_handler_,
397 &mock_acl_manager,
398 &mock_le_fixed_channel_service_manager,
399 nullptr,
400 mock_parameter_provider_);
401 EXPECT_EQ(hci_le_connection_callbacks, &le_link_manager);
402 EXPECT_EQ(hci_callback_handler, l2cap_handler_);
403
404 // Register fake services
405 MockFixedChannelServiceImpl mock_service_1, mock_service_2;
406 std::vector<std::pair<Cid, FixedChannelServiceImpl*>> results;
407 results.emplace_back(kSmpBrCid, &mock_service_1);
408 results.emplace_back(kConnectionlessCid, &mock_service_2);
409 EXPECT_CALL(mock_le_fixed_channel_service_manager, GetRegisteredServices()).WillRepeatedly(Return(results));
410
411 // Step 2: Connect to fixed channel without ACL connection should trigger ACL connection process
412 EXPECT_CALL(mock_acl_manager, CreateLeConnection(address_with_type, true)).Times(1);
413 LinkManager::PendingFixedChannelConnection pending_fixed_channel_connection{
414 .handler_ = user_handler_,
415 .on_fail_callback_ = common::BindOnce([](FixedChannelManager::ConnectionResult result) { FAIL(); })};
416 le_link_manager.ConnectFixedChannelServices(address_with_type, std::move(pending_fixed_channel_connection));
417
418 // Step 3: ACL connection success event should trigger channel creation for all registered services
419 auto* raw_acl_connection = new MockLeAclConnection();
420 std::unique_ptr<MockLeAclConnection> acl_connection(raw_acl_connection);
421 EXPECT_CALL(*acl_connection, GetRemoteAddress()).WillRepeatedly(Return(address_with_type));
422 hci::acl_manager::LeConnectionManagementCallbacks* connection_management_callbacks = nullptr;
423 os::Handler* connection_management_handler = nullptr;
424 EXPECT_CALL(*acl_connection, RegisterCallbacks(_, _))
425 .WillOnce(DoAll(SaveArg<0>(&connection_management_callbacks), SaveArg<1>(&connection_management_handler)));
426 std::unique_ptr<FixedChannel> channel_1, channel_2;
427 std::promise<void> promise_1, promise_2;
428 auto future_1 = promise_1.get_future();
429 auto future_2 = promise_2.get_future();
430 EXPECT_CALL(mock_service_1, NotifyChannelCreation(_))
431 .WillOnce([&channel_1, &promise_1](std::unique_ptr<FixedChannel> channel) {
432 channel_1 = std::move(channel);
433 promise_1.set_value();
434 });
435 EXPECT_CALL(mock_service_2, NotifyChannelCreation(_))
436 .WillOnce([&channel_2, &promise_2](std::unique_ptr<FixedChannel> channel) {
437 channel_2 = std::move(channel);
438 promise_2.set_value();
439 });
440 hci_callback_handler->Post(common::BindOnce(&hci::acl_manager::LeConnectionCallbacks::OnLeConnectSuccess,
441 common::Unretained(hci_le_connection_callbacks), address_with_type,
442 std::move(acl_connection)));
443 SyncHandler(hci_callback_handler);
444 connection_management_handler->Post(common::BindOnce(
445 &hci::acl_manager::LeConnectionManagementCallbacks::OnReadRemoteVersionInformationComplete,
446 common::Unretained(connection_management_callbacks),
447 hci::ErrorCode::SUCCESS,
448 0,
449 0,
450 0));
451 auto future_1_status = future_1.wait_for(kTestIdleDisconnectTimeoutShort);
452 EXPECT_EQ(future_1_status, std::future_status::ready);
453 EXPECT_NE(channel_1, nullptr);
454 auto future_2_status = future_2.wait_for(kTestIdleDisconnectTimeoutShort);
455 EXPECT_EQ(future_2_status, std::future_status::ready);
456 EXPECT_NE(channel_2, nullptr);
457 hci::ErrorCode status_1 = hci::ErrorCode::SUCCESS;
458 channel_1->RegisterOnCloseCallback(
459 user_handler_, common::testing::BindLambdaForTesting([&](hci::ErrorCode status) { status_1 = status; }));
460 hci::ErrorCode status_2 = hci::ErrorCode::SUCCESS;
461 channel_2->RegisterOnCloseCallback(
462 user_handler_, common::testing::BindLambdaForTesting([&](hci::ErrorCode status) { status_2 = status; }));
463
464 channel_1->Acquire();
465
466 // Step 4: ave channel IDLE, it won't disconnect to due acquired channel 1
467 EXPECT_CALL(*raw_acl_connection, Disconnect(hci::DisconnectReason::REMOTE_USER_TERMINATED_CONNECTION)).Times(0);
468 std::this_thread::sleep_for(kTestIdleDisconnectTimeoutShort * 2);
469
470 // Step 5: Link disconnect will trigger all callbacks
471 connection_management_handler->Post(common::BindOnce(
472 &hci::acl_manager::LeConnectionManagementCallbacks::OnDisconnection,
473 common::Unretained(connection_management_callbacks), hci::ErrorCode::CONNECTION_TERMINATED_BY_LOCAL_HOST));
474 SyncHandler(connection_management_handler);
475 SyncHandler(user_handler_);
476 EXPECT_EQ(hci::ErrorCode::CONNECTION_TERMINATED_BY_LOCAL_HOST, status_1);
477 EXPECT_EQ(hci::ErrorCode::CONNECTION_TERMINATED_BY_LOCAL_HOST, status_2);
478 }
479
TEST_F(L2capLeLinkManagerTest,acquiring_and_releasing_channels_should_eventually_disconnect_acl)480 TEST_F(L2capLeLinkManagerTest, acquiring_and_releasing_channels_should_eventually_disconnect_acl) {
481 EXPECT_CALL(*mock_parameter_provider_, GetLeLinkIdleDisconnectTimeout)
482 .WillRepeatedly(Return(kTestIdleDisconnectTimeoutShort));
483 MockFixedChannelServiceManagerImpl mock_le_fixed_channel_service_manager;
484 MockAclManager mock_acl_manager;
485 hci::AddressWithType address_with_type({{0x01, 0x02, 0x03, 0x04, 0x05, 0x06}},
486 hci::AddressType::PUBLIC_IDENTITY_ADDRESS);
487
488 // Step 1: Verify callback registration with HCI
489 hci::acl_manager::LeConnectionCallbacks* hci_le_connection_callbacks = nullptr;
490 os::Handler* hci_callback_handler = nullptr;
491 EXPECT_CALL(mock_acl_manager, RegisterLeCallbacks(_, _))
492 .WillOnce(DoAll(SaveArg<0>(&hci_le_connection_callbacks), SaveArg<1>(&hci_callback_handler)));
493 LinkManager le_link_manager(
494 l2cap_handler_,
495 &mock_acl_manager,
496 &mock_le_fixed_channel_service_manager,
497 nullptr,
498 mock_parameter_provider_);
499 EXPECT_EQ(hci_le_connection_callbacks, &le_link_manager);
500 EXPECT_EQ(hci_callback_handler, l2cap_handler_);
501
502 // Register fake services
503 MockFixedChannelServiceImpl mock_service_1, mock_service_2;
504 std::vector<std::pair<Cid, FixedChannelServiceImpl*>> results;
505 results.emplace_back(kSmpBrCid, &mock_service_1);
506 results.emplace_back(kConnectionlessCid, &mock_service_2);
507 EXPECT_CALL(mock_le_fixed_channel_service_manager, GetRegisteredServices()).WillRepeatedly(Return(results));
508
509 // Step 2: Connect to fixed channel without ACL connection should trigger ACL connection process
510 EXPECT_CALL(mock_acl_manager, CreateLeConnection(address_with_type, true)).Times(1);
511 LinkManager::PendingFixedChannelConnection pending_fixed_channel_connection{
512 .handler_ = user_handler_,
513 .on_fail_callback_ = common::BindOnce([](FixedChannelManager::ConnectionResult result) { FAIL(); })};
514 le_link_manager.ConnectFixedChannelServices(address_with_type, std::move(pending_fixed_channel_connection));
515
516 // Step 3: ACL connection success event should trigger channel creation for all registered services
517 auto* raw_acl_connection = new MockLeAclConnection();
518 std::unique_ptr<MockLeAclConnection> acl_connection(raw_acl_connection);
519 EXPECT_CALL(*acl_connection, GetRemoteAddress()).WillRepeatedly(Return(address_with_type));
520 hci::acl_manager::LeConnectionManagementCallbacks* connection_management_callbacks = nullptr;
521 os::Handler* connection_management_handler = nullptr;
522 EXPECT_CALL(*acl_connection, RegisterCallbacks(_, _))
523 .WillOnce(DoAll(SaveArg<0>(&connection_management_callbacks), SaveArg<1>(&connection_management_handler)));
524 std::unique_ptr<FixedChannel> channel_1, channel_2;
525 std::promise<void> promise_1, promise_2;
526 auto future_1 = promise_1.get_future();
527 auto future_2 = promise_2.get_future();
528 EXPECT_CALL(mock_service_1, NotifyChannelCreation(_))
529 .WillOnce([&channel_1, &promise_1](std::unique_ptr<FixedChannel> channel) {
530 channel_1 = std::move(channel);
531 promise_1.set_value();
532 });
533 EXPECT_CALL(mock_service_2, NotifyChannelCreation(_))
534 .WillOnce([&channel_2, &promise_2](std::unique_ptr<FixedChannel> channel) {
535 channel_2 = std::move(channel);
536 promise_2.set_value();
537 });
538 hci_callback_handler->Post(common::BindOnce(&hci::acl_manager::LeConnectionCallbacks::OnLeConnectSuccess,
539 common::Unretained(hci_le_connection_callbacks), address_with_type,
540 std::move(acl_connection)));
541 SyncHandler(hci_callback_handler);
542 connection_management_handler->Post(common::BindOnce(
543 &hci::acl_manager::LeConnectionManagementCallbacks::OnReadRemoteVersionInformationComplete,
544 common::Unretained(connection_management_callbacks),
545 hci::ErrorCode::SUCCESS,
546 0,
547 0,
548 0));
549 auto future_1_status = future_1.wait_for(kTestIdleDisconnectTimeoutShort);
550 EXPECT_EQ(future_1_status, std::future_status::ready);
551 EXPECT_NE(channel_1, nullptr);
552 auto future_2_status = future_2.wait_for(kTestIdleDisconnectTimeoutShort);
553 EXPECT_EQ(future_2_status, std::future_status::ready);
554 EXPECT_NE(channel_2, nullptr);
555 hci::ErrorCode status_1 = hci::ErrorCode::SUCCESS;
556 channel_1->RegisterOnCloseCallback(
557 user_handler_, common::testing::BindLambdaForTesting([&](hci::ErrorCode status) { status_1 = status; }));
558 hci::ErrorCode status_2 = hci::ErrorCode::SUCCESS;
559 channel_2->RegisterOnCloseCallback(
560 user_handler_, common::testing::BindLambdaForTesting([&](hci::ErrorCode status) { status_2 = status; }));
561
562 channel_1->Acquire();
563
564 // Step 4: ave channel IDLE, it won't disconnect to due acquired channel 1
565 EXPECT_CALL(*raw_acl_connection, Disconnect(hci::DisconnectReason::REMOTE_USER_TERMINATED_CONNECTION)).Times(0);
566 std::this_thread::sleep_for(kTestIdleDisconnectTimeoutShort * 2);
567
568 // Step 5: ave channel IDLE long enough, they will disconnect
569 channel_1->Release();
570 EXPECT_CALL(*raw_acl_connection, Disconnect(hci::DisconnectReason::REMOTE_USER_TERMINATED_CONNECTION)).Times(1);
571 std::this_thread::sleep_for(kTestIdleDisconnectTimeoutShort * 1.2);
572
573 // Step 6: Link disconnect will trigger all callbacks
574 connection_management_handler->Post(common::BindOnce(
575 &hci::acl_manager::LeConnectionManagementCallbacks::OnDisconnection,
576 common::Unretained(connection_management_callbacks), hci::ErrorCode::CONNECTION_TERMINATED_BY_LOCAL_HOST));
577 SyncHandler(connection_management_handler);
578 SyncHandler(user_handler_);
579 EXPECT_EQ(hci::ErrorCode::CONNECTION_TERMINATED_BY_LOCAL_HOST, status_1);
580 EXPECT_EQ(hci::ErrorCode::CONNECTION_TERMINATED_BY_LOCAL_HOST, status_2);
581 }
582
583 } // namespace
584 } // namespace internal
585 } // namespace le
586 } // namespace l2cap
587 } // namespace bluetooth
588