bta/gatt/bta_gattc_api.c

   1 /******************************************************************************
   2  *
   3  *  Copyright (C) 2010-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 is the implementation of the API for GATT module of BTA.
  22  *
  23  ******************************************************************************/
  24
  25 #include "bt_target.h"
  26
  27 #if defined(BTA_GATT_INCLUDED) && (BTA_GATT_INCLUDED == TRUE)
  28
  29 #include <string.h>
  30 #include "bt_common.h"
  31 #include "bta_sys.h"
  32 #include "bta_gatt_api.h"
  33 #include "bta_gattc_int.h"
  34
  35 /*****************************************************************************
  36 **  Constants
  37 *****************************************************************************/
  38
  39 static const tBTA_SYS_REG bta_gattc_reg =
  40 {
  41     bta_gattc_hdl_event,
  42     BTA_GATTC_Disable
  43 };
  44
  45
  46 /*******************************************************************************
  47 **
  48 ** Function         BTA_GATTC_Disable
  49 **
  50 ** Description      This function is called to disable GATTC module
  51 **
  52 ** Parameters       None.
  53 **
  54 ** Returns          None
  55 **
  56 *******************************************************************************/
  57 void BTA_GATTC_Disable(void)
  58 {
  59     if (bta_sys_is_register(BTA_ID_GATTC) == FALSE)
  60     {
  61         APPL_TRACE_WARNING("GATTC Module not enabled/already disabled");
  62         return;
  63     }
  64
  65     BT_HDR *p_buf = (BT_HDR *)osi_malloc(sizeof(BT_HDR));
  66     p_buf->event = BTA_GATTC_API_DISABLE_EVT;
  67
  68     bta_sys_sendmsg(p_buf);
  69     bta_sys_deregister(BTA_ID_GATTC);
  70 }
  71
  72 /*******************************************************************************
  73 **
  74 ** Function         BTA_GATTC_AppRegister
  75 **
  76 ** Description      This function is called to register application callbacks
  77 **                    with BTA GATTC module.
  78 **
  79 ** Parameters       p_app_uuid - applicaiton UUID
  80 **                  p_client_cb - pointer to the application callback function.
  81 **
  82 ** Returns          None
  83 **
  84 *******************************************************************************/
  85 void BTA_GATTC_AppRegister(tBT_UUID *p_app_uuid, tBTA_GATTC_CBACK *p_client_cb)
  86 {
  87     tBTA_GATTC_API_REG *p_buf =
  88         (tBTA_GATTC_API_REG *)osi_malloc(sizeof(tBTA_GATTC_API_REG));
  89
  90     if (bta_sys_is_register(BTA_ID_GATTC) == FALSE)
  91         bta_sys_register(BTA_ID_GATTC, &bta_gattc_reg);
  92
  93     p_buf->hdr.event = BTA_GATTC_API_REG_EVT;
  94     if (p_app_uuid != NULL)
  95         memcpy(&p_buf->app_uuid, p_app_uuid, sizeof(tBT_UUID));
  96     p_buf->p_cback = p_client_cb;
  97
  98     bta_sys_sendmsg(p_buf);
  99 }
 100
 101 /*******************************************************************************
 102 **
 103 ** Function         BTA_GATTC_AppDeregister
 104 **
 105 ** Description      This function is called to deregister an application
 106 **                  from BTA GATTC module.
 107 **
 108 ** Parameters       client_if - client interface identifier.
 109 **
 110 ** Returns          None
 111 **
 112 *******************************************************************************/
 113 void BTA_GATTC_AppDeregister(tBTA_GATTC_IF client_if)
 114 {
 115     tBTA_GATTC_API_DEREG *p_buf =
 116         (tBTA_GATTC_API_DEREG *)osi_malloc(sizeof(tBTA_GATTC_API_DEREG));
 117
 118     p_buf->hdr.event = BTA_GATTC_API_DEREG_EVT;
 119     p_buf->client_if = client_if;
 120
 121     bta_sys_sendmsg(p_buf);
 122 }
 123
 124 /*******************************************************************************
 125 **
 126 ** Function         BTA_GATTC_Open
 127 **
 128 ** Description      Open a direct connection or add a background auto connection
 129 **                  bd address
 130 **
 131 ** Parameters       client_if: server interface.
 132 **                  remote_bda: remote device BD address.
 133 **                  is_direct: direct connection or background auto connection
 134 **                  transport: Transport to be used for GATT connection (BREDR/LE)
 135 **
 136 ** Returns          void
 137 **
 138 *******************************************************************************/
 139 void BTA_GATTC_Open(tBTA_GATTC_IF client_if, BD_ADDR remote_bda,
 140                     BOOLEAN is_direct, tBTA_GATT_TRANSPORT transport)
 141 {
 142     tBTA_GATTC_API_OPEN *p_buf =
 143        (tBTA_GATTC_API_OPEN *) osi_malloc(sizeof(tBTA_GATTC_API_OPEN));
 144
 145     p_buf->hdr.event = BTA_GATTC_API_OPEN_EVT;
 146     p_buf->client_if = client_if;
 147     p_buf->is_direct = is_direct;
 148     p_buf->transport = transport;
 149     memcpy(p_buf->remote_bda, remote_bda, BD_ADDR_LEN);
 150
 151     bta_sys_sendmsg(p_buf);
 152 }
 153
 154 /*******************************************************************************
 155 **
 156 ** Function         BTA_GATTC_CancelOpen
 157 **
 158 ** Description      Cancel a direct open connection or remove a background auto connection
 159 **                  bd address
 160 **
 161 ** Parameters       client_if: server interface.
 162 **                  remote_bda: remote device BD address.
 163 **                  is_direct: direct connection or background auto connection
 164 **
 165 ** Returns          void
 166 **
 167 *******************************************************************************/
 168 void BTA_GATTC_CancelOpen(tBTA_GATTC_IF client_if, BD_ADDR remote_bda, BOOLEAN is_direct)
 169 {
 170     tBTA_GATTC_API_CANCEL_OPEN *p_buf =
 171         (tBTA_GATTC_API_CANCEL_OPEN *)osi_malloc(sizeof(tBTA_GATTC_API_CANCEL_OPEN));
 172
 173     p_buf->hdr.event = BTA_GATTC_API_CANCEL_OPEN_EVT;
 174     p_buf->client_if = client_if;
 175     p_buf->is_direct = is_direct;
 176     memcpy(p_buf->remote_bda, remote_bda, BD_ADDR_LEN);
 177
 178     bta_sys_sendmsg(p_buf);
 179 }
 180
 181 /*******************************************************************************
 182 **
 183 ** Function         BTA_GATTC_Close
 184 **
 185 ** Description      Close a connection to a GATT server.
 186 **
 187 ** Parameters       conn_id: connectino ID to be closed.
 188 **
 189 ** Returns          void
 190 **
 191 *******************************************************************************/
 192 void BTA_GATTC_Close(UINT16 conn_id)
 193 {
 194     BT_HDR *p_buf = (BT_HDR *)osi_malloc(sizeof(BT_HDR));
 195
 196     p_buf->event = BTA_GATTC_API_CLOSE_EVT;
 197     p_buf->layer_specific = conn_id;
 198
 199     bta_sys_sendmsg(p_buf);
 200 }
 201
 202 /*******************************************************************************
 203 **
 204 ** Function         BTA_GATTC_ConfigureMTU
 205 **
 206 ** Description      Configure the MTU size in the GATT channel. This can be done
 207 **                  only once per connection.
 208 **
 209 ** Parameters       conn_id: connection ID.
 210 **                  mtu: desired MTU size to use.
 211 **
 212 ** Returns          void
 213 **
 214 *******************************************************************************/
 215 void BTA_GATTC_ConfigureMTU (UINT16 conn_id, UINT16 mtu)
 216 {
 217     tBTA_GATTC_API_CFG_MTU *p_buf =
 218         (tBTA_GATTC_API_CFG_MTU *)osi_malloc(sizeof(tBTA_GATTC_API_CFG_MTU));
 219
 220     p_buf->hdr.event = BTA_GATTC_API_CFG_MTU_EVT;
 221     p_buf->hdr.layer_specific = conn_id;
 222     p_buf->mtu = mtu;
 223
 224     bta_sys_sendmsg(p_buf);
 225 }
 226
 227 /*******************************************************************************
 228 **
 229 ** Function         BTA_GATTC_ServiceSearchRequest
 230 **
 231 ** Description      This function is called to request a GATT service discovery
 232 **                    on a GATT server. This function report service search result
 233 **                  by a callback event, and followed by a service search complete
 234 **                  event.
 235 **
 236 ** Parameters       conn_id: connection ID.
 237 **                  p_srvc_uuid: a UUID of the service application is interested in.
 238 **                              If Null, discover for all services.
 239 **
 240 ** Returns          None
 241 **
 242 *******************************************************************************/
 243 void BTA_GATTC_ServiceSearchRequest (UINT16 conn_id, tBT_UUID *p_srvc_uuid)
 244 {
 245     const size_t len = sizeof(tBTA_GATTC_API_SEARCH) + sizeof(tBT_UUID);
 246     tBTA_GATTC_API_SEARCH *p_buf = (tBTA_GATTC_API_SEARCH *)osi_calloc(len);
 247
 248     p_buf->hdr.event = BTA_GATTC_API_SEARCH_EVT;
 249     p_buf->hdr.layer_specific = conn_id;
 250     if (p_srvc_uuid) {
 251         p_buf->p_srvc_uuid = (tBT_UUID *)(p_buf + 1);
 252         memcpy(p_buf->p_srvc_uuid, p_srvc_uuid, sizeof(tBT_UUID));
 253     } else {
 254         p_buf->p_srvc_uuid = NULL;
 255     }
 256
 257     bta_sys_sendmsg(p_buf);
 258 }
 259
 260 /*******************************************************************************
 261 **
 262 ** Function         BTA_GATTC_GetServices
 263 **
 264 ** Description      This function is called to find the services on the given server.
 265 **
 266 ** Parameters       conn_id: connection ID which identify the server.
 267 **
 268 ** Returns          returns list_t of tBTA_GATTC_SERVICE or NULL.
 269 **
 270 *******************************************************************************/
 271 const list_t* BTA_GATTC_GetServices(UINT16 conn_id) {
 272     return bta_gattc_get_services(conn_id);
 273 }
 274
 275 /*******************************************************************************
 276 **
 277 ** Function         BTA_GATTC_GetCharacteristic
 278 **
 279 ** Description      This function is called to find the characteristic on the given server.
 280 **
 281 ** Parameters       conn_id - connection ID which identify the server.
 282 **                  handle - characteristic handle
 283 **
 284 ** Returns          returns pointer to tBTA_GATTC_CHARACTERISTIC or NULL.
 285 **
 286 *******************************************************************************/
 287 const tBTA_GATTC_CHARACTERISTIC* BTA_GATTC_GetCharacteristic(UINT16 conn_id, UINT16 handle) {
 288     return bta_gattc_get_characteristic(conn_id, handle);
 289 }
 290
 291 /*******************************************************************************
 292 **
 293 ** Function         BTA_GATTC_GetDescriptor
 294 **
 295 ** Description      This function is called to find the characteristic on the given server.
 296 **
 297 ** Parameters       conn_id - connection ID which identify the server.
 298 **                  handle - descriptor handle
 299 **
 300 ** Returns          returns pointer to tBTA_GATTC_DESCRIPTOR or NULL.
 301 **
 302 *******************************************************************************/
 303 const tBTA_GATTC_DESCRIPTOR* BTA_GATTC_GetDescriptor(UINT16 conn_id, UINT16 handle) {
 304     return bta_gattc_get_descriptor(conn_id, handle);
 305 }
 306
 307 /*******************************************************************************
 308 **
 309 ** Function         BTA_GATTC_GetGattDb
 310 **
 311 ** Description      This function is called to get the GATT database.
 312 **
 313 ** Parameters       conn_id: connection ID which identify the server.
 314 **                  db: output parameter which will contain the GATT database copy.
 315 **                      Caller is responsible for freeing it.
 316 **                  count: number of elements in database.
 317 **
 318 *******************************************************************************/
 319 void  BTA_GATTC_GetGattDb(UINT16 conn_id, UINT16 start_handle, UINT16 end_handle,
 320                           btgatt_db_element_t **db, int *count)
 321 {
 322     bta_gattc_get_gatt_db(conn_id, start_handle, end_handle, db, count);
 323 }
 324
 325 /*******************************************************************************
 326 **
 327 ** Function         BTA_GATTC_ReadCharacteristic
 328 **
 329 ** Description      This function is called to read a characteristics value
 330 **
 331 ** Parameters       conn_id - connection ID.
 332 **                  handle - characteritic handle to read.
 333 **
 334 ** Returns          None
 335 **
 336 *******************************************************************************/
 337 void BTA_GATTC_ReadCharacteristic(UINT16 conn_id, UINT16 handle, tBTA_GATT_AUTH_REQ auth_req)
 338 {
 339     tBTA_GATTC_API_READ *p_buf =
 340         (tBTA_GATTC_API_READ *)osi_calloc(sizeof(tBTA_GATTC_API_READ));
 341
 342     p_buf->hdr.event = BTA_GATTC_API_READ_EVT;
 343     p_buf->hdr.layer_specific = conn_id;
 344     p_buf->auth_req = auth_req;
 345     p_buf->handle = handle;
 346     p_buf->cmpl_evt = BTA_GATTC_READ_CHAR_EVT;
 347
 348     bta_sys_sendmsg(p_buf);
 349 }
 350
 351 /*******************************************************************************
 352 **
 353 ** Function         BTA_GATTC_ReadCharDescr
 354 **
 355 ** Description      This function is called to read a descriptor value.
 356 **
 357 ** Parameters       conn_id - connection ID.
 358 **                  handle - descriptor handle to read.
 359 **
 360 ** Returns          None
 361 **
 362 *******************************************************************************/
 363 void BTA_GATTC_ReadCharDescr (UINT16 conn_id, UINT16 handle, tBTA_GATT_AUTH_REQ auth_req)
 364 {
 365     tBTA_GATTC_API_READ *p_buf =
 366         (tBTA_GATTC_API_READ *)osi_calloc(sizeof(tBTA_GATTC_API_READ));
 367
 368     p_buf->hdr.event = BTA_GATTC_API_READ_EVT;
 369     p_buf->hdr.layer_specific = conn_id;
 370     p_buf->auth_req = auth_req;
 371     p_buf->handle = handle;
 372     p_buf->cmpl_evt = BTA_GATTC_READ_DESCR_EVT;
 373
 374     bta_sys_sendmsg(p_buf);
 375 }
 376
 377 /*******************************************************************************
 378 **
 379 ** Function         BTA_GATTC_ReadMultiple
 380 **
 381 ** Description      This function is called to read multiple characteristic or
 382 **                  characteristic descriptors.
 383 **
 384 ** Parameters       conn_id - connectino ID.
 385 **                    p_read_multi - pointer to the read multiple parameter.
 386 **
 387 ** Returns          None
 388 **
 389 *******************************************************************************/
 390 void BTA_GATTC_ReadMultiple(UINT16 conn_id, tBTA_GATTC_MULTI *p_read_multi,
 391                             tBTA_GATT_AUTH_REQ auth_req)
 392 {
 393     tBTA_GATTC_API_READ_MULTI *p_buf =
 394         (tBTA_GATTC_API_READ_MULTI *)osi_calloc(sizeof(tBTA_GATTC_API_READ_MULTI));
 395
 396     p_buf->hdr.event = BTA_GATTC_API_READ_MULTI_EVT;
 397     p_buf->hdr.layer_specific = conn_id;
 398     p_buf->auth_req = auth_req;
 399     p_buf->num_attr = p_read_multi->num_attr;
 400
 401     if (p_buf->num_attr > 0)
 402         memcpy(p_buf->handles, p_read_multi->handles, sizeof(UINT16) * p_read_multi->num_attr);
 403
 404     bta_sys_sendmsg(p_buf);
 405 }
 406
 407 /*******************************************************************************
 408 **
 409 ** Function         BTA_GATTC_WriteCharValue
 410 **
 411 ** Description      This function is called to write characteristic value.
 412 **
 413 ** Parameters       conn_id - connection ID.
 414 **                  handle - characteristic handle to write.
 415 **                  write_type - type of write.
 416 **                  len: length of the data to be written.
 417 **                  p_value - the value to be written.
 418 **
 419 ** Returns          None
 420 **
 421 *******************************************************************************/
 422 void BTA_GATTC_WriteCharValue ( UINT16 conn_id,
 423                                 UINT16 handle,
 424                                 tBTA_GATTC_WRITE_TYPE  write_type,
 425                                 UINT16 len,
 426                                 UINT8 *p_value,
 427                                 tBTA_GATT_AUTH_REQ auth_req)
 428 {
 429     tBTA_GATTC_API_WRITE  *p_buf =
 430         (tBTA_GATTC_API_WRITE *)osi_calloc(sizeof(tBTA_GATTC_API_WRITE) + len);
 431
 432     p_buf->hdr.event = BTA_GATTC_API_WRITE_EVT;
 433     p_buf->hdr.layer_specific = conn_id;
 434     p_buf->auth_req = auth_req;
 435     p_buf->handle = handle;
 436     p_buf->cmpl_evt = BTA_GATTC_WRITE_CHAR_EVT;
 437     p_buf->write_type = write_type;
 438     p_buf->len = len;
 439
 440     if (p_value && len > 0) {
 441         p_buf->p_value = (UINT8 *)(p_buf + 1);
 442         memcpy(p_buf->p_value, p_value, len);
 443     }
 444
 445     bta_sys_sendmsg(p_buf);
 446 }
 447
 448 /*******************************************************************************
 449 **
 450 ** Function         BTA_GATTC_WriteCharDescr
 451 **
 452 ** Description      This function is called to write descriptor value.
 453 **
 454 ** Parameters       conn_id - connection ID
 455 **                  handle - descriptor hadle to write.
 456 **                  write_type - write type.
 457 **                  p_value - the value to be written.
 458 **
 459 ** Returns          None
 460 **
 461 *******************************************************************************/
 462 void BTA_GATTC_WriteCharDescr (UINT16 conn_id,
 463                                UINT16 handle,
 464                                tBTA_GATTC_WRITE_TYPE  write_type,
 465                                tBTA_GATT_UNFMT      *p_data,
 466                                tBTA_GATT_AUTH_REQ auth_req)
 467 {
 468     size_t len = sizeof(tBTA_GATTC_API_WRITE);
 469
 470     if (p_data != NULL)
 471         len += p_data->len;
 472
 473     tBTA_GATTC_API_WRITE *p_buf = (tBTA_GATTC_API_WRITE *)osi_calloc(len);
 474     p_buf->hdr.event = BTA_GATTC_API_WRITE_EVT;
 475     p_buf->hdr.layer_specific = conn_id;
 476     p_buf->auth_req = auth_req;
 477     p_buf->handle = handle;
 478     p_buf->cmpl_evt = BTA_GATTC_WRITE_DESCR_EVT;
 479     p_buf->write_type = write_type;
 480
 481     if (p_data && p_data->len != 0) {
 482         p_buf->p_value  = (UINT8 *)(p_buf + 1);
 483         p_buf->len      = p_data->len;
 484         /* pack the descr data */
 485         memcpy(p_buf->p_value, p_data->p_value, p_data->len);
 486     }
 487
 488     bta_sys_sendmsg(p_buf);
 489 }
 490
 491 /*******************************************************************************
 492 **
 493 ** Function         BTA_GATTC_PrepareWrite
 494 **
 495 ** Description      This function is called to prepare write a characteristic value.
 496 **
 497 ** Parameters       conn_id - connection ID.
 498 **                    p_char_id - GATT characteritic ID of the service.
 499 **                  offset - offset of the write value.
 500 **                  len: length of the data to be written.
 501 **                  p_value - the value to be written.
 502 **
 503 ** Returns          None
 504 **
 505 *******************************************************************************/
 506 void BTA_GATTC_PrepareWrite  (UINT16 conn_id, UINT16 handle,
 507                               UINT16 offset, UINT16 len, UINT8 *p_value,
 508                               tBTA_GATT_AUTH_REQ auth_req)
 509 {
 510     tBTA_GATTC_API_WRITE *p_buf =
 511         (tBTA_GATTC_API_WRITE *)osi_calloc(sizeof(tBTA_GATTC_API_WRITE) + len);
 512
 513     p_buf->hdr.event = BTA_GATTC_API_WRITE_EVT;
 514     p_buf->hdr.layer_specific = conn_id;
 515     p_buf->auth_req = auth_req;
 516     p_buf->handle = handle;
 517
 518     p_buf->write_type = BTA_GATTC_WRITE_PREPARE;
 519     p_buf->offset   = offset;
 520     p_buf->len = len;
 521
 522     if (p_value && len > 0) {
 523         p_buf->p_value = (UINT8 *)(p_buf + 1);
 524         memcpy(p_buf->p_value, p_value, len);
 525     }
 526
 527     bta_sys_sendmsg(p_buf);
 528 }
 529
 530 /*******************************************************************************
 531 **
 532 ** Function         BTA_GATTC_ExecuteWrite
 533 **
 534 ** Description      This function is called to execute write a prepare write sequence.
 535 **
 536 ** Parameters       conn_id - connection ID.
 537 **                    is_execute - execute or cancel.
 538 **
 539 ** Returns          None
 540 **
 541 *******************************************************************************/
 542 void BTA_GATTC_ExecuteWrite  (UINT16 conn_id, BOOLEAN is_execute)
 543 {
 544     tBTA_GATTC_API_EXEC *p_buf =
 545         (tBTA_GATTC_API_EXEC *)osi_calloc(sizeof(tBTA_GATTC_API_EXEC));
 546
 547     p_buf->hdr.event = BTA_GATTC_API_EXEC_EVT;
 548     p_buf->hdr.layer_specific = conn_id;
 549     p_buf->is_execute = is_execute;
 550
 551     bta_sys_sendmsg(p_buf);
 552 }
 553
 554 /*******************************************************************************
 555 **
 556 ** Function         BTA_GATTC_SendIndConfirm
 557 **
 558 ** Description      This function is called to send handle value confirmation.
 559 **
 560 ** Parameters       conn_id - connection ID.
 561 **                    p_char_id - characteristic ID to confirm.
 562 **
 563 ** Returns          None
 564 **
 565 *******************************************************************************/
 566 void BTA_GATTC_SendIndConfirm (UINT16 conn_id, UINT16 handle)
 567 {
 568     tBTA_GATTC_API_CONFIRM *p_buf =
 569         (tBTA_GATTC_API_CONFIRM *)osi_calloc(sizeof(tBTA_GATTC_API_CONFIRM));
 570
 571     APPL_TRACE_API("%s conn_id=%d handle=0x%04x", __func__, conn_id, handle);
 572
 573     p_buf->hdr.event = BTA_GATTC_API_CONFIRM_EVT;
 574     p_buf->hdr.layer_specific = conn_id;
 575     p_buf->handle = handle;
 576
 577     bta_sys_sendmsg(p_buf);
 578 }
 579
 580 /*******************************************************************************
 581 **
 582 ** Function         BTA_GATTC_RegisterForNotifications
 583 **
 584 ** Description      This function is called to register for notification of a service.
 585 **
 586 ** Parameters       client_if - client interface.
 587 **                  bda - target GATT server.
 588 **                  handle - GATT characteristic handle.
 589 **
 590 ** Returns          OK if registration succeed, otherwise failed.
 591 **
 592 *******************************************************************************/
 593 tBTA_GATT_STATUS BTA_GATTC_RegisterForNotifications (tBTA_GATTC_IF client_if,
 594                                                      BD_ADDR bda, UINT16 handle)
 595 {
 596     tBTA_GATTC_RCB      *p_clreg;
 597     tBTA_GATT_STATUS    status = BTA_GATT_ILLEGAL_PARAMETER;
 598     UINT8               i;
 599
 600     if (!handle)
 601     {
 602         APPL_TRACE_ERROR("deregistration failed, handle is 0");
 603         return status;
 604     }
 605
 606     if ((p_clreg = bta_gattc_cl_get_regcb(client_if)) != NULL)
 607     {
 608         for (i = 0; i < BTA_GATTC_NOTIF_REG_MAX; i ++)
 609         {
 610             if ( p_clreg->notif_reg[i].in_use &&
 611                  !memcmp(p_clreg->notif_reg[i].remote_bda, bda, BD_ADDR_LEN) &&
 612                   p_clreg->notif_reg[i].handle == handle)
 613             {
 614                 APPL_TRACE_WARNING("notification already registered");
 615                 status = BTA_GATT_OK;
 616                 break;
 617             }
 618         }
 619         if (status != BTA_GATT_OK)
 620         {
 621             for (i = 0; i < BTA_GATTC_NOTIF_REG_MAX; i ++)
 622             {
 623                 if (!p_clreg->notif_reg[i].in_use)
 624                 {
 625                     memset((void *)&p_clreg->notif_reg[i], 0, sizeof(tBTA_GATTC_NOTIF_REG));
 626
 627                     p_clreg->notif_reg[i].in_use = TRUE;
 628                     memcpy(p_clreg->notif_reg[i].remote_bda, bda, BD_ADDR_LEN);
 629
 630                     p_clreg->notif_reg[i].handle = handle;
 631                     status = BTA_GATT_OK;
 632                     break;
 633                 }
 634             }
 635             if (i == BTA_GATTC_NOTIF_REG_MAX)
 636             {
 637                 status = BTA_GATT_NO_RESOURCES;
 638                 APPL_TRACE_ERROR("Max Notification Reached, registration failed.");
 639             }
 640         }
 641     }
 642     else
 643     {
 644         APPL_TRACE_ERROR("Client_if: %d Not Registered", client_if);
 645     }
 646
 647     return status;
 648 }
 649
 650 /*******************************************************************************
 651 **
 652 ** Function         BTA_GATTC_DeregisterForNotifications
 653 **
 654 ** Description      This function is called to de-register for notification of a servbice.
 655 **
 656 ** Parameters       client_if - client interface.
 657 **                  remote_bda - target GATT server.
 658 **                  handle - GATT characteristic handle.
 659 **
 660 ** Returns          OK if deregistration succeed, otherwise failed.
 661 **
 662 *******************************************************************************/
 663 tBTA_GATT_STATUS BTA_GATTC_DeregisterForNotifications (tBTA_GATTC_IF client_if,
 664                                                        BD_ADDR bda, UINT16 handle)
 665 {
 666     if (!handle) {
 667         APPL_TRACE_ERROR("%s: deregistration failed, handle is 0", __func__);
 668         return BTA_GATT_ILLEGAL_PARAMETER;
 669     }
 670
 671     tBTA_GATTC_RCB *p_clreg = bta_gattc_cl_get_regcb(client_if);
 672     if (p_clreg == NULL) {
 673         APPL_TRACE_ERROR("%s client_if: %d not registered bd_addr:%02x:%02x:%02x:%02x:%02x:%02x",
 674             __func__, client_if, bda[0], bda[1], bda[2], bda[3], bda[4], bda[5]);
 675         return BTA_GATT_ILLEGAL_PARAMETER;
 676     }
 677
 678     for (int i = 0; i < BTA_GATTC_NOTIF_REG_MAX; i ++) {
 679         if (p_clreg->notif_reg[i].in_use &&
 680             !memcmp(p_clreg->notif_reg[i].remote_bda, bda, BD_ADDR_LEN) &&
 681             p_clreg->notif_reg[i].handle == handle) {
 682             APPL_TRACE_DEBUG("%s deregistered bd_addr:%02x:%02x:%02x:%02x:%02x:%02x",
 683                 __func__, bda[0], bda[1], bda[2], bda[3], bda[4], bda[5]);
 684             memset(&p_clreg->notif_reg[i], 0, sizeof(tBTA_GATTC_NOTIF_REG));
 685             return BTA_GATT_OK;
 686         }
 687     }
 688
 689     APPL_TRACE_ERROR("%s registration not found bd_addr:%02x:%02x:%02x:%02x:%02x:%02x",
 690         __func__, bda[0], bda[1], bda[2], bda[3], bda[4], bda[5]);
 691     return BTA_GATT_ERROR;
 692 }
 693
 694 /*******************************************************************************
 695 **
 696 ** Function         BTA_GATTC_Refresh
 697 **
 698 ** Description      Refresh the server cache of the remote device
 699 **
 700 ** Parameters       remote_bda: remote device BD address.
 701 **
 702 ** Returns          void
 703 **
 704 *******************************************************************************/
 705 void BTA_GATTC_Refresh(BD_ADDR remote_bda)
 706 {
 707     tBTA_GATTC_API_OPEN *p_buf =
 708         (tBTA_GATTC_API_OPEN *)osi_malloc(sizeof(tBTA_GATTC_API_OPEN));
 709
 710     p_buf->hdr.event = BTA_GATTC_API_REFRESH_EVT;
 711     memcpy(p_buf->remote_bda, remote_bda, BD_ADDR_LEN);
 712
 713     bta_sys_sendmsg(p_buf);
 714 }
 715
 716 /*******************************************************************************
 717 **
 718 ** Function         BTA_GATTC_Listen
 719 **
 720 ** Description      Start advertisement to listen for connection request for a GATT
 721 **                  client application.
 722 **
 723 ** Parameters       client_if: server interface.
 724 **                  start: to start or stop listening for connection
 725 **                  remote_bda: remote device BD address, if listen to all device
 726 **                              use NULL.
 727 **
 728 ** Returns          void
 729 **
 730 *******************************************************************************/
 731 void BTA_GATTC_Listen(tBTA_GATTC_IF client_if, BOOLEAN start, BD_ADDR_PTR target_bda)
 732 {
 733     tBTA_GATTC_API_LISTEN *p_buf =
 734         (tBTA_GATTC_API_LISTEN *)osi_malloc(sizeof(tBTA_GATTC_API_LISTEN) + BD_ADDR_LEN);
 735
 736     p_buf->hdr.event = BTA_GATTC_API_LISTEN_EVT;
 737     p_buf->client_if = client_if;
 738     p_buf->start = start;
 739     if (target_bda) {
 740         p_buf->remote_bda = (UINT8*)(p_buf + 1);
 741         memcpy(p_buf->remote_bda, target_bda, BD_ADDR_LEN);
 742     } else {
 743         p_buf->remote_bda = NULL;
 744     }
 745
 746     bta_sys_sendmsg(p_buf);
 747 }
 748
 749 /*******************************************************************************
 750 **
 751 ** Function         BTA_GATTC_Broadcast
 752 **
 753 ** Description      Start broadcasting (non-connectable advertisements)
 754 **
 755 ** Parameters       client_if: client interface.
 756 **                  start: to start or stop listening for connection
 757 **
 758 ** Returns          void
 759 **
 760 *******************************************************************************/
 761 void BTA_GATTC_Broadcast(tBTA_GATTC_IF client_if, BOOLEAN start)
 762 {
 763     tBTA_GATTC_API_LISTEN *p_buf =
 764         (tBTA_GATTC_API_LISTEN *)osi_malloc(sizeof(tBTA_GATTC_API_LISTEN) + BD_ADDR_LEN);
 765
 766     p_buf->hdr.event = BTA_GATTC_API_BROADCAST_EVT;
 767     p_buf->client_if = client_if;
 768     p_buf->start = start;
 769
 770     bta_sys_sendmsg(p_buf);
 771 }
 772
 773 #endif /* BTA_GATT_INCLUDED */