1 /*
2 * Copyright 2021 HIMSA II K/S - www.himsa.com.
3 * Represented by EHIMA - www.ehima.com
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18 #include <aics/api.h>
19 #include <base/functional/bind.h>
20 #include <com_android_bluetooth_flags.h>
21 #include <gmock/gmock.h>
22 #include <gtest/gtest.h>
23 #include <log/log.h>
24
25 #include "bta/include/bta_vc_api.h"
26 #include "bta/test/common/bta_gatt_api_mock.h"
27 #include "bta/test/common/bta_gatt_queue_mock.h"
28 #include "bta/test/common/btm_api_mock.h"
29 #include "bta/test/common/mock_csis_client.h"
30 #include "bta/vc/types.h"
31 #include "gatt/database_builder.h"
32 #include "hardware/bt_gatt_types.h"
33 #include "include/bind_helpers.h"
34 #include "osi/test/alarm_mock.h"
35 #include "stack/include/bt_uuid16.h"
36 #include "stack/include/btm_status.h"
37 #include "test/common/mock_functions.h"
38 #include "types/bluetooth/uuid.h"
39 #include "types/raw_address.h"
40
41 // TODO(b/369381361) Enfore -Wmissing-prototypes
42 #pragma GCC diagnostic ignored "-Wmissing-prototypes"
43
btif_storage_add_volume_control(const RawAddress &,bool)44 void btif_storage_add_volume_control(const RawAddress& /*addr*/, bool /*auto_conn*/) {}
45
46 struct alarm_t {
47 alarm_callback_t cb = nullptr;
48 void* data = nullptr;
49 bool on_main_loop = false;
50 };
51
52 using ::testing::NiceMock;
53
54 namespace bluetooth {
55 namespace vc {
56 namespace internal {
57 namespace {
58
59 using base::Bind;
60 using base::Unretained;
61
62 using bluetooth::aics::GainMode;
63 using bluetooth::aics::Mute;
64 using bluetooth::vc::ConnectionState;
65 using bluetooth::vc::VolumeControlCallbacks;
66
67 using testing::_;
68 using testing::DoAll;
69 using testing::DoDefault;
70 using testing::Invoke;
71 using testing::Mock;
72 using testing::NotNull;
73 using testing::Return;
74 using testing::SaveArg;
75 using testing::SetArgPointee;
76 using testing::WithArg;
77
GetTestAddress(int index)78 RawAddress GetTestAddress(int index) {
79 EXPECT_LT(index, UINT8_MAX);
80 RawAddress result = {{0xC0, 0xDE, 0xC0, 0xDE, 0x00, static_cast<uint8_t>(index)}};
81 return result;
82 }
83
84 class MockVolumeControlCallbacks : public VolumeControlCallbacks {
85 public:
86 MockVolumeControlCallbacks() = default;
87 MockVolumeControlCallbacks(const MockVolumeControlCallbacks&) = delete;
88 MockVolumeControlCallbacks& operator=(const MockVolumeControlCallbacks&) = delete;
89
90 ~MockVolumeControlCallbacks() override = default;
91
92 MOCK_METHOD((void), OnConnectionState, (ConnectionState state, const RawAddress& address),
93 (override));
94 MOCK_METHOD((void), OnDeviceAvailable,
95 (const RawAddress& address, uint8_t num_offset, uint8_t num_inputs), (override));
96 MOCK_METHOD((void), OnVolumeStateChanged,
97 (const RawAddress& address, uint8_t volume, bool mute, uint8_t flags,
98 bool isAutonomous),
99 (override));
100 MOCK_METHOD((void), OnGroupVolumeStateChanged,
101 (int group_id, uint8_t volume, bool mute, bool isAutonomous), (override));
102 MOCK_METHOD((void), OnExtAudioOutVolumeOffsetChanged,
103 (const RawAddress& address, uint8_t ext_output_id, int16_t offset), (override));
104 MOCK_METHOD((void), OnExtAudioOutLocationChanged,
105 (const RawAddress& address, uint8_t ext_output_id, uint32_t location), (override));
106 MOCK_METHOD((void), OnExtAudioOutDescriptionChanged,
107 (const RawAddress& address, uint8_t ext_output_id, std::string descr), (override));
108 MOCK_METHOD((void), OnExtAudioInStateChanged,
109 (const RawAddress& address, uint8_t ext_input_id, int8_t gain_setting, Mute mute,
110 GainMode gain_mode),
111 (override));
112 MOCK_METHOD((void), OnExtAudioInSetGainSettingFailed,
113 (const RawAddress& address, uint8_t ext_input_id), (override));
114 MOCK_METHOD((void), OnExtAudioInSetMuteFailed, (const RawAddress& address, uint8_t ext_input_id),
115 (override));
116 MOCK_METHOD((void), OnExtAudioInSetGainModeFailed,
117 (const RawAddress& address, uint8_t ext_input_id), (override));
118 MOCK_METHOD((void), OnExtAudioInStatusChanged,
119 (const RawAddress& address, uint8_t ext_input_id, VolumeInputStatus status),
120 (override));
121 MOCK_METHOD((void), OnExtAudioInTypeChanged,
122 (const RawAddress& address, uint8_t ext_input_id, VolumeInputType type), (override));
123 MOCK_METHOD((void), OnExtAudioInGainSettingPropertiesChanged,
124 (const RawAddress& address, uint8_t ext_input_id, uint8_t unit, int8_t min,
125 int8_t max),
126 (override));
127 MOCK_METHOD((void), OnExtAudioInDescriptionChanged,
128 (const RawAddress& address, uint8_t ext_input_id, std::string description,
129 bool is_writable),
130 (override));
131 };
132
133 class VolumeControlTest : public ::testing::Test {
134 private:
set_sample_database(uint16_t conn_id,bool vcs,bool vcs_broken,bool aics,bool aics_broken,bool vocs,bool vocs_broken)135 void set_sample_database(uint16_t conn_id, bool vcs, bool vcs_broken, bool aics, bool aics_broken,
136 bool vocs, bool vocs_broken) {
137 gatt::DatabaseBuilder builder;
138 builder.AddService(0x0001, 0x0003, Uuid::From16Bit(0x1800), true);
139 builder.AddCharacteristic(0x0002, 0x0003, Uuid::From16Bit(0x2a00), GATT_CHAR_PROP_BIT_READ);
140 /* 0x0004-0x000f RFU */
141 if (vcs) {
142 /* VCS */
143 builder.AddService(0x0010, 0x0026, kVolumeControlUuid, true);
144 if (aics) {
145 builder.AddIncludedService(0x0011, kVolumeAudioInputUuid, 0x0030, 0x003e);
146 builder.AddIncludedService(0x0012, kVolumeAudioInputUuid, 0x0050, 0x005f);
147 }
148 if (vocs) {
149 builder.AddIncludedService(0x0013, kVolumeOffsetUuid, 0x0070, 0x0079);
150 builder.AddIncludedService(0x0014, kVolumeOffsetUuid, 0x0080, 0x008b);
151 }
152 /* 0x0015-0x001f RFU */
153 builder.AddCharacteristic(0x0020, 0x0021, kVolumeControlStateUuid,
154 GATT_CHAR_PROP_BIT_READ | GATT_CHAR_PROP_BIT_NOTIFY);
155 builder.AddDescriptor(0x0022, Uuid::From16Bit(GATT_UUID_CHAR_CLIENT_CONFIG));
156 if (!vcs_broken) {
157 builder.AddCharacteristic(0x0023, 0x0024, kVolumeControlPointUuid,
158 GATT_CHAR_PROP_BIT_WRITE);
159 }
160 builder.AddCharacteristic(0x0025, 0x0026, kVolumeFlagsUuid, GATT_CHAR_PROP_BIT_READ);
161 /* 0x0027-0x002f RFU */
162 if (aics) {
163 /* AICS 1st instance */
164 builder.AddService(0x0030, 0x003e, kVolumeAudioInputUuid, false);
165 builder.AddCharacteristic(0x0031, 0x0032, kVolumeAudioInputStateUuid,
166 GATT_CHAR_PROP_BIT_READ);
167 builder.AddDescriptor(0x0033, Uuid::From16Bit(GATT_UUID_CHAR_CLIENT_CONFIG));
168 builder.AddCharacteristic(0x0034, 0x0035, kVolumeAudioInputGainSettingPropertiesUuid,
169 GATT_CHAR_PROP_BIT_READ);
170 builder.AddCharacteristic(0x0036, 0x0037, kVolumeAudioInputTypeUuid,
171 GATT_CHAR_PROP_BIT_READ);
172 builder.AddCharacteristic(0x0038, 0x0039, kVolumeAudioInputStatusUuid,
173 GATT_CHAR_PROP_BIT_READ | GATT_CHAR_PROP_BIT_NOTIFY);
174 builder.AddDescriptor(0x003a, Uuid::From16Bit(GATT_UUID_CHAR_CLIENT_CONFIG));
175 builder.AddCharacteristic(0x003b, 0x003c, kVolumeAudioInputControlPointUuid,
176 GATT_CHAR_PROP_BIT_WRITE);
177 builder.AddCharacteristic(0x003d, 0x003e, kVolumeAudioInputDescriptionUuid,
178 GATT_CHAR_PROP_BIT_READ);
179 /* 0x003f-0x004f RFU */
180
181 /* AICS 2nd instance */
182 builder.AddService(0x0050, 0x005f, kVolumeAudioInputUuid, false);
183 builder.AddCharacteristic(0x0051, 0x0052, kVolumeAudioInputStateUuid,
184 GATT_CHAR_PROP_BIT_READ | GATT_CHAR_PROP_BIT_NOTIFY);
185 builder.AddDescriptor(0x0053, Uuid::From16Bit(GATT_UUID_CHAR_CLIENT_CONFIG));
186 if (!aics_broken) {
187 builder.AddCharacteristic(0x0054, 0x0055, kVolumeAudioInputGainSettingPropertiesUuid,
188 GATT_CHAR_PROP_BIT_READ);
189 }
190 builder.AddCharacteristic(0x0056, 0x0057, kVolumeAudioInputTypeUuid,
191 GATT_CHAR_PROP_BIT_READ);
192 builder.AddCharacteristic(0x0058, 0x0059, kVolumeAudioInputStatusUuid,
193 GATT_CHAR_PROP_BIT_READ | GATT_CHAR_PROP_BIT_NOTIFY);
194 builder.AddDescriptor(0x005a, Uuid::From16Bit(GATT_UUID_CHAR_CLIENT_CONFIG));
195 builder.AddCharacteristic(0x005b, 0x005c, kVolumeAudioInputControlPointUuid,
196 GATT_CHAR_PROP_BIT_WRITE);
197 builder.AddCharacteristic(
198 0x005d, 0x005e, kVolumeAudioInputDescriptionUuid,
199 GATT_CHAR_PROP_BIT_READ | GATT_CHAR_PROP_BIT_WRITE_NR | GATT_CHAR_PROP_BIT_NOTIFY);
200 builder.AddDescriptor(0x005f, Uuid::From16Bit(GATT_UUID_CHAR_CLIENT_CONFIG));
201 /* 0x0060-0x006f RFU */
202 }
203 if (vocs) {
204 /* VOCS 1st instance */
205 builder.AddService(0x0070, 0x0079, kVolumeOffsetUuid, false);
206 builder.AddCharacteristic(0x0071, 0x0072, kVolumeOffsetStateUuid,
207 GATT_CHAR_PROP_BIT_READ | GATT_CHAR_PROP_BIT_NOTIFY);
208 builder.AddDescriptor(0x0073, Uuid::From16Bit(GATT_UUID_CHAR_CLIENT_CONFIG));
209 builder.AddCharacteristic(0x0074, 0x0075, kVolumeOffsetLocationUuid,
210 GATT_CHAR_PROP_BIT_READ);
211 builder.AddCharacteristic(0x0076, 0x0077, kVolumeOffsetControlPointUuid,
212 GATT_CHAR_PROP_BIT_WRITE);
213 builder.AddCharacteristic(0x0078, 0x0079, kVolumeOffsetOutputDescriptionUuid,
214 GATT_CHAR_PROP_BIT_READ);
215 /* 0x007a-0x007f RFU */
216
217 /* VOCS 2nd instance */
218 builder.AddService(0x0080, 0x008b, kVolumeOffsetUuid, false);
219 builder.AddCharacteristic(0x0081, 0x0082, kVolumeOffsetStateUuid,
220 GATT_CHAR_PROP_BIT_READ | GATT_CHAR_PROP_BIT_NOTIFY);
221 builder.AddDescriptor(0x0083, Uuid::From16Bit(GATT_UUID_CHAR_CLIENT_CONFIG));
222 if (!vocs_broken) {
223 builder.AddCharacteristic(0x0084, 0x0085, kVolumeOffsetLocationUuid,
224 GATT_CHAR_PROP_BIT_READ | GATT_CHAR_PROP_BIT_WRITE_NR |
225 GATT_CHAR_PROP_BIT_NOTIFY);
226 builder.AddDescriptor(0x0086, Uuid::From16Bit(GATT_UUID_CHAR_CLIENT_CONFIG));
227 }
228 builder.AddCharacteristic(0x0087, 0x0088, kVolumeOffsetControlPointUuid,
229 GATT_CHAR_PROP_BIT_WRITE);
230 builder.AddCharacteristic(
231 0x0089, 0x008a, kVolumeOffsetOutputDescriptionUuid,
232 GATT_CHAR_PROP_BIT_READ | GATT_CHAR_PROP_BIT_WRITE_NR | GATT_CHAR_PROP_BIT_NOTIFY);
233 builder.AddDescriptor(0x008b, Uuid::From16Bit(GATT_UUID_CHAR_CLIENT_CONFIG));
234 }
235 }
236 /* 0x008c-0x008f RFU */
237
238 /* GATTS */
239 builder.AddService(0x0090, 0x0093, Uuid::From16Bit(UUID_SERVCLASS_GATT_SERVER), true);
240 builder.AddCharacteristic(0x0091, 0x0092, Uuid::From16Bit(GATT_UUID_GATT_SRV_CHGD),
241 GATT_CHAR_PROP_BIT_NOTIFY);
242 builder.AddDescriptor(0x0093, Uuid::From16Bit(GATT_UUID_CHAR_CLIENT_CONFIG));
243 services_map[conn_id] = builder.Build().Services();
244
245 ON_CALL(gatt_queue, ReadCharacteristic(conn_id, _, _, _))
246 .WillByDefault(Invoke([&](uint16_t conn_id, uint16_t handle, GATT_READ_OP_CB cb,
247 void* cb_data) -> void {
248 std::vector<uint8_t> value;
249
250 switch (handle) {
251 case 0x0003:
252 /* device name */
253 value.resize(20);
254 break;
255
256 case 0x0021:
257 /* volume state */
258 value.resize(3);
259 break;
260
261 case 0x0026:
262 /* volume flags */
263 value.resize(1);
264 break;
265
266 case 0x0032: // 1st AICS instance
267 case 0x0052: // 2nd AICS instance
268 /* audio input state */
269 value.resize(4);
270 break;
271
272 case 0x0035: // 1st AICS instance
273 case 0x0055: // 2nd AICS instance
274 /* audio input gain settings */
275 value.resize(3);
276 break;
277
278 case 0x0037: // 1st AICS instance
279 case 0x0057: // 2nd AICS instance
280 /* audio input type */
281 value.resize(1);
282 break;
283
284 case 0x0039: // 1st AICS instance
285 case 0x0059: // 2nd AICS instance
286 /* audio input status */
287 value.resize(1);
288 break;
289
290 case 0x003e: // 1st AICS instance
291 case 0x005e: // 2nd AICS instance
292 /* audio input description */
293 value.resize(14);
294 break;
295
296 case 0x0072: // 1st VOCS instance
297 case 0x0082: // 2nd VOCS instance
298 /* offset state */
299 value.resize(3);
300 break;
301
302 case 0x0075: // 1st VOCS instance
303 case 0x0085: // 2nd VOCS instance
304 /* offset location */
305 value.resize(4);
306 break;
307
308 case 0x0079: // 1st VOCS instance
309 case 0x008a: // 2nd VOCS instance
310 /* offset output description */
311 value.resize(10);
312 break;
313
314 default:
315 FAIL();
316 return;
317 }
318
319 if (do_not_respond_to_reads) {
320 return;
321 }
322 cb(conn_id, GATT_SUCCESS, handle, value.size(), value.data(), cb_data);
323 }));
324
325 ON_CALL(gatt_queue, ReadMultiCharacteristic(conn_id, _, _, _))
326 .WillByDefault(Invoke([&](uint16_t conn_id, tBTA_GATTC_MULTI& handles,
327 GATT_READ_MULTI_OP_CB cb, void* cb_data) -> void {
328 std::vector<uint8_t> value;
329
330 auto add_element = [&](uint8_t data[], uint8_t len) -> void {
331 // LE order, 2 octets
332 value.push_back(len);
333 value.push_back(0x00);
334
335 uint8_t* p = &data[0];
336 for (size_t i = 0; i < len; i++) {
337 value.push_back(*p++);
338 }
339 };
340
341 for (size_t i = 0; i < handles.num_attr; i++) {
342 switch (handles.handles[i]) {
343 case 0x0003: {
344 /* device name */
345 uint8_t name[] = "UnknownName";
346 add_element(name, sizeof(name));
347 break;
348 }
349 case 0x0021: {
350 /* state */
351 uint8_t state[3] = {0x00, 0x00, 0x00};
352 add_element(state, sizeof(state));
353 break;
354 }
355 case 0x0026: {
356 /* volume flags */
357 uint8_t flags[] = {0x01};
358 add_element(flags, sizeof(flags));
359 break;
360 }
361 case 0x0032: // 1st AICS instance
362 case 0x0052: // 2nd AICS instance
363 {
364 /* audio input state */
365 uint8_t state[4] = {0x01, 0x01, 0x01, 0x00};
366 add_element(state, sizeof(state));
367 break;
368 }
369 case 0x0035: // 1st AICS instance
370 case 0x0055: // 2nd AICS instance
371 {
372 /* audio input gain settings */
373 uint8_t gain_settings[3] = {0x01, 0x01, 0x01};
374 add_element(gain_settings, sizeof(gain_settings));
375 break;
376 }
377 case 0x0037: // 1st AICS instance
378 case 0x0057: // 2nd AICS instance
379 {
380 /* audio input type */
381 uint8_t type[] = {0x01};
382 add_element(type, sizeof(type));
383 break;
384 }
385 case 0x0039: // 1st AICS instance
386 case 0x0059: // 2nd AICS instance
387 {
388 /* audio input status */
389 uint8_t status[] = {0x00};
390 add_element(status, sizeof(status));
391 break;
392 }
393 case 0x003e: // 1st AICS instance
394 case 0x005e: // 2nd AICS instance
395 {
396 /* audio input description */
397 uint8_t dest[] = "input";
398 add_element(dest, sizeof(dest));
399 break;
400 }
401 case 0x0072: // 1st VOCS instance
402 case 0x0082: // 2nd VOCS instance
403 {
404 /* offset state */
405 uint8_t state[3] = {0x00, 0x20, 0x00};
406 add_element(state, sizeof(state));
407 break;
408 }
409 case 0x0075: // 1st VOCS instance
410 case 0x0085: // 2nd VOCS instance
411 {
412 /* offset location */
413 uint8_t location[4] = {0x00, 0x02, 0x00, 0x01};
414 add_element(location, sizeof(location));
415 break;
416 }
417 case 0x0079: // 1st VOCS instance
418 case 0x008a: // 2nd VOCS instance
419 {
420 /* offset output description */
421 uint8_t dest[] = "VOCS_D";
422 add_element(dest, sizeof(dest));
423 break;
424 }
425 default:
426 FAIL();
427 return;
428 }
429 }
430
431 if (do_not_respond_to_reads) {
432 return;
433 }
434 cb(conn_id, GATT_SUCCESS, handles, value.size(), value.data(), cb_data);
435 }));
436 }
437
438 protected:
439 bool do_not_respond_to_reads = false;
440
SetUp(void)441 void SetUp(void) override {
442 __android_log_set_minimum_priority(ANDROID_LOG_VERBOSE);
443
444 com::android::bluetooth::flags::provider_->leaudio_add_aics_support(true);
445
446 bluetooth::manager::SetMockBtmInterface(&btm_interface);
447 MockCsisClient::SetMockInstanceForTesting(&mock_csis_client_module_);
448 gatt::SetMockBtaGattInterface(&gatt_interface);
449 gatt::SetMockBtaGattQueue(&gatt_queue);
450 reset_mock_function_count_map();
451
452 ON_CALL(btm_interface, IsLinkKeyKnown(_, _)).WillByDefault(DoAll(Return(true)));
453
454 // default action for GetCharacteristic function call
455 ON_CALL(gatt_interface, GetCharacteristic(_, _))
456 .WillByDefault(
457 Invoke([&](uint16_t conn_id, uint16_t handle) -> const gatt::Characteristic* {
458 std::list<gatt::Service>& services = services_map[conn_id];
459 for (auto const& service : services) {
460 for (auto const& characteristic : service.characteristics) {
461 if (characteristic.value_handle == handle) {
462 return &characteristic;
463 }
464 }
465 }
466
467 return nullptr;
468 }));
469
470 // default action for GetOwningService function call
471 ON_CALL(gatt_interface, GetOwningService(_, _))
472 .WillByDefault(Invoke([&](uint16_t conn_id, uint16_t handle) -> const gatt::Service* {
473 std::list<gatt::Service>& services = services_map[conn_id];
474 for (auto const& service : services) {
475 if (service.handle <= handle && service.end_handle >= handle) {
476 return &service;
477 }
478 }
479
480 return nullptr;
481 }));
482
483 // default action for GetServices function call
484 ON_CALL(gatt_interface, GetServices(_))
485 .WillByDefault(WithArg<0>(Invoke([&](uint16_t conn_id) -> std::list<gatt::Service>* {
486 return &services_map[conn_id];
487 })));
488
489 // default action for RegisterForNotifications function call
490 ON_CALL(gatt_interface, RegisterForNotifications(gatt_if, _, _))
491 .WillByDefault(Return(GATT_SUCCESS));
492
493 // default action for DeregisterForNotifications function call
494 ON_CALL(gatt_interface, DeregisterForNotifications(gatt_if, _, _))
495 .WillByDefault(Return(GATT_SUCCESS));
496
497 // default action for WriteDescriptor function call
498 ON_CALL(gatt_queue, WriteDescriptor(_, _, _, _, _, _))
499 .WillByDefault(Invoke([](uint16_t conn_id, uint16_t handle, std::vector<uint8_t> value,
500 tGATT_WRITE_TYPE /*write_type*/, GATT_WRITE_OP_CB cb,
501 void* cb_data) -> void {
502 if (cb) {
503 cb(conn_id, GATT_SUCCESS, handle, value.size(), value.data(), cb_data);
504 }
505 }));
506 auto mock_alarm = AlarmMock::Get();
507 ON_CALL(*mock_alarm, AlarmNew(_)).WillByDefault(Invoke([](const char* /*name*/) {
508 return new alarm_t();
509 }));
510 ON_CALL(*mock_alarm, AlarmFree(_)).WillByDefault(Invoke([](alarm_t* alarm) {
511 if (alarm) {
512 free(alarm);
513 }
514 }));
515 ON_CALL(*mock_alarm, AlarmCancel(_)).WillByDefault(Invoke([](alarm_t* alarm) {
516 if (alarm) {
517 alarm->cb = nullptr;
518 alarm->data = nullptr;
519 alarm->on_main_loop = false;
520 }
521 }));
522 ON_CALL(*mock_alarm, AlarmIsScheduled(_)).WillByDefault(Invoke([](const alarm_t* alarm) {
523 if (alarm) {
524 return alarm->cb != nullptr;
525 }
526 return false;
527 }));
528 ON_CALL(*mock_alarm, AlarmSet(_, _, _, _))
529 .WillByDefault(Invoke(
530 [](alarm_t* alarm, uint64_t /*interval_ms*/, alarm_callback_t cb, void* data) {
531 if (alarm) {
532 alarm->data = data;
533 alarm->cb = cb;
534 }
535 }));
536 ON_CALL(*mock_alarm, AlarmSetOnMloop(_, _, _, _))
537 .WillByDefault(Invoke(
538 [](alarm_t* alarm, uint64_t /*interval_ms*/, alarm_callback_t cb, void* data) {
539 if (alarm) {
540 alarm->on_main_loop = true;
541 alarm->data = data;
542 alarm->cb = cb;
543 }
544 }));
545 }
546
TearDown(void)547 void TearDown(void) override {
548 com::android::bluetooth::flags::provider_->reset_flags();
549 services_map.clear();
550 gatt::SetMockBtaGattQueue(nullptr);
551 gatt::SetMockBtaGattInterface(nullptr);
552 bluetooth::manager::SetMockBtmInterface(nullptr);
553 AlarmMock::Reset();
554 }
555
TestAppRegister(void)556 void TestAppRegister(void) {
557 BtaAppRegisterCallback app_register_callback;
558 EXPECT_CALL(gatt_interface, AppRegister(_, _, _))
559 .WillOnce(DoAll(SaveArg<0>(&gatt_callback), SaveArg<1>(&app_register_callback)));
560 VolumeControl::Initialize(&callbacks, base::DoNothing());
561 ASSERT_TRUE(gatt_callback);
562 ASSERT_TRUE(app_register_callback);
563 app_register_callback.Run(gatt_if, GATT_SUCCESS);
564 ASSERT_TRUE(VolumeControl::IsVolumeControlRunning());
565 }
566
TestAppUnregister(void)567 void TestAppUnregister(void) {
568 EXPECT_CALL(gatt_interface, AppDeregister(gatt_if));
569 VolumeControl::CleanUp();
570 ASSERT_FALSE(VolumeControl::IsVolumeControlRunning());
571 gatt_callback = nullptr;
572 }
573
TestConnect(const RawAddress & address)574 void TestConnect(const RawAddress& address) {
575 // by default indicate link as encrypted
576 ON_CALL(btm_interface, BTM_IsEncrypted(address, _)).WillByDefault(DoAll(Return(true)));
577
578 EXPECT_CALL(gatt_interface, Open(gatt_if, address, BTM_BLE_DIRECT_CONNECTION, true));
579 VolumeControl::Get()->Connect(address);
580 Mock::VerifyAndClearExpectations(&gatt_interface);
581 }
582
TestRemove(const RawAddress & address,uint16_t conn_id)583 void TestRemove(const RawAddress& address, uint16_t conn_id) {
584 EXPECT_CALL(gatt_interface, CancelOpen(gatt_if, address, true));
585 if (conn_id) {
586 EXPECT_CALL(gatt_interface, Close(conn_id));
587 } else {
588 EXPECT_CALL(gatt_interface, Close(conn_id)).Times(0);
589 }
590 VolumeControl::Get()->Remove(address);
591 Mock::VerifyAndClearExpectations(&gatt_interface);
592 }
593
TestDisconnect(const RawAddress & address,uint16_t conn_id)594 void TestDisconnect(const RawAddress& address, uint16_t conn_id) {
595 if (conn_id) {
596 EXPECT_CALL(gatt_interface, Close(conn_id));
597 } else {
598 EXPECT_CALL(gatt_interface, Close(conn_id)).Times(0);
599 }
600 VolumeControl::Get()->Disconnect(address);
601 Mock::VerifyAndClearExpectations(&gatt_interface);
602 }
603
TestAddFromStorage(const RawAddress & address)604 void TestAddFromStorage(const RawAddress& address) {
605 // by default indicate link as encrypted
606 ON_CALL(btm_interface, BTM_IsEncrypted(address, _)).WillByDefault(DoAll(Return(true)));
607
608 EXPECT_CALL(gatt_interface, Open(gatt_if, address, BTM_BLE_DIRECT_CONNECTION, true));
609 VolumeControl::Get()->AddFromStorage(address);
610 }
611
TestSubscribeNotifications(const RawAddress & address,uint16_t conn_id,const std::map<uint16_t,uint16_t> & handle_pairs)612 void TestSubscribeNotifications(const RawAddress& address, uint16_t conn_id,
613 const std::map<uint16_t, uint16_t>& handle_pairs) {
614 SetSampleDatabase(conn_id);
615 TestAppRegister();
616 TestConnect(address);
617 GetConnectedEvent(address, conn_id);
618
619 EXPECT_CALL(gatt_queue, WriteDescriptor(_, _, _, _, _, _)).WillRepeatedly(DoDefault());
620 EXPECT_CALL(gatt_interface, RegisterForNotifications(_, _, _)).WillRepeatedly(DoDefault());
621
622 std::vector<uint8_t> notify_value({0x01, 0x00});
623 for (auto const& handles : handle_pairs) {
624 EXPECT_CALL(gatt_queue,
625 WriteDescriptor(conn_id, handles.second, notify_value, GATT_WRITE, _, _))
626 .WillOnce(DoDefault());
627 EXPECT_CALL(gatt_interface, RegisterForNotifications(gatt_if, address, handles.first))
628 .WillOnce(DoDefault());
629 }
630
631 GetSearchCompleteEvent(conn_id);
632 TestAppUnregister();
633 }
634
TestReadCharacteristic(const RawAddress & address,uint16_t conn_id,std::vector<uint16_t> handles)635 void TestReadCharacteristic(const RawAddress& address, uint16_t conn_id,
636 std::vector<uint16_t> handles) {
637 SetSampleDatabase(conn_id);
638 TestAppRegister();
639 TestConnect(address);
640 GetConnectedEvent(address, conn_id);
641
642 tBTA_GATTC_MULTI received_to_read_1{};
643 tBTA_GATTC_MULTI received_to_read_2{};
644
645 if (!com::android::bluetooth::flags::le_ase_read_multiple_variable()) {
646 EXPECT_CALL(gatt_queue, ReadCharacteristic(conn_id, _, _, _)).WillRepeatedly(DoDefault());
647 for (auto const& handle : handles) {
648 EXPECT_CALL(gatt_queue, ReadCharacteristic(conn_id, handle, _, _)).WillOnce(DoDefault());
649 }
650 } else {
651 EXPECT_CALL(gatt_queue, ReadMultiCharacteristic(_, _, _, _)).Times(testing::AtLeast(1));
652 }
653
654 GetSearchCompleteEvent(conn_id);
655 TestAppUnregister();
656 }
657
GetConnectedEvent(const RawAddress & address,uint16_t conn_id,tGATT_STATUS status=GATT_SUCCESS)658 void GetConnectedEvent(const RawAddress& address, uint16_t conn_id,
659 tGATT_STATUS status = GATT_SUCCESS) {
660 tBTA_GATTC_OPEN event_data = {
661 .status = status,
662 .conn_id = conn_id,
663 .client_if = gatt_if,
664 .remote_bda = address,
665 .transport = BT_TRANSPORT_LE,
666 .mtu = 240,
667 };
668
669 gatt_callback(BTA_GATTC_OPEN_EVT, reinterpret_cast<tBTA_GATTC*>(&event_data));
670 }
671
GetDisconnectedEvent(const RawAddress & address,uint16_t conn_id)672 void GetDisconnectedEvent(const RawAddress& address, uint16_t conn_id) {
673 tBTA_GATTC_CLOSE event_data = {
674 .conn_id = conn_id,
675 .status = GATT_SUCCESS,
676 .client_if = gatt_if,
677 .remote_bda = address,
678 .reason = GATT_CONN_TERMINATE_PEER_USER,
679 };
680
681 gatt_callback(BTA_GATTC_CLOSE_EVT, reinterpret_cast<tBTA_GATTC*>(&event_data));
682 }
683
GetSearchCompleteEvent(uint16_t conn_id)684 void GetSearchCompleteEvent(uint16_t conn_id) {
685 tBTA_GATTC_SEARCH_CMPL event_data = {
686 .conn_id = conn_id,
687 .status = GATT_SUCCESS,
688 };
689
690 gatt_callback(BTA_GATTC_SEARCH_CMPL_EVT, reinterpret_cast<tBTA_GATTC*>(&event_data));
691 }
692
GetEncryptionCompleteEvt(const RawAddress & bda)693 void GetEncryptionCompleteEvt(const RawAddress& bda) {
694 tBTA_GATTC cb_data{};
695
696 cb_data.enc_cmpl.client_if = gatt_if;
697 cb_data.enc_cmpl.remote_bda = bda;
698 gatt_callback(BTA_GATTC_ENC_CMPL_CB_EVT, &cb_data);
699 }
700
SetEncryptionResult(const RawAddress & address,bool success)701 void SetEncryptionResult(const RawAddress& address, bool success) {
702 ON_CALL(btm_interface, BTM_IsEncrypted(address, _)).WillByDefault(DoAll(Return(false)));
703 ON_CALL(btm_interface, IsLinkKeyKnown(address, _)).WillByDefault(DoAll(Return(true)));
704 ON_CALL(btm_interface, SetEncryption(address, _, _, _, BTM_BLE_SEC_ENCRYPT))
705 .WillByDefault(
706 Invoke([&success, this](const RawAddress& bd_addr, tBT_TRANSPORT transport,
707 tBTM_SEC_CALLBACK* p_callback, void* p_ref_data,
708 tBTM_BLE_SEC_ACT /*sec_act*/) -> tBTM_STATUS {
709 if (p_callback) {
710 p_callback(bd_addr, transport, p_ref_data,
711 success ? tBTM_STATUS::BTM_SUCCESS
712 : tBTM_STATUS::BTM_FAILED_ON_SECURITY);
713 }
714 GetEncryptionCompleteEvt(bd_addr);
715 return tBTM_STATUS::BTM_SUCCESS;
716 }));
717 EXPECT_CALL(btm_interface, SetEncryption(address, _, _, _, BTM_BLE_SEC_ENCRYPT)).Times(1);
718 }
719
SetSampleDatabaseVCS(uint16_t conn_id)720 void SetSampleDatabaseVCS(uint16_t conn_id) {
721 set_sample_database(conn_id, true, false, false, false, false, false);
722 }
723
SetSampleDatabaseAICS(uint16_t conn_id)724 void SetSampleDatabaseAICS(uint16_t conn_id) {
725 set_sample_database(conn_id, true, false, true, false, false, false);
726 }
727
SetSampleDatabaseAICSBroken(uint16_t conn_id)728 void SetSampleDatabaseAICSBroken(uint16_t conn_id) {
729 set_sample_database(conn_id, true, false, true, true, true, false);
730 }
731
SetSampleDatabaseNoVCS(uint16_t conn_id)732 void SetSampleDatabaseNoVCS(uint16_t conn_id) {
733 set_sample_database(conn_id, false, false, true, false, true, false);
734 }
735
SetSampleDatabaseVCSBroken(uint16_t conn_id)736 void SetSampleDatabaseVCSBroken(uint16_t conn_id) {
737 set_sample_database(conn_id, true, true, true, false, true, false);
738 }
739
SetSampleDatabaseVOCS(uint16_t conn_id)740 void SetSampleDatabaseVOCS(uint16_t conn_id) {
741 set_sample_database(conn_id, true, false, false, false, true, false);
742 }
743
SetSampleDatabaseVOCSBroken(uint16_t conn_id)744 void SetSampleDatabaseVOCSBroken(uint16_t conn_id) {
745 set_sample_database(conn_id, true, false, true, false, true, true);
746 }
747
SetSampleDatabase(uint16_t conn_id)748 void SetSampleDatabase(uint16_t conn_id) {
749 set_sample_database(conn_id, true, false, true, false, true, false);
750 }
751
752 NiceMock<MockVolumeControlCallbacks> callbacks;
753 NiceMock<bluetooth::manager::MockBtmInterface> btm_interface;
754 MockCsisClient mock_csis_client_module_;
755 NiceMock<gatt::MockBtaGattInterface> gatt_interface;
756 NiceMock<gatt::MockBtaGattQueue> gatt_queue;
757
758 tBTA_GATTC_CBACK* gatt_callback;
759 const uint8_t gatt_if = 0xff;
760 std::map<uint16_t, std::list<gatt::Service>> services_map;
761 };
762
TEST_F(VolumeControlTest,test_get_uninitialized)763 TEST_F(VolumeControlTest, test_get_uninitialized) { ASSERT_DEATH(VolumeControl::Get(), ""); }
764
TEST_F(VolumeControlTest,test_initialize)765 TEST_F(VolumeControlTest, test_initialize) {
766 bool init_cb_called = false;
767 BtaAppRegisterCallback app_register_callback;
768 EXPECT_CALL(gatt_interface, AppRegister(_, _, _))
769 .WillOnce(DoAll(SaveArg<0>(&gatt_callback), SaveArg<1>(&app_register_callback)));
770 VolumeControl::Initialize(
771 &callbacks,
772 base::Bind([](bool* init_cb_called) { *init_cb_called = true; }, &init_cb_called));
773 ASSERT_TRUE(gatt_callback);
774 ASSERT_TRUE(app_register_callback);
775 app_register_callback.Run(gatt_if, GATT_SUCCESS);
776 ASSERT_TRUE(init_cb_called);
777
778 ASSERT_TRUE(VolumeControl::IsVolumeControlRunning());
779 VolumeControl::CleanUp();
780 }
781
TEST_F(VolumeControlTest,test_initialize_twice)782 TEST_F(VolumeControlTest, test_initialize_twice) {
783 VolumeControl::Initialize(&callbacks, base::DoNothing());
784 VolumeControl* volume_control_p = VolumeControl::Get();
785 VolumeControl::Initialize(&callbacks, base::DoNothing());
786 ASSERT_EQ(volume_control_p, VolumeControl::Get());
787 VolumeControl::CleanUp();
788 }
789
TEST_F(VolumeControlTest,test_cleanup_initialized)790 TEST_F(VolumeControlTest, test_cleanup_initialized) {
791 VolumeControl::Initialize(&callbacks, base::DoNothing());
792 VolumeControl::CleanUp();
793 ASSERT_FALSE(VolumeControl::IsVolumeControlRunning());
794 }
795
TEST_F(VolumeControlTest,test_cleanup_uninitialized)796 TEST_F(VolumeControlTest, test_cleanup_uninitialized) {
797 VolumeControl::CleanUp();
798 ASSERT_FALSE(VolumeControl::IsVolumeControlRunning());
799 }
800
TEST_F(VolumeControlTest,test_app_registration)801 TEST_F(VolumeControlTest, test_app_registration) {
802 TestAppRegister();
803 TestAppUnregister();
804 }
805
TEST_F(VolumeControlTest,test_connect)806 TEST_F(VolumeControlTest, test_connect) {
807 TestAppRegister();
808 TestConnect(GetTestAddress(0));
809 TestAppUnregister();
810 }
811
TEST_F(VolumeControlTest,test_connect_after_remove)812 TEST_F(VolumeControlTest, test_connect_after_remove) {
813 TestAppRegister();
814
815 const RawAddress test_address = GetTestAddress(0);
816 uint16_t conn_id = 1;
817
818 TestConnect(test_address);
819 GetConnectedEvent(test_address, conn_id);
820 Mock::VerifyAndClearExpectations(&callbacks);
821
822 EXPECT_CALL(callbacks, OnConnectionState(ConnectionState::DISCONNECTED, test_address)).Times(1);
823
824 TestRemove(test_address, conn_id);
825 Mock::VerifyAndClearExpectations(&callbacks);
826
827 EXPECT_CALL(callbacks, OnConnectionState(ConnectionState::DISCONNECTED, test_address)).Times(1);
828 ON_CALL(btm_interface, IsLinkKeyKnown(_, _)).WillByDefault(DoAll(Return(false)));
829
830 VolumeControl::Get()->Connect(test_address);
831 Mock::VerifyAndClearExpectations(&callbacks);
832 TestAppUnregister();
833 }
834
TEST_F(VolumeControlTest,test_reconnect_after_interrupted_discovery)835 TEST_F(VolumeControlTest, test_reconnect_after_interrupted_discovery) {
836 const RawAddress test_address = GetTestAddress(0);
837
838 // Initial connection - no callback calls yet as we want to disconnect in the
839 // middle
840 SetSampleDatabaseVOCS(1);
841 TestAppRegister();
842 TestConnect(test_address);
843 EXPECT_CALL(callbacks, OnConnectionState(ConnectionState::CONNECTED, test_address)).Times(0);
844 EXPECT_CALL(callbacks, OnDeviceAvailable(test_address, 2, _)).Times(0);
845 GetConnectedEvent(test_address, 1);
846 Mock::VerifyAndClearExpectations(&callbacks);
847
848 // Remote disconnects in the middle of the service discovery
849 EXPECT_CALL(callbacks, OnConnectionState(ConnectionState::DISCONNECTED, test_address));
850 GetDisconnectedEvent(test_address, 1);
851 Mock::VerifyAndClearExpectations(&callbacks);
852
853 // This time let the service discovery pass
854 ON_CALL(gatt_interface, ServiceSearchRequest(_, _))
855 .WillByDefault(Invoke([&](uint16_t conn_id, const bluetooth::Uuid* p_srvc_uuid) -> void {
856 if (*p_srvc_uuid == kVolumeControlUuid) {
857 GetSearchCompleteEvent(conn_id);
858 }
859 }));
860
861 // Remote is being connected by another GATT client
862 EXPECT_CALL(callbacks, OnConnectionState(ConnectionState::CONNECTED, test_address));
863 EXPECT_CALL(callbacks, OnDeviceAvailable(test_address, 2, _));
864 GetConnectedEvent(test_address, 1);
865 Mock::VerifyAndClearExpectations(&callbacks);
866
867 // Request connect when the remote was already connected by another service
868 EXPECT_CALL(callbacks, OnDeviceAvailable(test_address, 2, _)).Times(0);
869 EXPECT_CALL(callbacks, OnConnectionState(ConnectionState::CONNECTED, test_address));
870 VolumeControl::Get()->Connect(test_address);
871 // The GetConnectedEvent(test_address, 1); should not be triggered here, since
872 // GATT implementation will not send this event for the already connected
873 // device
874 Mock::VerifyAndClearExpectations(&callbacks);
875
876 TestAppUnregister();
877 }
878
TEST_F(VolumeControlTest,test_verify_opportunistic_connect_active_after_connect_timeout)879 TEST_F(VolumeControlTest, test_verify_opportunistic_connect_active_after_connect_timeout) {
880 const RawAddress address = GetTestAddress(0);
881
882 TestAppRegister();
883 TestAddFromStorage(address);
884 Mock::VerifyAndClearExpectations(&gatt_interface);
885
886 EXPECT_CALL(callbacks, OnConnectionState(ConnectionState::DISCONNECTED, address)).Times(1);
887 TestConnect(address);
888
889 EXPECT_CALL(gatt_interface, CancelOpen(gatt_if, address, _)).Times(0);
890 EXPECT_CALL(gatt_interface, Open(gatt_if, address, BTM_BLE_DIRECT_CONNECTION, true)).Times(1);
891
892 GetConnectedEvent(address, 1, GATT_ERROR);
893 Mock::VerifyAndClearExpectations(&callbacks);
894 Mock::VerifyAndClearExpectations(&gatt_interface);
895 TestAppUnregister();
896 }
897
TEST_F(VolumeControlTest,test_reconnect_after_timeout)898 TEST_F(VolumeControlTest, test_reconnect_after_timeout) {
899 const RawAddress address = GetTestAddress(0);
900
901 // Initial connection
902 SetSampleDatabaseVOCS(1);
903 TestAppRegister();
904
905 EXPECT_CALL(callbacks, OnConnectionState(ConnectionState::CONNECTED, address)).Times(0);
906 TestConnect(address);
907
908 // Disconnect not connected device - upper layer times out and needs a
909 // disconnection event to leave the transient Connecting state
910 EXPECT_CALL(callbacks, OnConnectionState(ConnectionState::DISCONNECTED, address));
911 EXPECT_CALL(gatt_interface, CancelOpen(gatt_if, address, _)).Times(0);
912 TestDisconnect(address, 0);
913
914 // Above the device was not connected and we got Disconnect request from the
915 // upper layer - it means it has timed-out but still wants to connect, thus
916 // native is still doing background or opportunistic connect. Let the remote
917 // device reconnect now.
918 ON_CALL(gatt_interface, ServiceSearchRequest(_, _))
919 .WillByDefault(Invoke([&](uint16_t conn_id, const bluetooth::Uuid* p_srvc_uuid) -> void {
920 if (*p_srvc_uuid == kVolumeControlUuid) {
921 GetSearchCompleteEvent(conn_id);
922 }
923 }));
924 EXPECT_CALL(callbacks, OnConnectionState(ConnectionState::CONNECTED, address));
925 EXPECT_CALL(callbacks, OnDeviceAvailable(address, 2, _));
926 GetConnectedEvent(address, 1);
927 Mock::VerifyAndClearExpectations(&callbacks);
928
929 // Make sure that the upper layer gets the disconnection event even if not
930 // connecting actively anymore due to the mentioned time-out mechanism.
931 EXPECT_CALL(callbacks, OnConnectionState(ConnectionState::DISCONNECTED, address));
932 GetDisconnectedEvent(address, 1);
933 Mock::VerifyAndClearExpectations(&callbacks);
934 TestAppUnregister();
935 }
936
TEST_F(VolumeControlTest,test_add_from_storage)937 TEST_F(VolumeControlTest, test_add_from_storage) {
938 TestAppRegister();
939 TestAddFromStorage(GetTestAddress(0));
940 TestAppUnregister();
941 }
942
TEST_F(VolumeControlTest,test_remove_non_connected)943 TEST_F(VolumeControlTest, test_remove_non_connected) {
944 const RawAddress test_address = GetTestAddress(0);
945 TestAppRegister();
946 TestConnect(test_address);
947 EXPECT_CALL(callbacks, OnConnectionState(ConnectionState::DISCONNECTED, test_address));
948 TestRemove(test_address, 0);
949 TestAppUnregister();
950 }
951
TEST_F(VolumeControlTest,test_remove_connected)952 TEST_F(VolumeControlTest, test_remove_connected) {
953 const RawAddress test_address = GetTestAddress(0);
954 TestAppRegister();
955 TestConnect(test_address);
956 GetConnectedEvent(test_address, 1);
957 EXPECT_CALL(callbacks, OnConnectionState(ConnectionState::DISCONNECTED, test_address));
958 TestDisconnect(test_address, 1);
959 TestAppUnregister();
960 }
961
TEST_F(VolumeControlTest,test_disconnect_non_connected)962 TEST_F(VolumeControlTest, test_disconnect_non_connected) {
963 const RawAddress test_address = GetTestAddress(0);
964 TestAppRegister();
965 TestConnect(test_address);
966 EXPECT_CALL(callbacks, OnConnectionState(ConnectionState::DISCONNECTED, test_address));
967 TestDisconnect(test_address, 0);
968 TestAppUnregister();
969 }
970
TEST_F(VolumeControlTest,test_disconnect_connected)971 TEST_F(VolumeControlTest, test_disconnect_connected) {
972 const RawAddress test_address = GetTestAddress(0);
973 TestAppRegister();
974 TestConnect(test_address);
975 GetConnectedEvent(test_address, 1);
976 EXPECT_CALL(callbacks, OnConnectionState(ConnectionState::DISCONNECTED, test_address));
977 TestDisconnect(test_address, 1);
978 TestAppUnregister();
979 }
980
TEST_F(VolumeControlTest,test_disconnected)981 TEST_F(VolumeControlTest, test_disconnected) {
982 const RawAddress test_address = GetTestAddress(0);
983 TestAppRegister();
984 TestConnect(test_address);
985 GetConnectedEvent(test_address, 1);
986 EXPECT_CALL(callbacks, OnConnectionState(ConnectionState::DISCONNECTED, test_address));
987 GetDisconnectedEvent(test_address, 1);
988 TestAppUnregister();
989 }
990
TEST_F(VolumeControlTest,test_disconnected_while_autoconnect)991 TEST_F(VolumeControlTest, test_disconnected_while_autoconnect) {
992 const RawAddress test_address = GetTestAddress(0);
993 TestAppRegister();
994 TestAddFromStorage(test_address);
995 GetConnectedEvent(test_address, 1);
996 Mock::VerifyAndClearExpectations(&gatt_interface);
997 // autoconnect - don't indicate disconnection
998 EXPECT_CALL(callbacks, OnConnectionState(ConnectionState::DISCONNECTED, test_address)).Times(0);
999 GetDisconnectedEvent(test_address, 1);
1000 TestAppUnregister();
1001 }
1002
TEST_F(VolumeControlTest,test_disconnect_when_link_key_gone)1003 TEST_F(VolumeControlTest, test_disconnect_when_link_key_gone) {
1004 const RawAddress test_address = GetTestAddress(0);
1005 TestAppRegister();
1006 TestAddFromStorage(test_address);
1007
1008 ON_CALL(btm_interface, BTM_IsEncrypted(test_address, _)).WillByDefault(DoAll(Return(false)));
1009 ON_CALL(btm_interface, SetEncryption(test_address, _, _, _, BTM_BLE_SEC_ENCRYPT))
1010 .WillByDefault(Return(tBTM_STATUS::BTM_ERR_KEY_MISSING));
1011
1012 // autoconnect - don't indicate disconnection
1013 EXPECT_CALL(callbacks, OnConnectionState(ConnectionState::DISCONNECTED, test_address)).Times(0);
1014 EXPECT_CALL(gatt_interface, Close(1));
1015 GetConnectedEvent(test_address, 1);
1016 Mock::VerifyAndClearExpectations(&btm_interface);
1017 TestAppUnregister();
1018 }
1019
TEST_F(VolumeControlTest,test_reconnect_after_encryption_failed)1020 TEST_F(VolumeControlTest, test_reconnect_after_encryption_failed) {
1021 const RawAddress test_address = GetTestAddress(0);
1022 TestAppRegister();
1023 TestAddFromStorage(test_address);
1024 SetEncryptionResult(test_address, false);
1025 // autoconnect - don't indicate disconnection
1026 EXPECT_CALL(callbacks, OnConnectionState(ConnectionState::DISCONNECTED, test_address)).Times(0);
1027 GetConnectedEvent(test_address, 1);
1028 Mock::VerifyAndClearExpectations(&btm_interface);
1029 SetEncryptionResult(test_address, true);
1030 GetConnectedEvent(test_address, 1);
1031 TestAppUnregister();
1032 }
1033
TEST_F(VolumeControlTest,test_service_discovery_completed_before_encryption)1034 TEST_F(VolumeControlTest, test_service_discovery_completed_before_encryption) {
1035 const RawAddress test_address = GetTestAddress(0);
1036 SetSampleDatabaseVCS(1);
1037 TestAppRegister();
1038 TestConnect(test_address);
1039
1040 ON_CALL(btm_interface, BTM_IsEncrypted(test_address, _)).WillByDefault(DoAll(Return(false)));
1041 ON_CALL(btm_interface, IsLinkKeyKnown(test_address, _)).WillByDefault(DoAll(Return(true)));
1042 ON_CALL(btm_interface, SetEncryption(test_address, _, _, _, _))
1043 .WillByDefault(Return(tBTM_STATUS::BTM_SUCCESS));
1044
1045 EXPECT_CALL(callbacks, OnConnectionState(ConnectionState::CONNECTED, test_address)).Times(0);
1046 uint16_t conn_id = 1;
1047 GetConnectedEvent(test_address, conn_id);
1048 GetSearchCompleteEvent(conn_id);
1049 Mock::VerifyAndClearExpectations(&btm_interface);
1050 Mock::VerifyAndClearExpectations(&callbacks);
1051
1052 EXPECT_CALL(callbacks, OnConnectionState(ConnectionState::CONNECTED, test_address)).Times(1);
1053
1054 ON_CALL(btm_interface, BTM_IsEncrypted(test_address, _)).WillByDefault(DoAll(Return(true)));
1055 EXPECT_CALL(gatt_interface, ServiceSearchRequest(_, _));
1056
1057 GetEncryptionCompleteEvt(test_address);
1058 GetSearchCompleteEvent(conn_id);
1059
1060 Mock::VerifyAndClearExpectations(&callbacks);
1061 Mock::VerifyAndClearExpectations(&gatt_interface);
1062
1063 TestAppUnregister();
1064 }
1065
TEST_F(VolumeControlTest,test_discovery_vcs_found)1066 TEST_F(VolumeControlTest, test_discovery_vcs_found) {
1067 const RawAddress test_address = GetTestAddress(0);
1068 SetSampleDatabaseVCS(1);
1069 TestAppRegister();
1070 TestConnect(test_address);
1071 EXPECT_CALL(callbacks, OnDeviceAvailable(test_address, _, _));
1072 EXPECT_CALL(callbacks, OnConnectionState(ConnectionState::CONNECTED, test_address));
1073 GetConnectedEvent(test_address, 1);
1074 GetSearchCompleteEvent(1);
1075 Mock::VerifyAndClearExpectations(&callbacks);
1076 TestAppUnregister();
1077 }
1078
TEST_F(VolumeControlTest,test_discovery_vcs_not_found)1079 TEST_F(VolumeControlTest, test_discovery_vcs_not_found) {
1080 const RawAddress test_address = GetTestAddress(0);
1081 SetSampleDatabaseNoVCS(1);
1082 TestAppRegister();
1083 TestConnect(test_address);
1084 EXPECT_CALL(callbacks, OnConnectionState(ConnectionState::DISCONNECTED, test_address));
1085 GetConnectedEvent(test_address, 1);
1086
1087 GetSearchCompleteEvent(1);
1088 Mock::VerifyAndClearExpectations(&callbacks);
1089 TestAppUnregister();
1090 }
1091
TEST_F(VolumeControlTest,test_discovery_vcs_broken)1092 TEST_F(VolumeControlTest, test_discovery_vcs_broken) {
1093 const RawAddress test_address = GetTestAddress(0);
1094 SetSampleDatabaseVCSBroken(1);
1095 TestAppRegister();
1096 TestConnect(test_address);
1097 EXPECT_CALL(callbacks, OnConnectionState(ConnectionState::DISCONNECTED, test_address));
1098 GetConnectedEvent(test_address, 1);
1099 GetSearchCompleteEvent(1);
1100 Mock::VerifyAndClearExpectations(&callbacks);
1101 TestAppUnregister();
1102 }
1103
TEST_F(VolumeControlTest,test_subscribe_vcs_volume_state)1104 TEST_F(VolumeControlTest, test_subscribe_vcs_volume_state) {
1105 std::map<uint16_t, uint16_t> handles({{0x0021, 0x0022}});
1106 TestSubscribeNotifications(GetTestAddress(0), 1, handles);
1107 }
1108
TEST_F(VolumeControlTest,test_subscribe_vocs_offset_state)1109 TEST_F(VolumeControlTest, test_subscribe_vocs_offset_state) {
1110 std::map<uint16_t, uint16_t> handles({{0x0072, 0x0073}, {0x0082, 0x0083}});
1111 TestSubscribeNotifications(GetTestAddress(0), 1, handles);
1112 }
1113
TEST_F(VolumeControlTest,test_subscribe_vocs_offset_location)1114 TEST_F(VolumeControlTest, test_subscribe_vocs_offset_location) {
1115 std::map<uint16_t, uint16_t> handles({{0x0085, 0x0086}});
1116 TestSubscribeNotifications(GetTestAddress(0), 1, handles);
1117 }
1118
TEST_F(VolumeControlTest,test_subscribe_vocs_output_description)1119 TEST_F(VolumeControlTest, test_subscribe_vocs_output_description) {
1120 std::map<uint16_t, uint16_t> handles({{0x008a, 0x008b}});
1121 TestSubscribeNotifications(GetTestAddress(0), 1, handles);
1122 }
1123
TEST_F(VolumeControlTest,test_read_vcs_volume_state)1124 TEST_F(VolumeControlTest, test_read_vcs_volume_state) {
1125 const RawAddress test_address = GetTestAddress(0);
1126 EXPECT_CALL(callbacks, OnVolumeStateChanged(test_address, _, _, _, true)).Times(1);
1127 std::vector<uint16_t> handles({0x0021});
1128 TestReadCharacteristic(test_address, 1, handles);
1129 }
1130
TEST_F(VolumeControlTest,test_read_vcs_volume_flags)1131 TEST_F(VolumeControlTest, test_read_vcs_volume_flags) {
1132 std::vector<uint16_t> handles({0x0026});
1133 TestReadCharacteristic(GetTestAddress(0), 1, handles);
1134 }
1135
TEST_F(VolumeControlTest,test_read_vocs_volume_offset)1136 TEST_F(VolumeControlTest, test_read_vocs_volume_offset) {
1137 com::android::bluetooth::flags::provider_->le_ase_read_multiple_variable(false);
1138 const RawAddress test_address = GetTestAddress(0);
1139 EXPECT_CALL(callbacks, OnExtAudioOutVolumeOffsetChanged(test_address, 1, _)).Times(1);
1140 EXPECT_CALL(callbacks, OnExtAudioOutVolumeOffsetChanged(test_address, 2, _)).Times(1);
1141 EXPECT_CALL(callbacks, OnExtAudioOutLocationChanged(test_address, 1, _)).Times(1);
1142 EXPECT_CALL(callbacks, OnExtAudioOutLocationChanged(test_address, 2, _)).Times(1);
1143 EXPECT_CALL(callbacks, OnExtAudioOutDescriptionChanged(test_address, 1, _)).Times(1);
1144 EXPECT_CALL(callbacks, OnExtAudioOutDescriptionChanged(test_address, 2, _)).Times(1);
1145 std::vector<uint16_t> handles({0x0072, 0x0082});
1146 TestReadCharacteristic(test_address, 1, handles);
1147 Mock::VerifyAndClearExpectations(&callbacks);
1148 }
1149
TEST_F(VolumeControlTest,test_read_vocs_volume_offset_multi)1150 TEST_F(VolumeControlTest, test_read_vocs_volume_offset_multi) {
1151 com::android::bluetooth::flags::provider_->le_ase_read_multiple_variable(true);
1152 const RawAddress test_address = GetTestAddress(0);
1153 EXPECT_CALL(callbacks, OnExtAudioOutVolumeOffsetChanged(test_address, 1, _)).Times(1);
1154 EXPECT_CALL(callbacks, OnExtAudioOutVolumeOffsetChanged(test_address, 2, _)).Times(1);
1155 EXPECT_CALL(callbacks, OnExtAudioOutLocationChanged(test_address, 1, _)).Times(1);
1156 EXPECT_CALL(callbacks, OnExtAudioOutLocationChanged(test_address, 2, _)).Times(1);
1157 EXPECT_CALL(callbacks, OnExtAudioOutDescriptionChanged(test_address, 1, _)).Times(1);
1158 EXPECT_CALL(callbacks, OnExtAudioOutDescriptionChanged(test_address, 2, _)).Times(1);
1159 std::vector<uint16_t> handles({0x0072, 0x0082});
1160 TestReadCharacteristic(test_address, 1, handles);
1161 Mock::VerifyAndClearExpectations(&callbacks);
1162 }
1163
TEST_F(VolumeControlTest,test_read_vocs_offset_location)1164 TEST_F(VolumeControlTest, test_read_vocs_offset_location) {
1165 com::android::bluetooth::flags::provider_->le_ase_read_multiple_variable(false);
1166 const RawAddress test_address = GetTestAddress(0);
1167 // It is called twice because after connect read is done once and second read is coming from the
1168 // test.
1169 EXPECT_CALL(callbacks, OnExtAudioOutVolumeOffsetChanged(test_address, 1, _)).Times(1);
1170 EXPECT_CALL(callbacks, OnExtAudioOutVolumeOffsetChanged(test_address, 2, _)).Times(1);
1171 EXPECT_CALL(callbacks, OnExtAudioOutLocationChanged(test_address, 1, _)).Times(1);
1172 EXPECT_CALL(callbacks, OnExtAudioOutLocationChanged(test_address, 2, _)).Times(1);
1173 EXPECT_CALL(callbacks, OnExtAudioOutDescriptionChanged(test_address, 1, _)).Times(1);
1174 EXPECT_CALL(callbacks, OnExtAudioOutDescriptionChanged(test_address, 2, _)).Times(1);
1175 std::vector<uint16_t> handles({0x0075, 0x0085});
1176 TestReadCharacteristic(test_address, 1, handles);
1177 Mock::VerifyAndClearExpectations(&callbacks);
1178 }
1179
TEST_F(VolumeControlTest,test_read_vocs_offset_location_multi)1180 TEST_F(VolumeControlTest, test_read_vocs_offset_location_multi) {
1181 com::android::bluetooth::flags::provider_->le_ase_read_multiple_variable(true);
1182 const RawAddress test_address = GetTestAddress(0);
1183 // It is called twice because after connect read is done once and second read is coming from the
1184 // test.
1185 EXPECT_CALL(callbacks, OnExtAudioOutVolumeOffsetChanged(test_address, 1, _)).Times(1);
1186 EXPECT_CALL(callbacks, OnExtAudioOutVolumeOffsetChanged(test_address, 2, _)).Times(1);
1187 EXPECT_CALL(callbacks, OnExtAudioOutLocationChanged(test_address, 1, _)).Times(1);
1188 EXPECT_CALL(callbacks, OnExtAudioOutLocationChanged(test_address, 2, _)).Times(1);
1189 EXPECT_CALL(callbacks, OnExtAudioOutDescriptionChanged(test_address, 1, _)).Times(1);
1190 EXPECT_CALL(callbacks, OnExtAudioOutDescriptionChanged(test_address, 2, _)).Times(1);
1191 std::vector<uint16_t> handles({0x0075, 0x0085});
1192 TestReadCharacteristic(test_address, 1, handles);
1193 Mock::VerifyAndClearExpectations(&callbacks);
1194 }
1195
TEST_F(VolumeControlTest,test_read_vocs_output_description)1196 TEST_F(VolumeControlTest, test_read_vocs_output_description) {
1197 com::android::bluetooth::flags::provider_->le_ase_read_multiple_variable(false);
1198 const RawAddress test_address = GetTestAddress(0);
1199 EXPECT_CALL(callbacks, OnExtAudioOutVolumeOffsetChanged(test_address, 1, _)).Times(1);
1200 EXPECT_CALL(callbacks, OnExtAudioOutVolumeOffsetChanged(test_address, 2, _)).Times(1);
1201 EXPECT_CALL(callbacks, OnExtAudioOutLocationChanged(test_address, 1, _)).Times(1);
1202 EXPECT_CALL(callbacks, OnExtAudioOutLocationChanged(test_address, 2, _)).Times(1);
1203 EXPECT_CALL(callbacks, OnExtAudioOutDescriptionChanged(test_address, 1, _)).Times(1);
1204 EXPECT_CALL(callbacks, OnExtAudioOutDescriptionChanged(test_address, 2, _)).Times(1);
1205 std::vector<uint16_t> handles({0x0079, 0x008a});
1206 TestReadCharacteristic(test_address, 1, handles);
1207 }
1208
TEST_F(VolumeControlTest,test_read_vocs_output_description_multi)1209 TEST_F(VolumeControlTest, test_read_vocs_output_description_multi) {
1210 com::android::bluetooth::flags::provider_->le_ase_read_multiple_variable(true);
1211 const RawAddress test_address = GetTestAddress(0);
1212 EXPECT_CALL(callbacks, OnExtAudioOutVolumeOffsetChanged(test_address, 1, _)).Times(1);
1213 EXPECT_CALL(callbacks, OnExtAudioOutVolumeOffsetChanged(test_address, 2, _)).Times(1);
1214 EXPECT_CALL(callbacks, OnExtAudioOutLocationChanged(test_address, 1, _)).Times(1);
1215 EXPECT_CALL(callbacks, OnExtAudioOutLocationChanged(test_address, 2, _)).Times(1);
1216 EXPECT_CALL(callbacks, OnExtAudioOutDescriptionChanged(test_address, 1, _)).Times(1);
1217 EXPECT_CALL(callbacks, OnExtAudioOutDescriptionChanged(test_address, 2, _)).Times(1);
1218 std::vector<uint16_t> handles({0x0079, 0x008a});
1219 TestReadCharacteristic(test_address, 1, handles);
1220 }
1221
TEST_F(VolumeControlTest,test_discovery_vocs_found)1222 TEST_F(VolumeControlTest, test_discovery_vocs_found) {
1223 const RawAddress test_address = GetTestAddress(0);
1224 SetSampleDatabaseVOCS(1);
1225 TestAppRegister();
1226 TestConnect(test_address);
1227 EXPECT_CALL(callbacks, OnConnectionState(ConnectionState::CONNECTED, test_address));
1228 EXPECT_CALL(callbacks, OnDeviceAvailable(test_address, 2, _));
1229 GetConnectedEvent(test_address, 1);
1230 GetSearchCompleteEvent(1);
1231 Mock::VerifyAndClearExpectations(&callbacks);
1232 TestAppUnregister();
1233 }
1234
TEST_F(VolumeControlTest,test_discovery_vocs_not_found)1235 TEST_F(VolumeControlTest, test_discovery_vocs_not_found) {
1236 const RawAddress test_address = GetTestAddress(0);
1237 SetSampleDatabaseVCS(1);
1238 TestAppRegister();
1239 TestConnect(test_address);
1240 EXPECT_CALL(callbacks, OnConnectionState(ConnectionState::CONNECTED, test_address));
1241 EXPECT_CALL(callbacks, OnDeviceAvailable(test_address, 0, _));
1242 GetConnectedEvent(test_address, 1);
1243 GetSearchCompleteEvent(1);
1244 Mock::VerifyAndClearExpectations(&callbacks);
1245 TestAppUnregister();
1246 }
1247
TEST_F(VolumeControlTest,test_discovery_vocs_broken)1248 TEST_F(VolumeControlTest, test_discovery_vocs_broken) {
1249 const RawAddress test_address = GetTestAddress(0);
1250 SetSampleDatabaseVOCSBroken(1);
1251 TestAppRegister();
1252 TestConnect(test_address);
1253 EXPECT_CALL(callbacks, OnConnectionState(ConnectionState::CONNECTED, test_address));
1254 EXPECT_CALL(callbacks, OnDeviceAvailable(test_address, 1, _));
1255 GetConnectedEvent(test_address, 1);
1256 GetSearchCompleteEvent(1);
1257 Mock::VerifyAndClearExpectations(&callbacks);
1258 TestAppUnregister();
1259 }
1260
TEST_F(VolumeControlTest,test_read_vcs_database_out_of_sync)1261 TEST_F(VolumeControlTest, test_read_vcs_database_out_of_sync) {
1262 const RawAddress test_address = GetTestAddress(0);
1263 EXPECT_CALL(callbacks, OnVolumeStateChanged(test_address, _, _, _, true));
1264 std::vector<uint16_t> handles({0x0021});
1265 uint16_t conn_id = 1;
1266
1267 SetSampleDatabase(conn_id);
1268 TestAppRegister();
1269 TestConnect(test_address);
1270 GetConnectedEvent(test_address, conn_id);
1271
1272 EXPECT_CALL(gatt_queue, ReadCharacteristic(conn_id, _, _, _)).WillRepeatedly(DoDefault());
1273 for (auto const& handle : handles) {
1274 EXPECT_CALL(gatt_queue, ReadCharacteristic(conn_id, handle, _, _)).WillOnce(DoDefault());
1275 }
1276 GetSearchCompleteEvent(conn_id);
1277
1278 /* Simulate database change on the remote side. */
1279 ON_CALL(gatt_queue, WriteCharacteristic(_, _, _, _, _, _))
1280 .WillByDefault(Invoke([this](uint16_t conn_id, uint16_t handle,
1281 std::vector<uint8_t> value, tGATT_WRITE_TYPE /*write_type*/,
1282 GATT_WRITE_OP_CB cb, void* cb_data) {
1283 auto* svc = gatt::FindService(services_map[conn_id], handle);
1284 if (svc == nullptr) {
1285 return;
1286 }
1287
1288 tGATT_STATUS status = GATT_DATABASE_OUT_OF_SYNC;
1289 if (cb) {
1290 cb(conn_id, status, handle, value.size(), value.data(), cb_data);
1291 }
1292 }));
1293
1294 ON_CALL(gatt_interface, ServiceSearchRequest(_, _)).WillByDefault(Return());
1295 EXPECT_CALL(gatt_interface, ServiceSearchRequest(_, _));
1296 VolumeControl::Get()->SetVolume(test_address, 15);
1297 Mock::VerifyAndClearExpectations(&gatt_interface);
1298 TestAppUnregister();
1299 }
1300
1301 class VolumeControlCallbackTest : public VolumeControlTest {
1302 protected:
1303 const RawAddress test_address = GetTestAddress(0);
1304 uint16_t conn_id = 22;
1305
SetUp(void)1306 void SetUp(void) override {
1307 VolumeControlTest::SetUp();
1308 SetSampleDatabase(conn_id);
1309 TestAppRegister();
1310 TestConnect(test_address);
1311 GetConnectedEvent(test_address, conn_id);
1312 GetSearchCompleteEvent(conn_id);
1313 }
1314
TearDown(void)1315 void TearDown(void) override {
1316 TestAppUnregister();
1317 VolumeControlTest::TearDown();
1318 }
1319
GetNotificationEvent(uint16_t handle,const std::vector<uint8_t> & value)1320 void GetNotificationEvent(uint16_t handle, const std::vector<uint8_t>& value) {
1321 tBTA_GATTC_NOTIFY event_data = {
1322 .conn_id = conn_id,
1323 .bda = test_address,
1324 .handle = handle,
1325 .len = (uint8_t)value.size(),
1326 .is_notify = true,
1327 };
1328
1329 std::copy(value.begin(), value.end(), event_data.value);
1330 gatt_callback(BTA_GATTC_NOTIF_EVT, reinterpret_cast<tBTA_GATTC*>(&event_data));
1331 }
1332 };
1333
TEST_F(VolumeControlCallbackTest,test_volume_state_changed_stress)1334 TEST_F(VolumeControlCallbackTest, test_volume_state_changed_stress) {
1335 std::vector<uint8_t> value({0x03, 0x01, 0x02});
1336 EXPECT_CALL(callbacks, OnVolumeStateChanged(test_address, 0x03, true, _, true));
1337 GetNotificationEvent(0x0021, value);
1338 }
1339
TEST_F(VolumeControlCallbackTest,test_volume_state_changed_malformed)1340 TEST_F(VolumeControlCallbackTest, test_volume_state_changed_malformed) {
1341 EXPECT_CALL(callbacks, OnVolumeStateChanged(test_address, _, _, _, _)).Times(0);
1342 std::vector<uint8_t> too_short({0x03, 0x01});
1343 GetNotificationEvent(0x0021, too_short);
1344 std::vector<uint8_t> too_long({0x03, 0x01, 0x02, 0x03});
1345 GetNotificationEvent(0x0021, too_long);
1346 }
1347
TEST_F(VolumeControlCallbackTest,audio_input_state_changed__invalid_mute__is_rejected)1348 TEST_F(VolumeControlCallbackTest, audio_input_state_changed__invalid_mute__is_rejected) {
1349 uint8_t invalid_mute = 0x03;
1350 std::vector<uint8_t> value({0x03, invalid_mute, (uint8_t)GainMode::MANUAL, 0x04});
1351 EXPECT_CALL(callbacks, OnExtAudioInStateChanged(_, _, _, _, _)).Times(0);
1352 GetNotificationEvent(0x0032, value);
1353 }
1354
TEST_F(VolumeControlCallbackTest,audio_input_state_changed__invalid_gain_mode__is_rejected)1355 TEST_F(VolumeControlCallbackTest, audio_input_state_changed__invalid_gain_mode__is_rejected) {
1356 uint8_t invalid_gain_mode = 0x06;
1357 std::vector<uint8_t> value({0x03, (uint8_t)Mute::MUTED, invalid_gain_mode, 0x04});
1358 EXPECT_CALL(callbacks, OnExtAudioInStateChanged(_, _, _, _, _)).Times(0);
1359 GetNotificationEvent(0x0032, value);
1360 }
1361
TEST_F(VolumeControlCallbackTest,test_audio_input_state_changed__muted)1362 TEST_F(VolumeControlCallbackTest, test_audio_input_state_changed__muted) {
1363 std::vector<uint8_t> value({0x03, (uint8_t)Mute::MUTED, (uint8_t)GainMode::MANUAL, 0x04});
1364 EXPECT_CALL(callbacks,
1365 OnExtAudioInStateChanged(test_address, _, 0x03, Mute::MUTED, GainMode::MANUAL));
1366 GetNotificationEvent(0x0032, value);
1367 }
1368
TEST_F(VolumeControlCallbackTest,test_audio_input_state_changed__disabled)1369 TEST_F(VolumeControlCallbackTest, test_audio_input_state_changed__disabled) {
1370 std::vector<uint8_t> value({0x03, (uint8_t)Mute::DISABLED, (uint8_t)GainMode::MANUAL, 0x04});
1371 EXPECT_CALL(callbacks,
1372 OnExtAudioInStateChanged(test_address, _, 0x03, Mute::DISABLED, GainMode::MANUAL));
1373 GetNotificationEvent(0x0032, value);
1374 }
1375
TEST_F(VolumeControlCallbackTest,test_audio_input_state_changed_malformed)1376 TEST_F(VolumeControlCallbackTest, test_audio_input_state_changed_malformed) {
1377 EXPECT_CALL(callbacks, OnExtAudioInStateChanged(test_address, _, _, _, _)).Times(0);
1378 std::vector<uint8_t> too_short({0x03, 0x01, 0x02});
1379 GetNotificationEvent(0x0032, too_short);
1380 std::vector<uint8_t> too_long({0x03, 0x01, 0x02, 0x04, 0x05});
1381 GetNotificationEvent(0x0032, too_long);
1382 }
1383
TEST_F(VolumeControlCallbackTest,test_audio_gain_props_changed)1384 TEST_F(VolumeControlCallbackTest, test_audio_gain_props_changed) {
1385 std::vector<uint8_t> value({0x03, 0x01, 0x02});
1386 EXPECT_CALL(callbacks,
1387 OnExtAudioInGainSettingPropertiesChanged(test_address, _, 0x03, 0x01, 0x02));
1388 GetNotificationEvent(0x0055, value);
1389 }
1390
TEST_F(VolumeControlCallbackTest,test_audio_gain_props_changed_malformed)1391 TEST_F(VolumeControlCallbackTest, test_audio_gain_props_changed_malformed) {
1392 EXPECT_CALL(callbacks, OnExtAudioInGainSettingPropertiesChanged(test_address, _, _, _, _))
1393 .Times(0);
1394 std::vector<uint8_t> too_short({0x03, 0x01});
1395 GetNotificationEvent(0x0055, too_short);
1396 std::vector<uint8_t> too_long({0x03, 0x01, 0x02, 0x03});
1397 GetNotificationEvent(0x0055, too_long);
1398 }
1399
TEST_F(VolumeControlCallbackTest,test_audio_input_status_changed)1400 TEST_F(VolumeControlCallbackTest, test_audio_input_status_changed) {
1401 std::vector<uint8_t> value({static_cast<uint8_t>(bluetooth::vc::VolumeInputStatus::Inactive)});
1402 EXPECT_CALL(callbacks, OnExtAudioInStatusChanged(test_address, _,
1403 bluetooth::vc::VolumeInputStatus::Inactive));
1404 GetNotificationEvent(0x0039, value);
1405 }
1406
TEST_F(VolumeControlCallbackTest,test_audio_input_status_changed_malformed)1407 TEST_F(VolumeControlCallbackTest, test_audio_input_status_changed_malformed) {
1408 EXPECT_CALL(callbacks, OnExtAudioInStatusChanged(test_address, _, _)).Times(0);
1409 std::vector<uint8_t> too_short(0);
1410 GetNotificationEvent(0x0039, too_short);
1411 std::vector<uint8_t> too_long({0x03, 0x01});
1412 GetNotificationEvent(0x0039, too_long);
1413 }
1414
TEST_F(VolumeControlCallbackTest,test_audio_input_description_changed)1415 TEST_F(VolumeControlCallbackTest, test_audio_input_description_changed) {
1416 std::string description = "SPDIF";
1417 std::vector<uint8_t> value(description.begin(), description.end());
1418 EXPECT_CALL(callbacks, OnExtAudioInDescriptionChanged(test_address, _, description, _));
1419 GetNotificationEvent(0x005e, value);
1420 }
1421
TEST_F(VolumeControlCallbackTest,test_volume_offset_changed)1422 TEST_F(VolumeControlCallbackTest, test_volume_offset_changed) {
1423 std::vector<uint8_t> value({0x04, 0x05, 0x06});
1424 EXPECT_CALL(callbacks, OnExtAudioOutVolumeOffsetChanged(test_address, 2, 0x0504));
1425 GetNotificationEvent(0x0082, value);
1426 }
1427
TEST_F(VolumeControlCallbackTest,test_volume_offset_changed_malformed)1428 TEST_F(VolumeControlCallbackTest, test_volume_offset_changed_malformed) {
1429 EXPECT_CALL(callbacks, OnExtAudioOutVolumeOffsetChanged(test_address, 2, _)).Times(0);
1430 std::vector<uint8_t> too_short({0x04});
1431 GetNotificationEvent(0x0082, too_short);
1432 std::vector<uint8_t> too_long({0x04, 0x05, 0x06, 0x07});
1433 GetNotificationEvent(0x0082, too_long);
1434 }
1435
TEST_F(VolumeControlCallbackTest,test_offset_location_changed)1436 TEST_F(VolumeControlCallbackTest, test_offset_location_changed) {
1437 std::vector<uint8_t> value({0x01, 0x02, 0x03, 0x04});
1438 EXPECT_CALL(callbacks, OnExtAudioOutLocationChanged(test_address, 2, 0x04030201));
1439 GetNotificationEvent(0x0085, value);
1440 }
1441
TEST_F(VolumeControlCallbackTest,test_offset_location_changed_malformed)1442 TEST_F(VolumeControlCallbackTest, test_offset_location_changed_malformed) {
1443 EXPECT_CALL(callbacks, OnExtAudioOutLocationChanged(test_address, 2, _)).Times(0);
1444 std::vector<uint8_t> too_short({0x04});
1445 GetNotificationEvent(0x0085, too_short);
1446 std::vector<uint8_t> too_long({0x04, 0x05, 0x06});
1447 GetNotificationEvent(0x0085, too_long);
1448 }
1449
TEST_F(VolumeControlCallbackTest,test_audio_output_description_changed)1450 TEST_F(VolumeControlCallbackTest, test_audio_output_description_changed) {
1451 std::string descr = "left";
1452 std::vector<uint8_t> value(descr.begin(), descr.end());
1453 EXPECT_CALL(callbacks, OnExtAudioOutDescriptionChanged(test_address, 2, descr));
1454 GetNotificationEvent(0x008a, value);
1455 }
1456
1457 class VolumeControlValueGetTest : public VolumeControlTest {
1458 protected:
1459 const RawAddress test_address = GetTestAddress(0);
1460 uint16_t conn_id = 22;
1461 GATT_READ_OP_CB cb;
1462 void* cb_data;
1463 uint16_t handle;
1464
SetUp(void)1465 void SetUp(void) override {
1466 VolumeControlTest::SetUp();
1467 SetSampleDatabase(conn_id);
1468 TestAppRegister();
1469 TestConnect(test_address);
1470 GetConnectedEvent(test_address, conn_id);
1471 GetSearchCompleteEvent(conn_id);
1472 EXPECT_CALL(gatt_queue, ReadCharacteristic(conn_id, _, _, _))
1473 .WillOnce(DoAll(SaveArg<1>(&handle), SaveArg<2>(&cb), SaveArg<3>(&cb_data)));
1474 }
1475
TearDown(void)1476 void TearDown(void) override {
1477 TestAppUnregister();
1478 cb = nullptr;
1479 cb_data = nullptr;
1480 handle = 0;
1481 VolumeControlTest::TearDown();
1482 }
1483 };
1484
TEST_F(VolumeControlValueGetTest,test_get_ext_audio_out_volume_offset)1485 TEST_F(VolumeControlValueGetTest, test_get_ext_audio_out_volume_offset) {
1486 VolumeControl::Get()->GetExtAudioOutVolumeOffset(test_address, 1);
1487 EXPECT_TRUE(cb);
1488 std::vector<uint8_t> value({0x01, 0x02, 0x03});
1489 EXPECT_CALL(callbacks, OnExtAudioOutVolumeOffsetChanged(test_address, 1, 0x0201));
1490 cb(conn_id, GATT_SUCCESS, handle, (uint16_t)value.size(), value.data(), cb_data);
1491 }
1492
TEST_F(VolumeControlValueGetTest,test_get_ext_audio_out_location)1493 TEST_F(VolumeControlValueGetTest, test_get_ext_audio_out_location) {
1494 VolumeControl::Get()->GetExtAudioOutLocation(test_address, 2);
1495 EXPECT_TRUE(cb);
1496 std::vector<uint8_t> value({0x01, 0x02, 0x03, 0x04});
1497 EXPECT_CALL(callbacks, OnExtAudioOutLocationChanged(test_address, 2, 0x04030201));
1498 cb(conn_id, GATT_SUCCESS, handle, (uint16_t)value.size(), value.data(), cb_data);
1499 }
1500
TEST_F(VolumeControlValueGetTest,test_get_ext_audio_out_description)1501 TEST_F(VolumeControlValueGetTest, test_get_ext_audio_out_description) {
1502 VolumeControl::Get()->GetExtAudioOutDescription(test_address, 2);
1503 EXPECT_TRUE(cb);
1504 std::string descr = "right";
1505 std::vector<uint8_t> value(descr.begin(), descr.end());
1506 EXPECT_CALL(callbacks, OnExtAudioOutDescriptionChanged(test_address, 2, descr));
1507 cb(conn_id, GATT_SUCCESS, handle, (uint16_t)value.size(), value.data(), cb_data);
1508 }
1509
TEST_F(VolumeControlValueGetTest,test_get_ext_audio_in_state)1510 TEST_F(VolumeControlValueGetTest, test_get_ext_audio_in_state) {
1511 VolumeControl::Get()->GetExtAudioInState(test_address, 1);
1512 EXPECT_TRUE(cb);
1513 std::vector<uint8_t> value({0x01, (uint8_t)Mute::NOT_MUTED, (uint8_t)GainMode::MANUAL, 0x03});
1514 EXPECT_CALL(callbacks,
1515 OnExtAudioInStateChanged(test_address, 1, 0x01, Mute::NOT_MUTED, GainMode::MANUAL));
1516 cb(conn_id, GATT_SUCCESS, handle, (uint16_t)value.size(), value.data(), cb_data);
1517 }
1518
TEST_F(VolumeControlValueGetTest,test_get_ext_audio_in_status)1519 TEST_F(VolumeControlValueGetTest, test_get_ext_audio_in_status) {
1520 VolumeControl::Get()->GetExtAudioInStatus(test_address, 0);
1521 EXPECT_TRUE(cb);
1522 std::vector<uint8_t> value({static_cast<uint8_t>(bluetooth::vc::VolumeInputStatus::Active)});
1523 EXPECT_CALL(callbacks,
1524 OnExtAudioInStatusChanged(test_address, 0, bluetooth::vc::VolumeInputStatus::Active));
1525 cb(conn_id, GATT_SUCCESS, handle, (uint16_t)value.size(), value.data(), cb_data);
1526 }
1527
TEST_F(VolumeControlValueGetTest,test_get_ext_audio_in_gain_props)1528 TEST_F(VolumeControlValueGetTest, test_get_ext_audio_in_gain_props) {
1529 VolumeControl::Get()->GetExtAudioInGainProps(test_address, 0);
1530 EXPECT_TRUE(cb);
1531 std::vector<uint8_t> value({0x01, 0x02, 0x03});
1532 EXPECT_CALL(callbacks,
1533 OnExtAudioInGainSettingPropertiesChanged(test_address, 0, 0x01, 0x02, 0x03));
1534 cb(conn_id, GATT_SUCCESS, handle, (uint16_t)value.size(), value.data(), cb_data);
1535 }
1536
TEST_F(VolumeControlValueGetTest,test_get_ext_audio_in_description)1537 TEST_F(VolumeControlValueGetTest, test_get_ext_audio_in_description) {
1538 VolumeControl::Get()->GetExtAudioInDescription(test_address, 1);
1539 EXPECT_TRUE(cb);
1540 std::string description = "AUX-IN";
1541 std::vector<uint8_t> value(description.begin(), description.end());
1542 EXPECT_CALL(callbacks, OnExtAudioInDescriptionChanged(test_address, 1, description, _));
1543 cb(conn_id, GATT_SUCCESS, handle, (uint16_t)value.size(), value.data(), cb_data);
1544 }
1545
TEST_F(VolumeControlValueGetTest,test_get_ext_audio_in_type)1546 TEST_F(VolumeControlValueGetTest, test_get_ext_audio_in_type) {
1547 VolumeControl::Get()->GetExtAudioInType(test_address, 1);
1548 EXPECT_TRUE(cb);
1549 std::vector<uint8_t> value({static_cast<uint8_t>(bluetooth::vc::VolumeInputType::Ambient)});
1550 EXPECT_CALL(callbacks,
1551 OnExtAudioInTypeChanged(test_address, 1, bluetooth::vc::VolumeInputType::Ambient));
1552 cb(conn_id, GATT_SUCCESS, handle, (uint16_t)value.size(), value.data(), cb_data);
1553 }
1554
1555 class VolumeControlValueSetTest : public VolumeControlTest {
1556 protected:
1557 const RawAddress test_address = GetTestAddress(0);
1558 uint16_t conn_id = 22;
1559
SetUp(void)1560 void SetUp(void) override {
1561 VolumeControlTest::SetUp();
1562 SetSampleDatabase(conn_id);
1563 TestAppRegister();
1564 TestConnect(test_address);
1565 GetConnectedEvent(test_address, conn_id);
1566 GetSearchCompleteEvent(conn_id);
1567
1568 ON_CALL(gatt_queue, WriteCharacteristic(conn_id, 0x0024, _, GATT_WRITE, _, _))
1569 .WillByDefault([this](uint16_t conn_id, uint16_t /*handle*/, std::vector<uint8_t> value,
1570 tGATT_WRITE_TYPE /*write_type*/, GATT_WRITE_OP_CB cb,
1571 void* cb_data) {
1572 uint8_t write_rsp;
1573
1574 std::vector<uint8_t> ntf_value({value[0], 0, static_cast<uint8_t>(value[1] + 1)});
1575 switch (value[0]) {
1576 case 0x06: // mute
1577 ntf_value[1] = 1;
1578 break;
1579 case 0x05: // unmute
1580 break;
1581 case 0x04: // set abs. volume
1582 ntf_value[0] = value[2];
1583 ntf_value[1] = (value[2] ? 0 : 1);
1584 break;
1585 case 0x03: // unmute rel. up
1586 break;
1587 case 0x02: // unmute rel. down
1588 break;
1589 case 0x01: // rel. up
1590 break;
1591 case 0x00: // rel. down
1592 break;
1593 default:
1594 break;
1595 }
1596 GetNotificationEvent(0x0021, ntf_value);
1597 cb(conn_id, GATT_SUCCESS, 0x0024, 0, &write_rsp, cb_data);
1598 });
1599 }
1600
GetNotificationEvent(uint16_t handle,const std::vector<uint8_t> & value)1601 void GetNotificationEvent(uint16_t handle, const std::vector<uint8_t>& value) {
1602 tBTA_GATTC_NOTIFY event_data = {
1603 .conn_id = conn_id,
1604 .bda = test_address,
1605 .handle = handle,
1606 .len = (uint8_t)value.size(),
1607 .is_notify = true,
1608 };
1609
1610 std::copy(value.begin(), value.end(), event_data.value);
1611 gatt_callback(BTA_GATTC_NOTIF_EVT, reinterpret_cast<tBTA_GATTC*>(&event_data));
1612 }
1613
TearDown(void)1614 void TearDown(void) override {
1615 TestAppUnregister();
1616 VolumeControlTest::TearDown();
1617 }
1618 };
1619
TEST_F(VolumeControlValueSetTest,test_volume_operation_failed)1620 TEST_F(VolumeControlValueSetTest, test_volume_operation_failed) {
1621 const std::vector<uint8_t> vol_x10({0x04, 0x00, 0x10});
1622 EXPECT_CALL(gatt_queue, WriteCharacteristic(conn_id, 0x0024, vol_x10, GATT_WRITE, _, _)).Times(1);
1623 ON_CALL(gatt_queue, WriteCharacteristic(_, _, _, _, _, _))
1624 .WillByDefault(Invoke([this](uint16_t conn_id, uint16_t handle,
1625 std::vector<uint8_t> value, tGATT_WRITE_TYPE /*write_type*/,
1626 GATT_WRITE_OP_CB cb, void* cb_data) {
1627 auto* svc = gatt::FindService(services_map[conn_id], handle);
1628 if (svc == nullptr) {
1629 return;
1630 }
1631
1632 tGATT_STATUS status = GATT_ERROR;
1633 if (cb) {
1634 cb(conn_id, status, handle, value.size(), value.data(), cb_data);
1635 }
1636 }));
1637
1638 EXPECT_CALL(*AlarmMock::Get(), AlarmSetOnMloop(_, _, _, _)).Times(1);
1639 EXPECT_CALL(*AlarmMock::Get(), AlarmCancel(_)).Times(1);
1640 VolumeControl::Get()->SetVolume(test_address, 0x10);
1641
1642 Mock::VerifyAndClearExpectations(&gatt_queue);
1643 Mock::VerifyAndClearExpectations(AlarmMock::Get());
1644 }
1645
TEST_F(VolumeControlValueSetTest,test_volume_operation_failed_due_to_device_disconnection)1646 TEST_F(VolumeControlValueSetTest, test_volume_operation_failed_due_to_device_disconnection) {
1647 const std::vector<uint8_t> vol_x10({0x04, 0x00, 0x10});
1648 EXPECT_CALL(gatt_queue, WriteCharacteristic(conn_id, 0x0024, vol_x10, GATT_WRITE, _, _)).Times(1);
1649 ON_CALL(gatt_queue, WriteCharacteristic(_, _, _, _, _, _))
1650 .WillByDefault(Invoke([](uint16_t /*conn_id*/, uint16_t /*handle*/,
1651 std::vector<uint8_t> /*value*/, tGATT_WRITE_TYPE /*write_type*/,
1652 GATT_WRITE_OP_CB /*cb*/, void* /*cb_data*/) {
1653 /* Do nothing */
1654 }));
1655
1656 EXPECT_CALL(*AlarmMock::Get(), AlarmSetOnMloop(_, _, _, _)).Times(0);
1657
1658 alarm_callback_t active_alarm_cb = nullptr;
1659 EXPECT_CALL(*AlarmMock::Get(), AlarmSetOnMloop(_, _, _, _))
1660 .WillOnce(Invoke([&](alarm_t* alarm, uint64_t /*interval_ms*/, alarm_callback_t cb,
1661 void* /*data*/) {
1662 if (alarm) {
1663 alarm->on_main_loop = true;
1664 alarm->cb = cb;
1665 active_alarm_cb = cb;
1666 }
1667 }));
1668 ON_CALL(*AlarmMock::Get(), AlarmCancel(_)).WillByDefault(Invoke([&](alarm_t* alarm) {
1669 if (alarm) {
1670 alarm->cb = nullptr;
1671 alarm->on_main_loop = false;
1672 active_alarm_cb = nullptr;
1673 }
1674 }));
1675
1676 VolumeControl::Get()->SetVolume(test_address, 0x10);
1677
1678 Mock::VerifyAndClearExpectations(&gatt_queue);
1679 Mock::VerifyAndClearExpectations(AlarmMock::Get());
1680 ASSERT_NE(active_alarm_cb, nullptr);
1681
1682 EXPECT_CALL(*AlarmMock::Get(), AlarmCancel(_)).Times(1);
1683 EXPECT_CALL(callbacks, OnConnectionState(ConnectionState::DISCONNECTED, test_address));
1684 GetDisconnectedEvent(test_address, conn_id);
1685
1686 ASSERT_EQ(active_alarm_cb, nullptr);
1687 Mock::VerifyAndClearExpectations(&callbacks);
1688 }
1689
TEST_F(VolumeControlValueSetTest,test_set_volume)1690 TEST_F(VolumeControlValueSetTest, test_set_volume) {
1691 const std::vector<uint8_t> vol_x10({0x04, 0x00, 0x10});
1692 EXPECT_CALL(gatt_queue, WriteCharacteristic(conn_id, 0x0024, vol_x10, GATT_WRITE, _, _)).Times(1);
1693 VolumeControl::Get()->SetVolume(test_address, 0x10);
1694
1695 // Same volume level should not be applied twice
1696 const std::vector<uint8_t> vol_x10_2({0x04, 0x01, 0x10});
1697 EXPECT_CALL(gatt_queue, WriteCharacteristic(conn_id, 0x0024, vol_x10_2, GATT_WRITE, _, _))
1698 .Times(0);
1699 VolumeControl::Get()->SetVolume(test_address, 0x10);
1700
1701 const std::vector<uint8_t> vol_x20({0x04, 0x01, 0x20});
1702 EXPECT_CALL(gatt_queue, WriteCharacteristic(conn_id, 0x0024, vol_x20, GATT_WRITE, _, _)).Times(1);
1703 VolumeControl::Get()->SetVolume(test_address, 0x20);
1704 }
1705
TEST_F(VolumeControlValueSetTest,test_set_volume_stress)1706 TEST_F(VolumeControlValueSetTest, test_set_volume_stress) {
1707 uint8_t n = 100;
1708 uint8_t change_cnt = 0;
1709 uint8_t vol = 1;
1710
1711 for (uint8_t i = 1; i < n; i++) {
1712 const std::vector<uint8_t> vol_x10({0x04, change_cnt, vol});
1713 EXPECT_CALL(gatt_queue, WriteCharacteristic(conn_id, 0x0024, vol_x10, GATT_WRITE, _, _))
1714 .Times(1);
1715 VolumeControl::Get()->SetVolume(test_address, vol);
1716 Mock::VerifyAndClearExpectations(&gatt_queue);
1717 change_cnt++;
1718 vol++;
1719 }
1720 }
1721
TEST_F(VolumeControlValueSetTest,test_set_volume_stress_2)1722 TEST_F(VolumeControlValueSetTest, test_set_volume_stress_2) {
1723 uint8_t change_cnt = 0;
1724 uint8_t vol = 1;
1725
1726 // In this test we simulate notification coming later and operations will be
1727 // queued
1728 ON_CALL(gatt_queue, WriteCharacteristic(conn_id, 0x0024, _, GATT_WRITE, _, _))
1729 .WillByDefault([](uint16_t conn_id, uint16_t handle, std::vector<uint8_t> value,
1730 tGATT_WRITE_TYPE /*write_type*/, GATT_WRITE_OP_CB cb, void* cb_data) {
1731 uint8_t write_rsp;
1732
1733 switch (value[0]) {
1734 case 0x04: // set abs. volume
1735 break;
1736 default:
1737 break;
1738 }
1739 cb(conn_id, GATT_SUCCESS, handle, 0, &write_rsp, cb_data);
1740 });
1741
1742 const std::vector<uint8_t> vol_x10({0x04, /*change_cnt*/ 0, 0x10});
1743 std::vector<uint8_t> ntf_value_x10({0x10, 0, 1});
1744 const std::vector<uint8_t> vol_x11({0x04, /*change_cnt*/ 1, 0x11});
1745 std::vector<uint8_t> ntf_value_x11({0x11, 0, 2});
1746 const std::vector<uint8_t> vol_x12({0x04, /*change_cnt*/ 2, 0x12});
1747 std::vector<uint8_t> ntf_value_x12({0x12, 0, 3});
1748 const std::vector<uint8_t> vol_x13({0x04, /*change_cnt*/ 3, 0x13});
1749 std::vector<uint8_t> ntf_value_x13({0x13, 0, 4});
1750
1751 EXPECT_CALL(gatt_queue, WriteCharacteristic(conn_id, 0x0024, vol_x10, GATT_WRITE, _, _)).Times(1);
1752 EXPECT_CALL(gatt_queue, WriteCharacteristic(conn_id, 0x0024, vol_x11, GATT_WRITE, _, _)).Times(1);
1753 EXPECT_CALL(gatt_queue, WriteCharacteristic(conn_id, 0x0024, vol_x12, GATT_WRITE, _, _)).Times(1);
1754 EXPECT_CALL(gatt_queue, WriteCharacteristic(conn_id, 0x0024, vol_x13, GATT_WRITE, _, _)).Times(1);
1755
1756 VolumeControl::Get()->SetVolume(test_address, 0x10);
1757 VolumeControl::Get()->SetVolume(test_address, 0x11);
1758 GetNotificationEvent(0x0021, ntf_value_x10);
1759 GetNotificationEvent(0x0021, ntf_value_x11);
1760 VolumeControl::Get()->SetVolume(test_address, 0x12);
1761 VolumeControl::Get()->SetVolume(test_address, 0x13);
1762 GetNotificationEvent(0x0021, ntf_value_x12);
1763 GetNotificationEvent(0x0021, ntf_value_x13);
1764
1765 Mock::VerifyAndClearExpectations(&gatt_queue);
1766 }
1767
TEST_F(VolumeControlValueSetTest,test_set_volume_stress_3)1768 TEST_F(VolumeControlValueSetTest, test_set_volume_stress_3) {
1769 uint8_t change_cnt = 0;
1770 uint8_t vol = 1;
1771
1772 /* In this test we simulate notification coming later and operations will be
1773 * queued but some will be removed from the queue
1774 */
1775 ON_CALL(gatt_queue, WriteCharacteristic(conn_id, 0x0024, _, GATT_WRITE, _, _))
1776 .WillByDefault([](uint16_t conn_id, uint16_t handle, std::vector<uint8_t> value,
1777 tGATT_WRITE_TYPE /*write_type*/, GATT_WRITE_OP_CB cb, void* cb_data) {
1778 uint8_t write_rsp;
1779
1780 switch (value[0]) {
1781 case 0x04: // set abs. volume
1782 break;
1783 default:
1784 break;
1785 }
1786 cb(conn_id, GATT_SUCCESS, handle, 0, &write_rsp, cb_data);
1787 });
1788
1789 const std::vector<uint8_t> vol_x10({0x04, /*change_cnt*/ 0, 0x10});
1790 std::vector<uint8_t> ntf_value_x10({0x10, 0, 1});
1791 const std::vector<uint8_t> vol_x11({0x04, /*change_cnt*/ 1, 0x11});
1792 std::vector<uint8_t> ntf_value_x11({0x11, 0, 2});
1793 const std::vector<uint8_t> vol_x12({0x04, /*change_cnt*/ 1, 0x12});
1794 std::vector<uint8_t> ntf_value_x12({0x12, 0, 3});
1795 const std::vector<uint8_t> vol_x13({0x04, /*change_cnt*/ 1, 0x13});
1796 std::vector<uint8_t> ntf_value_x13({0x13, 0, 4});
1797
1798 EXPECT_CALL(gatt_queue, WriteCharacteristic(conn_id, 0x0024, vol_x10, GATT_WRITE, _, _)).Times(1);
1799
1800 // Those two belowe will be removed from the queue
1801 EXPECT_CALL(gatt_queue, WriteCharacteristic(conn_id, 0x0024, vol_x11, GATT_WRITE, _, _)).Times(0);
1802 EXPECT_CALL(gatt_queue, WriteCharacteristic(conn_id, 0x0024, vol_x12, GATT_WRITE, _, _)).Times(0);
1803
1804 // This one shall be sent with a change count 1.
1805 EXPECT_CALL(gatt_queue, WriteCharacteristic(conn_id, 0x0024, vol_x13, GATT_WRITE, _, _)).Times(1);
1806
1807 VolumeControl::Get()->SetVolume(test_address, 0x10);
1808 VolumeControl::Get()->SetVolume(test_address, 0x11);
1809 VolumeControl::Get()->SetVolume(test_address, 0x12);
1810 VolumeControl::Get()->SetVolume(test_address, 0x13);
1811 GetNotificationEvent(0x0021, ntf_value_x10);
1812 GetNotificationEvent(0x0021, ntf_value_x11);
1813 GetNotificationEvent(0x0021, ntf_value_x12);
1814 GetNotificationEvent(0x0021, ntf_value_x13);
1815
1816 Mock::VerifyAndClearExpectations(&gatt_queue);
1817 }
1818
TEST_F(VolumeControlValueSetTest,test_mute_unmute)1819 TEST_F(VolumeControlValueSetTest, test_mute_unmute) {
1820 std::vector<uint8_t> mute_x0({0x06, 0x00});
1821 EXPECT_CALL(gatt_queue, WriteCharacteristic(conn_id, 0x0024, mute_x0, GATT_WRITE, _, _)).Times(1);
1822 // Don't mute when already muted
1823 std::vector<uint8_t> mute_x1({0x06, 0x01});
1824 EXPECT_CALL(gatt_queue, WriteCharacteristic(conn_id, 0x0024, mute_x1, GATT_WRITE, _, _)).Times(0);
1825 VolumeControl::Get()->Mute(test_address);
1826 VolumeControl::Get()->Mute(test_address);
1827
1828 // Needs to be muted to unmute
1829 std::vector<uint8_t> unmute_x1({0x05, 0x01});
1830 EXPECT_CALL(gatt_queue, WriteCharacteristic(conn_id, 0x0024, unmute_x1, GATT_WRITE, _, _))
1831 .Times(1);
1832 // Don't unmute when already unmuted
1833 std::vector<uint8_t> unmute_x2({0x05, 0x02});
1834 EXPECT_CALL(gatt_queue, WriteCharacteristic(conn_id, 0x0024, unmute_x2, GATT_WRITE, _, _))
1835 .Times(0);
1836 VolumeControl::Get()->UnMute(test_address);
1837 VolumeControl::Get()->UnMute(test_address);
1838 }
1839
TEST_F(VolumeControlValueSetTest,test_set_ext_audio_out_volume_offset)1840 TEST_F(VolumeControlValueSetTest, test_set_ext_audio_out_volume_offset) {
1841 std::vector<uint8_t> expected_data({0x01, 0x00, 0x34, 0x12});
1842 EXPECT_CALL(gatt_queue, WriteCharacteristic(conn_id, 0x0088, expected_data, GATT_WRITE, _, _));
1843 VolumeControl::Get()->SetExtAudioOutVolumeOffset(test_address, 2, 0x1234);
1844 }
1845
TEST_F(VolumeControlValueSetTest,test_set_ext_audio_out_location)1846 TEST_F(VolumeControlValueSetTest, test_set_ext_audio_out_location) {
1847 std::vector<uint8_t> expected_data({0x44, 0x33, 0x22, 0x11});
1848 EXPECT_CALL(gatt_queue,
1849 WriteCharacteristic(conn_id, 0x0085, expected_data, GATT_WRITE_NO_RSP, _, _));
1850 VolumeControl::Get()->SetExtAudioOutLocation(test_address, 2, 0x11223344);
1851 }
1852
TEST_F(VolumeControlValueSetTest,test_set_ext_audio_out_location_non_writable)1853 TEST_F(VolumeControlValueSetTest, test_set_ext_audio_out_location_non_writable) {
1854 EXPECT_CALL(gatt_queue, WriteCharacteristic(_, _, _, _, _, _)).Times(0);
1855 VolumeControl::Get()->SetExtAudioOutLocation(test_address, 1, 0x11223344);
1856 }
1857
TEST_F(VolumeControlValueSetTest,test_set_ext_audio_out_description)1858 TEST_F(VolumeControlValueSetTest, test_set_ext_audio_out_description) {
1859 std::string descr = "right front";
1860 std::vector<uint8_t> expected_data(descr.begin(), descr.end());
1861 EXPECT_CALL(gatt_queue,
1862 WriteCharacteristic(conn_id, 0x008a, expected_data, GATT_WRITE_NO_RSP, _, _));
1863 VolumeControl::Get()->SetExtAudioOutDescription(test_address, 2, descr);
1864 }
1865
TEST_F(VolumeControlValueSetTest,test_set_ext_audio_out_description_non_writable)1866 TEST_F(VolumeControlValueSetTest, test_set_ext_audio_out_description_non_writable) {
1867 std::string descr = "left front";
1868 EXPECT_CALL(gatt_queue, WriteCharacteristic(_, _, _, _, _, _)).Times(0);
1869 VolumeControl::Get()->SetExtAudioOutDescription(test_address, 1, descr);
1870 }
1871
TEST_F(VolumeControlValueSetTest,test_set_ext_audio_in_description)1872 TEST_F(VolumeControlValueSetTest, test_set_ext_audio_in_description) {
1873 std::string descr = "HDMI";
1874 std::vector<uint8_t> expected_data(descr.begin(), descr.end());
1875 EXPECT_CALL(gatt_queue,
1876 WriteCharacteristic(conn_id, 0x005e, expected_data, GATT_WRITE_NO_RSP, _, _));
1877 VolumeControl::Get()->SetExtAudioInDescription(test_address, 1, descr);
1878 }
1879
TEST_F(VolumeControlValueSetTest,test_set_ext_audio_in_description_non_writable)1880 TEST_F(VolumeControlValueSetTest, test_set_ext_audio_in_description_non_writable) {
1881 std::string descr = "AUX";
1882 std::vector<uint8_t> expected_data(descr.begin(), descr.end());
1883 EXPECT_CALL(gatt_queue, WriteCharacteristic(_, _, _, _, _, _)).Times(0);
1884 VolumeControl::Get()->SetExtAudioInDescription(test_address, 0, descr);
1885 }
1886
TEST_F(VolumeControlValueSetTest,test_set_ext_audio_in_gain_setting)1887 TEST_F(VolumeControlValueSetTest, test_set_ext_audio_in_gain_setting) {
1888 std::vector<uint8_t> expected_data({0x01, 0x00, 0x34});
1889 EXPECT_CALL(gatt_queue, WriteCharacteristic(conn_id, 0x005c, expected_data, GATT_WRITE, _, _));
1890 VolumeControl::Get()->SetExtAudioInGainSetting(test_address, 1, 0x34);
1891 }
1892
TEST_F(VolumeControlValueSetTest,test_set_ext_audio_in_gain_mode)1893 TEST_F(VolumeControlValueSetTest, test_set_ext_audio_in_gain_mode) {
1894 std::vector<uint8_t> mode_manual({0x04, 0x00}); // 0x04 is the opcode for Manual
1895 EXPECT_CALL(gatt_queue, WriteCharacteristic(conn_id, 0x005c, mode_manual, GATT_WRITE, _, _));
1896 VolumeControl::Get()->SetExtAudioInGainMode(test_address, 1, GainMode::MANUAL);
1897 std::vector<uint8_t> mode_automatic({0x05, 0x00}); // 0x05 is the opcode for Automatic
1898 EXPECT_CALL(gatt_queue, WriteCharacteristic(conn_id, 0x005c, mode_automatic, GATT_WRITE, _, _));
1899 VolumeControl::Get()->SetExtAudioInGainMode(test_address, 1, GainMode::AUTOMATIC);
1900 }
1901
TEST_F(VolumeControlValueSetTest,test_set_ext_audio_in_gain_mute)1902 TEST_F(VolumeControlValueSetTest, test_set_ext_audio_in_gain_mute) {
1903 std::vector<uint8_t> mute({0x03, 0x00}); // 0x03 is the opcode for Mute
1904 EXPECT_CALL(gatt_queue, WriteCharacteristic(conn_id, 0x005c, mute, GATT_WRITE, _, _));
1905 VolumeControl::Get()->SetExtAudioInMute(test_address, 1, Mute::MUTED);
1906 std::vector<uint8_t> unmute({0x02, 0x00}); // 0x02 is the opcode for UnMute
1907 EXPECT_CALL(gatt_queue, WriteCharacteristic(conn_id, 0x005c, unmute, GATT_WRITE, _, _));
1908 VolumeControl::Get()->SetExtAudioInMute(test_address, 1, Mute::NOT_MUTED);
1909 }
1910
1911 class VolumeControlCsis : public VolumeControlTest {
1912 protected:
1913 const RawAddress test_address_1 = GetTestAddress(0);
1914 const RawAddress test_address_2 = GetTestAddress(1);
1915 std::vector<RawAddress> csis_group = {test_address_1, test_address_2};
1916
1917 uint16_t conn_id_1 = 22;
1918 uint16_t conn_id_2 = 33;
1919 int group_id = 5;
1920
SetUp(void)1921 void SetUp(void) override {
1922 VolumeControlTest::SetUp();
1923
1924 ON_CALL(mock_csis_client_module_, Get()).WillByDefault(Return(&mock_csis_client_module_));
1925
1926 // Report working CSIS
1927 ON_CALL(mock_csis_client_module_, IsCsisClientRunning()).WillByDefault(Return(true));
1928
1929 ON_CALL(mock_csis_client_module_, GetDeviceList(_)).WillByDefault(Return(csis_group));
1930
1931 ON_CALL(mock_csis_client_module_, GetGroupId(_, _)).WillByDefault(Return(group_id));
1932
1933 SetSampleDatabase(conn_id_1);
1934 SetSampleDatabase(conn_id_2);
1935
1936 TestAppRegister();
1937 }
1938
TearDown(void)1939 void TearDown(void) override {
1940 TestAppUnregister();
1941 VolumeControlTest::TearDown();
1942 }
1943
GetNotificationEvent(uint16_t conn_id,const RawAddress & test_address,uint16_t handle,const std::vector<uint8_t> & value)1944 void GetNotificationEvent(uint16_t conn_id, const RawAddress& test_address, uint16_t handle,
1945 const std::vector<uint8_t>& value) {
1946 tBTA_GATTC_NOTIFY event_data = {
1947 .conn_id = conn_id,
1948 .bda = test_address,
1949 .handle = handle,
1950 .len = (uint8_t)value.size(),
1951 .is_notify = true,
1952 };
1953
1954 std::copy(value.begin(), value.end(), event_data.value);
1955 gatt_callback(BTA_GATTC_NOTIF_EVT, reinterpret_cast<tBTA_GATTC*>(&event_data));
1956 }
1957 };
1958
TEST_F(VolumeControlCsis,test_set_volume)1959 TEST_F(VolumeControlCsis, test_set_volume) {
1960 TestConnect(test_address_1);
1961 GetConnectedEvent(test_address_1, conn_id_1);
1962 GetSearchCompleteEvent(conn_id_1);
1963 TestConnect(test_address_2);
1964 GetConnectedEvent(test_address_2, conn_id_2);
1965 GetSearchCompleteEvent(conn_id_2);
1966
1967 /* Set value for the group */
1968 EXPECT_CALL(gatt_queue, WriteCharacteristic(conn_id_1, 0x0024, _, GATT_WRITE, _, _));
1969 EXPECT_CALL(gatt_queue, WriteCharacteristic(conn_id_2, 0x0024, _, GATT_WRITE, _, _));
1970
1971 VolumeControl::Get()->SetVolume(group_id, 10);
1972
1973 /* Now inject notification and make sure callback is sent up to Java layer */
1974 EXPECT_CALL(callbacks, OnGroupVolumeStateChanged(group_id, 0x03, true, false));
1975
1976 std::vector<uint8_t> value({0x03, 0x01, 0x02});
1977 GetNotificationEvent(conn_id_1, test_address_1, 0x0021, value);
1978 GetNotificationEvent(conn_id_2, test_address_2, 0x0021, value);
1979
1980 /* Verify exactly one operation with this exact value is queued for each
1981 * device */
1982 EXPECT_CALL(gatt_queue, WriteCharacteristic(conn_id_1, 0x0024, _, GATT_WRITE, _, _)).Times(1);
1983 EXPECT_CALL(gatt_queue, WriteCharacteristic(conn_id_2, 0x0024, _, GATT_WRITE, _, _)).Times(1);
1984 VolumeControl::Get()->SetVolume(test_address_1, 20);
1985 VolumeControl::Get()->SetVolume(test_address_2, 20);
1986 VolumeControl::Get()->SetVolume(test_address_1, 20);
1987 VolumeControl::Get()->SetVolume(test_address_2, 20);
1988
1989 EXPECT_CALL(callbacks, OnVolumeStateChanged(test_address_1, 20, false, _, false));
1990 EXPECT_CALL(callbacks, OnVolumeStateChanged(test_address_2, 20, false, _, false));
1991 std::vector<uint8_t> value2({20, 0x00, 0x03});
1992 GetNotificationEvent(conn_id_1, test_address_1, 0x0021, value2);
1993 GetNotificationEvent(conn_id_2, test_address_2, 0x0021, value2);
1994 }
1995
TEST_F(VolumeControlCsis,test_set_volume_device_not_ready)1996 TEST_F(VolumeControlCsis, test_set_volume_device_not_ready) {
1997 /* Make sure we did not get responds to the initial reads,
1998 * so that the device was not marked as ready yet.
1999 */
2000 do_not_respond_to_reads = true;
2001
2002 TestConnect(test_address_1);
2003 GetConnectedEvent(test_address_1, conn_id_1);
2004 GetSearchCompleteEvent(conn_id_1);
2005 TestConnect(test_address_2);
2006 GetConnectedEvent(test_address_2, conn_id_2);
2007 GetSearchCompleteEvent(conn_id_2);
2008
2009 /* Set value for the group */
2010 EXPECT_CALL(gatt_queue, WriteCharacteristic(conn_id_1, 0x0024, _, GATT_WRITE, _, _)).Times(0);
2011 EXPECT_CALL(gatt_queue, WriteCharacteristic(conn_id_2, 0x0024, _, GATT_WRITE, _, _)).Times(0);
2012
2013 VolumeControl::Get()->SetVolume(group_id, 10);
2014 }
2015
TEST_F(VolumeControlCsis,autonomus_test_set_volume)2016 TEST_F(VolumeControlCsis, autonomus_test_set_volume) {
2017 TestConnect(test_address_1);
2018 GetConnectedEvent(test_address_1, conn_id_1);
2019 GetSearchCompleteEvent(conn_id_1);
2020 TestConnect(test_address_2);
2021 GetConnectedEvent(test_address_2, conn_id_2);
2022 GetSearchCompleteEvent(conn_id_2);
2023
2024 /* Now inject notification and make sure callback is sent up to Java layer */
2025 EXPECT_CALL(callbacks, OnGroupVolumeStateChanged(group_id, 0x03, false, true));
2026
2027 std::vector<uint8_t> value({0x03, 0x00, 0x02});
2028 GetNotificationEvent(conn_id_1, test_address_1, 0x0021, value);
2029 GetNotificationEvent(conn_id_2, test_address_2, 0x0021, value);
2030 }
2031
TEST_F(VolumeControlCsis,autonomus_single_device_test_set_volume)2032 TEST_F(VolumeControlCsis, autonomus_single_device_test_set_volume) {
2033 TestConnect(test_address_1);
2034 GetConnectedEvent(test_address_1, conn_id_1);
2035 GetSearchCompleteEvent(conn_id_1);
2036 TestConnect(test_address_2);
2037 GetConnectedEvent(test_address_2, conn_id_2);
2038 GetSearchCompleteEvent(conn_id_2);
2039
2040 /* Disconnect one device. */
2041 EXPECT_CALL(callbacks, OnConnectionState(ConnectionState::DISCONNECTED, test_address_1));
2042 GetDisconnectedEvent(test_address_1, conn_id_1);
2043
2044 /* Now inject notification and make sure callback is sent up to Java layer */
2045 EXPECT_CALL(callbacks, OnGroupVolumeStateChanged(group_id, 0x03, false, true));
2046
2047 std::vector<uint8_t> value({0x03, 0x00, 0x02});
2048 GetNotificationEvent(conn_id_2, test_address_2, 0x0021, value);
2049 }
2050
2051 } // namespace
2052 } // namespace internal
2053 } // namespace vc
2054 } // namespace bluetooth
2055