1 /******************************************************************************
2 *
3 * Copyright (C) 2009-2014 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 *
22 * Filename: btif_gatt_client.c
23 *
24 * Description: GATT client implementation
25 *
26 *******************************************************************************/
27
28 #include <hardware/bluetooth.h>
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <errno.h>
32 #include <string.h>
33
34 #define LOG_TAG "bt_btif_gattc"
35
36 #include "btcore/include/bdaddr.h"
37 #include "btif_common.h"
38 #include "btif_util.h"
39
40 #if (defined(BLE_INCLUDED) && (BLE_INCLUDED == TRUE))
41
42 #include "btif_gatt_multi_adv_util.h"
43 #include <hardware/bt_gatt.h>
44 #include "bta_api.h"
45 #include "bta_gatt_api.h"
46 #include "btif_storage.h"
47 #include "btif_config.h"
48
49 #include "btif_gatt.h"
50 #include "btif_gatt_util.h"
51 #include "btif_dm.h"
52 #include "btif_storage.h"
53
54 #include "osi/include/log.h"
55 #include "vendor_api.h"
56
57 /*******************************************************************************
58 ** Constants & Macros
59 ********************************************************************************/
60
61 #define CHECK_BTGATT_INIT() if (bt_gatt_callbacks == NULL)\
62 {\
63 LOG_WARN("%s: BTGATT not initialized", __FUNCTION__);\
64 return BT_STATUS_NOT_READY;\
65 } else {\
66 LOG_VERBOSE("%s", __FUNCTION__);\
67 }
68
69 #define BLE_RESOLVE_ADDR_MSB 0x40 /* bit7, bit6 is 01 to be resolvable random */
70 #define BLE_RESOLVE_ADDR_MASK 0xc0 /* bit 6, and bit7 */
71 #define BTM_BLE_IS_RESOLVE_BDA(x) ((x[0] & BLE_RESOLVE_ADDR_MASK) == BLE_RESOLVE_ADDR_MSB)
72
73 typedef enum {
74 BTIF_GATTC_REGISTER_APP = 1000,
75 BTIF_GATTC_UNREGISTER_APP,
76 BTIF_GATTC_SCAN_START,
77 BTIF_GATTC_SCAN_STOP,
78 BTIF_GATTC_OPEN,
79 BTIF_GATTC_CLOSE,
80 BTIF_GATTC_SEARCH_SERVICE,
81 BTIF_GATTC_GET_FIRST_CHAR,
82 BTIF_GATTC_GET_NEXT_CHAR,
83 BTIF_GATTC_GET_FIRST_CHAR_DESCR,
84 BTIF_GATTC_GET_NEXT_CHAR_DESCR,
85 BTIF_GATTC_GET_FIRST_INCL_SERVICE,
86 BTIF_GATTC_GET_NEXT_INCL_SERVICE,
87 BTIF_GATTC_READ_CHAR,
88 BTIF_GATTC_READ_CHAR_DESCR,
89 BTIF_GATTC_WRITE_CHAR,
90 BTIF_GATTC_WRITE_CHAR_DESCR,
91 BTIF_GATTC_EXECUTE_WRITE,
92 BTIF_GATTC_REG_FOR_NOTIFICATION,
93 BTIF_GATTC_DEREG_FOR_NOTIFICATION,
94 BTIF_GATTC_REFRESH,
95 BTIF_GATTC_READ_RSSI,
96 BTIF_GATTC_LISTEN,
97 BTIF_GATTC_SET_ADV_DATA,
98 BTIF_GATTC_CONFIGURE_MTU,
99 BTIF_GATTC_CONN_PARAM_UPDT,
100 BTIF_GATTC_SCAN_FILTER_PARAM_SETUP,
101 BTIF_GATTC_SCAN_FILTER_CONFIG,
102 BTIF_GATTC_SCAN_FILTER_CLEAR,
103 BTIF_GATTC_SCAN_FILTER_ENABLE,
104 BTIF_GATTC_SET_SCAN_PARAMS,
105 BTIF_GATTC_ADV_INSTANCE_ENABLE,
106 BTIF_GATTC_ADV_INSTANCE_UPDATE,
107 BTIF_GATTC_ADV_INSTANCE_SET_DATA,
108 BTIF_GATTC_ADV_INSTANCE_DISABLE,
109 BTIF_GATTC_CONFIG_STORAGE_PARAMS,
110 BTIF_GATTC_ENABLE_BATCH_SCAN,
111 BTIF_GATTC_READ_BATCH_SCAN_REPORTS,
112 BTIF_GATTC_DISABLE_BATCH_SCAN
113 } btif_gattc_event_t;
114
115 #define BTIF_GATT_MAX_OBSERVED_DEV 40
116
117 #define BTIF_GATT_OBSERVE_EVT 0x1000
118 #define BTIF_GATTC_RSSI_EVT 0x1001
119 #define BTIF_GATTC_SCAN_FILTER_EVT 0x1003
120 #define BTIF_GATTC_SCAN_PARAM_EVT 0x1004
121
122 #define ENABLE_BATCH_SCAN 1
123 #define DISABLE_BATCH_SCAN 0
124
125 /*******************************************************************************
126 ** Local type definitions
127 ********************************************************************************/
128 typedef struct
129 {
130 uint8_t report_format;
131 uint16_t data_len;
132 uint8_t num_records;
133 uint8_t *p_rep_data;
134 } btgatt_batch_reports;
135
136 typedef struct
137 {
138 uint8_t status;
139 uint8_t client_if;
140 uint8_t action;
141 uint8_t avbl_space;
142 uint8_t lost_timeout;
143 tBLE_ADDR_TYPE addr_type;
144 uint8_t batch_scan_full_max;
145 uint8_t batch_scan_trunc_max;
146 uint8_t batch_scan_notify_threshold;
147 tBTA_BLE_BATCH_SCAN_MODE scan_mode;
148 uint32_t scan_interval;
149 uint32_t scan_window;
150 tBTA_BLE_DISCARD_RULE discard_rule;
151 btgatt_batch_reports read_reports;
152 } btgatt_batch_track_cb_t;
153
154
155 typedef tBTA_DM_BLE_PF_FILT_PARAMS btgatt_adv_filt_param_t;
156
157 typedef struct
158 {
159 uint8_t client_if;
160 uint8_t action;
161 tBTA_DM_BLE_PF_COND_TYPE filt_type;
162 bt_bdaddr_t bd_addr;
163 uint8_t value[BTGATT_MAX_ATTR_LEN];
164 uint8_t value_len;
165 uint8_t filt_index;
166 uint16_t conn_id;
167 uint16_t company_id_mask;
168 bt_uuid_t uuid;
169 bt_uuid_t uuid_mask;
170 uint8_t value_mask[BTGATT_MAX_ATTR_LEN];
171 uint8_t value_mask_len;
172 uint8_t has_mask;
173 uint8_t addr_type;
174 uint8_t status;
175 tBTA_DM_BLE_PF_AVBL_SPACE avbl_space;
176 tBTA_DM_BLE_SCAN_COND_OP cond_op;
177 btgatt_adv_filt_param_t adv_filt_param;
178 } btgatt_adv_filter_cb_t;
179
180 typedef struct
181 {
182 uint8_t value[BTGATT_MAX_ATTR_LEN];
183 uint8_t inst_id;
184 bt_bdaddr_t bd_addr;
185 btgatt_srvc_id_t srvc_id;
186 btgatt_srvc_id_t incl_srvc_id;
187 btgatt_gatt_id_t char_id;
188 btgatt_gatt_id_t descr_id;
189 bt_uuid_t uuid;
190 bt_uuid_t uuid_mask;
191 uint16_t conn_id;
192 uint16_t len;
193 uint16_t mask;
194 uint32_t scan_interval;
195 uint32_t scan_window;
196 uint8_t client_if;
197 uint8_t action;
198 uint8_t is_direct;
199 uint8_t search_all;
200 uint8_t auth_req;
201 uint8_t write_type;
202 uint8_t status;
203 uint8_t addr_type;
204 uint8_t start;
205 uint8_t has_mask;
206 int8_t rssi;
207 uint8_t flag;
208 tBT_DEVICE_TYPE device_type;
209 btgatt_transport_t transport;
210 } __attribute__((packed)) btif_gattc_cb_t;
211
212 typedef struct
213 {
214 bt_bdaddr_t bd_addr;
215 uint16_t min_interval;
216 uint16_t max_interval;
217 uint16_t timeout;
218 uint16_t latency;
219 } btif_conn_param_cb_t;
220
221 typedef struct
222 {
223 bt_bdaddr_t bd_addr;
224 BOOLEAN in_use;
225 }__attribute__((packed)) btif_gattc_dev_t;
226
227 typedef struct
228 {
229 btif_gattc_dev_t remote_dev[BTIF_GATT_MAX_OBSERVED_DEV];
230 uint8_t addr_type;
231 uint8_t next_storage_idx;
232 }__attribute__((packed)) btif_gattc_dev_cb_t;
233
234 /*******************************************************************************
235 ** Static variables
236 ********************************************************************************/
237
238 extern const btgatt_callbacks_t *bt_gatt_callbacks;
239 static btif_gattc_dev_cb_t btif_gattc_dev_cb;
240 static btif_gattc_dev_cb_t *p_dev_cb = &btif_gattc_dev_cb;
241 static uint8_t rssi_request_client_if;
242
243 /*******************************************************************************
244 ** Static functions
245 ********************************************************************************/
246
247 static bt_status_t btif_gattc_multi_adv_disable(int client_if);
btif_multi_adv_stop_cb(void * p_tle)248 static void btif_multi_adv_stop_cb(void *p_tle)
249 {
250 int client_if = ((TIMER_LIST_ENT*)p_tle)->data;
251 btif_gattc_multi_adv_disable(client_if); // Does context switch
252 }
253
btif_gattc_translate_btm_status(tBTM_STATUS status)254 static btgattc_error_t btif_gattc_translate_btm_status(tBTM_STATUS status)
255 {
256 switch(status)
257 {
258 case BTM_SUCCESS:
259 case BTM_SUCCESS_NO_SECURITY:
260 return BT_GATTC_COMMAND_SUCCESS;
261
262 case BTM_CMD_STARTED:
263 return BT_GATTC_COMMAND_STARTED;
264
265 case BTM_BUSY:
266 return BT_GATTC_COMMAND_BUSY;
267
268 case BTM_CMD_STORED:
269 return BT_GATTC_COMMAND_STORED;
270
271 case BTM_NO_RESOURCES:
272 return BT_GATTC_NO_RESOURCES;
273
274 case BTM_MODE_UNSUPPORTED:
275 case BTM_WRONG_MODE:
276 case BTM_MODE4_LEVEL4_NOT_SUPPORTED:
277 return BT_GATTC_MODE_UNSUPPORTED;
278
279 case BTM_ILLEGAL_VALUE:
280 case BTM_SCO_BAD_LENGTH:
281 return BT_GATTC_ILLEGAL_VALUE;
282
283 case BTM_UNKNOWN_ADDR:
284 return BT_GATTC_UNKNOWN_ADDR;
285
286 case BTM_DEVICE_TIMEOUT:
287 return BT_GATTC_DEVICE_TIMEOUT;
288
289 case BTM_FAILED_ON_SECURITY:
290 case BTM_REPEATED_ATTEMPTS:
291 case BTM_NOT_AUTHORIZED:
292 return BT_GATTC_SECURITY_ERROR;
293
294 case BTM_DEV_RESET:
295 case BTM_ILLEGAL_ACTION:
296 return BT_GATTC_INCORRECT_STATE;
297
298 case BTM_BAD_VALUE_RET:
299 return BT_GATTC_INVALID_CONTROLLER_OUTPUT;
300
301 case BTM_DELAY_CHECK:
302 return BT_GATTC_DELAYED_ENCRYPTION_CHECK;
303
304 case BTM_ERR_PROCESSING:
305 default:
306 return BT_GATTC_ERR_PROCESSING;
307 }
308 }
309
btapp_gattc_req_data(UINT16 event,char * p_dest,char * p_src)310 static void btapp_gattc_req_data(UINT16 event, char *p_dest, char *p_src)
311 {
312 tBTA_GATTC *p_dest_data = (tBTA_GATTC*) p_dest;
313 tBTA_GATTC *p_src_data = (tBTA_GATTC*) p_src;
314
315 if (!p_src_data || !p_dest_data)
316 return;
317
318 // Copy basic structure first
319 memcpy(p_dest_data, p_src_data, sizeof(tBTA_GATTC));
320
321 // Allocate buffer for request data if necessary
322 switch (event)
323 {
324 case BTA_GATTC_READ_CHAR_EVT:
325 case BTA_GATTC_READ_DESCR_EVT:
326
327 if (p_src_data->read.p_value != NULL)
328 {
329 p_dest_data->read.p_value = GKI_getbuf(sizeof(tBTA_GATT_READ_VAL));
330
331 if (p_dest_data->read.p_value != NULL)
332 {
333 memcpy(p_dest_data->read.p_value, p_src_data->read.p_value,
334 sizeof(tBTA_GATT_READ_VAL));
335
336 // Allocate buffer for att value if necessary
337 if (get_uuid16(&p_src_data->read.descr_type.uuid) != GATT_UUID_CHAR_AGG_FORMAT
338 && p_src_data->read.p_value->unformat.len > 0
339 && p_src_data->read.p_value->unformat.p_value != NULL)
340 {
341 p_dest_data->read.p_value->unformat.p_value =
342 GKI_getbuf(p_src_data->read.p_value->unformat.len);
343 if (p_dest_data->read.p_value->unformat.p_value != NULL)
344 {
345 memcpy(p_dest_data->read.p_value->unformat.p_value,
346 p_src_data->read.p_value->unformat.p_value,
347 p_src_data->read.p_value->unformat.len);
348 }
349 }
350 }
351 }
352 else
353 {
354 BTIF_TRACE_WARNING("%s :Src read.p_value ptr is NULL for event 0x%x",
355 __FUNCTION__, event);
356 p_dest_data->read.p_value = NULL;
357
358 }
359 break;
360
361 default:
362 break;
363 }
364 }
365
btapp_gattc_free_req_data(UINT16 event,tBTA_GATTC * p_data)366 static void btapp_gattc_free_req_data(UINT16 event, tBTA_GATTC *p_data)
367 {
368 switch (event)
369 {
370 case BTA_GATTC_READ_CHAR_EVT:
371 case BTA_GATTC_READ_DESCR_EVT:
372 if (p_data != NULL && p_data->read.p_value != NULL)
373 {
374 if (get_uuid16 (&p_data->read.descr_type.uuid) != GATT_UUID_CHAR_AGG_FORMAT
375 && p_data->read.p_value->unformat.len > 0
376 && p_data->read.p_value->unformat.p_value != NULL)
377 {
378 GKI_freebuf(p_data->read.p_value->unformat.p_value);
379 }
380 GKI_freebuf(p_data->read.p_value);
381 }
382 break;
383
384 default:
385 break;
386 }
387 }
388
btif_gattc_init_dev_cb(void)389 static void btif_gattc_init_dev_cb(void)
390 {
391 memset(p_dev_cb, 0, sizeof(btif_gattc_dev_cb_t));
392 }
393
btif_gattc_add_remote_bdaddr(BD_ADDR p_bda,uint8_t addr_type)394 static void btif_gattc_add_remote_bdaddr (BD_ADDR p_bda, uint8_t addr_type)
395 {
396 uint8_t i;
397 for (i = 0; i < BTIF_GATT_MAX_OBSERVED_DEV; i++)
398 {
399 if (!p_dev_cb->remote_dev[i].in_use )
400 {
401 memcpy(p_dev_cb->remote_dev[i].bd_addr.address, p_bda, BD_ADDR_LEN);
402 p_dev_cb->addr_type = addr_type;
403 p_dev_cb->remote_dev[i].in_use = TRUE;
404 LOG_VERBOSE("%s device added idx=%d", __FUNCTION__, i );
405 break;
406 }
407 }
408
409 if ( i == BTIF_GATT_MAX_OBSERVED_DEV)
410 {
411 i= p_dev_cb->next_storage_idx;
412 memcpy(p_dev_cb->remote_dev[i].bd_addr.address, p_bda, BD_ADDR_LEN);
413 p_dev_cb->addr_type = addr_type;
414 p_dev_cb->remote_dev[i].in_use = TRUE;
415 LOG_VERBOSE("%s device overwrite idx=%d", __FUNCTION__, i );
416 p_dev_cb->next_storage_idx++;
417 if (p_dev_cb->next_storage_idx >= BTIF_GATT_MAX_OBSERVED_DEV)
418 p_dev_cb->next_storage_idx = 0;
419 }
420 }
421
btif_gattc_find_bdaddr(BD_ADDR p_bda)422 static BOOLEAN btif_gattc_find_bdaddr (BD_ADDR p_bda)
423 {
424 uint8_t i;
425 for (i = 0; i < BTIF_GATT_MAX_OBSERVED_DEV; i++)
426 {
427 if (p_dev_cb->remote_dev[i].in_use &&
428 !memcmp(p_dev_cb->remote_dev[i].bd_addr.address, p_bda, BD_ADDR_LEN))
429 {
430 return TRUE;
431 }
432 }
433 return FALSE;
434 }
435
btif_gattc_update_properties(btif_gattc_cb_t * p_btif_cb)436 static void btif_gattc_update_properties ( btif_gattc_cb_t *p_btif_cb )
437 {
438 uint8_t remote_name_len;
439 uint8_t *p_eir_remote_name=NULL;
440 bt_bdname_t bdname;
441
442 p_eir_remote_name = BTM_CheckEirData(p_btif_cb->value,
443 BTM_EIR_COMPLETE_LOCAL_NAME_TYPE, &remote_name_len);
444
445 if (p_eir_remote_name == NULL)
446 {
447 p_eir_remote_name = BTM_CheckEirData(p_btif_cb->value,
448 BT_EIR_SHORTENED_LOCAL_NAME_TYPE, &remote_name_len);
449 }
450
451 if (p_eir_remote_name)
452 {
453 memcpy(bdname.name, p_eir_remote_name, remote_name_len);
454 bdname.name[remote_name_len]='\0';
455
456 LOG_DEBUG("%s BLE device name=%s len=%d dev_type=%d", __FUNCTION__, bdname.name,
457 remote_name_len, p_btif_cb->device_type );
458 btif_dm_update_ble_remote_properties( p_btif_cb->bd_addr.address, bdname.name,
459 p_btif_cb->device_type);
460 }
461
462 btif_storage_set_remote_addr_type( &p_btif_cb->bd_addr, p_btif_cb->addr_type);
463 }
464
btif_gattc_upstreams_evt(uint16_t event,char * p_param)465 static void btif_gattc_upstreams_evt(uint16_t event, char* p_param)
466 {
467 LOG_VERBOSE("%s: Event %d", __FUNCTION__, event);
468
469 tBTA_GATTC *p_data = (tBTA_GATTC*) p_param;
470 switch (event)
471 {
472 case BTA_GATTC_REG_EVT:
473 {
474 bt_uuid_t app_uuid;
475 bta_to_btif_uuid(&app_uuid, &p_data->reg_oper.app_uuid);
476 HAL_CBACK(bt_gatt_callbacks, client->register_client_cb
477 , p_data->reg_oper.status
478 , p_data->reg_oper.client_if
479 , &app_uuid
480 );
481 break;
482 }
483
484 case BTA_GATTC_DEREG_EVT:
485 break;
486
487 case BTA_GATTC_READ_CHAR_EVT:
488 {
489 btgatt_read_params_t data;
490 set_read_value(&data, &p_data->read);
491
492 HAL_CBACK(bt_gatt_callbacks, client->read_characteristic_cb
493 , p_data->read.conn_id, p_data->read.status, &data);
494 break;
495 }
496
497 case BTA_GATTC_WRITE_CHAR_EVT:
498 case BTA_GATTC_PREP_WRITE_EVT:
499 {
500 btgatt_write_params_t data;
501 bta_to_btif_srvc_id(&data.srvc_id, &p_data->write.srvc_id);
502 bta_to_btif_gatt_id(&data.char_id, &p_data->write.char_id);
503
504 HAL_CBACK(bt_gatt_callbacks, client->write_characteristic_cb
505 , p_data->write.conn_id, p_data->write.status, &data
506 );
507 break;
508 }
509
510 case BTA_GATTC_EXEC_EVT:
511 {
512 HAL_CBACK(bt_gatt_callbacks, client->execute_write_cb
513 , p_data->exec_cmpl.conn_id, p_data->exec_cmpl.status
514 );
515 break;
516 }
517
518 case BTA_GATTC_SEARCH_CMPL_EVT:
519 {
520 HAL_CBACK(bt_gatt_callbacks, client->search_complete_cb
521 , p_data->search_cmpl.conn_id, p_data->search_cmpl.status);
522 break;
523 }
524
525 case BTA_GATTC_SEARCH_RES_EVT:
526 {
527 btgatt_srvc_id_t data;
528 bta_to_btif_srvc_id(&data, &(p_data->srvc_res.service_uuid));
529 HAL_CBACK(bt_gatt_callbacks, client->search_result_cb
530 , p_data->srvc_res.conn_id, &data);
531 break;
532 }
533
534 case BTA_GATTC_READ_DESCR_EVT:
535 {
536 btgatt_read_params_t data;
537 set_read_value(&data, &p_data->read);
538
539 HAL_CBACK(bt_gatt_callbacks, client->read_descriptor_cb
540 , p_data->read.conn_id, p_data->read.status, &data);
541 break;
542 }
543
544 case BTA_GATTC_WRITE_DESCR_EVT:
545 {
546 btgatt_write_params_t data;
547 bta_to_btif_srvc_id(&data.srvc_id, &p_data->write.srvc_id);
548 bta_to_btif_gatt_id(&data.char_id, &p_data->write.char_id);
549 bta_to_btif_gatt_id(&data.descr_id, &p_data->write.descr_type);
550
551 HAL_CBACK(bt_gatt_callbacks, client->write_descriptor_cb
552 , p_data->write.conn_id, p_data->write.status, &data);
553 break;
554 }
555
556 case BTA_GATTC_NOTIF_EVT:
557 {
558 btgatt_notify_params_t data;
559
560 bdcpy(data.bda.address, p_data->notify.bda);
561
562 bta_to_btif_srvc_id(&data.srvc_id, &p_data->notify.char_id.srvc_id);
563 bta_to_btif_gatt_id(&data.char_id, &p_data->notify.char_id.char_id);
564 memcpy(data.value, p_data->notify.value, p_data->notify.len);
565
566 data.is_notify = p_data->notify.is_notify;
567 data.len = p_data->notify.len;
568
569 HAL_CBACK(bt_gatt_callbacks, client->notify_cb
570 , p_data->notify.conn_id, &data);
571
572 if (p_data->notify.is_notify == FALSE)
573 {
574 BTA_GATTC_SendIndConfirm(p_data->notify.conn_id,
575 &p_data->notify.char_id);
576 }
577 break;
578 }
579
580 case BTA_GATTC_OPEN_EVT:
581 {
582 bt_bdaddr_t bda;
583 bdcpy(bda.address, p_data->open.remote_bda);
584
585 HAL_CBACK(bt_gatt_callbacks, client->open_cb, p_data->open.conn_id
586 , p_data->open.status, p_data->open.client_if, &bda);
587
588 if (GATT_DEF_BLE_MTU_SIZE != p_data->open.mtu && p_data->open.mtu)
589 {
590 HAL_CBACK(bt_gatt_callbacks, client->configure_mtu_cb, p_data->open.conn_id
591 , p_data->open.status , p_data->open.mtu);
592 }
593
594 if (p_data->open.status == BTA_GATT_OK)
595 btif_gatt_check_encrypted_link(p_data->open.remote_bda, p_data->open.transport);
596 break;
597 }
598
599 case BTA_GATTC_CLOSE_EVT:
600 {
601 bt_bdaddr_t bda;
602 bdcpy(bda.address, p_data->close.remote_bda);
603 HAL_CBACK(bt_gatt_callbacks, client->close_cb, p_data->close.conn_id
604 , p_data->status, p_data->close.client_if, &bda);
605 break;
606 }
607
608 case BTA_GATTC_ACL_EVT:
609 LOG_DEBUG("BTA_GATTC_ACL_EVT: status = %d", p_data->status);
610 /* Ignore for now */
611 break;
612
613 case BTA_GATTC_CANCEL_OPEN_EVT:
614 break;
615
616 case BTIF_GATT_OBSERVE_EVT:
617 {
618 btif_gattc_cb_t *p_btif_cb = (btif_gattc_cb_t*) p_param;
619 uint8_t remote_name_len;
620 uint8_t *p_eir_remote_name=NULL;
621 bt_device_type_t dev_type;
622 bt_property_t properties;
623
624 p_eir_remote_name = BTM_CheckEirData(p_btif_cb->value,
625 BTM_EIR_COMPLETE_LOCAL_NAME_TYPE, &remote_name_len);
626
627 if (p_eir_remote_name == NULL)
628 {
629 p_eir_remote_name = BTM_CheckEirData(p_btif_cb->value,
630 BT_EIR_SHORTENED_LOCAL_NAME_TYPE, &remote_name_len);
631 }
632
633 if ((p_btif_cb->addr_type != BLE_ADDR_RANDOM) || (p_eir_remote_name))
634 {
635 if (!btif_gattc_find_bdaddr(p_btif_cb->bd_addr.address))
636 {
637 btif_gattc_add_remote_bdaddr(p_btif_cb->bd_addr.address, p_btif_cb->addr_type);
638 btif_gattc_update_properties(p_btif_cb);
639 }
640 }
641
642 dev_type = p_btif_cb->device_type;
643 BTIF_STORAGE_FILL_PROPERTY(&properties,
644 BT_PROPERTY_TYPE_OF_DEVICE, sizeof(dev_type), &dev_type);
645 btif_storage_set_remote_device_property(&(p_btif_cb->bd_addr), &properties);
646
647 HAL_CBACK(bt_gatt_callbacks, client->scan_result_cb,
648 &p_btif_cb->bd_addr, p_btif_cb->rssi, p_btif_cb->value);
649 break;
650 }
651
652 case BTIF_GATTC_RSSI_EVT:
653 {
654 btif_gattc_cb_t *p_btif_cb = (btif_gattc_cb_t*) p_param;
655 HAL_CBACK(bt_gatt_callbacks, client->read_remote_rssi_cb, p_btif_cb->client_if,
656 &p_btif_cb->bd_addr, p_btif_cb->rssi, p_btif_cb->status);
657 break;
658 }
659
660 case BTA_GATTC_LISTEN_EVT:
661 {
662 HAL_CBACK(bt_gatt_callbacks, client->listen_cb
663 , p_data->reg_oper.status
664 , p_data->reg_oper.client_if
665 );
666 break;
667 }
668
669 case BTA_GATTC_CFG_MTU_EVT:
670 {
671 HAL_CBACK(bt_gatt_callbacks, client->configure_mtu_cb, p_data->cfg_mtu.conn_id
672 , p_data->cfg_mtu.status , p_data->cfg_mtu.mtu);
673 break;
674 }
675
676 case BTA_GATTC_MULT_ADV_ENB_EVT:
677 {
678 btif_gattc_cb_t *p_btif_cb = (btif_gattc_cb_t*) p_param;
679 if (0xFF != p_btif_cb->inst_id)
680 btif_multi_adv_add_instid_map(p_btif_cb->client_if, p_btif_cb->inst_id, false);
681 HAL_CBACK(bt_gatt_callbacks, client->multi_adv_enable_cb
682 , p_btif_cb->client_if
683 , p_btif_cb->status
684 );
685 btif_multi_adv_timer_ctrl(p_btif_cb->client_if,
686 (p_btif_cb->status==0 ? btif_multi_adv_stop_cb : NULL));
687 break;
688 }
689
690 case BTA_GATTC_MULT_ADV_UPD_EVT:
691 {
692 btif_gattc_cb_t *p_btif_cb = (btif_gattc_cb_t*) p_param;
693 HAL_CBACK(bt_gatt_callbacks, client->multi_adv_update_cb
694 , p_btif_cb->client_if
695 , p_btif_cb->status
696 );
697 btif_multi_adv_timer_ctrl(p_btif_cb->client_if,
698 (p_btif_cb->status==0 ? btif_multi_adv_stop_cb : NULL));
699 break;
700 }
701
702 case BTA_GATTC_MULT_ADV_DATA_EVT:
703 {
704 btif_gattc_cb_t *p_btif_cb = (btif_gattc_cb_t*) p_param;
705 btif_gattc_clear_clientif(p_btif_cb->client_if, FALSE);
706 HAL_CBACK(bt_gatt_callbacks, client->multi_adv_data_cb
707 , p_btif_cb->client_if
708 , p_btif_cb->status
709 );
710 break;
711 }
712
713 case BTA_GATTC_MULT_ADV_DIS_EVT:
714 {
715 btif_gattc_cb_t *p_btif_cb = (btif_gattc_cb_t*) p_param;
716 btif_gattc_clear_clientif(p_btif_cb->client_if, TRUE);
717 HAL_CBACK(bt_gatt_callbacks, client->multi_adv_disable_cb
718 , p_btif_cb->client_if
719 , p_btif_cb->status
720 );
721 break;
722 }
723
724 case BTA_GATTC_ADV_DATA_EVT:
725 {
726 btif_gattc_cleanup_inst_cb(STD_ADV_INSTID, FALSE);
727 /* No HAL callback available */
728 break;
729 }
730
731 case BTA_GATTC_CONGEST_EVT:
732 HAL_CBACK(bt_gatt_callbacks, client->congestion_cb
733 , p_data->congest.conn_id
734 , p_data->congest.congested
735 );
736 break;
737
738 case BTA_GATTC_BTH_SCAN_CFG_EVT:
739 {
740 btgatt_batch_track_cb_t *p_data = (btgatt_batch_track_cb_t*) p_param;
741 HAL_CBACK(bt_gatt_callbacks, client->batchscan_cfg_storage_cb
742 , p_data->client_if
743 , p_data->status
744 );
745 break;
746 }
747
748 case BTA_GATTC_BTH_SCAN_ENB_EVT:
749 {
750 btgatt_batch_track_cb_t *p_data = (btgatt_batch_track_cb_t*) p_param;
751 HAL_CBACK(bt_gatt_callbacks, client->batchscan_enb_disable_cb
752 , ENABLE_BATCH_SCAN
753 , p_data->client_if
754 , p_data->status);
755 break;
756 }
757
758 case BTA_GATTC_BTH_SCAN_DIS_EVT:
759 {
760 btgatt_batch_track_cb_t *p_data = (btgatt_batch_track_cb_t*) p_param;
761 HAL_CBACK(bt_gatt_callbacks, client->batchscan_enb_disable_cb
762 , DISABLE_BATCH_SCAN
763 , p_data->client_if
764 , p_data->status);
765 break;
766 }
767
768 case BTA_GATTC_BTH_SCAN_THR_EVT:
769 {
770 btgatt_batch_track_cb_t *p_data = (btgatt_batch_track_cb_t*) p_param;
771 HAL_CBACK(bt_gatt_callbacks, client->batchscan_threshold_cb
772 , p_data->client_if);
773 break;
774 }
775
776 case BTA_GATTC_BTH_SCAN_RD_EVT:
777 {
778 btgatt_batch_track_cb_t *p_data = (btgatt_batch_track_cb_t*) p_param;
779 uint8_t *p_rep_data = NULL;
780
781 if (p_data->read_reports.data_len > 0 && NULL != p_data->read_reports.p_rep_data)
782 {
783 p_rep_data = GKI_getbuf(p_data->read_reports.data_len);
784 memcpy(p_rep_data, p_data->read_reports.p_rep_data, p_data->read_reports.data_len);
785 }
786
787 HAL_CBACK(bt_gatt_callbacks, client->batchscan_reports_cb
788 , p_data->client_if, p_data->status, p_data->read_reports.report_format
789 , p_data->read_reports.num_records, p_data->read_reports.data_len, p_rep_data);
790 if (NULL != p_rep_data)
791 GKI_freebuf(p_rep_data);
792 break;
793 }
794
795 case BTA_GATTC_SCAN_FLT_CFG_EVT:
796 {
797 btgatt_adv_filter_cb_t *p_btif_cb = (btgatt_adv_filter_cb_t*) p_param;
798 HAL_CBACK(bt_gatt_callbacks, client->scan_filter_cfg_cb, p_btif_cb->action,
799 p_btif_cb->client_if, p_btif_cb->status, p_btif_cb->cond_op,
800 p_btif_cb->avbl_space);
801 break;
802 }
803
804 case BTA_GATTC_SCAN_FLT_PARAM_EVT:
805 {
806 btgatt_adv_filter_cb_t *p_data = (btgatt_adv_filter_cb_t*) p_param;
807 BTIF_TRACE_DEBUG("BTA_GATTC_SCAN_FLT_PARAM_EVT: %d, %d, %d, %d",p_data->client_if,
808 p_data->action, p_data->avbl_space, p_data->status);
809 HAL_CBACK(bt_gatt_callbacks, client->scan_filter_param_cb
810 , p_data->action, p_data->client_if, p_data->status
811 , p_data->avbl_space);
812 break;
813 }
814
815 case BTA_GATTC_SCAN_FLT_STATUS_EVT:
816 {
817 btgatt_adv_filter_cb_t *p_data = (btgatt_adv_filter_cb_t*) p_param;
818 BTIF_TRACE_DEBUG("BTA_GATTC_SCAN_FLT_STATUS_EVT: %d, %d, %d",p_data->client_if,
819 p_data->action, p_data->status);
820 HAL_CBACK(bt_gatt_callbacks, client->scan_filter_status_cb
821 , p_data->action, p_data->client_if, p_data->status);
822 break;
823 }
824
825 case BTA_GATTC_ADV_VSC_EVT:
826 {
827 btgatt_track_adv_info_t *p_data = (btgatt_track_adv_info_t*)p_param;
828 btgatt_track_adv_info_t adv_info_data;
829
830 memset(&adv_info_data, 0, sizeof(btgatt_track_adv_info_t));
831
832 btif_gatt_move_track_adv_data(&adv_info_data, p_data);
833 HAL_CBACK(bt_gatt_callbacks, client->track_adv_event_cb, &adv_info_data);
834 break;
835 }
836
837 case BTIF_GATTC_SCAN_PARAM_EVT:
838 {
839 btif_gattc_cb_t *p_btif_cb = (btif_gattc_cb_t *)p_param;
840 HAL_CBACK(bt_gatt_callbacks, client->scan_parameter_setup_completed_cb,
841 p_btif_cb->client_if, btif_gattc_translate_btm_status(p_btif_cb->status));
842 break;
843 }
844
845 default:
846 LOG_ERROR("%s: Unhandled event (%d)!", __FUNCTION__, event);
847 break;
848 }
849
850 btapp_gattc_free_req_data(event, p_data);
851 }
852
bta_gattc_cback(tBTA_GATTC_EVT event,tBTA_GATTC * p_data)853 static void bta_gattc_cback(tBTA_GATTC_EVT event, tBTA_GATTC *p_data)
854 {
855 bt_status_t status = btif_transfer_context(btif_gattc_upstreams_evt,
856 (uint16_t) event, (void*) p_data, sizeof(tBTA_GATTC), btapp_gattc_req_data);
857 ASSERTC(status == BT_STATUS_SUCCESS, "Context transfer failed!", status);
858 }
859
bta_gattc_multi_adv_cback(tBTA_BLE_MULTI_ADV_EVT event,UINT8 inst_id,void * p_ref,tBTA_STATUS call_status)860 static void bta_gattc_multi_adv_cback(tBTA_BLE_MULTI_ADV_EVT event, UINT8 inst_id,
861 void *p_ref, tBTA_STATUS call_status)
862 {
863 btif_gattc_cb_t btif_cb;
864 tBTA_GATTC_EVT upevt;
865 uint8_t client_if = 0;
866
867 if (NULL == p_ref)
868 {
869 BTIF_TRACE_WARNING("%s Invalid p_ref received",__FUNCTION__);
870 }
871 else
872 {
873 client_if = *(UINT8 *) p_ref;
874 }
875
876 BTIF_TRACE_DEBUG("%s -Inst ID %d, Status:%x, client_if:%d",__FUNCTION__,inst_id, call_status,
877 client_if);
878 btif_cb.status = call_status;
879 btif_cb.client_if = client_if;
880 btif_cb.inst_id = inst_id;
881
882 switch(event)
883 {
884 case BTA_BLE_MULTI_ADV_ENB_EVT:
885 upevt = BTA_GATTC_MULT_ADV_ENB_EVT;
886 break;
887
888 case BTA_BLE_MULTI_ADV_DISABLE_EVT:
889 upevt = BTA_GATTC_MULT_ADV_DIS_EVT;
890 break;
891
892 case BTA_BLE_MULTI_ADV_PARAM_EVT:
893 upevt = BTA_GATTC_MULT_ADV_UPD_EVT;
894 break;
895
896 case BTA_BLE_MULTI_ADV_DATA_EVT:
897 upevt = BTA_GATTC_MULT_ADV_DATA_EVT;
898 break;
899
900 default:
901 return;
902 }
903
904 bt_status_t status = btif_transfer_context(btif_gattc_upstreams_evt, (uint16_t) upevt,
905 (char*) &btif_cb, sizeof(btif_gattc_cb_t), NULL);
906 ASSERTC(status == BT_STATUS_SUCCESS, "Context transfer failed!", status);
907 }
908
bta_gattc_set_adv_data_cback(tBTA_STATUS call_status)909 static void bta_gattc_set_adv_data_cback(tBTA_STATUS call_status)
910 {
911 UNUSED(call_status);
912 btif_gattc_cb_t btif_cb;
913 btif_cb.status = call_status;
914 btif_cb.action = 0;
915 btif_transfer_context(btif_gattc_upstreams_evt, BTA_GATTC_ADV_DATA_EVT,
916 (char*) &btif_cb, sizeof(btif_gattc_cb_t), NULL);
917 }
918
bta_batch_scan_setup_cb(tBTA_BLE_BATCH_SCAN_EVT evt,tBTA_DM_BLE_REF_VALUE ref_value,tBTA_STATUS status)919 static void bta_batch_scan_setup_cb (tBTA_BLE_BATCH_SCAN_EVT evt,
920 tBTA_DM_BLE_REF_VALUE ref_value, tBTA_STATUS status)
921 {
922 UINT8 upevt = 0;
923 btgatt_batch_track_cb_t btif_scan_track_cb;
924
925 btif_scan_track_cb.status = status;
926 btif_scan_track_cb.client_if = ref_value;
927 BTIF_TRACE_DEBUG("bta_batch_scan_setup_cb-Status:%x, client_if:%d, evt=%d",
928 status, ref_value, evt);
929
930 switch(evt)
931 {
932 case BTA_BLE_BATCH_SCAN_ENB_EVT:
933 {
934 upevt = BTA_GATTC_BTH_SCAN_ENB_EVT;
935 break;
936 }
937
938 case BTA_BLE_BATCH_SCAN_DIS_EVT:
939 {
940 upevt = BTA_GATTC_BTH_SCAN_DIS_EVT;
941 break;
942 }
943
944 case BTA_BLE_BATCH_SCAN_CFG_STRG_EVT:
945 {
946 upevt = BTA_GATTC_BTH_SCAN_CFG_EVT;
947 break;
948 }
949
950 case BTA_BLE_BATCH_SCAN_DATA_EVT:
951 {
952 upevt = BTA_GATTC_BTH_SCAN_RD_EVT;
953 break;
954 }
955
956 case BTA_BLE_BATCH_SCAN_THRES_EVT:
957 {
958 upevt = BTA_GATTC_BTH_SCAN_THR_EVT;
959 break;
960 }
961
962 default:
963 return;
964 }
965
966 btif_transfer_context(btif_gattc_upstreams_evt, upevt,(char*) &btif_scan_track_cb,
967 sizeof(btgatt_batch_track_cb_t), NULL);
968
969 }
970
bta_batch_scan_threshold_cb(tBTA_DM_BLE_REF_VALUE ref_value)971 static void bta_batch_scan_threshold_cb(tBTA_DM_BLE_REF_VALUE ref_value)
972 {
973 btgatt_batch_track_cb_t btif_scan_track_cb;
974 btif_scan_track_cb.status = 0;
975 btif_scan_track_cb.client_if = ref_value;
976
977 BTIF_TRACE_DEBUG("%s - client_if:%d",__FUNCTION__, ref_value);
978
979 btif_transfer_context(btif_gattc_upstreams_evt, BTA_GATTC_BTH_SCAN_THR_EVT,
980 (char*) &btif_scan_track_cb, sizeof(btif_gattc_cb_t), NULL);
981 }
982
bta_batch_scan_reports_cb(tBTA_DM_BLE_REF_VALUE ref_value,UINT8 report_format,UINT8 num_records,UINT16 data_len,UINT8 * p_rep_data,tBTA_STATUS status)983 static void bta_batch_scan_reports_cb(tBTA_DM_BLE_REF_VALUE ref_value, UINT8 report_format,
984 UINT8 num_records, UINT16 data_len,
985 UINT8* p_rep_data, tBTA_STATUS status)
986 {
987 btgatt_batch_track_cb_t btif_scan_track_cb;
988 memset(&btif_scan_track_cb, 0, sizeof(btgatt_batch_track_cb_t));
989 BTIF_TRACE_DEBUG("%s - client_if:%d, %d, %d, %d",__FUNCTION__, ref_value, status, num_records,
990 data_len);
991
992 btif_scan_track_cb.status = status;
993
994 btif_scan_track_cb.client_if = ref_value;
995 btif_scan_track_cb.read_reports.report_format = report_format;
996 btif_scan_track_cb.read_reports.data_len = data_len;
997 btif_scan_track_cb.read_reports.num_records = num_records;
998
999 if (data_len > 0)
1000 {
1001 btif_scan_track_cb.read_reports.p_rep_data = GKI_getbuf(data_len);
1002 memcpy(btif_scan_track_cb.read_reports.p_rep_data, p_rep_data, data_len);
1003 GKI_freebuf(p_rep_data);
1004 }
1005
1006 btif_transfer_context(btif_gattc_upstreams_evt, BTA_GATTC_BTH_SCAN_RD_EVT,
1007 (char*) &btif_scan_track_cb, sizeof(btgatt_batch_track_cb_t), NULL);
1008
1009 if (data_len > 0)
1010 GKI_freebuf(btif_scan_track_cb.read_reports.p_rep_data);
1011 }
1012
bta_scan_results_cb(tBTA_DM_SEARCH_EVT event,tBTA_DM_SEARCH * p_data)1013 static void bta_scan_results_cb (tBTA_DM_SEARCH_EVT event, tBTA_DM_SEARCH *p_data)
1014 {
1015 btif_gattc_cb_t btif_cb;
1016 uint8_t len;
1017
1018 switch (event)
1019 {
1020 case BTA_DM_INQ_RES_EVT:
1021 {
1022 bdcpy(btif_cb.bd_addr.address, p_data->inq_res.bd_addr);
1023 btif_cb.device_type = p_data->inq_res.device_type;
1024 btif_cb.rssi = p_data->inq_res.rssi;
1025 btif_cb.addr_type = p_data->inq_res.ble_addr_type;
1026 btif_cb.flag = p_data->inq_res.flag;
1027 if (p_data->inq_res.p_eir)
1028 {
1029 memcpy(btif_cb.value, p_data->inq_res.p_eir, 62);
1030 if (BTM_CheckEirData(p_data->inq_res.p_eir, BTM_EIR_COMPLETE_LOCAL_NAME_TYPE,
1031 &len))
1032 {
1033 p_data->inq_res.remt_name_not_required = TRUE;
1034 }
1035 }
1036 }
1037 break;
1038
1039 case BTA_DM_INQ_CMPL_EVT:
1040 {
1041 BTIF_TRACE_DEBUG("%s BLE observe complete. Num Resp %d",
1042 __FUNCTION__,p_data->inq_cmpl.num_resps);
1043 return;
1044 }
1045
1046 default:
1047 BTIF_TRACE_WARNING("%s : Unknown event 0x%x", __FUNCTION__, event);
1048 return;
1049 }
1050 btif_transfer_context(btif_gattc_upstreams_evt, BTIF_GATT_OBSERVE_EVT,
1051 (char*) &btif_cb, sizeof(btif_gattc_cb_t), NULL);
1052 }
1053
bta_track_adv_event_cb(tBTA_DM_BLE_TRACK_ADV_DATA * p_track_adv_data)1054 static void bta_track_adv_event_cb(tBTA_DM_BLE_TRACK_ADV_DATA *p_track_adv_data)
1055 {
1056 btgatt_track_adv_info_t btif_scan_track_cb;
1057 BTIF_TRACE_DEBUG("%s",__FUNCTION__);
1058 btif_gatt_move_track_adv_data(&btif_scan_track_cb,
1059 (btgatt_track_adv_info_t*)p_track_adv_data);
1060
1061 btif_transfer_context(btif_gattc_upstreams_evt, BTA_GATTC_ADV_VSC_EVT,
1062 (char*) &btif_scan_track_cb, sizeof(btgatt_track_adv_info_t), NULL);
1063 }
1064
btm_read_rssi_cb(tBTM_RSSI_RESULTS * p_result)1065 static void btm_read_rssi_cb (tBTM_RSSI_RESULTS *p_result)
1066 {
1067 btif_gattc_cb_t btif_cb;
1068
1069 bdcpy(btif_cb.bd_addr.address, p_result->rem_bda);
1070 btif_cb.rssi = p_result->rssi;
1071 btif_cb.status = p_result->status;
1072 btif_cb.client_if = rssi_request_client_if;
1073 btif_transfer_context(btif_gattc_upstreams_evt, BTIF_GATTC_RSSI_EVT,
1074 (char*) &btif_cb, sizeof(btif_gattc_cb_t), NULL);
1075 }
1076
bta_scan_param_setup_cb(tGATT_IF client_if,tBTM_STATUS status)1077 static void bta_scan_param_setup_cb(tGATT_IF client_if, tBTM_STATUS status)
1078 {
1079 btif_gattc_cb_t btif_cb;
1080
1081 btif_cb.status = status;
1082 btif_cb.client_if = client_if;
1083 btif_transfer_context(btif_gattc_upstreams_evt, BTIF_GATTC_SCAN_PARAM_EVT,
1084 (char *)&btif_cb, sizeof(btif_gattc_cb_t), NULL);
1085 }
1086
bta_scan_filt_cfg_cb(tBTA_DM_BLE_PF_ACTION action,tBTA_DM_BLE_SCAN_COND_OP cfg_op,tBTA_DM_BLE_PF_AVBL_SPACE avbl_space,tBTA_STATUS status,tBTA_DM_BLE_REF_VALUE ref_value)1087 static void bta_scan_filt_cfg_cb(tBTA_DM_BLE_PF_ACTION action, tBTA_DM_BLE_SCAN_COND_OP cfg_op,
1088 tBTA_DM_BLE_PF_AVBL_SPACE avbl_space, tBTA_STATUS status,
1089 tBTA_DM_BLE_REF_VALUE ref_value)
1090 {
1091 btgatt_adv_filter_cb_t btif_cb;
1092 btif_cb.status = status;
1093 btif_cb.action = action;
1094 btif_cb.cond_op = cfg_op;
1095 btif_cb.avbl_space = avbl_space;
1096 btif_cb.client_if = ref_value;
1097 btif_transfer_context(btif_gattc_upstreams_evt, BTA_GATTC_SCAN_FLT_CFG_EVT,
1098 (char*) &btif_cb, sizeof(btgatt_adv_filter_cb_t), NULL);
1099 }
1100
bta_scan_filt_param_setup_cb(UINT8 action_type,tBTA_DM_BLE_PF_AVBL_SPACE avbl_space,tBTA_DM_BLE_REF_VALUE ref_value,tBTA_STATUS status)1101 static void bta_scan_filt_param_setup_cb(UINT8 action_type,
1102 tBTA_DM_BLE_PF_AVBL_SPACE avbl_space,
1103 tBTA_DM_BLE_REF_VALUE ref_value, tBTA_STATUS status)
1104 {
1105 btgatt_adv_filter_cb_t btif_cb;
1106
1107 btif_cb.status = status;
1108 btif_cb.action = action_type;
1109 btif_cb.client_if = ref_value;
1110 btif_cb.avbl_space = avbl_space;
1111 btif_transfer_context(btif_gattc_upstreams_evt, BTA_GATTC_SCAN_FLT_PARAM_EVT,
1112 (char*) &btif_cb, sizeof(btgatt_adv_filter_cb_t), NULL);
1113 }
1114
bta_scan_filt_status_cb(UINT8 action,tBTA_STATUS status,tBTA_DM_BLE_REF_VALUE ref_value)1115 static void bta_scan_filt_status_cb(UINT8 action, tBTA_STATUS status,
1116 tBTA_DM_BLE_REF_VALUE ref_value)
1117 {
1118 btgatt_adv_filter_cb_t btif_cb;
1119
1120 btif_cb.status = status;
1121 btif_cb.action = action;
1122 btif_cb.client_if = ref_value;
1123 btif_transfer_context(btif_gattc_upstreams_evt, BTA_GATTC_SCAN_FLT_STATUS_EVT,
1124 (char*) &btif_cb, sizeof(btgatt_adv_filter_cb_t), NULL);
1125 }
1126
btgattc_free_event_data(UINT16 event,char * event_data)1127 static void btgattc_free_event_data(UINT16 event, char *event_data)
1128 {
1129 switch (event)
1130 {
1131 case BTIF_GATTC_ADV_INSTANCE_SET_DATA:
1132 case BTIF_GATTC_SET_ADV_DATA:
1133 {
1134 const btif_adv_data_t *adv_data = (btif_adv_data_t*) event_data;
1135 btif_gattc_adv_data_cleanup(adv_data);
1136 break;
1137 }
1138
1139 default:
1140 break;
1141 }
1142 }
1143
btgattc_handle_event(uint16_t event,char * p_param)1144 static void btgattc_handle_event(uint16_t event, char* p_param)
1145 {
1146 tBTA_GATT_STATUS status;
1147 tBT_UUID uuid;
1148 tBTA_GATT_SRVC_ID srvc_id;
1149 tGATT_CHAR_PROP out_char_prop;
1150 tBTA_GATTC_CHAR_ID in_char_id;
1151 tBTA_GATTC_CHAR_ID out_char_id;
1152 tBTA_GATTC_CHAR_DESCR_ID in_char_descr_id;
1153 tBTA_GATTC_CHAR_DESCR_ID out_char_descr_id;
1154 tBTA_GATTC_INCL_SVC_ID in_incl_svc_id;
1155 tBTA_GATTC_INCL_SVC_ID out_incl_svc_id;
1156 tBTA_GATT_UNFMT descr_val;
1157
1158 btif_gattc_cb_t* p_cb = (btif_gattc_cb_t*) p_param;
1159 if (!p_cb) return;
1160
1161 LOG_VERBOSE("%s: Event %d", __FUNCTION__, event);
1162
1163 switch (event)
1164 {
1165 case BTIF_GATTC_REGISTER_APP:
1166 btif_to_bta_uuid(&uuid, &p_cb->uuid);
1167 btif_gattc_incr_app_count();
1168 BTA_GATTC_AppRegister(&uuid, bta_gattc_cback);
1169 break;
1170
1171 case BTIF_GATTC_UNREGISTER_APP:
1172 btif_gattc_clear_clientif(p_cb->client_if, TRUE);
1173 btif_gattc_decr_app_count();
1174 BTA_GATTC_AppDeregister(p_cb->client_if);
1175 break;
1176
1177 case BTIF_GATTC_SCAN_START:
1178 btif_gattc_init_dev_cb();
1179 BTA_DmBleObserve(TRUE, 0, bta_scan_results_cb);
1180 break;
1181
1182 case BTIF_GATTC_SCAN_STOP:
1183 BTA_DmBleObserve(FALSE, 0, 0);
1184 break;
1185
1186 case BTIF_GATTC_OPEN:
1187 {
1188 // Ensure device is in inquiry database
1189 int addr_type = 0;
1190 int device_type = 0;
1191 tBTA_GATT_TRANSPORT transport = BTA_GATT_TRANSPORT_LE;
1192
1193 if (btif_get_address_type(p_cb->bd_addr.address, &addr_type) &&
1194 btif_get_device_type(p_cb->bd_addr.address, &device_type) &&
1195 device_type != BT_DEVICE_TYPE_BREDR)
1196 {
1197 BTA_DmAddBleDevice(p_cb->bd_addr.address, addr_type, device_type);
1198 }
1199
1200 // Mark background connections
1201 if (!p_cb->is_direct)
1202 {
1203 // Check if RPA offloading is supported, otherwise, do not start
1204 // background connection, since it will not connect after address
1205 // changes
1206 if ((p_cb->addr_type == BLE_ADDR_RANDOM)
1207 && BTM_BLE_IS_RESOLVE_BDA(p_cb->bd_addr.address))
1208 {
1209 tBTM_BLE_VSC_CB vnd_capabilities;
1210 BTM_BleGetVendorCapabilities(&vnd_capabilities);
1211 if (!vnd_capabilities.rpa_offloading)
1212 {
1213 HAL_CBACK(bt_gatt_callbacks, client->open_cb, 0, BT_STATUS_UNSUPPORTED,
1214 p_cb->client_if, &p_cb->bd_addr);
1215 return;
1216 }
1217 }
1218 BTA_DmBleSetBgConnType(BTM_BLE_CONN_AUTO, NULL);
1219 }
1220
1221 switch(device_type)
1222 {
1223 case BT_DEVICE_TYPE_BREDR:
1224 transport = BTA_GATT_TRANSPORT_BR_EDR;
1225 break;
1226
1227 case BT_DEVICE_TYPE_BLE:
1228 transport = BTA_GATT_TRANSPORT_LE;
1229 break;
1230
1231 case BT_DEVICE_TYPE_DUMO:
1232 if (p_cb->transport == GATT_TRANSPORT_LE)
1233 transport = BTA_GATT_TRANSPORT_LE;
1234 else
1235 transport = BTA_GATT_TRANSPORT_BR_EDR;
1236 break;
1237 }
1238
1239 // Connect!
1240 BTIF_TRACE_DEBUG ("BTA_GATTC_Open Transport = %d, dev type = %d",
1241 transport, device_type);
1242 BTA_GATTC_Open(p_cb->client_if, p_cb->bd_addr.address, p_cb->is_direct, transport);
1243 break;
1244 }
1245
1246 case BTIF_GATTC_CLOSE:
1247 // Disconnect established connections
1248 if (p_cb->conn_id != 0)
1249 BTA_GATTC_Close(p_cb->conn_id);
1250 else
1251 BTA_GATTC_CancelOpen(p_cb->client_if, p_cb->bd_addr.address, TRUE);
1252
1253 // Cancel pending background connections (remove from whitelist)
1254 BTA_GATTC_CancelOpen(p_cb->client_if, p_cb->bd_addr.address, FALSE);
1255 break;
1256
1257 case BTIF_GATTC_SEARCH_SERVICE:
1258 {
1259 if (p_cb->search_all)
1260 {
1261 BTA_GATTC_ServiceSearchRequest(p_cb->conn_id, NULL);
1262 } else {
1263 btif_to_bta_uuid(&uuid, &p_cb->uuid);
1264 BTA_GATTC_ServiceSearchRequest(p_cb->conn_id, &uuid);
1265 }
1266 break;
1267 }
1268
1269 case BTIF_GATTC_GET_FIRST_CHAR:
1270 {
1271 btgatt_gatt_id_t char_id;
1272 btif_to_bta_srvc_id(&srvc_id, &p_cb->srvc_id);
1273 status = BTA_GATTC_GetFirstChar(p_cb->conn_id, &srvc_id, NULL,
1274 &out_char_id, &out_char_prop);
1275
1276 if (status == 0)
1277 bta_to_btif_gatt_id(&char_id, &out_char_id.char_id);
1278
1279 HAL_CBACK(bt_gatt_callbacks, client->get_characteristic_cb,
1280 p_cb->conn_id, status, &p_cb->srvc_id,
1281 &char_id, out_char_prop);
1282 break;
1283 }
1284
1285 case BTIF_GATTC_GET_NEXT_CHAR:
1286 {
1287 btgatt_gatt_id_t char_id;
1288 btif_to_bta_srvc_id(&in_char_id.srvc_id, &p_cb->srvc_id);
1289 btif_to_bta_gatt_id(&in_char_id.char_id, &p_cb->char_id);
1290
1291 status = BTA_GATTC_GetNextChar(p_cb->conn_id, &in_char_id, NULL,
1292 &out_char_id, &out_char_prop);
1293
1294 if (status == 0)
1295 bta_to_btif_gatt_id(&char_id, &out_char_id.char_id);
1296
1297 HAL_CBACK(bt_gatt_callbacks, client->get_characteristic_cb,
1298 p_cb->conn_id, status, &p_cb->srvc_id,
1299 &char_id, out_char_prop);
1300 break;
1301 }
1302
1303 case BTIF_GATTC_GET_FIRST_CHAR_DESCR:
1304 {
1305 btgatt_gatt_id_t descr_id;
1306 btif_to_bta_srvc_id(&in_char_id.srvc_id, &p_cb->srvc_id);
1307 btif_to_bta_gatt_id(&in_char_id.char_id, &p_cb->char_id);
1308
1309 status = BTA_GATTC_GetFirstCharDescr(p_cb->conn_id, &in_char_id, NULL,
1310 &out_char_descr_id);
1311
1312 if (status == 0)
1313 bta_to_btif_gatt_id(&descr_id, &out_char_descr_id.descr_id);
1314
1315 HAL_CBACK(bt_gatt_callbacks, client->get_descriptor_cb,
1316 p_cb->conn_id, status, &p_cb->srvc_id,
1317 &p_cb->char_id, &descr_id);
1318 break;
1319 }
1320
1321 case BTIF_GATTC_GET_NEXT_CHAR_DESCR:
1322 {
1323 btgatt_gatt_id_t descr_id;
1324 btif_to_bta_srvc_id(&in_char_descr_id.char_id.srvc_id, &p_cb->srvc_id);
1325 btif_to_bta_gatt_id(&in_char_descr_id.char_id.char_id, &p_cb->char_id);
1326 btif_to_bta_gatt_id(&in_char_descr_id.descr_id, &p_cb->descr_id);
1327
1328 status = BTA_GATTC_GetNextCharDescr(p_cb->conn_id, &in_char_descr_id
1329 , NULL, &out_char_descr_id);
1330
1331 if (status == 0)
1332 bta_to_btif_gatt_id(&descr_id, &out_char_descr_id.descr_id);
1333
1334 HAL_CBACK(bt_gatt_callbacks, client->get_descriptor_cb,
1335 p_cb->conn_id, status, &p_cb->srvc_id,
1336 &p_cb->char_id, &descr_id);
1337 break;
1338 }
1339
1340 case BTIF_GATTC_GET_FIRST_INCL_SERVICE:
1341 {
1342 btgatt_srvc_id_t incl_srvc_id;
1343 btif_to_bta_srvc_id(&srvc_id, &p_cb->srvc_id);
1344
1345 status = BTA_GATTC_GetFirstIncludedService(p_cb->conn_id,
1346 &srvc_id, NULL, &out_incl_svc_id);
1347
1348 bta_to_btif_srvc_id(&incl_srvc_id, &out_incl_svc_id.incl_svc_id);
1349
1350 HAL_CBACK(bt_gatt_callbacks, client->get_included_service_cb,
1351 p_cb->conn_id, status, &p_cb->srvc_id,
1352 &incl_srvc_id);
1353 break;
1354 }
1355
1356 case BTIF_GATTC_GET_NEXT_INCL_SERVICE:
1357 {
1358 btgatt_srvc_id_t incl_srvc_id;
1359 btif_to_bta_srvc_id(&in_incl_svc_id.srvc_id, &p_cb->srvc_id);
1360 btif_to_bta_srvc_id(&in_incl_svc_id.incl_svc_id, &p_cb->incl_srvc_id);
1361
1362 status = BTA_GATTC_GetNextIncludedService(p_cb->conn_id,
1363 &in_incl_svc_id, NULL, &out_incl_svc_id);
1364
1365 bta_to_btif_srvc_id(&incl_srvc_id, &out_incl_svc_id.incl_svc_id);
1366
1367 HAL_CBACK(bt_gatt_callbacks, client->get_included_service_cb,
1368 p_cb->conn_id, status, &p_cb->srvc_id,
1369 &incl_srvc_id);
1370 break;
1371 }
1372
1373 case BTIF_GATTC_READ_CHAR:
1374 btif_to_bta_srvc_id(&in_char_id.srvc_id, &p_cb->srvc_id);
1375 btif_to_bta_gatt_id(&in_char_id.char_id, &p_cb->char_id);
1376
1377 BTA_GATTC_ReadCharacteristic(p_cb->conn_id, &in_char_id, p_cb->auth_req);
1378 break;
1379
1380 case BTIF_GATTC_READ_CHAR_DESCR:
1381 btif_to_bta_srvc_id(&in_char_descr_id.char_id.srvc_id, &p_cb->srvc_id);
1382 btif_to_bta_gatt_id(&in_char_descr_id.char_id.char_id, &p_cb->char_id);
1383 btif_to_bta_gatt_id(&in_char_descr_id.descr_id, &p_cb->descr_id);
1384
1385 BTA_GATTC_ReadCharDescr(p_cb->conn_id, &in_char_descr_id, p_cb->auth_req);
1386 break;
1387
1388 case BTIF_GATTC_WRITE_CHAR:
1389 btif_to_bta_srvc_id(&in_char_id.srvc_id, &p_cb->srvc_id);
1390 btif_to_bta_gatt_id(&in_char_id.char_id, &p_cb->char_id);
1391
1392 BTA_GATTC_WriteCharValue(p_cb->conn_id, &in_char_id,
1393 p_cb->write_type,
1394 p_cb->len,
1395 p_cb->value,
1396 p_cb->auth_req);
1397 break;
1398
1399 case BTIF_GATTC_WRITE_CHAR_DESCR:
1400 btif_to_bta_srvc_id(&in_char_descr_id.char_id.srvc_id, &p_cb->srvc_id);
1401 btif_to_bta_gatt_id(&in_char_descr_id.char_id.char_id, &p_cb->char_id);
1402 btif_to_bta_gatt_id(&in_char_descr_id.descr_id, &p_cb->descr_id);
1403
1404 descr_val.len = p_cb->len;
1405 descr_val.p_value = p_cb->value;
1406
1407 BTA_GATTC_WriteCharDescr(p_cb->conn_id, &in_char_descr_id,
1408 p_cb->write_type, &descr_val,
1409 p_cb->auth_req);
1410 break;
1411
1412 case BTIF_GATTC_EXECUTE_WRITE:
1413 BTA_GATTC_ExecuteWrite(p_cb->conn_id, p_cb->action);
1414 break;
1415
1416 case BTIF_GATTC_REG_FOR_NOTIFICATION:
1417 btif_to_bta_srvc_id(&in_char_id.srvc_id, &p_cb->srvc_id);
1418 btif_to_bta_gatt_id(&in_char_id.char_id, &p_cb->char_id);
1419
1420 status = BTA_GATTC_RegisterForNotifications(p_cb->client_if,
1421 p_cb->bd_addr.address, &in_char_id);
1422
1423 HAL_CBACK(bt_gatt_callbacks, client->register_for_notification_cb,
1424 p_cb->conn_id, 1, status, &p_cb->srvc_id,
1425 &p_cb->char_id);
1426 break;
1427
1428 case BTIF_GATTC_DEREG_FOR_NOTIFICATION:
1429 btif_to_bta_srvc_id(&in_char_id.srvc_id, &p_cb->srvc_id);
1430 btif_to_bta_gatt_id(&in_char_id.char_id, &p_cb->char_id);
1431
1432 status = BTA_GATTC_DeregisterForNotifications(p_cb->client_if,
1433 p_cb->bd_addr.address, &in_char_id);
1434
1435 HAL_CBACK(bt_gatt_callbacks, client->register_for_notification_cb,
1436 p_cb->conn_id, 0, status, &p_cb->srvc_id,
1437 &p_cb->char_id);
1438 break;
1439
1440 case BTIF_GATTC_REFRESH:
1441 BTA_GATTC_Refresh(p_cb->bd_addr.address);
1442 break;
1443
1444 case BTIF_GATTC_READ_RSSI:
1445 rssi_request_client_if = p_cb->client_if;
1446 BTM_ReadRSSI (p_cb->bd_addr.address, (tBTM_CMPL_CB *)btm_read_rssi_cb);
1447 break;
1448
1449 case BTIF_GATTC_SCAN_FILTER_PARAM_SETUP:
1450 {
1451 btgatt_adv_filter_cb_t *p_adv_filt_cb = (btgatt_adv_filter_cb_t *) p_param;
1452 if (1 == p_adv_filt_cb->adv_filt_param.dely_mode)
1453 BTA_DmBleTrackAdvertiser(p_adv_filt_cb->client_if, bta_track_adv_event_cb);
1454 BTA_DmBleScanFilterSetup(p_adv_filt_cb->action, p_adv_filt_cb->filt_index,
1455 &p_adv_filt_cb->adv_filt_param, NULL, bta_scan_filt_param_setup_cb,
1456 p_adv_filt_cb->client_if);
1457 break;
1458 }
1459
1460 case BTIF_GATTC_SCAN_FILTER_CONFIG:
1461 {
1462 btgatt_adv_filter_cb_t *p_adv_filt_cb = (btgatt_adv_filter_cb_t *) p_param;
1463 tBTA_DM_BLE_PF_COND_PARAM cond;
1464 memset(&cond, 0, sizeof(cond));
1465
1466 switch (p_adv_filt_cb->filt_type)
1467 {
1468 case BTA_DM_BLE_PF_ADDR_FILTER: // 0
1469 bdcpy(cond.target_addr.bda, p_adv_filt_cb->bd_addr.address);
1470 cond.target_addr.type = p_adv_filt_cb->addr_type;
1471 BTA_DmBleCfgFilterCondition(p_adv_filt_cb->action,
1472 p_adv_filt_cb->filt_type, p_adv_filt_cb->filt_index,
1473 &cond, bta_scan_filt_cfg_cb,
1474 p_adv_filt_cb->client_if);
1475 break;
1476
1477 case BTA_DM_BLE_PF_SRVC_DATA: // 1
1478 BTA_DmBleCfgFilterCondition(p_adv_filt_cb->action,
1479 p_adv_filt_cb->filt_type, p_adv_filt_cb->filt_index,
1480 NULL, bta_scan_filt_cfg_cb, p_adv_filt_cb->client_if);
1481 break;
1482
1483 case BTA_DM_BLE_PF_SRVC_UUID: // 2
1484 {
1485 tBTA_DM_BLE_PF_COND_MASK uuid_mask;
1486
1487 cond.srvc_uuid.p_target_addr = NULL;
1488 cond.srvc_uuid.cond_logic = BTA_DM_BLE_PF_LOGIC_AND;
1489 btif_to_bta_uuid(&cond.srvc_uuid.uuid, &p_adv_filt_cb->uuid);
1490
1491 cond.srvc_uuid.p_uuid_mask = NULL;
1492 if (p_adv_filt_cb->has_mask)
1493 {
1494 btif_to_bta_uuid_mask(&uuid_mask, &p_adv_filt_cb->uuid_mask);
1495 cond.srvc_uuid.p_uuid_mask = &uuid_mask;
1496 }
1497 BTA_DmBleCfgFilterCondition(p_adv_filt_cb->action,
1498 p_adv_filt_cb->filt_type, p_adv_filt_cb->filt_index,
1499 &cond, bta_scan_filt_cfg_cb,
1500 p_adv_filt_cb->client_if);
1501 break;
1502 }
1503
1504 case BTA_DM_BLE_PF_SRVC_SOL_UUID: // 3
1505 {
1506 cond.solicitate_uuid.p_target_addr = NULL;
1507 cond.solicitate_uuid.cond_logic = BTA_DM_BLE_PF_LOGIC_AND;
1508 btif_to_bta_uuid(&cond.solicitate_uuid.uuid, &p_adv_filt_cb->uuid);
1509 BTA_DmBleCfgFilterCondition(p_adv_filt_cb->action,
1510 p_adv_filt_cb->filt_type, p_adv_filt_cb->filt_index,
1511 &cond, bta_scan_filt_cfg_cb,
1512 p_adv_filt_cb->client_if);
1513 break;
1514 }
1515
1516 case BTA_DM_BLE_PF_LOCAL_NAME: // 4
1517 {
1518 cond.local_name.data_len = p_adv_filt_cb->value_len;
1519 cond.local_name.p_data = p_adv_filt_cb->value;
1520 BTA_DmBleCfgFilterCondition(p_adv_filt_cb->action,
1521 p_adv_filt_cb->filt_type, p_adv_filt_cb->filt_index,
1522 &cond, bta_scan_filt_cfg_cb,
1523 p_adv_filt_cb->client_if);
1524 break;
1525 }
1526
1527 case BTA_DM_BLE_PF_MANU_DATA: // 5
1528 {
1529 cond.manu_data.company_id = p_adv_filt_cb->conn_id;
1530 cond.manu_data.company_id_mask = p_adv_filt_cb->company_id_mask;
1531 cond.manu_data.data_len = p_adv_filt_cb->value_len;
1532 cond.manu_data.p_pattern = p_adv_filt_cb->value;
1533 cond.manu_data.p_pattern_mask = p_adv_filt_cb->value_mask;
1534 BTA_DmBleCfgFilterCondition(p_adv_filt_cb->action,
1535 p_adv_filt_cb->filt_type, p_adv_filt_cb->filt_index,
1536 &cond, bta_scan_filt_cfg_cb,
1537 p_adv_filt_cb->client_if);
1538 break;
1539 }
1540
1541 case BTA_DM_BLE_PF_SRVC_DATA_PATTERN: //6
1542 {
1543 cond.srvc_data.data_len = p_adv_filt_cb->value_len;
1544 cond.srvc_data.p_pattern = p_adv_filt_cb->value;
1545 cond.srvc_data.p_pattern_mask = p_adv_filt_cb->value_mask;
1546 BTA_DmBleCfgFilterCondition(p_adv_filt_cb->action,
1547 p_adv_filt_cb->filt_type, p_adv_filt_cb->filt_index,
1548 &cond, bta_scan_filt_cfg_cb,
1549 p_adv_filt_cb->client_if);
1550 break;
1551 }
1552
1553 default:
1554 LOG_ERROR("%s: Unknown filter type (%d)!", __FUNCTION__, p_cb->action);
1555 break;
1556 }
1557 break;
1558 }
1559
1560 case BTIF_GATTC_SCAN_FILTER_CLEAR:
1561 {
1562 btgatt_adv_filter_cb_t *p_adv_filt_cb = (btgatt_adv_filter_cb_t *) p_param;
1563 BTA_DmBleCfgFilterCondition(BTA_DM_BLE_SCAN_COND_CLEAR, BTA_DM_BLE_PF_TYPE_ALL,
1564 p_adv_filt_cb->filt_index, NULL, bta_scan_filt_cfg_cb,
1565 p_adv_filt_cb->client_if);
1566 break;
1567 }
1568
1569 case BTIF_GATTC_SCAN_FILTER_ENABLE:
1570 {
1571 btgatt_adv_filter_cb_t *p_adv_filt_cb = (btgatt_adv_filter_cb_t *) p_param;
1572 BTA_DmEnableScanFilter(p_adv_filt_cb->action, bta_scan_filt_status_cb,
1573 p_adv_filt_cb->client_if);
1574 break;
1575 }
1576
1577 case BTIF_GATTC_LISTEN:
1578 #if (defined(BLE_PERIPHERAL_MODE_SUPPORT) && (BLE_PERIPHERAL_MODE_SUPPORT == TRUE))
1579 BTA_GATTC_Listen(p_cb->client_if, p_cb->start, NULL);
1580 #else
1581 BTA_GATTC_Broadcast(p_cb->client_if, p_cb->start);
1582 #endif
1583 break;
1584
1585 case BTIF_GATTC_SET_ADV_DATA:
1586 {
1587 const btif_adv_data_t *p_adv_data = (btif_adv_data_t*) p_param;
1588 const int cbindex = CLNT_IF_IDX;
1589 if (cbindex >= 0 && btif_gattc_copy_datacb(cbindex, p_adv_data, false))
1590 {
1591 btgatt_multi_adv_common_data *p_multi_adv_data_cb = btif_obtain_multi_adv_data_cb();
1592 if (!p_adv_data->set_scan_rsp)
1593 {
1594 BTA_DmBleSetAdvConfig(p_multi_adv_data_cb->inst_cb[cbindex].mask,
1595 &p_multi_adv_data_cb->inst_cb[cbindex].data, bta_gattc_set_adv_data_cback);
1596 }
1597 else
1598 {
1599 BTA_DmBleSetScanRsp(p_multi_adv_data_cb->inst_cb[cbindex].mask,
1600 &p_multi_adv_data_cb->inst_cb[cbindex].data, bta_gattc_set_adv_data_cback);
1601 }
1602 }
1603 else
1604 {
1605 BTIF_TRACE_ERROR("%s:%s: failed to get instance data cbindex: %d",
1606 __func__, "BTIF_GATTC_SET_ADV_DATA", cbindex);
1607 }
1608 break;
1609 }
1610
1611 case BTIF_GATTC_ADV_INSTANCE_ENABLE:
1612 {
1613 btgatt_multi_adv_inst_cb *p_inst_cb = (btgatt_multi_adv_inst_cb*) p_param;
1614
1615 int cbindex = -1, arrindex = -1;
1616
1617 arrindex = btif_multi_adv_add_instid_map(p_inst_cb->client_if,INVALID_ADV_INST, true);
1618 if (arrindex >= 0)
1619 cbindex = btif_gattc_obtain_idx_for_datacb(p_inst_cb->client_if, CLNT_IF_IDX);
1620
1621 if (cbindex >= 0 && arrindex >= 0)
1622 {
1623 btgatt_multi_adv_common_data *p_multi_adv_data_cb = btif_obtain_multi_adv_data_cb();
1624 memcpy(&p_multi_adv_data_cb->inst_cb[cbindex].param,
1625 &p_inst_cb->param, sizeof(tBTA_BLE_ADV_PARAMS));
1626 p_multi_adv_data_cb->inst_cb[cbindex].timeout_s = p_inst_cb->timeout_s;
1627 BTIF_TRACE_DEBUG("%s, client_if value: %d", __FUNCTION__,
1628 p_multi_adv_data_cb->clntif_map[arrindex + arrindex]);
1629 BTA_BleEnableAdvInstance(&(p_multi_adv_data_cb->inst_cb[cbindex].param),
1630 bta_gattc_multi_adv_cback,
1631 &(p_multi_adv_data_cb->clntif_map[arrindex + arrindex]));
1632 }
1633 else
1634 {
1635 /* let the error propagate up from BTA layer */
1636 BTIF_TRACE_ERROR("%s invalid index in BTIF_GATTC_ENABLE_ADV",__FUNCTION__);
1637 BTA_BleEnableAdvInstance(&p_inst_cb->param, bta_gattc_multi_adv_cback, NULL);
1638 }
1639 break;
1640 }
1641
1642 case BTIF_GATTC_ADV_INSTANCE_UPDATE:
1643 {
1644 btgatt_multi_adv_inst_cb *p_inst_cb = (btgatt_multi_adv_inst_cb*) p_param;
1645 int inst_id = btif_multi_adv_instid_for_clientif(p_inst_cb->client_if);
1646 int cbindex = btif_gattc_obtain_idx_for_datacb(p_inst_cb->client_if, CLNT_IF_IDX);
1647 if (inst_id >= 0 && cbindex >= 0 && NULL != p_inst_cb)
1648 {
1649 btgatt_multi_adv_common_data *p_multi_adv_data_cb = btif_obtain_multi_adv_data_cb();
1650 memcpy(&p_multi_adv_data_cb->inst_cb[cbindex].param, &p_inst_cb->param,
1651 sizeof(tBTA_BLE_ADV_PARAMS));
1652 BTA_BleUpdateAdvInstParam((UINT8)inst_id,
1653 &(p_multi_adv_data_cb->inst_cb[cbindex].param));
1654 }
1655 else
1656 BTIF_TRACE_ERROR("%s invalid index in BTIF_GATTC_UPDATE_ADV", __FUNCTION__);
1657 break;
1658 }
1659
1660 case BTIF_GATTC_ADV_INSTANCE_SET_DATA:
1661 {
1662 btif_adv_data_t *p_adv_data = (btif_adv_data_t*) p_param;
1663 int cbindex = btif_gattc_obtain_idx_for_datacb(p_adv_data->client_if, CLNT_IF_IDX);
1664 int inst_id = btif_multi_adv_instid_for_clientif(p_adv_data->client_if);
1665 if (inst_id >= 0 && cbindex >= 0 && btif_gattc_copy_datacb(cbindex, p_adv_data, true))
1666 {
1667 btgatt_multi_adv_common_data *p_multi_adv_data_cb =
1668 btif_obtain_multi_adv_data_cb();
1669 BTA_BleCfgAdvInstData(
1670 (UINT8)inst_id,
1671 p_multi_adv_data_cb->inst_cb[cbindex].is_scan_rsp,
1672 p_multi_adv_data_cb->inst_cb[cbindex].mask,
1673 &p_multi_adv_data_cb->inst_cb[cbindex].data);
1674 }
1675 else
1676 {
1677 BTIF_TRACE_ERROR(
1678 "%s:%s: failed to get invalid instance data: inst_id:%d "
1679 "cbindex:%d",
1680 __func__, "BTIF_GATTC_ADV_INSTANCE_SET_DATA", inst_id, cbindex);
1681 }
1682 break;
1683 }
1684
1685 case BTIF_GATTC_ADV_INSTANCE_DISABLE:
1686 {
1687 btgatt_multi_adv_inst_cb *p_inst_cb = (btgatt_multi_adv_inst_cb*) p_param;
1688 int inst_id = btif_multi_adv_instid_for_clientif(p_inst_cb->client_if);
1689 if (inst_id >=0)
1690 BTA_BleDisableAdvInstance((UINT8)inst_id);
1691 else
1692 BTIF_TRACE_ERROR("%s invalid instance ID in BTIF_GATTC_DISABLE_ADV",__FUNCTION__);
1693 break;
1694 }
1695
1696 case BTIF_GATTC_CONFIGURE_MTU:
1697 BTA_GATTC_ConfigureMTU(p_cb->conn_id, p_cb->len);
1698 break;
1699
1700 case BTIF_GATTC_CONN_PARAM_UPDT:
1701 {
1702 btif_conn_param_cb_t *p_conn_param_cb = (btif_conn_param_cb_t*) p_param;
1703 if (BTA_DmGetConnectionState(p_conn_param_cb->bd_addr.address))
1704 {
1705 BTA_DmBleUpdateConnectionParams(p_conn_param_cb->bd_addr.address,
1706 p_conn_param_cb->min_interval, p_conn_param_cb->max_interval,
1707 p_conn_param_cb->latency, p_conn_param_cb->timeout);
1708 } else {
1709 BTA_DmSetBlePrefConnParams(p_conn_param_cb->bd_addr.address,
1710 p_conn_param_cb->min_interval, p_conn_param_cb->max_interval,
1711 p_conn_param_cb->latency, p_conn_param_cb->timeout);
1712 }
1713 break;
1714 }
1715
1716 case BTIF_GATTC_SET_SCAN_PARAMS:
1717 {
1718 BTA_DmSetBleScanParams(p_cb->client_if, p_cb->scan_interval, p_cb->scan_window,
1719 BTM_BLE_SCAN_MODE_ACTI, bta_scan_param_setup_cb);
1720 break;
1721 }
1722
1723 case BTIF_GATTC_CONFIG_STORAGE_PARAMS:
1724 {
1725 btgatt_batch_track_cb_t *p_scan_track_cb = (btgatt_batch_track_cb_t *) p_param;
1726 BTA_DmBleSetStorageParams(p_scan_track_cb->batch_scan_full_max,
1727 p_scan_track_cb->batch_scan_trunc_max, p_scan_track_cb->batch_scan_notify_threshold,
1728 bta_batch_scan_setup_cb, bta_batch_scan_threshold_cb, bta_batch_scan_reports_cb,
1729 (tBTA_DM_BLE_REF_VALUE) p_scan_track_cb->client_if);
1730 break;
1731 }
1732
1733 case BTIF_GATTC_ENABLE_BATCH_SCAN:
1734 {
1735 btgatt_batch_track_cb_t *p_scan_track_cb = (btgatt_batch_track_cb_t *) p_param;
1736 BTA_DmBleEnableBatchScan(p_scan_track_cb->scan_mode, p_scan_track_cb->scan_interval,
1737 p_scan_track_cb->scan_window, p_scan_track_cb->discard_rule,
1738 p_scan_track_cb->addr_type, p_scan_track_cb->client_if);
1739 break;
1740 }
1741
1742 case BTIF_GATTC_DISABLE_BATCH_SCAN:
1743 {
1744 btgatt_batch_track_cb_t *p_scan_track_cb = (btgatt_batch_track_cb_t *) p_param;
1745 BTA_DmBleDisableBatchScan(p_scan_track_cb->client_if);
1746 break;
1747 }
1748
1749 case BTIF_GATTC_READ_BATCH_SCAN_REPORTS:
1750 {
1751 btgatt_batch_track_cb_t *p_scan_track_cb = (btgatt_batch_track_cb_t *) p_param;
1752 BTA_DmBleReadScanReports(p_scan_track_cb->scan_mode, p_scan_track_cb->client_if);
1753 break;
1754 }
1755
1756 default:
1757 LOG_ERROR("%s: Unknown event (%d)!", __FUNCTION__, event);
1758 break;
1759 }
1760
1761 btgattc_free_event_data(event, p_param);
1762 }
1763
1764 /*******************************************************************************
1765 ** Client API Functions
1766 ********************************************************************************/
1767
btif_gattc_register_app(bt_uuid_t * uuid)1768 static bt_status_t btif_gattc_register_app(bt_uuid_t *uuid)
1769 {
1770 CHECK_BTGATT_INIT();
1771 btif_gattc_cb_t btif_cb;
1772 memcpy(&btif_cb.uuid, uuid, sizeof(bt_uuid_t));
1773 return btif_transfer_context(btgattc_handle_event, BTIF_GATTC_REGISTER_APP,
1774 (char*) &btif_cb, sizeof(btif_gattc_cb_t), NULL);
1775 }
1776
btif_gattc_unregister_app(int client_if)1777 static bt_status_t btif_gattc_unregister_app(int client_if )
1778 {
1779 CHECK_BTGATT_INIT();
1780 btif_gattc_cb_t btif_cb;
1781 btif_cb.client_if = (uint8_t) client_if;
1782 return btif_transfer_context(btgattc_handle_event, BTIF_GATTC_UNREGISTER_APP,
1783 (char*) &btif_cb, sizeof(btif_gattc_cb_t), NULL);
1784 }
1785
btif_gattc_scan(bool start)1786 static bt_status_t btif_gattc_scan( bool start )
1787 {
1788 CHECK_BTGATT_INIT();
1789 btif_gattc_cb_t btif_cb;
1790 return btif_transfer_context(btgattc_handle_event, start ? BTIF_GATTC_SCAN_START : BTIF_GATTC_SCAN_STOP,
1791 (char*) &btif_cb, sizeof(btif_gattc_cb_t), NULL);
1792 }
1793
btif_gattc_open(int client_if,const bt_bdaddr_t * bd_addr,bool is_direct,int transport)1794 static bt_status_t btif_gattc_open(int client_if, const bt_bdaddr_t *bd_addr,
1795 bool is_direct,int transport)
1796 {
1797 CHECK_BTGATT_INIT();
1798 btif_gattc_cb_t btif_cb;
1799 btif_cb.client_if = (uint8_t) client_if;
1800 btif_cb.is_direct = is_direct ? 1 : 0;
1801 btif_cb.transport = (btgatt_transport_t)transport;
1802 bdcpy(btif_cb.bd_addr.address, bd_addr->address);
1803 return btif_transfer_context(btgattc_handle_event, BTIF_GATTC_OPEN,
1804 (char*) &btif_cb, sizeof(btif_gattc_cb_t), NULL);
1805 }
1806
btif_gattc_close(int client_if,const bt_bdaddr_t * bd_addr,int conn_id)1807 static bt_status_t btif_gattc_close( int client_if, const bt_bdaddr_t *bd_addr, int conn_id)
1808 {
1809 CHECK_BTGATT_INIT();
1810 btif_gattc_cb_t btif_cb;
1811 btif_cb.client_if = (uint8_t) client_if;
1812 btif_cb.conn_id = (uint16_t) conn_id;
1813 bdcpy(btif_cb.bd_addr.address, bd_addr->address);
1814 return btif_transfer_context(btgattc_handle_event, BTIF_GATTC_CLOSE,
1815 (char*) &btif_cb, sizeof(btif_gattc_cb_t), NULL);
1816 }
1817
btif_gattc_listen(int client_if,bool start)1818 static bt_status_t btif_gattc_listen(int client_if, bool start)
1819 {
1820 CHECK_BTGATT_INIT();
1821 btif_gattc_cb_t btif_cb;
1822 btif_cb.client_if = (uint8_t) client_if;
1823 btif_cb.start = start ? 1 : 0;
1824 return btif_transfer_context(btgattc_handle_event, BTIF_GATTC_LISTEN,
1825 (char*) &btif_cb, sizeof(btif_gattc_cb_t), NULL);
1826 }
1827
btif_gattc_deep_copy(UINT16 event,char * p_dest,char * p_src)1828 static void btif_gattc_deep_copy(UINT16 event, char *p_dest, char *p_src)
1829 {
1830 switch (event)
1831 {
1832 case BTIF_GATTC_ADV_INSTANCE_SET_DATA:
1833 case BTIF_GATTC_SET_ADV_DATA:
1834 {
1835 const btif_adv_data_t *src = (btif_adv_data_t*) p_src;
1836 btif_adv_data_t *dst = (btif_adv_data_t*) p_dest;
1837 memcpy(dst, src, sizeof(*src));
1838
1839 if (src->p_manufacturer_data)
1840 {
1841 dst->p_manufacturer_data = GKI_getbuf(src->manufacturer_len);
1842 memcpy(dst->p_manufacturer_data, src->p_manufacturer_data,
1843 src->manufacturer_len);
1844 }
1845
1846 if (src->p_service_data)
1847 {
1848 dst->p_service_data = GKI_getbuf(src->service_data_len);
1849 memcpy(dst->p_service_data, src->p_service_data, src->service_data_len);
1850 }
1851
1852 if (src->p_service_uuid)
1853 {
1854 dst->p_service_uuid = GKI_getbuf(src->service_uuid_len);
1855 memcpy(dst->p_service_uuid, src->p_service_uuid, src->service_uuid_len);
1856 }
1857 break;
1858 }
1859
1860 default:
1861 ASSERTC(false, "Unhandled deep copy", event);
1862 break;
1863 }
1864 }
1865
btif_gattc_set_adv_data(int client_if,bool set_scan_rsp,bool include_name,bool include_txpower,int min_interval,int max_interval,int appearance,uint16_t manufacturer_len,char * manufacturer_data,uint16_t service_data_len,char * service_data,uint16_t service_uuid_len,char * service_uuid)1866 static bt_status_t btif_gattc_set_adv_data(int client_if, bool set_scan_rsp, bool include_name,
1867 bool include_txpower, int min_interval, int max_interval, int appearance,
1868 uint16_t manufacturer_len, char* manufacturer_data,
1869 uint16_t service_data_len, char* service_data,
1870 uint16_t service_uuid_len, char* service_uuid)
1871 {
1872 CHECK_BTGATT_INIT();
1873 btif_adv_data_t adv_data;
1874
1875 btif_gattc_adv_data_packager(client_if, set_scan_rsp, include_name,
1876 include_txpower, min_interval, max_interval, appearance, manufacturer_len,
1877 manufacturer_data, service_data_len, service_data, service_uuid_len, service_uuid,
1878 &adv_data);
1879
1880 bt_status_t status = btif_transfer_context(btgattc_handle_event, BTIF_GATTC_SET_ADV_DATA,
1881 (char*) &adv_data, sizeof(adv_data), btif_gattc_deep_copy);
1882 btif_gattc_adv_data_cleanup(&adv_data);
1883 return status;
1884 }
1885
btif_gattc_refresh(int client_if,const bt_bdaddr_t * bd_addr)1886 static bt_status_t btif_gattc_refresh( int client_if, const bt_bdaddr_t *bd_addr )
1887 {
1888 CHECK_BTGATT_INIT();
1889 btif_gattc_cb_t btif_cb;
1890 btif_cb.client_if = (uint8_t) client_if;
1891 bdcpy(btif_cb.bd_addr.address, bd_addr->address);
1892 return btif_transfer_context(btgattc_handle_event, BTIF_GATTC_REFRESH,
1893 (char*) &btif_cb, sizeof(btif_gattc_cb_t), NULL);
1894 }
1895
btif_gattc_search_service(int conn_id,bt_uuid_t * filter_uuid)1896 static bt_status_t btif_gattc_search_service(int conn_id, bt_uuid_t *filter_uuid )
1897 {
1898 CHECK_BTGATT_INIT();
1899 btif_gattc_cb_t btif_cb;
1900 btif_cb.conn_id = (uint16_t) conn_id;
1901 btif_cb.search_all = filter_uuid ? 0 : 1;
1902 if (filter_uuid)
1903 memcpy(&btif_cb.uuid, filter_uuid, sizeof(bt_uuid_t));
1904 return btif_transfer_context(btgattc_handle_event, BTIF_GATTC_SEARCH_SERVICE,
1905 (char*) &btif_cb, sizeof(btif_gattc_cb_t), NULL);
1906 }
1907
btif_gattc_get_characteristic(int conn_id,btgatt_srvc_id_t * srvc_id,btgatt_gatt_id_t * start_char_id)1908 static bt_status_t btif_gattc_get_characteristic( int conn_id
1909 , btgatt_srvc_id_t *srvc_id, btgatt_gatt_id_t *start_char_id)
1910 {
1911 CHECK_BTGATT_INIT();
1912 btif_gattc_cb_t btif_cb;
1913 btif_cb.conn_id = (uint16_t) conn_id;
1914 memcpy(&btif_cb.srvc_id, srvc_id, sizeof(btgatt_srvc_id_t));
1915 if (start_char_id)
1916 {
1917 memcpy(&btif_cb.char_id, start_char_id, sizeof(btgatt_gatt_id_t));
1918 return btif_transfer_context(btgattc_handle_event, BTIF_GATTC_GET_NEXT_CHAR,
1919 (char*) &btif_cb, sizeof(btif_gattc_cb_t), NULL);
1920 }
1921 return btif_transfer_context(btgattc_handle_event, BTIF_GATTC_GET_FIRST_CHAR,
1922 (char*) &btif_cb, sizeof(btif_gattc_cb_t), NULL);
1923 }
1924
btif_gattc_get_descriptor(int conn_id,btgatt_srvc_id_t * srvc_id,btgatt_gatt_id_t * char_id,btgatt_gatt_id_t * start_descr_id)1925 static bt_status_t btif_gattc_get_descriptor( int conn_id
1926 , btgatt_srvc_id_t *srvc_id, btgatt_gatt_id_t *char_id
1927 , btgatt_gatt_id_t *start_descr_id)
1928 {
1929 CHECK_BTGATT_INIT();
1930 btif_gattc_cb_t btif_cb;
1931 btif_cb.conn_id = (uint16_t) conn_id;
1932 memcpy(&btif_cb.srvc_id, srvc_id, sizeof(btgatt_srvc_id_t));
1933 memcpy(&btif_cb.char_id, char_id, sizeof(btgatt_gatt_id_t));
1934 if (start_descr_id)
1935 {
1936 memcpy(&btif_cb.descr_id, start_descr_id, sizeof(btgatt_gatt_id_t));
1937 return btif_transfer_context(btgattc_handle_event, BTIF_GATTC_GET_NEXT_CHAR_DESCR,
1938 (char*) &btif_cb, sizeof(btif_gattc_cb_t), NULL);
1939 }
1940
1941 return btif_transfer_context(btgattc_handle_event, BTIF_GATTC_GET_FIRST_CHAR_DESCR,
1942 (char*) &btif_cb, sizeof(btif_gattc_cb_t), NULL);
1943 }
1944
btif_gattc_get_included_service(int conn_id,btgatt_srvc_id_t * srvc_id,btgatt_srvc_id_t * start_incl_srvc_id)1945 static bt_status_t btif_gattc_get_included_service(int conn_id, btgatt_srvc_id_t *srvc_id,
1946 btgatt_srvc_id_t *start_incl_srvc_id)
1947 {
1948 CHECK_BTGATT_INIT();
1949 btif_gattc_cb_t btif_cb;
1950 btif_cb.conn_id = (uint16_t) conn_id;
1951 memcpy(&btif_cb.srvc_id, srvc_id, sizeof(btgatt_srvc_id_t));
1952 if (start_incl_srvc_id)
1953 {
1954 memcpy(&btif_cb.incl_srvc_id, start_incl_srvc_id, sizeof(btgatt_srvc_id_t));
1955 return btif_transfer_context(btgattc_handle_event, BTIF_GATTC_GET_NEXT_INCL_SERVICE,
1956 (char*) &btif_cb, sizeof(btif_gattc_cb_t), NULL);
1957 }
1958 return btif_transfer_context(btgattc_handle_event, BTIF_GATTC_GET_FIRST_INCL_SERVICE,
1959 (char*) &btif_cb, sizeof(btif_gattc_cb_t), NULL);
1960 }
1961
btif_gattc_read_char(int conn_id,btgatt_srvc_id_t * srvc_id,btgatt_gatt_id_t * char_id,int auth_req)1962 static bt_status_t btif_gattc_read_char(int conn_id, btgatt_srvc_id_t* srvc_id,
1963 btgatt_gatt_id_t* char_id, int auth_req )
1964 {
1965 CHECK_BTGATT_INIT();
1966 btif_gattc_cb_t btif_cb;
1967 btif_cb.conn_id = (uint16_t) conn_id;
1968 btif_cb.auth_req = (uint8_t) auth_req;
1969 memcpy(&btif_cb.srvc_id, srvc_id, sizeof(btgatt_srvc_id_t));
1970 memcpy(&btif_cb.char_id, char_id, sizeof(btgatt_gatt_id_t));
1971 return btif_transfer_context(btgattc_handle_event, BTIF_GATTC_READ_CHAR,
1972 (char*) &btif_cb, sizeof(btif_gattc_cb_t), NULL);
1973 }
1974
btif_gattc_read_char_descr(int conn_id,btgatt_srvc_id_t * srvc_id,btgatt_gatt_id_t * char_id,btgatt_gatt_id_t * descr_id,int auth_req)1975 static bt_status_t btif_gattc_read_char_descr(int conn_id, btgatt_srvc_id_t* srvc_id,
1976 btgatt_gatt_id_t* char_id,
1977 btgatt_gatt_id_t* descr_id,
1978 int auth_req )
1979 {
1980 CHECK_BTGATT_INIT();
1981 btif_gattc_cb_t btif_cb;
1982 btif_cb.conn_id = (uint16_t) conn_id;
1983 btif_cb.auth_req = (uint8_t) auth_req;
1984 memcpy(&btif_cb.srvc_id, srvc_id, sizeof(btgatt_srvc_id_t));
1985 memcpy(&btif_cb.char_id, char_id, sizeof(btgatt_gatt_id_t));
1986 memcpy(&btif_cb.descr_id, descr_id, sizeof(btgatt_gatt_id_t));
1987 return btif_transfer_context(btgattc_handle_event, BTIF_GATTC_READ_CHAR_DESCR,
1988 (char*) &btif_cb, sizeof(btif_gattc_cb_t), NULL);
1989 }
1990
btif_gattc_write_char(int conn_id,btgatt_srvc_id_t * srvc_id,btgatt_gatt_id_t * char_id,int write_type,int len,int auth_req,char * p_value)1991 static bt_status_t btif_gattc_write_char(int conn_id, btgatt_srvc_id_t* srvc_id,
1992 btgatt_gatt_id_t* char_id, int write_type,
1993 int len, int auth_req, char* p_value)
1994 {
1995 CHECK_BTGATT_INIT();
1996 btif_gattc_cb_t btif_cb;
1997 btif_cb.conn_id = (uint16_t) conn_id;
1998 btif_cb.auth_req = (uint8_t) auth_req;
1999 btif_cb.write_type = (uint8_t) write_type;
2000 btif_cb.len = len > BTGATT_MAX_ATTR_LEN ? BTGATT_MAX_ATTR_LEN : len;
2001 memcpy(&btif_cb.srvc_id, srvc_id, sizeof(btgatt_srvc_id_t));
2002 memcpy(&btif_cb.char_id, char_id, sizeof(btgatt_gatt_id_t));
2003 memcpy(btif_cb.value, p_value, btif_cb.len);
2004 return btif_transfer_context(btgattc_handle_event, BTIF_GATTC_WRITE_CHAR,
2005 (char*) &btif_cb, sizeof(btif_gattc_cb_t), NULL);
2006 }
2007
btif_gattc_write_char_descr(int conn_id,btgatt_srvc_id_t * srvc_id,btgatt_gatt_id_t * char_id,btgatt_gatt_id_t * descr_id,int write_type,int len,int auth_req,char * p_value)2008 static bt_status_t btif_gattc_write_char_descr(int conn_id, btgatt_srvc_id_t* srvc_id,
2009 btgatt_gatt_id_t* char_id,
2010 btgatt_gatt_id_t* descr_id,
2011 int write_type, int len, int auth_req,
2012 char* p_value)
2013 {
2014 CHECK_BTGATT_INIT();
2015 btif_gattc_cb_t btif_cb;
2016 btif_cb.conn_id = (uint16_t) conn_id;
2017 btif_cb.auth_req = (uint8_t) auth_req;
2018 btif_cb.write_type = (uint8_t) write_type;
2019 btif_cb.len = len > BTGATT_MAX_ATTR_LEN ? BTGATT_MAX_ATTR_LEN : len;
2020 memcpy(&btif_cb.srvc_id, srvc_id, sizeof(btgatt_srvc_id_t));
2021 memcpy(&btif_cb.char_id, char_id, sizeof(btgatt_gatt_id_t));
2022 memcpy(&btif_cb.descr_id, descr_id, sizeof(btgatt_gatt_id_t));
2023 memcpy(btif_cb.value, p_value, btif_cb.len);
2024 return btif_transfer_context(btgattc_handle_event, BTIF_GATTC_WRITE_CHAR_DESCR,
2025 (char*) &btif_cb, sizeof(btif_gattc_cb_t), NULL);
2026 }
2027
btif_gattc_execute_write(int conn_id,int execute)2028 static bt_status_t btif_gattc_execute_write(int conn_id, int execute)
2029 {
2030 CHECK_BTGATT_INIT();
2031 btif_gattc_cb_t btif_cb;
2032 btif_cb.conn_id = (uint16_t) conn_id;
2033 btif_cb.action = (uint8_t) execute;
2034 return btif_transfer_context(btgattc_handle_event, BTIF_GATTC_EXECUTE_WRITE,
2035 (char*) &btif_cb, sizeof(btif_gattc_cb_t), NULL);
2036 }
2037
btif_gattc_reg_for_notification(int client_if,const bt_bdaddr_t * bd_addr,btgatt_srvc_id_t * srvc_id,btgatt_gatt_id_t * char_id)2038 static bt_status_t btif_gattc_reg_for_notification(int client_if, const bt_bdaddr_t *bd_addr,
2039 btgatt_srvc_id_t* srvc_id,
2040 btgatt_gatt_id_t* char_id)
2041 {
2042 CHECK_BTGATT_INIT();
2043 btif_gattc_cb_t btif_cb;
2044 btif_cb.client_if = (uint8_t) client_if;
2045 bdcpy(btif_cb.bd_addr.address, bd_addr->address);
2046 memcpy(&btif_cb.srvc_id, srvc_id, sizeof(btgatt_srvc_id_t));
2047 memcpy(&btif_cb.char_id, char_id, sizeof(btgatt_gatt_id_t));
2048 return btif_transfer_context(btgattc_handle_event, BTIF_GATTC_REG_FOR_NOTIFICATION,
2049 (char*) &btif_cb, sizeof(btif_gattc_cb_t), NULL);
2050 }
2051
btif_gattc_dereg_for_notification(int client_if,const bt_bdaddr_t * bd_addr,btgatt_srvc_id_t * srvc_id,btgatt_gatt_id_t * char_id)2052 static bt_status_t btif_gattc_dereg_for_notification(int client_if, const bt_bdaddr_t *bd_addr,
2053 btgatt_srvc_id_t* srvc_id,
2054 btgatt_gatt_id_t* char_id)
2055 {
2056 CHECK_BTGATT_INIT();
2057 btif_gattc_cb_t btif_cb;
2058 btif_cb.client_if = (uint8_t) client_if;
2059 bdcpy(btif_cb.bd_addr.address, bd_addr->address);
2060 memcpy(&btif_cb.srvc_id, srvc_id, sizeof(btgatt_srvc_id_t));
2061 memcpy(&btif_cb.char_id, char_id, sizeof(btgatt_gatt_id_t));
2062 return btif_transfer_context(btgattc_handle_event, BTIF_GATTC_DEREG_FOR_NOTIFICATION,
2063 (char*) &btif_cb, sizeof(btif_gattc_cb_t), NULL);
2064 }
2065
btif_gattc_read_remote_rssi(int client_if,const bt_bdaddr_t * bd_addr)2066 static bt_status_t btif_gattc_read_remote_rssi(int client_if, const bt_bdaddr_t *bd_addr)
2067 {
2068 CHECK_BTGATT_INIT();
2069 btif_gattc_cb_t btif_cb;
2070 btif_cb.client_if = (uint8_t) client_if;
2071 bdcpy(btif_cb.bd_addr.address, bd_addr->address);
2072 return btif_transfer_context(btgattc_handle_event, BTIF_GATTC_READ_RSSI,
2073 (char*) &btif_cb, sizeof(btif_gattc_cb_t), NULL);
2074 }
2075
btif_gattc_configure_mtu(int conn_id,int mtu)2076 static bt_status_t btif_gattc_configure_mtu(int conn_id, int mtu)
2077 {
2078 CHECK_BTGATT_INIT();
2079 btif_gattc_cb_t btif_cb;
2080 btif_cb.conn_id = conn_id;
2081 btif_cb.len = mtu; // Re-use len field
2082 return btif_transfer_context(btgattc_handle_event, BTIF_GATTC_CONFIGURE_MTU,
2083 (char*) &btif_cb, sizeof(btif_gattc_cb_t), NULL);
2084 }
2085
btif_gattc_conn_parameter_update(const bt_bdaddr_t * bd_addr,int min_interval,int max_interval,int latency,int timeout)2086 static bt_status_t btif_gattc_conn_parameter_update(const bt_bdaddr_t *bd_addr, int min_interval,
2087 int max_interval, int latency, int timeout)
2088 {
2089 CHECK_BTGATT_INIT();
2090 btif_conn_param_cb_t btif_cb;
2091 btif_cb.min_interval = min_interval;
2092 btif_cb.max_interval = max_interval;
2093 btif_cb.latency = latency;
2094 btif_cb.timeout = timeout;
2095 bdcpy(btif_cb.bd_addr.address, bd_addr->address);
2096 return btif_transfer_context(btgattc_handle_event, BTIF_GATTC_CONN_PARAM_UPDT,
2097 (char*) &btif_cb, sizeof(btif_conn_param_cb_t), NULL);
2098 }
2099
btif_gattc_scan_filter_param_setup(btgatt_filt_param_setup_t filt_param)2100 static bt_status_t btif_gattc_scan_filter_param_setup(btgatt_filt_param_setup_t
2101 filt_param)
2102 {
2103 CHECK_BTGATT_INIT();
2104 BTIF_TRACE_DEBUG("%s", __FUNCTION__);
2105 btgatt_adv_filter_cb_t btif_filt_cb;
2106 memset(&btif_filt_cb, 0, sizeof(btgatt_adv_filter_cb_t));
2107 btif_filt_cb.client_if = filt_param.client_if;
2108 btif_filt_cb.action = filt_param.action;
2109 btif_filt_cb.filt_index = filt_param.filt_index;
2110 btif_filt_cb.adv_filt_param.feat_seln = filt_param.feat_seln;
2111 btif_filt_cb.adv_filt_param.list_logic_type = filt_param.list_logic_type;
2112 btif_filt_cb.adv_filt_param.filt_logic_type = filt_param.filt_logic_type;
2113 btif_filt_cb.adv_filt_param.rssi_high_thres = filt_param.rssi_high_thres;
2114 btif_filt_cb.adv_filt_param.rssi_low_thres = filt_param.rssi_low_thres;
2115 btif_filt_cb.adv_filt_param.dely_mode = filt_param.dely_mode;
2116 btif_filt_cb.adv_filt_param.found_timeout = filt_param.found_timeout;
2117 btif_filt_cb.adv_filt_param.lost_timeout = filt_param.lost_timeout;
2118 btif_filt_cb.adv_filt_param.found_timeout_cnt = filt_param.found_timeout_cnt;
2119 btif_filt_cb.adv_filt_param.num_of_tracking_entries = filt_param.num_of_tracking_entries;
2120 return btif_transfer_context(btgattc_handle_event, BTIF_GATTC_SCAN_FILTER_PARAM_SETUP,
2121 (char*) &btif_filt_cb, sizeof(btgatt_adv_filter_cb_t), NULL);
2122 }
2123
btif_gattc_scan_filter_add_remove(int client_if,int action,int filt_type,int filt_index,int company_id,int company_id_mask,const bt_uuid_t * p_uuid,const bt_uuid_t * p_uuid_mask,const bt_bdaddr_t * bd_addr,char addr_type,int data_len,char * p_data,int mask_len,char * p_mask)2124 static bt_status_t btif_gattc_scan_filter_add_remove(int client_if, int action,
2125 int filt_type, int filt_index, int company_id,
2126 int company_id_mask, const bt_uuid_t *p_uuid,
2127 const bt_uuid_t *p_uuid_mask, const bt_bdaddr_t *bd_addr,
2128 char addr_type, int data_len, char* p_data, int mask_len,
2129 char* p_mask)
2130 {
2131 CHECK_BTGATT_INIT();
2132 btgatt_adv_filter_cb_t btif_filt_cb;
2133 memset(&btif_filt_cb, 0, sizeof(btgatt_adv_filter_cb_t));
2134 BTIF_TRACE_DEBUG("%s, %d, %d", __FUNCTION__, action, filt_type);
2135
2136 /* If data is passed, both mask and data have to be the same length */
2137 if (data_len != mask_len && NULL != p_data && NULL != p_mask)
2138 return BT_STATUS_PARM_INVALID;
2139
2140 btif_filt_cb.client_if = client_if;
2141 btif_filt_cb.action = action;
2142 btif_filt_cb.filt_index = filt_index;
2143 btif_filt_cb.filt_type = filt_type;
2144 btif_filt_cb.conn_id = company_id;
2145 btif_filt_cb.company_id_mask = company_id_mask ? company_id_mask : 0xFFFF;
2146 if (bd_addr)
2147 bdcpy(btif_filt_cb.bd_addr.address, bd_addr->address);
2148
2149 btif_filt_cb.addr_type = addr_type;
2150 btif_filt_cb.has_mask = (p_uuid_mask != NULL);
2151
2152 if (p_uuid != NULL)
2153 memcpy(&btif_filt_cb.uuid, p_uuid, sizeof(bt_uuid_t));
2154 if (p_uuid_mask != NULL)
2155 memcpy(&btif_filt_cb.uuid_mask, p_uuid_mask, sizeof(bt_uuid_t));
2156 if (p_data != NULL && data_len != 0)
2157 {
2158 memcpy(btif_filt_cb.value, p_data, data_len);
2159 btif_filt_cb.value_len = data_len;
2160 memcpy(btif_filt_cb.value_mask, p_mask, mask_len);
2161 btif_filt_cb.value_mask_len = mask_len;
2162 }
2163 return btif_transfer_context(btgattc_handle_event, BTIF_GATTC_SCAN_FILTER_CONFIG,
2164 (char*) &btif_filt_cb, sizeof(btgatt_adv_filter_cb_t), NULL);
2165 }
2166
btif_gattc_scan_filter_clear(int client_if,int filt_index)2167 static bt_status_t btif_gattc_scan_filter_clear(int client_if, int filt_index)
2168 {
2169 CHECK_BTGATT_INIT();
2170 BTIF_TRACE_DEBUG("%s, %d", __FUNCTION__, filt_index);
2171
2172 btgatt_adv_filter_cb_t btif_filt_cb;
2173 memset(&btif_filt_cb, 0, sizeof(btgatt_adv_filter_cb_t));
2174 btif_filt_cb.client_if = client_if;
2175 btif_filt_cb.filt_index = filt_index;
2176 btif_filt_cb.action = BTA_DM_BLE_SCAN_COND_CLEAR;
2177 return btif_transfer_context(btgattc_handle_event, BTIF_GATTC_SCAN_FILTER_CONFIG,
2178 (char*) &btif_filt_cb, sizeof(btgatt_adv_filter_cb_t), NULL);
2179 }
2180
btif_gattc_scan_filter_enable(int client_if,bool enable)2181 static bt_status_t btif_gattc_scan_filter_enable(int client_if, bool enable)
2182 {
2183 int action = 0;
2184 CHECK_BTGATT_INIT();
2185 BTIF_TRACE_DEBUG("%s, %d", __FUNCTION__, enable);
2186
2187 btgatt_adv_filter_cb_t btif_filt_cb;
2188 memset(&btif_filt_cb, 0, sizeof(btgatt_adv_filter_cb_t));
2189 btif_filt_cb.client_if = client_if;
2190 if (true == enable)
2191 action = 1;
2192 btif_filt_cb.action = action;
2193 return btif_transfer_context(btgattc_handle_event, BTIF_GATTC_SCAN_FILTER_ENABLE,
2194 (char*) &btif_filt_cb, sizeof(btgatt_adv_filter_cb_t), NULL);
2195 }
2196
btif_gattc_set_scan_parameters(int client_if,int scan_interval,int scan_window)2197 static bt_status_t btif_gattc_set_scan_parameters(int client_if, int scan_interval,
2198 int scan_window)
2199 {
2200 CHECK_BTGATT_INIT();
2201 btif_gattc_cb_t btif_cb;
2202 btif_cb.client_if = client_if;
2203 btif_cb.scan_interval = scan_interval;
2204 btif_cb.scan_window = scan_window;
2205 return btif_transfer_context(btgattc_handle_event, BTIF_GATTC_SET_SCAN_PARAMS,
2206 (char*) &btif_cb, sizeof(btif_gattc_cb_t), NULL);
2207 }
2208
btif_gattc_get_device_type(const bt_bdaddr_t * bd_addr)2209 static int btif_gattc_get_device_type( const bt_bdaddr_t *bd_addr )
2210 {
2211 int device_type = 0;
2212 char bd_addr_str[18] = {0};
2213
2214 bdaddr_to_string(bd_addr, bd_addr_str, sizeof(bd_addr_str));
2215 if (btif_config_get_int(bd_addr_str, "DevType", &device_type))
2216 return device_type;
2217 return 0;
2218 }
2219
btif_gattc_multi_adv_enable(int client_if,int min_interval,int max_interval,int adv_type,int chnl_map,int tx_power,int timeout_s)2220 static bt_status_t btif_gattc_multi_adv_enable(int client_if, int min_interval, int max_interval,
2221 int adv_type, int chnl_map, int tx_power, int timeout_s)
2222 {
2223 CHECK_BTGATT_INIT();
2224 btgatt_multi_adv_inst_cb adv_cb;
2225 memset(&adv_cb, 0, sizeof(btgatt_multi_adv_inst_cb));
2226 adv_cb.client_if = (uint8_t) client_if;
2227
2228 adv_cb.param.adv_int_min = min_interval;
2229 adv_cb.param.adv_int_max = max_interval;
2230 adv_cb.param.adv_type = adv_type;
2231 adv_cb.param.channel_map = chnl_map;
2232 adv_cb.param.adv_filter_policy = 0;
2233 adv_cb.param.tx_power = tx_power;
2234 adv_cb.timeout_s = timeout_s;
2235 return btif_transfer_context(btgattc_handle_event, BTIF_GATTC_ADV_INSTANCE_ENABLE,
2236 (char*) &adv_cb, sizeof(btgatt_multi_adv_inst_cb), NULL);
2237 }
2238
btif_gattc_multi_adv_update(int client_if,int min_interval,int max_interval,int adv_type,int chnl_map,int tx_power,int timeout_s)2239 static bt_status_t btif_gattc_multi_adv_update(int client_if, int min_interval, int max_interval,
2240 int adv_type, int chnl_map,int tx_power, int timeout_s)
2241 {
2242 CHECK_BTGATT_INIT();
2243 btgatt_multi_adv_inst_cb adv_cb;
2244 memset(&adv_cb, 0, sizeof(btgatt_multi_adv_inst_cb));
2245 adv_cb.client_if = (uint8_t) client_if;
2246
2247 adv_cb.param.adv_int_min = min_interval;
2248 adv_cb.param.adv_int_max = max_interval;
2249 adv_cb.param.adv_type = adv_type;
2250 adv_cb.param.channel_map = chnl_map;
2251 adv_cb.param.adv_filter_policy = 0;
2252 adv_cb.param.tx_power = tx_power;
2253 adv_cb.timeout_s = timeout_s;
2254 return btif_transfer_context(btgattc_handle_event, BTIF_GATTC_ADV_INSTANCE_UPDATE,
2255 (char*) &adv_cb, sizeof(btgatt_multi_adv_inst_cb), NULL);
2256 }
2257
btif_gattc_multi_adv_setdata(int client_if,bool set_scan_rsp,bool include_name,bool incl_txpower,int appearance,int manufacturer_len,char * manufacturer_data,int service_data_len,char * service_data,int service_uuid_len,char * service_uuid)2258 static bt_status_t btif_gattc_multi_adv_setdata(int client_if, bool set_scan_rsp,
2259 bool include_name, bool incl_txpower, int appearance,
2260 int manufacturer_len, char* manufacturer_data,
2261 int service_data_len, char* service_data,
2262 int service_uuid_len, char* service_uuid)
2263 {
2264 CHECK_BTGATT_INIT();
2265
2266 btif_adv_data_t multi_adv_data_inst;
2267 memset(&multi_adv_data_inst, 0, sizeof(multi_adv_data_inst));
2268
2269 const int min_interval = 0;
2270 const int max_interval = 0;
2271
2272 btif_gattc_adv_data_packager(client_if, set_scan_rsp, include_name, incl_txpower,
2273 min_interval, max_interval, appearance, manufacturer_len, manufacturer_data,
2274 service_data_len, service_data, service_uuid_len, service_uuid, &multi_adv_data_inst);
2275
2276 bt_status_t status = btif_transfer_context(
2277 btgattc_handle_event, BTIF_GATTC_ADV_INSTANCE_SET_DATA,
2278 (char *)&multi_adv_data_inst, sizeof(multi_adv_data_inst),
2279 btif_gattc_deep_copy);
2280 btif_gattc_adv_data_cleanup(&multi_adv_data_inst);
2281 return status;
2282 }
2283
btif_gattc_multi_adv_disable(int client_if)2284 static bt_status_t btif_gattc_multi_adv_disable(int client_if)
2285 {
2286 CHECK_BTGATT_INIT();
2287 btgatt_multi_adv_inst_cb adv_cb;
2288 memset(&adv_cb, 0, sizeof(btgatt_multi_adv_inst_cb));
2289 adv_cb.client_if = (uint8_t) client_if;
2290
2291 return btif_transfer_context(btgattc_handle_event, BTIF_GATTC_ADV_INSTANCE_DISABLE,
2292 (char*) &adv_cb, sizeof(btgatt_multi_adv_inst_cb), NULL);
2293 }
2294
btif_gattc_cfg_storage(int client_if,int batch_scan_full_max,int batch_scan_trunc_max,int batch_scan_notify_threshold)2295 static bt_status_t btif_gattc_cfg_storage(int client_if,int batch_scan_full_max,
2296 int batch_scan_trunc_max, int batch_scan_notify_threshold)
2297 {
2298 CHECK_BTGATT_INIT();
2299 btgatt_batch_track_cb_t bt_scan_cb;
2300 memset(&bt_scan_cb, 0, sizeof(btgatt_batch_track_cb_t));
2301 bt_scan_cb.client_if = (uint8_t) client_if;
2302 bt_scan_cb.batch_scan_full_max = batch_scan_full_max;
2303 bt_scan_cb.batch_scan_trunc_max = batch_scan_trunc_max;
2304 bt_scan_cb.batch_scan_notify_threshold = batch_scan_notify_threshold;
2305 return btif_transfer_context(btgattc_handle_event, BTIF_GATTC_CONFIG_STORAGE_PARAMS,
2306 (char*) &bt_scan_cb, sizeof(btgatt_batch_track_cb_t), NULL);
2307 }
2308
btif_gattc_enb_batch_scan(int client_if,int scan_mode,int scan_interval,int scan_window,int addr_type,int discard_rule)2309 static bt_status_t btif_gattc_enb_batch_scan(int client_if,int scan_mode, int scan_interval,
2310 int scan_window, int addr_type, int discard_rule)
2311 {
2312 CHECK_BTGATT_INIT();
2313 btgatt_batch_track_cb_t bt_scan_cb;
2314 memset(&bt_scan_cb, 0, sizeof(btgatt_batch_track_cb_t));
2315 bt_scan_cb.client_if = (uint8_t) client_if;
2316 bt_scan_cb.scan_mode = scan_mode;
2317 bt_scan_cb.scan_interval = scan_interval;
2318 bt_scan_cb.scan_window = scan_window;
2319 bt_scan_cb.discard_rule = discard_rule;
2320 bt_scan_cb.addr_type = addr_type;
2321 return btif_transfer_context(btgattc_handle_event, BTIF_GATTC_ENABLE_BATCH_SCAN,
2322 (char*) &bt_scan_cb, sizeof(btgatt_batch_track_cb_t), NULL);
2323 }
2324
btif_gattc_dis_batch_scan(int client_if)2325 static bt_status_t btif_gattc_dis_batch_scan(int client_if)
2326 {
2327 CHECK_BTGATT_INIT();
2328 btgatt_batch_track_cb_t bt_scan_cb;
2329 memset(&bt_scan_cb, 0, sizeof(btgatt_batch_track_cb_t));
2330 bt_scan_cb.client_if = (uint8_t) client_if;
2331 return btif_transfer_context(btgattc_handle_event, BTIF_GATTC_DISABLE_BATCH_SCAN,
2332 (char*) &bt_scan_cb, sizeof(btgatt_batch_track_cb_t), NULL);
2333 }
2334
btif_gattc_read_batch_scan_reports(int client_if,int scan_mode)2335 static bt_status_t btif_gattc_read_batch_scan_reports(int client_if, int scan_mode)
2336 {
2337 CHECK_BTGATT_INIT();
2338 btgatt_batch_track_cb_t bt_scan_cb;
2339 memset(&bt_scan_cb, 0, sizeof(btgatt_batch_track_cb_t));
2340 bt_scan_cb.client_if = (uint8_t) client_if;
2341 bt_scan_cb.scan_mode = scan_mode;
2342 return btif_transfer_context(btgattc_handle_event, BTIF_GATTC_READ_BATCH_SCAN_REPORTS,
2343 (char*) &bt_scan_cb, sizeof(btgatt_batch_track_cb_t), NULL);
2344 }
2345
2346 extern bt_status_t btif_gattc_test_command_impl(int command, btgatt_test_params_t* params);
2347
btif_gattc_test_command(int command,btgatt_test_params_t * params)2348 static bt_status_t btif_gattc_test_command(int command, btgatt_test_params_t* params)
2349 {
2350 return btif_gattc_test_command_impl(command, params);
2351 }
2352
2353
2354 const btgatt_client_interface_t btgattClientInterface = {
2355 btif_gattc_register_app,
2356 btif_gattc_unregister_app,
2357 btif_gattc_scan,
2358 btif_gattc_open,
2359 btif_gattc_close,
2360 btif_gattc_listen,
2361 btif_gattc_refresh,
2362 btif_gattc_search_service,
2363 btif_gattc_get_included_service,
2364 btif_gattc_get_characteristic,
2365 btif_gattc_get_descriptor,
2366 btif_gattc_read_char,
2367 btif_gattc_write_char,
2368 btif_gattc_read_char_descr,
2369 btif_gattc_write_char_descr,
2370 btif_gattc_execute_write,
2371 btif_gattc_reg_for_notification,
2372 btif_gattc_dereg_for_notification,
2373 btif_gattc_read_remote_rssi,
2374 btif_gattc_scan_filter_param_setup,
2375 btif_gattc_scan_filter_add_remove,
2376 btif_gattc_scan_filter_clear,
2377 btif_gattc_scan_filter_enable,
2378 btif_gattc_get_device_type,
2379 btif_gattc_set_adv_data,
2380 btif_gattc_configure_mtu,
2381 btif_gattc_conn_parameter_update,
2382 btif_gattc_set_scan_parameters,
2383 btif_gattc_multi_adv_enable,
2384 btif_gattc_multi_adv_update,
2385 btif_gattc_multi_adv_setdata,
2386 btif_gattc_multi_adv_disable,
2387 btif_gattc_cfg_storage,
2388 btif_gattc_enb_batch_scan,
2389 btif_gattc_dis_batch_scan,
2390 btif_gattc_read_batch_scan_reports,
2391 btif_gattc_test_command
2392 };
2393
2394 #endif
2395