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_gatt_reg =
40 {
41 bta_gattc_hdl_event,
42 NULL /* need a disable functino to be called when BT is disabled */
43 };
44
45 /*******************************************************************************
46 **
47 ** Function BTA_GATTC_AppRegister
48 **
49 ** Description This function is called to register application callbacks
50 ** with BTA GATTC module.
51 **
52 ** Parameters p_app_uuid - applicaiton UUID
53 ** p_client_cb - pointer to the application callback function.
54 **
55 ** Returns None
56 **
57 *******************************************************************************/
BTA_GATTC_AppRegister(tBT_UUID * p_app_uuid,tBTA_GATTC_CBACK * p_client_cb)58 void BTA_GATTC_AppRegister(tBT_UUID *p_app_uuid, tBTA_GATTC_CBACK *p_client_cb)
59 {
60 tBTA_GATTC_API_REG *p_buf;
61
62 /* register with BTA system manager */
63 GKI_sched_lock();
64 bta_sys_register(BTA_ID_GATTC, &bta_gatt_reg);
65 GKI_sched_unlock();
66
67 if ((p_buf = (tBTA_GATTC_API_REG *) GKI_getbuf(sizeof(tBTA_GATTC_API_REG))) != NULL)
68 {
69 p_buf->hdr.event = BTA_GATTC_API_REG_EVT;
70 if (p_app_uuid != NULL)
71 memcpy(&p_buf->app_uuid, p_app_uuid, sizeof(tBT_UUID));
72 p_buf->p_cback = p_client_cb;
73
74 bta_sys_sendmsg(p_buf);
75 }
76 return;
77 }
78
79 /*******************************************************************************
80 **
81 ** Function BTA_GATTC_AppDeregister
82 **
83 ** Description This function is called to deregister an application
84 ** from BTA GATTC module.
85 **
86 ** Parameters client_if - client interface identifier.
87 **
88 ** Returns None
89 **
90 *******************************************************************************/
BTA_GATTC_AppDeregister(tBTA_GATTC_IF client_if)91 void BTA_GATTC_AppDeregister(tBTA_GATTC_IF client_if)
92 {
93 tBTA_GATTC_API_DEREG *p_buf;
94
95 if ((p_buf = (tBTA_GATTC_API_DEREG *) GKI_getbuf(sizeof(tBTA_GATTC_API_DEREG))) != NULL)
96 {
97 p_buf->hdr.event = BTA_GATTC_API_DEREG_EVT;
98 p_buf->client_if = client_if;
99 bta_sys_sendmsg(p_buf);
100 }
101 return;
102 }
103
104 /*******************************************************************************
105 **
106 ** Function BTA_GATTC_Open
107 **
108 ** Description Open a direct connection or add a background auto connection
109 ** bd address
110 **
111 ** Parameters client_if: server interface.
112 ** remote_bda: remote device BD address.
113 ** is_direct: direct connection or background auto connection
114 **
115 ** Returns void
116 **
117 *******************************************************************************/
BTA_GATTC_Open(tBTA_GATTC_IF client_if,BD_ADDR remote_bda,BOOLEAN is_direct)118 void BTA_GATTC_Open(tBTA_GATTC_IF client_if, BD_ADDR remote_bda, BOOLEAN is_direct)
119 {
120 tBTA_GATTC_API_OPEN *p_buf;
121
122 if ((p_buf = (tBTA_GATTC_API_OPEN *) GKI_getbuf(sizeof(tBTA_GATTC_API_OPEN))) != NULL)
123 {
124 p_buf->hdr.event = BTA_GATTC_API_OPEN_EVT;
125
126 p_buf->client_if = client_if;
127 p_buf->is_direct = is_direct;
128 memcpy(p_buf->remote_bda, remote_bda, BD_ADDR_LEN);
129
130
131 bta_sys_sendmsg(p_buf);
132 }
133 return;
134 }
135
136 /*******************************************************************************
137 **
138 ** Function BTA_GATTC_CancelOpen
139 **
140 ** Description Cancel a direct open connection or remove a background auto connection
141 ** bd address
142 **
143 ** Parameters client_if: server interface.
144 ** remote_bda: remote device BD address.
145 ** is_direct: direct connection or background auto connection
146 **
147 ** Returns void
148 **
149 *******************************************************************************/
BTA_GATTC_CancelOpen(tBTA_GATTC_IF client_if,BD_ADDR remote_bda,BOOLEAN is_direct)150 void BTA_GATTC_CancelOpen(tBTA_GATTC_IF client_if, BD_ADDR remote_bda, BOOLEAN is_direct)
151 {
152 tBTA_GATTC_API_CANCEL_OPEN *p_buf;
153
154 if ((p_buf = (tBTA_GATTC_API_CANCEL_OPEN *) GKI_getbuf(sizeof(tBTA_GATTC_API_CANCEL_OPEN))) != NULL)
155 {
156 p_buf->hdr.event = BTA_GATTC_API_CANCEL_OPEN_EVT;
157
158 p_buf->client_if = client_if;
159 p_buf->is_direct = is_direct;
160 memcpy(p_buf->remote_bda, remote_bda, BD_ADDR_LEN);
161
162 bta_sys_sendmsg(p_buf);
163 }
164 return;
165 }
166
167 /*******************************************************************************
168 **
169 ** Function BTA_GATTC_Close
170 **
171 ** Description Close a connection to a GATT server.
172 **
173 ** Parameters conn_id: connectino ID to be closed.
174 **
175 ** Returns void
176 **
177 *******************************************************************************/
BTA_GATTC_Close(UINT16 conn_id)178 void BTA_GATTC_Close(UINT16 conn_id)
179 {
180 BT_HDR *p_buf;
181
182 if ((p_buf = (BT_HDR *) GKI_getbuf(sizeof(BT_HDR))) != NULL)
183 {
184 p_buf->event = BTA_GATTC_API_CLOSE_EVT;
185
186 p_buf->layer_specific = conn_id;
187
188 bta_sys_sendmsg(p_buf);
189 }
190 return;
191
192 }
193 /*******************************************************************************
194 **
195 ** Function BTA_GATTC_ServiceSearchRequest
196 **
197 ** Description This function is called to request a GATT service discovery
198 ** on a GATT server. This function report service search result
199 ** by a callback event, and followed by a service search complete
200 ** event.
201 **
202 ** Parameters conn_id: connection ID.
203 ** p_srvc_uuid: a UUID of the service application is interested in.
204 ** If Null, discover for all services.
205 **
206 ** Returns None
207 **
208 *******************************************************************************/
BTA_GATTC_ServiceSearchRequest(UINT16 conn_id,tBT_UUID * p_srvc_uuid)209 void BTA_GATTC_ServiceSearchRequest (UINT16 conn_id, tBT_UUID *p_srvc_uuid)
210 {
211 tBTA_GATTC_API_SEARCH *p_buf;
212 UINT16 len = sizeof(tBTA_GATTC_API_SEARCH) + sizeof(tBT_UUID);
213
214 if ((p_buf = (tBTA_GATTC_API_SEARCH *) GKI_getbuf(len)) != NULL)
215 {
216 memset(p_buf, 0, len);
217
218 p_buf->hdr.event = BTA_GATTC_API_SEARCH_EVT;
219 p_buf->hdr.layer_specific = conn_id;
220
221 if (p_srvc_uuid)
222 {
223 memcpy(&p_buf->srvc_uuid, p_srvc_uuid, sizeof(tBT_UUID));
224 }
225 bta_sys_sendmsg(p_buf);
226 }
227 return;
228 }
229
230
231 /*******************************************************************************
232 **
233 ** Function BTA_GATTC_GetFirstChar
234 **
235 ** Description This function is called to find the first charatceristic of the
236 ** service on the given server.
237 **
238 ** Parameters conn_id: connection ID which identify the server.
239 ** p_srvc_id: the service ID of which the characteristic is belonged to.
240 ** p_char_uuid_cond: Characteristic UUID, if NULL find the first available
241 ** characteristic.
242 ** p_char_result: output parameter which will store the GATT
243 ** characteristic ID.
244 ** p_property: output parameter to carry the characteristic property.
245 **
246 ** Returns returns status.
247 **
248 *******************************************************************************/
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)249 tBTA_GATT_STATUS BTA_GATTC_GetFirstChar (UINT16 conn_id, tBTA_GATT_SRVC_ID *p_srvc_id,
250 tBT_UUID *p_char_uuid_cond,
251 tBTA_GATTC_CHAR_ID *p_char_result,
252 tBTA_GATT_CHAR_PROP *p_property)
253 {
254 tBTA_GATT_STATUS status;
255
256 if (!p_srvc_id || !p_char_result)
257 return BTA_GATT_ILLEGAL_PARAMETER;
258
259 if ((status = bta_gattc_query_cache(conn_id, BTA_GATTC_ATTR_TYPE_CHAR, p_srvc_id, NULL,
260 p_char_uuid_cond, &p_char_result->char_id, p_property))
261 == BTA_GATT_OK)
262 {
263 memcpy(&p_char_result->srvc_id, p_srvc_id, sizeof(tBTA_GATT_SRVC_ID));
264 }
265
266 return status;
267
268 }
269 /*******************************************************************************
270 **
271 ** Function BTA_GATTC_GetNextChar
272 **
273 ** Description This function is called to find the next charatceristic of the
274 ** service on the given server.
275 **
276 ** Parameters conn_id: connection ID which identify the server.
277 ** p_start_char_id: start the characteristic search from the next record
278 ** after the one identified by char_id.
279 ** p_char_uuid_cond: Characteristic UUID, if NULL find the first available
280 ** characteristic.
281 ** p_char_result: output parameter which will store the GATT
282 ** characteristic ID.
283 ** p_property: output parameter to carry the characteristic property.
284 **
285 ** Returns returns status.
286 **
287 *******************************************************************************/
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)288 tBTA_GATT_STATUS BTA_GATTC_GetNextChar (UINT16 conn_id,
289 tBTA_GATTC_CHAR_ID *p_start_char_id,
290 tBT_UUID *p_char_uuid_cond,
291 tBTA_GATTC_CHAR_ID *p_char_result,
292 tBTA_GATT_CHAR_PROP *p_property)
293 {
294 tBTA_GATT_STATUS status;
295
296 if (!p_start_char_id || !p_char_result)
297 return BTA_GATT_ILLEGAL_PARAMETER;
298
299 if ((status = bta_gattc_query_cache(conn_id, BTA_GATTC_ATTR_TYPE_CHAR,
300 &p_start_char_id->srvc_id,
301 &p_start_char_id->char_id,
302 p_char_uuid_cond,
303 &p_char_result->char_id,
304 p_property))
305 == BTA_GATT_OK)
306 {
307 memcpy(&p_char_result->srvc_id, &p_start_char_id->srvc_id, sizeof(tBTA_GATT_SRVC_ID));
308 }
309
310 return status;
311 }
312
313 /*******************************************************************************
314 **
315 ** Function BTA_GATTC_GetFirstCharDescr
316 **
317 ** Description This function is called to find the first charatceristic descriptor of the
318 ** charatceristic on the given server.
319 **
320 ** Parameters conn_id: connection ID which identify the server.
321 ** p_char_id: the characteristic ID of which the descriptor is belonged to.
322 ** p_descr_uuid_cond: Characteristic Descr UUID, if NULL find the first available
323 ** characteristic.
324 ** p_descr_result: output parameter which will store the GATT
325 ** characteristic descriptor ID.
326 **
327 ** Returns returns status.
328 **
329 *******************************************************************************/
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)330 tBTA_GATT_STATUS BTA_GATTC_GetFirstCharDescr (UINT16 conn_id, tBTA_GATTC_CHAR_ID *p_char_id,
331 tBT_UUID *p_descr_uuid_cond,
332 tBTA_GATTC_CHAR_DESCR_ID *p_descr_result)
333 {
334 tBTA_GATT_STATUS status;
335
336 if (!p_char_id || !p_descr_result)
337 return BTA_GATT_ILLEGAL_PARAMETER;
338
339 memset(p_descr_result, 0, sizeof(tBTA_GATTC_CHAR_DESCR_ID));
340
341 if ((status = bta_gattc_query_cache(conn_id,
342 BTA_GATTC_ATTR_TYPE_CHAR_DESCR,
343 &p_char_id->srvc_id,
344 &p_char_id->char_id,
345 p_descr_uuid_cond,
346 &p_descr_result->char_id.char_id,
347 NULL))
348 == BTA_GATT_OK)
349 {
350 memcpy(&p_descr_result->descr_type, &p_descr_result->char_id.char_id.uuid, sizeof(tBT_UUID));
351 memcpy(&p_descr_result->char_id, p_char_id, sizeof(tBTA_GATTC_CHAR_ID));
352 }
353
354 return status;
355
356 }
357 /*******************************************************************************
358 **
359 ** Function BTA_GATTC_GetNextCharDescr
360 **
361 ** Description This function is called to find the next charatceristic of the
362 ** service on the given server.
363 **
364 ** Parameters conn_id: connection ID which identify the server.
365 ** p_start_descr_id: start the characteristic search from the next record
366 ** after the one identified by p_start_descr_id.
367 ** p_descr_uuid_cond: Characteristic descriptor UUID, if NULL find
368 ** the first available characteristic descriptor.
369 ** p_descr_result: output parameter which will store the GATT
370 ** characteristic descriptor ID.
371 **
372 ** Returns returns status.
373 **
374 *******************************************************************************/
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)375 tBTA_GATT_STATUS BTA_GATTC_GetNextCharDescr (UINT16 conn_id,
376 tBTA_GATTC_CHAR_DESCR_ID *p_start_descr_id,
377 tBT_UUID *p_descr_uuid_cond,
378 tBTA_GATTC_CHAR_DESCR_ID *p_descr_result)
379 {
380 tBTA_GATT_STATUS status;
381
382 if (!p_start_descr_id || !p_descr_result)
383 return BTA_GATT_ILLEGAL_PARAMETER;
384
385 memset(p_descr_result, 0, sizeof(tBTA_GATTC_CHAR_DESCR_ID));
386
387 if ((status = bta_gattc_query_cache(conn_id, BTA_GATTC_ATTR_TYPE_CHAR_DESCR,
388 &p_start_descr_id->char_id.srvc_id,
389 &p_start_descr_id->char_id.char_id,
390 p_descr_uuid_cond,
391 &p_descr_result->char_id.char_id,
392 (void *)&p_start_descr_id->descr_type))
393 == BTA_GATT_OK)
394 {
395 memcpy(&p_descr_result->descr_type, &p_descr_result->char_id.char_id.uuid, sizeof(tBT_UUID));
396 memcpy(&p_descr_result->char_id, p_start_descr_id, sizeof(tBTA_GATTC_CHAR_ID));
397 }
398
399 return status;
400 }
401
402
403 /*******************************************************************************
404 **
405 ** Function BTA_GATTC_GetFirstIncludedService
406 **
407 ** Description This function is called to find the first included service of the
408 ** service on the given server.
409 **
410 ** Parameters conn_id: connection ID which identify the server.
411 ** p_srvc_id: the service ID of which the characteristic is belonged to.
412 ** p_uuid_cond: Characteristic UUID, if NULL find the first available
413 ** characteristic.
414 ** p_result: output parameter which will store the GATT ID
415 ** of the included service found.
416 **
417 ** Returns returns status.
418 **
419 *******************************************************************************/
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)420 tBTA_GATT_STATUS BTA_GATTC_GetFirstIncludedService(UINT16 conn_id, tBTA_GATT_SRVC_ID *p_srvc_id,
421 tBT_UUID *p_uuid_cond, tBTA_GATTC_INCL_SVC_ID *p_result)
422 {
423 tBTA_GATT_STATUS status;
424
425 if (!p_srvc_id || !p_result)
426 return BTA_GATT_ILLEGAL_PARAMETER;
427
428 if ((status = bta_gattc_query_cache(conn_id,
429 BTA_GATTC_ATTR_TYPE_INCL_SRVC,
430 p_srvc_id,
431 NULL,
432 p_uuid_cond,
433 &p_result->incl_svc_id.id,
434 (tBTA_GATT_CHAR_PROP *)&p_result->incl_svc_id.is_primary))
435 == BTA_GATT_OK)
436 {
437 memcpy(&p_result->srvc_id, p_srvc_id, sizeof(tBTA_GATT_SRVC_ID));
438 }
439
440 return status;
441 }
442 /*******************************************************************************
443 **
444 ** Function BTA_GATTC_GetNextIncludedService
445 **
446 ** Description This function is called to find the next included service of the
447 ** service on the given server.
448 **
449 ** Parameters conn_id: connection ID which identify the server.
450 ** p_start_id: start the search from the next record
451 ** after the one identified by p_start_id.
452 ** p_uuid_cond: Included service UUID, if NULL find the first available
453 ** included service.
454 ** p_result: output parameter which will store the GATT ID
455 ** of the included service found.
456 **
457 ** Returns returns status.
458 **
459 *******************************************************************************/
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)460 tBTA_GATT_STATUS BTA_GATTC_GetNextIncludedService(UINT16 conn_id,
461 tBTA_GATTC_INCL_SVC_ID *p_start_id,
462 tBT_UUID *p_uuid_cond,
463 tBTA_GATTC_INCL_SVC_ID *p_result)
464 {
465 tBTA_GATT_STATUS status;
466
467 if (!p_start_id || !p_result)
468 return BTA_GATT_ILLEGAL_PARAMETER;
469
470 if ((status = bta_gattc_query_cache(conn_id,
471 BTA_GATTC_ATTR_TYPE_INCL_SRVC,
472 &p_start_id->srvc_id,
473 &p_start_id->incl_svc_id.id,
474 p_uuid_cond,
475 &p_result->incl_svc_id.id,
476 (tBTA_GATT_CHAR_PROP *)&p_result->incl_svc_id.is_primary))
477 == BTA_GATT_OK)
478 {
479 memcpy(&p_result->srvc_id, &p_start_id->srvc_id, sizeof(tBTA_GATT_SRVC_ID));
480 }
481
482 return status;
483 }
484
485 /*******************************************************************************
486 **
487 ** Function BTA_GATTC_ReadCharacteristic
488 **
489 ** Description This function is called to read a service's characteristics of
490 ** the given characteritisc ID.
491 **
492 ** Parameters conn_id - connectino ID.
493 ** p_char_id - characteritic ID to read.
494 **
495 ** Returns None
496 **
497 *******************************************************************************/
BTA_GATTC_ReadCharacteristic(UINT16 conn_id,tBTA_GATTC_CHAR_ID * p_char_id,tBTA_GATT_AUTH_REQ auth_req)498 void BTA_GATTC_ReadCharacteristic(UINT16 conn_id, tBTA_GATTC_CHAR_ID *p_char_id,
499 tBTA_GATT_AUTH_REQ auth_req)
500 {
501 tBTA_GATTC_API_READ *p_buf;
502
503 if ((p_buf = (tBTA_GATTC_API_READ *) GKI_getbuf(sizeof(tBTA_GATTC_API_READ))) != NULL)
504 {
505 memset(p_buf, 0, sizeof(tBTA_GATTC_API_READ));
506
507 p_buf->hdr.event = BTA_GATTC_API_READ_EVT;
508 p_buf->hdr.layer_specific = conn_id;
509 p_buf->auth_req = auth_req;
510
511 memcpy(&p_buf->srvc_id, &p_char_id->srvc_id, sizeof(tBTA_GATT_SRVC_ID));
512 memcpy(&p_buf->char_id, &p_char_id->char_id, sizeof(tBTA_GATT_ID));
513
514 bta_sys_sendmsg(p_buf);
515 }
516 return;
517 }
518
519 /*******************************************************************************
520 **
521 ** Function BTA_GATTC_ReadCharDescr
522 **
523 ** Description This function is called to read a characteristics descriptor.
524 **
525 ** Parameters conn_id - connection ID.
526 ** p_char_descr_id - characteritic descriptor ID to read.
527 **
528 ** Returns None
529 **
530 *******************************************************************************/
BTA_GATTC_ReadCharDescr(UINT16 conn_id,tBTA_GATTC_CHAR_DESCR_ID * p_descr_id,tBTA_GATT_AUTH_REQ auth_req)531 void BTA_GATTC_ReadCharDescr (UINT16 conn_id,
532 tBTA_GATTC_CHAR_DESCR_ID *p_descr_id,
533 tBTA_GATT_AUTH_REQ auth_req)
534 {
535 tBTA_GATTC_API_READ *p_buf;
536
537 if ((p_buf = (tBTA_GATTC_API_READ *) GKI_getbuf(sizeof(tBTA_GATTC_API_READ))) != NULL)
538 {
539 memset(p_buf, 0, sizeof(tBTA_GATTC_API_READ));
540
541 p_buf->hdr.event = BTA_GATTC_API_READ_EVT;
542 p_buf->hdr.layer_specific = conn_id;
543 p_buf->auth_req = auth_req;
544
545 memcpy(&p_buf->srvc_id, &p_descr_id->char_id.srvc_id, sizeof(tBTA_GATT_SRVC_ID));
546 memcpy(&p_buf->char_id, &p_descr_id->char_id.char_id, sizeof(tBTA_GATT_ID));
547 memcpy(&p_buf->descr_type, &p_descr_id->descr_type, sizeof(tBT_UUID));
548
549 bta_sys_sendmsg(p_buf);
550 }
551 return;
552
553 }
554 /*******************************************************************************
555 **
556 ** Function BTA_GATTC_ReadMultiple
557 **
558 ** Description This function is called to read multiple characteristic or
559 ** characteristic descriptors.
560 **
561 ** Parameters conn_id - connectino ID.
562 ** p_read_multi - pointer to the read multiple parameter.
563 **
564 ** Returns None
565 **
566 *******************************************************************************/
BTA_GATTC_ReadMultiple(UINT16 conn_id,tBTA_GATTC_MULTI * p_read_multi,tBTA_GATT_AUTH_REQ auth_req)567 void BTA_GATTC_ReadMultiple(UINT16 conn_id, tBTA_GATTC_MULTI *p_read_multi,
568 tBTA_GATT_AUTH_REQ auth_req)
569 {
570 tBTA_GATTC_API_READ_MULTI *p_buf;
571 tBTA_GATTC_ATTR_ID *p_value;
572 UINT16 len = (UINT16)(sizeof(tBTA_GATTC_API_READ_MULTI) +
573 p_read_multi->num_attr * sizeof(tBTA_GATTC_ATTR_ID));
574 UINT8 i;
575
576 if ((p_buf = (tBTA_GATTC_API_READ_MULTI *) GKI_getbuf(len)) != NULL)
577 {
578 memset(p_buf, 0, len);
579
580 p_buf->hdr.event = BTA_GATTC_API_READ_MULTI_EVT;
581 p_buf->hdr.layer_specific = conn_id;
582 p_buf->auth_req = auth_req;
583
584 p_buf->num_attr = p_read_multi->num_attr;
585
586 if (p_buf->num_attr > 0)
587 {
588 p_buf->p_id_list = p_value = (tBTA_GATTC_ATTR_ID *)(p_buf + 1);
589
590 for (i = 0; i < p_buf->num_attr; i ++, p_value ++)
591 {
592 memcpy(p_value, &p_read_multi->id_list[i], sizeof(tBTA_GATTC_ATTR_ID));
593 }
594 }
595 bta_sys_sendmsg(p_buf);
596 }
597 return;
598 }
599
600
601 /*******************************************************************************
602 **
603 ** Function BTA_GATTC_WriteCharValue
604 **
605 ** Description This function is called to write characteristic value.
606 **
607 ** Parameters conn_id - connection ID.
608 ** p_char_id - characteristic ID to write.
609 ** write_type - type of write.
610 ** len: length of the data to be written.
611 ** p_value - the value to be written.
612 **
613 ** Returns None
614 **
615 *******************************************************************************/
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)616 void BTA_GATTC_WriteCharValue ( UINT16 conn_id,
617 tBTA_GATTC_CHAR_ID *p_char_id,
618 tBTA_GATTC_WRITE_TYPE write_type,
619 UINT16 len,
620 UINT8 *p_value,
621 tBTA_GATT_AUTH_REQ auth_req)
622 {
623 tBTA_GATTC_API_WRITE *p_buf;
624
625 if ((p_buf = (tBTA_GATTC_API_WRITE *) GKI_getbuf((UINT16)(sizeof(tBTA_GATTC_API_WRITE) + len))) != NULL)
626 {
627 memset(p_buf, 0, sizeof(tBTA_GATTC_API_WRITE) + len);
628
629 p_buf->hdr.event = BTA_GATTC_API_WRITE_EVT;
630 p_buf->hdr.layer_specific = conn_id;
631 p_buf->auth_req = auth_req;
632
633 memcpy(&p_buf->srvc_id, &p_char_id->srvc_id, sizeof(tBTA_GATT_SRVC_ID));
634 memcpy(&p_buf->char_id, &p_char_id->char_id, sizeof(tBTA_GATT_ID));
635
636 p_buf->write_type = write_type;
637 p_buf->len = len;
638
639 if (p_value && len > 0)
640 {
641 p_buf->p_value = (UINT8 *)(p_buf + 1);
642 memcpy(p_buf->p_value, p_value, len);
643 }
644
645 bta_sys_sendmsg(p_buf);
646 }
647 return;
648 }
649 /*******************************************************************************
650 **
651 ** Function BTA_GATTC_WriteCharDescr
652 **
653 ** Description This function is called to write characteristic descriptor value.
654 **
655 ** Parameters conn_id - connection ID
656 ** p_char_descr_id - characteristic descriptor ID to write.
657 ** write_type - write type.
658 ** p_value - the value to be written.
659 **
660 ** Returns None
661 **
662 *******************************************************************************/
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)663 void BTA_GATTC_WriteCharDescr (UINT16 conn_id,
664 tBTA_GATTC_CHAR_DESCR_ID *p_char_descr_id,
665 tBTA_GATTC_WRITE_TYPE write_type,
666 tBTA_GATT_UNFMT *p_data,
667 tBTA_GATT_AUTH_REQ auth_req)
668 {
669 tBTA_GATTC_API_WRITE *p_buf;
670 UINT16 len = sizeof(tBTA_GATTC_API_WRITE) + p_data->len;
671
672 if ((p_buf = (tBTA_GATTC_API_WRITE *) GKI_getbuf(len)) != NULL)
673 {
674 memset(p_buf, 0, len);
675
676 p_buf->hdr.event = BTA_GATTC_API_WRITE_EVT;
677 p_buf->hdr.layer_specific = conn_id;
678 p_buf->auth_req = auth_req;
679
680 memcpy(&p_buf->srvc_id, &p_char_descr_id->char_id.srvc_id, sizeof(tBTA_GATT_SRVC_ID));
681 memcpy(&p_buf->char_id, &p_char_descr_id->char_id.char_id, sizeof(tBTA_GATT_ID));
682 memcpy(&p_buf->descr_type, &p_char_descr_id->descr_type, sizeof(tBT_UUID));
683 p_buf->write_type = write_type;
684
685 if (p_data && p_data->len != 0)
686 {
687 p_buf->p_value = (UINT8 *)(p_buf + 1);
688 p_buf->len = p_data->len;
689 /* pack the descr data */
690 memcpy(p_buf->p_value, p_data->p_value, p_data->len);
691 }
692
693 bta_sys_sendmsg(p_buf);
694 }
695 return;
696
697 }
698 /*******************************************************************************
699 **
700 ** Function BTA_GATTC_PrepareWrite
701 **
702 ** Description This function is called to prepare write a characteristic value.
703 **
704 ** Parameters conn_id - connection ID.
705 ** p_char_id - GATT characteritic ID of the service.
706 ** offset - offset of the write value.
707 ** len: length of the data to be written.
708 ** p_value - the value to be written.
709 **
710 ** Returns None
711 **
712 *******************************************************************************/
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)713 void BTA_GATTC_PrepareWrite (UINT16 conn_id, tBTA_GATTC_CHAR_ID *p_char_id,
714 UINT16 offset, UINT16 len, UINT8 *p_value,
715 tBTA_GATT_AUTH_REQ auth_req)
716 {
717 tBTA_GATTC_API_WRITE *p_buf;
718
719 if ((p_buf = (tBTA_GATTC_API_WRITE *) GKI_getbuf((UINT16)(sizeof(tBTA_GATTC_API_WRITE) + len))) != NULL)
720 {
721 memset(p_buf, 0, sizeof(tBTA_GATTC_API_WRITE) + len);
722
723 p_buf->hdr.event = BTA_GATTC_API_WRITE_EVT;
724 p_buf->hdr.layer_specific = conn_id;
725 p_buf->auth_req = auth_req;
726
727 memcpy(&p_buf->srvc_id, &p_char_id->srvc_id, sizeof(tBTA_GATT_SRVC_ID));
728 memcpy(&p_buf->char_id, &p_char_id->char_id, sizeof(tBTA_GATT_ID));
729
730 p_buf->write_type = BTA_GATTC_WRITE_PREPARE;
731 p_buf->offset = offset;
732 p_buf->len = len;
733
734 if (p_value && len > 0)
735 {
736 p_buf->p_value = (UINT8 *)(p_buf + 1);
737 memcpy(p_buf->p_value, p_value, len);
738 }
739
740 bta_sys_sendmsg(p_buf);
741 }
742 return;
743
744 }
745 /*******************************************************************************
746 **
747 ** Function BTA_GATTC_ExecuteWrite
748 **
749 ** Description This function is called to execute write a prepare write sequence.
750 **
751 ** Parameters conn_id - connection ID.
752 ** is_execute - execute or cancel.
753 **
754 ** Returns None
755 **
756 *******************************************************************************/
BTA_GATTC_ExecuteWrite(UINT16 conn_id,BOOLEAN is_execute)757 void BTA_GATTC_ExecuteWrite (UINT16 conn_id, BOOLEAN is_execute)
758 {
759 tBTA_GATTC_API_EXEC *p_buf;
760
761 if ((p_buf = (tBTA_GATTC_API_EXEC *) GKI_getbuf((UINT16)sizeof(tBTA_GATTC_API_EXEC))) != NULL)
762 {
763 memset(p_buf, 0, sizeof(tBTA_GATTC_API_EXEC));
764
765 p_buf->hdr.event = BTA_GATTC_API_EXEC_EVT;
766 p_buf->hdr.layer_specific = conn_id;
767
768 p_buf->is_execute = is_execute;
769
770 bta_sys_sendmsg(p_buf);
771 }
772 return;
773
774 }
775 /*******************************************************************************
776 **
777 ** Function BTA_GATTC_SendIndConfirm
778 **
779 ** Description This function is called to send handle value confirmation.
780 **
781 ** Parameters conn_id - connection ID.
782 ** p_char_id - characteristic ID to confirm.
783 **
784 ** Returns None
785 **
786 *******************************************************************************/
BTA_GATTC_SendIndConfirm(UINT16 conn_id,tBTA_GATTC_CHAR_ID * p_char_id)787 void BTA_GATTC_SendIndConfirm (UINT16 conn_id, tBTA_GATTC_CHAR_ID *p_char_id)
788 {
789 tBTA_GATTC_API_CONFIRM *p_buf;
790
791 APPL_TRACE_API3("BTA_GATTC_SendIndConfirm conn_id=%d service uuid1=0x%x char uuid=0x%x",
792 conn_id, p_char_id->srvc_id.id.uuid.uu.uuid16, p_char_id->char_id.uuid.uu.uuid16); //toto
793
794 if ((p_buf = (tBTA_GATTC_API_CONFIRM *) GKI_getbuf(sizeof(tBTA_GATTC_API_CONFIRM))) != NULL)
795 {
796 memset(p_buf, 0, sizeof(tBTA_GATTC_API_CONFIRM));
797
798 p_buf->hdr.event = BTA_GATTC_API_CONFIRM_EVT;
799 p_buf->hdr.layer_specific = conn_id;
800
801 memcpy(&p_buf->srvc_id, &p_char_id->srvc_id, sizeof(tBTA_GATT_SRVC_ID));
802 memcpy(&p_buf->char_id, &p_char_id->char_id, sizeof(tBTA_GATT_ID));
803
804 bta_sys_sendmsg(p_buf);
805 }
806 return;
807
808 }
809
810 /*******************************************************************************
811 **
812 ** Function BTA_GATTC_RegisterForNotifications
813 **
814 ** Description This function is called to register for notification of a service.
815 **
816 ** Parameters client_if - client interface.
817 ** bda - target GATT server.
818 ** p_char_id - pointer to GATT characteristic ID.
819 **
820 ** Returns OK if registration succeed, otherwise failed.
821 **
822 *******************************************************************************/
BTA_GATTC_RegisterForNotifications(tBTA_GATTC_IF client_if,BD_ADDR bda,tBTA_GATTC_CHAR_ID * p_char_id)823 tBTA_GATT_STATUS BTA_GATTC_RegisterForNotifications (tBTA_GATTC_IF client_if,
824 BD_ADDR bda,
825 tBTA_GATTC_CHAR_ID *p_char_id)
826 {
827 tBTA_GATTC_RCB *p_clreg;
828 tBTA_GATT_STATUS status = BTA_GATT_ILLEGAL_PARAMETER;
829 UINT8 i;
830
831 if (!p_char_id)
832 {
833 APPL_TRACE_ERROR0("deregistration failed, unknow char id");
834 return status;
835 }
836
837 /* lock other GKI task */
838 GKI_sched_lock();
839
840 if ((p_clreg = bta_gattc_cl_get_regcb(client_if)) != NULL)
841 {
842 for (i = 0; i < BTA_GATTC_NOTIF_REG_MAX; i ++)
843 {
844 if (!p_clreg->notif_reg[i].in_use)
845 {
846 memset(&p_clreg->notif_reg, 0, sizeof(tBTA_GATTC_NOTIF_REG));
847
848 p_clreg->notif_reg[i].in_use = TRUE;
849 memcpy(p_clreg->notif_reg[i].remote_bda, bda, BD_ADDR_LEN);
850 memcpy(&p_clreg->notif_reg[i].char_id, p_char_id, sizeof(tBTA_GATTC_CHAR_ID));
851
852 status = BTA_GATT_OK;
853 break;
854 }
855 }
856 if (i == BTA_GATTC_NOTIF_REG_MAX)
857 {
858 status = BTA_GATT_NO_RESOURCES;
859 APPL_TRACE_ERROR0("Max Notification Reached, registration failed.");
860 }
861 }
862 else
863 {
864 APPL_TRACE_ERROR1("Client_if: %d Not Registered", client_if);
865 }
866
867 GKI_sched_unlock();
868
869 return status;
870 }
871
872 /*******************************************************************************
873 **
874 ** Function BTA_GATTC_DeregisterForNotifications
875 **
876 ** Description This function is called to de-register for notification of a service.
877 **
878 ** Parameters client_if - client interface.
879 ** bda - target GATT server.
880 ** p_char_id - pointer to GATT characteristic ID.
881 **
882 ** Returns OK if deregistration succeed, otherwise failed.
883 **
884 *******************************************************************************/
BTA_GATTC_DeregisterForNotifications(tBTA_GATTC_IF client_if,BD_ADDR bda,tBTA_GATTC_CHAR_ID * p_char_id)885 tBTA_GATT_STATUS BTA_GATTC_DeregisterForNotifications (tBTA_GATTC_IF client_if,
886 BD_ADDR bda,
887 tBTA_GATTC_CHAR_ID *p_char_id)
888 {
889 tBTA_GATTC_RCB *p_clreg;
890 tBTA_GATT_STATUS status = BTA_GATT_ILLEGAL_PARAMETER;
891 UINT8 i;
892
893 if (!p_char_id)
894 {
895 APPL_TRACE_ERROR0("deregistration failed, unknow char id");
896 return status;
897 }
898
899 /* lock other GKI task */
900 GKI_sched_lock();
901
902 if ((p_clreg = bta_gattc_cl_get_regcb(client_if)) != NULL)
903 {
904 for (i = 0; i < BTA_GATTC_NOTIF_REG_MAX; i ++)
905 {
906 if (p_clreg->notif_reg[i].in_use &&
907 !memcmp(p_clreg->notif_reg[i].remote_bda, bda, BD_ADDR_LEN) &&
908 !memcmp(&p_clreg->notif_reg[i].char_id, p_char_id, sizeof(tBTA_GATTC_CHAR_ID)))
909 {
910 APPL_TRACE_DEBUG0("Deregistered.");
911
912 memset(&p_clreg->notif_reg[i], 0, sizeof(tBTA_GATTC_NOTIF_REG));
913 status = BTA_GATT_OK;
914 break;
915 }
916 }
917 if (i == BTA_GATTC_NOTIF_REG_MAX)
918 {
919 status = BTA_GATT_ERROR;
920
921 APPL_TRACE_ERROR0("registration not found");
922 }
923 }
924 else
925 {
926 APPL_TRACE_ERROR1("Client_if: %d Not Registered", client_if);
927 }
928
929 GKI_sched_unlock();
930
931 return status;
932 }
933
934 #endif /* BTA_GATT_INCLUDED */
935