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 *******************************************************************************/
bta_gattc_enable(tBTA_GATTC_CB * p_cb)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 *******************************************************************************/
bta_gattc_disable(tBTA_GATTC_CB * p_cb)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 *******************************************************************************/
bta_gattc_register(tBTA_GATTC_CB * p_cb,tBTA_GATTC_DATA * p_data)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 *******************************************************************************/
bta_gattc_start_if(tBTA_GATTC_CB * p_cb,tBTA_GATTC_DATA * p_msg)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 *******************************************************************************/
bta_gattc_deregister(tBTA_GATTC_CB * p_cb,tBTA_GATTC_RCB * p_clreg)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 *******************************************************************************/
bta_gattc_process_api_open(tBTA_GATTC_CB * p_cb,tBTA_GATTC_DATA * p_msg)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 *******************************************************************************/
bta_gattc_process_api_open_cancel(tBTA_GATTC_CB * p_cb,tBTA_GATTC_DATA * p_msg)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 *******************************************************************************/
bta_gattc_process_enc_cmpl(tBTA_GATTC_CB * p_cb,tBTA_GATTC_DATA * p_msg)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 *******************************************************************************/
bta_gattc_cancel_open_error(tBTA_GATTC_CLCB * p_clcb,tBTA_GATTC_DATA * p_data)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 *******************************************************************************/
bta_gattc_open_error(tBTA_GATTC_CLCB * p_clcb,tBTA_GATTC_DATA * p_data)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 *******************************************************************************/
bta_gattc_open_fail(tBTA_GATTC_CLCB * p_clcb,tBTA_GATTC_DATA * p_data)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 *******************************************************************************/
bta_gattc_open(tBTA_GATTC_CLCB * p_clcb,tBTA_GATTC_DATA * p_data)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 *******************************************************************************/
bta_gattc_init_bk_conn(tBTA_GATTC_API_OPEN * p_data,tBTA_GATTC_RCB * p_clreg)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 *******************************************************************************/
bta_gattc_cancel_bk_conn(tBTA_GATTC_API_CANCEL_OPEN * p_data)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 *******************************************************************************/
bta_gattc_cancel_open_ok(tBTA_GATTC_CLCB * p_clcb,tBTA_GATTC_DATA * p_data)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 *******************************************************************************/
bta_gattc_cancel_open(tBTA_GATTC_CLCB * p_clcb,tBTA_GATTC_DATA * p_data)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 *******************************************************************************/
bta_gattc_conn(tBTA_GATTC_CLCB * p_clcb,tBTA_GATTC_DATA * p_data)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 *******************************************************************************/
bta_gattc_close_fail(tBTA_GATTC_CLCB * p_clcb,tBTA_GATTC_DATA * p_data)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 *******************************************************************************/
bta_gattc_close(tBTA_GATTC_CLCB * p_clcb,tBTA_GATTC_DATA * p_data)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 *******************************************************************************/
bta_gattc_reset_discover_st(tBTA_GATTC_SERV * p_srcb,tBTA_GATT_STATUS status)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 *******************************************************************************/
bta_gattc_disc_close(tBTA_GATTC_CLCB * p_clcb,tBTA_GATTC_DATA * p_data)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 *******************************************************************************/
bta_gattc_set_discover_st(tBTA_GATTC_SERV * p_srcb)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 *******************************************************************************/
bta_gattc_restart_discover(tBTA_GATTC_CLCB * p_clcb,tBTA_GATTC_DATA * p_data)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 *******************************************************************************/
bta_gattc_cfg_mtu(tBTA_GATTC_CLCB * p_clcb,tBTA_GATTC_DATA * p_data)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 *******************************************************************************/
bta_gattc_start_discover(tBTA_GATTC_CLCB * p_clcb,tBTA_GATTC_DATA * p_data)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 *******************************************************************************/
bta_gattc_disc_cmpl(tBTA_GATTC_CLCB * p_clcb,tBTA_GATTC_DATA * p_data)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 *******************************************************************************/
bta_gattc_read(tBTA_GATTC_CLCB * p_clcb,tBTA_GATTC_DATA * p_data)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 *********************************************************************************/
bta_gattc_read_multi(tBTA_GATTC_CLCB * p_clcb,tBTA_GATTC_DATA * p_data)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 *******************************************************************************/
bta_gattc_write(tBTA_GATTC_CLCB * p_clcb,tBTA_GATTC_DATA * p_data)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 *********************************************************************************/
bta_gattc_execute(tBTA_GATTC_CLCB * p_clcb,tBTA_GATTC_DATA * p_data)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 *******************************************************************************/
bta_gattc_confirm(tBTA_GATTC_CLCB * p_clcb,tBTA_GATTC_DATA * p_data)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 *******************************************************************************/
bta_gattc_read_cmpl(tBTA_GATTC_CLCB * p_clcb,tBTA_GATTC_OP_CMPL * p_data)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 *******************************************************************************/
bta_gattc_write_cmpl(tBTA_GATTC_CLCB * p_clcb,tBTA_GATTC_OP_CMPL * p_data)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 *******************************************************************************/
bta_gattc_exec_cmpl(tBTA_GATTC_CLCB * p_clcb,tBTA_GATTC_OP_CMPL * p_data)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 *******************************************************************************/
bta_gattc_cfg_mtu_cmpl(tBTA_GATTC_CLCB * p_clcb,tBTA_GATTC_OP_CMPL * p_data)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 *******************************************************************************/
bta_gattc_op_cmpl(tBTA_GATTC_CLCB * p_clcb,tBTA_GATTC_DATA * p_data)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 *******************************************************************************/
bta_gattc_ignore_op_cmpl(tBTA_GATTC_CLCB * p_clcb,tBTA_GATTC_DATA * p_data)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 *******************************************************************************/
bta_gattc_search(tBTA_GATTC_CLCB * p_clcb,tBTA_GATTC_DATA * p_data)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 *******************************************************************************/
bta_gattc_q_cmd(tBTA_GATTC_CLCB * p_clcb,tBTA_GATTC_DATA * p_data)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 *******************************************************************************/
bta_gattc_cache_open(tBTA_GATTC_CLCB * p_clcb,tBTA_GATTC_DATA * p_data)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 *******************************************************************************/
bta_gattc_ci_open(tBTA_GATTC_CLCB * p_clcb,tBTA_GATTC_DATA * p_data)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 *******************************************************************************/
bta_gattc_ci_load(tBTA_GATTC_CLCB * p_clcb,tBTA_GATTC_DATA * p_data)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 *******************************************************************************/
bta_gattc_ci_save(tBTA_GATTC_CLCB * p_clcb,tBTA_GATTC_DATA * p_data)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 *******************************************************************************/
bta_gattc_fail(tBTA_GATTC_CLCB * p_clcb,tBTA_GATTC_DATA * p_data)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 *******************************************************************************/
bta_gattc_deregister_cmpl(tBTA_GATTC_RCB * p_clreg)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 *******************************************************************************/
bta_gattc_conn_cback(tGATT_IF gattc_if,BD_ADDR bda,UINT16 conn_id,BOOLEAN connected,tGATT_DISCONN_REASON reason,tBT_TRANSPORT transport)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 *******************************************************************************/
bta_gattc_enc_cmpl_cback(tGATT_IF gattc_if,BD_ADDR bda)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 *******************************************************************************/
bta_gattc_process_api_refresh(tBTA_GATTC_CB * p_cb,tBTA_GATTC_DATA * p_msg)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 *******************************************************************************/
bta_gattc_process_srvc_chg_ind(UINT16 conn_id,tBTA_GATTC_RCB * p_clrcb,tBTA_GATTC_SERV * p_srcb,tBTA_GATTC_CLCB * p_clcb,tBTA_GATTC_NOTIFY * p_notify,UINT16 handle)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 *******************************************************************************/
bta_gattc_proc_other_indication(tBTA_GATTC_CLCB * p_clcb,UINT8 op,tGATT_CL_COMPLETE * p_data,tBTA_GATTC_NOTIFY * p_notify)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 *******************************************************************************/
bta_gattc_process_indicate(UINT16 conn_id,tGATTC_OPTYPE op,tGATT_CL_COMPLETE * p_data)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                             &notify.char_id.srvc_id,
2084                             &notify.char_id.char_id,
2085                             &notify.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, &notify, handle))
2089         {
2090             /* if app registered for the notification */
2091             if (bta_gattc_check_notif_registry(p_clrcb, p_srcb, &notify))
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, &notify);
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 *******************************************************************************/
bta_gattc_cmpl_cback(UINT16 conn_id,tGATTC_OPTYPE op,tGATT_STATUS status,tGATT_CL_COMPLETE * p_data)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 ********************************************************************************/
bta_gattc_cong_cback(UINT16 conn_id,BOOLEAN congested)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 ********************************************************************************/
bta_gattc_init_clcb_conn(UINT8 cif,BD_ADDR remote_bda)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 ********************************************************************************/
bta_gattc_process_listen_all(UINT8 cif)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 ********************************************************************************/
bta_gattc_listen(tBTA_GATTC_CB * p_cb,tBTA_GATTC_DATA * p_msg)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 ********************************************************************************/
bta_gattc_broadcast(tBTA_GATTC_CB * p_cb,tBTA_GATTC_DATA * p_msg)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