1 /****************************************************************************** 2 * 3 * Copyright 2003-2014 Broadcom Corporation 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 19 /****************************************************************************** 20 * 21 * This is the API implementation file for the BTA device manager. 22 * 23 ******************************************************************************/ 24 #include <base/bind_helpers.h> 25 #include <string.h> 26 27 #include "bt_common.h" 28 #include "bta_api.h" 29 #include "bta_closure_api.h" 30 #include "bta_dm_int.h" 31 #include "bta_sys.h" 32 #include "bta_sys_int.h" 33 #include "btm_api.h" 34 #include "btm_int.h" 35 #include "osi/include/osi.h" 36 #include "utl.h" 37 38 using bluetooth::Uuid; 39 40 /***************************************************************************** 41 * Constants 42 ****************************************************************************/ 43 44 static const tBTA_SYS_REG bta_dm_search_reg = {bta_dm_search_sm_execute, 45 bta_dm_search_sm_disable}; 46 47 /******************************************************************************* 48 * 49 * Function BTA_EnableBluetooth 50 * 51 * Description Enables bluetooth service. This function must be 52 * called before any other functions in the BTA API are called. 53 * 54 * 55 * Returns tBTA_STATUS 56 * 57 ******************************************************************************/ 58 tBTA_STATUS BTA_EnableBluetooth(tBTA_DM_SEC_CBACK* p_cback) { 59 /* Bluetooth disabling is in progress */ 60 if (bta_dm_cb.disabling) return BTA_FAILURE; 61 62 bta_sys_register(BTA_ID_DM_SEARCH, &bta_dm_search_reg); 63 64 /* if UUID list is not provided as static data */ 65 bta_sys_eir_register(bta_dm_eir_update_uuid); 66 67 do_in_bta_thread(FROM_HERE, base::Bind(bta_dm_enable, p_cback)); 68 return BTA_SUCCESS; 69 } 70 71 /******************************************************************************* 72 * 73 * Function BTA_DisableBluetooth 74 * 75 * Description Disables bluetooth service. This function is called when 76 * the application no longer needs bluetooth service 77 * 78 * Returns void 79 * 80 ******************************************************************************/ 81 tBTA_STATUS BTA_DisableBluetooth(void) { 82 do_in_bta_thread(FROM_HERE, base::Bind(bta_dm_disable)); 83 return BTA_SUCCESS; 84 } 85 86 /** Enables bluetooth device under test mode */ 87 void BTA_EnableTestMode(void) { 88 do_in_bta_thread(FROM_HERE, 89 base::Bind(base::IgnoreResult(BTM_EnableTestMode))); 90 } 91 92 /** Disable bluetooth device under test mode */ 93 void BTA_DisableTestMode(void) { 94 do_in_bta_thread(FROM_HERE, base::Bind(BTM_DeviceReset, nullptr)); 95 } 96 97 /** This function sets the Bluetooth name of local device */ 98 void BTA_DmSetDeviceName(char* p_name) { 99 std::vector<uint8_t> name(BD_NAME_LEN); 100 strlcpy((char*)name.data(), p_name, BD_NAME_LEN); 101 102 do_in_bta_thread(FROM_HERE, base::Bind(bta_dm_set_dev_name, name)); 103 } 104 105 /** This function sets the Bluetooth connectable, discoverable, pairable and 106 * conn paired only modes of local device 107 */ 108 void BTA_DmSetVisibility(tBTA_DM_DISC disc_mode, tBTA_DM_CONN conn_mode, 109 uint8_t pairable_mode, uint8_t conn_paired_only) { 110 do_in_bta_thread(FROM_HERE, 111 base::Bind(bta_dm_set_visibility, disc_mode, conn_mode, 112 pairable_mode, conn_paired_only)); 113 } 114 115 /******************************************************************************* 116 * 117 * Function BTA_DmSearch 118 * 119 * Description This function searches for peer Bluetooth devices. It 120 * performs an inquiry and gets the remote name for devices. 121 * Service discovery is done if services is non zero 122 * 123 * 124 * Returns void 125 * 126 ******************************************************************************/ 127 void BTA_DmSearch(tBTA_DM_INQ* p_dm_inq, tBTA_SERVICE_MASK services, 128 tBTA_DM_SEARCH_CBACK* p_cback) { 129 tBTA_DM_API_SEARCH* p_msg = 130 (tBTA_DM_API_SEARCH*)osi_calloc(sizeof(tBTA_DM_API_SEARCH)); 131 132 p_msg->hdr.event = BTA_DM_API_SEARCH_EVT; 133 memcpy(&p_msg->inq_params, p_dm_inq, sizeof(tBTA_DM_INQ)); 134 p_msg->services = services; 135 p_msg->p_cback = p_cback; 136 p_msg->rs_res = BTA_DM_RS_NONE; 137 138 bta_sys_sendmsg(p_msg); 139 } 140 141 /******************************************************************************* 142 * 143 * Function BTA_DmSearchCancel 144 * 145 * Description This function cancels a search initiated by BTA_DmSearch 146 * 147 * 148 * Returns void 149 * 150 ******************************************************************************/ 151 void BTA_DmSearchCancel(void) { 152 BT_HDR* p_msg = (BT_HDR*)osi_malloc(sizeof(BT_HDR)); 153 154 p_msg->event = BTA_DM_API_SEARCH_CANCEL_EVT; 155 bta_sys_sendmsg(p_msg); 156 } 157 158 /******************************************************************************* 159 * 160 * Function BTA_DmDiscover 161 * 162 * Description This function does service discovery for services of a 163 * peer device 164 * 165 * 166 * Returns void 167 * 168 ******************************************************************************/ 169 void BTA_DmDiscover(const RawAddress& bd_addr, tBTA_SERVICE_MASK services, 170 tBTA_DM_SEARCH_CBACK* p_cback, bool sdp_search) { 171 tBTA_DM_API_DISCOVER* p_msg = 172 (tBTA_DM_API_DISCOVER*)osi_calloc(sizeof(tBTA_DM_API_DISCOVER)); 173 174 p_msg->hdr.event = BTA_DM_API_DISCOVER_EVT; 175 p_msg->bd_addr = bd_addr; 176 p_msg->services = services; 177 p_msg->p_cback = p_cback; 178 p_msg->sdp_search = sdp_search; 179 180 bta_sys_sendmsg(p_msg); 181 } 182 183 /******************************************************************************* 184 * 185 * Function BTA_DmDiscoverUUID 186 * 187 * Description This function does service discovery for services of a 188 * peer device 189 * 190 * 191 * Returns void 192 * 193 ******************************************************************************/ 194 void BTA_DmDiscoverUUID(const RawAddress& bd_addr, const Uuid& uuid, 195 tBTA_DM_SEARCH_CBACK* p_cback, bool sdp_search) { 196 tBTA_DM_API_DISCOVER* p_msg = 197 (tBTA_DM_API_DISCOVER*)osi_malloc(sizeof(tBTA_DM_API_DISCOVER)); 198 199 p_msg->hdr.event = BTA_DM_API_DISCOVER_EVT; 200 p_msg->bd_addr = bd_addr; 201 p_msg->services = BTA_USER_SERVICE_MASK; // Not exposed at API level 202 p_msg->p_cback = p_cback; 203 p_msg->sdp_search = sdp_search; 204 205 p_msg->num_uuid = 0; 206 p_msg->p_uuid = NULL; 207 p_msg->uuid = uuid; 208 209 bta_sys_sendmsg(p_msg); 210 } 211 212 /** This function initiates a bonding procedure with a peer device */ 213 void BTA_DmBond(const RawAddress& bd_addr) { 214 do_in_bta_thread(FROM_HERE, 215 base::Bind(bta_dm_bond, bd_addr, BTA_TRANSPORT_UNKNOWN)); 216 } 217 218 /** This function initiates a bonding procedure with a peer device */ 219 void BTA_DmBondByTransport(const RawAddress& bd_addr, 220 tBTA_TRANSPORT transport) { 221 do_in_bta_thread(FROM_HERE, base::Bind(bta_dm_bond, bd_addr, transport)); 222 } 223 224 /** This function cancels the bonding procedure with a peer device 225 */ 226 void BTA_DmBondCancel(const RawAddress& bd_addr) { 227 do_in_bta_thread(FROM_HERE, base::Bind(bta_dm_bond_cancel, bd_addr)); 228 } 229 230 /******************************************************************************* 231 * 232 * Function BTA_DmPinReply 233 * 234 * Description This function provides a pincode for a remote device when 235 * one is requested by DM through BTA_DM_PIN_REQ_EVT 236 * 237 * 238 * Returns void 239 * 240 ******************************************************************************/ 241 void BTA_DmPinReply(const RawAddress& bd_addr, bool accept, uint8_t pin_len, 242 uint8_t* p_pin) { 243 std::unique_ptr<tBTA_DM_API_PIN_REPLY> msg = 244 std::make_unique<tBTA_DM_API_PIN_REPLY>(); 245 246 msg->bd_addr = bd_addr; 247 msg->accept = accept; 248 if (accept) { 249 msg->pin_len = pin_len; 250 memcpy(msg->p_pin, p_pin, pin_len); 251 } 252 253 do_in_bta_thread(FROM_HERE, base::Bind(bta_dm_pin_reply, base::Passed(&msg))); 254 } 255 256 /******************************************************************************* 257 * 258 * Function BTA_DmLocalOob 259 * 260 * Description This function retrieves the OOB data from local controller. 261 * The result is reported by: 262 * - bta_dm_co_loc_oob_ext() if device supports secure 263 * connections (SC) 264 * - bta_dm_co_loc_oob() if device doesn't support SC 265 * 266 * Returns void 267 * 268 ******************************************************************************/ 269 void BTA_DmLocalOob(void) { 270 do_in_bta_thread(FROM_HERE, base::Bind(BTM_ReadLocalOobData)); 271 } 272 273 /******************************************************************************* 274 * 275 * Function BTA_DmConfirm 276 * 277 * Description This function accepts or rejects the numerical value of the 278 * Simple Pairing process on BTA_DM_SP_CFM_REQ_EVT 279 * 280 * Returns void 281 * 282 ******************************************************************************/ 283 void BTA_DmConfirm(const RawAddress& bd_addr, bool accept) { 284 do_in_bta_thread(FROM_HERE, base::Bind(bta_dm_confirm, bd_addr, accept)); 285 } 286 287 /******************************************************************************* 288 * 289 * Function BTA_DmAddDevice 290 * 291 * Description This function adds a device to the security database list of 292 * peer device 293 * 294 * 295 * Returns void 296 * 297 ******************************************************************************/ 298 void BTA_DmAddDevice(const RawAddress& bd_addr, DEV_CLASS dev_class, 299 LINK_KEY link_key, tBTA_SERVICE_MASK trusted_mask, 300 bool is_trusted, uint8_t key_type, tBTA_IO_CAP io_cap, 301 uint8_t pin_length) { 302 std::unique_ptr<tBTA_DM_API_ADD_DEVICE> msg = 303 std::make_unique<tBTA_DM_API_ADD_DEVICE>(); 304 305 msg->bd_addr = bd_addr; 306 msg->tm = trusted_mask; 307 msg->is_trusted = is_trusted; 308 msg->io_cap = io_cap; 309 310 if (link_key) { 311 msg->link_key_known = true; 312 msg->key_type = key_type; 313 memcpy(msg->link_key, link_key, LINK_KEY_LEN); 314 } 315 316 /* Load device class if specified */ 317 if (dev_class) { 318 msg->dc_known = true; 319 memcpy(msg->dc, dev_class, DEV_CLASS_LEN); 320 } 321 322 memset(msg->bd_name, 0, BD_NAME_LEN + 1); 323 memset(msg->features, 0, sizeof(msg->features)); 324 msg->pin_length = pin_length; 325 326 do_in_bta_thread(FROM_HERE, 327 base::Bind(bta_dm_add_device, base::Passed(&msg))); 328 } 329 330 /** This function removes a device fromthe security database list of peer 331 * device. It manages unpairing even while connected */ 332 tBTA_STATUS BTA_DmRemoveDevice(const RawAddress& bd_addr) { 333 do_in_bta_thread(FROM_HERE, base::Bind(bta_dm_remove_device, bd_addr)); 334 return BTA_SUCCESS; 335 } 336 337 /******************************************************************************* 338 * 339 * Function BTA_GetEirService 340 * 341 * Description This function is called to get BTA service mask from EIR. 342 * 343 * Parameters p_eir - pointer of EIR significant part 344 * p_services - return the BTA service mask 345 * 346 * Returns None 347 * 348 ******************************************************************************/ 349 extern const uint16_t bta_service_id_to_uuid_lkup_tbl[]; 350 void BTA_GetEirService(uint8_t* p_eir, size_t eir_len, 351 tBTA_SERVICE_MASK* p_services) { 352 uint8_t xx, yy; 353 uint8_t num_uuid, max_num_uuid = 32; 354 uint8_t uuid_list[32 * Uuid::kNumBytes16]; 355 uint16_t* p_uuid16 = (uint16_t*)uuid_list; 356 tBTA_SERVICE_MASK mask; 357 358 BTM_GetEirUuidList(p_eir, eir_len, Uuid::kNumBytes16, &num_uuid, uuid_list, 359 max_num_uuid); 360 for (xx = 0; xx < num_uuid; xx++) { 361 mask = 1; 362 for (yy = 0; yy < BTA_MAX_SERVICE_ID; yy++) { 363 if (*(p_uuid16 + xx) == bta_service_id_to_uuid_lkup_tbl[yy]) { 364 *p_services |= mask; 365 break; 366 } 367 mask <<= 1; 368 } 369 370 /* for HSP v1.2 only device */ 371 if (*(p_uuid16 + xx) == UUID_SERVCLASS_HEADSET_HS) 372 *p_services |= BTA_HSP_SERVICE_MASK; 373 374 if (*(p_uuid16 + xx) == UUID_SERVCLASS_HDP_SOURCE) 375 *p_services |= BTA_HL_SERVICE_MASK; 376 377 if (*(p_uuid16 + xx) == UUID_SERVCLASS_HDP_SINK) 378 *p_services |= BTA_HL_SERVICE_MASK; 379 } 380 } 381 382 /******************************************************************************* 383 * 384 * Function BTA_DmGetConnectionState 385 * 386 * Description Returns whether the remote device is currently connected. 387 * 388 * Returns 0 if the device is NOT connected. 389 * 390 ******************************************************************************/ 391 uint16_t BTA_DmGetConnectionState(const RawAddress& bd_addr) { 392 tBTA_DM_PEER_DEVICE* p_dev = bta_dm_find_peer_device(bd_addr); 393 return (p_dev && p_dev->conn_state == BTA_DM_CONNECTED); 394 } 395 396 /******************************************************************************* 397 * Device Identification (DI) Server Functions 398 ******************************************************************************/ 399 /******************************************************************************* 400 * 401 * Function BTA_DmSetLocalDiRecord 402 * 403 * Description This function adds a DI record to the local SDP database. 404 * 405 * Returns BTA_SUCCESS if record set sucessfully, otherwise error code. 406 * 407 ******************************************************************************/ 408 tBTA_STATUS BTA_DmSetLocalDiRecord(tBTA_DI_RECORD* p_device_info, 409 uint32_t* p_handle) { 410 tBTA_STATUS status = BTA_FAILURE; 411 412 if (bta_dm_di_cb.di_num < BTA_DI_NUM_MAX) { 413 if (SDP_SetLocalDiRecord((tSDP_DI_RECORD*)p_device_info, p_handle) == 414 SDP_SUCCESS) { 415 if (!p_device_info->primary_record) { 416 bta_dm_di_cb.di_handle[bta_dm_di_cb.di_num] = *p_handle; 417 bta_dm_di_cb.di_num++; 418 } 419 420 bta_sys_add_uuid(UUID_SERVCLASS_PNP_INFORMATION); 421 status = BTA_SUCCESS; 422 } 423 } 424 425 return status; 426 } 427 428 /******************************************************************************* 429 * 430 * Function BTA_DmAddBleKey 431 * 432 * Description Add/modify LE device information. This function will be 433 * normally called during host startup to restore all required 434 * information stored in the NVRAM. 435 * 436 * Parameters: bd_addr - BD address of the peer 437 * p_le_key - LE key values. 438 * key_type - LE SMP key type. 439 * 440 * Returns BTA_SUCCESS if successful 441 * BTA_FAIL if operation failed. 442 * 443 ******************************************************************************/ 444 void BTA_DmAddBleKey(const RawAddress& bd_addr, tBTA_LE_KEY_VALUE* p_le_key, 445 tBTA_LE_KEY_TYPE key_type) { 446 do_in_bta_thread(FROM_HERE, 447 base::Bind(bta_dm_add_blekey, bd_addr, *p_le_key, key_type)); 448 } 449 450 /******************************************************************************* 451 * 452 * Function BTA_DmAddBleDevice 453 * 454 * Description Add a BLE device. This function will be normally called 455 * during host startup to restore all required information 456 * for a LE device stored in the NVRAM. 457 * 458 * Parameters: bd_addr - BD address of the peer 459 * dev_type - Remote device's device type. 460 * addr_type - LE device address type. 461 * 462 * Returns void 463 * 464 ******************************************************************************/ 465 void BTA_DmAddBleDevice(const RawAddress& bd_addr, tBLE_ADDR_TYPE addr_type, 466 tBT_DEVICE_TYPE dev_type) { 467 do_in_bta_thread(FROM_HERE, base::Bind(bta_dm_add_ble_device, bd_addr, 468 addr_type, dev_type)); 469 } 470 471 /******************************************************************************* 472 * 473 * Function BTA_DmBlePasskeyReply 474 * 475 * Description Send BLE SMP passkey reply. 476 * 477 * Parameters: bd_addr - BD address of the peer 478 * accept - passkey entry sucessful or declined. 479 * passkey - passkey value, must be a 6 digit number, 480 * can be lead by 0. 481 * 482 * Returns void 483 * 484 ******************************************************************************/ 485 void BTA_DmBlePasskeyReply(const RawAddress& bd_addr, bool accept, 486 uint32_t passkey) { 487 do_in_bta_thread(FROM_HERE, base::Bind(bta_dm_ble_passkey_reply, bd_addr, 488 accept, accept ? passkey : 0)); 489 } 490 491 /******************************************************************************* 492 * 493 * Function BTA_DmBleConfirmReply 494 * 495 * Description Send BLE SMP SC user confirmation reply. 496 * 497 * Parameters: bd_addr - BD address of the peer 498 * accept - numbers to compare are the same or 499 * different. 500 * 501 * Returns void 502 * 503 ******************************************************************************/ 504 void BTA_DmBleConfirmReply(const RawAddress& bd_addr, bool accept) { 505 do_in_bta_thread(FROM_HERE, 506 base::Bind(bta_dm_ble_confirm_reply, bd_addr, accept)); 507 } 508 509 /******************************************************************************* 510 * 511 * Function BTA_DmBleSecurityGrant 512 * 513 * Description Grant security request access. 514 * 515 * Parameters: bd_addr - BD address of the peer 516 * res - security grant status. 517 * 518 * Returns void 519 * 520 ******************************************************************************/ 521 void BTA_DmBleSecurityGrant(const RawAddress& bd_addr, 522 tBTA_DM_BLE_SEC_GRANT res) { 523 do_in_bta_thread(FROM_HERE, base::Bind(BTM_SecurityGrant, bd_addr, res)); 524 } 525 526 /******************************************************************************* 527 * 528 * Function BTA_DmSetBlePrefConnParams 529 * 530 * Description This function is called to set the preferred connection 531 * parameters when default connection parameter is not desired. 532 * 533 * Parameters: bd_addr - BD address of the peripheral 534 * scan_interval - scan interval 535 * scan_window - scan window 536 * min_conn_int - minimum preferred connection interval 537 * max_conn_int - maximum preferred connection interval 538 * slave_latency - preferred slave latency 539 * supervision_tout - preferred supervision timeout 540 * 541 * 542 * Returns void 543 * 544 ******************************************************************************/ 545 void BTA_DmSetBlePrefConnParams(const RawAddress& bd_addr, 546 uint16_t min_conn_int, uint16_t max_conn_int, 547 uint16_t slave_latency, 548 uint16_t supervision_tout) { 549 do_in_bta_thread(FROM_HERE, 550 base::Bind(bta_dm_ble_set_conn_params, bd_addr, min_conn_int, 551 max_conn_int, slave_latency, supervision_tout)); 552 } 553 554 /******************************************************************************* 555 * 556 * Function BTA_DmSetBleConnScanParams 557 * 558 * Description This function is called to set scan parameters used in 559 * BLE connection request 560 * 561 * Parameters: scan_interval - scan interval 562 * scan_window - scan window 563 * 564 * Returns void 565 * 566 ******************************************************************************/ 567 void BTA_DmSetBleConnScanParams(uint32_t scan_interval, uint32_t scan_window) { 568 do_in_bta_thread(FROM_HERE, base::Bind(bta_dm_ble_set_conn_scan_params, 569 scan_interval, scan_window)); 570 } 571 572 /** Set BLE connectable mode to auto connect */ 573 void BTA_DmBleStartAutoConn() { 574 do_in_bta_thread(FROM_HERE, base::Bind(BTM_BleStartAutoConn)); 575 } 576 577 /******************************************************************************* 578 * 579 * Function bta_dm_discover_send_msg 580 * 581 * Description This function send discover message to BTA task. 582 * 583 * Returns void 584 * 585 ******************************************************************************/ 586 static void bta_dm_discover_send_msg(const RawAddress& bd_addr, 587 tBTA_SERVICE_MASK_EXT* p_services, 588 tBTA_DM_SEARCH_CBACK* p_cback, 589 bool sdp_search, 590 tBTA_TRANSPORT transport) { 591 const size_t len = 592 p_services 593 ? (sizeof(tBTA_DM_API_DISCOVER) + sizeof(Uuid) * p_services->num_uuid) 594 : sizeof(tBTA_DM_API_DISCOVER); 595 tBTA_DM_API_DISCOVER* p_msg = (tBTA_DM_API_DISCOVER*)osi_calloc(len); 596 597 p_msg->hdr.event = BTA_DM_API_DISCOVER_EVT; 598 p_msg->bd_addr = bd_addr; 599 p_msg->p_cback = p_cback; 600 p_msg->sdp_search = sdp_search; 601 p_msg->transport = transport; 602 603 if (p_services != NULL) { 604 p_msg->services = p_services->srvc_mask; 605 p_msg->num_uuid = p_services->num_uuid; 606 if (p_services->num_uuid != 0) { 607 p_msg->p_uuid = (Uuid*)(p_msg + 1); 608 memcpy(p_msg->p_uuid, p_services->p_uuid, 609 sizeof(Uuid) * p_services->num_uuid); 610 } 611 } 612 613 bta_sys_sendmsg(p_msg); 614 } 615 616 /******************************************************************************* 617 * 618 * Function BTA_DmDiscoverByTransport 619 * 620 * Description This function does service discovery on particular transport 621 * for services of a 622 * peer device. When services.num_uuid is 0, it indicates all 623 * GATT based services are to be searched; otherwise a list of 624 * UUID of interested services should be provided through 625 * p_services->p_uuid. 626 * 627 * 628 * 629 * Returns void 630 * 631 ******************************************************************************/ 632 void BTA_DmDiscoverByTransport(const RawAddress& bd_addr, 633 tBTA_SERVICE_MASK_EXT* p_services, 634 tBTA_DM_SEARCH_CBACK* p_cback, bool sdp_search, 635 tBTA_TRANSPORT transport) { 636 bta_dm_discover_send_msg(bd_addr, p_services, p_cback, sdp_search, transport); 637 } 638 639 /******************************************************************************* 640 * 641 * Function BTA_DmDiscoverExt 642 * 643 * Description This function does service discovery for services of a 644 * peer device. When services.num_uuid is 0, it indicates all 645 * GATT based services are to be searched; other wise a list of 646 * UUID of interested services should be provided through 647 * p_services->p_uuid. 648 * 649 * 650 * 651 * Returns void 652 * 653 ******************************************************************************/ 654 void BTA_DmDiscoverExt(const RawAddress& bd_addr, 655 tBTA_SERVICE_MASK_EXT* p_services, 656 tBTA_DM_SEARCH_CBACK* p_cback, bool sdp_search) { 657 bta_dm_discover_send_msg(bd_addr, p_services, p_cback, sdp_search, 658 BTA_TRANSPORT_UNKNOWN); 659 } 660 661 /******************************************************************************* 662 * 663 * Function BTA_DmSearchExt 664 * 665 * Description This function searches for peer Bluetooth devices. It 666 * performs an inquiry and gets the remote name for devices. 667 * Service discovery is done if services is non zero 668 * 669 * Parameters p_dm_inq: inquiry conditions 670 * p_services: if service is not empty, service discovery will 671 * be done. For all GATT based service conditions, 672 * put num_uuid, and p_uuid is the pointer to the 673 * list of UUID values. 674 * p_cback: callback function when search is completed. 675 * 676 * 677 * 678 * Returns void 679 * 680 ******************************************************************************/ 681 void BTA_DmSearchExt(tBTA_DM_INQ* p_dm_inq, tBTA_SERVICE_MASK_EXT* p_services, 682 tBTA_DM_SEARCH_CBACK* p_cback) { 683 const size_t len = 684 p_services 685 ? (sizeof(tBTA_DM_API_SEARCH) + sizeof(Uuid) * p_services->num_uuid) 686 : sizeof(tBTA_DM_API_SEARCH); 687 tBTA_DM_API_SEARCH* p_msg = (tBTA_DM_API_SEARCH*)osi_calloc(len); 688 689 p_msg->hdr.event = BTA_DM_API_SEARCH_EVT; 690 memcpy(&p_msg->inq_params, p_dm_inq, sizeof(tBTA_DM_INQ)); 691 p_msg->p_cback = p_cback; 692 p_msg->rs_res = BTA_DM_RS_NONE; 693 694 if (p_services != NULL) { 695 p_msg->services = p_services->srvc_mask; 696 p_msg->num_uuid = p_services->num_uuid; 697 698 if (p_services->num_uuid != 0) { 699 p_msg->p_uuid = (Uuid*)(p_msg + 1); 700 memcpy(p_msg->p_uuid, p_services->p_uuid, 701 sizeof(Uuid) * p_services->num_uuid); 702 } else { 703 p_msg->p_uuid = NULL; 704 } 705 } 706 707 bta_sys_sendmsg(p_msg); 708 } 709 710 /******************************************************************************* 711 * 712 * Function BTA_DmBleUpdateConnectionParam 713 * 714 * Description Update connection parameters, can only be used when 715 * connection is up. 716 * 717 * Parameters: bd_addr - BD address of the peer 718 * min_int - minimum connection interval, 719 * [0x0004 ~ 0x4000] 720 * max_int - maximum connection interval, 721 * [0x0004 ~ 0x4000] 722 * latency - slave latency [0 ~ 500] 723 * timeout - supervision timeout [0x000a ~ 0xc80] 724 * 725 * Returns void 726 * 727 ******************************************************************************/ 728 void BTA_DmBleUpdateConnectionParams(const RawAddress& bd_addr, 729 uint16_t min_int, uint16_t max_int, 730 uint16_t latency, uint16_t timeout, 731 uint16_t min_ce_len, uint16_t max_ce_len) { 732 do_in_bta_thread( 733 FROM_HERE, base::Bind(bta_dm_ble_update_conn_params, bd_addr, min_int, 734 max_int, latency, timeout, min_ce_len, max_ce_len)); 735 } 736 737 /******************************************************************************* 738 * 739 * Function BTA_DmBleConfigLocalPrivacy 740 * 741 * Description Enable/disable privacy on the local device 742 * 743 * Parameters: privacy_enable - enable/disabe privacy on remote device. 744 * 745 * Returns void 746 * 747 ******************************************************************************/ 748 void BTA_DmBleConfigLocalPrivacy(bool privacy_enable) { 749 #if (BLE_PRIVACY_SPT == TRUE) 750 do_in_bta_thread(FROM_HERE, 751 base::Bind(bta_dm_ble_config_local_privacy, privacy_enable)); 752 #else 753 UNUSED(privacy_enable); 754 #endif 755 } 756 757 /******************************************************************************* 758 * 759 * Function BTA_DmBleGetEnergyInfo 760 * 761 * Description This function is called to obtain the energy info 762 * 763 * Parameters p_cmpl_cback - Command complete callback 764 * 765 * Returns void 766 * 767 ******************************************************************************/ 768 void BTA_DmBleGetEnergyInfo(tBTA_BLE_ENERGY_INFO_CBACK* p_cmpl_cback) { 769 do_in_bta_thread(FROM_HERE, 770 base::Bind(bta_dm_ble_get_energy_info, p_cmpl_cback)); 771 } 772 773 /** This function is to set maximum LE data packet size */ 774 void BTA_DmBleSetDataLength(const RawAddress& remote_device, 775 uint16_t tx_data_length) { 776 do_in_bta_thread(FROM_HERE, base::Bind(bta_dm_ble_set_data_length, 777 remote_device, tx_data_length)); 778 } 779 780 /******************************************************************************* 781 * 782 * Function BTA_DmSetEncryption 783 * 784 * Description This function is called to ensure that connection is 785 * encrypted. Should be called only on an open connection. 786 * Typically only needed for connections that first want to 787 * bring up unencrypted links, then later encrypt them. 788 * 789 * Parameters: bd_addr - Address of the peer device 790 * transport - transport of the link to be encruypted 791 * p_callback - Pointer to callback function to indicat the 792 * link encryption status 793 * sec_act - This is the security action to indicate 794 * what kind of BLE security level is required 795 * for the BLE link if BLE is supported. 796 * Note: This parameter is ignored for the 797 * BR/EDR or if BLE is not supported. 798 * 799 * Returns void 800 * 801 ******************************************************************************/ 802 void BTA_DmSetEncryption(const RawAddress& bd_addr, tBTA_TRANSPORT transport, 803 tBTA_DM_ENCRYPT_CBACK* p_callback, 804 tBTA_DM_BLE_SEC_ACT sec_act) { 805 APPL_TRACE_API("%s", __func__); 806 do_in_bta_thread(FROM_HERE, base::Bind(bta_dm_set_encryption, bd_addr, 807 transport, p_callback, sec_act)); 808 } 809 810 /******************************************************************************* 811 * 812 * Function BTA_DmCloseACL 813 * 814 * Description This function force to close an ACL connection and remove 815 * the device from the security database list of known devices. 816 * 817 * Parameters: bd_addr - Address of the peer device 818 * remove_dev - remove device or not after link down 819 * 820 * Returns void 821 * 822 ******************************************************************************/ 823 void BTA_DmCloseACL(const RawAddress& bd_addr, bool remove_dev, 824 tBTA_TRANSPORT transport) { 825 do_in_bta_thread( 826 FROM_HERE, base::Bind(bta_dm_close_acl, bd_addr, remove_dev, transport)); 827 } 828 829 /******************************************************************************* 830 * 831 * Function BTA_DmBleObserve 832 * 833 * Description This procedure keep the device listening for advertising 834 * events from a broadcast device. 835 * 836 * Parameters start: start or stop observe. 837 * 838 * Returns void 839 840 * 841 * Returns void. 842 * 843 ******************************************************************************/ 844 extern void BTA_DmBleObserve(bool start, uint8_t duration, 845 tBTA_DM_SEARCH_CBACK* p_results_cb) { 846 APPL_TRACE_API("%s:start = %d ", __func__, start); 847 do_in_bta_thread( 848 FROM_HERE, base::Bind(bta_dm_ble_observe, start, duration, p_results_cb)); 849 } 850 851 /******************************************************************************* 852 * 853 * Function BTA_VendorInit 854 * 855 * Description This function initializes vendor specific 856 * 857 * Returns void 858 * 859 ******************************************************************************/ 860 void BTA_VendorInit(void) { APPL_TRACE_API("BTA_VendorInit"); } 861 862 /******************************************************************************* 863 * 864 * Function BTA_VendorCleanup 865 * 866 * Description This function frees up Broadcom specific VS specific dynamic 867 * memory 868 * 869 * Returns void 870 * 871 ******************************************************************************/ 872 void BTA_VendorCleanup(void) { 873 tBTM_BLE_VSC_CB cmn_ble_vsc_cb; 874 BTM_BleGetVendorCapabilities(&cmn_ble_vsc_cb); 875 876 if (cmn_ble_vsc_cb.max_filter > 0) { 877 btm_ble_adv_filter_cleanup(); 878 #if (BLE_PRIVACY_SPT == TRUE) 879 btm_ble_resolving_list_cleanup(); 880 #endif 881 } 882 883 if (cmn_ble_vsc_cb.tot_scan_results_strg > 0) btm_ble_batchscan_cleanup(); 884 885 if (cmn_ble_vsc_cb.adv_inst_max > 0) btm_ble_multi_adv_cleanup(); 886 } 887
