1 /******************************************************************************
2 *
3 * Copyright (C) 2016 The Linux Foundation
4 * Copyright 2009-2012 Broadcom Corporation
5 *
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at:
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 *
18 ******************************************************************************/
19
20 /*******************************************************************************
21 *
22 * Filename: bluetooth.c
23 *
24 * Description: Bluetooth HAL implementation
25 *
26 ******************************************************************************/
27
28 #define LOG_TAG "bt_btif"
29
30 #include "hardware/bluetooth.h"
31
32 #include <base/functional/bind.h>
33 #include <base/functional/callback.h>
34 #include <bluetooth/log.h>
35
36 #include <cstdint>
37 #include <cstdlib>
38 #include <cstring>
39 #include <string>
40 #include <utility>
41 #include <vector>
42
43 #include "bta/gatt/bta_gattc_int.h"
44 #include "bta/hh/bta_hh_int.h"
45 #include "bta/include/bta_api.h"
46 #include "bta/include/bta_ar_api.h"
47 #include "bta/include/bta_av_api.h"
48 #include "bta/include/bta_csis_api.h"
49 #include "bta/include/bta_has_api.h"
50 #include "bta/include/bta_hearing_aid_api.h"
51 #include "bta/include/bta_hf_client_api.h"
52 #include "bta/include/bta_le_audio_api.h"
53 #include "bta/include/bta_le_audio_broadcaster_api.h"
54 #include "bta/include/bta_vc_api.h"
55 #include "btif/avrcp/avrcp_service.h"
56 #include "btif/include/bluetooth.h"
57 #include "btif/include/btif_a2dp.h"
58 #include "btif/include/btif_a2dp_source.h"
59 #include "btif/include/btif_api.h"
60 #include "btif/include/btif_av.h"
61 #include "btif/include/btif_bqr.h"
62 #include "btif/include/btif_common.h"
63 #include "btif/include/btif_config.h"
64 #include "btif/include/btif_debug_conn.h"
65 #include "btif/include/btif_dm.h"
66 #include "btif/include/btif_gatt.h"
67 #include "btif/include/btif_hd.h"
68 #include "btif/include/btif_hearing_aid.h"
69 #include "btif/include/btif_hf.h"
70 #include "btif/include/btif_hf_client.h"
71 #include "btif/include/btif_hh.h"
72 #include "btif/include/btif_keystore.h"
73 #include "btif/include/btif_le_audio.h"
74 #include "btif/include/btif_pan.h"
75 #include "btif/include/btif_profile_storage.h"
76 #include "btif/include/btif_rc.h"
77 #include "btif/include/btif_sdp.h"
78 #include "btif/include/btif_sock.h"
79 #include "btif/include/btif_sock_logging.h"
80 #include "btif/include/btif_storage.h"
81 #include "btif/include/core_callbacks.h"
82 #include "btif/include/stack_manager_t.h"
83 #include "common/address_obfuscator.h"
84 #include "common/os_utils.h"
85 #include "device/include/device_iot_config.h"
86 #include "device/include/esco_parameters.h"
87 #include "device/include/interop.h"
88 #include "device/include/interop_config.h"
89 #include "hardware/avrcp/avrcp.h"
90 #include "hardware/bt_csis.h"
91 #include "hardware/bt_gatt.h"
92 #include "hardware/bt_has.h"
93 #include "hardware/bt_hearing_aid.h"
94 #include "hardware/bt_le_audio.h"
95 #include "hardware/bt_rc.h"
96 #include "hardware/bt_sdp.h"
97 #include "hardware/bt_sock.h"
98 #include "hardware/bt_vc.h"
99 #include "internal_include/bt_target.h"
100 #include "main/shim/dumpsys.h"
101 #include "main/shim/metric_id_api.h"
102 #include "os/parameter_provider.h"
103 #include "osi/include/alarm.h"
104 #include "osi/include/allocator.h"
105 #include "osi/include/properties.h"
106 #include "osi/include/stack_power_telemetry.h"
107 #include "osi/include/wakelock.h"
108 #include "stack/btm/btm_dev.h"
109 #include "stack/btm/btm_sco_hfp_hal.h"
110 #include "stack/connection_manager/connection_manager.h"
111 #include "stack/include/a2dp_api.h"
112 #include "stack/include/avct_api.h"
113 #include "stack/include/avdt_api.h"
114 #include "stack/include/avrc_api.h"
115 #include "stack/include/bnep_api.h"
116 #include "stack/include/bt_name.h"
117 #include "stack/include/bt_octets.h"
118 #include "stack/include/btm_client_interface.h"
119 #include "stack/include/btm_status.h"
120 #include "stack/include/gatt_api.h"
121 #include "stack/include/hcidefs.h"
122 #include "stack/include/hfp_lc3_decoder.h"
123 #include "stack/include/hfp_lc3_encoder.h"
124 #include "stack/include/hfp_msbc_decoder.h"
125 #include "stack/include/hfp_msbc_encoder.h"
126 #include "stack/include/hidh_api.h"
127 #include "stack/include/l2cap_module.h"
128 #include "stack/include/main_thread.h"
129 #include "stack/include/pan_api.h"
130 #include "stack/include/sdp_api.h"
131 #include "storage/config_keys.h"
132 #include "types/ble_address_with_type.h"
133 #include "types/bt_transport.h"
134 #include "types/raw_address.h"
135
136 using bluetooth::csis::CsisClientInterface;
137 using bluetooth::has::HasClientInterface;
138 using bluetooth::le_audio::LeAudioBroadcasterInterface;
139 using bluetooth::le_audio::LeAudioClientInterface;
140 using bluetooth::vc::VolumeControlInterface;
141 using namespace bluetooth;
142
143 namespace {
to_bt_transport(int val)144 tBT_TRANSPORT to_bt_transport(int val) {
145 switch (val) {
146 case 0:
147 return BT_TRANSPORT_AUTO;
148 case 1:
149 return BT_TRANSPORT_BR_EDR;
150 case 2:
151 return BT_TRANSPORT_LE;
152 default:
153 break;
154 }
155 log::warn("Passed unexpected transport value:{}", val);
156 return BT_TRANSPORT_AUTO;
157 }
158
159 } // namespace
160
161 /*******************************************************************************
162 * Static variables
163 ******************************************************************************/
164
165 static bt_callbacks_t* bt_hal_cbacks = NULL;
166 static bool restricted_mode = false;
167 static bool common_criteria_mode = false;
168 static constexpr int CONFIG_COMPARE_ALL_PASS = 0b11;
169 static int common_criteria_config_compare_result = CONFIG_COMPARE_ALL_PASS;
170 static bool is_local_device_atv = false;
171
172 /*******************************************************************************
173 * Callbacks from bluetooth::core (see go/invisalign-bt)
174 ******************************************************************************/
175
176 struct ConfigInterfaceImpl : bluetooth::core::ConfigInterface {
ConfigInterfaceImplConfigInterfaceImpl177 ConfigInterfaceImpl() : bluetooth::core::ConfigInterface() {}
178
isRestrictedModeConfigInterfaceImpl179 bool isRestrictedMode() override { return is_restricted_mode(); }
180
isA2DPOffloadEnabledConfigInterfaceImpl181 bool isA2DPOffloadEnabled() override {
182 char value_sup[PROPERTY_VALUE_MAX] = {'\0'};
183 char value_dis[PROPERTY_VALUE_MAX] = {'\0'};
184
185 osi_property_get("ro.bluetooth.a2dp_offload.supported", value_sup, "false");
186 osi_property_get("persist.bluetooth.a2dp_offload.disabled", value_dis, "false");
187 auto a2dp_offload_enabled =
188 (strcmp(value_sup, "true") == 0) && (strcmp(value_dis, "false") == 0);
189 log::verbose("a2dp_offload.enable = {}", a2dp_offload_enabled);
190
191 return a2dp_offload_enabled;
192 }
193
isAndroidTVDeviceConfigInterfaceImpl194 bool isAndroidTVDevice() override { return is_atv_device(); }
195 };
196
197 // TODO(aryarahul): remove unnecessary indirection through hfp_msbc_*.cc
198 struct MSBCCodec : bluetooth::core::CodecInterface {
MSBCCodecMSBCCodec199 MSBCCodec() : bluetooth::core::CodecInterface() {}
200
initializeMSBCCodec201 void initialize() override {
202 hfp_msbc_decoder_init();
203 hfp_msbc_encoder_init();
204 }
205
cleanupMSBCCodec206 void cleanup() override {
207 hfp_msbc_decoder_cleanup();
208 hfp_msbc_encoder_cleanup();
209 }
210
encodePacketMSBCCodec211 uint32_t encodePacket(int16_t* input, uint8_t* output) {
212 return hfp_msbc_encode_frames(input, output);
213 }
214
decodePacketMSBCCodec215 bool decodePacket(const uint8_t* i_buf, int16_t* o_buf, size_t out_len) {
216 return hfp_msbc_decoder_decode_packet(i_buf, o_buf, out_len);
217 }
218 };
219
220 struct LC3Codec : bluetooth::core::CodecInterface {
LC3CodecLC3Codec221 LC3Codec() : bluetooth::core::CodecInterface() {}
222
initializeLC3Codec223 void initialize() override {
224 hfp_lc3_decoder_init();
225 hfp_lc3_encoder_init();
226 }
227
cleanupLC3Codec228 void cleanup() override {
229 hfp_lc3_encoder_cleanup();
230 hfp_lc3_decoder_cleanup();
231 }
232
encodePacketLC3Codec233 uint32_t encodePacket(int16_t* input, uint8_t* output) {
234 return hfp_lc3_encode_frames(input, output);
235 }
236
decodePacketLC3Codec237 bool decodePacket(const uint8_t* i_buf, int16_t* o_buf, size_t out_len) {
238 return hfp_lc3_decoder_decode_packet(i_buf, o_buf, out_len);
239 }
240 };
241
242 struct CoreInterfaceImpl : bluetooth::core::CoreInterface {
243 using bluetooth::core::CoreInterface::CoreInterface;
244
onBluetoothEnabledCoreInterfaceImpl245 void onBluetoothEnabled() override {
246 /* init pan */
247 btif_pan_init();
248 }
249
toggleProfileCoreInterfaceImpl250 bt_status_t toggleProfile(tBTA_SERVICE_ID service_id, bool enable) override {
251 /* Check the service_ID and invoke the profile's BT state changed API */
252 switch (service_id) {
253 case BTA_HFP_SERVICE_ID:
254 case BTA_HSP_SERVICE_ID: {
255 bluetooth::headset::ExecuteService(enable);
256 } break;
257 case BTA_A2DP_SOURCE_SERVICE_ID: {
258 btif_av_source_execute_service(enable);
259 } break;
260 case BTA_A2DP_SINK_SERVICE_ID: {
261 btif_av_sink_execute_service(enable);
262 } break;
263 case BTA_HID_SERVICE_ID: {
264 btif_hh_execute_service(enable);
265 } break;
266 case BTA_HFP_HS_SERVICE_ID: {
267 btif_hf_client_execute_service(enable);
268 } break;
269 case BTA_HIDD_SERVICE_ID: {
270 btif_hd_execute_service(enable);
271 } break;
272 case BTA_PBAP_SERVICE_ID:
273 case BTA_PCE_SERVICE_ID:
274 case BTA_MAP_SERVICE_ID:
275 case BTA_MN_SERVICE_ID: {
276 /**
277 * Do nothing; these services were started elsewhere. However, we need
278 * to flow through this codepath in order to properly report back the
279 * local UUIDs back to adapter properties in Java. To achieve this, we
280 * need to catch these service IDs in order for {@link
281 * btif_in_execute_service_request} to return {@code BT_STATUS_SUCCESS},
282 * so that in {@link btif_dm_enable_service} the check passes and the
283 * UUIDs are allowed to be passed up into the Java layer.
284 */
285 } break;
286 default:
287 log::error("Unknown service {} being {}", service_id, (enable) ? "enabled" : "disabled");
288 return BT_STATUS_FAIL;
289 }
290 return BT_STATUS_SUCCESS;
291 }
292
removeDeviceFromProfilesCoreInterfaceImpl293 void removeDeviceFromProfiles(const RawAddress& bd_addr) override {
294 /*special handling for HID devices */
295 #if (defined(BTA_HH_INCLUDED) && (BTA_HH_INCLUDED == TRUE))
296 tAclLinkSpec link_spec;
297 link_spec.addrt.bda = bd_addr;
298 link_spec.addrt.type = BLE_ADDR_PUBLIC;
299 link_spec.transport = BT_TRANSPORT_AUTO;
300
301 btif_hh_remove_device(link_spec);
302 #endif
303 #if (defined(BTA_HD_INCLUDED) && (BTA_HD_INCLUDED == TRUE))
304 btif_hd_remove_device(bd_addr);
305 #endif
306 btif_hearing_aid_get_interface()->RemoveDevice(bd_addr);
307
308 if (bluetooth::csis::CsisClient::IsCsisClientRunning()) {
309 btif_csis_client_get_interface()->RemoveDevice(bd_addr);
310 }
311
312 if (LeAudioClient::IsLeAudioClientRunning()) {
313 btif_le_audio_get_interface()->RemoveDevice(bd_addr);
314 }
315
316 if (VolumeControl::IsVolumeControlRunning()) {
317 btif_volume_control_get_interface()->RemoveDevice(bd_addr);
318 }
319 }
320
onLinkDownCoreInterfaceImpl321 void onLinkDown(const RawAddress& bd_addr, tBT_TRANSPORT transport) override {
322 btif_hh_disconnected(bd_addr, transport);
323
324 if (transport != BT_TRANSPORT_BR_EDR) {
325 return;
326 }
327
328 btif_av_acl_disconnected(bd_addr, A2dpType::kSource);
329 btif_av_acl_disconnected(bd_addr, A2dpType::kSink);
330 }
331 };
332
CreateInterfaceToProfiles()333 static bluetooth::core::CoreInterface* CreateInterfaceToProfiles() {
334 static bluetooth::core::EventCallbacks eventCallbacks{
335 .invoke_adapter_state_changed_cb = invoke_adapter_state_changed_cb,
336 .invoke_adapter_properties_cb = invoke_adapter_properties_cb,
337 .invoke_remote_device_properties_cb = invoke_remote_device_properties_cb,
338 .invoke_device_found_cb = invoke_device_found_cb,
339 .invoke_discovery_state_changed_cb = invoke_discovery_state_changed_cb,
340 .invoke_pin_request_cb = invoke_pin_request_cb,
341 .invoke_ssp_request_cb = invoke_ssp_request_cb,
342 .invoke_oob_data_request_cb = invoke_oob_data_request_cb,
343 .invoke_bond_state_changed_cb = invoke_bond_state_changed_cb,
344 .invoke_address_consolidate_cb = invoke_address_consolidate_cb,
345 .invoke_le_address_associate_cb = invoke_le_address_associate_cb,
346 .invoke_acl_state_changed_cb = invoke_acl_state_changed_cb,
347 .invoke_thread_evt_cb = invoke_thread_evt_cb,
348 .invoke_le_test_mode_cb = invoke_le_test_mode_cb,
349 .invoke_energy_info_cb = invoke_energy_info_cb,
350 .invoke_link_quality_report_cb = invoke_link_quality_report_cb,
351 .invoke_key_missing_cb = invoke_key_missing_cb,
352 .invoke_encryption_change_cb = invoke_encryption_change_cb,
353 };
354 static bluetooth::core::HACK_ProfileInterface profileInterface{
355 // HID
356 .btif_hh_virtual_unplug = btif_hh_virtual_unplug,
357 .bta_hh_read_ssr_param = bta_hh_read_ssr_param,
358
359 // AVDTP
360 .btif_av_set_dynamic_audio_buffer_size = btif_av_set_dynamic_audio_buffer_size,
361
362 // ASHA
363 .GetHearingAidDeviceCount = HearingAid::GetDeviceCount,
364
365 // LE Audio
366 .IsLeAudioClientRunning = LeAudioClient::IsLeAudioClientRunning,
367
368 // AVRCP
369 .AVRC_GetProfileVersion = AVRC_GetProfileVersion,
370 };
371
372 static auto configInterface = ConfigInterfaceImpl();
373 static auto msbcCodecInterface = MSBCCodec();
374 static auto lc3CodecInterface = LC3Codec();
375
376 static auto interfaceForCore =
377 CoreInterfaceImpl(&eventCallbacks, &configInterface, &msbcCodecInterface,
378 &lc3CodecInterface, &profileInterface);
379 return &interfaceForCore;
380 }
381
382 /*******************************************************************************
383 * Functions
384 ******************************************************************************/
385
interface_ready(void)386 static bool interface_ready(void) { return bt_hal_cbacks != NULL; }
set_hal_cbacks(bt_callbacks_t * callbacks)387 static void set_hal_cbacks(bt_callbacks_t* callbacks) { bt_hal_cbacks = callbacks; }
388
is_profile(const char * p1,const char * p2)389 static bool is_profile(const char* p1, const char* p2) {
390 log::assert_that(p1 != nullptr, "assert failed: p1 != nullptr");
391 log::assert_that(p2 != nullptr, "assert failed: p2 != nullptr");
392 return strlen(p1) == strlen(p2) && strncmp(p1, p2, strlen(p2)) == 0;
393 }
394
395 /*****************************************************************************
396 *
397 * BLUETOOTH HAL INTERFACE FUNCTIONS
398 *
399 ****************************************************************************/
400
401 #ifdef TARGET_FLOSS
402 static int global_hci_adapter = 0;
403
set_adapter_index(int adapter)404 static void set_adapter_index(int adapter) { global_hci_adapter = adapter; }
GetAdapterIndex()405 int GetAdapterIndex() { return global_hci_adapter; }
406 #else
GetAdapterIndex()407 int GetAdapterIndex() { return 0; } // Unsupported outside of FLOSS
408 #endif // TARGET_FLOSS
409
init(bt_callbacks_t * callbacks,bool start_restricted,bool is_common_criteria_mode,int config_compare_result,bool is_atv)410 static int init(bt_callbacks_t* callbacks, bool start_restricted, bool is_common_criteria_mode,
411 int config_compare_result, bool is_atv) {
412 log::info(
413 "start restricted = {} ; common criteria mode = {}, config compare "
414 "result = {}",
415 start_restricted, is_common_criteria_mode, config_compare_result);
416
417 if (interface_ready()) {
418 return BT_STATUS_DONE;
419 }
420
421 set_hal_cbacks(callbacks);
422
423 restricted_mode = start_restricted;
424
425 bluetooth::os::ParameterProvider::SetBtKeystoreInterface(
426 bluetooth::bluetooth_keystore::getBluetoothKeystoreInterface());
427 bluetooth::os::ParameterProvider::SetCommonCriteriaMode(is_common_criteria_mode);
428 if (is_bluetooth_uid() && is_common_criteria_mode) {
429 bluetooth::os::ParameterProvider::SetCommonCriteriaConfigCompareResult(config_compare_result);
430 } else {
431 bluetooth::os::ParameterProvider::SetCommonCriteriaConfigCompareResult(CONFIG_COMPARE_ALL_PASS);
432 }
433
434 is_local_device_atv = is_atv;
435
436 stack_manager_get_interface()->init_stack(CreateInterfaceToProfiles());
437 return BT_STATUS_SUCCESS;
438 }
439
start_profiles()440 static void start_profiles() {
441 #if (BNEP_INCLUDED == TRUE)
442 BNEP_Init();
443 #if (PAN_INCLUDED == TRUE)
444 PAN_Init();
445 #endif /* PAN */
446 #endif /* BNEP Included */
447 A2DP_Init();
448 AVRC_Init();
449 #if (HID_HOST_INCLUDED == TRUE)
450 HID_HostInit();
451 #endif
452 bta_ar_init();
453 }
454
stop_profiles()455 static void stop_profiles() {
456 btif_sock_cleanup();
457 btif_pan_cleanup();
458 }
459
enable()460 static int enable() {
461 if (!interface_ready()) {
462 return BT_STATUS_NOT_READY;
463 }
464
465 stack_manager_get_interface()->start_up_stack_async(CreateInterfaceToProfiles(), &start_profiles,
466 &stop_profiles);
467 return BT_STATUS_SUCCESS;
468 }
469
disable(void)470 static int disable(void) {
471 if (!interface_ready()) {
472 return BT_STATUS_NOT_READY;
473 }
474
475 stack_manager_get_interface()->shut_down_stack_async(&stop_profiles);
476 return BT_STATUS_SUCCESS;
477 }
478
cleanup(void)479 static void cleanup(void) { stack_manager_get_interface()->clean_up_stack(&stop_profiles); }
480
start_rust_module(void)481 static void start_rust_module(void) {
482 std::promise<void> rust_up_promise;
483 auto rust_up_future = rust_up_promise.get_future();
484 stack_manager_get_interface()->start_up_rust_module_async(std::move(rust_up_promise));
485 rust_up_future.wait();
486 }
487
stop_rust_module(void)488 static void stop_rust_module(void) { stack_manager_get_interface()->shut_down_rust_module_async(); }
489
is_restricted_mode()490 bool is_restricted_mode() { return restricted_mode; }
491
get_wbs_supported()492 static bool get_wbs_supported() { return hfp_hal_interface::get_wbs_supported(); }
493
get_swb_supported()494 static bool get_swb_supported() { return hfp_hal_interface::get_swb_supported(); }
495
is_coding_format_supported(esco_coding_format_t coding_format)496 static bool is_coding_format_supported(esco_coding_format_t coding_format) {
497 return hfp_hal_interface::is_coding_format_supported(coding_format);
498 }
499
is_common_criteria_mode()500 bool is_common_criteria_mode() { return is_bluetooth_uid() && common_criteria_mode; }
501 // if common criteria mode disable, will always return
502 // CONFIG_COMPARE_ALL_PASS(0b11) indicate don't check config checksum.
get_common_criteria_config_compare_result()503 int get_common_criteria_config_compare_result() {
504 return is_common_criteria_mode() ? common_criteria_config_compare_result
505 : CONFIG_COMPARE_ALL_PASS;
506 }
507
is_atv_device()508 bool is_atv_device() { return is_local_device_atv; }
509
get_adapter_properties(void)510 static int get_adapter_properties(void) {
511 if (!btif_is_enabled()) {
512 return BT_STATUS_NOT_READY;
513 }
514
515 do_in_main_thread(base::BindOnce(btif_get_adapter_properties));
516 return BT_STATUS_SUCCESS;
517 }
518
get_adapter_property(bt_property_type_t type)519 static int get_adapter_property(bt_property_type_t type) {
520 /* Allow get_adapter_property only for BDADDR and BDNAME if BT is disabled */
521 if (!btif_is_enabled() && (type != BT_PROPERTY_BDADDR) && (type != BT_PROPERTY_BDNAME)) {
522 return BT_STATUS_NOT_READY;
523 }
524
525 do_in_main_thread(base::BindOnce(btif_get_adapter_property, type));
526 return BT_STATUS_SUCCESS;
527 }
528
set_scan_mode(bt_scan_mode_t mode)529 static void set_scan_mode(bt_scan_mode_t mode) {
530 do_in_main_thread(base::BindOnce(btif_set_scan_mode, mode));
531 }
532
set_adapter_property(const bt_property_t * property)533 static int set_adapter_property(const bt_property_t* property) {
534 if (!btif_is_enabled()) {
535 return BT_STATUS_NOT_READY;
536 }
537
538 switch (property->type) {
539 case BT_PROPERTY_BDNAME:
540 case BT_PROPERTY_ADAPTER_DISCOVERABLE_TIMEOUT:
541 case BT_PROPERTY_CLASS_OF_DEVICE:
542 break;
543 default:
544 return BT_STATUS_UNHANDLED;
545 }
546
547 do_in_main_thread(base::BindOnce(
548 [](bt_property_t* property) {
549 btif_set_adapter_property(property);
550 osi_free(property);
551 },
552 property_deep_copy(property)));
553 return BT_STATUS_SUCCESS;
554 }
555
get_remote_device_properties(RawAddress * remote_addr)556 static int get_remote_device_properties(RawAddress* remote_addr) {
557 if (!btif_is_enabled()) {
558 return BT_STATUS_NOT_READY;
559 }
560
561 do_in_main_thread(base::BindOnce(btif_get_remote_device_properties, *remote_addr));
562 return BT_STATUS_SUCCESS;
563 }
564
get_remote_device_property(RawAddress * remote_addr,bt_property_type_t type)565 static int get_remote_device_property(RawAddress* remote_addr, bt_property_type_t type) {
566 if (!btif_is_enabled()) {
567 return BT_STATUS_NOT_READY;
568 }
569
570 do_in_main_thread(base::BindOnce(btif_get_remote_device_property, *remote_addr, type));
571 return BT_STATUS_SUCCESS;
572 }
573
set_remote_device_property(RawAddress * remote_addr,const bt_property_t * property)574 static int set_remote_device_property(RawAddress* remote_addr, const bt_property_t* property) {
575 if (!btif_is_enabled()) {
576 return BT_STATUS_NOT_READY;
577 }
578
579 do_in_main_thread(base::BindOnce(
580 [](RawAddress remote_addr, bt_property_t* property) {
581 btif_set_remote_device_property(&remote_addr, property);
582 osi_free(property);
583 },
584 *remote_addr, property_deep_copy(property)));
585 return BT_STATUS_SUCCESS;
586 }
587
get_remote_services(RawAddress * remote_addr,int transport)588 static int get_remote_services(RawAddress* remote_addr, int transport) {
589 if (!interface_ready()) {
590 return BT_STATUS_NOT_READY;
591 }
592
593 do_in_main_thread(
594 base::BindOnce(btif_dm_get_remote_services, *remote_addr, to_bt_transport(transport)));
595 return BT_STATUS_SUCCESS;
596 }
597
start_discovery(void)598 static int start_discovery(void) {
599 if (!interface_ready()) {
600 return BT_STATUS_NOT_READY;
601 }
602
603 do_in_main_thread(base::BindOnce(btif_dm_start_discovery));
604 return BT_STATUS_SUCCESS;
605 }
606
cancel_discovery(void)607 static int cancel_discovery(void) {
608 if (!interface_ready()) {
609 return BT_STATUS_NOT_READY;
610 }
611
612 do_in_main_thread(base::BindOnce(btif_dm_cancel_discovery));
613 return BT_STATUS_SUCCESS;
614 }
615
create_bond(const RawAddress * bd_addr,int transport)616 static int create_bond(const RawAddress* bd_addr, int transport) {
617 if (!interface_ready()) {
618 return BT_STATUS_NOT_READY;
619 }
620 if (btif_dm_pairing_is_busy()) {
621 return BT_STATUS_BUSY;
622 }
623
624 do_in_main_thread(base::BindOnce(btif_dm_create_bond, *bd_addr, to_bt_transport(transport)));
625 return BT_STATUS_SUCCESS;
626 }
627
create_bond_le(const RawAddress * bd_addr,uint8_t addr_type)628 static int create_bond_le(const RawAddress* bd_addr, uint8_t addr_type) {
629 if (!interface_ready()) {
630 return BT_STATUS_NOT_READY;
631 }
632 if (btif_dm_pairing_is_busy()) {
633 return BT_STATUS_BUSY;
634 }
635
636 do_in_main_thread(base::BindOnce(btif_dm_create_bond_le, *bd_addr, addr_type));
637 return BT_STATUS_SUCCESS;
638 }
639
create_bond_out_of_band(const RawAddress * bd_addr,int transport,const bt_oob_data_t * p192_data,const bt_oob_data_t * p256_data)640 static int create_bond_out_of_band(const RawAddress* bd_addr, int transport,
641 const bt_oob_data_t* p192_data, const bt_oob_data_t* p256_data) {
642 if (!interface_ready()) {
643 return BT_STATUS_NOT_READY;
644 }
645 if (btif_dm_pairing_is_busy()) {
646 return BT_STATUS_BUSY;
647 }
648
649 do_in_main_thread(base::BindOnce(btif_dm_create_bond_out_of_band, *bd_addr,
650 to_bt_transport(transport), *p192_data, *p256_data));
651 return BT_STATUS_SUCCESS;
652 }
653
generate_local_oob_data(tBT_TRANSPORT transport)654 static int generate_local_oob_data(tBT_TRANSPORT transport) {
655 log::info("");
656 if (!interface_ready()) {
657 return BT_STATUS_NOT_READY;
658 }
659
660 return do_in_main_thread(base::BindOnce(btif_dm_generate_local_oob_data, transport));
661 }
662
cancel_bond(const RawAddress * bd_addr)663 static int cancel_bond(const RawAddress* bd_addr) {
664 if (!interface_ready()) {
665 return BT_STATUS_NOT_READY;
666 }
667
668 do_in_main_thread(base::BindOnce(btif_dm_cancel_bond, *bd_addr));
669 return BT_STATUS_SUCCESS;
670 }
671
remove_bond(const RawAddress * bd_addr)672 static int remove_bond(const RawAddress* bd_addr) {
673 if (is_restricted_mode() && !btif_storage_is_restricted_device(bd_addr)) {
674 log::info("{} cannot be removed in restricted mode", *bd_addr);
675 return BT_STATUS_SUCCESS;
676 }
677
678 if (!interface_ready()) {
679 return BT_STATUS_NOT_READY;
680 }
681
682 do_in_main_thread(base::BindOnce(btif_dm_remove_bond, *bd_addr));
683 return BT_STATUS_SUCCESS;
684 }
685
pairing_is_busy()686 static bool pairing_is_busy() {
687 if (btif_dm_pairing_is_busy()) {
688 return true;
689 }
690
691 return false;
692 }
693
get_connection_state(const RawAddress * bd_addr)694 static int get_connection_state(const RawAddress* bd_addr) {
695 if (!interface_ready()) {
696 return 0;
697 }
698
699 if (bd_addr == nullptr) {
700 return 0;
701 }
702
703 return btif_dm_get_connection_state(*bd_addr);
704 }
705
pin_reply(const RawAddress * bd_addr,uint8_t accept,uint8_t pin_len,bt_pin_code_t * pin_code)706 static int pin_reply(const RawAddress* bd_addr, uint8_t accept, uint8_t pin_len,
707 bt_pin_code_t* pin_code) {
708 bt_pin_code_t tmp_pin_code;
709 if (!interface_ready()) {
710 return BT_STATUS_NOT_READY;
711 }
712 if (pin_code == nullptr || pin_len > PIN_CODE_LEN) {
713 return BT_STATUS_PARM_INVALID;
714 }
715
716 memcpy(&tmp_pin_code, pin_code, pin_len);
717
718 do_in_main_thread(base::BindOnce(btif_dm_pin_reply, *bd_addr, accept, pin_len, tmp_pin_code));
719 return BT_STATUS_SUCCESS;
720 }
721
ssp_reply(const RawAddress * bd_addr,bt_ssp_variant_t variant,uint8_t accept,uint32_t)722 static int ssp_reply(const RawAddress* bd_addr, bt_ssp_variant_t variant, uint8_t accept,
723 uint32_t /* passkey */) {
724 if (!interface_ready()) {
725 return BT_STATUS_NOT_READY;
726 }
727 if (variant == BT_SSP_VARIANT_PASSKEY_ENTRY) {
728 return BT_STATUS_PARM_INVALID;
729 }
730
731 do_in_main_thread(base::BindOnce(btif_dm_ssp_reply, *bd_addr, variant, accept));
732 return BT_STATUS_SUCCESS;
733 }
734
read_energy_info()735 static int read_energy_info() {
736 if (!interface_ready()) {
737 return BT_STATUS_NOT_READY;
738 }
739
740 do_in_main_thread(base::BindOnce(btif_dm_read_energy_info));
741 return BT_STATUS_SUCCESS;
742 }
743
clear_event_filter()744 static int clear_event_filter() {
745 log::verbose("");
746 if (!interface_ready()) {
747 return BT_STATUS_NOT_READY;
748 }
749
750 do_in_main_thread(base::BindOnce(btif_dm_clear_event_filter));
751 return BT_STATUS_SUCCESS;
752 }
753
clear_event_mask()754 static int clear_event_mask() {
755 log::verbose("");
756 if (!interface_ready()) {
757 return BT_STATUS_NOT_READY;
758 }
759
760 do_in_main_thread(base::BindOnce(btif_dm_clear_event_mask));
761 return BT_STATUS_SUCCESS;
762 }
763
clear_filter_accept_list()764 static int clear_filter_accept_list() {
765 log::verbose("");
766 if (!interface_ready()) {
767 return BT_STATUS_NOT_READY;
768 }
769
770 do_in_main_thread(base::BindOnce(btif_dm_clear_filter_accept_list));
771 return BT_STATUS_SUCCESS;
772 }
773
disconnect_all_acls()774 static int disconnect_all_acls() {
775 log::verbose("");
776 if (!interface_ready()) {
777 return BT_STATUS_NOT_READY;
778 }
779
780 do_in_main_thread(base::BindOnce(btif_dm_disconnect_all_acls));
781 return BT_STATUS_SUCCESS;
782 }
783
disconnect_acl(const RawAddress & bd_addr,int transport)784 static int disconnect_acl(const RawAddress& bd_addr, int transport) {
785 log::verbose("{}", bd_addr);
786 if (!interface_ready()) {
787 return BT_STATUS_NOT_READY;
788 }
789
790 do_in_main_thread(base::BindOnce(btif_dm_disconnect_acl, bd_addr, to_bt_transport(transport)));
791 return BT_STATUS_SUCCESS;
792 }
793
le_rand_btif_cb(uint64_t random_number)794 static void le_rand_btif_cb(uint64_t random_number) {
795 log::verbose("");
796 do_in_jni_thread(base::BindOnce(
797 [](uint64_t random) { HAL_CBACK(bt_hal_cbacks, le_rand_cb, random); }, random_number));
798 }
799
le_rand()800 static int le_rand() {
801 log::verbose("");
802 if (!interface_ready()) {
803 return BT_STATUS_NOT_READY;
804 }
805
806 do_in_main_thread(base::BindOnce(btif_dm_le_rand, get_main_thread()->BindOnce(&le_rand_btif_cb)));
807 return BT_STATUS_SUCCESS;
808 }
809
set_event_filter_inquiry_result_all_devices()810 static int set_event_filter_inquiry_result_all_devices() {
811 if (!interface_ready()) {
812 return BT_STATUS_NOT_READY;
813 }
814 do_in_main_thread(base::BindOnce(btif_dm_set_event_filter_inquiry_result_all_devices));
815 return BT_STATUS_SUCCESS;
816 }
817
set_default_event_mask_except(uint64_t mask,uint64_t le_mask)818 static int set_default_event_mask_except(uint64_t mask, uint64_t le_mask) {
819 if (!interface_ready()) {
820 return BT_STATUS_NOT_READY;
821 }
822 do_in_main_thread(base::BindOnce(btif_dm_set_default_event_mask_except, mask, le_mask));
823 return BT_STATUS_SUCCESS;
824 }
825
restore_filter_accept_list()826 static int restore_filter_accept_list() {
827 if (!interface_ready()) {
828 return BT_STATUS_NOT_READY;
829 }
830 // TODO(b/260922031) - When restoring the filter accept list after a system
831 // suspend, we need to re-arm the LE connections that had `is_direct=False`.
832 // This should be the list of bonded devices and potentially any GATT
833 // connections that have `is_direct=False`. Currently, we only restore LE hid
834 // devices.
835 auto le_hid_addrs = btif_storage_get_le_hid_devices();
836 do_in_main_thread(base::BindOnce(btif_dm_restore_filter_accept_list, std::move(le_hid_addrs)));
837 return BT_STATUS_SUCCESS;
838 }
839
allow_wake_by_hid()840 static int allow_wake_by_hid() {
841 if (!interface_ready()) {
842 return BT_STATUS_NOT_READY;
843 }
844 auto le_hid_addrs = btif_storage_get_le_hid_devices();
845 auto classic_hid_addrs = btif_storage_get_wake_capable_classic_hid_devices();
846 do_in_main_thread(base::BindOnce(btif_dm_allow_wake_by_hid, std::move(classic_hid_addrs),
847 std::move(le_hid_addrs)));
848 return BT_STATUS_SUCCESS;
849 }
850
set_event_filter_connection_setup_all_devices()851 static int set_event_filter_connection_setup_all_devices() {
852 if (!interface_ready()) {
853 return BT_STATUS_NOT_READY;
854 }
855 do_in_main_thread(base::BindOnce(btif_dm_set_event_filter_connection_setup_all_devices));
856 return BT_STATUS_SUCCESS;
857 }
858
dump(int fd,const char **)859 static void dump(int fd, const char** /*arguments*/) {
860 log::debug("Started bluetooth dumpsys");
861 btif_debug_conn_dump(fd);
862 btif_debug_bond_event_dump(fd);
863 btif_debug_linkkey_type_dump(fd);
864 btif_debug_rc_dump(fd);
865 btif_debug_a2dp_dump(fd);
866 btif_debug_av_dump(fd);
867 bta_debug_av_dump(fd);
868 stack_debug_avdtp_api_dump(fd);
869 btif_sock_dump(fd);
870 bluetooth::avrcp::AvrcpService::DebugDump(fd);
871 gatt_tcb_dump(fd);
872 bta_gatt_client_dump(fd);
873 device_debug_iot_config_dump(fd);
874 BTA_HfClientDumpStatistics(fd);
875 wakelock_debug_dump(fd);
876 alarm_debug_dump(fd);
877 bluetooth::csis::CsisClient::DebugDump(fd);
878 ::bluetooth::le_audio::has::HasClient::DebugDump(fd);
879 HearingAid::DebugDump(fd);
880 LeAudioClient::DebugDump(fd);
881 LeAudioBroadcaster::DebugDump(fd);
882 VolumeControl::DebugDump(fd);
883 connection_manager::dump(fd);
884 bluetooth::bqr::DebugDump(fd);
885 AVCT_Dumpsys(fd);
886 PAN_Dumpsys(fd);
887 DumpsysHid(fd);
888 DumpsysBtaDm(fd);
889 SDP_Dumpsys(fd);
890 DumpsysRecord(fd);
891 L2CA_Dumpsys(fd);
892 DumpsysBtm(fd);
893 bluetooth::shim::Dump(fd);
894 power_telemetry::GetInstance().Dumpsys(fd);
895 log::debug("Finished bluetooth dumpsys");
896 }
897
get_remote_pbap_pce_version(const RawAddress * bd_addr)898 static int get_remote_pbap_pce_version(const RawAddress* bd_addr) {
899 // Read and restore the PCE version from local storage
900 uint16_t pce_version = 0;
901 size_t version_value_size = sizeof(pce_version);
902 if (!btif_config_get_bin(bd_addr->ToString(), BTIF_STORAGE_KEY_PBAP_PCE_VERSION,
903 (uint8_t*)&pce_version, &version_value_size)) {
904 log::warn("Failed to read cached peer PCE version for {}", *bd_addr);
905 }
906 return pce_version;
907 }
908
pbap_pse_dynamic_version_upgrade_is_enabled()909 static bool pbap_pse_dynamic_version_upgrade_is_enabled() {
910 log::info("PBAP PSE dynamic version upgrade is not enabled");
911 return false;
912 }
913
get_profile_interface(const char * profile_id)914 static const void* get_profile_interface(const char* profile_id) {
915 log::info("id = {}", profile_id);
916
917 /* sanity check */
918 if (!interface_ready()) {
919 return NULL;
920 }
921
922 /* check for supported profile interfaces */
923 if (is_profile(profile_id, BT_PROFILE_HANDSFREE_ID)) {
924 return bluetooth::headset::GetInterface();
925 }
926
927 if (is_profile(profile_id, BT_PROFILE_HANDSFREE_CLIENT_ID)) {
928 return btif_hf_client_get_interface();
929 }
930
931 if (is_profile(profile_id, BT_PROFILE_SOCKETS_ID)) {
932 return btif_sock_get_interface();
933 }
934
935 if (is_profile(profile_id, BT_PROFILE_PAN_ID)) {
936 return btif_pan_get_interface();
937 }
938
939 if (is_profile(profile_id, BT_PROFILE_HIDHOST_ID)) {
940 return btif_hh_get_interface();
941 }
942
943 if (is_profile(profile_id, BT_PROFILE_HIDDEV_ID)) {
944 return btif_hd_get_interface();
945 }
946
947 if (is_profile(profile_id, BT_PROFILE_SDP_CLIENT_ID)) {
948 return btif_sdp_get_interface();
949 }
950
951 if (is_profile(profile_id, BT_PROFILE_GATT_ID)) {
952 return btif_gatt_get_interface();
953 }
954
955 if (is_profile(profile_id, BT_PROFILE_AV_RC_CTRL_ID)) {
956 return btif_rc_ctrl_get_interface();
957 }
958
959 if (is_profile(profile_id, BT_PROFILE_HEARING_AID_ID)) {
960 return btif_hearing_aid_get_interface();
961 }
962
963 if (is_profile(profile_id, BT_PROFILE_HAP_CLIENT_ID)) {
964 return btif_has_client_get_interface();
965 }
966
967 if (is_profile(profile_id, BT_KEYSTORE_ID)) {
968 return bluetooth::bluetooth_keystore::getBluetoothKeystoreInterface();
969 }
970
971 if (is_profile(profile_id, BT_PROFILE_LE_AUDIO_ID)) {
972 return btif_le_audio_get_interface();
973 }
974
975 if (is_profile(profile_id, BT_PROFILE_LE_AUDIO_BROADCASTER_ID)) {
976 return btif_le_audio_broadcaster_get_interface();
977 }
978
979 if (is_profile(profile_id, BT_PROFILE_VC_ID)) {
980 return btif_volume_control_get_interface();
981 }
982
983 if (is_profile(profile_id, BT_PROFILE_CSIS_CLIENT_ID)) {
984 return btif_csis_client_get_interface();
985 }
986
987 if (is_profile(profile_id, BT_BQR_ID)) {
988 return bluetooth::bqr::getBluetoothQualityReportInterface();
989 }
990
991 return NULL;
992 }
993
dut_mode_configure(uint8_t enable)994 static int dut_mode_configure(uint8_t enable) {
995 if (!interface_ready()) {
996 return BT_STATUS_NOT_READY;
997 }
998 if (!stack_manager_get_interface()->get_stack_is_running()) {
999 return BT_STATUS_NOT_READY;
1000 }
1001
1002 do_in_main_thread(base::BindOnce(btif_dut_mode_configure, enable));
1003 return BT_STATUS_SUCCESS;
1004 }
1005
dut_mode_send(uint16_t opcode,uint8_t * buf,uint8_t len)1006 static int dut_mode_send(uint16_t opcode, uint8_t* buf, uint8_t len) {
1007 if (!interface_ready()) {
1008 return BT_STATUS_NOT_READY;
1009 }
1010 if (!btif_is_dut_mode()) {
1011 return BT_STATUS_UNEXPECTED_STATE;
1012 }
1013
1014 uint8_t* copy = (uint8_t*)osi_calloc(len);
1015 memcpy(copy, buf, len);
1016
1017 do_in_main_thread(base::BindOnce(
1018 [](uint16_t opcode, uint8_t* buf, uint8_t len) {
1019 btif_dut_mode_send(opcode, buf, len);
1020 osi_free(buf);
1021 },
1022 opcode, copy, len));
1023 return BT_STATUS_SUCCESS;
1024 }
1025
le_test_mode(uint16_t opcode,uint8_t * buf,uint8_t len)1026 static int le_test_mode(uint16_t opcode, uint8_t* buf, uint8_t len) {
1027 if (!interface_ready()) {
1028 return BT_STATUS_NOT_READY;
1029 }
1030
1031 switch (opcode) {
1032 case HCI_BLE_TRANSMITTER_TEST:
1033 if (len != 3) {
1034 return BT_STATUS_PARM_INVALID;
1035 }
1036 do_in_main_thread(base::BindOnce(btif_ble_transmitter_test, buf[0], buf[1], buf[2]));
1037 break;
1038 case HCI_BLE_RECEIVER_TEST:
1039 if (len != 1) {
1040 return BT_STATUS_PARM_INVALID;
1041 }
1042 do_in_main_thread(base::BindOnce(btif_ble_receiver_test, buf[0]));
1043 break;
1044 case HCI_BLE_TEST_END:
1045 do_in_main_thread(base::BindOnce(btif_ble_test_end));
1046 break;
1047 default:
1048 return BT_STATUS_UNSUPPORTED;
1049 }
1050 return BT_STATUS_SUCCESS;
1051 }
1052
1053 static bt_os_callouts_t* wakelock_os_callouts_saved = nullptr;
1054
acquire_wake_lock_cb(const char * lock_name)1055 static int acquire_wake_lock_cb(const char* lock_name) {
1056 return do_in_jni_thread(base::BindOnce(
1057 base::IgnoreResult(wakelock_os_callouts_saved->acquire_wake_lock), lock_name));
1058 }
1059
release_wake_lock_cb(const char * lock_name)1060 static int release_wake_lock_cb(const char* lock_name) {
1061 return do_in_jni_thread(base::BindOnce(
1062 base::IgnoreResult(wakelock_os_callouts_saved->release_wake_lock), lock_name));
1063 }
1064
1065 static bt_os_callouts_t wakelock_os_callouts_jni = {
1066 sizeof(wakelock_os_callouts_jni),
1067 acquire_wake_lock_cb,
1068 release_wake_lock_cb,
1069 };
1070
set_os_callouts(bt_os_callouts_t * callouts)1071 static int set_os_callouts(bt_os_callouts_t* callouts) {
1072 wakelock_os_callouts_saved = callouts;
1073 wakelock_set_os_callouts(&wakelock_os_callouts_jni);
1074 return BT_STATUS_SUCCESS;
1075 }
1076
config_clear(void)1077 static int config_clear(void) {
1078 log::info("");
1079 int ret = BT_STATUS_SUCCESS;
1080 if (!btif_config_clear()) {
1081 log::error("Failed to clear btif config");
1082 ret = BT_STATUS_FAIL;
1083 }
1084
1085 if (!device_iot_config_clear()) {
1086 log::error("Failed to clear device iot config");
1087 ret = BT_STATUS_FAIL;
1088 }
1089
1090 return ret;
1091 }
1092
get_avrcp_service(void)1093 static bluetooth::avrcp::ServiceInterface* get_avrcp_service(void) {
1094 return bluetooth::avrcp::AvrcpService::GetServiceInterface();
1095 }
1096
obfuscate_address(const RawAddress & address)1097 static std::string obfuscate_address(const RawAddress& address) {
1098 return bluetooth::common::AddressObfuscator::GetInstance()->Obfuscate(address);
1099 }
1100
get_metric_id(const RawAddress & address)1101 static int get_metric_id(const RawAddress& address) {
1102 return bluetooth::shim::AllocateIdFromMetricIdAllocator(address);
1103 }
1104
set_dynamic_audio_buffer_size(int codec,int size)1105 static int set_dynamic_audio_buffer_size(int codec, int size) {
1106 return btif_set_dynamic_audio_buffer_size(codec, size);
1107 }
1108
allow_low_latency_audio(bool allowed,const RawAddress &)1109 static bool allow_low_latency_audio(bool allowed, const RawAddress& /* address */) {
1110 btif_a2dp_source_allow_low_latency_audio(allowed);
1111 return true;
1112 }
1113
metadata_changed(const RawAddress & remote_bd_addr,int key,std::vector<uint8_t> value)1114 static void metadata_changed(const RawAddress& remote_bd_addr, int key,
1115 std::vector<uint8_t> value) {
1116 if (!interface_ready()) {
1117 log::error("Interface not ready!");
1118 return;
1119 }
1120
1121 do_in_main_thread(
1122 base::BindOnce(btif_dm_metadata_changed, remote_bd_addr, key, std::move(value)));
1123 }
1124
interop_match_addr(const char * feature_name,const RawAddress * addr)1125 static bool interop_match_addr(const char* feature_name, const RawAddress* addr) {
1126 if (feature_name == NULL || addr == NULL) {
1127 return false;
1128 }
1129
1130 int feature = interop_feature_name_to_feature_id(feature_name);
1131 if (feature == -1) {
1132 log::error("feature doesn't exist: {}", feature_name);
1133 return false;
1134 }
1135
1136 return interop_match_addr((interop_feature_t)feature, addr);
1137 }
1138
interop_match_name(const char * feature_name,const char * name)1139 static bool interop_match_name(const char* feature_name, const char* name) {
1140 if (feature_name == NULL || name == NULL) {
1141 return false;
1142 }
1143
1144 int feature = interop_feature_name_to_feature_id(feature_name);
1145 if (feature == -1) {
1146 log::error("feature doesn't exist: {}", feature_name);
1147 return false;
1148 }
1149
1150 return interop_match_name((interop_feature_t)feature, name);
1151 }
1152
interop_match_addr_or_name(const char * feature_name,const RawAddress * addr)1153 static bool interop_match_addr_or_name(const char* feature_name, const RawAddress* addr) {
1154 if (feature_name == NULL || addr == NULL) {
1155 return false;
1156 }
1157
1158 int feature = interop_feature_name_to_feature_id(feature_name);
1159 if (feature == -1) {
1160 log::error("feature doesn't exist: {}", feature_name);
1161 return false;
1162 }
1163
1164 return interop_match_addr_or_name((interop_feature_t)feature, addr,
1165 &btif_storage_get_remote_device_property);
1166 }
1167
interop_database_add_remove_addr(bool do_add,const char * feature_name,const RawAddress * addr,int length)1168 static void interop_database_add_remove_addr(bool do_add, const char* feature_name,
1169 const RawAddress* addr, int length) {
1170 if (feature_name == NULL || addr == NULL) {
1171 return;
1172 }
1173
1174 int feature = interop_feature_name_to_feature_id(feature_name);
1175 if (feature == -1) {
1176 log::error("feature doesn't exist: {}", feature_name);
1177 return;
1178 }
1179
1180 if (do_add) {
1181 interop_database_add_addr((interop_feature_t)feature, addr, (size_t)length);
1182 } else {
1183 interop_database_remove_addr((interop_feature_t)feature, addr);
1184 }
1185 }
1186
interop_database_add_remove_name(bool do_add,const char * feature_name,const char * name)1187 static void interop_database_add_remove_name(bool do_add, const char* feature_name,
1188 const char* name) {
1189 if (feature_name == NULL || name == NULL) {
1190 return;
1191 }
1192
1193 int feature = interop_feature_name_to_feature_id(feature_name);
1194 if (feature == -1) {
1195 log::error("feature doesn't exist: {}", feature_name);
1196 return;
1197 }
1198
1199 if (do_add) {
1200 interop_database_add_name((interop_feature_t)feature, name);
1201 } else {
1202 interop_database_remove_name((interop_feature_t)feature, name);
1203 }
1204 }
1205
1206 EXPORT_SYMBOL bt_interface_t bluetoothInterface = {
1207 sizeof(bluetoothInterface),
1208 #ifdef TARGET_FLOSS
1209 .set_adapter_index = set_adapter_index,
1210 #endif
1211 .init = init,
1212 .enable = enable,
1213 .disable = disable,
1214 .cleanup = cleanup,
1215 .start_rust_module = start_rust_module,
1216 .stop_rust_module = stop_rust_module,
1217 .get_adapter_properties = get_adapter_properties,
1218 .get_adapter_property = get_adapter_property,
1219 .set_scan_mode = set_scan_mode,
1220 .set_adapter_property = set_adapter_property,
1221 .get_remote_device_properties = get_remote_device_properties,
1222 .get_remote_device_property = get_remote_device_property,
1223 .set_remote_device_property = set_remote_device_property,
1224 .get_remote_service_record = nullptr,
1225 .get_remote_services = get_remote_services,
1226 .start_discovery = start_discovery,
1227 .cancel_discovery = cancel_discovery,
1228 .create_bond = create_bond,
1229 .create_bond_le = create_bond_le,
1230 .create_bond_out_of_band = create_bond_out_of_band,
1231 .remove_bond = remove_bond,
1232 .cancel_bond = cancel_bond,
1233 .pairing_is_busy = pairing_is_busy,
1234 .get_connection_state = get_connection_state,
1235 .pin_reply = pin_reply,
1236 .ssp_reply = ssp_reply,
1237 .get_profile_interface = get_profile_interface,
1238 .dut_mode_configure = dut_mode_configure,
1239 .dut_mode_send = dut_mode_send,
1240 .le_test_mode = le_test_mode,
1241 .set_os_callouts = set_os_callouts,
1242 .read_energy_info = read_energy_info,
1243 .dump = dump,
1244 .config_clear = config_clear,
1245 .interop_database_clear = interop_database_clear,
1246 .interop_database_add = interop_database_add,
1247 .get_avrcp_service = get_avrcp_service,
1248 .obfuscate_address = obfuscate_address,
1249 .get_metric_id = get_metric_id,
1250 .set_dynamic_audio_buffer_size = set_dynamic_audio_buffer_size,
1251 .generate_local_oob_data = generate_local_oob_data,
1252 .allow_low_latency_audio = allow_low_latency_audio,
1253 .clear_event_filter = clear_event_filter,
1254 .clear_event_mask = clear_event_mask,
1255 .clear_filter_accept_list = clear_filter_accept_list,
1256 .disconnect_all_acls = disconnect_all_acls,
1257 .disconnect_acl = disconnect_acl,
1258 .le_rand = le_rand,
1259 .set_event_filter_inquiry_result_all_devices = set_event_filter_inquiry_result_all_devices,
1260 .set_default_event_mask_except = set_default_event_mask_except,
1261 .restore_filter_accept_list = restore_filter_accept_list,
1262 .allow_wake_by_hid = allow_wake_by_hid,
1263 .set_event_filter_connection_setup_all_devices =
1264 set_event_filter_connection_setup_all_devices,
1265 .get_wbs_supported = get_wbs_supported,
1266 .get_swb_supported = get_swb_supported,
1267 .is_coding_format_supported = is_coding_format_supported,
1268 .metadata_changed = metadata_changed,
1269 .interop_match_addr = interop_match_addr,
1270 .interop_match_name = interop_match_name,
1271 .interop_match_addr_or_name = interop_match_addr_or_name,
1272 .interop_database_add_remove_addr = interop_database_add_remove_addr,
1273 .interop_database_add_remove_name = interop_database_add_remove_name,
1274 .get_remote_pbap_pce_version = get_remote_pbap_pce_version,
1275 .pbap_pse_dynamic_version_upgrade_is_enabled = pbap_pse_dynamic_version_upgrade_is_enabled,
1276 };
1277
1278 // callback reporting helpers
1279
property_deep_copy_array(int num_properties,bt_property_t * properties)1280 static bt_property_t* property_deep_copy_array(int num_properties, bt_property_t* properties) {
1281 bt_property_t* copy = nullptr;
1282 if (num_properties > 0) {
1283 size_t content_len = 0;
1284 for (int i = 0; i < num_properties; i++) {
1285 auto len = properties[i].len;
1286 if (len > 0) {
1287 content_len += len;
1288 }
1289 }
1290
1291 copy = (bt_property_t*)osi_calloc((sizeof(bt_property_t) * num_properties) + content_len);
1292 log::assert_that(copy != nullptr, "assert failed: copy != nullptr");
1293 uint8_t* content = (uint8_t*)(copy + num_properties);
1294
1295 for (int i = 0; i < num_properties; i++) {
1296 auto len = properties[i].len;
1297 copy[i].type = properties[i].type;
1298 copy[i].len = len;
1299 if (len <= 0) {
1300 continue;
1301 }
1302 copy[i].val = content;
1303 memcpy(content, properties[i].val, len);
1304 content += len;
1305 }
1306 }
1307 return copy;
1308 }
1309
invoke_adapter_state_changed_cb(bt_state_t state)1310 void invoke_adapter_state_changed_cb(bt_state_t state) {
1311 do_in_jni_thread(base::BindOnce(
1312 [](bt_state_t state) { HAL_CBACK(bt_hal_cbacks, adapter_state_changed_cb, state); },
1313 state));
1314 }
1315
invoke_adapter_properties_cb(bt_status_t status,int num_properties,bt_property_t * properties)1316 void invoke_adapter_properties_cb(bt_status_t status, int num_properties,
1317 bt_property_t* properties) {
1318 do_in_jni_thread(base::BindOnce(
1319 [](bt_status_t status, int num_properties, bt_property_t* properties) {
1320 HAL_CBACK(bt_hal_cbacks, adapter_properties_cb, status, num_properties, properties);
1321 if (properties) {
1322 osi_free(properties);
1323 }
1324 },
1325 status, num_properties, property_deep_copy_array(num_properties, properties)));
1326 }
1327
invoke_remote_device_properties_cb(bt_status_t status,RawAddress bd_addr,int num_properties,bt_property_t * properties)1328 void invoke_remote_device_properties_cb(bt_status_t status, RawAddress bd_addr, int num_properties,
1329 bt_property_t* properties) {
1330 do_in_jni_thread(base::BindOnce(
1331 [](bt_status_t status, RawAddress bd_addr, int num_properties,
1332 bt_property_t* properties) {
1333 HAL_CBACK(bt_hal_cbacks, remote_device_properties_cb, status, &bd_addr, num_properties,
1334 properties);
1335 if (properties) {
1336 osi_free(properties);
1337 }
1338 },
1339 status, bd_addr, num_properties, property_deep_copy_array(num_properties, properties)));
1340 }
1341
invoke_device_found_cb(int num_properties,bt_property_t * properties)1342 void invoke_device_found_cb(int num_properties, bt_property_t* properties) {
1343 do_in_jni_thread(base::BindOnce(
1344 [](int num_properties, bt_property_t* properties) {
1345 HAL_CBACK(bt_hal_cbacks, device_found_cb, num_properties, properties);
1346 if (properties) {
1347 osi_free(properties);
1348 }
1349 },
1350 num_properties, property_deep_copy_array(num_properties, properties)));
1351 }
1352
invoke_discovery_state_changed_cb(bt_discovery_state_t state)1353 void invoke_discovery_state_changed_cb(bt_discovery_state_t state) {
1354 do_in_jni_thread(base::BindOnce(
1355 [](bt_discovery_state_t state) {
1356 HAL_CBACK(bt_hal_cbacks, discovery_state_changed_cb, state);
1357 },
1358 state));
1359 }
1360
invoke_pin_request_cb(RawAddress bd_addr,bt_bdname_t bd_name,uint32_t cod,bool min_16_digit)1361 void invoke_pin_request_cb(RawAddress bd_addr, bt_bdname_t bd_name, uint32_t cod,
1362 bool min_16_digit) {
1363 do_in_jni_thread(base::BindOnce(
1364 [](RawAddress bd_addr, bt_bdname_t bd_name, uint32_t cod, bool min_16_digit) {
1365 HAL_CBACK(bt_hal_cbacks, pin_request_cb, &bd_addr, &bd_name, cod, min_16_digit);
1366 },
1367 bd_addr, bd_name, cod, min_16_digit));
1368 }
1369
invoke_ssp_request_cb(RawAddress bd_addr,bt_ssp_variant_t pairing_variant,uint32_t pass_key)1370 void invoke_ssp_request_cb(RawAddress bd_addr, bt_ssp_variant_t pairing_variant,
1371 uint32_t pass_key) {
1372 do_in_jni_thread(base::BindOnce(
1373 [](RawAddress bd_addr, bt_ssp_variant_t pairing_variant, uint32_t pass_key) {
1374 HAL_CBACK(bt_hal_cbacks, ssp_request_cb, &bd_addr, pairing_variant, pass_key);
1375 },
1376 bd_addr, pairing_variant, pass_key));
1377 }
1378
invoke_oob_data_request_cb(tBT_TRANSPORT t,bool valid,Octet16 c,Octet16 r,RawAddress raw_address,uint8_t address_type)1379 void invoke_oob_data_request_cb(tBT_TRANSPORT t, bool valid, Octet16 c, Octet16 r,
1380 RawAddress raw_address, uint8_t address_type) {
1381 log::info("");
1382 bt_oob_data_t oob_data = {};
1383 const char* local_name;
1384 if (get_btm_client_interface().local.BTM_ReadLocalDeviceName(&local_name) !=
1385 tBTM_STATUS::BTM_SUCCESS) {
1386 log::warn("Unable to read local device name");
1387 }
1388 for (int i = 0; i < BD_NAME_LEN; i++) {
1389 oob_data.device_name[i] = local_name[i];
1390 }
1391
1392 // Set the local address
1393 int j = 5;
1394 for (int i = 0; i < 6; i++) {
1395 oob_data.address[i] = raw_address.address[j];
1396 j--;
1397 }
1398 oob_data.address[6] = address_type;
1399
1400 // Each value (for C and R) is 16 octets in length
1401 bool c_empty = true;
1402 for (int i = 0; i < 16; i++) {
1403 // C cannot be all 0s, if so then we want to fail
1404 if (c[i] != 0) {
1405 c_empty = false;
1406 }
1407 oob_data.c[i] = c[i];
1408 // R is optional and may be empty
1409 oob_data.r[i] = r[i];
1410 }
1411 oob_data.is_valid = valid && !c_empty;
1412 // The oob_data_length is 2 octets in length. The value includes the length
1413 // of itself. 16 + 16 + 2 = 34 Data 0x0022 Little Endian order 0x2200
1414 oob_data.oob_data_length[0] = 0;
1415 oob_data.oob_data_length[1] = 34;
1416 bt_status_t status = do_in_jni_thread(base::BindOnce(
1417 [](tBT_TRANSPORT t, bt_oob_data_t oob_data) {
1418 HAL_CBACK(bt_hal_cbacks, generate_local_oob_data_cb, t, oob_data);
1419 },
1420 t, oob_data));
1421 if (status != BT_STATUS_SUCCESS) {
1422 log::error("Failed to call callback!");
1423 }
1424 }
1425
invoke_bond_state_changed_cb(bt_status_t status,RawAddress bd_addr,bt_bond_state_t state,int fail_reason)1426 void invoke_bond_state_changed_cb(bt_status_t status, RawAddress bd_addr, bt_bond_state_t state,
1427 int fail_reason) {
1428 do_in_jni_thread(base::BindOnce(
1429 [](bt_status_t status, RawAddress bd_addr, bt_bond_state_t state, int fail_reason) {
1430 HAL_CBACK(bt_hal_cbacks, bond_state_changed_cb, status, &bd_addr, state, fail_reason);
1431 },
1432 status, bd_addr, state, fail_reason));
1433 }
1434
invoke_address_consolidate_cb(RawAddress main_bd_addr,RawAddress secondary_bd_addr)1435 void invoke_address_consolidate_cb(RawAddress main_bd_addr, RawAddress secondary_bd_addr) {
1436 do_in_jni_thread(base::BindOnce(
1437 [](RawAddress main_bd_addr, RawAddress secondary_bd_addr) {
1438 HAL_CBACK(bt_hal_cbacks, address_consolidate_cb, &main_bd_addr, &secondary_bd_addr);
1439 },
1440 main_bd_addr, secondary_bd_addr));
1441 }
1442
invoke_le_address_associate_cb(RawAddress main_bd_addr,RawAddress secondary_bd_addr,uint8_t identity_address_type)1443 void invoke_le_address_associate_cb(RawAddress main_bd_addr, RawAddress secondary_bd_addr,
1444 uint8_t identity_address_type) {
1445 do_in_jni_thread(base::BindOnce(
1446 [](RawAddress main_bd_addr, RawAddress secondary_bd_addr, uint8_t identity_address_type) {
1447 HAL_CBACK(bt_hal_cbacks, le_address_associate_cb, &main_bd_addr, &secondary_bd_addr,
1448 identity_address_type);
1449 },
1450 main_bd_addr, secondary_bd_addr, identity_address_type));
1451 }
1452
invoke_acl_state_changed_cb(bt_status_t status,RawAddress bd_addr,bt_acl_state_t state,int transport_link_type,bt_hci_error_code_t hci_reason,bt_conn_direction_t direction,uint16_t acl_handle)1453 void invoke_acl_state_changed_cb(bt_status_t status, RawAddress bd_addr, bt_acl_state_t state,
1454 int transport_link_type, bt_hci_error_code_t hci_reason,
1455 bt_conn_direction_t direction, uint16_t acl_handle) {
1456 do_in_jni_thread(base::BindOnce(
1457 [](bt_status_t status, RawAddress bd_addr, bt_acl_state_t state, int transport_link_type,
1458 bt_hci_error_code_t hci_reason, bt_conn_direction_t direction, uint16_t acl_handle) {
1459 HAL_CBACK(bt_hal_cbacks, acl_state_changed_cb, status, &bd_addr, state,
1460 transport_link_type, hci_reason, direction, acl_handle);
1461 },
1462 status, bd_addr, state, transport_link_type, hci_reason, direction, acl_handle));
1463 }
1464
invoke_thread_evt_cb(bt_cb_thread_evt event)1465 void invoke_thread_evt_cb(bt_cb_thread_evt event) {
1466 do_in_jni_thread(base::BindOnce(
1467 [](bt_cb_thread_evt event) {
1468 HAL_CBACK(bt_hal_cbacks, thread_evt_cb, event);
1469 if (event == DISASSOCIATE_JVM) {
1470 bt_hal_cbacks = NULL;
1471 }
1472 },
1473 event));
1474 }
1475
invoke_le_test_mode_cb(bt_status_t status,uint16_t count)1476 void invoke_le_test_mode_cb(bt_status_t status, uint16_t count) {
1477 do_in_jni_thread(base::BindOnce(
1478 [](bt_status_t status, uint16_t count) {
1479 HAL_CBACK(bt_hal_cbacks, le_test_mode_cb, status, count);
1480 },
1481 status, count));
1482 }
1483
1484 // takes ownership of |uid_data|
invoke_energy_info_cb(bt_activity_energy_info energy_info,bt_uid_traffic_t * uid_data)1485 void invoke_energy_info_cb(bt_activity_energy_info energy_info, bt_uid_traffic_t* uid_data) {
1486 do_in_jni_thread(base::BindOnce(
1487 [](bt_activity_energy_info energy_info, bt_uid_traffic_t* uid_data) {
1488 HAL_CBACK(bt_hal_cbacks, energy_info_cb, &energy_info, uid_data);
1489 osi_free(uid_data);
1490 },
1491 energy_info, uid_data));
1492 }
1493
invoke_link_quality_report_cb(uint64_t timestamp,int report_id,int rssi,int snr,int retransmission_count,int packets_not_receive_count,int negative_acknowledgement_count)1494 void invoke_link_quality_report_cb(uint64_t timestamp, int report_id, int rssi, int snr,
1495 int retransmission_count, int packets_not_receive_count,
1496 int negative_acknowledgement_count) {
1497 do_in_jni_thread(base::BindOnce(
1498 [](uint64_t timestamp, int report_id, int rssi, int snr, int retransmission_count,
1499 int packets_not_receive_count, int negative_acknowledgement_count) {
1500 HAL_CBACK(bt_hal_cbacks, link_quality_report_cb, timestamp, report_id, rssi, snr,
1501 retransmission_count, packets_not_receive_count,
1502 negative_acknowledgement_count);
1503 },
1504 timestamp, report_id, rssi, snr, retransmission_count, packets_not_receive_count,
1505 negative_acknowledgement_count));
1506 }
1507
invoke_switch_buffer_size_cb(bool is_low_latency_buffer_size)1508 void invoke_switch_buffer_size_cb(bool is_low_latency_buffer_size) {
1509 do_in_jni_thread(base::BindOnce(
1510 [](bool is_low_latency_buffer_size) {
1511 HAL_CBACK(bt_hal_cbacks, switch_buffer_size_cb, is_low_latency_buffer_size);
1512 },
1513 is_low_latency_buffer_size));
1514 }
1515
invoke_switch_codec_cb(bool is_low_latency_buffer_size)1516 void invoke_switch_codec_cb(bool is_low_latency_buffer_size) {
1517 do_in_jni_thread(base::BindOnce(
1518 [](bool is_low_latency_buffer_size) {
1519 HAL_CBACK(bt_hal_cbacks, switch_codec_cb, is_low_latency_buffer_size);
1520 },
1521 is_low_latency_buffer_size));
1522 }
1523
invoke_key_missing_cb(RawAddress bd_addr)1524 void invoke_key_missing_cb(RawAddress bd_addr) {
1525 do_in_jni_thread(base::BindOnce(
1526 [](RawAddress bd_addr) { HAL_CBACK(bt_hal_cbacks, key_missing_cb, bd_addr); }, bd_addr));
1527 }
1528
invoke_encryption_change_cb(bt_encryption_change_evt encryption_change)1529 void invoke_encryption_change_cb(bt_encryption_change_evt encryption_change) {
1530 do_in_jni_thread(base::BindOnce(
1531 [](bt_encryption_change_evt encryption_change) {
1532 HAL_CBACK(bt_hal_cbacks, encryption_change_cb, encryption_change);
1533 },
1534 encryption_change));
1535 }
1536
1537 namespace bluetooth::testing {
set_hal_cbacks(bt_callbacks_t * callbacks)1538 void set_hal_cbacks(bt_callbacks_t* callbacks) { ::set_hal_cbacks(callbacks); }
1539 } // namespace bluetooth::testing
1540