1 /****************************************************************************** 2 * 3 * Copyright (C) 2003-2012 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 file contains the GATT client action functions for the state 22 * machine. 23 * 24 ******************************************************************************/ 25 #define LOG_TAG "bt_bta_gattc" 26 27 #include "bt_target.h" 28 29 #include "utl.h" 30 #include "gki.h" 31 #include "bta_sys.h" 32 33 #include "bta_gattc_int.h" 34 #include "l2c_api.h" 35 36 #if (defined BTA_HH_LE_INCLUDED && BTA_HH_LE_INCLUDED == TRUE) 37 #include "bta_hh_int.h" 38 #endif 39 40 #include "btif/include/btif_debug_conn.h" 41 42 #include <string.h> 43 44 #include "osi/include/log.h" 45 46 #if BTA_GATT_INCLUDED && BLE_INCLUDED == TRUE 47 48 /***************************************************************************** 49 ** Constants 50 *****************************************************************************/ 51 static void bta_gattc_conn_cback(tGATT_IF gattc_if, BD_ADDR bda, UINT16 conn_id, 52 BOOLEAN connected, tGATT_DISCONN_REASON reason, 53 tBT_TRANSPORT transport); 54 55 static void bta_gattc_cmpl_cback(UINT16 conn_id, tGATTC_OPTYPE op, tGATT_STATUS status, 56 tGATT_CL_COMPLETE *p_data); 57 58 static void bta_gattc_deregister_cmpl(tBTA_GATTC_RCB *p_clreg); 59 static void bta_gattc_enc_cmpl_cback(tGATT_IF gattc_if, BD_ADDR bda); 60 static void bta_gattc_cong_cback (UINT16 conn_id, BOOLEAN congested); 61 62 static tGATT_CBACK bta_gattc_cl_cback = 63 { 64 bta_gattc_conn_cback, 65 bta_gattc_cmpl_cback, 66 bta_gattc_disc_res_cback, 67 bta_gattc_disc_cmpl_cback, 68 NULL, 69 bta_gattc_enc_cmpl_cback, 70 bta_gattc_cong_cback 71 }; 72 73 /* opcode(tGATTC_OPTYPE) order has to be comply with internal event order */ 74 static UINT16 bta_gattc_opcode_to_int_evt[] = 75 { 76 BTA_GATTC_API_READ_EVT, 77 BTA_GATTC_API_WRITE_EVT, 78 BTA_GATTC_API_EXEC_EVT, 79 BTA_GATTC_API_CFG_MTU_EVT 80 }; 81 82 #if (BT_TRACE_VERBOSE == TRUE) 83 static const char *bta_gattc_op_code_name[] = 84 { 85 "Unknown", 86 "Discovery", 87 "Read", 88 "Write", 89 "Exec", 90 "Config", 91 "Notification", 92 "Indication" 93 }; 94 #endif 95 /***************************************************************************** 96 ** Action Functions 97 *****************************************************************************/ 98 99 /******************************************************************************* 100 ** 101 ** Function bta_gattc_enable 102 ** 103 ** Description Enables GATTC module 104 ** 105 ** 106 ** Returns void 107 ** 108 *******************************************************************************/ 109 static void bta_gattc_enable(tBTA_GATTC_CB *p_cb) 110 { 111 APPL_TRACE_DEBUG("bta_gattc_enable"); 112 113 if (p_cb->state == BTA_GATTC_STATE_DISABLED) 114 { 115 /* initialize control block */ 116 memset(&bta_gattc_cb, 0, sizeof(tBTA_GATTC_CB)); 117 p_cb->state = BTA_GATTC_STATE_ENABLED; 118 } 119 else 120 { 121 APPL_TRACE_DEBUG("GATTC is arelady enabled"); 122 } 123 } 124 125 126 /******************************************************************************* 127 ** 128 ** Function bta_gattc_disable 129 ** 130 ** Description Disable GATTC module by cleaning up all active connections 131 ** and deregister all application. 132 ** 133 ** Returns void 134 ** 135 *******************************************************************************/ 136 void bta_gattc_disable(tBTA_GATTC_CB *p_cb) 137 { 138 UINT8 i; 139 140 APPL_TRACE_DEBUG("bta_gattc_disable"); 141 142 if (p_cb->state != BTA_GATTC_STATE_ENABLED) 143 { 144 APPL_TRACE_ERROR("not enabled or disable in pogress"); 145 return; 146 } 147 148 for (i = 0; i <BTA_GATTC_CL_MAX; i ++) 149 { 150 if (p_cb->cl_rcb[i].in_use) 151 { 152 p_cb->state = BTA_GATTC_STATE_DISABLING; 153 /* don't deregister HH GATT IF */ 154 /* HH GATT IF will be deregistered by bta_hh_le_deregister when disable HH */ 155 #if (defined BTA_HH_LE_INCLUDED && BTA_HH_LE_INCLUDED == TRUE) 156 if (!bta_hh_le_is_hh_gatt_if(p_cb->cl_rcb[i].client_if)) { 157 #endif 158 bta_gattc_deregister(p_cb, &p_cb->cl_rcb[i]); 159 #if (defined BTA_HH_LE_INCLUDED && BTA_HH_LE_INCLUDED == TRUE) 160 } 161 #endif 162 } 163 } 164 165 /* no registered apps, indicate disable completed */ 166 if (p_cb->state != BTA_GATTC_STATE_DISABLING) 167 { 168 p_cb->state = BTA_GATTC_STATE_DISABLED; 169 memset(p_cb, 0, sizeof(tBTA_GATTC_CB)); 170 } 171 } 172 173 /******************************************************************************* 174 ** 175 ** Function bta_gattc_register 176 ** 177 ** Description Register a GATT client application with BTA. 178 ** 179 ** Returns void 180 ** 181 *******************************************************************************/ 182 void bta_gattc_register(tBTA_GATTC_CB *p_cb, tBTA_GATTC_DATA *p_data) 183 { 184 tBTA_GATTC cb_data; 185 UINT8 i; 186 tBT_UUID *p_app_uuid = &p_data->api_reg.app_uuid; 187 tBTA_GATTC_INT_START_IF *p_buf; 188 tBTA_GATT_STATUS status = BTA_GATT_NO_RESOURCES; 189 190 191 APPL_TRACE_DEBUG("bta_gattc_register state %d",p_cb->state); 192 memset(&cb_data, 0, sizeof(cb_data)); 193 cb_data.reg_oper.status = BTA_GATT_NO_RESOURCES; 194 195 /* check if GATTC module is already enabled . Else enable */ 196 if (p_cb->state == BTA_GATTC_STATE_DISABLED) 197 { 198 bta_gattc_enable (p_cb); 199 } 200 /* todo need to check duplicate uuid */ 201 for (i = 0; i < BTA_GATTC_CL_MAX; i ++) 202 { 203 if (!p_cb->cl_rcb[i].in_use) 204 { 205 if ((p_app_uuid == NULL) || (p_cb->cl_rcb[i].client_if = GATT_Register(p_app_uuid, &bta_gattc_cl_cback)) == 0) 206 { 207 APPL_TRACE_ERROR("Register with GATT stack failed."); 208 status = BTA_GATT_ERROR; 209 } 210 else 211 { 212 p_cb->cl_rcb[i].in_use = TRUE; 213 p_cb->cl_rcb[i].p_cback = p_data->api_reg.p_cback; 214 memcpy(&p_cb->cl_rcb[i].app_uuid, p_app_uuid, sizeof(tBT_UUID)); 215 216 /* BTA use the same client interface as BTE GATT statck */ 217 cb_data.reg_oper.client_if = p_cb->cl_rcb[i].client_if; 218 219 if ((p_buf = (tBTA_GATTC_INT_START_IF *) GKI_getbuf(sizeof(tBTA_GATTC_INT_START_IF))) != NULL) 220 { 221 p_buf->hdr.event = BTA_GATTC_INT_START_IF_EVT; 222 p_buf->client_if = p_cb->cl_rcb[i].client_if; 223 224 bta_sys_sendmsg(p_buf); 225 status = BTA_GATT_OK; 226 } 227 else 228 { 229 GATT_Deregister(p_cb->cl_rcb[i].client_if); 230 231 status = BTA_GATT_NO_RESOURCES; 232 memset( &p_cb->cl_rcb[i], 0 , sizeof(tBTA_GATTC_RCB)); 233 } 234 break; 235 } 236 } 237 } 238 239 /* callback with register event */ 240 if (p_data->api_reg.p_cback) 241 { 242 if (p_app_uuid != NULL) 243 memcpy(&(cb_data.reg_oper.app_uuid),p_app_uuid,sizeof(tBT_UUID)); 244 245 cb_data.reg_oper.status = status; 246 (*p_data->api_reg.p_cback)(BTA_GATTC_REG_EVT, (tBTA_GATTC *)&cb_data); 247 } 248 } 249 /******************************************************************************* 250 ** 251 ** Function bta_gattc_start_if 252 ** 253 ** Description start an application interface. 254 ** 255 ** Returns none. 256 ** 257 *******************************************************************************/ 258 void bta_gattc_start_if(tBTA_GATTC_CB *p_cb, tBTA_GATTC_DATA *p_msg) 259 { 260 UNUSED(p_cb); 261 262 if (bta_gattc_cl_get_regcb(p_msg->int_start_if.client_if) !=NULL ) 263 { 264 GATT_StartIf(p_msg->int_start_if.client_if); 265 } 266 else 267 { 268 APPL_TRACE_ERROR("Unable to start app.: Unknown interface =%d",p_msg->int_start_if.client_if ); 269 } 270 } 271 /******************************************************************************* 272 ** 273 ** Function bta_gattc_deregister 274 ** 275 ** Description De-Register a GATT client application with BTA. 276 ** 277 ** Returns void 278 ** 279 *******************************************************************************/ 280 void bta_gattc_deregister(tBTA_GATTC_CB *p_cb, tBTA_GATTC_RCB *p_clreg) 281 { 282 UINT8 i; 283 BT_HDR buf; 284 285 if (p_clreg != NULL) 286 { 287 /* remove bg connection associated with this rcb */ 288 for (i = 0; i < BTA_GATTC_KNOWN_SR_MAX; i ++) 289 { 290 if (p_cb->bg_track[i].in_use) 291 { 292 if (p_cb->bg_track[i].cif_mask & (1 <<(p_clreg->client_if - 1))) 293 { 294 bta_gattc_mark_bg_conn(p_clreg->client_if, p_cb->bg_track[i].remote_bda, FALSE, FALSE); 295 GATT_CancelConnect(p_clreg->client_if, p_cb->bg_track[i].remote_bda, FALSE); 296 } 297 if (p_cb->bg_track[i].cif_adv_mask & (1 <<(p_clreg->client_if - 1))) 298 { 299 bta_gattc_mark_bg_conn(p_clreg->client_if, p_cb->bg_track[i].remote_bda, FALSE, TRUE); 300 } 301 } 302 } 303 304 if (p_clreg->num_clcb > 0) 305 { 306 /* close all CLCB related to this app */ 307 for (i= 0; i < BTA_GATTC_CLCB_MAX; i ++) 308 { 309 if (p_cb->clcb[i].in_use && (p_cb->clcb[i].p_rcb == p_clreg)) 310 { 311 p_clreg->dereg_pending = TRUE; 312 313 buf.event = BTA_GATTC_API_CLOSE_EVT; 314 buf.layer_specific = p_cb->clcb[i].bta_conn_id; 315 bta_gattc_close(&p_cb->clcb[i], (tBTA_GATTC_DATA *)&buf) ; 316 } 317 } 318 } 319 else 320 bta_gattc_deregister_cmpl(p_clreg); 321 } 322 else 323 { 324 APPL_TRACE_ERROR("bta_gattc_deregister Deregister Failedm unknown client cif"); 325 } 326 } 327 /******************************************************************************* 328 ** 329 ** Function bta_gattc_process_api_open 330 ** 331 ** Description process connect API request. 332 ** 333 ** Returns void 334 ** 335 *******************************************************************************/ 336 void bta_gattc_process_api_open (tBTA_GATTC_CB *p_cb, tBTA_GATTC_DATA * p_msg) 337 { 338 UINT16 event = ((BT_HDR *)p_msg)->event; 339 tBTA_GATTC_CLCB *p_clcb = NULL; 340 tBTA_GATTC_RCB *p_clreg = bta_gattc_cl_get_regcb(p_msg->api_conn.client_if); 341 UNUSED(p_cb); 342 343 if (p_clreg != NULL) 344 { 345 if (p_msg->api_conn.is_direct) 346 { 347 if ((p_clcb = bta_gattc_find_alloc_clcb(p_msg->api_conn.client_if, 348 p_msg->api_conn.remote_bda, 349 p_msg->api_conn.transport)) != NULL) 350 { 351 bta_gattc_sm_execute(p_clcb, event, p_msg); 352 } 353 else 354 { 355 APPL_TRACE_ERROR("No resources to open a new connection."); 356 357 bta_gattc_send_open_cback(p_clreg, 358 BTA_GATT_NO_RESOURCES, 359 p_msg->api_conn.remote_bda, 360 BTA_GATT_INVALID_CONN_ID, 361 p_msg->api_conn.transport, 0); 362 } 363 } 364 else 365 { 366 bta_gattc_init_bk_conn(&p_msg->api_conn, p_clreg); 367 } 368 } 369 else 370 { 371 APPL_TRACE_ERROR("bta_gattc_process_api_open Failed, unknown client_if: %d", 372 p_msg->api_conn.client_if); 373 } 374 } 375 /******************************************************************************* 376 ** 377 ** Function bta_gattc_process_api_open_cancel 378 ** 379 ** Description process connect API request. 380 ** 381 ** Returns void 382 ** 383 *******************************************************************************/ 384 void bta_gattc_process_api_open_cancel (tBTA_GATTC_CB *p_cb, tBTA_GATTC_DATA * p_msg) 385 { 386 UINT16 event = ((BT_HDR *)p_msg)->event; 387 tBTA_GATTC_CLCB *p_clcb = NULL; 388 tBTA_GATTC_RCB *p_clreg; 389 tBTA_GATTC cb_data; 390 UNUSED(p_cb); 391 392 if (p_msg->api_cancel_conn.is_direct) 393 { 394 if ((p_clcb = bta_gattc_find_clcb_by_cif(p_msg->api_cancel_conn.client_if, 395 p_msg->api_cancel_conn.remote_bda, 396 BTA_GATT_TRANSPORT_LE)) != NULL) 397 { 398 bta_gattc_sm_execute(p_clcb, event, p_msg); 399 } 400 else 401 { 402 APPL_TRACE_ERROR("No such connection need to be cancelled"); 403 404 p_clreg = bta_gattc_cl_get_regcb(p_msg->api_cancel_conn.client_if); 405 406 if (p_clreg && p_clreg->p_cback) 407 { 408 cb_data.status = BTA_GATT_ERROR; 409 (*p_clreg->p_cback)(BTA_GATTC_CANCEL_OPEN_EVT, &cb_data); 410 } 411 } 412 } 413 else 414 { 415 bta_gattc_cancel_bk_conn(&p_msg->api_cancel_conn); 416 417 } 418 } 419 420 /******************************************************************************* 421 ** 422 ** Function bta_gattc_process_enc_cmpl 423 ** 424 ** Description process encryption complete message. 425 ** 426 ** Returns void 427 ** 428 *******************************************************************************/ 429 void bta_gattc_process_enc_cmpl(tBTA_GATTC_CB *p_cb, tBTA_GATTC_DATA *p_msg) 430 { 431 tBTA_GATTC_RCB *p_clreg; 432 tBTA_GATTC cb_data; 433 UNUSED(p_cb); 434 435 p_clreg = bta_gattc_cl_get_regcb(p_msg->enc_cmpl.client_if); 436 437 if (p_clreg && p_clreg->p_cback) 438 { 439 memset(&cb_data, 0, sizeof(tBTA_GATTC)); 440 441 cb_data.enc_cmpl.client_if = p_msg->enc_cmpl.client_if; 442 bdcpy(cb_data.enc_cmpl.remote_bda, p_msg->enc_cmpl.remote_bda); 443 444 (*p_clreg->p_cback)(BTA_GATTC_ENC_CMPL_CB_EVT, &cb_data); 445 } 446 } 447 448 /******************************************************************************* 449 ** 450 ** Function bta_gattc_cancel_open_error 451 ** 452 ** Description 453 ** 454 ** Returns void 455 ** 456 *******************************************************************************/ 457 void bta_gattc_cancel_open_error(tBTA_GATTC_CLCB *p_clcb, tBTA_GATTC_DATA *p_data) 458 { 459 tBTA_GATTC cb_data; 460 UNUSED(p_data); 461 462 cb_data.status=BTA_GATT_ERROR; 463 464 if ( p_clcb && p_clcb->p_rcb && p_clcb->p_rcb->p_cback ) 465 (*p_clcb->p_rcb->p_cback)(BTA_GATTC_CANCEL_OPEN_EVT, &cb_data); 466 } 467 468 /******************************************************************************* 469 ** 470 ** Function bta_gattc_open_error 471 ** 472 ** Description 473 ** 474 ** Returns void 475 ** 476 *******************************************************************************/ 477 void bta_gattc_open_error(tBTA_GATTC_CLCB *p_clcb, tBTA_GATTC_DATA *p_data) 478 { 479 UNUSED(p_data); 480 481 APPL_TRACE_ERROR("Connection already opened. wrong state"); 482 483 bta_gattc_send_open_cback(p_clcb->p_rcb, 484 BTA_GATT_OK, 485 p_clcb->bda, 486 p_clcb->bta_conn_id, 487 p_clcb->transport, 488 0); 489 } 490 /******************************************************************************* 491 ** 492 ** Function bta_gattc_open_fail 493 ** 494 ** Description 495 ** 496 ** Returns void 497 ** 498 *******************************************************************************/ 499 void bta_gattc_open_fail(tBTA_GATTC_CLCB *p_clcb, tBTA_GATTC_DATA *p_data) 500 { 501 UNUSED(p_data); 502 503 bta_gattc_send_open_cback(p_clcb->p_rcb, 504 BTA_GATT_ERROR, 505 p_clcb->bda, 506 p_clcb->bta_conn_id, 507 p_clcb->transport, 508 0); 509 /* open failure, remove clcb */ 510 bta_gattc_clcb_dealloc(p_clcb); 511 } 512 513 /******************************************************************************* 514 ** 515 ** Function bta_gattc_open 516 ** 517 ** Description Process API connection function. 518 ** 519 ** Returns void 520 ** 521 *******************************************************************************/ 522 void bta_gattc_open(tBTA_GATTC_CLCB *p_clcb, tBTA_GATTC_DATA *p_data) 523 { 524 tBTA_GATTC_DATA gattc_data; 525 526 /* open/hold a connection */ 527 if (!GATT_Connect(p_clcb->p_rcb->client_if, p_data->api_conn.remote_bda, 528 TRUE, p_data->api_conn.transport)) 529 { 530 APPL_TRACE_ERROR("Connection open failure"); 531 532 bta_gattc_sm_execute(p_clcb, BTA_GATTC_INT_OPEN_FAIL_EVT, p_data); 533 } 534 else 535 { 536 /* a connected remote device */ 537 if (GATT_GetConnIdIfConnected(p_clcb->p_rcb->client_if, 538 p_data->api_conn.remote_bda, 539 &p_clcb->bta_conn_id, 540 p_data->api_conn.transport)) 541 { 542 gattc_data.int_conn.hdr.layer_specific = p_clcb->bta_conn_id; 543 544 bta_gattc_sm_execute(p_clcb, BTA_GATTC_INT_CONN_EVT, &gattc_data); 545 } 546 /* else wait for the callback event */ 547 } 548 } 549 /******************************************************************************* 550 ** 551 ** Function bta_gattc_init_bk_conn 552 ** 553 ** Description Process API Open for a background connection 554 ** 555 ** Returns void 556 ** 557 *******************************************************************************/ 558 void bta_gattc_init_bk_conn(tBTA_GATTC_API_OPEN *p_data, tBTA_GATTC_RCB *p_clreg) 559 { 560 tBTA_GATT_STATUS status = BTA_GATT_NO_RESOURCES; 561 UINT16 conn_id; 562 tBTA_GATTC_CLCB *p_clcb; 563 tBTA_GATTC_DATA gattc_data; 564 565 if (bta_gattc_mark_bg_conn(p_data->client_if, p_data->remote_bda, TRUE, FALSE)) 566 { 567 /* always call open to hold a connection */ 568 if (!GATT_Connect(p_data->client_if, p_data->remote_bda, FALSE, p_data->transport)) 569 { 570 uint8_t *bda = (uint8_t *)p_data->remote_bda; 571 status = BTA_GATT_ERROR; 572 APPL_TRACE_ERROR("%s unable to connect to remote bd_addr:%02x:%02x:%02x:%02x:%02x:%02x", 573 __func__, bda[0], bda[1], bda[2], bda[3], bda[4], bda[5]); 574 575 } 576 else 577 { 578 status = BTA_GATT_OK; 579 580 /* if is a connected remote device */ 581 if (GATT_GetConnIdIfConnected(p_data->client_if, 582 p_data->remote_bda, 583 &conn_id, 584 p_data->transport)) 585 { 586 if ((p_clcb = bta_gattc_find_alloc_clcb(p_data->client_if, p_data->remote_bda, 587 BTA_GATT_TRANSPORT_LE)) != NULL) 588 { 589 gattc_data.hdr.layer_specific = p_clcb->bta_conn_id = conn_id; 590 591 /* open connection */ 592 bta_gattc_sm_execute(p_clcb, BTA_GATTC_INT_CONN_EVT, &gattc_data); 593 status = BTA_GATT_OK; 594 } 595 } 596 } 597 } 598 599 /* open failure, report OPEN_EVT */ 600 if (status != BTA_GATT_OK) 601 { 602 bta_gattc_send_open_cback(p_clreg, status, p_data->remote_bda, 603 BTA_GATT_INVALID_CONN_ID, BTA_GATT_TRANSPORT_LE, 0); 604 } 605 } 606 /******************************************************************************* 607 ** 608 ** Function bta_gattc_cancel_bk_conn 609 ** 610 ** Description Process API Cancel Open for a background connection 611 ** 612 ** Returns void 613 ** 614 *******************************************************************************/ 615 void bta_gattc_cancel_bk_conn(tBTA_GATTC_API_CANCEL_OPEN *p_data) 616 { 617 tBTA_GATTC_RCB *p_clreg; 618 tBTA_GATTC cb_data; 619 cb_data.status = BTA_GATT_ERROR; 620 621 /* remove the device from the bg connection mask */ 622 if (bta_gattc_mark_bg_conn(p_data->client_if, p_data->remote_bda, FALSE, FALSE)) 623 { 624 if (GATT_CancelConnect(p_data->client_if, p_data->remote_bda, FALSE)) 625 { 626 cb_data.status = BTA_GATT_OK; 627 } 628 else 629 { 630 APPL_TRACE_ERROR("bta_gattc_cancel_bk_conn failed"); 631 } 632 } 633 p_clreg = bta_gattc_cl_get_regcb(p_data->client_if); 634 635 if (p_clreg && p_clreg->p_cback) 636 { 637 (*p_clreg->p_cback)(BTA_GATTC_CANCEL_OPEN_EVT, &cb_data); 638 } 639 640 } 641 /******************************************************************************* 642 ** 643 ** Function bta_gattc_int_cancel_open_ok 644 ** 645 ** Description 646 ** 647 ** Returns void 648 ** 649 *******************************************************************************/ 650 void bta_gattc_cancel_open_ok(tBTA_GATTC_CLCB *p_clcb, tBTA_GATTC_DATA *p_data) 651 { 652 tBTA_GATTC cb_data; 653 UNUSED(p_data); 654 655 if ( p_clcb->p_rcb->p_cback ) 656 { 657 cb_data.status = BTA_GATT_OK; 658 (*p_clcb->p_rcb->p_cback)(BTA_GATTC_CANCEL_OPEN_EVT, &cb_data); 659 } 660 661 bta_gattc_clcb_dealloc(p_clcb); 662 } 663 /******************************************************************************* 664 ** 665 ** Function bta_gattc_cancel_open 666 ** 667 ** Description 668 ** 669 ** Returns void 670 ** 671 *******************************************************************************/ 672 void bta_gattc_cancel_open(tBTA_GATTC_CLCB *p_clcb, tBTA_GATTC_DATA *p_data) 673 { 674 tBTA_GATTC cb_data; 675 676 if (GATT_CancelConnect(p_clcb->p_rcb->client_if, p_data->api_cancel_conn.remote_bda, TRUE)) 677 { 678 bta_gattc_sm_execute(p_clcb, BTA_GATTC_INT_CANCEL_OPEN_OK_EVT, p_data); 679 } 680 else 681 { 682 if ( p_clcb->p_rcb->p_cback ) 683 { 684 cb_data.status = BTA_GATT_ERROR; 685 (*p_clcb->p_rcb->p_cback)(BTA_GATTC_CANCEL_OPEN_EVT, &cb_data); 686 } 687 } 688 } 689 /******************************************************************************* 690 ** 691 ** Function bta_gattc_conn 692 ** 693 ** Description receive connection callback from stack 694 ** 695 ** Returns void 696 ** 697 *******************************************************************************/ 698 void bta_gattc_conn(tBTA_GATTC_CLCB *p_clcb, tBTA_GATTC_DATA *p_data) 699 { 700 tBTA_GATTC_IF gatt_if; 701 APPL_TRACE_DEBUG("bta_gattc_conn server cache state=%d",p_clcb->p_srcb->state); 702 703 if (p_data != NULL) 704 { 705 APPL_TRACE_DEBUG("bta_gattc_conn conn_id=%d",p_data->hdr.layer_specific); 706 p_clcb->bta_conn_id = p_data->int_conn.hdr.layer_specific; 707 708 GATT_GetConnectionInfor(p_data->hdr.layer_specific, 709 &gatt_if, p_clcb->bda, &p_clcb->transport); 710 } 711 712 p_clcb->p_srcb->connected = TRUE; 713 714 if (p_clcb->p_srcb->mtu == 0) 715 p_clcb->p_srcb->mtu = GATT_DEF_BLE_MTU_SIZE; 716 717 /* start database cache if needed */ 718 if (p_clcb->p_srcb->p_srvc_cache == NULL || 719 p_clcb->p_srcb->state != BTA_GATTC_SERV_IDLE) 720 { 721 if (p_clcb->p_srcb->state == BTA_GATTC_SERV_IDLE) 722 { 723 p_clcb->p_srcb->state = BTA_GATTC_SERV_LOAD; 724 bta_gattc_sm_execute(p_clcb, BTA_GATTC_START_CACHE_EVT, NULL); 725 } 726 else /* cache is building */ 727 p_clcb->state = BTA_GATTC_DISCOVER_ST; 728 } 729 730 else 731 { 732 /* a pending service handle change indication */ 733 if (p_clcb->p_srcb->srvc_hdl_chg) 734 { 735 p_clcb->p_srcb->srvc_hdl_chg = FALSE; 736 /* start discovery */ 737 bta_gattc_sm_execute(p_clcb, BTA_GATTC_INT_DISCOVER_EVT, NULL); 738 } 739 } 740 741 if (p_clcb->p_rcb) 742 { 743 /* there is no RM for GATT */ 744 if (p_clcb->transport == BTA_TRANSPORT_BR_EDR) 745 bta_sys_conn_open(BTA_ID_GATTC, BTA_ALL_APP_ID, p_clcb->bda); 746 747 bta_gattc_send_open_cback(p_clcb->p_rcb, 748 BTA_GATT_OK, 749 p_clcb->bda, 750 p_clcb->bta_conn_id, 751 p_clcb->transport, 752 p_clcb->p_srcb->mtu); 753 } 754 } 755 /******************************************************************************* 756 ** 757 ** Function bta_gattc_close_fail 758 ** 759 ** Description close a connection. 760 ** 761 ** Returns void 762 ** 763 *******************************************************************************/ 764 void bta_gattc_close_fail(tBTA_GATTC_CLCB *p_clcb, tBTA_GATTC_DATA *p_data) 765 { 766 tBTA_GATTC cb_data; 767 768 if ( p_clcb->p_rcb->p_cback ) 769 { 770 memset(&cb_data, 0, sizeof(tBTA_GATTC)); 771 cb_data.close.client_if = p_clcb->p_rcb->client_if; 772 cb_data.close.conn_id = p_data->hdr.layer_specific; 773 bdcpy(cb_data.close.remote_bda, p_clcb->bda); 774 cb_data.close.status = BTA_GATT_ERROR; 775 cb_data.close.reason = BTA_GATT_CONN_NONE; 776 777 778 (*p_clcb->p_rcb->p_cback)(BTA_GATTC_CLOSE_EVT, &cb_data); 779 } 780 } 781 /******************************************************************************* 782 ** 783 ** Function bta_gattc_api_close 784 ** 785 ** Description close a GATTC connection. 786 ** 787 ** Returns void 788 ** 789 *******************************************************************************/ 790 void bta_gattc_close(tBTA_GATTC_CLCB *p_clcb, tBTA_GATTC_DATA *p_data) 791 { 792 tBTA_GATTC_CBACK *p_cback = p_clcb->p_rcb->p_cback; 793 tBTA_GATTC_RCB *p_clreg = p_clcb->p_rcb; 794 tBTA_GATTC cb_data; 795 796 APPL_TRACE_DEBUG("bta_gattc_close conn_id=%d",p_clcb->bta_conn_id); 797 798 cb_data.close.client_if = p_clcb->p_rcb->client_if; 799 cb_data.close.conn_id = p_clcb->bta_conn_id; 800 cb_data.close.reason = p_clcb->reason; 801 cb_data.close.status = p_clcb->status; 802 bdcpy(cb_data.close.remote_bda, p_clcb->bda); 803 804 if (p_clcb->transport == BTA_TRANSPORT_BR_EDR) 805 bta_sys_conn_close( BTA_ID_GATTC ,BTA_ALL_APP_ID, p_clcb->bda); 806 807 bta_gattc_clcb_dealloc(p_clcb); 808 809 if (p_data->hdr.event == BTA_GATTC_API_CLOSE_EVT) 810 { 811 cb_data.close.status = GATT_Disconnect(p_data->hdr.layer_specific); 812 } 813 else if (p_data->hdr.event == BTA_GATTC_INT_DISCONN_EVT) 814 { 815 cb_data.close.status = p_data->int_conn.reason; 816 cb_data.close.reason = p_data->int_conn.reason; 817 } 818 819 if(p_cback) 820 (* p_cback)(BTA_GATTC_CLOSE_EVT, (tBTA_GATTC *)&cb_data); 821 822 if (p_clreg->num_clcb == 0 && p_clreg->dereg_pending) 823 { 824 bta_gattc_deregister_cmpl(p_clreg); 825 } 826 } 827 /******************************************************************************* 828 ** 829 ** Function bta_gattc_reset_discover_st 830 ** 831 ** Description when a SRCB finished discovery, tell all related clcb. 832 ** 833 ** Returns None. 834 ** 835 *******************************************************************************/ 836 void bta_gattc_reset_discover_st(tBTA_GATTC_SERV *p_srcb, tBTA_GATT_STATUS status) 837 { 838 tBTA_GATTC_CB *p_cb = &bta_gattc_cb; 839 UINT8 i; 840 841 for (i = 0; i < BTA_GATTC_CLCB_MAX; i ++) 842 { 843 if (p_cb->clcb[i].p_srcb == p_srcb) 844 { 845 p_cb->clcb[i].status = status; 846 bta_gattc_sm_execute(&p_cb->clcb[i], BTA_GATTC_DISCOVER_CMPL_EVT, NULL); 847 } 848 } 849 } 850 /******************************************************************************* 851 ** 852 ** Function bta_gattc_disc_close 853 ** 854 ** Description close a GATTC connection while in discovery state. 855 ** 856 ** Returns void 857 ** 858 *******************************************************************************/ 859 void bta_gattc_disc_close(tBTA_GATTC_CLCB *p_clcb, tBTA_GATTC_DATA *p_data) 860 { 861 APPL_TRACE_DEBUG("%s: Discovery cancel conn_id=%d", __func__, 862 p_clcb->bta_conn_id); 863 864 if (p_clcb->disc_active) 865 bta_gattc_reset_discover_st(p_clcb->p_srcb, BTA_GATT_ERROR); 866 else 867 p_clcb->state = BTA_GATTC_CONN_ST; 868 869 // This function only gets called as the result of a BTA_GATTC_API_CLOSE_EVT 870 // while in the BTA_GATTC_DISCOVER_ST state. Once the state changes, the 871 // connection itself still needs to be closed to resolve the original event. 872 if (p_clcb->state == BTA_GATTC_CONN_ST) 873 { 874 APPL_TRACE_DEBUG("State is back to BTA_GATTC_CONN_ST. " 875 "Trigger connection close"); 876 bta_gattc_close(p_clcb, p_data); 877 } 878 } 879 /******************************************************************************* 880 ** 881 ** Function bta_gattc_set_discover_st 882 ** 883 ** Description when a SRCB start discovery, tell all related clcb and set 884 ** the state. 885 ** 886 ** Returns None. 887 ** 888 *******************************************************************************/ 889 void bta_gattc_set_discover_st(tBTA_GATTC_SERV *p_srcb) 890 { 891 tBTA_GATTC_CB *p_cb = &bta_gattc_cb; 892 UINT8 i; 893 894 #if BLE_INCLUDED == TRUE 895 L2CA_EnableUpdateBleConnParams(p_srcb->server_bda, FALSE); 896 #endif 897 for (i = 0; i < BTA_GATTC_CLCB_MAX; i ++) 898 { 899 if (p_cb->clcb[i].p_srcb == p_srcb) 900 { 901 p_cb->clcb[i].status = BTA_GATT_OK; 902 p_cb->clcb[i].state = BTA_GATTC_DISCOVER_ST; 903 } 904 } 905 } 906 /******************************************************************************* 907 ** 908 ** Function bta_gattc_restart_discover 909 ** 910 ** Description process service change in discovery state, mark up the auto 911 ** update flag and set status to be discovery cancel for current 912 ** discovery. 913 ** 914 ** Returns None. 915 ** 916 *******************************************************************************/ 917 void bta_gattc_restart_discover(tBTA_GATTC_CLCB *p_clcb, tBTA_GATTC_DATA *p_data) 918 { 919 UNUSED(p_data); 920 921 p_clcb->status = BTA_GATT_CANCEL; 922 p_clcb->auto_update = BTA_GATTC_DISC_WAITING; 923 } 924 925 /******************************************************************************* 926 ** 927 ** Function bta_gattc_cfg_mtu 928 ** 929 ** Description Configure MTU size on the GATT connection. 930 ** 931 ** Returns None. 932 ** 933 *******************************************************************************/ 934 void bta_gattc_cfg_mtu(tBTA_GATTC_CLCB *p_clcb, tBTA_GATTC_DATA *p_data) 935 { 936 tBTA_GATTC_OP_CMPL op_cmpl; 937 tBTA_GATT_STATUS status; 938 939 if (bta_gattc_enqueue(p_clcb, p_data)) 940 { 941 status = GATTC_ConfigureMTU (p_clcb->bta_conn_id, p_data->api_mtu.mtu); 942 943 /* if failed, return callback here */ 944 if (status != GATT_SUCCESS && status != GATT_CMD_STARTED) 945 { 946 memset(&op_cmpl, 0, sizeof(tBTA_GATTC_OP_CMPL)); 947 948 op_cmpl.status = status; 949 op_cmpl.op_code = GATTC_OPTYPE_CONFIG; 950 op_cmpl.p_cmpl = NULL; 951 952 bta_gattc_sm_execute(p_clcb, BTA_GATTC_OP_CMPL_EVT, (tBTA_GATTC_DATA *)&op_cmpl); 953 } 954 } 955 } 956 /******************************************************************************* 957 ** 958 ** Function bta_gattc_start_discover 959 ** 960 ** Description Start a discovery on server. 961 ** 962 ** Returns None. 963 ** 964 *******************************************************************************/ 965 void bta_gattc_start_discover(tBTA_GATTC_CLCB *p_clcb, tBTA_GATTC_DATA *p_data) 966 { 967 UNUSED(p_data); 968 969 APPL_TRACE_DEBUG("bta_gattc_start_discover conn_id=%d p_clcb->p_srcb->state = %d ", 970 p_clcb->bta_conn_id, p_clcb->p_srcb->state); 971 972 if (((p_clcb->p_q_cmd == NULL || p_clcb->auto_update == BTA_GATTC_REQ_WAITING) && 973 p_clcb->p_srcb->state == BTA_GATTC_SERV_IDLE) || 974 p_clcb->p_srcb->state == BTA_GATTC_SERV_DISC) 975 /* no pending operation, start discovery right away */ 976 { 977 p_clcb->auto_update = BTA_GATTC_NO_SCHEDULE; 978 979 if (p_clcb->p_srcb != NULL) 980 { 981 /* clear the service change mask */ 982 p_clcb->p_srcb->srvc_hdl_chg = FALSE; 983 p_clcb->p_srcb->update_count = 0; 984 p_clcb->p_srcb->state = BTA_GATTC_SERV_DISC_ACT; 985 986 if (p_clcb->transport == BTA_TRANSPORT_LE) 987 L2CA_EnableUpdateBleConnParams(p_clcb->p_srcb->server_bda, FALSE); 988 989 /* set all srcb related clcb into discovery ST */ 990 bta_gattc_set_discover_st(p_clcb->p_srcb); 991 992 if ((p_clcb->status = bta_gattc_init_cache(p_clcb->p_srcb)) == BTA_GATT_OK) 993 { 994 p_clcb->status = bta_gattc_discover_pri_service(p_clcb->bta_conn_id, 995 p_clcb->p_srcb, GATT_DISC_SRVC_ALL); 996 } 997 if (p_clcb->status != BTA_GATT_OK) 998 { 999 APPL_TRACE_ERROR("discovery on server failed"); 1000 bta_gattc_reset_discover_st(p_clcb->p_srcb, p_clcb->status); 1001 } 1002 else 1003 p_clcb->disc_active = TRUE; 1004 } 1005 else 1006 { 1007 APPL_TRACE_ERROR("unknown device, can not start discovery"); 1008 } 1009 } 1010 /* pending operation, wait until it finishes */ 1011 else 1012 { 1013 p_clcb->auto_update = BTA_GATTC_DISC_WAITING; 1014 1015 if (p_clcb->p_srcb->state == BTA_GATTC_SERV_IDLE) 1016 p_clcb->state = BTA_GATTC_CONN_ST; /* set clcb state */ 1017 } 1018 1019 } 1020 /******************************************************************************* 1021 ** 1022 ** Function bta_gattc_disc_cmpl 1023 ** 1024 ** Description discovery on server is finished 1025 ** 1026 ** Returns None. 1027 ** 1028 *******************************************************************************/ 1029 void bta_gattc_disc_cmpl(tBTA_GATTC_CLCB *p_clcb, tBTA_GATTC_DATA *p_data) 1030 { 1031 tBTA_GATTC_DATA *p_q_cmd = p_clcb->p_q_cmd; 1032 UNUSED(p_data); 1033 1034 APPL_TRACE_DEBUG("bta_gattc_disc_cmpl conn_id=%d",p_clcb->bta_conn_id); 1035 1036 #if BLE_INCLUDED == TRUE 1037 if(p_clcb->transport == BTA_TRANSPORT_LE) 1038 L2CA_EnableUpdateBleConnParams(p_clcb->p_srcb->server_bda, TRUE); 1039 #endif 1040 p_clcb->p_srcb->state = BTA_GATTC_SERV_IDLE; 1041 p_clcb->disc_active = FALSE; 1042 1043 if (p_clcb->status != GATT_SUCCESS) 1044 { 1045 /* clean up cache */ 1046 if(p_clcb->p_srcb && p_clcb->p_srcb->p_srvc_cache) 1047 { 1048 while (!GKI_queue_is_empty(&p_clcb->p_srcb->cache_buffer)) 1049 { 1050 GKI_freebuf (GKI_dequeue (&p_clcb->p_srcb->cache_buffer)); 1051 } 1052 p_clcb->p_srcb->p_srvc_cache = NULL; 1053 } 1054 1055 /* used to reset cache in application */ 1056 bta_gattc_co_cache_reset(p_clcb->p_srcb->server_bda); 1057 } 1058 /* release pending attribute list buffer */ 1059 utl_freebuf((void **)&p_clcb->p_srcb->p_srvc_list); 1060 1061 if (p_clcb->auto_update == BTA_GATTC_DISC_WAITING) 1062 { 1063 /* start discovery again */ 1064 bta_gattc_sm_execute(p_clcb, BTA_GATTC_INT_DISCOVER_EVT, NULL); 1065 } 1066 /* get any queued command to proceed */ 1067 else if (p_q_cmd != NULL) 1068 { 1069 p_clcb->p_q_cmd = NULL; 1070 1071 bta_gattc_sm_execute(p_clcb, p_q_cmd->hdr.event, p_q_cmd); 1072 /* if the command executed requeued the cmd, we don't 1073 * want to free the underlying buffer that's being 1074 * referenced by p_clcb->p_q_cmd 1075 */ 1076 if (p_q_cmd != p_clcb->p_q_cmd) { 1077 utl_freebuf((void **)&p_q_cmd); 1078 } 1079 } 1080 } 1081 /******************************************************************************* 1082 ** 1083 ** Function bta_gattc_read 1084 ** 1085 ** Description Read an attribute 1086 ** 1087 ** Returns None. 1088 ** 1089 *******************************************************************************/ 1090 void bta_gattc_read(tBTA_GATTC_CLCB *p_clcb, tBTA_GATTC_DATA *p_data) 1091 { 1092 UINT16 handle = 0; 1093 tGATT_READ_PARAM read_param; 1094 tBTA_GATTC_OP_CMPL op_cmpl; 1095 1096 memset (&read_param, 0 ,sizeof(tGATT_READ_PARAM)); 1097 memset (&op_cmpl, 0 ,sizeof(tBTA_GATTC_OP_CMPL)); 1098 1099 if (bta_gattc_enqueue(p_clcb, p_data)) 1100 { 1101 if ((handle = bta_gattc_id2handle(p_clcb->p_srcb, 1102 &p_data->api_read.srvc_id, 1103 &p_data->api_read.char_id, 1104 p_data->api_read.p_descr_type)) == 0) 1105 { 1106 op_cmpl.status = BTA_GATT_ERROR; 1107 } 1108 else 1109 { 1110 read_param.by_handle.handle = handle; 1111 read_param.by_handle.auth_req = p_data->api_read.auth_req; 1112 1113 op_cmpl.status = GATTC_Read(p_clcb->bta_conn_id, GATT_READ_BY_HANDLE, &read_param); 1114 } 1115 1116 /* read fail */ 1117 if (op_cmpl.status != BTA_GATT_OK) 1118 { 1119 op_cmpl.op_code = GATTC_OPTYPE_READ; 1120 op_cmpl.p_cmpl = NULL; 1121 1122 bta_gattc_sm_execute(p_clcb, BTA_GATTC_OP_CMPL_EVT, (tBTA_GATTC_DATA *)&op_cmpl); 1123 } 1124 } 1125 } 1126 /******************************************************************************* 1127 ** 1128 ** Function bta_gattc_read_multi 1129 ** 1130 ** Description read multiple 1131 ** 1132 ** Returns None. 1133 *********************************************************************************/ 1134 void bta_gattc_read_multi(tBTA_GATTC_CLCB *p_clcb, tBTA_GATTC_DATA *p_data) 1135 { 1136 UINT16 i, handle; 1137 tBTA_GATT_STATUS status = BTA_GATT_OK; 1138 tGATT_READ_PARAM read_param; 1139 tBTA_GATTC_OP_CMPL op_cmpl; 1140 tBTA_GATTC_ATTR_ID *p_id; 1141 1142 if (bta_gattc_enqueue(p_clcb, p_data)) 1143 { 1144 memset(&read_param, 0, sizeof(tGATT_READ_PARAM)); 1145 1146 p_id = p_data->api_read_multi.p_id_list; 1147 1148 for (i = 0; i < p_data->api_read_multi.num_attr && p_id; i ++, p_id ++) 1149 { 1150 handle = 0; 1151 1152 if (p_id->id_type == BTA_GATT_TYPE_CHAR) 1153 { 1154 handle = bta_gattc_id2handle(p_clcb->p_srcb, 1155 &p_id->id_value.char_id.srvc_id, 1156 &p_id->id_value.char_id.char_id, 1157 NULL); 1158 } 1159 else if (p_id->id_type == BTA_GATT_TYPE_CHAR_DESCR) 1160 { 1161 handle = bta_gattc_id2handle(p_clcb->p_srcb, 1162 &p_id->id_value.char_descr_id.char_id.srvc_id, 1163 &p_id->id_value.char_descr_id.char_id.char_id, 1164 &p_id->id_value.char_descr_id.descr_id); 1165 } 1166 else 1167 { 1168 APPL_TRACE_ERROR("invalud ID type: %d", p_id->id_type); 1169 } 1170 1171 if (handle == 0) 1172 { 1173 status = BTA_GATT_ERROR; 1174 break; 1175 } 1176 } 1177 if (status == BTA_GATT_OK) 1178 { 1179 read_param.read_multiple.num_handles = p_data->api_read_multi.num_attr; 1180 read_param.read_multiple.auth_req = p_data->api_read_multi.auth_req; 1181 1182 status = GATTC_Read(p_clcb->bta_conn_id, GATT_READ_MULTIPLE, &read_param); 1183 } 1184 1185 /* read fail */ 1186 if (status != BTA_GATT_OK) 1187 { 1188 memset(&op_cmpl, 0, sizeof(tBTA_GATTC_OP_CMPL)); 1189 1190 op_cmpl.status = status; 1191 op_cmpl.op_code = GATTC_OPTYPE_READ; 1192 op_cmpl.p_cmpl = NULL; 1193 1194 bta_gattc_sm_execute(p_clcb, BTA_GATTC_OP_CMPL_EVT, (tBTA_GATTC_DATA *)&op_cmpl); 1195 } 1196 } 1197 } 1198 /******************************************************************************* 1199 ** 1200 ** Function bta_gattc_write 1201 ** 1202 ** Description Write an attribute 1203 ** 1204 ** Returns None. 1205 ** 1206 *******************************************************************************/ 1207 void bta_gattc_write(tBTA_GATTC_CLCB *p_clcb, tBTA_GATTC_DATA *p_data) 1208 { 1209 UINT16 handle = 0; 1210 tGATT_VALUE attr = {0}; 1211 tBTA_GATTC_OP_CMPL op_cmpl; 1212 tBTA_GATT_STATUS status = BTA_GATT_OK; 1213 1214 if (bta_gattc_enqueue(p_clcb, p_data)) 1215 { 1216 if ((handle = bta_gattc_id2handle(p_clcb->p_srcb, 1217 &p_data->api_write.srvc_id, 1218 &p_data->api_write.char_id, 1219 p_data->api_write.p_descr_type)) == 0) 1220 { 1221 status = BTA_GATT_ERROR; 1222 } 1223 else 1224 { 1225 attr.handle= handle; 1226 attr.offset = p_data->api_write.offset; 1227 attr.len = p_data->api_write.len; 1228 attr.auth_req = p_data->api_write.auth_req; 1229 1230 if (p_data->api_write.p_value) 1231 memcpy(attr.value, p_data->api_write.p_value, p_data->api_write.len); 1232 1233 status = GATTC_Write(p_clcb->bta_conn_id, p_data->api_write.write_type, &attr); 1234 } 1235 1236 /* write fail */ 1237 if (status != BTA_GATT_OK) 1238 { 1239 memset(&op_cmpl, 0, sizeof(tBTA_GATTC_OP_CMPL)); 1240 1241 op_cmpl.status = status; 1242 op_cmpl.op_code = GATTC_OPTYPE_WRITE; 1243 op_cmpl.p_cmpl = NULL; 1244 1245 bta_gattc_sm_execute(p_clcb, BTA_GATTC_OP_CMPL_EVT, (tBTA_GATTC_DATA *)&op_cmpl); 1246 } 1247 } 1248 } 1249 /******************************************************************************* 1250 ** 1251 ** Function bta_gattc_execute 1252 ** 1253 ** Description send execute write 1254 ** 1255 ** Returns None. 1256 *********************************************************************************/ 1257 void bta_gattc_execute(tBTA_GATTC_CLCB *p_clcb, tBTA_GATTC_DATA *p_data) 1258 { 1259 tBTA_GATTC_OP_CMPL op_cmpl; 1260 tBTA_GATT_STATUS status; 1261 1262 if (bta_gattc_enqueue(p_clcb, p_data)) 1263 { 1264 status = GATTC_ExecuteWrite(p_clcb->bta_conn_id, p_data->api_exec.is_execute); 1265 1266 if (status != BTA_GATT_OK) 1267 { 1268 memset(&op_cmpl, 0, sizeof(tBTA_GATTC_OP_CMPL)); 1269 1270 op_cmpl.status = status; 1271 op_cmpl.op_code = GATTC_OPTYPE_EXE_WRITE; 1272 op_cmpl.p_cmpl = NULL; 1273 1274 bta_gattc_sm_execute(p_clcb, BTA_GATTC_OP_CMPL_EVT, (tBTA_GATTC_DATA *)&op_cmpl); 1275 } 1276 } 1277 } 1278 /******************************************************************************* 1279 ** 1280 ** Function bta_gattc_confirm 1281 ** 1282 ** Description send handle value confirmation 1283 ** 1284 ** Returns None. 1285 ** 1286 *******************************************************************************/ 1287 void bta_gattc_confirm(tBTA_GATTC_CLCB *p_clcb, tBTA_GATTC_DATA *p_data) 1288 { 1289 UINT16 handle; 1290 1291 if ((handle = bta_gattc_id2handle(p_clcb->p_srcb, 1292 &p_data->api_confirm.srvc_id, 1293 &p_data->api_confirm.char_id, 1294 NULL)) == 0) 1295 { 1296 APPL_TRACE_ERROR("Can not map service/char ID into valid handle"); 1297 } 1298 else 1299 { 1300 if (GATTC_SendHandleValueConfirm(p_data->api_confirm.hdr.layer_specific, handle) 1301 != GATT_SUCCESS) 1302 { 1303 APPL_TRACE_ERROR("bta_gattc_confirm to handle [0x%04x] failed", handle); 1304 } 1305 else 1306 { 1307 /* if over BR_EDR, inform PM for mode change */ 1308 if (p_clcb->transport == BTA_TRANSPORT_BR_EDR) 1309 { 1310 bta_sys_busy(BTA_ID_GATTC, BTA_ALL_APP_ID, p_clcb->bda); 1311 bta_sys_idle(BTA_ID_GATTC, BTA_ALL_APP_ID, p_clcb->bda); 1312 } 1313 } 1314 } 1315 } 1316 /******************************************************************************* 1317 ** 1318 ** Function bta_gattc_read_cmpl 1319 ** 1320 ** Description read complete 1321 ** 1322 ** Returns None. 1323 ** 1324 *******************************************************************************/ 1325 void bta_gattc_read_cmpl(tBTA_GATTC_CLCB *p_clcb, tBTA_GATTC_OP_CMPL *p_data) 1326 { 1327 UINT8 event; 1328 tBTA_GATTC cb_data; 1329 tBTA_GATT_READ_VAL read_value; 1330 1331 memset(&cb_data, 0, sizeof(tBTA_GATTC)); 1332 memset(&read_value, 0, sizeof(tBTA_GATT_READ_VAL)); 1333 1334 cb_data.read.status = p_data->status; 1335 1336 if (p_data->p_cmpl != NULL && p_data->status == BTA_GATT_OK) 1337 { 1338 if (bta_gattc_handle2id(p_clcb->p_srcb, 1339 p_data->p_cmpl->att_value.handle, 1340 &cb_data.read.srvc_id, 1341 &cb_data.read.char_id, 1342 &cb_data.read.descr_type) == FALSE) 1343 { 1344 cb_data.read.status = BTA_GATT_INTERNAL_ERROR; 1345 APPL_TRACE_ERROR("can not map to GATT ID. handle = 0x%04x", 1346 p_data->p_cmpl->att_value.handle); 1347 } 1348 else 1349 { 1350 cb_data.read.status = bta_gattc_pack_read_cb_data(p_clcb->p_srcb, 1351 &cb_data.read.descr_type.uuid, 1352 &p_data->p_cmpl->att_value, 1353 &read_value); 1354 cb_data.read.p_value = &read_value; 1355 } 1356 } 1357 else 1358 { 1359 cb_data.read.srvc_id = p_clcb->p_q_cmd->api_read.srvc_id; 1360 cb_data.read.char_id = p_clcb->p_q_cmd->api_read.char_id; 1361 if (p_clcb->p_q_cmd->api_read.p_descr_type) 1362 memcpy(&cb_data.read.descr_type, p_clcb->p_q_cmd->api_read.p_descr_type, 1363 sizeof(tBTA_GATT_ID)); 1364 } 1365 1366 event = (p_clcb->p_q_cmd->api_read.p_descr_type == NULL) ? 1367 BTA_GATTC_READ_CHAR_EVT: BTA_GATTC_READ_DESCR_EVT; 1368 cb_data.read.conn_id = p_clcb->bta_conn_id; 1369 1370 utl_freebuf((void **)&p_clcb->p_q_cmd); 1371 /* read complete, callback */ 1372 ( *p_clcb->p_rcb->p_cback)(event, (tBTA_GATTC *)&cb_data); 1373 1374 } 1375 /******************************************************************************* 1376 ** 1377 ** Function bta_gattc_write_cmpl 1378 ** 1379 ** Description write complete 1380 ** 1381 ** Returns None. 1382 ** 1383 *******************************************************************************/ 1384 void bta_gattc_write_cmpl(tBTA_GATTC_CLCB *p_clcb, tBTA_GATTC_OP_CMPL *p_data) 1385 { 1386 tBTA_GATTC cb_data = {0}; 1387 UINT8 event; 1388 1389 memset(&cb_data, 0, sizeof(tBTA_GATTC)); 1390 1391 cb_data.write.status = p_data->status; 1392 1393 if (p_data->p_cmpl != NULL) 1394 { 1395 bta_gattc_handle2id(p_clcb->p_srcb, p_data->p_cmpl->att_value.handle, 1396 &cb_data.write.srvc_id, &cb_data.write.char_id, 1397 &cb_data.write.descr_type); 1398 } 1399 else 1400 { 1401 memcpy(&cb_data.write.srvc_id, &p_clcb->p_q_cmd->api_write.srvc_id, 1402 sizeof(tBTA_GATT_SRVC_ID)); 1403 memcpy(&cb_data.write.char_id, &p_clcb->p_q_cmd->api_write.char_id, 1404 sizeof(tBTA_GATT_ID)); 1405 if (p_clcb->p_q_cmd->api_write.p_descr_type) 1406 memcpy(&cb_data.write.descr_type, p_clcb->p_q_cmd->api_write.p_descr_type, 1407 sizeof(tBTA_GATT_ID)); 1408 } 1409 1410 if (p_clcb->p_q_cmd->api_write.hdr.event == BTA_GATTC_API_WRITE_EVT && 1411 p_clcb->p_q_cmd->api_write.write_type == BTA_GATTC_WRITE_PREPARE) 1412 1413 event = BTA_GATTC_PREP_WRITE_EVT; 1414 1415 else if (p_clcb->p_q_cmd->api_write.p_descr_type == NULL) 1416 1417 event = BTA_GATTC_WRITE_CHAR_EVT; 1418 1419 else 1420 event = BTA_GATTC_WRITE_DESCR_EVT; 1421 1422 utl_freebuf((void **)&p_clcb->p_q_cmd); 1423 cb_data.write.conn_id = p_clcb->bta_conn_id; 1424 /* write complete, callback */ 1425 ( *p_clcb->p_rcb->p_cback)(event, (tBTA_GATTC *)&cb_data); 1426 1427 } 1428 /******************************************************************************* 1429 ** 1430 ** Function bta_gattc_exec_cmpl 1431 ** 1432 ** Description execute write complete 1433 ** 1434 ** Returns None. 1435 ** 1436 *******************************************************************************/ 1437 void bta_gattc_exec_cmpl(tBTA_GATTC_CLCB *p_clcb, tBTA_GATTC_OP_CMPL *p_data) 1438 { 1439 tBTA_GATTC cb_data; 1440 1441 utl_freebuf((void **)&p_clcb->p_q_cmd); 1442 1443 p_clcb->status = BTA_GATT_OK; 1444 1445 /* execute complete, callback */ 1446 cb_data.exec_cmpl.conn_id = p_clcb->bta_conn_id; 1447 cb_data.exec_cmpl.status = p_data->status; 1448 1449 ( *p_clcb->p_rcb->p_cback)(BTA_GATTC_EXEC_EVT, &cb_data); 1450 1451 } 1452 1453 /******************************************************************************* 1454 ** 1455 ** Function bta_gattc_cfg_mtu_cmpl 1456 ** 1457 ** Description configure MTU operation complete 1458 ** 1459 ** Returns None. 1460 ** 1461 *******************************************************************************/ 1462 void bta_gattc_cfg_mtu_cmpl(tBTA_GATTC_CLCB *p_clcb, tBTA_GATTC_OP_CMPL *p_data) 1463 { 1464 tBTA_GATTC cb_data; 1465 1466 utl_freebuf((void **)&p_clcb->p_q_cmd); 1467 1468 1469 if (p_data->p_cmpl && p_data->status == BTA_GATT_OK) 1470 p_clcb->p_srcb->mtu = p_data->p_cmpl->mtu; 1471 1472 /* configure MTU complete, callback */ 1473 p_clcb->status = p_data->status; 1474 cb_data.cfg_mtu.conn_id = p_clcb->bta_conn_id; 1475 cb_data.cfg_mtu.status = p_data->status; 1476 cb_data.cfg_mtu.mtu = p_clcb->p_srcb->mtu; 1477 1478 (*p_clcb->p_rcb->p_cback) (BTA_GATTC_CFG_MTU_EVT, &cb_data); 1479 1480 } 1481 /******************************************************************************* 1482 ** 1483 ** Function bta_gattc_op_cmpl 1484 ** 1485 ** Description operation completed. 1486 ** 1487 ** Returns None. 1488 ** 1489 *******************************************************************************/ 1490 void bta_gattc_op_cmpl(tBTA_GATTC_CLCB *p_clcb, tBTA_GATTC_DATA *p_data) 1491 { 1492 UINT8 op = (UINT8)p_data->op_cmpl.op_code; 1493 UINT8 mapped_op = 0; 1494 1495 APPL_TRACE_DEBUG("bta_gattc_op_cmpl op = %d", op); 1496 1497 if (op == GATTC_OPTYPE_INDICATION || op == GATTC_OPTYPE_NOTIFICATION) 1498 { 1499 APPL_TRACE_ERROR("unexpected operation, ignored"); 1500 } 1501 else if (op >= GATTC_OPTYPE_READ) 1502 { 1503 if (p_clcb->p_q_cmd == NULL) 1504 { 1505 APPL_TRACE_ERROR("No pending command"); 1506 return; 1507 } 1508 if (p_clcb->p_q_cmd->hdr.event != bta_gattc_opcode_to_int_evt[op - GATTC_OPTYPE_READ]) 1509 { 1510 mapped_op = p_clcb->p_q_cmd->hdr.event - BTA_GATTC_API_READ_EVT + GATTC_OPTYPE_READ; 1511 if ( mapped_op > GATTC_OPTYPE_INDICATION) mapped_op = 0; 1512 1513 #if (BT_TRACE_VERBOSE == TRUE) 1514 APPL_TRACE_ERROR("expect op:(%s :0x%04x), receive unexpected operation (%s).", 1515 bta_gattc_op_code_name[mapped_op] , p_clcb->p_q_cmd->hdr.event, 1516 bta_gattc_op_code_name[op]); 1517 #else 1518 APPL_TRACE_ERROR("expect op:(%u :0x%04x), receive unexpected operation (%u).", 1519 mapped_op , p_clcb->p_q_cmd->hdr.event, op); 1520 #endif 1521 return; 1522 } 1523 1524 /* discard responses if service change indication is received before operation completed */ 1525 if (p_clcb->auto_update == BTA_GATTC_DISC_WAITING && p_clcb->p_srcb->srvc_hdl_chg) 1526 { 1527 APPL_TRACE_DEBUG("Discard all responses when service change indication is received."); 1528 p_data->op_cmpl.status = GATT_ERROR; 1529 } 1530 1531 /* service handle change void the response, discard it */ 1532 if (op == GATTC_OPTYPE_READ) 1533 bta_gattc_read_cmpl(p_clcb, &p_data->op_cmpl); 1534 1535 else if (op == GATTC_OPTYPE_WRITE) 1536 bta_gattc_write_cmpl(p_clcb, &p_data->op_cmpl); 1537 1538 else if (op == GATTC_OPTYPE_EXE_WRITE) 1539 bta_gattc_exec_cmpl(p_clcb, &p_data->op_cmpl); 1540 1541 else if (op == GATTC_OPTYPE_CONFIG) 1542 bta_gattc_cfg_mtu_cmpl(p_clcb, &p_data->op_cmpl); 1543 1544 if (p_clcb->auto_update == BTA_GATTC_DISC_WAITING) 1545 { 1546 p_clcb->auto_update = BTA_GATTC_REQ_WAITING; 1547 bta_gattc_sm_execute(p_clcb, BTA_GATTC_INT_DISCOVER_EVT, NULL); 1548 } 1549 } 1550 } 1551 /******************************************************************************* 1552 ** 1553 ** Function bta_gattc_op_cmpl 1554 ** 1555 ** Description operation completed. 1556 ** 1557 ** Returns None. 1558 ** 1559 *******************************************************************************/ 1560 void bta_gattc_ignore_op_cmpl(tBTA_GATTC_CLCB *p_clcb, tBTA_GATTC_DATA *p_data) 1561 { 1562 UNUSED(p_clcb); 1563 1564 /* receive op complete when discovery is started, ignore the response, 1565 and wait for discovery finish and resent */ 1566 APPL_TRACE_DEBUG("bta_gattc_ignore_op_cmpl op = %d", p_data->hdr.layer_specific); 1567 1568 } 1569 /******************************************************************************* 1570 ** 1571 ** Function bta_gattc_search 1572 ** 1573 ** Description start a search in the local server cache 1574 ** 1575 ** Returns None. 1576 ** 1577 *******************************************************************************/ 1578 void bta_gattc_search(tBTA_GATTC_CLCB *p_clcb, tBTA_GATTC_DATA *p_data) 1579 { 1580 tBTA_GATT_STATUS status = GATT_INTERNAL_ERROR; 1581 tBTA_GATTC cb_data; 1582 APPL_TRACE_DEBUG("bta_gattc_search conn_id=%d",p_clcb->bta_conn_id); 1583 if (p_clcb->p_srcb && p_clcb->p_srcb->p_srvc_cache) 1584 { 1585 status = BTA_GATT_OK; 1586 /* search the local cache of a server device */ 1587 bta_gattc_search_service(p_clcb, p_data->api_search.p_srvc_uuid); 1588 } 1589 cb_data.search_cmpl.status = status; 1590 cb_data.search_cmpl.conn_id = p_clcb->bta_conn_id; 1591 1592 /* end of search or no server cache available */ 1593 ( *p_clcb->p_rcb->p_cback)(BTA_GATTC_SEARCH_CMPL_EVT, &cb_data); 1594 } 1595 /******************************************************************************* 1596 ** 1597 ** Function bta_gattc_q_cmd 1598 ** 1599 ** Description enqueue a command into control block, usually because discovery 1600 ** operation is busy. 1601 ** 1602 ** Returns None. 1603 ** 1604 *******************************************************************************/ 1605 void bta_gattc_q_cmd(tBTA_GATTC_CLCB *p_clcb, tBTA_GATTC_DATA *p_data) 1606 { 1607 bta_gattc_enqueue(p_clcb, p_data); 1608 } 1609 /******************************************************************************* 1610 ** 1611 ** Function bta_gattc_cache_open 1612 ** 1613 ** Description open a NV cache for loading 1614 ** 1615 ** Returns void 1616 ** 1617 *******************************************************************************/ 1618 void bta_gattc_cache_open(tBTA_GATTC_CLCB *p_clcb, tBTA_GATTC_DATA *p_data) 1619 { 1620 UNUSED(p_data); 1621 1622 bta_gattc_set_discover_st(p_clcb->p_srcb); 1623 1624 APPL_TRACE_DEBUG("bta_gattc_cache_open conn_id=%d",p_clcb->bta_conn_id); 1625 bta_gattc_co_cache_open(p_clcb->p_srcb->server_bda, BTA_GATTC_CI_CACHE_OPEN_EVT, 1626 p_clcb->bta_conn_id, FALSE); 1627 } 1628 /******************************************************************************* 1629 ** 1630 ** Function bta_gattc_start_load 1631 ** 1632 ** Description start cache loading by sending callout open cache 1633 ** 1634 ** Returns None. 1635 ** 1636 *******************************************************************************/ 1637 void bta_gattc_ci_open(tBTA_GATTC_CLCB *p_clcb, tBTA_GATTC_DATA *p_data) 1638 { 1639 APPL_TRACE_DEBUG("bta_gattc_ci_open conn_id=%d server state=%d" , 1640 p_clcb->bta_conn_id, p_clcb->p_srcb->state); 1641 if (p_clcb->p_srcb->state == BTA_GATTC_SERV_LOAD) 1642 { 1643 if (p_data->ci_open.status == BTA_GATT_OK) 1644 { 1645 p_clcb->p_srcb->attr_index = 0; 1646 bta_gattc_co_cache_load(p_clcb->p_srcb->server_bda, 1647 BTA_GATTC_CI_CACHE_LOAD_EVT, 1648 p_clcb->p_srcb->attr_index, 1649 p_clcb->bta_conn_id); 1650 } 1651 else 1652 { 1653 p_clcb->p_srcb->state = BTA_GATTC_SERV_DISC; 1654 /* cache open failure, start discovery */ 1655 bta_gattc_start_discover(p_clcb, NULL); 1656 } 1657 } 1658 if (p_clcb->p_srcb->state == BTA_GATTC_SERV_SAVE) 1659 { 1660 if (p_data->ci_open.status == BTA_GATT_OK) 1661 { 1662 if (!bta_gattc_cache_save(p_clcb->p_srcb, p_clcb->bta_conn_id)) 1663 { 1664 p_data->ci_open.status = BTA_GATT_ERROR; 1665 } 1666 } 1667 if (p_data->ci_open.status != BTA_GATT_OK) 1668 { 1669 p_clcb->p_srcb->attr_index = 0; 1670 bta_gattc_co_cache_close(p_clcb->p_srcb->server_bda, p_clcb->bta_conn_id); 1671 bta_gattc_reset_discover_st(p_clcb->p_srcb, p_clcb->status); 1672 1673 } 1674 } 1675 } 1676 /******************************************************************************* 1677 ** 1678 ** Function bta_gattc_ci_load 1679 ** 1680 ** Description cache loading received. 1681 ** 1682 ** Returns None. 1683 ** 1684 *******************************************************************************/ 1685 void bta_gattc_ci_load(tBTA_GATTC_CLCB *p_clcb, tBTA_GATTC_DATA *p_data) 1686 { 1687 1688 APPL_TRACE_DEBUG("bta_gattc_ci_load conn_id=%d load status=%d", 1689 p_clcb->bta_conn_id, p_data->ci_load.status); 1690 1691 if (p_data->ci_load.status == BTA_GATT_OK || 1692 p_data->ci_load.status == BTA_GATT_MORE) 1693 { 1694 if (p_data->ci_load.num_attr != 0) 1695 bta_gattc_rebuild_cache(p_clcb->p_srcb, p_data->ci_load.num_attr, 1696 p_data->ci_load.attr, p_clcb->p_srcb->attr_index); 1697 1698 if (p_data->ci_load.status == BTA_GATT_OK) 1699 { 1700 p_clcb->p_srcb->attr_index = 0; 1701 bta_gattc_reset_discover_st(p_clcb->p_srcb, BTA_GATT_OK); 1702 bta_gattc_co_cache_close(p_clcb->p_srcb->server_bda, 0); 1703 } 1704 else /* load more */ 1705 { 1706 p_clcb->p_srcb->attr_index += p_data->ci_load.num_attr; 1707 1708 bta_gattc_co_cache_load(p_clcb->p_srcb->server_bda, 1709 BTA_GATTC_CI_CACHE_LOAD_EVT, 1710 p_clcb->p_srcb->attr_index, 1711 p_clcb->bta_conn_id); 1712 } 1713 } 1714 else 1715 { 1716 bta_gattc_co_cache_close(p_clcb->p_srcb->server_bda, 0); 1717 p_clcb->p_srcb->state = BTA_GATTC_SERV_DISC; 1718 p_clcb->p_srcb->attr_index = 0; 1719 /* cache load failure, start discovery */ 1720 bta_gattc_start_discover(p_clcb, NULL); 1721 } 1722 } 1723 /******************************************************************************* 1724 ** 1725 ** Function bta_gattc_ci_save 1726 ** 1727 ** Description cache loading received. 1728 ** 1729 ** Returns None. 1730 ** 1731 *******************************************************************************/ 1732 void bta_gattc_ci_save(tBTA_GATTC_CLCB *p_clcb, tBTA_GATTC_DATA *p_data) 1733 { 1734 UNUSED(p_data); 1735 1736 APPL_TRACE_DEBUG("bta_gattc_ci_save conn_id=%d " , 1737 p_clcb->bta_conn_id ); 1738 1739 if (!bta_gattc_cache_save(p_clcb->p_srcb, p_clcb->bta_conn_id)) 1740 { 1741 p_clcb->p_srcb->attr_index = 0; 1742 bta_gattc_co_cache_close(p_clcb->p_srcb->server_bda, 0); 1743 bta_gattc_reset_discover_st(p_clcb->p_srcb, p_clcb->status); 1744 } 1745 } 1746 /******************************************************************************* 1747 ** 1748 ** Function bta_gattc_fail 1749 ** 1750 ** Description report API call failure back to apps 1751 ** 1752 ** Returns None. 1753 ** 1754 *******************************************************************************/ 1755 void bta_gattc_fail(tBTA_GATTC_CLCB *p_clcb, tBTA_GATTC_DATA *p_data) 1756 { 1757 UNUSED(p_data); 1758 1759 if (p_clcb->status == BTA_GATT_OK) 1760 { 1761 APPL_TRACE_ERROR("operation not supported at current state [%d]", p_clcb->state); 1762 } 1763 } 1764 1765 /******************************************************************************* 1766 ** 1767 ** Function bta_gattc_deregister_cmpl 1768 ** 1769 ** Description De-Register a GATT client application with BTA completed. 1770 ** 1771 ** Returns void 1772 ** 1773 *******************************************************************************/ 1774 static void bta_gattc_deregister_cmpl(tBTA_GATTC_RCB *p_clreg) 1775 { 1776 tBTA_GATTC_CB *p_cb = &bta_gattc_cb; 1777 tBTA_GATTC_IF client_if = p_clreg->client_if; 1778 tBTA_GATTC cb_data; 1779 tBTA_GATTC_CBACK *p_cback = p_clreg->p_cback; 1780 1781 memset(&cb_data, 0, sizeof(tBTA_GATTC)); 1782 1783 GATT_Deregister(p_clreg->client_if); 1784 memset(p_clreg, 0, sizeof(tBTA_GATTC_RCB)); 1785 1786 cb_data.reg_oper.client_if = client_if; 1787 cb_data.reg_oper.status = BTA_GATT_OK; 1788 1789 if (p_cback) 1790 /* callback with de-register event */ 1791 (*p_cback)(BTA_GATTC_DEREG_EVT, (tBTA_GATTC *)&cb_data); 1792 1793 if (bta_gattc_num_reg_app() == 0 && p_cb->state == BTA_GATTC_STATE_DISABLING) 1794 { 1795 p_cb->state = BTA_GATTC_STATE_DISABLED; 1796 } 1797 } 1798 /******************************************************************************* 1799 ** 1800 ** Function bta_gattc_conn_cback 1801 ** bta_gattc_cmpl_cback 1802 ** 1803 ** Description callback functions to GATT client stack. 1804 ** 1805 ** Returns void 1806 ** 1807 *******************************************************************************/ 1808 static void bta_gattc_conn_cback(tGATT_IF gattc_if, BD_ADDR bda, UINT16 conn_id, 1809 BOOLEAN connected, tGATT_DISCONN_REASON reason, 1810 tBT_TRANSPORT transport) 1811 { 1812 tBTA_GATTC_DATA *p_buf; 1813 1814 if (reason != 0) 1815 { 1816 APPL_TRACE_WARNING("%s() - cif=%d connected=%d conn_id=%d reason=0x%04x", 1817 __FUNCTION__, gattc_if, connected, conn_id, reason); 1818 } 1819 1820 bt_bdaddr_t bdaddr; 1821 bdcpy(bdaddr.address, bda); 1822 if (connected) 1823 btif_debug_conn_state(bdaddr, BTIF_DEBUG_CONNECTED, GATT_CONN_UNKNOWN); 1824 else 1825 btif_debug_conn_state(bdaddr, BTIF_DEBUG_DISCONNECTED, reason); 1826 1827 if ((p_buf = (tBTA_GATTC_DATA *) GKI_getbuf(sizeof(tBTA_GATTC_DATA))) != NULL) 1828 { 1829 memset(p_buf, 0, sizeof(tBTA_GATTC_DATA)); 1830 1831 p_buf->int_conn.hdr.event = connected ? BTA_GATTC_INT_CONN_EVT: 1832 BTA_GATTC_INT_DISCONN_EVT; 1833 p_buf->int_conn.hdr.layer_specific = conn_id; 1834 p_buf->int_conn.client_if = gattc_if; 1835 p_buf->int_conn.role = L2CA_GetBleConnRole(bda); 1836 p_buf->int_conn.reason = reason; 1837 p_buf->int_conn.transport = transport; 1838 bdcpy(p_buf->int_conn.remote_bda, bda); 1839 1840 bta_sys_sendmsg(p_buf); 1841 } 1842 } 1843 1844 /******************************************************************************* 1845 ** 1846 ** Function bta_gattc_enc_cmpl_cback 1847 ** 1848 ** Description encryption complete callback function to GATT client stack. 1849 ** 1850 ** Returns void 1851 ** 1852 *******************************************************************************/ 1853 static void bta_gattc_enc_cmpl_cback(tGATT_IF gattc_if, BD_ADDR bda) 1854 { 1855 tBTA_GATTC_DATA *p_buf; 1856 tBTA_GATTC_CLCB *p_clcb = NULL; 1857 1858 if ((p_clcb = bta_gattc_find_clcb_by_cif(gattc_if, bda, BTA_GATT_TRANSPORT_LE)) == NULL) 1859 { 1860 return; 1861 } 1862 1863 #if (defined BTA_HH_LE_INCLUDED && BTA_HH_LE_INCLUDED == TRUE) 1864 /* filter this event just for BTA HH LE GATT client, 1865 In the future, if we want to enable encryption complete event 1866 for all GATT clients, we can remove this code */ 1867 if (!bta_hh_le_is_hh_gatt_if(gattc_if)) 1868 { 1869 return; 1870 } 1871 #endif 1872 1873 APPL_TRACE_DEBUG("bta_gattc_enc_cmpl_cback: cif = %d", gattc_if); 1874 1875 if ((p_buf = (tBTA_GATTC_DATA *) GKI_getbuf(sizeof(tBTA_GATTC_DATA))) != NULL) 1876 { 1877 memset(p_buf, 0, sizeof(tBTA_GATTC_DATA)); 1878 1879 p_buf->enc_cmpl.hdr.event = BTA_GATTC_ENC_CMPL_EVT; 1880 p_buf->enc_cmpl.hdr.layer_specific = p_clcb->bta_conn_id; 1881 p_buf->enc_cmpl.client_if = gattc_if; 1882 bdcpy(p_buf->enc_cmpl.remote_bda, bda); 1883 1884 bta_sys_sendmsg(p_buf); 1885 } 1886 } 1887 1888 /******************************************************************************* 1889 ** 1890 ** Function bta_gattc_process_api_refresh 1891 ** 1892 ** Description process refresh API to delete cache and start a new discovery 1893 ** if currently connected. 1894 ** 1895 ** Returns None. 1896 ** 1897 *******************************************************************************/ 1898 void bta_gattc_process_api_refresh(tBTA_GATTC_CB *p_cb, tBTA_GATTC_DATA * p_msg) 1899 { 1900 tBTA_GATTC_SERV *p_srvc_cb = bta_gattc_find_srvr_cache(p_msg->api_conn.remote_bda); 1901 tBTA_GATTC_CLCB *p_clcb = &bta_gattc_cb.clcb[0]; 1902 BOOLEAN found = FALSE; 1903 UINT8 i; 1904 UNUSED(p_cb); 1905 1906 if (p_srvc_cb != NULL) 1907 { 1908 /* try to find a CLCB */ 1909 if (p_srvc_cb->connected && p_srvc_cb->num_clcb != 0) 1910 { 1911 for (i = 0; i < BTA_GATTC_CLCB_MAX; i ++, p_clcb ++) 1912 { 1913 if (p_clcb->in_use && p_clcb->p_srcb == p_srvc_cb) 1914 { 1915 found = TRUE; 1916 break; 1917 } 1918 } 1919 if (found) 1920 { 1921 bta_gattc_sm_execute(p_clcb, BTA_GATTC_INT_DISCOVER_EVT, NULL); 1922 return; 1923 } 1924 } 1925 /* in all other cases, mark it and delete the cache */ 1926 if (p_srvc_cb->p_srvc_cache != NULL) 1927 { 1928 while (!GKI_queue_is_empty(&p_srvc_cb->cache_buffer)) 1929 GKI_freebuf (GKI_dequeue (&p_srvc_cb->cache_buffer)); 1930 1931 p_srvc_cb->p_srvc_cache = NULL; 1932 } 1933 } 1934 /* used to reset cache in application */ 1935 bta_gattc_co_cache_reset(p_msg->api_conn.remote_bda); 1936 1937 } 1938 /******************************************************************************* 1939 ** 1940 ** Function bta_gattc_process_srvc_chg_ind 1941 ** 1942 ** Description process service change indication. 1943 ** 1944 ** Returns None. 1945 ** 1946 *******************************************************************************/ 1947 BOOLEAN bta_gattc_process_srvc_chg_ind(UINT16 conn_id, 1948 tBTA_GATTC_RCB *p_clrcb, 1949 tBTA_GATTC_SERV *p_srcb, 1950 tBTA_GATTC_CLCB *p_clcb, 1951 tBTA_GATTC_NOTIFY *p_notify, 1952 UINT16 handle) 1953 { 1954 tBT_UUID gattp_uuid, srvc_chg_uuid; 1955 BOOLEAN processed = FALSE; 1956 UINT8 i; 1957 1958 gattp_uuid.len = 2; 1959 gattp_uuid.uu.uuid16 = UUID_SERVCLASS_GATT_SERVER; 1960 1961 srvc_chg_uuid.len = 2; 1962 srvc_chg_uuid.uu.uuid16 = GATT_UUID_GATT_SRV_CHGD; 1963 1964 if (bta_gattc_uuid_compare(&p_notify->char_id.srvc_id.id.uuid, &gattp_uuid, TRUE) && 1965 bta_gattc_uuid_compare(&p_notify->char_id.char_id.uuid, &srvc_chg_uuid, TRUE)) 1966 { 1967 processed = TRUE; 1968 /* mark service handle change pending */ 1969 p_srcb->srvc_hdl_chg = TRUE; 1970 /* clear up all notification/indication registration */ 1971 bta_gattc_clear_notif_registration(conn_id); 1972 /* service change indication all received, do discovery update */ 1973 if ( ++ p_srcb->update_count == bta_gattc_num_reg_app()) 1974 { 1975 /* not an opened connection; or connection busy */ 1976 /* search for first available clcb and start discovery */ 1977 if (p_clcb == NULL || (p_clcb && p_clcb->p_q_cmd != NULL)) 1978 { 1979 for (i = 0 ; i < BTA_GATTC_CLCB_MAX; i ++) 1980 { 1981 if (bta_gattc_cb.clcb[i].in_use && 1982 bta_gattc_cb.clcb[i].p_srcb == p_srcb && 1983 bta_gattc_cb.clcb[i].p_q_cmd == NULL) 1984 { 1985 p_clcb = &bta_gattc_cb.clcb[i]; 1986 break; 1987 } 1988 } 1989 } 1990 /* send confirmation here if this is an indication, it should always be */ 1991 GATTC_SendHandleValueConfirm(conn_id, handle); 1992 1993 /* if connection available, refresh cache by doing discovery now */ 1994 if (p_clcb != NULL) 1995 bta_gattc_sm_execute(p_clcb, BTA_GATTC_INT_DISCOVER_EVT, NULL); 1996 } 1997 /* notify applicationf or service change */ 1998 if (p_clrcb->p_cback != NULL) 1999 { 2000 (* p_clrcb->p_cback)(BTA_GATTC_SRVC_CHG_EVT, (tBTA_GATTC *)p_srcb->server_bda); 2001 } 2002 2003 } 2004 2005 return processed; 2006 2007 } 2008 /******************************************************************************* 2009 ** 2010 ** Function bta_gattc_proc_other_indication 2011 ** 2012 ** Description process all non-service change indication/notification. 2013 ** 2014 ** Returns None. 2015 ** 2016 *******************************************************************************/ 2017 void bta_gattc_proc_other_indication(tBTA_GATTC_CLCB *p_clcb, UINT8 op, 2018 tGATT_CL_COMPLETE *p_data, 2019 tBTA_GATTC_NOTIFY *p_notify) 2020 { 2021 APPL_TRACE_DEBUG("bta_gattc_proc_other_indication check \ 2022 p_data->att_value.handle=%d p_data->handle=%d", 2023 p_data->att_value.handle, p_data->handle); 2024 APPL_TRACE_DEBUG("is_notify", p_notify->is_notify); 2025 2026 p_notify->is_notify = (op == GATTC_OPTYPE_INDICATION) ? FALSE : TRUE; 2027 p_notify->len = p_data->att_value.len; 2028 bdcpy(p_notify->bda, p_clcb->bda); 2029 memcpy(p_notify->value, p_data->att_value.value, p_data->att_value.len); 2030 p_notify->conn_id = p_clcb->bta_conn_id; 2031 2032 if (p_clcb->p_rcb->p_cback) 2033 (*p_clcb->p_rcb->p_cback)(BTA_GATTC_NOTIF_EVT, (tBTA_GATTC *)p_notify); 2034 2035 } 2036 /******************************************************************************* 2037 ** 2038 ** Function bta_gattc_process_indicate 2039 ** 2040 ** Description process indication/notification. 2041 ** 2042 ** Returns None. 2043 ** 2044 *******************************************************************************/ 2045 void bta_gattc_process_indicate(UINT16 conn_id, tGATTC_OPTYPE op, tGATT_CL_COMPLETE *p_data) 2046 { 2047 UINT16 handle = p_data->att_value.handle; 2048 tBTA_GATTC_CLCB *p_clcb ; 2049 tBTA_GATTC_RCB *p_clrcb = NULL; 2050 tBTA_GATTC_SERV *p_srcb = NULL; 2051 tBTA_GATTC_NOTIFY notify; 2052 BD_ADDR remote_bda; 2053 tBTA_GATTC_IF gatt_if; 2054 tBTA_TRANSPORT transport; 2055 2056 if (!GATT_GetConnectionInfor(conn_id, &gatt_if, remote_bda, &transport)) 2057 { 2058 APPL_TRACE_ERROR("%s indication/notif for unknown app", __func__); 2059 if (op == GATTC_OPTYPE_INDICATION) 2060 GATTC_SendHandleValueConfirm(conn_id, handle); 2061 return; 2062 } 2063 2064 if ((p_clrcb = bta_gattc_cl_get_regcb(gatt_if)) == NULL) 2065 { 2066 APPL_TRACE_ERROR("%s indication/notif for unregistered app", __func__); 2067 if (op == GATTC_OPTYPE_INDICATION) 2068 GATTC_SendHandleValueConfirm(conn_id, handle); 2069 return; 2070 } 2071 2072 if ((p_srcb = bta_gattc_find_srcb(remote_bda)) == NULL) 2073 { 2074 APPL_TRACE_ERROR("%s indication/notif for unknown device, ignore", __func__); 2075 if (op == GATTC_OPTYPE_INDICATION) 2076 GATTC_SendHandleValueConfirm(conn_id, handle); 2077 return; 2078 } 2079 2080 p_clcb = bta_gattc_find_clcb_by_conn_id(conn_id); 2081 2082 if (bta_gattc_handle2id(p_srcb, handle, 2083 ¬ify.char_id.srvc_id, 2084 ¬ify.char_id.char_id, 2085 ¬ify.descr_type)) 2086 { 2087 /* if non-service change indication/notification, forward to application */ 2088 if (!bta_gattc_process_srvc_chg_ind(conn_id, p_clrcb, p_srcb, p_clcb, ¬ify, handle)) 2089 { 2090 /* if app registered for the notification */ 2091 if (bta_gattc_check_notif_registry(p_clrcb, p_srcb, ¬ify)) 2092 { 2093 /* connection not open yet */ 2094 if (p_clcb == NULL) 2095 { 2096 if ((p_clcb = bta_gattc_clcb_alloc(gatt_if, remote_bda, transport)) != NULL) 2097 { 2098 p_clcb->bta_conn_id = conn_id; 2099 p_clcb->transport = transport; 2100 2101 bta_gattc_sm_execute(p_clcb, BTA_GATTC_INT_CONN_EVT, NULL); 2102 } 2103 else 2104 { 2105 APPL_TRACE_ERROR("No resources"); 2106 } 2107 } 2108 2109 if (p_clcb != NULL) 2110 bta_gattc_proc_other_indication(p_clcb, op, p_data, ¬ify); 2111 } 2112 /* no one intersted and need ack? */ 2113 else if (op == GATTC_OPTYPE_INDICATION) 2114 { 2115 APPL_TRACE_DEBUG("%s no one interested, ack now", __func__); 2116 GATTC_SendHandleValueConfirm(conn_id, handle); 2117 } 2118 } 2119 } 2120 else 2121 { 2122 APPL_TRACE_ERROR("%s Indi/Notif for Unknown handle[0x%04x], can not find in local cache.", 2123 __func__, handle); 2124 if (op == GATTC_OPTYPE_INDICATION) 2125 GATTC_SendHandleValueConfirm(conn_id, handle); 2126 } 2127 } 2128 /******************************************************************************* 2129 ** 2130 ** Function bta_gattc_cmpl_cback 2131 ** 2132 ** Description client operation complete callback register with BTE GATT. 2133 ** 2134 ** Returns None. 2135 ** 2136 *******************************************************************************/ 2137 static void bta_gattc_cmpl_cback(UINT16 conn_id, tGATTC_OPTYPE op, tGATT_STATUS status, 2138 tGATT_CL_COMPLETE *p_data) 2139 { 2140 tBTA_GATTC_CLCB *p_clcb ; 2141 tBTA_GATTC_OP_CMPL *p_buf; 2142 UINT16 len = sizeof(tBTA_GATTC_OP_CMPL) + sizeof(tGATT_CL_COMPLETE); 2143 2144 APPL_TRACE_DEBUG("bta_gattc_cmpl_cback: conn_id = %d op = %d status = %d", 2145 conn_id, op, status); 2146 2147 /* notification and indication processed right away */ 2148 if (op == GATTC_OPTYPE_NOTIFICATION || op == GATTC_OPTYPE_INDICATION) 2149 { 2150 bta_gattc_process_indicate(conn_id, op, p_data); 2151 return; 2152 } 2153 /* for all other operation, not expected if w/o connection */ 2154 else if ((p_clcb = bta_gattc_find_clcb_by_conn_id(conn_id)) == NULL) 2155 { 2156 APPL_TRACE_ERROR("bta_gattc_cmpl_cback unknown conn_id = %d, ignore data", conn_id); 2157 return; 2158 } 2159 2160 /* if over BR_EDR, inform PM for mode change */ 2161 if (p_clcb->transport == BTA_TRANSPORT_BR_EDR) 2162 { 2163 bta_sys_busy(BTA_ID_GATTC, BTA_ALL_APP_ID, p_clcb->bda); 2164 bta_sys_idle(BTA_ID_GATTC, BTA_ALL_APP_ID, p_clcb->bda); 2165 } 2166 2167 if ((p_buf = (tBTA_GATTC_OP_CMPL *) GKI_getbuf(len)) != NULL) 2168 { 2169 memset(p_buf, 0, len); 2170 p_buf->hdr.event = BTA_GATTC_OP_CMPL_EVT; 2171 p_buf->hdr.layer_specific = conn_id; 2172 p_buf->status = status; 2173 p_buf->op_code = op; 2174 2175 if (p_data != NULL) 2176 { 2177 p_buf->p_cmpl = (tGATT_CL_COMPLETE *)(p_buf + 1); 2178 memcpy(p_buf->p_cmpl, p_data, sizeof(tGATT_CL_COMPLETE)); 2179 } 2180 2181 bta_sys_sendmsg(p_buf); 2182 } 2183 2184 return; 2185 } 2186 2187 /******************************************************************************* 2188 ** 2189 ** Function bta_gattc_cong_cback 2190 ** 2191 ** Description congestion callback for BTA GATT client. 2192 ** 2193 ** Returns void 2194 ** 2195 ********************************************************************************/ 2196 static void bta_gattc_cong_cback (UINT16 conn_id, BOOLEAN congested) 2197 { 2198 tBTA_GATTC_CLCB *p_clcb; 2199 tBTA_GATTC cb_data; 2200 2201 if ((p_clcb = bta_gattc_find_clcb_by_conn_id(conn_id)) != NULL) 2202 { 2203 if (p_clcb->p_rcb->p_cback) 2204 { 2205 cb_data.congest.conn_id = conn_id; 2206 cb_data.congest.congested = congested; 2207 2208 (*p_clcb->p_rcb->p_cback)(BTA_GATTC_CONGEST_EVT, &cb_data); 2209 } 2210 } 2211 } 2212 2213 #if BLE_INCLUDED == TRUE 2214 /******************************************************************************* 2215 ** 2216 ** Function bta_gattc_init_clcb_conn 2217 ** 2218 ** Description Initaite a BTA CLCB connection 2219 ** 2220 ** Returns void 2221 ** 2222 ********************************************************************************/ 2223 void bta_gattc_init_clcb_conn(UINT8 cif, BD_ADDR remote_bda) 2224 { 2225 tBTA_GATTC_CLCB *p_clcb = NULL; 2226 tBTA_GATTC_DATA gattc_data; 2227 UINT16 conn_id; 2228 2229 /* should always get the connection ID */ 2230 if (GATT_GetConnIdIfConnected(cif, remote_bda, &conn_id, BTA_GATT_TRANSPORT_LE) == FALSE) 2231 { 2232 APPL_TRACE_ERROR("bta_gattc_init_clcb_conn ERROR: not a connected device"); 2233 return; 2234 } 2235 2236 /* initaite a new connection here */ 2237 if ((p_clcb = bta_gattc_clcb_alloc(cif, remote_bda, BTA_GATT_TRANSPORT_LE)) != NULL) 2238 { 2239 gattc_data.hdr.layer_specific = p_clcb->bta_conn_id = conn_id; 2240 2241 gattc_data.api_conn.client_if = cif; 2242 memcpy(gattc_data.api_conn.remote_bda, remote_bda, BD_ADDR_LEN); 2243 gattc_data.api_conn.is_direct = TRUE; 2244 2245 bta_gattc_sm_execute(p_clcb, BTA_GATTC_API_OPEN_EVT, &gattc_data); 2246 } 2247 else 2248 { 2249 APPL_TRACE_ERROR("No resources"); 2250 } 2251 } 2252 /******************************************************************************* 2253 ** 2254 ** Function bta_gattc_process_listen_all 2255 ** 2256 ** Description process listen all, send open callback to application for all 2257 ** connected slave LE link. 2258 ** 2259 ** Returns void 2260 ** 2261 ********************************************************************************/ 2262 void bta_gattc_process_listen_all(UINT8 cif) 2263 { 2264 UINT8 i_conn = 0; 2265 tBTA_GATTC_CONN *p_conn = &bta_gattc_cb.conn_track[0]; 2266 2267 for (i_conn = 0; i_conn < BTA_GATTC_CONN_MAX; i_conn++, p_conn ++) 2268 { 2269 if (p_conn->in_use ) 2270 { 2271 if (bta_gattc_find_clcb_by_cif(cif, p_conn->remote_bda, BTA_GATT_TRANSPORT_LE) == NULL) 2272 { 2273 bta_gattc_init_clcb_conn(cif, p_conn->remote_bda); 2274 } 2275 /* else already connected */ 2276 } 2277 } 2278 } 2279 /******************************************************************************* 2280 ** 2281 ** Function bta_gattc_listen 2282 ** 2283 ** Description Start or stop a listen for connection 2284 ** 2285 ** Returns void 2286 ** 2287 ********************************************************************************/ 2288 void bta_gattc_listen(tBTA_GATTC_CB *p_cb, tBTA_GATTC_DATA * p_msg) 2289 { 2290 tBTA_GATTC_RCB *p_clreg = bta_gattc_cl_get_regcb(p_msg->api_listen.client_if); 2291 tBTA_GATTC cb_data; 2292 UNUSED(p_cb); 2293 2294 cb_data.reg_oper.status = BTA_GATT_ERROR; 2295 cb_data.reg_oper.client_if = p_msg->api_listen.client_if; 2296 2297 if (p_clreg == NULL) 2298 { 2299 APPL_TRACE_ERROR("bta_gattc_listen failed, unknown client_if: %d", 2300 p_msg->api_listen.client_if); 2301 return; 2302 } 2303 /* mark bg conn record */ 2304 if (bta_gattc_mark_bg_conn(p_msg->api_listen.client_if, 2305 (BD_ADDR_PTR) p_msg->api_listen.remote_bda, 2306 p_msg->api_listen.start, 2307 TRUE)) 2308 { 2309 if (!GATT_Listen(p_msg->api_listen.client_if, 2310 p_msg->api_listen.start, 2311 p_msg->api_listen.remote_bda)) 2312 { 2313 APPL_TRACE_ERROR("Listen failure"); 2314 (*p_clreg->p_cback)(BTA_GATTC_LISTEN_EVT, &cb_data); 2315 } 2316 else 2317 { 2318 cb_data.status = BTA_GATT_OK; 2319 2320 (*p_clreg->p_cback)(BTA_GATTC_LISTEN_EVT, &cb_data); 2321 2322 if (p_msg->api_listen.start) 2323 { 2324 /* if listen to a specific target */ 2325 if (p_msg->api_listen.remote_bda != NULL) 2326 { 2327 2328 /* if is a connected remote device */ 2329 if (L2CA_GetBleConnRole(p_msg->api_listen.remote_bda) == HCI_ROLE_SLAVE && 2330 bta_gattc_find_clcb_by_cif(p_msg->api_listen.client_if, 2331 p_msg->api_listen.remote_bda, 2332 BTA_GATT_TRANSPORT_LE) == NULL) 2333 { 2334 2335 bta_gattc_init_clcb_conn(p_msg->api_listen.client_if, 2336 p_msg->api_listen.remote_bda); 2337 } 2338 } 2339 /* if listen to all */ 2340 else 2341 { 2342 LOG_DEBUG("Listen For All now"); 2343 /* go through all connected device and send 2344 callback for all connected slave connection */ 2345 bta_gattc_process_listen_all(p_msg->api_listen.client_if); 2346 } 2347 } 2348 } 2349 } 2350 } 2351 2352 /******************************************************************************* 2353 ** 2354 ** Function bta_gattc_broadcast 2355 ** 2356 ** Description Start or stop broadcasting 2357 ** 2358 ** Returns void 2359 ** 2360 ********************************************************************************/ 2361 void bta_gattc_broadcast(tBTA_GATTC_CB *p_cb, tBTA_GATTC_DATA * p_msg) 2362 { 2363 tBTA_GATTC_RCB *p_clreg = bta_gattc_cl_get_regcb(p_msg->api_listen.client_if); 2364 tBTA_GATTC cb_data; 2365 UNUSED(p_cb); 2366 2367 cb_data.reg_oper.client_if = p_msg->api_listen.client_if; 2368 cb_data.reg_oper.status = BTM_BleBroadcast(p_msg->api_listen.start); 2369 2370 if (p_clreg && p_clreg->p_cback) 2371 (*p_clreg->p_cback)(BTA_GATTC_LISTEN_EVT, &cb_data); 2372 } 2373 #endif 2374 #endif 2375
