2 * Open Adaptation Layer (OAL)
4 * Copyright (c) 2014-2015 Samsung Electronics Co., Ltd.
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
10 * http://www.apache.org/licenses/LICENSE-2.0
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
20 #include <bluetooth.h>
22 #include "oal-event.h"
23 #include "oal-internal.h"
24 #include "oal-manager.h"
25 #include "oal-adapter-mgr.h"
26 #include "oal-utils.h"
28 #include "oal-common.h"
30 #define DEV_APPEARANCE 0x0000
31 #define DEFAULT_GATT_CLIENT_UUID "0000A00A-1111-1111-0123-456789ABCDEF"
32 #define MAX_PROP_LEN 95 /* SVACE WGID: 324403*/
33 #define MAX_PERM_LEN 80 //Fix for svace wgid:324402
35 #define NUM_SERVER_INST 10 // Maximum slots supported by stack is set to 10
36 #define CHECK_OAL_GATT_ENABLED() \
38 if (gatt_api == NULL) { \
39 BT_ERR("GATT Not Enabled"); \
40 return OAL_STATUS_NOT_READY; \
44 #define CHECK_SERVER_INSTANCE(instance_id) \
46 if (instance_id < 1 || instance_id > NUM_SERVER_INST) { \
47 BT_ERR("Invalid Instance"); \
48 return OAL_STATUS_INVALID_PARAM; \
52 #define CHECK_SERVER_REGISTRATION(instance_id) \
54 if (gatt_servers[instance_id - 1].server_id < 0) {\
55 BT_INFO("GATT server registeration is not done for server Instance : %d", instance_id);\
56 return OAL_STATUS_INTERNAL_ERROR;\
60 #define CHECK_CORRECT_SERVER_ID(instance_id, server_if, server_inst)\
62 for (instance_id = 1 ; instance_id <= NUM_SERVER_INST; instance_id++) { \
63 if (gatt_servers[instance_id - 1].server_id == server_if) { \
64 server_inst = instance_id; \
70 #define PRINT_ADV_DATA(length, manuf_data, data_type) \
72 char * buf_str = g_malloc0(3*length + 1);\
73 if (NULL != buf_str) { \
74 convert_hex_2_str(manuf_data, length, buf_str);\
75 if (TRUE == data_type) \
76 BT_INFO("Scan Response Data:%s\n", buf_str);\
78 BT_INFO("Advertising Data:%s\n", buf_str);\
83 #define CHECK_CLIENT_REGISTRATION(client_id) \
85 if (client_id <= 0) { \
86 BT_DBG("No client registered yet...");\
87 return OAL_STATUS_INTERNAL_ERROR;\
91 #define CHECK_CLIENT_CONNECTION(conn_id) \
94 BT_ERR("No active connection");\
95 return OAL_STATUS_INTERNAL_ERROR;\
102 GATT_INS_DATA_SETTING,
114 const char *oal_device_type[] = {
125 } oal_pending_gattc_req_e;
127 static const btgatt_interface_t * gatt_api;
128 static gboolean cur_adv_state[NUM_SERVER_INST];
129 static gatt_server_t gatt_servers[NUM_SERVER_INST];
131 /* Forward declarations of GATT Server callbacks */
132 static void cb_gatts_register_app(int status, int server_if, bt_uuid_t *uuid);
133 static void cb_gatts_multi_adv_enable(int server_if, int status);
134 static void cb_gatts_multi_adv_set_inst_data(int server_if, int status);
135 static void cb_gatts_multi_adv_disable(int server_if, int status);
136 static void cb_gatts_multi_adv_update(int server_if, int status);
138 static void cb_gatts_listen(int status, int server_if);
141 static void cb_gatts_service_added(int status, int server_if, btgatt_srvc_id_t *srvc_id, int srvc_handle);
142 static void cb_gatts_included_service_added(int status, int server_if, int srvc_handle, int incl_srvc_handle);
143 static void cb_gatts_characteristic_added(int status, int server_if, bt_uuid_t *char_id, int srvc_handle, int char_handle);
144 static void cb_gatts_descriptor_added(int status, int server_if, bt_uuid_t *descr_id, int srvc_handle, int descr_handle);
146 static void cb_gatts_service_started(int status, int server_if, int srvc_handle);
147 static void cb_gatts_service_stopped(int status, int server_if, int srvc_handle);
148 static void cb_gatts_service_deleted(int status, int server_if, int srvc_handle);
150 static void cb_gatts_request_read(int conn_id, int trans_id, bt_bdaddr_t *bda, int attr_handle, int offset, bool is_long);
151 static void cb_gatts_request_write(int conn_id, int trans_id, bt_bdaddr_t *bda, int attr_handle, int offset, int length,
152 bool need_rsp, bool is_prep, uint8_t* value);
153 static void cb_gatts_response_confirmation(int status, int handle);
155 static void cb_gatts_acquire_write(int fd, int conn_id, int trans_id, int attr_handle, bt_bdaddr_t*);
156 static void cb_gatts_acquire_notify(int fd, int conn_id, int trans_id, int attr_handle);
158 static void cb_indication_confirmation(int conn_id, int trans_id, int attr_handle, bt_bdaddr_t *bda);
159 static void cb_gatts_connection(int conn_id, int server_if, int connected, bt_bdaddr_t *bda);
161 static void cb_gatts_mtu_changed(int conn_id, int mtu);
164 static void cb_notifcation_changed(int conn_id, int trans_id, int attr_handle, bool notify, bt_bdaddr_t *bda);
167 /************************************HAL Interface *************************************/
169 /*TODO GATT Server callbacks will be implemented in subsequent patches */
170 static const btgatt_server_callbacks_t btgatt_server_callbacks = {
171 .register_server_cb = cb_gatts_register_app,
172 .connection_cb = cb_gatts_connection,
173 .service_added_cb = cb_gatts_service_added,
174 .included_service_added_cb = cb_gatts_included_service_added,
175 .characteristic_added_cb = cb_gatts_characteristic_added,
176 .descriptor_added_cb = cb_gatts_descriptor_added,
177 .service_started_cb = cb_gatts_service_started,
178 .service_stopped_cb = cb_gatts_service_stopped,
179 .service_deleted_cb = cb_gatts_service_deleted,
180 .indication_confirmation_cb = cb_indication_confirmation,
181 .request_read_cb = cb_gatts_request_read,
182 .request_write_cb = cb_gatts_request_write,
183 .request_exec_write_cb = NULL,
184 .response_confirmation_cb = cb_gatts_response_confirmation,
185 .listen_cb = cb_gatts_listen,
186 .multi_adv_enable_cb = cb_gatts_multi_adv_enable,
187 .multi_adv_update_cb = cb_gatts_multi_adv_update,
188 .multi_adv_data_cb = cb_gatts_multi_adv_set_inst_data,
189 .multi_adv_disable_cb = cb_gatts_multi_adv_disable,
190 .mtu_changed_cb = cb_gatts_mtu_changed,
192 .notif_enabled_cb = cb_notifcation_changed,
194 .request_acquire_write_cb = cb_gatts_acquire_write,
195 .request_acquire_notify_cb = cb_gatts_acquire_notify
198 /* Forward declaration for GATT client callbacks */
199 static void cb_gattc_register_app(int status, int clientIf, bt_uuid_t *app_uuid);
200 static void cb_gattc_scan_result(bt_bdaddr_t* bdaddress, int rssi, uint8_t *adv_data);
201 static void cb_gattc_connection(int conn_id, int status, int client_if, bt_bdaddr_t* bda);
202 static void cb_gattc_disconnect(int conn_id, int status, int client_if, bt_bdaddr_t* bda);
203 static void cb_gattc_search_result(int conn_id, btgatt_srvc_id_t *srvc_id);
204 static void cb_gattc_search_complete(int conn_id, int status);
205 static void cb_gattc_get_characteristics(int conn_id, int status, btgatt_srvc_id_t *srvc_id,
206 btgatt_gatt_id_t *char_id, int char_prop);
207 static void cb_gattc_get_descriptor(int conn_id, int status, btgatt_srvc_id_t *srvc_id,
208 btgatt_gatt_id_t *char_id, btgatt_gatt_id_t *descr_id);
209 static void cb_gattc_read_characteristic(int conn_id, int status, btgatt_read_params_t *p_data);
210 static void cb_gattc_read_descriptor(int conn_id, int status, btgatt_read_params_t *p_data);
211 static void cb_gattc_write_characteristic(int conn_id, int status, btgatt_write_params_t *p_data);
212 static void cb_gattc_write_descriptor(int conn_id, int status, btgatt_write_params_t *p_data);
213 static void cb_gattc_register_for_notification(int conn_id, int registered, int status,
214 btgatt_srvc_id_t *srvc_id, btgatt_gatt_id_t *char_id);
215 static void cb_gattc_notify(int conn_id, btgatt_notify_params_t *p_data);
217 /*TODO GATT CLient callbacks will be implemented in subsequent patches */
218 static const btgatt_client_callbacks_t btgatt_client_callbacks = {
219 .register_client_cb = cb_gattc_register_app,
220 .scan_result_cb = cb_gattc_scan_result,
221 .open_cb = cb_gattc_connection,
222 .close_cb = cb_gattc_disconnect,
223 .search_complete_cb = cb_gattc_search_complete,
224 .search_result_cb = cb_gattc_search_result,
225 .get_characteristic_cb = cb_gattc_get_characteristics,
226 .get_descriptor_cb = cb_gattc_get_descriptor,
227 .get_included_service_cb = NULL,
228 .register_for_notification_cb = cb_gattc_register_for_notification,
229 .notify_cb = cb_gattc_notify,
230 .read_characteristic_cb = cb_gattc_read_characteristic,
231 .write_characteristic_cb = cb_gattc_write_characteristic,
232 .read_descriptor_cb = cb_gattc_read_descriptor,
233 .write_descriptor_cb = cb_gattc_write_descriptor,
234 .execute_write_cb = NULL,
235 .read_remote_rssi_cb = NULL,
236 .configure_mtu_cb = NULL,
237 #ifdef PLATFORM_ANDROID_HAL
238 .scan_filter_cfg_cb = NULL,
239 .scan_filter_param_cb = NULL,
240 .scan_filter_status_cb = NULL,
241 .congestion_cb = NULL,
242 .batchscan_cfg_storage_cb = NULL,
243 .batchscan_enb_disable_cb = NULL,
244 .batchscan_reports_cb = NULL,
245 .batchscan_threshold_cb = NULL,
246 .track_adv_event_cb = NULL,
250 static btgatt_callbacks_t btgatt_callbacks = {
251 sizeof(btgatt_callbacks_t),
252 &btgatt_client_callbacks,
253 &btgatt_server_callbacks
256 /*******************************GATT Initialisation - Deinitialisation********************************/
257 oal_status_t gatt_enable(void)
259 const bt_interface_t * blued_api;
263 for (i = 0; i < NUM_SERVER_INST; i++) {
264 gatt_servers[i].server_id = -1;
265 gatt_servers[i].state = GATT_INS_DISABLED;
266 memset(&gatt_servers[i].uuid, 0, sizeof(oal_uuid_t));
267 cur_adv_state[i] = FALSE;
270 /* Get stack interface */
271 blued_api = (const bt_interface_t *) adapter_get_stack_interface();
273 if (blued_api == NULL) {
274 BT_ERR("Stack is not initialized");
275 return OAL_STATUS_NOT_READY;
279 BT_WARN("GATT Interface is already initialized...");
280 return OAL_STATUS_ALREADY_DONE;
283 gatt_api = (const btgatt_interface_t *)blued_api->get_profile_interface(BT_PROFILE_GATT_ID);
284 if (gatt_api == NULL) {
285 BT_ERR("GATT interface failed");
286 return OAL_STATUS_INTERNAL_ERROR;
289 if ((ret = gatt_api->init(&btgatt_callbacks)) != BT_STATUS_SUCCESS) {
290 BT_ERR("Error: Unable to initialise GATT :%s", status2string(ret));
293 return convert_to_oal_status(ret);
296 BT_INFO("GATT successfully initialized");
297 return OAL_STATUS_SUCCESS;
300 oal_status_t gatt_disable(void)
308 for (i = 0; i < NUM_SERVER_INST; i++) {
309 gatt_servers[i].server_id = -1;
310 gatt_servers[i].state = GATT_INS_DISABLED;
311 memset(&gatt_servers[i].uuid, 0, sizeof(oal_uuid_t));
313 return OAL_STATUS_SUCCESS;
316 /************************************GATT Server Functions*************************************/
318 oal_status_t gatts_register(oal_uuid_t* server_uuid)
320 char str[2*BT_UUID_STRING_MAX];
321 int ret = OAL_STATUS_SUCCESS;
324 CHECK_OAL_GATT_ENABLED();
325 uuid_to_stringname((service_uuid_t*)server_uuid->uuid, str);
326 API_TRACE("Register the server instance: UUID: [%s]", str);
328 for (i = 0; i < NUM_SERVER_INST; i++) {
329 if (memcmp(server_uuid->uuid, gatt_servers[i].uuid.uuid, sizeof(oal_uuid_t)) == 0) {
330 if (gatt_servers[i].server_id != -1) {
331 BT_ERR("This is resevered UUID for easy set up application i = %d \
332 gatt_servers[i].server_id = %d", i, gatt_servers[i].server_id);
333 return OAL_STATUS_ALREADY_DONE;
338 ret = gatt_api->server->register_server((bt_uuid_t*)server_uuid);
340 if (ret != BT_STATUS_SUCCESS) {
341 BT_ERR("GATT server registration with UUID:%s failed: %s", str, status2string(ret));
342 return convert_to_oal_status(ret);
344 return OAL_STATUS_SUCCESS;
347 oal_status_t gatts_unregister(int instance_id)
349 int ret = OAL_STATUS_SUCCESS;
350 API_TRACE("Unregister the registered server, instance_id: %d", instance_id);
352 CHECK_OAL_GATT_ENABLED();
353 CHECK_SERVER_INSTANCE(instance_id);
354 CHECK_SERVER_REGISTRATION(instance_id);
356 ret = gatt_api->server->unregister_server(gatt_servers[instance_id - 1].server_id);
358 if (ret != BT_STATUS_SUCCESS) {
359 BT_ERR("GATT server unregistration failed: %d", instance_id);
360 return convert_to_oal_status(ret);
363 gatt_servers[instance_id-1].server_id = -1;
364 gatt_servers[instance_id-1].state = GATT_INS_DISABLED;
366 if (instance_id != 1 && instance_id != 2)
367 memset(&gatt_servers[instance_id-1].uuid, 0, sizeof(oal_uuid_t));
369 return OAL_STATUS_SUCCESS;
372 /* Legacy Advertisement */
373 oal_status_t gatts_start_listen(int instance_id, gboolean enable)
375 int ret = OAL_STATUS_SUCCESS;
376 API_TRACE("server-id:%d enable: %d", gatt_servers[instance_id-1].server_id, enable);
378 CHECK_OAL_GATT_ENABLED();
379 CHECK_SERVER_INSTANCE(instance_id);
380 CHECK_SERVER_REGISTRATION(instance_id);
382 ret = gatt_api->server->listen(gatt_servers[instance_id-1].server_id, enable);
384 if (ret != BT_STATUS_SUCCESS) {
385 BT_ERR("Error:Advertising start/stop on server-id:%d failed With Status: [%s]",
386 gatt_servers[instance_id-1].server_id, status2string(ret));
387 return convert_to_oal_status(ret);
390 return OAL_STATUS_SUCCESS;
393 oal_status_t gatts_stop_advertising(int instance_id)
395 int ret = OAL_STATUS_SUCCESS;
396 API_TRACE("Stop advertising");
398 CHECK_OAL_GATT_ENABLED();
399 CHECK_SERVER_INSTANCE(instance_id);
400 CHECK_SERVER_REGISTRATION(instance_id);
402 ret = gatt_api->server->listen(gatt_servers[instance_id - 1].server_id, FALSE);
404 if (ret != BT_STATUS_SUCCESS) {
405 BT_ERR("Stop Advertising failed for server Instance:%d With Status: %s",
406 instance_id, status2string(ret));
407 return convert_to_oal_status(ret);
409 return OAL_STATUS_SUCCESS;
413 /* Below API's need to be removed as they are hardcoded API's.
414 If at all, product specific API's are required to set specific data, then new naming should
415 be adopted for these API's */
416 oal_status_t gatts_set_advertising_params(int instance_id, float min_intv, float max_intv)
418 int ret = OAL_STATUS_SUCCESS;
420 API_TRACE("Set advertising params min_int:%f, max_int:%f", min_intv, max_intv);
421 CHECK_OAL_GATT_ENABLED();
422 CHECK_SERVER_INSTANCE(instance_id);
423 CHECK_SERVER_REGISTRATION(instance_id);
425 /* Historically used for Legacy Advertising */
426 return OAL_STATUS_NOT_SUPPORT;
429 oal_status_t gatts_set_advertising_data(int instance_id, uint16_t manufac_len, char* manufac_data)
431 int ret = OAL_STATUS_SUCCESS;
433 API_TRACE("Set advertising data");
434 CHECK_OAL_GATT_ENABLED();
435 CHECK_SERVER_INSTANCE(instance_id);
436 CHECK_SERVER_REGISTRATION(instance_id);
438 /* Historically used for Legacy Advertising */
439 return OAL_STATUS_NOT_SUPPORT;
442 oal_status_t gatts_set_scan_response(int instance_id, uint16_t manufac_len, char* manufac_data)
444 int ret = OAL_STATUS_SUCCESS;
446 API_TRACE("Set Scan Response data");
447 CHECK_OAL_GATT_ENABLED();
448 CHECK_SERVER_INSTANCE(instance_id);
449 CHECK_SERVER_REGISTRATION(instance_id);
451 /* Historically used for Legacy Advertising */
452 return OAL_STATUS_NOT_SUPPORT;
456 oal_status_t gatts_multi_adv_enable(int instance_id)
458 int ret = OAL_STATUS_SUCCESS;
459 API_TRACE("Start Multi advertising, srv_if: %d, instance_id: %d",
460 gatt_servers[instance_id - 1].server_id, instance_id);
462 CHECK_OAL_GATT_ENABLED();
463 CHECK_SERVER_INSTANCE(instance_id);
464 CHECK_SERVER_REGISTRATION(instance_id);
466 if (gatt_api->server->multi_adv_enable == NULL)
467 return OAL_STATUS_NOT_SUPPORT;
469 /* Platform Requirement: Advertising to be enabled even when no data is set: i.e Empty Advertisement
470 if (gatt_servers[instance_id - 1].state != GATT_INS_DATA_SET){
471 BT_ERR("Not allowed, state: %d, instance_id: %d",
472 gatt_servers[instance_id - 1].state, instance_id);
473 return OAL_STATUS_BUSY;
476 if (gatt_servers[instance_id - 1].state == GATT_INS_ENABLED) {
477 BT_ERR("Not allowed, state: %d, instance_id: %d",
478 gatt_servers[instance_id - 1].state, instance_id);
479 return OAL_STATUS_ALREADY_DONE;
482 if (gatt_servers[instance_id - 1].state == GATT_INS_ENABLING) {
483 BT_ERR("Not allowed, state: %d, instance_id: %d",
484 gatt_servers[instance_id - 1].state, instance_id);
485 return OAL_STATUS_BUSY;
488 gatt_servers[instance_id - 1].state = GATT_INS_ENABLING;
490 ret = gatt_api->server->multi_adv_enable(gatt_servers[instance_id - 1].server_id);
492 if (ret != BT_STATUS_SUCCESS) {
493 BT_ERR("GATT enable multi advertising failed for server Instance: %d With Status: %s",
494 instance_id, status2string(ret));
495 // gatt_servers[instance_id - 1].state = GATT_INS_DATA_SET;
496 return convert_to_oal_status(ret);
498 return OAL_STATUS_SUCCESS;
501 oal_status_t gatts_multi_adv_disable(int instance_id)
503 int ret = OAL_STATUS_SUCCESS;
504 API_TRACE("Stop Multi advertising, srv_if: %d, instance_id: %d",
505 gatt_servers[instance_id - 1].server_id, instance_id);
507 CHECK_OAL_GATT_ENABLED();
508 CHECK_SERVER_INSTANCE(instance_id);
509 CHECK_SERVER_REGISTRATION(instance_id);
511 if (gatt_api->server->multi_adv_disable == NULL)
512 return OAL_STATUS_NOT_SUPPORT;
514 if ((gatt_servers[instance_id - 1].state != GATT_INS_ENABLED)) {
515 BT_ERR("Not Allowed, state: %d, instance_id: %d",
516 gatt_servers[instance_id - 1].state, instance_id);
517 return OAL_STATUS_BUSY;
520 ret = gatt_api->server->multi_adv_disable(gatt_servers[instance_id - 1].server_id);
522 if (ret != BT_STATUS_SUCCESS) {
523 BT_ERR("GATT disable multi advertising failed for server Instance: %d With Status: %s",
524 instance_id, status2string(ret));
525 return convert_to_oal_status(ret);
527 return OAL_STATUS_SUCCESS;
530 oal_status_t gatts_set_filter_policy(int filter_policy)
532 int ret = OAL_STATUS_SUCCESS;
534 CHECK_OAL_GATT_ENABLED();
536 /* send the filter_policy value to the HAL Layer */
537 ret = gatt_api->server->set_filter_policy(filter_policy);
539 if (ret != BT_STATUS_SUCCESS) {
540 BT_ERR("set_filter_policy failed: %d",ret);
541 return convert_to_oal_status(ret);
544 return OAL_STATUS_SUCCESS;
547 oal_status_t gatts_multi_adv_update(int instance_id,
548 int min_intv, int max_intv,
549 int adv_type, int chnl_map,
550 int tx_power, int timeout_s)
552 int ret = OAL_STATUS_SUCCESS;
553 API_TRACE("Multi advertising Update");
555 CHECK_OAL_GATT_ENABLED();
556 CHECK_SERVER_INSTANCE(instance_id);
557 CHECK_SERVER_REGISTRATION(instance_id);
559 if (gatt_api->server->multi_adv_update == NULL)
560 return OAL_STATUS_NOT_SUPPORT;
562 ret = gatt_api->server->multi_adv_update(gatt_servers[instance_id - 1].server_id,
565 tx_power, timeout_s);
567 if (ret != BT_STATUS_SUCCESS) {
568 BT_ERR("GATT update multi advertising failed for server Instance: %d With Status: %s",
569 instance_id, status2string(ret));
570 return convert_to_oal_status(ret);
572 return OAL_STATUS_SUCCESS;
575 oal_status_t gatts_multi_adv_set_inst_data(int instance_id,
576 oal_ble_multi_adv_param_setup_t *adv_param_setup)
578 int ret = OAL_STATUS_SUCCESS;
579 btgatt_adv_param_setup_t adv_setup;
580 API_TRACE("Set Multi advertising data, srv_if: %d, instance_id: %d",
581 gatt_servers[instance_id - 1].server_id, instance_id);
583 CHECK_OAL_GATT_ENABLED();
584 CHECK_SERVER_INSTANCE(instance_id);
585 CHECK_SERVER_REGISTRATION(instance_id);
587 if (gatt_api->server->multi_adv_set_inst_data == NULL)
588 return OAL_STATUS_NOT_SUPPORT;
590 if ((gatt_servers[instance_id - 1].state >= GATT_INS_DATA_SETTING) && (gatt_servers[instance_id - 1].state != GATT_INS_DATA_SET)) {
591 BT_ERR("Not Allowed, state: %d, instance_id: %d", gatt_servers[instance_id - 1].state, instance_id);
592 return OAL_STATUS_BUSY;
595 gatt_servers[instance_id - 1].state = GATT_INS_DATA_SETTING;
598 adv_setup.set_scan_rsp = adv_param_setup->set_scan_rsp;
599 adv_setup.include_name = adv_param_setup->include_name;
600 adv_setup.include_txpower = adv_param_setup->include_txpower;
601 adv_setup.appearance = adv_param_setup->appearance;
602 adv_setup.manufacturer_data = adv_param_setup->manufacturer_data;
603 adv_setup.manufacturer_data_len = adv_param_setup->manufacturer_data_len;
604 adv_setup.service_data = adv_param_setup->service_data;
605 adv_setup.service_data_len = adv_param_setup->service_data_len;
606 adv_setup.service_uuid = adv_param_setup->service_uuid;
607 adv_setup.service_uuid_len = adv_param_setup->service_uuid_len;
608 /* Solicit UUID handler: Start */
609 adv_setup.solicit_uuid = adv_param_setup->solicit_uuid;
610 adv_setup.solicit_uuid_len = adv_param_setup->solicit_uuid_len;
611 /* Solicit UUID handler: End */
612 adv_setup.min_interval = adv_param_setup->min_interval;
613 adv_setup.max_interval = adv_param_setup->min_interval;
614 adv_setup.adv_type = adv_param_setup->adv_type;
615 adv_setup.chnl_map = adv_param_setup->chnl_map;
616 adv_setup.tx_power = adv_param_setup->tx_power;
617 adv_setup.timeout_s = adv_param_setup->timeout_s;
619 adv_setup.server_if = gatt_servers[instance_id - 1].server_id;
620 if (adv_setup.manufacturer_data_len > 0 && adv_setup.manufacturer_data != NULL) {
621 BT_INFO("Manufacture data.....\n");
622 PRINT_ADV_DATA(adv_setup.manufacturer_data_len, (unsigned char *)adv_setup.manufacturer_data, adv_setup.set_scan_rsp);
625 if (adv_setup.service_uuid_len > 0 && adv_setup.service_uuid != NULL) {
626 BT_INFO("Service uuid.....\n");
627 PRINT_ADV_DATA(adv_setup.service_uuid_len, (unsigned char*)adv_setup.service_uuid, FALSE);
631 ret = gatt_api->server->multi_adv_set_inst_data(adv_setup);
633 if (ret != BT_STATUS_SUCCESS) {
634 BT_ERR("GATT Set Multi advertising data failed: %s", status2string(ret));
635 gatt_servers[instance_id - 1].state = GATT_INS_DISABLED;
636 return convert_to_oal_status(ret);
638 return OAL_STATUS_SUCCESS;
641 oal_status_t gatts_disconnect(int instance_id, bt_address_t *device_address, int conn_id)
643 int ret = OAL_STATUS_SUCCESS;
646 API_TRACE("Server Disonnect: instance_id = %d, conn_id = %d", instance_id, conn_id);
648 CHECK_OAL_GATT_ENABLED();
649 CHECK_SERVER_INSTANCE(instance_id);
650 CHECK_SERVER_REGISTRATION(instance_id);
652 API_TRACE("[%s]", bdt_bd2str(device_address, &bdstr));
654 ret = gatt_api->server->disconnect(gatt_servers[instance_id - 1].server_id, (bt_bdaddr_t *) device_address, conn_id);
655 if (ret != BT_STATUS_SUCCESS) {
656 BT_ERR("GATT Server disconnect failed: %s", status2string(ret));
657 return convert_to_oal_status(ret);
659 return OAL_STATUS_SUCCESS;
663 /************************************GATT Server Functions*************************************/
665 static void cb_gatts_register_app(int status, int server_if, bt_uuid_t *uuid)
668 char str[2*BT_UUID_STRING_MAX];
669 uuid_to_stringname((service_uuid_t*)uuid, str);
671 event_gatts_register_t *event = g_malloc0(sizeof(event_gatts_register_t));
673 BT_INFO("BTGATT SERVER REGISTER APP CB, status:%d, server_if:%d", status, server_if);
674 BT_INFO("UUID: [%s]", str);
676 for (i = 0; i < NUM_SERVER_INST; i++) {
677 if (gatt_servers[i].server_id == -1) {
678 BT_INFO("Server Instance registered with stack [%d]", i+1);
679 gatt_servers[i].server_id = server_if;
680 event->server_inst = i+1;
681 memcpy(gatt_servers[i].uuid.uuid, uuid->uu, sizeof(bt_uuid_t));
682 memcpy(event->server_uuid.uuid, uuid->uu, sizeof(bt_uuid_t));
686 send_event(OAL_EVENT_BLE_SERVER_INSTANCE_INITIALISED, event, sizeof(event_gatts_register_t));
689 static void cb_gatts_listen(int status, int server_if)
691 gboolean prev_state[NUM_SERVER_INST];
693 event_ble_adv_status *event = g_malloc0(sizeof(event_ble_adv_status));
696 for (instance_id = 1 ; instance_id <= NUM_SERVER_INST ; instance_id++) {
697 if (gatt_servers[instance_id - 1].server_id == server_if) {
698 event->server_inst = instance_id;
701 BT_WARN("Server ID:%d recevied server Id:%d\n", gatt_servers[instance_id - 1].server_id, server_if);
704 if ((event->server_inst > 0) && (event->server_inst <= 10)) {
705 prev_state[event->server_inst - 1] = cur_adv_state[event->server_inst - 1];
706 new_state = (status == BT_STATUS_SUCCESS) ? !(prev_state[event->server_inst - 1]) : (prev_state[event->server_inst - 1]);
707 cur_adv_state[event->server_inst - 1] = new_state;
709 BT_ERR("Invalid Callback...");
714 BT_INFO("Adv State of server instance %d :%d", instance_id, new_state);
716 if (TRUE == new_state)
717 send_event(OAL_EVENT_BLE_ADVERTISING_STARTED, event, sizeof(event_ble_adv_status));
719 send_event(OAL_EVENT_BLE_ADVERTISING_STOPPED, event, sizeof(event_ble_adv_status));
722 static void cb_gatts_multi_adv_enable(int server_if, int status)
725 BT_INFO("BTGATT SERVER MULTI ADV ENABLE CB, status:%d, srv_if: %d", status, server_if);
726 event_ble_multiadv_status *event = g_malloc0(sizeof(event_ble_multiadv_status));
729 if (status != BT_STATUS_SUCCESS)
730 BT_ERR("MULTI ADV ENABLE failed, status:%d, srv_if: %d", status, server_if);
732 for (instance_id = 1 ; instance_id <= NUM_SERVER_INST ; instance_id++) {
733 if (gatt_servers[instance_id - 1].server_id == server_if) {
734 event->server_inst = instance_id;
735 gatt_servers[instance_id - 1].state = GATT_INS_ENABLED;
739 BT_ERR("Invalid Interface, srv_if: %d", server_if);
740 event->server_inst = -1;
742 event->status = convert_to_oal_status(status);
743 send_event(OAL_EVENT_BLE_MULTI_ADVERTISING_ENABLE, event, sizeof(event_ble_multiadv_status));
746 static void cb_gatts_multi_adv_disable(int server_if, int status)
748 BT_INFO("BTGATT SERVER MULTI ADV DISABLE CB, status:%d, srv_if: %d", status, server_if);
749 event_ble_multiadv_status *event = g_malloc0(sizeof(event_ble_multiadv_status));
752 if (status != BT_STATUS_SUCCESS)
753 BT_ERR("MULTI ADV DISABLE failed, status:%d, srv_if: %d", status, server_if);
755 for (instance_id = 1 ; instance_id <= NUM_SERVER_INST; instance_id++) {
756 if (gatt_servers[instance_id - 1].server_id == server_if) {
757 event->server_inst = instance_id;
758 gatt_servers[instance_id - 1].state = GATT_INS_DISABLED;
762 BT_ERR("Invalid Interface, srv_if: %d", server_if);
763 event->server_inst = -1;
765 event->status = convert_to_oal_status(status);
766 send_event(OAL_EVENT_BLE_MULTI_ADVERTISING_DISABLE, event, sizeof(event_ble_multiadv_status));
769 static void cb_gatts_multi_adv_update(int server_if, int status)
771 BT_INFO("BTGATT SERVER MULTI ADV UPDATE CB, status:%d, srv_if: %d", status, server_if);
772 event_ble_multiadv_status *event = g_malloc0(sizeof(event_ble_multiadv_status));
775 if (status != BT_STATUS_SUCCESS)
776 BT_ERR("MULTI ADV UPDATE failed, status:%d, srv_if: %d", status, server_if);
778 for (instance_id = 1 ; instance_id <= NUM_SERVER_INST ; instance_id++) {
779 if (gatt_servers[instance_id - 1].server_id == server_if) {
780 event->server_inst = instance_id;
784 BT_ERR("Invalid Interface, srv_if: %d", server_if);
785 event->server_inst = -1;
787 event->status = convert_to_oal_status(status);
788 send_event(OAL_EVENT_BLE_MULTI_ADVERTISING_UPDATE, event, sizeof(event_ble_multiadv_status));
791 static void cb_gatts_multi_adv_set_inst_data(int server_if, int status)
793 BT_INFO("BTGATT SERVER MULTI ADV SET INST DATA CB, status:%d, srv_if: %d", status, server_if);
794 event_ble_multiadv_status *event = g_malloc0(sizeof(event_ble_multiadv_status));
797 if (status != BT_STATUS_SUCCESS)
798 BT_ERR("MULTI ADV SET DATA failed, status:%d, srv_if: %d", status, server_if);
800 for (instance_id = 1 ; instance_id <= NUM_SERVER_INST ; instance_id++) {
801 if (gatt_servers[instance_id - 1].server_id == server_if) {
802 event->server_inst = instance_id;
803 gatt_servers[instance_id - 1].state = GATT_INS_DATA_SET;
807 BT_ERR("Invalid Interface, srv_if: %d", server_if);
808 event->server_inst = -1;
810 event->status = convert_to_oal_status(status);
811 send_event(OAL_EVENT_BLE_MULTI_ADVERTISING_SET_INST_DATA, event, sizeof(event_ble_multiadv_status));
814 oal_status_t gatts_get_att_mtu(int conn_id, int *mtu)
816 int ret = OAL_STATUS_SUCCESS;
817 API_TRACE("Get ATT MTU, conn_id: %d", conn_id);
818 CHECK_OAL_GATT_ENABLED();
819 OAL_CHECK_PARAMETER(mtu, return);
821 /* To prevent crash in case other libraries not support this api */
822 if (gatt_api->server->get_att_mtu == NULL) {
823 BT_WARN("get_att_mtu is NULL");
824 return OAL_STATUS_NOT_SUPPORT;
827 ret = gatt_api->server->get_att_mtu(conn_id, mtu);
828 if (ret != BT_STATUS_SUCCESS) {
829 BT_ERR("GATT MTU Size failed, status: %s", status2string(ret));
830 return convert_to_oal_status(ret);
833 BT_INFO("Current ATT MTU Size: %d", *mtu);
834 return OAL_STATUS_SUCCESS;
836 oal_status_t gatt_send_response_acquire(int conn_id, int trans_id,
837 int status, int fd, int mtu , void * fdlist)
839 int ret = OAL_STATUS_SUCCESS;
841 API_TRACE("Server Send Response : ConnId = %d, TransId = %d, %d", conn_id, trans_id, fd);
842 CHECK_OAL_GATT_ENABLED();
844 ret = gatt_api->server->send_response_acquire(conn_id, trans_id, status, fd, mtu, fdlist);
845 if (ret != BT_STATUS_SUCCESS) {
846 BT_ERR("GATT Server Send Response failed: %s", status2string(ret));
847 return convert_to_oal_status(ret);
849 return OAL_STATUS_SUCCESS;
852 oal_status_t gatts_add_service(int instance_id, oal_gatt_srvc_id_t *gatt_serv_id,
855 int ret = OAL_STATUS_SUCCESS;
856 btgatt_srvc_id_t btgatt_srvc_id;
857 char str[2*BT_UUID_STRING_MAX];
859 API_TRACE("Server Add Service : instance_id = %d, num_handles = %d", instance_id, num_handles);
860 CHECK_OAL_GATT_ENABLED();
862 CHECK_SERVER_INSTANCE(instance_id);
863 CHECK_SERVER_REGISTRATION(instance_id);
865 if (gatt_serv_id != NULL) {
866 uuid_to_stringname(&(gatt_serv_id->id.uuid), str);
867 API_TRACE("Service uuid: [%s]", str);
868 memcpy(btgatt_srvc_id.id.uuid.uu, gatt_serv_id->id.uuid.uuid, sizeof(gatt_serv_id->id.uuid));
869 btgatt_srvc_id.id.inst_id = gatt_serv_id->id.inst_id;
870 btgatt_srvc_id.is_primary = gatt_serv_id->is_prmry;
872 BT_INFO("GATT Server Service Id is NULL");
873 return OAL_STATUS_INVALID_PARAM;
876 ret = gatt_api->server->add_service(gatt_servers[instance_id - 1].server_id, &btgatt_srvc_id, num_handles);
878 if (ret != BT_STATUS_SUCCESS) {
879 BT_ERR("GATT Server add service failed: %s", status2string(ret));
880 return convert_to_oal_status(ret);
882 return OAL_STATUS_SUCCESS;
885 oal_status_t gatts_add_included_services(int instance_id, int serv_handle,
888 int ret = OAL_STATUS_SUCCESS;
889 API_TRACE("Server Add included Service : instance_id = %d, serv_handle = %d, incl_handle = %d",
890 instance_id, serv_handle, incl_handle);
891 CHECK_OAL_GATT_ENABLED();
893 CHECK_SERVER_INSTANCE(instance_id);
895 CHECK_SERVER_REGISTRATION(instance_id);
897 ret = gatt_api->server->add_included_service(gatt_servers[instance_id - 1].server_id, serv_handle, incl_handle);
898 if (ret != BT_STATUS_SUCCESS) {
899 BT_ERR("GATT Server Add included Service failed: %s", status2string(ret));
900 return convert_to_oal_status(ret);
902 return OAL_STATUS_SUCCESS;
905 oal_status_t gatts_add_characteristics(int instance_id, int serv_handle,
906 oal_uuid_t* charc_uuid, int propts, int permsn)
908 int ret = OAL_STATUS_SUCCESS;
909 char str[2*BT_UUID_STRING_MAX];
910 char prop[MAX_PROP_LEN], perm[MAX_PERM_LEN];
911 char_prop_to_string(propts, prop);
912 char_perm_to_string(permsn, perm);
913 API_TRACE("Server Add Characteristic : instance_id = %d, serv_handle = %d, Properties =%s, Permisison = %s",
914 instance_id, serv_handle, prop, perm);
915 CHECK_OAL_GATT_ENABLED();
917 CHECK_SERVER_INSTANCE(instance_id);
919 CHECK_SERVER_REGISTRATION(instance_id);
921 if (charc_uuid != NULL) {
922 uuid_to_stringname(charc_uuid, str);
923 API_TRACE("uuid: [%s]", str);
926 ret = gatt_api->server->add_characteristic(gatt_servers[instance_id - 1].server_id,
927 serv_handle, (bt_uuid_t*)charc_uuid, propts, permsn);
928 if (ret != BT_STATUS_SUCCESS) {
929 BT_ERR("GATT Server Add Characteristic failed: %s", status2string(ret));
930 return convert_to_oal_status(ret);
932 return OAL_STATUS_SUCCESS;
935 oal_status_t gatts_add_descriptor(int instance_id, int serv_handle,
936 oal_uuid_t* desc_uuid, int permsn)
938 int ret = OAL_STATUS_SUCCESS;
939 char str[2*BT_UUID_STRING_MAX];
940 char perm[MAX_PERM_LEN];
941 char_perm_to_string(permsn, perm);
942 API_TRACE("Server Add Descriptor : instance_id = %d, serv_handle = %d, Permisison = %s",
943 instance_id, serv_handle, perm);
944 CHECK_OAL_GATT_ENABLED();
946 CHECK_SERVER_INSTANCE(instance_id);
948 CHECK_SERVER_REGISTRATION(instance_id);
950 if (desc_uuid != NULL) {
951 uuid_to_stringname(desc_uuid, str);
952 API_TRACE("uuid: [%s]", str);
955 ret = gatt_api->server->add_descriptor(gatt_servers[instance_id - 1].server_id,
956 serv_handle, (bt_uuid_t*)desc_uuid, permsn);
958 if (ret != BT_STATUS_SUCCESS) {
959 BT_ERR("GATT Server Add Descriptor failed: %s", status2string(ret));
960 return convert_to_oal_status(ret);
962 return OAL_STATUS_SUCCESS;
965 oal_status_t gatts_start_service(int instance_id, int svc_handle, int transport)
967 int ret = OAL_STATUS_SUCCESS;
969 API_TRACE("Server Start Service : Ins_id = %d, srvHndl = %d, transport = %d",
970 instance_id, svc_handle, transport);
971 CHECK_OAL_GATT_ENABLED();
973 CHECK_SERVER_INSTANCE(instance_id);
975 CHECK_SERVER_REGISTRATION(instance_id);
977 ret = gatt_api->server->start_service(gatt_servers[instance_id - 1].server_id, svc_handle, transport);
979 if (ret != BT_STATUS_SUCCESS) {
980 BT_ERR("GATT Server Start Service failed: %s", status2string(ret));
981 return convert_to_oal_status(ret);
983 return OAL_STATUS_SUCCESS;
986 oal_status_t gatts_stop_service(int ins_id, int srv_hdl)
988 int ret = OAL_STATUS_SUCCESS;
990 API_TRACE("Server Stop Service : Ins_id = %d, srvHndl = %d, ", ins_id, srv_hdl);
991 CHECK_OAL_GATT_ENABLED();
993 CHECK_SERVER_INSTANCE(ins_id);
994 CHECK_SERVER_REGISTRATION(ins_id);
996 ret = gatt_api->server->stop_service(gatt_servers[ins_id - 1].server_id, srv_hdl);
997 if (ret != BT_STATUS_SUCCESS) {
998 BT_ERR("GATT Server Stop Service failed: %s", status2string(ret));
999 return convert_to_oal_status(ret);
1001 return OAL_STATUS_SUCCESS;
1004 oal_status_t gatts_delete_service(int ins_id, int srv_hdl)
1006 int ret = OAL_STATUS_SUCCESS;
1008 API_TRACE("Server Delete Service : Ins_id = %d, srvHndl = %d, ", ins_id, srv_hdl);
1009 CHECK_OAL_GATT_ENABLED();
1011 CHECK_SERVER_INSTANCE(ins_id);
1013 CHECK_SERVER_REGISTRATION(ins_id);
1015 ret = gatt_api->server->delete_service(gatt_servers[ins_id - 1].server_id, srv_hdl);
1016 if (ret != BT_STATUS_SUCCESS) {
1017 BT_ERR("GATT Server Delete Service failed: %s", status2string(ret));
1018 return convert_to_oal_status(ret);
1020 return OAL_STATUS_SUCCESS;
1023 oal_status_t gatts_send_response(int conn_id, int trans_id, int resp_status, oal_gatt_response_t *response)
1025 int ret = OAL_STATUS_SUCCESS;
1027 API_TRACE("Server Send Response : ConnId = %d, TransId = %d, ", conn_id, trans_id);
1028 CHECK_OAL_GATT_ENABLED();
1030 if (response == NULL) {
1031 BT_ERR("GATT Server attribute value is empty");
1032 return OAL_STATUS_INVALID_PARAM;
1035 ret = gatt_api->server->send_response(conn_id, trans_id, resp_status, (btgatt_response_t *)response);
1036 if (ret != BT_STATUS_SUCCESS) {
1037 BT_ERR("GATT Server Send Response failed: %s", status2string(ret));
1038 return convert_to_oal_status(ret);
1040 return OAL_STATUS_SUCCESS;
1043 oal_status_t gatts_send_indication(int ins_id, int attr_hndl, int conn_id, int len, int confirm, char* value)
1045 int ret = OAL_STATUS_SUCCESS;
1047 API_TRACE("Server Send Indication : Ins_id = %d, srvHndl = %d, [%s]",
1048 ins_id, attr_hndl, confirm == TRUE ? "INDICATION" : "NOTIFICATION");
1049 CHECK_OAL_GATT_ENABLED();
1051 CHECK_SERVER_INSTANCE(ins_id);
1053 CHECK_SERVER_REGISTRATION(ins_id);
1055 if (value == NULL || len == 0) {
1056 BT_ERR("GATT Server attribute value is empty");
1057 return OAL_STATUS_INVALID_PARAM;
1060 ret = gatt_api->server->send_indication(gatt_servers[ins_id - 1].server_id,
1061 attr_hndl, conn_id, len, confirm, value);
1063 if (ret != BT_STATUS_SUCCESS) {
1064 BT_ERR("GATT Server Send Indication failed: %s", status2string(ret));
1065 return convert_to_oal_status(ret);
1067 return OAL_STATUS_SUCCESS;
1070 oal_status_t gatts_update_att_value(int ins_id, oal_gatt_value_t *value)
1072 int ret = OAL_STATUS_SUCCESS;
1074 CHECK_OAL_GATT_ENABLED();
1076 CHECK_SERVER_INSTANCE(ins_id);
1078 CHECK_SERVER_REGISTRATION(ins_id);
1080 if (value == NULL || value->len == 0) {
1081 BT_ERR("GATT Server attribute value is empty");
1082 return OAL_STATUS_INVALID_PARAM;
1085 API_TRACE("Server Update Value: Ins_id = [%d], att handle = [%d] data len [%d]",
1086 ins_id, value->handle, value->len);
1088 ret = gatt_api->server->update_att_value(gatt_servers[ins_id - 1].server_id,
1089 (int)value->handle, (int)value->len, (char*)value->value);
1091 if (ret != BT_STATUS_SUCCESS) {
1092 BT_ERR("GATT Server Update Attribute Value failed: [%s]", status2string(ret));
1093 return convert_to_oal_status(ret);
1095 return OAL_STATUS_SUCCESS;
1098 /* GATT Server Callbacks:Start */
1099 static void cb_gatts_service_added(int status, int server_if,
1100 btgatt_srvc_id_t *psrvc_id, int srvc_handle)
1104 BT_INFO("BTGATT SERVER SERVICE ADDED CB, status:%d, handle:%d", status, srvc_handle);
1105 event_gatts_srvc_prm_t* event = g_new0(event_gatts_srvc_prm_t, 1);
1107 CHECK_CORRECT_SERVER_ID(instance_id, server_if, event->gatt_srvc_stat.server_inst);
1109 BT_ERR("Invalid Interface, srv_if: %d", server_if);
1110 event->gatt_srvc_stat.server_inst = -1;
1112 event->gatt_srvc_stat.servic_hndl = srvc_handle;
1113 if (psrvc_id != NULL) {
1114 event->gatt_srvc_id.id.inst_id = psrvc_id->id.inst_id;
1115 //event->gatt_srvc_id.id.uuid = psrvc_id->id.uuid;
1116 memcpy(event->gatt_srvc_id.id.uuid.uuid, psrvc_id->id.uuid.uu, sizeof(psrvc_id->id.uuid));
1117 event->gatt_srvc_id.is_prmry = psrvc_id->is_primary;
1120 event->gatt_srvc_stat.status = convert_to_oal_status(status);
1122 send_event(OAL_EVENT_GATTS_SERVICE_ADDED, event, sizeof(event_gatts_srvc_prm_t));
1125 static void cb_gatts_included_service_added(int status, int server_if,
1127 int incl_srvc_handle)
1130 BT_INFO("BTGATT SERVER INCLUDED SERVICE ADDED CB, status:%d, srvc handle:%d, incl handle:%d",
1131 status, srvc_handle, incl_srvc_handle);
1133 event_gatts_incld_srvc_t* event = g_new0(event_gatts_incld_srvc_t, 1);
1135 CHECK_CORRECT_SERVER_ID(ins_id, server_if, event->gatt_srvc_stat.server_inst);
1137 BT_ERR("Invalid Interface, srv_if: %d", server_if);
1138 event->gatt_srvc_stat.server_inst = -1;
1140 event->gatt_srvc_stat.servic_hndl = srvc_handle;
1141 event->incl_srvc_hndl = incl_srvc_handle;
1142 event->gatt_srvc_stat.status = convert_to_oal_status(status);
1143 send_event(OAL_EVENT_GATTS_INCLUDED_SERVICE_ADDED, event, sizeof(event_gatts_incld_srvc_t));
1146 static void cb_gatts_characteristic_added(int status, int server_if, bt_uuid_t *char_id,
1147 int srvc_handle, int char_handle)
1151 BT_INFO("BTGATT SERVER CHARACTERISTIC ADDED CB, status:%d, srvc handle:%d, char handle:%d",
1152 status, srvc_handle, char_handle);
1154 event_gatts_srvc_charctr_t* event = g_new0(event_gatts_srvc_charctr_t, 1);
1156 CHECK_CORRECT_SERVER_ID(Ins_id, server_if, event->gatt_srvc_stat.server_inst);
1158 BT_ERR("Invalid Interface, srv_if: %d", server_if);
1159 event->gatt_srvc_stat.server_inst = -1;
1161 event->gatt_srvc_stat.servic_hndl = srvc_handle;
1162 event->charctr_hndl = char_handle;
1163 event->gatt_srvc_stat.status = convert_to_oal_status(status);
1164 memcpy(event->charctr_uuid.uuid, char_id->uu, sizeof(bt_uuid_t));
1165 send_event(OAL_EVENT_GATTS_CHARACTERISTIC_ADDED, event, sizeof(event_gatts_srvc_charctr_t));
1168 static void cb_gatts_descriptor_added(int status, int server_if,
1169 bt_uuid_t *descr_id, int srvc_handle,
1173 BT_INFO("BTGATT SERVER DESCRIPTOR ADDED CB, status:%d, srvc handle:%d, desc handle:%d",
1174 status, srvc_handle, descr_handle);
1176 event_gatts_srvc_descr_t* event = g_new0(event_gatts_srvc_descr_t, 1);
1178 CHECK_CORRECT_SERVER_ID(Ins_id, server_if, event->gatt_srvc_stat.server_inst);
1180 BT_ERR("Invalid Interface, srv_if: %d", server_if);
1181 event->gatt_srvc_stat.server_inst = -1;
1183 event->gatt_srvc_stat.servic_hndl = srvc_handle;
1184 event->descrptr_hndl = descr_handle;
1185 event->gatt_srvc_stat.status = convert_to_oal_status(status);
1186 memcpy(event->descrptr_uuid.uuid, descr_id->uu, sizeof(bt_uuid_t));
1187 send_event(OAL_EVENT_GATTS_DESCRIPTOR_ADDED, event, sizeof(event_gatts_srvc_descr_t));
1190 static void cb_gatts_service_started(int status, int server_if, int srvc_handle)
1193 BT_INFO("BTGATT SERVER SERVICE STARTED CB, status:%d, srvc_handle:%d", status, srvc_handle);
1195 event_gatts_srvc_t* event = g_new0(event_gatts_srvc_t, 1);
1197 CHECK_CORRECT_SERVER_ID(Ins_id, server_if, event->server_inst);
1199 BT_ERR("Invalid Interface, srv_if: %d", server_if);
1200 event->server_inst = -1;
1202 event->servic_hndl = srvc_handle;
1203 event->status = convert_to_oal_status(status);
1204 send_event(OAL_EVENT_GATTS_SERVICE_STARTED, event, sizeof(event_gatts_srvc_t));
1207 static void cb_gatts_service_stopped(int status, int server_if, int srvc_handle)
1210 BT_INFO("BTGATT SERVER SERVICE STOPPED CB, status:%d, srvc_handle:%d", status, srvc_handle);
1212 event_gatts_srvc_t* event = g_new0(event_gatts_srvc_t, 1);
1214 CHECK_CORRECT_SERVER_ID(ins_id, server_if, event->server_inst);
1216 BT_ERR("Invalid Interface, srv_if: %d", server_if);
1217 event->server_inst = -1;
1219 event->servic_hndl = srvc_handle;
1220 event->status = convert_to_oal_status(status);
1221 send_event(OAL_EVENT_GATTS_SERVICE_STOPED, event, sizeof(event_gatts_srvc_t));
1224 static void cb_gatts_service_deleted(int status, int server_if, int srvc_handle)
1227 BT_INFO("BTGATT SERVER SERVICE DELETED CB, status:%d, srvc_handle:%d", status, srvc_handle);
1229 event_gatts_srvc_t* event = g_new0(event_gatts_srvc_t, 1);
1231 CHECK_CORRECT_SERVER_ID(ins_id, server_if, event->server_inst);
1233 BT_ERR("Invalid Interface, srv_if: %d", server_if);
1234 event->server_inst = -1;
1236 event->servic_hndl = srvc_handle;
1237 event->status = convert_to_oal_status(status);
1238 send_event(OAL_EVENT_GATTS_SERVICE_DELETED, event, sizeof(event_gatts_srvc_t));
1241 static void cb_gatts_connection(int conn_id, int server_if, int connected, bt_bdaddr_t *bda)
1244 oal_event_t event_type;
1246 BT_INFO("BTGATT SERVER CONNECTION connnected:%d, conn_id:%d server_if:%d", connected, conn_id, server_if);
1247 event_gatts_conn_t *event = g_new0(event_gatts_conn_t, 1);
1249 for (ins_id = 1 ; ins_id <= NUM_SERVER_INST ; ins_id++) {
1250 if ((gatt_servers[ins_id - 1].server_id == server_if)) {
1251 event->server_inst = ins_id;
1254 BT_INFO("Server ID:%d recevied server Id:%d\n", gatt_servers[ins_id - 1].server_id, server_if);
1257 if (ins_id == NUM_SERVER_INST+1) {
1258 BT_WARN("Incorrect Server Interface received: %d\n", server_if);
1262 memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1263 event->conn_id = conn_id;
1264 event_type = ((connected == TRUE) ? OAL_EVENT_GATTS_CONNECTION_COMPLETED : OAL_EVENT_GATTS_DISCONNECTION_COMPLETED);
1265 event->status = OAL_STATUS_SUCCESS;
1267 send_event(event_type, event, sizeof(event_gatts_conn_t));
1270 static void cb_gatts_request_read(int conn_id, int trans_id, bt_bdaddr_t *bda,
1271 int attr_handle, int offset, bool is_long)
1273 BT_INFO("BTGATT SERVER REQUEST READ CB: conn_id:%d", conn_id);
1275 event_gatts_srvc_read_attr_t* event = g_new0(event_gatts_srvc_read_attr_t, 1);
1277 memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1279 event->attr_trans.attr_handle = attr_handle;
1280 event->attr_trans.conn_id = conn_id;
1281 event->attr_trans.trans_id = trans_id;
1282 event->attr_trans.offset = offset;
1283 event->is_long = is_long;
1285 send_event(OAL_EVENT_GATTS_REQUEST_READ, event, sizeof(event_gatts_srvc_read_attr_t));
1288 static void cb_gatts_request_write(int conn_id, int trans_id,
1289 bt_bdaddr_t *bda, int attr_handle,
1290 int offset, int length,
1291 bool need_rsp, bool is_prep, uint8_t* value)
1293 BT_INFO("BTGATT SERVER REQUEST WRITE conn_id:%d", conn_id);
1295 event_gatts_srvc_write_attr_t* event = g_new0(event_gatts_srvc_write_attr_t, 1);
1297 memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1299 event->attr_trans.attr_handle = attr_handle;
1300 event->attr_trans.conn_id = conn_id;
1301 event->attr_trans.trans_id = trans_id;
1302 event->attr_trans.offset = offset;
1303 event->need_rsp = need_rsp;
1304 event->is_prep = is_prep;
1306 if (length > 0 && value != NULL) {
1307 if (length > OAL_GATT_MAX_ATTR_LEN)
1308 length = OAL_GATT_MAX_ATTR_LEN;
1309 memcpy(event->value, value, length);
1310 event->length = length;
1312 send_event(OAL_EVENT_GATTS_REQUEST_WRITE, event, sizeof(event_gatts_srvc_write_attr_t));
1315 static void cb_gatts_acquire_write(int mtu, int conn_id, int trans_id, int attr_handle , bt_bdaddr_t *bda)
1318 BT_INFO("BTGATT SERVER REQUEST ACQUIRE WRITE conn_id:%d", conn_id);
1320 event_gatts_srvc_acquire_attr_t* event = g_new0(event_gatts_srvc_acquire_attr_t, 1);
1322 event->attr_trans.attr_handle = attr_handle;
1323 event->attr_trans.conn_id = conn_id;
1324 event->attr_trans.trans_id = trans_id;
1326 memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1328 send_event(OAL_EVENT_GATTS_REQUEST_ACQUIRE_WRITE, event, sizeof(event_gatts_srvc_acquire_attr_t));
1331 static void cb_gatts_acquire_notify(int mtu, int conn_id, int trans_id, int attr_handle)
1333 BT_INFO("BTGATT SERVER REQUEST ACQUIRE NOTIFY conn_id:%d", conn_id);
1335 event_gatts_srvc_acquire_attr_t* event = g_new0(event_gatts_srvc_acquire_attr_t, 1);
1337 event->attr_trans.attr_handle = attr_handle;
1338 event->attr_trans.conn_id = conn_id;
1339 event->attr_trans.trans_id = trans_id;
1342 send_event(OAL_EVENT_GATTS_REQUEST_ACQUIRE_NOTIFY, event, sizeof(event_gatts_srvc_acquire_attr_t));
1346 static void cb_gatts_response_confirmation(int status, int handle)
1348 BT_INFO("BTGATT SERVER RESPONSE CONFIRMATION CB, status:%d, handle:%d", status, handle);
1350 event_gatts_respons_t* event = g_new0(event_gatts_respons_t, 1);
1352 event->hndl = handle;
1353 event->status = convert_to_oal_status(status);
1355 send_event(OAL_EVENT_GATTS_RESPONSE_CONFIRMED, event, sizeof(event_gatts_respons_t));
1358 static void cb_indication_confirmation(int conn_id, int trans_id, int attr_handle, bt_bdaddr_t *bda)
1360 BT_INFO("BTGATT SERVER Indication Confirmation CB, conn_id:%d, trans_id:%d attr_handle:%d",
1361 conn_id, trans_id, attr_handle);
1363 event_gatts_ind_cnfrm_t* event = g_new0(event_gatts_ind_cnfrm_t, 1);
1365 memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1367 event->attr_handle = attr_handle;
1368 event->conn_id = conn_id;
1369 event->trans_id = trans_id;
1370 send_event(OAL_EVENT_GATTS_IND_CONFIRM, event, sizeof(event_gatts_ind_cnfrm_t));
1373 static void cb_gatts_mtu_changed(int conn_id, int mtu)
1375 BT_INFO("BTGATT SERVER MTU CHANGED CB, conn_id: %d, mtu_size: %d", conn_id, mtu);
1376 event_gatts_mtu_changed_t *event = g_new0(event_gatts_mtu_changed_t, 1);
1377 event->conn_id = conn_id;
1378 event->mtu_size = mtu;
1379 send_event(OAL_EVENT_GATTS_MTU_CHANGED, event, sizeof(event_gatts_mtu_changed_t));
1383 static void cb_notifcation_changed(int conn_id, int trans_id, int attr_handle, bool notify, bt_bdaddr_t *bda)
1385 BT_INFO("BTGATT SERVER Notication CB, conn_id:%d, trans_id:%d attr_handle:%d Notify:%d",
1386 conn_id, trans_id, attr_handle, notify);
1388 event_gatts_notif_t* event = g_new0(event_gatts_notif_t, 1);
1390 memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1392 event->attr_handle = attr_handle;
1393 event->conn_id = conn_id;
1394 event->trans_id = trans_id;
1395 event->notify = notify;
1396 send_event(OAL_EVENT_GATTS_NOTIFICATION, event, sizeof(event_gatts_notif_t));
1401 /* GATT Server Callbacks: End */
1402 /************************************ GATT Client ***********************************/
1403 /* Client Callbacks */
1404 static void cb_gattc_register_app(int status, int clientIf, bt_uuid_t *app_uuid)
1406 char uuid_str[BT_UUID_STRING_MAX];
1407 event_gattc_register_t *event;
1411 /* Check if GATT client registered for Default GATT client UUID */
1412 uuid_to_string((service_uuid_t *)app_uuid, uuid_str);
1413 BT_INFO("UUID:%s", uuid_str);
1415 BT_INFO("BTGATT CLIENT REGISTER APP CB, status:%d, clientIf:%d", status, clientIf);
1416 event = g_new0(event_gattc_register_t, 1);
1417 event->client_if = clientIf;
1418 event->status = (status == 0 ? OAL_STATUS_SUCCESS : OAL_STATUS_INTERNAL_ERROR);
1419 memcpy(event->client_uuid.uuid, app_uuid->uu, sizeof(oal_uuid_t));
1420 send_event(OAL_EVENT_GATTC_REGISTRATION, event, sizeof(event_gattc_register_t));
1423 static void cb_gattc_scan_result(bt_bdaddr_t* bdaddress, int rssi, uint8_t *adv_data)
1425 event_ble_scan_result_info *event;
1427 event = g_new0(event_ble_scan_result_info, 1);
1429 memcpy(event->address.addr, bdaddress->address, BT_ADDRESS_BYTES_NUM);
1430 memcpy(event->adv_data, adv_data, BLE_ADV_DATA_LENGTH);
1431 send_event_bda_trace(OAL_EVENT_BLE_REMOTE_DEVICE_FOUND, event,
1432 sizeof(event_ble_scan_result_info), (bt_address_t *)bdaddress);
1435 static void cb_gattc_connection(int conn_id, int status, int client_if, bt_bdaddr_t* bda)
1437 event_gattc_conn_t *event;
1438 BT_INFO("BTGATT CLIENT CONNECTED CB, status:[%d] client_if[%d] id[%d]",
1439 status, client_if, conn_id);
1441 event = g_new0(event_gattc_conn_t, 1);
1442 memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1443 event->client_if = client_if;
1445 if (BT_STATUS_SUCCESS != status) {
1446 event->status = OAL_STATUS_INTERNAL_ERROR;
1447 BT_ERR("gattc connection Error: %d", status);
1449 event->conn_id = conn_id;
1450 event->status = OAL_STATUS_SUCCESS;
1453 send_event_bda_trace(OAL_EVENT_GATTC_CONNECTION_COMPLETED, event,
1454 sizeof(*event), (bt_address_t *)bda);
1458 static void cb_gattc_disconnect(int conn_id, int status, int client_if, bt_bdaddr_t* bda)
1460 event_gattc_conn_t *event;
1461 BT_INFO("BTGATT Client Disconnect Complete cb, status:[%d], client_if[%d] id[%d]",
1462 status, client_if, conn_id);
1463 event = g_new0(event_gattc_conn_t, 1);
1464 event->status = convert_to_oal_status(status);
1465 event->client_if = client_if;
1466 event->conn_id = conn_id;
1467 memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1468 send_event_bda_trace(OAL_EVENT_GATTC_DISCONNECTION_COMPLETED, event,
1469 sizeof(*event), (bt_address_t *)bda);
1472 static void cb_gattc_search_result(int conn_id, btgatt_srvc_id_t *srvc_id)
1474 char uuid_str[2*BT_UUID_STRING_MAX];
1476 BT_INFO("BTGATT Client Service Search Result cb, conn_id:%d", conn_id);
1478 uuid_to_stringname((oal_uuid_t *)&(srvc_id->id.uuid), uuid_str);
1479 BT_INFO("Service=> UUID: [%s], Inst_id: [%u], Type: [%s]",
1480 uuid_str, srvc_id->id.inst_id, srvc_id->is_primary ? "Primary" : "Secondary");
1482 event_gattc_service_result_t *event = g_new0(event_gattc_service_result_t, 1);
1483 event->conn_status.status = OAL_STATUS_SUCCESS;
1484 event->conn_status.conn_id = conn_id;
1485 memcpy(&(event->srvc_id), srvc_id, sizeof(oal_gatt_srvc_id_t));
1487 send_event(OAL_EVENT_GATTC_SERVICE_SEARCH_RESULT, event, sizeof(*event));
1490 static void cb_gattc_search_complete(int conn_id, int status)
1492 BT_INFO("BTGATT Client Service Search Complete cb, status:%d, conn_id:%d",
1495 event_gattc_conn_status_t *event = g_new0(event_gattc_conn_status_t, 1);
1496 event->conn_id = conn_id;
1497 event->status = convert_to_oal_status(status);
1499 send_event(OAL_EVENT_GATTC_SERVICE_SEARCH_DONE, event, sizeof(*event));
1503 static void cb_gattc_get_characteristics(int conn_id, int status, btgatt_srvc_id_t *srvc_id,
1504 btgatt_gatt_id_t *char_id, int char_prop)
1506 char uuid_str1[2*BT_UUID_STRING_MAX];
1507 char uuid_str2[2*BT_UUID_STRING_MAX];
1509 BT_INFO("BTGATT Client Get Characteristic Callback, conn_id:%d, status:%d", conn_id, status);
1510 uuid_to_stringname((oal_uuid_t *)&(srvc_id->id.uuid), uuid_str1);
1511 BT_INFO("Service=> UUID: [%s], Inst_id: [%u], Type: [%s]",
1512 uuid_str1, srvc_id->id.inst_id, srvc_id->is_primary ? "Primary" : "Secondary");
1514 event_gattc_characteristic_result_t *event = g_new0(event_gattc_characteristic_result_t, 1);
1515 event->conn_status.conn_id = conn_id;
1516 event->conn_status.status = convert_to_oal_status(status);
1517 memcpy(&(event->srvc_id), srvc_id, sizeof(oal_gatt_srvc_id_t));
1520 uuid_to_stringname((oal_uuid_t *)&(char_id->uuid), uuid_str2);
1521 BT_INFO("Charac=> UUID: [%s], Inst_id: [%u], Prop: [%s]",
1522 uuid_str2, char_id->inst_id, char_prop_to_string(char_prop, str));
1523 event->char_prop = char_prop;
1524 memcpy(&(event->char_id), char_id, sizeof(oal_gatt_id_t));
1526 send_event(OAL_EVENT_GATTC_CHARAC_SERACH_RESULT, event, sizeof(*event));
1531 static void cb_gattc_get_descriptor(int conn_id, int status, btgatt_srvc_id_t *srvc_id, btgatt_gatt_id_t *char_id, btgatt_gatt_id_t *descr_id)
1533 char uuid_str1[2*BT_UUID_STRING_MAX];
1534 char uuid_str2[2*BT_UUID_STRING_MAX];
1535 char uuid_str3[2*BT_UUID_STRING_MAX];
1536 BT_INFO("BTGATT Client Get Descriptor Callback, conn_id:%d, status:%d", conn_id, status);
1537 uuid_to_stringname((oal_uuid_t *)&(srvc_id->id.uuid), uuid_str1);
1538 uuid_to_stringname((oal_uuid_t *)&(char_id->uuid), uuid_str2);
1539 BT_INFO("Service=> UUID: [%s], Inst_id: [%u], Type: [%s]",
1540 uuid_str1, srvc_id->id.inst_id, srvc_id->is_primary ? "Primary" : "Secondary");
1541 BT_INFO("Charac=> UUID: [%s], Inst_id: [%u]", uuid_str2, char_id->inst_id);
1543 event_gattc_descriptor_result_t *event = g_new0(event_gattc_descriptor_result_t, 1);
1544 event->conn_status.conn_id = conn_id;
1545 event->conn_status.status = convert_to_oal_status(status);
1546 memcpy(&(event->srvc_id), srvc_id, sizeof(oal_gatt_srvc_id_t));
1547 memcpy(&(event->char_id), char_id, sizeof(oal_gatt_id_t));
1550 uuid_to_stringname((oal_uuid_t *)&(descr_id->uuid), uuid_str3);
1551 BT_INFO("Desc=> UUID: [%s], Inst_id: [%u]", uuid_str3, descr_id->inst_id);
1552 memcpy(&(event->descr_id), descr_id, sizeof(oal_gatt_id_t));
1554 send_event(OAL_EVENT_GATTC_DESC_SERACH_RESULT, event, sizeof(*event));
1557 static void cb_gattc_register_for_notification(int client_if, int registered, int status, btgatt_srvc_id_t *srvc_id, btgatt_gatt_id_t *char_id)
1559 char uuid_str1[2*BT_UUID_STRING_MAX];
1560 char uuid_str2[2*BT_UUID_STRING_MAX];
1561 BT_INFO("BTGATT Client Register For Notification Callback, client_if:%d, status:%d, registered: %s",
1562 client_if, status, registered == 1 ? "REGISTERED" : "DEREGISTERED");
1563 uuid_to_stringname((oal_uuid_t *)&(srvc_id->id.uuid), uuid_str1);
1564 uuid_to_stringname((oal_uuid_t *)&(char_id->uuid), uuid_str2);
1565 BT_INFO("Service=> UUID: [%s], Inst_id: [%u], Type: [%s]", uuid_str1, srvc_id->id.inst_id, srvc_id->is_primary ? "Primary" : "Secondary");
1566 BT_INFO("Charac=> UUID: [%s], Inst_id: [%u]", uuid_str2, char_id->inst_id);
1568 event_gattc_regdereg_notify_t *event = g_new0(event_gattc_regdereg_notify_t, 1);
1569 oal_event_t event_type = (registered == 1 ? OAL_EVENT_GATTC_NOTIFICATION_REGISTERED : OAL_EVENT_GATTC_NOTIFICATION_DEREGISTERED);
1570 event->client_if = client_if;
1571 event->status = convert_to_oal_status(status);
1572 memcpy(&(event->srvc_id), srvc_id, sizeof(oal_gatt_srvc_id_t));
1573 memcpy(&(event->char_id), char_id, sizeof(oal_gatt_id_t));
1575 send_event(event_type, event, sizeof(*event));
1578 static void cb_gattc_notify(int conn_id, btgatt_notify_params_t *p_data)
1581 char uuid_str1[2*BT_UUID_STRING_MAX];
1582 char uuid_str2[2*BT_UUID_STRING_MAX];
1584 BT_INFO("BTGATT Client Notify Callback, conn_id:%d", conn_id);
1585 BT_INFO("Server Address:[%s], is_notify:[%d], len:[%d]",
1586 bdt_bd2str((bt_address_t *)&(p_data->bda), &bdstr), p_data->is_notify, p_data->len);
1588 uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
1589 uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
1591 BT_INFO("Service=> UUID: [%s], Inst_id: [%u], Type: [%s]",
1592 uuid_str1, p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
1593 BT_INFO("Charac=> UUID: [%s], Inst_id: [%u]", uuid_str2, p_data->char_id.inst_id);
1595 if (p_data->len > 0) {
1597 data = g_malloc(3*p_data->len+1);
1599 BT_ERR("memory allocation failed");
1603 convert_hex_2_str((unsigned char *)p_data->value, p_data->len, data);
1604 BT_INFO("Notified Data: [%s]", data);
1606 event_gattc_notify_data *event = g_new0(event_gattc_notify_data, 1);
1607 memcpy(event->address.addr, p_data->bda.address, BT_ADDRESS_BYTES_NUM);
1608 event->is_notify = p_data->is_notify;
1609 event->data_len = p_data->len;
1610 memcpy(event->data, p_data->value, event->data_len);
1611 memcpy(&(event->char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
1612 memcpy(&(event->srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
1614 send_event_bda_trace(OAL_EVENT_GATTC_NOTIFY_DATA, event, sizeof(*event), (bt_address_t *)&p_data->bda);
1620 static void cb_gattc_read_characteristic(int conn_id, int status, btgatt_read_params_t *p_data)
1622 char uuid_str1[2*BT_UUID_STRING_MAX];
1623 char uuid_str2[2*BT_UUID_STRING_MAX];
1624 BT_INFO("BTGATT Client Read Charcateristic Callback, conn_id:%d, read_status:%d", conn_id, status);
1626 event_gattc_read_data *event = g_new0(event_gattc_read_data, 1);
1627 event->uuid_status.conn_status.conn_id = conn_id;
1628 event->uuid_status.conn_status.status = convert_to_oal_status(status);
1629 event->value_type = p_data->value_type;
1630 memcpy(&(event->uuid_status.srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
1631 memcpy(&(event->uuid_status.char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
1633 uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
1634 uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
1635 BT_INFO("Service=> UUID: [%s], Inst_id: [%u], Type: [%s]", uuid_str1,
1636 p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
1637 BT_INFO("Charac=> UUID: [%s], Inst_id: [%u]", uuid_str2, p_data->char_id.inst_id);
1638 BT_INFO("Len: %u, value_type: %u", p_data->value.len, p_data->value_type);
1639 if (p_data->value.len > 0 && event->value_type == GATTC_READ_VALUE_TYPE_VALUE) {
1641 data = g_malloc(3*p_data->value.len+1);
1643 BT_ERR("memory allocation failed");
1647 convert_hex_2_str((unsigned char *)p_data->value.value, p_data->value.len, data);
1648 BT_INFO("Read Data: [%s]", data);
1649 event->data_len = p_data->value.len;
1650 memcpy(&(event->data), &(p_data->value.value), event->data_len);
1654 send_event(OAL_EVENT_GATTC_READ_CHARAC, event, sizeof(*event));
1657 static void cb_gattc_write_characteristic(int conn_id, int status, btgatt_write_params_t *p_data)
1659 char uuid_str1[2*BT_UUID_STRING_MAX];
1660 char uuid_str2[2*BT_UUID_STRING_MAX];
1661 BT_INFO("BTGATT Client Write Charcateristic Callback, conn_id:%d, write_status:%d", conn_id, status);
1663 event_gattc_write_data *event = g_new0(event_gattc_write_data, 1);
1664 event->conn_status.conn_id = conn_id;
1665 event->conn_status.status = convert_to_oal_status(status);
1666 memcpy(&(event->srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
1667 memcpy(&(event->char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
1669 uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
1670 uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
1671 BT_INFO("Service=> UUID: [%s], Inst_id: [%u], Type: [%s]", uuid_str1,
1672 p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
1673 BT_INFO("Charac=> UUID: [%s], Inst_id: [%u]", uuid_str2, p_data->char_id.inst_id);
1675 send_event(OAL_EVENT_GATTC_WRITE_CHARAC, event, sizeof(*event));
1678 static void cb_gattc_write_descriptor(int conn_id, int status, btgatt_write_params_t *p_data)
1680 char uuid_str1[2*BT_UUID_STRING_MAX];
1681 char uuid_str2[2*BT_UUID_STRING_MAX];
1682 char uuid_str3[2*BT_UUID_STRING_MAX];
1683 BT_INFO("BTGATT Client Write Descriptor Callback, conn_id:%d, write_status:%d", conn_id, status);
1685 event_gattc_write_data *event = g_new0(event_gattc_write_data, 1);
1686 event->conn_status.conn_id = conn_id;
1687 event->conn_status.status = convert_to_oal_status(status);
1688 memcpy(&(event->srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
1689 memcpy(&(event->char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
1690 memcpy(&(event->descr_id), &(p_data->descr_id), sizeof(oal_gatt_id_t));
1692 uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
1693 uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
1694 uuid_to_stringname((oal_uuid_t *)&(p_data->descr_id.uuid), uuid_str3);
1695 BT_INFO("Service=> UUID: [%s], Inst_id: [%u], Type: [%s]", uuid_str1,
1696 p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
1697 BT_INFO("Charac=> UUID: [%s], Inst_id: [%u]", uuid_str2, p_data->char_id.inst_id);
1698 BT_INFO("Desc=> UUID: [%s], Inst_id: [%u]", uuid_str3, p_data->descr_id.inst_id);
1700 send_event(OAL_EVENT_GATTC_WRITE_DESCR, event, sizeof(*event));
1705 static void cb_gattc_read_descriptor(int conn_id, int status, btgatt_read_params_t *p_data)
1707 char uuid_str1[2*BT_UUID_STRING_MAX];
1708 char uuid_str2[2*BT_UUID_STRING_MAX];
1709 char uuid_str3[2*BT_UUID_STRING_MAX];
1710 BT_INFO("BTGATT Client Read Descriptor Callback, conn_id:%d, read_status:%d", conn_id, status);
1712 event_gattc_read_data *event = g_new0(event_gattc_read_data, 1);
1713 event->uuid_status.conn_status.conn_id = conn_id;
1714 event->uuid_status.conn_status.status = convert_to_oal_status(status);
1715 event->value_type = p_data->value_type;
1716 memcpy(&(event->uuid_status.srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
1717 memcpy(&(event->uuid_status.char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
1718 memcpy(&(event->uuid_status.descr_id), &(p_data->descr_id), sizeof(oal_gatt_id_t));
1721 uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
1722 uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
1723 uuid_to_stringname((oal_uuid_t *)&(p_data->descr_id.uuid), uuid_str3);
1724 BT_INFO("Service=> UUID: [%s], Inst_id: [%u], Type: [%s]", uuid_str1,
1725 p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
1726 BT_INFO("Charac=> UUID: [%s], Inst_id: [%u]", uuid_str2, p_data->char_id.inst_id);
1727 BT_INFO("Desc=> UUID: [%s], Inst_id: [%u]", uuid_str3, p_data->descr_id.inst_id);
1728 BT_INFO("Len: %u, value_type: %u", p_data->value.len, p_data->value_type);
1729 if (p_data->value.len > 0 && event->value_type == GATTC_READ_VALUE_TYPE_VALUE) {
1731 data = g_malloc(3*p_data->value.len+1);
1733 BT_ERR("memory allocation failed");
1737 convert_hex_2_str((unsigned char *)p_data->value.value, p_data->value.len, data);
1738 BT_INFO("Read Data: [%s]", data);
1739 event->data_len = p_data->value.len;
1740 memcpy(&(event->data), &(p_data->value.value), event->data_len);
1744 send_event(OAL_EVENT_GATTC_READ_DESCR, event, sizeof(*event));
1747 oal_status_t gattc_start_le_discovery(int client_id)
1750 int ret = OAL_STATUS_SUCCESS;
1752 API_TRACE("BTGATT CLIENT SCAN START");
1753 CHECK_OAL_GATT_ENABLED();
1754 CHECK_CLIENT_REGISTRATION(client_id);
1756 ret = gatt_api->client->scan(client_id, 1);
1757 if (ret != BT_STATUS_SUCCESS) {
1758 BT_ERR("Error:Start LE Discovery failed: %s", status2string(ret));
1759 return convert_to_oal_status(ret);
1761 return OAL_STATUS_SUCCESS;
1764 oal_status_t gattc_stop_le_discovery(int client_id)
1767 int ret = OAL_STATUS_SUCCESS;
1769 API_TRACE("Scan is stopped");
1770 CHECK_OAL_GATT_ENABLED();
1771 CHECK_CLIENT_REGISTRATION(client_id);
1772 ret = gatt_api->client->scan(client_id, 0);
1773 if (ret != BT_STATUS_SUCCESS) {
1774 BT_ERR("Error:Stop LE Discovery failed: %s", status2string(ret));
1775 return convert_to_oal_status(ret);
1777 return OAL_STATUS_SUCCESS;
1780 oal_status_t gattc_set_le_scan_param(int scan_type, int itv, int win)
1784 API_TRACE("Scan is stopped");
1785 CHECK_OAL_GATT_ENABLED();
1788 ret = gatt_api->client->set_scan_parameters(scan_type, itv, win);
1789 if (ret != BT_STATUS_SUCCESS) {
1790 BT_ERR("Error:Set scan parameters failed: %s", status2string(ret));
1791 return convert_to_oal_status(ret);
1794 ret = gatt_api->client->set_scan_parameters(itv, win);
1795 if (ret != BT_STATUS_SUCCESS) {
1796 BT_ERR("Error:Set scan parameters failed: %s", status2string(ret));
1797 return convert_to_oal_status(ret);
1801 return OAL_STATUS_SUCCESS;
1803 /************************************ GATT Client ***********************************/
1804 oal_status_t gattc_register(oal_uuid_t* client_uuid)
1807 char str[2*BT_UUID_STRING_MAX];
1808 int ret = OAL_STATUS_SUCCESS;
1810 CHECK_OAL_GATT_ENABLED();
1811 uuid_to_stringname(client_uuid, str);
1812 API_TRACE("uuid: [%s]", str);
1813 /* We will perform actual registration in cb_gattc_register_app callback */
1814 ret = gatt_api->client->register_client((bt_uuid_t *)client_uuid);
1815 if (ret != BT_STATUS_SUCCESS) {
1816 BT_ERR("GATT client register failed: %s", status2string(ret));
1817 return convert_to_oal_status(ret);
1819 return OAL_STATUS_SUCCESS;
1822 oal_status_t gattc_deregister(int client_id)
1824 int ret = OAL_STATUS_SUCCESS;
1826 API_TRACE("GATT client deregister");
1827 CHECK_OAL_GATT_ENABLED();
1828 CHECK_CLIENT_REGISTRATION(client_id);
1830 ret = gatt_api->client->unregister_client(client_id);
1831 if (ret != BT_STATUS_SUCCESS) {
1832 BT_ERR("GATT client deregister failed: %s", status2string(ret));
1833 return convert_to_oal_status(ret);
1836 return OAL_STATUS_SUCCESS;
1839 oal_status_t gattc_connect(int client_id, bt_address_t *device_address, int isDirect)
1841 int ret = OAL_STATUS_SUCCESS;
1844 OAL_CHECK_PARAMETER(device_address, return);
1845 API_TRACE("Client Connect: [%s]", bdt_bd2str(device_address, &bdstr));
1846 CHECK_OAL_GATT_ENABLED();
1847 CHECK_CLIENT_REGISTRATION(client_id);
1849 /* Handle the actual connection in cb_gattc_connection callback */
1850 ret = gatt_api->client->connect(client_id, (bt_bdaddr_t *)device_address, isDirect);
1851 if (ret != BT_STATUS_SUCCESS) {
1852 BT_ERR("GATT client connect failed: %s", status2string(ret));
1853 return convert_to_oal_status(ret);
1855 return OAL_STATUS_SUCCESS;
1858 oal_status_t gattc_disconnect(int client_id, bt_address_t *device_address, int conn_id)
1861 int ret = OAL_STATUS_SUCCESS;
1864 OAL_CHECK_PARAMETER(device_address, return);
1865 API_TRACE("Client Disconnect: [%s]", bdt_bd2str(device_address, &bdstr));
1866 CHECK_OAL_GATT_ENABLED();
1867 CHECK_CLIENT_REGISTRATION(client_id);
1868 CHECK_CLIENT_CONNECTION(conn_id);
1870 /* Handle actual disconnection in callback */
1871 ret = gatt_api->client->disconnect(client_id, (bt_bdaddr_t *) device_address, conn_id);
1872 if (ret != BT_STATUS_SUCCESS) {
1873 BT_ERR("GATT client disconnect failed: %s", status2string(ret));
1874 return convert_to_oal_status(ret);
1876 return OAL_STATUS_SUCCESS;
1880 oal_status_t gattc_search_service(int conn_id, oal_uuid_t *service_uuid)
1882 int ret = OAL_STATUS_SUCCESS;
1883 char uuid_str[2*BT_UUID_STRING_MAX];
1886 uuid_to_stringname(service_uuid, uuid_str);
1887 API_TRACE("Client Service Search UUID: [%s]", uuid_str);
1889 API_TRACE("Client Service Search All");
1891 CHECK_OAL_GATT_ENABLED();
1892 CHECK_CLIENT_CONNECTION(conn_id);
1893 ret = gatt_api->client->search_service(conn_id, (bt_uuid_t *)service_uuid);
1895 if (ret != BT_STATUS_SUCCESS) {
1896 BT_ERR("GATT client service search failed: %s", status2string(ret));
1897 return convert_to_oal_status(ret);
1899 return OAL_STATUS_SUCCESS;
1902 oal_status_t gattc_get_characteristic(int conn_id, oal_gatt_srvc_id_t *srvc_id, oal_gatt_id_t *char_id)
1904 int ret = OAL_STATUS_SUCCESS;
1905 char uuid_str[2*BT_UUID_STRING_MAX];
1907 OAL_CHECK_PARAMETER(srvc_id, return);
1908 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str);
1909 API_TRACE("Client Get Characteristic, Service_uuid: [%s]", uuid_str);
1910 CHECK_OAL_GATT_ENABLED();
1911 CHECK_CLIENT_CONNECTION(conn_id);
1912 ret = gatt_api->client->get_characteristic(conn_id, (btgatt_srvc_id_t *)srvc_id,
1913 (btgatt_gatt_id_t *)char_id);
1914 if (ret != BT_STATUS_SUCCESS) {
1915 BT_ERR("GATT client get characteristic failed: %s", status2string(ret));
1916 return convert_to_oal_status(ret);
1918 return OAL_STATUS_SUCCESS;
1921 oal_status_t gattc_get_descriptor(int conn_id, oal_gatt_srvc_id_t *srvc_id,
1922 oal_gatt_id_t *char_id, oal_gatt_id_t *desc_id)
1924 int ret = OAL_STATUS_SUCCESS;
1925 char uuid_str1[2*BT_UUID_STRING_MAX];
1926 char uuid_str2[2*BT_UUID_STRING_MAX];
1928 OAL_CHECK_PARAMETER(srvc_id, return);
1929 OAL_CHECK_PARAMETER(char_id, return);
1930 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
1931 uuid_to_stringname(&(char_id->uuid), uuid_str2);
1932 API_TRACE("Client Get Descriptor, Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
1933 CHECK_OAL_GATT_ENABLED();
1934 CHECK_CLIENT_CONNECTION(conn_id);
1935 ret = gatt_api->client->get_descriptor(conn_id, (btgatt_srvc_id_t *)srvc_id,
1936 (btgatt_gatt_id_t *)char_id, (btgatt_gatt_id_t *)desc_id);
1937 if (ret != BT_STATUS_SUCCESS) {
1938 BT_ERR("GATT client get descriptor failed: %s", status2string(ret));
1939 return convert_to_oal_status(ret);
1941 return OAL_STATUS_SUCCESS;
1944 oal_status_t gattc_register_for_notification(int client_id, bt_address_t * address,
1945 oal_gatt_srvc_id_t *srvc_id, oal_gatt_id_t *char_id) {
1946 int ret = OAL_STATUS_SUCCESS;
1947 char uuid_str1[2*BT_UUID_STRING_MAX];
1948 char uuid_str2[2*BT_UUID_STRING_MAX];
1951 OAL_CHECK_PARAMETER(address, return);
1952 OAL_CHECK_PARAMETER(srvc_id, return);
1953 OAL_CHECK_PARAMETER(char_id, return);
1954 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
1955 uuid_to_stringname(&(char_id->uuid), uuid_str2);
1956 API_TRACE("Client Register Notification: [%s], Service_uuid: [%s], Char_uuid: [%s]", bdt_bd2str(address, &bdstr), uuid_str1, uuid_str2);
1957 CHECK_OAL_GATT_ENABLED();
1958 CHECK_CLIENT_REGISTRATION(client_id);
1960 ret = gatt_api->client->register_for_notification(client_id, (bt_bdaddr_t *)address, (btgatt_srvc_id_t *)srvc_id, (btgatt_gatt_id_t *)char_id);
1961 if (ret != BT_STATUS_SUCCESS) {
1962 BT_ERR("GATT client register notification failed: %s", status2string(ret));
1963 return convert_to_oal_status(ret);
1966 return OAL_STATUS_SUCCESS;
1969 oal_status_t gattc_deregister_for_notification(int client_id, bt_address_t * address,
1970 oal_gatt_srvc_id_t *srvc_id, oal_gatt_id_t *char_id) {
1971 int ret = OAL_STATUS_SUCCESS;
1972 char uuid_str1[2*BT_UUID_STRING_MAX];
1973 char uuid_str2[2*BT_UUID_STRING_MAX];
1976 OAL_CHECK_PARAMETER(address, return);
1977 OAL_CHECK_PARAMETER(srvc_id, return);
1978 OAL_CHECK_PARAMETER(char_id, return);
1979 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
1980 uuid_to_stringname(&(char_id->uuid), uuid_str2);
1981 API_TRACE("Client Deregister Notification: [%s], Service_uuid: [%s], Char_uuid: [%s]", bdt_bd2str(address, &bdstr), uuid_str1, uuid_str2);
1982 CHECK_OAL_GATT_ENABLED();
1983 CHECK_CLIENT_REGISTRATION(client_id);
1985 ret = gatt_api->client->deregister_for_notification(client_id, (bt_bdaddr_t *)address, (btgatt_srvc_id_t *)srvc_id, (btgatt_gatt_id_t *)char_id);
1986 if (ret != BT_STATUS_SUCCESS) {
1987 BT_ERR("GATT client deregister notification failed: %s", status2string(ret));
1988 return convert_to_oal_status(ret);
1991 return OAL_STATUS_SUCCESS;
1995 oal_status_t gattc_read_characteristic(int conn_id, oal_gatt_srvc_id_t *srvc_id,
1996 oal_gatt_id_t *char_id, oal_gatt_auth_req_t auth_req)
1998 int ret = OAL_STATUS_SUCCESS;
1999 char uuid_str1[2*BT_UUID_STRING_MAX];
2000 char uuid_str2[2*BT_UUID_STRING_MAX];
2002 OAL_CHECK_PARAMETER(srvc_id, return);
2003 OAL_CHECK_PARAMETER(char_id, return);
2004 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2005 uuid_to_stringname(&(char_id->uuid), uuid_str2);
2006 API_TRACE("Client Read Characteristic: Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
2007 CHECK_OAL_GATT_ENABLED();
2008 CHECK_CLIENT_CONNECTION(conn_id);
2010 ret = gatt_api->client->read_characteristic(conn_id, (btgatt_srvc_id_t *)srvc_id,
2011 (btgatt_gatt_id_t *)char_id, auth_req);
2012 if (ret != BT_STATUS_SUCCESS) {
2013 BT_ERR("GATT client read characteristic failed: %s", status2string(ret));
2014 return convert_to_oal_status(ret);
2017 return OAL_STATUS_SUCCESS;
2020 oal_status_t gattc_read_descriptor(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2021 oal_gatt_id_t *char_id, oal_gatt_id_t *desc_id, oal_gatt_auth_req_t auth_req)
2023 int ret = OAL_STATUS_SUCCESS;
2024 char uuid_str1[2*BT_UUID_STRING_MAX];
2025 char uuid_str2[2*BT_UUID_STRING_MAX];
2026 char uuid_str3[2*BT_UUID_STRING_MAX];
2028 OAL_CHECK_PARAMETER(srvc_id, return);
2029 OAL_CHECK_PARAMETER(char_id, return);
2030 OAL_CHECK_PARAMETER(desc_id, return);
2031 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2032 uuid_to_stringname(&(char_id->uuid), uuid_str2);
2033 uuid_to_stringname(&(desc_id->uuid), uuid_str3);
2034 API_TRACE("Client Read Descriptor: Service_uuid: [%s], Char_uuid: [%s], Desc_uuid: [%s]",
2035 uuid_str1, uuid_str2, uuid_str3);
2036 CHECK_OAL_GATT_ENABLED();
2037 CHECK_CLIENT_CONNECTION(conn_id);
2039 ret = gatt_api->client->read_descriptor(conn_id, (btgatt_srvc_id_t *)srvc_id,
2040 (btgatt_gatt_id_t *)char_id, (btgatt_gatt_id_t *)desc_id, auth_req);
2041 if (ret != BT_STATUS_SUCCESS) {
2042 BT_ERR("GATT client read descriptor failed: %s", status2string(ret));
2043 return convert_to_oal_status(ret);
2046 return OAL_STATUS_SUCCESS;
2049 oal_status_t gattc_acquire_notify(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2050 oal_gatt_id_t *char_id, int *fd, int *mtu)
2052 int ret = OAL_STATUS_SUCCESS;
2053 char uuid_str1[2*BT_UUID_STRING_MAX];
2054 char uuid_str2[2*BT_UUID_STRING_MAX];
2055 OAL_CHECK_PARAMETER(srvc_id, return);
2056 OAL_CHECK_PARAMETER(char_id, return);
2057 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2058 uuid_to_stringname(&(char_id->uuid), uuid_str2);
2059 API_TRACE("Client Write Characteristic: Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
2060 CHECK_OAL_GATT_ENABLED();
2061 CHECK_CLIENT_CONNECTION(conn_id);
2063 ret = gatt_api->client->acquire_notify(conn_id, (btgatt_srvc_id_t *)srvc_id,
2064 (btgatt_gatt_id_t *)char_id, fd, mtu);
2065 if (ret != BT_STATUS_SUCCESS) {
2066 BT_ERR("GATT client write characteristic failed: %s", status2string(ret));
2067 return convert_to_oal_status(ret);
2070 return OAL_STATUS_SUCCESS;
2073 oal_status_t gattc_acquire_write(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2074 oal_gatt_id_t *char_id, oal_gatt_auth_req_t auth_req , int *fd, int*mtu)
2076 int ret = OAL_STATUS_SUCCESS;
2077 char uuid_str1[2*BT_UUID_STRING_MAX];
2078 char uuid_str2[2*BT_UUID_STRING_MAX];
2079 OAL_CHECK_PARAMETER(srvc_id, return);
2080 OAL_CHECK_PARAMETER(char_id, return);
2081 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2082 uuid_to_stringname(&(char_id->uuid), uuid_str2);
2083 API_TRACE("Client Write Characteristic: Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
2084 CHECK_OAL_GATT_ENABLED();
2085 CHECK_CLIENT_CONNECTION(conn_id);
2087 ret = gatt_api->client->acquire_write(conn_id, (btgatt_srvc_id_t *)srvc_id,
2088 (btgatt_gatt_id_t *)char_id, auth_req, fd, mtu);
2089 if (ret != BT_STATUS_SUCCESS) {
2090 BT_ERR("GATT client write characteristic failed: %s", status2string(ret));
2091 return convert_to_oal_status(ret);
2094 return OAL_STATUS_SUCCESS;
2097 oal_status_t gattc_write_characteristic(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2098 oal_gatt_id_t *char_id, oal_gatt_write_type_t write_type,
2099 int len, oal_gatt_auth_req_t auth_req, char* data)
2101 int ret = OAL_STATUS_SUCCESS;
2102 char uuid_str1[2*BT_UUID_STRING_MAX];
2103 char uuid_str2[2*BT_UUID_STRING_MAX];
2104 OAL_CHECK_PARAMETER(srvc_id, return);
2105 OAL_CHECK_PARAMETER(char_id, return);
2106 OAL_CHECK_PARAMETER(data, return);
2107 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2108 uuid_to_stringname(&(char_id->uuid), uuid_str2);
2109 API_TRACE("Client Write Characteristic: Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
2110 CHECK_OAL_GATT_ENABLED();
2111 CHECK_CLIENT_CONNECTION(conn_id);
2113 ret = gatt_api->client->write_characteristic(conn_id, (btgatt_srvc_id_t *)srvc_id,
2114 (btgatt_gatt_id_t *)char_id, write_type, len, auth_req, data);
2115 if (ret != BT_STATUS_SUCCESS) {
2116 BT_ERR("GATT client write characteristic failed: %s", status2string(ret));
2117 return convert_to_oal_status(ret);
2120 return OAL_STATUS_SUCCESS;
2123 oal_status_t gattc_write_descriptor(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2124 oal_gatt_id_t *char_id, oal_gatt_id_t *desc_id,
2125 oal_gatt_write_type_t write_type, int len, oal_gatt_auth_req_t auth_req, char* data)
2127 int ret = OAL_STATUS_SUCCESS;
2128 char uuid_str1[2*BT_UUID_STRING_MAX];
2129 char uuid_str2[2*BT_UUID_STRING_MAX];
2130 char uuid_str3[2*BT_UUID_STRING_MAX];
2131 OAL_CHECK_PARAMETER(srvc_id, return);
2132 OAL_CHECK_PARAMETER(char_id, return);
2133 OAL_CHECK_PARAMETER(desc_id, return);
2134 OAL_CHECK_PARAMETER(data, return);
2135 uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2136 uuid_to_stringname(&(char_id->uuid), uuid_str2);
2137 uuid_to_stringname(&(desc_id->uuid), uuid_str3);
2138 API_TRACE("Client Write Descriptor: Service_uuid: [%s], Char_uuid: [%s], Desc_uuid: [%s]",
2139 uuid_str1, uuid_str2, uuid_str3);
2140 CHECK_OAL_GATT_ENABLED();
2141 CHECK_CLIENT_CONNECTION(conn_id);
2143 ret = gatt_api->client->write_descriptor(conn_id, (btgatt_srvc_id_t *)srvc_id,
2144 (btgatt_gatt_id_t *)char_id, (btgatt_gatt_id_t *)desc_id, write_type, len, auth_req, data);
2145 if (ret != BT_STATUS_SUCCESS) {
2146 BT_ERR("GATT client write characteristic failed: %s", status2string(ret));
2147 return convert_to_oal_status(ret);
2150 return OAL_STATUS_SUCCESS;
2153 oal_status_t gattc_conn_param_update(bt_address_t * address, int min, int max, int latency, int timeout)
2158 OAL_CHECK_PARAMETER(address, return);
2159 API_TRACE("Conn Param Update: [%s]", bdt_bd2str(address, &bdstr));
2160 CHECK_OAL_GATT_ENABLED();
2162 BT_INFO("[%s] min[%d] max[%d] latency[%d] timeout[%d]", bdt_bd2str(address, &bdstr), min, max, latency, timeout);
2163 ret = gatt_api->client->conn_parameter_update((bt_bdaddr_t *)address, min, max, latency, timeout);
2164 if (ret != BT_STATUS_SUCCESS) {
2165 BT_ERR("error: %s", status2string(ret));
2166 return convert_to_oal_status(ret);
2168 return OAL_STATUS_SUCCESS;
2171 oal_status_t gattc_unregister_scan_filter(int slot_id)
2177 CHECK_OAL_GATT_ENABLED();
2179 BT_INFO("Remove Scan filter Slot ID is: [%d]", slot_id);
2181 ret = gatt_api->client->scan_filter_clear(client_if, slot_id);
2182 if (ret != BT_STATUS_SUCCESS) {
2183 BT_ERR("error: %s", status2string(ret));
2184 return convert_to_oal_status(ret);
2186 return OAL_STATUS_SUCCESS;
2189 oal_status_t gattc_enable_scan_filter(int client_if)
2194 CHECK_OAL_GATT_ENABLED();
2196 BT_INFO("Enable Scan filter. Client If: %d", client_if);
2198 ret = gatt_api->client->scan_filter_enable(client_if, TRUE);
2199 if (ret != BT_STATUS_SUCCESS) {
2200 BT_ERR("error: %s", status2string(ret));
2201 return convert_to_oal_status(ret);
2203 return OAL_STATUS_SUCCESS;
2206 oal_status_t gattc_disable_scan_filter(int client_if)
2211 CHECK_OAL_GATT_ENABLED();
2213 BT_INFO("Disable Scan filter. Client If: %d", client_if);
2215 ret = gatt_api->client->scan_filter_enable(client_if, FALSE);
2216 if (ret != BT_STATUS_SUCCESS) {
2217 BT_ERR("error: %s", status2string(ret));
2218 return convert_to_oal_status(ret);
2220 return OAL_STATUS_SUCCESS;
2223 oal_status_t gattc_register_scan_filter(oal_ble_scan_filter_t* filter_data)
2226 int client_info = 0;
2229 int company_id_mask = 0;
2230 int address_type = 0;
2231 int feature_selection = 0;
2233 oal_ble_scan_filter_param_setup_t scan_filter_setup = {.list_logic_type = 0,
2234 .filt_logic_type = 1,
2235 .rssi_high_thres = -127,
2236 .rssi_low_thres = -127,
2240 .found_timeout_cnt = 0
2243 OAL_CHECK_PARAMETER(filter_data, return);
2245 CHECK_OAL_GATT_ENABLED();
2247 if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS){
2249 BT_INFO("OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS is being added");
2250 BT_INFO("BT remote Device address is %s", bdt_bd2str(filter_data->device_address, &bdstr));
2251 ret = gatt_api->client->scan_filter_add_remove(client_info,
2253 OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS,
2254 filter_data->slot_id,
2259 (bt_bdaddr_t*)filter_data->device_address,
2266 if (ret != BT_STATUS_SUCCESS){
2267 BT_ERR("error: %s", status2string(ret));
2268 BT_INFO("unregistering already set filter features.");
2269 gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
2270 return convert_to_oal_status(ret);
2273 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS;
2275 if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_NAME){
2276 ret = gatt_api->client->scan_filter_add_remove(client_info,
2278 OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_NAME,
2279 filter_data->slot_id,
2287 filter_data->device_name, // device_name as p_data in HAL
2291 if (ret != BT_STATUS_SUCCESS){
2292 BT_ERR("error: %s", status2string(ret));
2293 BT_INFO("unregistering already set filter features.");
2294 gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
2295 return convert_to_oal_status(ret);
2298 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_NAME;
2300 if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_UUID){
2301 BT_INFO("OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_UUID is being added");
2302 char uuid_str1[2*BT_UUID_STRING_MAX];
2303 char uuid_str2[2*BT_UUID_STRING_MAX];
2305 uuid_to_stringname((service_uuid_t*)filter_data->service_uuid, uuid_str1);
2306 uuid_to_stringname((service_uuid_t*)filter_data->service_uuid_mask, uuid_str2);
2308 BT_INFO("Service UUID is [%s] and Service UUID mask is [%s]", uuid_str1, uuid_str2);
2309 ret = gatt_api->client->scan_filter_add_remove(client_info,
2311 OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_UUID,
2312 filter_data->slot_id,
2315 (bt_uuid_t*)filter_data->service_uuid,
2316 (bt_uuid_t*)filter_data->service_uuid_mask,
2319 filter_data->service_uuid_len, // service_uuid_len as data_len in HAL
2321 filter_data->service_uuid_mask_len,
2324 if (ret != BT_STATUS_SUCCESS){
2325 BT_ERR("error: %s", status2string(ret));
2326 BT_INFO("unregistering already set filter features.");
2327 gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
2328 return convert_to_oal_status(ret);
2331 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_UUID;
2333 if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID){
2334 BT_INFO("OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID is being added");
2335 char uuid_str1[2*BT_UUID_STRING_MAX];
2336 char uuid_str2[2*BT_UUID_STRING_MAX];
2337 uuid_to_stringname((service_uuid_t*)filter_data->service_solicitation_uuid, uuid_str1);
2338 uuid_to_stringname((service_uuid_t*)filter_data->service_solicitation_uuid_mask, uuid_str2);
2339 BT_INFO("Service Solicitation UUID is [%s] and Service Solicitation UUID mask is [%s]", uuid_str1, uuid_str2);
2340 ret = gatt_api->client->scan_filter_add_remove(client_info,
2342 OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID,
2343 filter_data->slot_id,
2346 (bt_uuid_t*)filter_data->service_solicitation_uuid,
2347 (bt_uuid_t*)filter_data->service_solicitation_uuid_mask,
2350 filter_data->service_solicitation_uuid_len, // service_solicitation_uuid_len as data_len in HAL
2352 filter_data->service_solicitation_uuid_mask_len,
2355 if (ret != BT_STATUS_SUCCESS){
2356 BT_ERR("error: %s", status2string(ret));
2357 BT_INFO("unregistering already set filter features.");
2358 gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
2359 return convert_to_oal_status(ret);
2362 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID;
2364 if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_DATA){
2365 ret = gatt_api->client->scan_filter_add_remove(client_info,
2367 OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_DATA,
2368 filter_data->slot_id,
2375 filter_data->service_data_len, //service_data_len as data_len in HAL
2376 (char*)filter_data->service_data,
2377 filter_data->service_data_mask_len,
2378 (char*)filter_data->service_data_mask
2380 if (ret != BT_STATUS_SUCCESS){
2381 BT_ERR("error: %s", status2string(ret));
2382 BT_INFO("unregistering already set filter features.");
2383 gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
2384 return convert_to_oal_status(ret);
2387 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_DATA;
2389 if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA){
2390 ret = gatt_api->client->scan_filter_add_remove(client_info,
2392 OAL_BLE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA,
2393 filter_data->slot_id,
2394 filter_data->manufacturer_id,
2400 filter_data->manufacturer_data_len, //manufacturer_data_len as data_len in HAL
2401 (char*)filter_data->manufacturer_data,
2402 filter_data->manufacturer_data_mask_len,
2403 (char*)filter_data->manufacturer_data_mask
2405 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA;
2406 if (ret != BT_STATUS_SUCCESS){
2407 BT_ERR("error: %s", status2string(ret));
2408 BT_INFO("unregistering already set filter features.");
2409 gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
2410 return convert_to_oal_status(ret);
2413 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA;
2416 BT_DBG("Filter selection 0x%.2x", feature_selection);
2418 ret = gatt_api->client->scan_filter_param_setup(client_info, action, filter_data->slot_id, feature_selection,
2419 scan_filter_setup.list_logic_type, scan_filter_setup.filt_logic_type,
2420 scan_filter_setup.rssi_high_thres, scan_filter_setup.rssi_low_thres,
2421 scan_filter_setup.dely_mode, scan_filter_setup.found_timeout,
2422 scan_filter_setup.lost_timeout, scan_filter_setup.found_timeout_cnt);
2423 if (ret != BT_STATUS_SUCCESS){
2424 BT_ERR("error: %s", status2string(ret));
2425 return convert_to_oal_status(ret);
2427 return OAL_STATUS_SUCCESS;