1 /******************************************************************************
2  *
3  *  Copyright (C) 2010-2012 Broadcom Corporation
4  *
5  *  Licensed under the Apache License, Version 2.0 (the "License");
6  *  you may not use this file except in compliance with the License.
7  *  You may obtain a copy of the License at:
8  *
9  *  http://www.apache.org/licenses/LICENSE-2.0
10  *
11  *  Unless required by applicable law or agreed to in writing, software
12  *  distributed under the License is distributed on an "AS IS" BASIS,
13  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  *  See the License for the specific language governing permissions and
15  *  limitations under the License.
16  *
17  ******************************************************************************/
18 
19 /******************************************************************************
20  *
21  *  This is the implementation of the API for GATT module of BTA.
22  *
23  ******************************************************************************/
24 
25 #include "common/bt_target.h"
26 #include "osi/allocator.h"
27 
28 #if defined(GATTC_INCLUDED) && (GATTC_INCLUDED == TRUE)
29 
30 #include <string.h>
31 #include "bta/bta_sys.h"
32 #include "bta/bta_gatt_api.h"
33 #include "bta_gattc_int.h"
34 #include "stack/l2c_api.h"
35 /*****************************************************************************
36 **  Constants
37 *****************************************************************************/
38 
39 static const tBTA_SYS_REG bta_gattc_reg = {
40     bta_gattc_hdl_event,
41     BTA_GATTC_Disable
42 };
43 
44 
45 /*******************************************************************************
46 **
47 ** Function         BTA_GATTC_Disable
48 **
49 ** Description      This function is called to disable GATTC module
50 **
51 ** Parameters       None.
52 **
53 ** Returns          None
54 **
55 *******************************************************************************/
BTA_GATTC_Disable(void)56 void BTA_GATTC_Disable(void)
57 {
58     BT_HDR  *p_buf;
59 
60     if (bta_sys_is_register(BTA_ID_GATTC) == FALSE) {
61         APPL_TRACE_WARNING("GATTC Module not enabled/already disabled\n");
62         return;
63     }
64     if ((p_buf = (BT_HDR *) osi_malloc(sizeof(BT_HDR))) != NULL) {
65         p_buf->event = BTA_GATTC_API_DISABLE_EVT;
66         bta_sys_sendmsg(p_buf);
67     }
68     bta_sys_deregister(BTA_ID_GATTC);
69 
70 }
71 
72 /*******************************************************************************
73 **
74 ** Function         BTA_GATTC_AppRegister
75 **
76 ** Description      This function is called to register application callbacks
77 **                    with BTA GATTC module.
78 **
79 ** Parameters       p_app_uuid - application UUID
80 **                  p_client_cb - pointer to the application callback function.
81 **
82 ** Returns          None
83 **
84 *******************************************************************************/
BTA_GATTC_AppRegister(tBT_UUID * p_app_uuid,tBTA_GATTC_CBACK * p_client_cb)85 void BTA_GATTC_AppRegister(tBT_UUID *p_app_uuid, tBTA_GATTC_CBACK *p_client_cb)
86 {
87     tBTA_GATTC_API_REG  *p_buf;
88 
89     if (bta_sys_is_register(BTA_ID_GATTC) == FALSE) {
90         bta_sys_register(BTA_ID_GATTC, &bta_gattc_reg);
91     }
92 
93     if ((p_buf = (tBTA_GATTC_API_REG *) osi_malloc(sizeof(tBTA_GATTC_API_REG))) != NULL) {
94         p_buf->hdr.event    = BTA_GATTC_API_REG_EVT;
95         if (p_app_uuid != NULL) {
96             memcpy(&p_buf->app_uuid, p_app_uuid, sizeof(tBT_UUID));
97         }
98         p_buf->p_cback      = p_client_cb;
99 
100         bta_sys_sendmsg(p_buf);
101     }
102     return;
103 }
104 
105 /*******************************************************************************
106 **
107 ** Function         BTA_GATTC_AppDeregister
108 **
109 ** Description      This function is called to deregister an application
110 **                  from BTA GATTC module.
111 **
112 ** Parameters       client_if - client interface identifier.
113 **
114 ** Returns          None
115 **
116 *******************************************************************************/
BTA_GATTC_AppDeregister(tBTA_GATTC_IF client_if)117 void BTA_GATTC_AppDeregister(tBTA_GATTC_IF client_if)
118 {
119     tBTA_GATTC_API_DEREG  *p_buf;
120 
121     if ((p_buf = (tBTA_GATTC_API_DEREG *) osi_malloc(sizeof(tBTA_GATTC_API_DEREG))) != NULL) {
122         p_buf->hdr.event = BTA_GATTC_API_DEREG_EVT;
123         p_buf->client_if = client_if;
124         bta_sys_sendmsg(p_buf);
125     }
126     return;
127 }
128 
129 /*******************************************************************************
130 **
131 ** Function         BTA_GATTC_Enh_Open
132 **
133 ** Description      Open a direct connection or add a background auto connection
134 **                  bd address
135 **
136 ** Parameters       client_if: server interface.
137 **                  remote_bda: remote device BD address.
138 **                  remote_addr_type: remote device BD address type.
139 **                  is_direct: direct connection or background auto connection
140 **                  transport: Transport to be used for GATT connection (BREDR/LE)
141 **
142 ** Returns          void
143 **
144 *******************************************************************************/
BTA_GATTC_Enh_Open(tBTA_GATTC_IF client_if,BD_ADDR remote_bda,tBTA_ADDR_TYPE remote_addr_type,BOOLEAN is_direct,tBTA_GATT_TRANSPORT transport,BOOLEAN is_aux,tBTA_ADDR_TYPE own_addr_type,UINT8 phy_mask,tBTA_BLE_CONN_PARAMS * phy_1m_conn_params,tBTA_BLE_CONN_PARAMS * phy_2m_conn_params,tBTA_BLE_CONN_PARAMS * phy_coded_conn_params)145 void BTA_GATTC_Enh_Open(tBTA_GATTC_IF client_if, BD_ADDR remote_bda, tBTA_ADDR_TYPE remote_addr_type,
146                         BOOLEAN is_direct, tBTA_GATT_TRANSPORT transport, BOOLEAN is_aux, tBTA_ADDR_TYPE own_addr_type,
147                         UINT8 phy_mask, tBTA_BLE_CONN_PARAMS *phy_1m_conn_params, tBTA_BLE_CONN_PARAMS *phy_2m_conn_params,
148                         tBTA_BLE_CONN_PARAMS *phy_coded_conn_params)
149 {
150     tBTA_GATTC_API_OPEN  *p_buf;
151 
152     if ((p_buf = (tBTA_GATTC_API_OPEN *) osi_malloc(sizeof(tBTA_GATTC_API_OPEN))) != NULL) {
153         p_buf->hdr.event = BTA_GATTC_API_OPEN_EVT;
154 
155         p_buf->client_if = client_if;
156         p_buf->is_direct = is_direct;
157         p_buf->transport = transport;
158         p_buf->is_aux = is_aux;
159         p_buf->remote_addr_type = remote_addr_type;
160         p_buf->own_addr_type = own_addr_type;
161         p_buf->phy_mask = phy_mask;
162         memcpy(p_buf->remote_bda, remote_bda, BD_ADDR_LEN);
163         if ((phy_mask & BTA_BLE_PHY_1M_MASK) && phy_1m_conn_params) {
164             memcpy(&p_buf->phy_1m_conn_params, phy_1m_conn_params, sizeof(tBTA_BLE_CONN_PARAMS));
165         }
166         if ((phy_mask & BTA_BLE_PHY_2M_MASK) && phy_2m_conn_params) {
167             memcpy(&p_buf->phy_2m_conn_params, phy_2m_conn_params, sizeof(tBTA_BLE_CONN_PARAMS));
168         }
169         if ((phy_mask & BTA_BLE_PHY_CODED_MASK) && phy_coded_conn_params) {
170             memcpy(&p_buf->phy_coded_conn_params, phy_coded_conn_params, sizeof(tBTA_BLE_CONN_PARAMS));
171         }
172 
173         bta_sys_sendmsg(p_buf);
174     }
175     return;
176 }
177 
178 /*******************************************************************************
179 **
180 ** Function         BTA_GATTC_CancelOpen
181 **
182 ** Description      Cancel a direct open connection or remove a background auto connection
183 **                  bd address
184 **
185 ** Parameters       client_if: server interface.
186 **                  remote_bda: remote device BD address.
187 **                  is_direct: direct connection or background auto connection
188 **
189 ** Returns          void
190 **
191 *******************************************************************************/
BTA_GATTC_CancelOpen(tBTA_GATTC_IF client_if,BD_ADDR remote_bda,BOOLEAN is_direct)192 void BTA_GATTC_CancelOpen(tBTA_GATTC_IF client_if, BD_ADDR remote_bda, BOOLEAN is_direct)
193 {
194     //If the registration callback is NULL, return
195     if(bta_sys_is_register(BTA_ID_GATTC) == FALSE) {
196         return;
197     }
198 
199     tBTA_GATTC_API_CANCEL_OPEN  *p_buf;
200 
201     if ((p_buf = (tBTA_GATTC_API_CANCEL_OPEN *) osi_malloc(sizeof(tBTA_GATTC_API_CANCEL_OPEN))) != NULL) {
202         p_buf->hdr.event = BTA_GATTC_API_CANCEL_OPEN_EVT;
203 
204         p_buf->client_if = client_if;
205         p_buf->is_direct = is_direct;
206         memcpy(p_buf->remote_bda, remote_bda, BD_ADDR_LEN);
207 
208         bta_sys_sendmsg(p_buf);
209     }
210     return;
211 }
212 
213 /*******************************************************************************
214 **
215 ** Function         BTA_GATTC_Close
216 **
217 ** Description      Close a connection to a GATT server.
218 **
219 ** Parameters       conn_id: connection ID to be closed.
220 **
221 ** Returns          void
222 **
223 *******************************************************************************/
BTA_GATTC_Close(UINT16 conn_id)224 void BTA_GATTC_Close(UINT16 conn_id)
225 {
226     BT_HDR  *p_buf;
227 
228     if ((p_buf = (BT_HDR *) osi_malloc(sizeof(BT_HDR))) != NULL) {
229         p_buf->event = BTA_GATTC_API_CLOSE_EVT;
230 
231         p_buf->layer_specific = conn_id;
232 
233         bta_sys_sendmsg(p_buf);
234     }
235     return;
236 
237 }
238 /*******************************************************************************
239 **
240 ** Function         BTA_GATTC_ConfigureMTU
241 **
242 ** Description      Configure the MTU size in the GATT channel. This can be done
243 **                  only once per connection.
244 **
245 ** Parameters       conn_id: connection ID.
246 **                  mtu: desired MTU size to use.
247 **
248 ** Returns          void
249 **
250 *******************************************************************************/
BTA_GATTC_ConfigureMTU(UINT16 conn_id)251 void BTA_GATTC_ConfigureMTU (UINT16 conn_id)
252 {
253     tBTA_GATTC_API_CFG_MTU  *p_buf;
254 
255     if ((p_buf = (tBTA_GATTC_API_CFG_MTU *) osi_malloc(sizeof(tBTA_GATTC_API_CFG_MTU))) != NULL) {
256         p_buf->hdr.event = BTA_GATTC_API_CFG_MTU_EVT;
257         p_buf->hdr.layer_specific = conn_id;
258 
259         bta_sys_sendmsg(p_buf);
260     }
261     return;
262 }
263 /*******************************************************************************
264 **
265 ** Function         BTA_GATTC_ServiceSearchRequest
266 **
267 ** Description      This function is called to request a GATT service discovery
268 **                    on a GATT server. This function report service search result
269 **                  by a callback event, and followed by a service search complete
270 **                  event.
271 **
272 ** Parameters       conn_id: connection ID.
273 **                  p_srvc_uuid: a UUID of the service application is interested in.
274 **                              If Null, discover for all services.
275 **
276 ** Returns          None
277 **
278 *******************************************************************************/
BTA_GATTC_ServiceSearchRequest(UINT16 conn_id,tBT_UUID * p_srvc_uuid)279 void BTA_GATTC_ServiceSearchRequest (UINT16 conn_id, tBT_UUID *p_srvc_uuid)
280 {
281     tBTA_GATTC_API_SEARCH  *p_buf;
282     UINT16  len = sizeof(tBTA_GATTC_API_SEARCH) + sizeof(tBT_UUID);
283 
284     if ((p_buf = (tBTA_GATTC_API_SEARCH *) osi_malloc(len)) != NULL) {
285         memset(p_buf, 0, len);
286 
287         p_buf->hdr.event = BTA_GATTC_API_SEARCH_EVT;
288         p_buf->hdr.layer_specific = conn_id;
289 
290         if (p_srvc_uuid) {
291             p_buf->p_srvc_uuid = (tBT_UUID *)(p_buf + 1);
292             memcpy(p_buf->p_srvc_uuid, p_srvc_uuid, sizeof(tBT_UUID));
293         } else {
294             p_buf->p_srvc_uuid = NULL;
295         }
296 
297         bta_sys_sendmsg(p_buf);
298     }
299     return;
300 }
301 
302 
303 /*******************************************************************************
304 **
305 ** Function         BTA_GATTC_GetServices
306 **
307 ** Description      This function is called to find the services on the given server.
308 **
309 ** Parameters       conn_id: connection ID which identify the server.
310 **
311 ** Returns          returns list_t of tBTA_GATTC_SERVICE or NULL.
312 **
313 *******************************************************************************/
BTA_GATTC_GetServices(UINT16 conn_id)314 const list_t* BTA_GATTC_GetServices(UINT16 conn_id)
315 {
316     return bta_gattc_get_services(conn_id);
317 }
318 
319 /*******************************************************************************
320 **
321 ** Function         BTA_GATTC_GetCharacteristic
322 **
323 ** Description      This function is called to find the characteristic on the given server.
324 **
325 ** Parameters       conn_id - connection ID which identify the server.
326 **                  handle - characteristic handle
327 **
328 ** Returns          returns pointer to tBTA_GATTC_CHARACTERISTIC or NULL.
329 **
330 *******************************************************************************/
BTA_GATTC_GetCharacteristic(UINT16 conn_id,UINT16 handle)331 const tBTA_GATTC_CHARACTERISTIC* BTA_GATTC_GetCharacteristic(UINT16 conn_id, UINT16 handle)
332 {
333     return bta_gattc_get_characteristic(conn_id, handle);
334 }
335 
336 /*******************************************************************************
337 **
338 ** Function         BTA_GATTC_GetDescriptor
339 **
340 ** Description      This function is called to find the characteristic on the given server.
341 **
342 ** Parameters       conn_id - connection ID which identify the server.
343 **                  handle - descriptor handle
344 **
345 ** Returns          returns pointer to tBTA_GATTC_DESCRIPTOR or NULL.
346 **
347 *******************************************************************************/
BTA_GATTC_GetDescriptor(UINT16 conn_id,UINT16 handle)348 const tBTA_GATTC_DESCRIPTOR* BTA_GATTC_GetDescriptor(UINT16 conn_id, UINT16 handle)
349 {
350     return bta_gattc_get_descriptor(conn_id, handle);
351 }
352 
BTA_GATTC_GetServiceWithUUID(UINT16 conn_id,tBT_UUID * svc_uuid,btgatt_db_element_t ** db,UINT16 * count)353 void BTA_GATTC_GetServiceWithUUID(UINT16 conn_id, tBT_UUID *svc_uuid,
354                                   btgatt_db_element_t **db, UINT16 *count)
355 {
356     bta_gattc_get_service_with_uuid(conn_id, svc_uuid, db, count);
357 }
358 
BTA_GATTC_GetAllChar(UINT16 conn_id,UINT16 start_handle,UINT16 end_handle,btgatt_db_element_t ** db,UINT16 * count)359 void BTA_GATTC_GetAllChar(UINT16 conn_id, UINT16 start_handle, UINT16 end_handle,
360                           btgatt_db_element_t **db, UINT16 *count)
361 {
362     bta_gattc_get_db_with_opration(conn_id,
363                                    GATT_OP_GET_ALL_CHAR,
364                                    0,
365                                    NULL,
366                                    NULL,
367                                    NULL,
368                                    start_handle,
369                                    end_handle,
370                                    db,
371                                    count);
372 }
373 
BTA_GATTC_GetAllDescriptor(UINT16 conn_id,UINT16 char_handle,btgatt_db_element_t ** db,UINT16 * count)374 void BTA_GATTC_GetAllDescriptor(UINT16 conn_id, UINT16 char_handle,
375                                 btgatt_db_element_t **db, UINT16 *count)
376 {
377     bta_gattc_get_db_with_opration(conn_id,
378                                    GATT_OP_GET_ALL_DESCRI,
379                                    char_handle,
380                                    NULL,
381                                    NULL,
382                                    NULL,
383                                    0,
384                                    0xFFFF,
385                                    db,
386                                    count);
387 }
388 
BTA_GATTC_GetCharByUUID(UINT16 conn_id,UINT16 start_handle,UINT16 end_handle,tBT_UUID char_uuid,btgatt_db_element_t ** db,UINT16 * count)389 void BTA_GATTC_GetCharByUUID(UINT16 conn_id, UINT16 start_handle, UINT16 end_handle, tBT_UUID char_uuid,
390                              btgatt_db_element_t **db, UINT16 *count)
391 {
392     bta_gattc_get_db_with_opration(conn_id,
393                                    GATT_OP_GET_CHAR_BY_UUID,
394                                    0,
395                                    NULL,
396                                    &char_uuid,
397                                    NULL,
398                                    start_handle,
399                                    end_handle,
400                                    db,
401                                    count);
402 }
403 
BTA_GATTC_GetDescrByUUID(UINT16 conn_id,uint16_t start_handle,uint16_t end_handle,tBT_UUID char_uuid,tBT_UUID descr_uuid,btgatt_db_element_t ** db,UINT16 * count)404 void BTA_GATTC_GetDescrByUUID(UINT16 conn_id, uint16_t start_handle, uint16_t end_handle,
405                               tBT_UUID char_uuid, tBT_UUID descr_uuid,
406                               btgatt_db_element_t **db, UINT16 *count)
407 {
408     bta_gattc_get_db_with_opration(conn_id,
409                                    GATT_OP_GET_DESCRI_BY_UUID,
410                                    0,
411                                    NULL,
412                                    &char_uuid,
413                                    &descr_uuid,
414                                    start_handle,
415                                    end_handle,
416                                    db,
417                                    count);
418 }
419 
BTA_GATTC_GetDescrByCharHandle(UINT16 conn_id,UINT16 char_handle,tBT_UUID descr_uuid,btgatt_db_element_t ** db,UINT16 * count)420 void BTA_GATTC_GetDescrByCharHandle(UINT16 conn_id, UINT16 char_handle, tBT_UUID descr_uuid,
421                                     btgatt_db_element_t **db, UINT16 *count)
422 {
423     bta_gattc_get_db_with_opration(conn_id,
424                                    GATT_OP_GET_DESCRI_BY_HANDLE,
425                                    char_handle,
426                                    NULL,
427                                    NULL,
428                                    &descr_uuid,
429                                    0,
430                                    0xFFFF,
431                                    db,
432                                    count);
433 }
434 
BTA_GATTC_GetIncludeService(UINT16 conn_id,UINT16 start_handle,UINT16 end_handle,tBT_UUID * incl_uuid,btgatt_db_element_t ** db,UINT16 * count)435 void BTA_GATTC_GetIncludeService(UINT16 conn_id, UINT16 start_handle, UINT16 end_handle,
436                                  tBT_UUID *incl_uuid, btgatt_db_element_t **db, UINT16 *count)
437 {
438     bta_gattc_get_db_with_opration(conn_id,
439                                    GATT_OP_GET_INCLUDE_SVC,
440                                    0,
441                                    incl_uuid,
442                                    NULL,
443                                    NULL,
444                                    start_handle,
445                                    end_handle,
446                                    db,
447                                    count);
448 }
449 
BTA_GATTC_GetDBSize(UINT16 conn_id,UINT16 start_handle,UINT16 end_handle,UINT16 * count)450 void BTA_GATTC_GetDBSize(UINT16 conn_id, UINT16 start_handle, UINT16 end_handle, UINT16 *count)
451 {
452     bta_gattc_get_db_size_handle(conn_id, start_handle, end_handle, count);
453 }
454 
BTA_GATTC_GetDBSizeByType(UINT16 conn_id,bt_gatt_db_attribute_type_t type,UINT16 start_handle,UINT16 end_handle,UINT16 char_handle,UINT16 * count)455 void BTA_GATTC_GetDBSizeByType(UINT16 conn_id, bt_gatt_db_attribute_type_t type,
456                                UINT16 start_handle, UINT16 end_handle, UINT16 char_handle, UINT16 *count)
457 {
458     bta_gattc_get_db_size_with_type_handle(conn_id, type, start_handle, end_handle, char_handle, count);
459 }
460 
461 
462 /*******************************************************************************
463 **
464 ** Function         BTA_GATTC_GetGattDb
465 **
466 ** Description      This function is called to get the GATT database.
467 **
468 ** Parameters       conn_id: connection ID which identify the server.
469 **                  db: output parameter which will contain the GATT database copy.
470 **                      Caller is responsible for freeing it.
471 **                  count: number of elements in database.
472 **
473 *******************************************************************************/
BTA_GATTC_GetGattDb(UINT16 conn_id,UINT16 start_handle,UINT16 end_handle,btgatt_db_element_t ** db,UINT16 * count)474 void  BTA_GATTC_GetGattDb(UINT16 conn_id, UINT16 start_handle, UINT16 end_handle,
475                           btgatt_db_element_t **db, UINT16 *count)
476 {
477     bta_gattc_get_gatt_db(conn_id, start_handle, end_handle, db, count);
478 }
479 
480 /*******************************************************************************
481 **
482 ** Function         BTA_GATTC_ReadCharacteristic
483 **
484 ** Description      This function is called to read a characteristics value
485 **
486 ** Parameters       conn_id - connection ID.
487 **                  handle - characteristic handle to read.
488 **
489 ** Returns          None
490 **
491 *******************************************************************************/
BTA_GATTC_ReadCharacteristic(UINT16 conn_id,UINT16 handle,tBTA_GATT_AUTH_REQ auth_req)492 void BTA_GATTC_ReadCharacteristic(UINT16 conn_id, UINT16 handle, tBTA_GATT_AUTH_REQ auth_req)
493 {
494     tBTA_GATTC_API_READ  *p_buf;
495 
496     if ((p_buf = (tBTA_GATTC_API_READ *) osi_malloc(sizeof(tBTA_GATTC_API_READ))) != NULL) {
497         memset(p_buf, 0, sizeof(tBTA_GATTC_API_READ));
498 
499         p_buf->hdr.event = BTA_GATTC_API_READ_EVT;
500         p_buf->hdr.layer_specific = conn_id;
501         p_buf->auth_req = auth_req;
502         p_buf->handle = handle;
503         p_buf->cmpl_evt = BTA_GATTC_READ_CHAR_EVT;
504 
505         bta_sys_sendmsg(p_buf);
506     }
507     return;
508 }
509 
510 /*******************************************************************************
511 **
512 ** Function         BTA_GATTC_ReadCharDescr
513 **
514 ** Description      This function is called to read a descriptor value.
515 **
516 ** Parameters       conn_id - connection ID.
517 **                  handle - descriptor handle to read.
518 **
519 ** Returns          None
520 **
521 *******************************************************************************/
BTA_GATTC_ReadCharDescr(UINT16 conn_id,UINT16 handle,tBTA_GATT_AUTH_REQ auth_req)522 void BTA_GATTC_ReadCharDescr (UINT16 conn_id, UINT16 handle, tBTA_GATT_AUTH_REQ auth_req)
523 {
524     tBTA_GATTC_API_READ  *p_buf;
525     UINT16  len = (UINT16)(sizeof(tBTA_GATT_ID) + sizeof(tBTA_GATTC_API_READ));
526 
527     if ((p_buf = (tBTA_GATTC_API_READ *) osi_malloc(len)) != NULL) {
528         memset(p_buf, 0, sizeof(tBTA_GATTC_API_READ));
529 
530         p_buf->hdr.event = BTA_GATTC_API_READ_EVT;
531         p_buf->hdr.layer_specific = conn_id;
532         p_buf->auth_req = auth_req;
533         p_buf->handle = handle;
534         p_buf->cmpl_evt = BTA_GATTC_READ_DESCR_EVT;
535 
536         bta_sys_sendmsg(p_buf);
537     }
538     return;
539 
540 }
541 /*******************************************************************************
542 **
543 ** Function         BTA_GATTC_ReadMultiple
544 **
545 ** Description      This function is called to read multiple characteristic or
546 **                  characteristic descriptors.
547 **
548 ** Parameters       conn_id - connection ID.
549 **                    p_read_multi - pointer to the read multiple parameter.
550 **
551 ** Returns          None
552 **
553 *******************************************************************************/
BTA_GATTC_ReadMultiple(UINT16 conn_id,tBTA_GATTC_MULTI * p_read_multi,tBTA_GATT_AUTH_REQ auth_req)554 void BTA_GATTC_ReadMultiple(UINT16 conn_id, tBTA_GATTC_MULTI *p_read_multi,
555                             tBTA_GATT_AUTH_REQ auth_req)
556 {
557     tBTA_GATTC_API_READ_MULTI  *p_buf;
558     //tBTA_GATTC_API_READ_MULTI          *p_value;
559     UINT16      len = (UINT16)(sizeof(tBTA_GATTC_API_READ_MULTI));
560 
561     if ((p_buf = (tBTA_GATTC_API_READ_MULTI *) osi_malloc(len)) != NULL) {
562         memset(p_buf, 0, len);
563 
564         p_buf->hdr.event = BTA_GATTC_API_READ_MULTI_EVT;
565         p_buf->hdr.layer_specific = conn_id;
566         p_buf->auth_req = auth_req;
567         p_buf->num_attr = p_read_multi->num_attr;
568         p_buf->cmpl_evt = BTA_GATTC_READ_MULTIPLE_EVT;
569         if (p_buf->num_attr > 0) {
570             memcpy(p_buf->handles, p_read_multi->handles, sizeof(UINT16) * p_read_multi->num_attr);
571 	    }
572 
573         bta_sys_sendmsg(p_buf);
574     }
575     return;
576 }
577 
578 /*******************************************************************************
579 **
580 ** Function         BTA_GATTC_ReadMultipleVariable
581 **
582 ** Description      This function is called to read multiple variable length characteristic or
583 **                  characteristic descriptors.
584 **
585 ** Parameters       conn_id - connection ID.
586 **                    p_read_multi - pointer to the read multiple parameter.
587 **
588 ** Returns          None
589 **
590 *******************************************************************************/
BTA_GATTC_ReadMultipleVariable(UINT16 conn_id,tBTA_GATTC_MULTI * p_read_multi,tBTA_GATT_AUTH_REQ auth_req)591 void BTA_GATTC_ReadMultipleVariable(UINT16 conn_id, tBTA_GATTC_MULTI *p_read_multi,
592                             tBTA_GATT_AUTH_REQ auth_req)
593 {
594     tBTA_GATTC_API_READ_MULTI  *p_buf;
595     UINT16 len = (UINT16)(sizeof(tBTA_GATTC_API_READ_MULTI));
596 
597     if ((p_buf = (tBTA_GATTC_API_READ_MULTI *) osi_malloc(len)) != NULL) {
598         memset(p_buf, 0, len);
599 
600         p_buf->hdr.event = BTA_GATTC_API_READ_MULTI_VAR_EVT;
601         p_buf->hdr.layer_specific = conn_id;
602         p_buf->auth_req = auth_req;
603         p_buf->num_attr = p_read_multi->num_attr;
604         p_buf->cmpl_evt = BTA_GATTC_READ_MULTI_VAR_EVT;
605         if (p_buf->num_attr > 0) {
606             memcpy(p_buf->handles, p_read_multi->handles, sizeof(UINT16) * p_read_multi->num_attr);
607 	    }
608 
609         bta_sys_sendmsg(p_buf);
610     }
611     return;
612 }
613 
614 /*******************************************************************************
615 **
616 ** Function         BTA_GATTC_Read_by_type
617 **
618 ** Description      This function is called to read a attribute value by uuid
619 **
620 ** Parameters       conn_id - connection ID.
621 **                  s_handle - start handle.
622 **                  e_handle - end handle
623 **                  uuid - The attribute UUID.
624 **
625 ** Returns          None
626 **
627 *******************************************************************************/
BTA_GATTC_Read_by_type(UINT16 conn_id,UINT16 s_handle,UINT16 e_handle,tBT_UUID * uuid,tBTA_GATT_AUTH_REQ auth_req)628 void BTA_GATTC_Read_by_type(UINT16 conn_id, UINT16 s_handle,UINT16 e_handle, tBT_UUID *uuid, tBTA_GATT_AUTH_REQ auth_req)
629 {
630     tBTA_GATTC_API_READ  *p_buf;
631 
632     if ((p_buf = (tBTA_GATTC_API_READ *) osi_malloc(sizeof(tBTA_GATTC_API_READ))) != NULL) {
633         memset(p_buf, 0, sizeof(tBTA_GATTC_API_READ));
634 
635         p_buf->hdr.event = BTA_GATTC_API_READ_BY_TYPE_EVT;
636         p_buf->hdr.layer_specific = conn_id;
637         p_buf->auth_req = auth_req;
638         p_buf->s_handle = s_handle;
639         p_buf->e_handle = e_handle;
640         memcpy(&(p_buf->uuid), uuid, sizeof(tBT_UUID));
641         p_buf->cmpl_evt = BTA_GATTC_READ_CHAR_EVT;
642 
643         bta_sys_sendmsg(p_buf);
644     }
645     return;
646 }
647 
648 /*******************************************************************************
649 **
650 ** Function         BTA_GATTC_WriteCharValue
651 **
652 ** Description      This function is called to write characteristic value.
653 **
654 ** Parameters       conn_id - connection ID.
655 **                  handle - characteristic handle to write.
656 **                  write_type - type of write.
657 **                  len: length of the data to be written.
658 **                  p_value - the value to be written.
659 **
660 ** Returns          None
661 **
662 *******************************************************************************/
BTA_GATTC_WriteCharValue(UINT16 conn_id,UINT16 handle,tBTA_GATTC_WRITE_TYPE write_type,UINT16 len,UINT8 * p_value,tBTA_GATT_AUTH_REQ auth_req)663 void BTA_GATTC_WriteCharValue ( UINT16 conn_id,
664                                 UINT16 handle,
665                                 tBTA_GATTC_WRITE_TYPE  write_type,
666                                 UINT16 len,
667                                 UINT8 *p_value,
668                                 tBTA_GATT_AUTH_REQ auth_req)
669 {
670     tBTA_GATTC_API_WRITE  *p_buf;
671 
672     if ((p_buf = (tBTA_GATTC_API_WRITE *) osi_malloc((UINT16)(sizeof(tBTA_GATTC_API_WRITE) + len))) != NULL) {
673         memset(p_buf, 0, sizeof(tBTA_GATTC_API_WRITE) + len);
674 
675         p_buf->hdr.event = BTA_GATTC_API_WRITE_EVT;
676         p_buf->hdr.layer_specific = conn_id;
677         p_buf->auth_req = auth_req;
678         p_buf->handle = handle;
679         p_buf->cmpl_evt = BTA_GATTC_WRITE_CHAR_EVT;
680         p_buf->write_type = write_type;
681         p_buf->len = len;
682 
683         if (p_value && len > 0) {
684             p_buf->p_value = (UINT8 *)(p_buf + 1);
685             memcpy(p_buf->p_value, p_value, len);
686         }
687         if(write_type == BTA_GATTC_TYPE_WRITE_NO_RSP){
688             l2ble_update_att_acl_pkt_num(L2CA_DECREASE_BTC_NUM, NULL);
689             l2ble_update_att_acl_pkt_num(L2CA_ADD_BTU_NUM, NULL);
690         }
691         bta_sys_sendmsg(p_buf);
692     }
693     return;
694 }
695 /*******************************************************************************
696 **
697 ** Function         BTA_GATTC_WriteCharDescr
698 **
699 ** Description      This function is called to write descriptor value.
700 **
701 ** Parameters       conn_id - connection ID
702 **                  handle - descriptor handle to write.
703 **                  write_type - write type.
704 **                  p_value - the value to be written.
705 **
706 ** Returns          None
707 **
708 *******************************************************************************/
BTA_GATTC_WriteCharDescr(UINT16 conn_id,UINT16 handle,tBTA_GATTC_WRITE_TYPE write_type,tBTA_GATT_UNFMT * p_data,tBTA_GATT_AUTH_REQ auth_req)709 void BTA_GATTC_WriteCharDescr (UINT16 conn_id,
710                                UINT16 handle,
711                                tBTA_GATTC_WRITE_TYPE  write_type,
712                                tBTA_GATT_UNFMT      *p_data,
713                                tBTA_GATT_AUTH_REQ auth_req)
714 {
715     size_t len = sizeof(tBTA_GATTC_API_WRITE);
716     tBTA_GATTC_API_WRITE *p_buf;
717     if (p_data != NULL) {
718         len += p_data->len;
719     }
720 
721     if ((p_buf = (tBTA_GATTC_API_WRITE *) osi_malloc(len)) != NULL) {
722         memset(p_buf, 0, len);
723 
724         p_buf->hdr.event = BTA_GATTC_API_WRITE_EVT;
725         p_buf->hdr.layer_specific = conn_id;
726         p_buf->auth_req = auth_req;
727         p_buf->handle = handle;
728         p_buf->cmpl_evt = BTA_GATTC_WRITE_DESCR_EVT;
729         p_buf->write_type = write_type;
730 
731         if (p_data && p_data->len != 0) {
732             p_buf->p_value  = (UINT8 *)(p_buf + 1);
733             p_buf->len      = p_data->len;
734             /* pack the descr data */
735             memcpy(p_buf->p_value, p_data->p_value, p_data->len);
736         }
737         if(write_type == BTA_GATTC_TYPE_WRITE_NO_RSP){
738             l2ble_update_att_acl_pkt_num(L2CA_DECREASE_BTC_NUM, NULL);
739             l2ble_update_att_acl_pkt_num(L2CA_ADD_BTU_NUM, NULL);
740         }
741         bta_sys_sendmsg(p_buf);
742     }
743     return;
744 
745 }
746 /*******************************************************************************
747 **
748 ** Function         BTA_GATTC_PrepareWrite
749 **
750 ** Description      This function is called to prepare write a characteristic value.
751 **
752 ** Parameters       conn_id - connection ID.
753 **                    p_char_id - GATT characteristic ID of the service.
754 **                  offset - offset of the write value.
755 **                  len: length of the data to be written.
756 **                  p_value - the value to be written.
757 **
758 ** Returns          None
759 **
760 *******************************************************************************/
BTA_GATTC_PrepareWrite(UINT16 conn_id,UINT16 handle,UINT16 offset,UINT16 len,UINT8 * p_value,tBTA_GATT_AUTH_REQ auth_req)761 void BTA_GATTC_PrepareWrite  (UINT16 conn_id, UINT16 handle,
762                               UINT16 offset, UINT16 len, UINT8 *p_value,
763                               tBTA_GATT_AUTH_REQ auth_req)
764 {
765     tBTA_GATTC_API_WRITE  *p_buf;
766 
767     if ((p_buf = (tBTA_GATTC_API_WRITE *) osi_malloc((UINT16)(sizeof(tBTA_GATTC_API_WRITE) + len))) != NULL) {
768         memset(p_buf, 0, sizeof(tBTA_GATTC_API_WRITE) + len);
769 
770         p_buf->hdr.event = BTA_GATTC_API_WRITE_EVT;
771         p_buf->hdr.layer_specific = conn_id;
772         p_buf->auth_req = auth_req;
773         p_buf->handle = handle;
774 
775         p_buf->write_type = BTA_GATTC_WRITE_PREPARE;
776         p_buf->offset   = offset;
777         p_buf->len = len;
778 
779         if (p_value && len > 0) {
780             p_buf->p_value = (UINT8 *)(p_buf + 1);
781             memcpy(p_buf->p_value, p_value, len);
782         }
783 
784         bta_sys_sendmsg(p_buf);
785     }
786     return;
787 
788 }
789 /*******************************************************************************
790 **
791 ** Function         BTA_GATTC_PrepareWriteCharDescr
792 **
793 ** Description      This function is called to prepare write a characteristic descriptor value.
794 **
795 ** Parameters       conn_id - connection ID.
796 **                  p_char_descr_id - GATT characteristic descriptor ID of the service.
797 **                  offset - offset of the write value.
798 **                  len: length of the data to be written.
799 **                  p_value - the value to be written.
800 **
801 ** Returns          None
802 **
803 *******************************************************************************/
BTA_GATTC_PrepareWriteCharDescr(UINT16 conn_id,UINT16 handle,UINT16 offset,tBTA_GATT_UNFMT * p_data,tBTA_GATT_AUTH_REQ auth_req)804 void BTA_GATTC_PrepareWriteCharDescr  (UINT16 conn_id, UINT16 handle,
805                                        UINT16 offset,tBTA_GATT_UNFMT *p_data,
806                                        tBTA_GATT_AUTH_REQ auth_req)
807 {
808     tBTA_GATTC_API_WRITE  *p_buf;
809     UINT16  len = sizeof(tBTA_GATTC_API_WRITE);
810 
811     if (p_data != NULL) {
812         len += p_data->len;
813     }
814 
815     if ((p_buf = (tBTA_GATTC_API_WRITE *) osi_malloc(len)) != NULL) {
816         memset(p_buf, 0, len);
817 
818         p_buf->hdr.event = BTA_GATTC_API_WRITE_EVT;
819         p_buf->hdr.layer_specific = conn_id;
820         p_buf->auth_req = auth_req;
821         p_buf->handle = handle;
822         p_buf->write_type = BTA_GATTC_WRITE_PREPARE;
823         p_buf->offset = offset;
824 
825         if (p_data && p_data->len != 0) {
826             p_buf->len      = p_data->len;
827             p_buf->p_value = (UINT8 *)(p_buf + 1);
828             /* pack the descr data */
829             memcpy(p_buf->p_value, p_data->p_value, p_data->len);
830         }
831 
832         bta_sys_sendmsg(p_buf);
833     }
834     return;
835 
836 }
837 /*******************************************************************************
838 **
839 ** Function         BTA_GATTC_ExecuteWrite
840 **
841 ** Description      This function is called to execute write a prepare write sequence.
842 **
843 ** Parameters       conn_id - connection ID.
844 **                    is_execute - execute or cancel.
845 **
846 ** Returns          None
847 **
848 *******************************************************************************/
BTA_GATTC_ExecuteWrite(UINT16 conn_id,BOOLEAN is_execute)849 void BTA_GATTC_ExecuteWrite  (UINT16 conn_id, BOOLEAN is_execute)
850 {
851     tBTA_GATTC_API_EXEC  *p_buf;
852 
853     if ((p_buf = (tBTA_GATTC_API_EXEC *) osi_malloc((UINT16)sizeof(tBTA_GATTC_API_EXEC))) != NULL) {
854         memset(p_buf, 0, sizeof(tBTA_GATTC_API_EXEC));
855         p_buf->hdr.event = BTA_GATTC_API_EXEC_EVT;
856         p_buf->hdr.layer_specific = conn_id;
857 
858         p_buf->is_execute = is_execute;
859 
860         bta_sys_sendmsg(p_buf);
861     }
862     return;
863 
864 }
865 /*******************************************************************************
866 **
867 ** Function         BTA_GATTC_SendIndConfirm
868 **
869 ** Description      This function is called to send handle value confirmation.
870 **
871 ** Parameters       conn_id - connection ID.
872 **                    p_char_id - characteristic ID to confirm.
873 **
874 ** Returns          None
875 **
876 *******************************************************************************/
BTA_GATTC_SendIndConfirm(UINT16 conn_id,UINT16 handle)877 void BTA_GATTC_SendIndConfirm (UINT16 conn_id, UINT16 handle)
878 {
879     tBTA_GATTC_API_CONFIRM  *p_buf;
880 
881     APPL_TRACE_API("BTA_GATTC_SendIndConfirm conn_id=%d handle =0x%x",
882                    conn_id, handle);
883 
884     if ((p_buf = (tBTA_GATTC_API_CONFIRM *) osi_malloc(sizeof(tBTA_GATTC_API_CONFIRM))) != NULL) {
885         memset(p_buf, 0, sizeof(tBTA_GATTC_API_CONFIRM));
886         p_buf->hdr.event = BTA_GATTC_API_CONFIRM_EVT;
887         p_buf->hdr.layer_specific = conn_id;
888         p_buf->handle = handle;
889 
890         bta_sys_sendmsg(p_buf);
891     }
892     return;
893 
894 }
895 
896 /*******************************************************************************
897 **
898 ** Function         BTA_GATTC_RegisterForNotifications
899 **
900 ** Description      This function is called to register for notification of a service.
901 **
902 ** Parameters       client_if - client interface.
903 **                  bda - target GATT server.
904 **                  handle - GATT characteristic handle.
905 **
906 ** Returns          OK if registration succeed, otherwise failed.
907 **
908 *******************************************************************************/
BTA_GATTC_RegisterForNotifications(tBTA_GATTC_IF client_if,BD_ADDR bda,UINT16 handle)909 tBTA_GATT_STATUS BTA_GATTC_RegisterForNotifications (tBTA_GATTC_IF client_if,
910                                                      BD_ADDR bda, UINT16 handle)
911 {
912     tBTA_GATTC_RCB      *p_clreg;
913     tBTA_GATT_STATUS    status = BTA_GATT_ILLEGAL_PARAMETER;
914     UINT8               i;
915 
916     if (!handle)
917     {
918         APPL_TRACE_ERROR("deregistration failed, handle is 0");
919         return status;
920     }
921 
922     if ((p_clreg = bta_gattc_cl_get_regcb(client_if)) != NULL) {
923         for (i = 0; i < BTA_GATTC_NOTIF_REG_MAX; i ++) {
924             if ( p_clreg->notif_reg[i].in_use &&
925                     !memcmp(p_clreg->notif_reg[i].remote_bda, bda, BD_ADDR_LEN) &&
926                   p_clreg->notif_reg[i].handle == handle) {
927                 APPL_TRACE_DEBUG("notification already registered");
928                 status = BTA_GATT_OK;
929                 break;
930             }
931         }
932         if (status != BTA_GATT_OK) {
933             for (i = 0; i < BTA_GATTC_NOTIF_REG_MAX; i ++) {
934                 if (!p_clreg->notif_reg[i].in_use) {
935                     memset((void *)&p_clreg->notif_reg[i], 0, sizeof(tBTA_GATTC_NOTIF_REG));
936 
937                     p_clreg->notif_reg[i].in_use = TRUE;
938                     memcpy(p_clreg->notif_reg[i].remote_bda, bda, BD_ADDR_LEN);
939 
940                     p_clreg->notif_reg[i].handle = handle;
941                     status = BTA_GATT_OK;
942                     break;
943                 }
944             }
945             if (i == BTA_GATTC_NOTIF_REG_MAX) {
946                 status = BTA_GATT_NO_RESOURCES;
947                 APPL_TRACE_ERROR("Max Notification Reached, registration failed,see CONFIG_BT_GATTC_NOTIF_REG_MAX in menuconfig");
948             }
949         }
950     } else {
951         APPL_TRACE_ERROR("Client_if: %d Not Registered", client_if);
952     }
953 
954     return status;
955 }
956 
957 /*******************************************************************************
958 **
959 ** Function         BTA_GATTC_DeregisterForNotifications
960 **
961 ** Description      This function is called to de-register for notification of a service.
962 **
963 ** Parameters       client_if - client interface.
964 **                  remote_bda - target GATT server.
965 **                  handle - GATT characteristic handle.
966 **
967 ** Returns          OK if deregistration succeed, otherwise failed.
968 **
969 *******************************************************************************/
BTA_GATTC_DeregisterForNotifications(tBTA_GATTC_IF client_if,BD_ADDR bda,UINT16 handle)970 tBTA_GATT_STATUS BTA_GATTC_DeregisterForNotifications (tBTA_GATTC_IF client_if,
971                                                        BD_ADDR bda, UINT16 handle)
972 {
973     if (!handle) {
974         APPL_TRACE_ERROR("%s: deregistration failed, handle is 0", __func__);
975         return BTA_GATT_ILLEGAL_PARAMETER;
976     }
977 
978     tBTA_GATTC_RCB *p_clreg = bta_gattc_cl_get_regcb(client_if);
979     if (p_clreg == NULL) {
980         APPL_TRACE_ERROR("%s client_if: %d not registered bd_addr:%02x:%02x:%02x:%02x:%02x:%02x",
981             __func__, client_if, bda[0], bda[1], bda[2], bda[3], bda[4], bda[5]);
982         return BTA_GATT_ILLEGAL_PARAMETER;
983     }
984 
985     for (int i = 0; i < BTA_GATTC_NOTIF_REG_MAX; i ++) {
986         if (p_clreg->notif_reg[i].in_use &&
987             !memcmp(p_clreg->notif_reg[i].remote_bda, bda, BD_ADDR_LEN) &&
988             p_clreg->notif_reg[i].handle == handle) {
989             APPL_TRACE_DEBUG("%s deregistered bd_addr:%02x:%02x:%02x:%02x:%02x:%02x",
990                 __func__, bda[0], bda[1], bda[2], bda[3], bda[4], bda[5]);
991             memset(&p_clreg->notif_reg[i], 0, sizeof(tBTA_GATTC_NOTIF_REG));
992             return BTA_GATT_OK;
993         }
994     }
995 
996     APPL_TRACE_ERROR("%s registration not found bd_addr:%02x:%02x:%02x:%02x:%02x:%02x",
997         __func__, bda[0], bda[1], bda[2], bda[3], bda[4], bda[5]);
998     return BTA_GATT_ERROR;
999 }
1000 
1001 /*******************************************************************************
1002 **
1003 ** Function         BTA_GATTC_Refresh
1004 **
1005 ** Description      Refresh the server cache of the remote device
1006 **
1007 ** Parameters       remote_bda: remote device BD address.
1008 **                  erase_flash: delete cache from nvs flash
1009 **
1010 ** Returns          void
1011 **
1012 *******************************************************************************/
BTA_GATTC_Refresh(BD_ADDR remote_bda,bool erase_flash)1013 void BTA_GATTC_Refresh(BD_ADDR remote_bda, bool erase_flash)
1014 {
1015 #if(GATTC_CACHE_NVS == TRUE)
1016     if(erase_flash) {
1017         /* used to reset cache in application */
1018         bta_gattc_cache_reset(remote_bda);
1019     }
1020 #endif
1021     //If the registration callback is NULL, return
1022     if(bta_sys_is_register(BTA_ID_GATTC) == FALSE) {
1023         return;
1024     }
1025     tBTA_GATTC_API_CACHE_REFRESH  *p_buf;
1026 
1027     if ((p_buf = (tBTA_GATTC_API_CACHE_REFRESH *) osi_malloc(sizeof(tBTA_GATTC_API_CACHE_REFRESH))) != NULL) {
1028         p_buf->hdr.event = BTA_GATTC_API_REFRESH_EVT;
1029         memcpy(p_buf->remote_bda, remote_bda, BD_ADDR_LEN);
1030 
1031         bta_sys_sendmsg(p_buf);
1032     }
1033     return;
1034 }
1035 
BTA_GATTC_CacheAssoc(tBTA_GATTC_IF client_if,BD_ADDR src_addr,BD_ADDR assoc_addr,BOOLEAN is_assoc)1036 void BTA_GATTC_CacheAssoc(tBTA_GATTC_IF client_if, BD_ADDR src_addr, BD_ADDR assoc_addr, BOOLEAN is_assoc)
1037 {
1038     tBTA_GATTC_API_CACHE_ASSOC *p_buf;
1039 
1040     if ((p_buf = (tBTA_GATTC_API_CACHE_ASSOC *)osi_malloc(sizeof(tBTA_GATTC_API_CACHE_ASSOC))) != NULL) {
1041         p_buf->hdr.event = BTA_GATTC_API_CACHE_ASSOC_EVT;
1042         p_buf->is_assoc = is_assoc;
1043         p_buf->client_if  = client_if;
1044         memcpy(p_buf->src_addr, src_addr, sizeof(BD_ADDR));
1045         memcpy(p_buf->assoc_addr, assoc_addr, sizeof(BD_ADDR));
1046 
1047         bta_sys_sendmsg(p_buf);
1048 
1049     }
1050     return;
1051 }
1052 
BTA_GATTC_CacheGetAddrList(tBTA_GATTC_IF client_if)1053 void BTA_GATTC_CacheGetAddrList(tBTA_GATTC_IF client_if)
1054 {
1055     tBTA_GATTC_API_GET_ADDR *p_buf;
1056     if ((p_buf = (tBTA_GATTC_API_GET_ADDR *)osi_malloc(sizeof(tBTA_GATTC_API_GET_ADDR))) != NULL) {
1057         p_buf->hdr.event = BTA_GATTC_API_CACHE_GET_ADDR_LIST_EVT;
1058         p_buf->client_if = client_if;
1059 
1060         bta_sys_sendmsg(p_buf);
1061     }
1062     return;
1063 }
1064 
1065 /*******************************************************************************
1066 **
1067 ** Function         BTA_GATTC_Clean
1068 **
1069 ** Description      Clean the server cache of the remote device
1070 **
1071 ** Parameters       remote_bda: remote device BD address.
1072 **
1073 ** Returns          void
1074 **
1075 *******************************************************************************/
BTA_GATTC_Clean(BD_ADDR remote_bda)1076 void BTA_GATTC_Clean(BD_ADDR remote_bda)
1077 {
1078 #if(GATTC_CACHE_NVS == TRUE)
1079     /* used to reset cache in application */
1080     bta_gattc_cache_reset(remote_bda);
1081 #endif
1082 
1083     tBTA_GATTC_API_CACHE_CLEAN  *p_buf;
1084 
1085     if ((p_buf = (tBTA_GATTC_API_CACHE_CLEAN *) osi_malloc(sizeof(tBTA_GATTC_API_CACHE_CLEAN))) != NULL) {
1086         p_buf->hdr.event = BTA_GATTC_API_CACHE_CLEAN_EVT;
1087         memcpy(p_buf->remote_bda, remote_bda, BD_ADDR_LEN);
1088 
1089         bta_sys_sendmsg(p_buf);
1090     }
1091     return;
1092 }
1093 /*******************************************************************************
1094 **
1095 ** Function         BTA_GATTC_Listen
1096 **
1097 ** Description      Start advertisement to listen for connection request for a GATT
1098 **                  client application.
1099 **
1100 ** Parameters       client_if: server interface.
1101 **                  start: to start or stop listening for connection
1102 **                  remote_bda: remote device BD address, if listen to all device
1103 **                              use NULL.
1104 **
1105 ** Returns          void
1106 **
1107 *******************************************************************************/
BTA_GATTC_Listen(tBTA_GATTC_IF client_if,BOOLEAN start,BD_ADDR_PTR target_bda)1108 void BTA_GATTC_Listen(tBTA_GATTC_IF client_if, BOOLEAN start, BD_ADDR_PTR target_bda)
1109 {
1110     tBTA_GATTC_API_LISTEN  *p_buf;
1111 
1112     if ((p_buf = (tBTA_GATTC_API_LISTEN *) osi_malloc((UINT16)(sizeof(tBTA_GATTC_API_LISTEN) + BD_ADDR_LEN))) != NULL) {
1113         p_buf->hdr.event = BTA_GATTC_API_LISTEN_EVT;
1114 
1115         p_buf->client_if = client_if;
1116         p_buf->start = start;
1117         if (target_bda) {
1118             p_buf->remote_bda = (UINT8 *)(p_buf + 1);
1119             memcpy(p_buf->remote_bda, target_bda, BD_ADDR_LEN);
1120         } else {
1121             p_buf->remote_bda = NULL;
1122         }
1123 
1124         bta_sys_sendmsg(p_buf);
1125     }
1126     return;
1127 }
1128 
1129 /*******************************************************************************
1130 **
1131 ** Function         BTA_GATTC_Broadcast
1132 **
1133 ** Description      Start broadcasting (non-connectable advertisements)
1134 **
1135 ** Parameters       client_if: client interface.
1136 **                  start: to start or stop listening for connection
1137 **
1138 ** Returns          void
1139 **
1140 *******************************************************************************/
BTA_GATTC_Broadcast(tBTA_GATTC_IF client_if,BOOLEAN start)1141 void BTA_GATTC_Broadcast(tBTA_GATTC_IF client_if, BOOLEAN start)
1142 {
1143     tBTA_GATTC_API_LISTEN  *p_buf;
1144 
1145     if ((p_buf = (tBTA_GATTC_API_LISTEN *) osi_malloc((UINT16)(sizeof(tBTA_GATTC_API_LISTEN) + BD_ADDR_LEN))) != NULL) {
1146         p_buf->hdr.event = BTA_GATTC_API_BROADCAST_EVT;
1147         p_buf->client_if = client_if;
1148         p_buf->start = start;
1149         bta_sys_sendmsg(p_buf);
1150     }
1151     return;
1152 }
1153 
1154 /* Add For BLE PTS */
BTA_GATTC_AutoDiscoverEnable(uint8_t enable)1155 uint8_t BTA_GATTC_AutoDiscoverEnable(uint8_t enable)
1156 {
1157     APPL_TRACE_DEBUG("%s enable %d", __func__, enable);
1158 
1159     bta_gattc_cb.auto_disc = ((enable > 0) ? true : false);
1160     GATTC_AutoDiscoverEnable(enable);
1161 
1162     return 0;
1163 }
1164 
1165 typedef struct {
1166     UINT16 len;
1167     union {
1168         UINT16    uuid16;
1169         UINT32    uuid32;
1170         UINT8     uuid128[LEN_UUID_128];
1171     } uuid;
1172 } __attribute__((packed)) tAPP_UUID;
1173 
BTA_GATTC_Discover(uint8_t gatt_if,uint16_t conn_id,void * uuid,uint8_t disc_type,uint16_t s_handle,uint16_t e_handle)1174 uint8_t BTA_GATTC_Discover(uint8_t gatt_if, uint16_t conn_id, void *uuid, uint8_t disc_type, uint16_t s_handle, uint16_t e_handle)
1175 {
1176     tGATT_STATUS status;
1177     tGATT_DISC_PARAM param;
1178     tAPP_UUID *app_uuid = (tAPP_UUID *)uuid;
1179 
1180     conn_id = (UINT16)((((UINT8)conn_id) << 8) | gatt_if);
1181     memset(&param, 0, sizeof(tGATT_DISC_PARAM));
1182 
1183     if (disc_type == GATT_DISC_SRVC_ALL || disc_type == GATT_DISC_SRVC_BY_UUID) {
1184         param.s_handle = 1;
1185         param.e_handle = 0xFFFF;
1186     } else {
1187         param.s_handle = s_handle;
1188         param.e_handle = e_handle;
1189     }
1190 
1191     if (app_uuid) {
1192         param.service.len = app_uuid->len;
1193         if (app_uuid->len == LEN_UUID_16) {
1194             param.service.uu.uuid16 = app_uuid->uuid.uuid16;
1195         } else if (app_uuid->len == LEN_UUID_32) {
1196             param.service.uu.uuid32 = app_uuid->uuid.uuid32;
1197         } else if (app_uuid->len == LEN_UUID_128) {
1198             memcpy(param.service.uu.uuid128, app_uuid->uuid.uuid128, LEN_UUID_128);
1199         } else {
1200             APPL_TRACE_ERROR("%s invalid uuid len %u", __func__, app_uuid->len);
1201         }
1202     }
1203 
1204     status = GATTC_Discover (conn_id, disc_type, &param);
1205     if (status != GATT_SUCCESS) {
1206         APPL_TRACE_ERROR("%s status %x", __func__, status);
1207         return -1;
1208     }
1209 
1210     return 0;
1211 }
1212 
BTA_GATTC_ReadLongChar(uint8_t gatt_if,uint16_t conn_id,uint16_t handle,uint16_t offset,uint8_t auth_req)1213 uint8_t BTA_GATTC_ReadLongChar(uint8_t gatt_if, uint16_t conn_id, uint16_t handle, uint16_t offset, uint8_t auth_req)
1214 {
1215     tGATT_STATUS status;
1216     tGATT_READ_PARAM read_param;
1217 
1218     conn_id = (UINT16)((((UINT8)conn_id) << 8) | gatt_if);
1219     memset (&read_param, 0, sizeof(tGATT_READ_PARAM));
1220     read_param.partial.handle = handle;
1221     read_param.partial.offset = offset;
1222     read_param.partial.auth_req = auth_req;
1223 
1224     status = GATTC_Read(conn_id, GATT_READ_PARTIAL, &read_param);
1225     if (status != GATT_SUCCESS) {
1226         APPL_TRACE_ERROR("%s status %x", __func__, status);
1227         return -1;
1228     }
1229 
1230     return 0;
1231 }
1232 /* End BLE PTS */
1233 #endif /* defined(GATTC_INCLUDED) && (GATTC_INCLUDED == TRUE) */
1234