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