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