bt-oal/oal-gatt.c

   1 /*
   2  * Open Adaptation Layer (OAL)
   3  *
   4  * Copyright (c) 2014-2015 Samsung Electronics Co., Ltd.
   5  *
   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
   9  *
  10  *              http://www.apache.org/licenses/LICENSE-2.0
  11  *
  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.
  17  *
  18  */
  19 #include <dlog.h>
  20 #include <bluetooth.h>
  21 #include "bt_gatt.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"
  27 #include "oal-gatt.h"
  28 #include "oal-common.h"
  29
  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
  34
  35 #define NUM_SERVER_INST 10 // Maximum slots supported by stack is set to 10
  36 #define CHECK_OAL_GATT_ENABLED() \
  37         do { \
  38                 if (gatt_api == NULL) { \
  39                         BT_ERR("GATT Not Enabled"); \
  40                         return OAL_STATUS_NOT_READY; \
  41                 } \
  42         } while (0)
  43
  44 #define CHECK_SERVER_INSTANCE(instance_id) \
  45         do { \
  46                 if (instance_id < 1 || instance_id > NUM_SERVER_INST) { \
  47                         BT_ERR("Invalid Instance"); \
  48                         return OAL_STATUS_INVALID_PARAM; \
  49                 } \
  50         } while (0)
  51
  52 #define CHECK_SERVER_REGISTRATION(instance_id) \
  53         do { \
  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;\
  57                 } \
  58         } while (0)
  59
  60 #define CHECK_CORRECT_SERVER_ID(instance_id, server_if, server_inst)\
  61         do { \
  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; \
  65                                 goto sendevent;\
  66                         } \
  67                 } \
  68         } while (0)
  69
  70 #define PRINT_ADV_DATA(length, manuf_data, data_type) \
  71         do { \
  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);\
  77                         else \
  78                         BT_INFO("Advertising Data:%s\n", buf_str);\
  79                         g_free(buf_str);\
  80                 } \
  81         } while (0)
  82
  83 #define CHECK_CLIENT_REGISTRATION(client_id) \
  84         do { \
  85                 if (client_id <= 0) { \
  86                         BT_DBG("No client registered yet...");\
  87                         return OAL_STATUS_INTERNAL_ERROR;\
  88                 } \
  89         } while (0)
  90
  91 #define CHECK_CLIENT_CONNECTION(conn_id) \
  92         do { \
  93                 if (conn_id <= 0) {\
  94                         BT_ERR("No active connection");\
  95                         return OAL_STATUS_INTERNAL_ERROR;\
  96                 } \
  97         } while (0)
  98
  99
 100 typedef enum {
 101         GATT_INS_DISABLED,
 102         GATT_INS_DATA_SETTING,
 103         GATT_INS_DATA_SET,
 104         GATT_INS_ENABLING,
 105         GATT_INS_ENABLED,
 106 } gatt_data_state;
 107
 108 typedef struct {
 109         int server_id;
 110         oal_uuid_t uuid;
 111         int state;
 112 } gatt_server_t;
 113
 114 const char *oal_device_type[] = {
 115         "UNKNOWN",
 116         "BR/EDR",
 117         "BLE",
 118         "DUAL_MODE",
 119 };
 120
 121 typedef enum {
 122         OAL_REQ_NONE,
 123         OAL_REQ_LE_SCAN,
 124         OAL_REQ_LE_CONNECT,
 125 } oal_pending_gattc_req_e;
 126
 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];
 130
 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);
 137
 138 static void cb_gatts_listen(int status, int server_if);
 139
 140
 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);
 145
 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);
 149
 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);
 154
 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);
 157
 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);
 160
 161 static void cb_gatts_mtu_changed(int conn_id, int mtu);
 162
 163 #ifdef TIZEN_BT_HAL
 164 static void cb_notifcation_changed(int conn_id, int trans_id, int attr_handle, bool notify,  bt_bdaddr_t *bda);
 165 #endif
 166
 167 /************************************HAL Interface *************************************/
 168
 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,
 191 #ifdef TIZEN_BT_HAL
 192         .notif_enabled_cb = cb_notifcation_changed,
 193 #endif
 194         .request_acquire_write_cb = cb_gatts_acquire_write,
 195         .request_acquire_notify_cb = cb_gatts_acquire_notify
 196 };
 197
 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);
 216
 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,
 247 #endif
 248 };
 249
 250 static btgatt_callbacks_t btgatt_callbacks = {
 251         sizeof(btgatt_callbacks_t),
 252         &btgatt_client_callbacks,
 253         &btgatt_server_callbacks
 254 };
 255
 256 /*******************************GATT Initialisation - Deinitialisation********************************/
 257 oal_status_t gatt_enable(void)
 258 {
 259         const bt_interface_t * blued_api;
 260         int ret;
 261         int i = 0;
 262
 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;
 268         }
 269
 270         /* Get stack interface */
 271         blued_api = (const bt_interface_t *) adapter_get_stack_interface();
 272
 273         if (blued_api == NULL) {
 274                 BT_ERR("Stack is not initialized");
 275                 return OAL_STATUS_NOT_READY;
 276         }
 277
 278         if (gatt_api) {
 279                 BT_WARN("GATT Interface is already initialized...");
 280                 return OAL_STATUS_ALREADY_DONE;
 281         }
 282
 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;
 287         }
 288
 289         if ((ret = gatt_api->init(&btgatt_callbacks)) != BT_STATUS_SUCCESS) {
 290                 BT_ERR("Error: Unable to initialise GATT :%s", status2string(ret));
 291                 gatt_api->cleanup();
 292                 gatt_api = NULL;
 293                 return convert_to_oal_status(ret);
 294         }
 295
 296         BT_INFO("GATT successfully initialized");
 297         return OAL_STATUS_SUCCESS;
 298 }
 299
 300 oal_status_t gatt_disable(void)
 301 {
 302         int i;
 303         if (gatt_api) {
 304                 gatt_api->cleanup();
 305                 gatt_api = NULL;
 306         }
 307
 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));
 312         }
 313         return OAL_STATUS_SUCCESS;
 314 }
 315
 316 /************************************GATT Server Functions*************************************/
 317 /*Public */
 318 oal_status_t gatts_register(oal_uuid_t* server_uuid)
 319 {
 320         char str[2*BT_UUID_STRING_MAX];
 321         int ret = OAL_STATUS_SUCCESS;
 322         int i;
 323
 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);
 327
 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;
 334                         }
 335                 }
 336         }
 337
 338         ret = gatt_api->server->register_server((bt_uuid_t*)server_uuid);
 339
 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);
 343         }
 344         return OAL_STATUS_SUCCESS;
 345 }
 346
 347 oal_status_t gatts_unregister(int instance_id)
 348 {
 349         int ret = OAL_STATUS_SUCCESS;
 350         API_TRACE("Unregister the registered server, instance_id: %d", instance_id);
 351
 352         CHECK_OAL_GATT_ENABLED();
 353         CHECK_SERVER_INSTANCE(instance_id);
 354         CHECK_SERVER_REGISTRATION(instance_id);
 355
 356         ret = gatt_api->server->unregister_server(gatt_servers[instance_id - 1].server_id);
 357
 358         if (ret != BT_STATUS_SUCCESS) {
 359                 BT_ERR("GATT server unregistration failed: %d", instance_id);
 360                 return convert_to_oal_status(ret);
 361         }
 362
 363         gatt_servers[instance_id-1].server_id = -1;
 364         gatt_servers[instance_id-1].state = GATT_INS_DISABLED;
 365
 366         if (instance_id != 1 && instance_id != 2)
 367                 memset(&gatt_servers[instance_id-1].uuid, 0, sizeof(oal_uuid_t));
 368
 369         return OAL_STATUS_SUCCESS;
 370 }
 371
 372 /* Legacy Advertisement */
 373 oal_status_t gatts_start_listen(int instance_id, gboolean enable)
 374 {
 375         int ret = OAL_STATUS_SUCCESS;
 376         API_TRACE("server-id:%d enable: %d", gatt_servers[instance_id-1].server_id, enable);
 377
 378         CHECK_OAL_GATT_ENABLED();
 379         CHECK_SERVER_INSTANCE(instance_id);
 380         CHECK_SERVER_REGISTRATION(instance_id);
 381
 382         ret = gatt_api->server->listen(gatt_servers[instance_id-1].server_id, enable);
 383
 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);
 388         }
 389
 390         return OAL_STATUS_SUCCESS;
 391 }
 392
 393 oal_status_t gatts_stop_advertising(int instance_id)
 394 {
 395         int ret = OAL_STATUS_SUCCESS;
 396         API_TRACE("Stop advertising");
 397
 398         CHECK_OAL_GATT_ENABLED();
 399         CHECK_SERVER_INSTANCE(instance_id);
 400         CHECK_SERVER_REGISTRATION(instance_id);
 401
 402         ret = gatt_api->server->listen(gatt_servers[instance_id - 1].server_id, FALSE);
 403
 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);
 408         }
 409         return OAL_STATUS_SUCCESS;
 410 }
 411
 412 #if 0
 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)
 417 {
 418         int ret = OAL_STATUS_SUCCESS;
 419
 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);
 424
 425         /* Historically used for Legacy Advertising */
 426         return OAL_STATUS_NOT_SUPPORT;
 427 }
 428
 429 oal_status_t gatts_set_advertising_data(int instance_id, uint16_t manufac_len, char* manufac_data)
 430 {
 431         int ret = OAL_STATUS_SUCCESS;
 432
 433         API_TRACE("Set advertising data");
 434         CHECK_OAL_GATT_ENABLED();
 435         CHECK_SERVER_INSTANCE(instance_id);
 436         CHECK_SERVER_REGISTRATION(instance_id);
 437
 438         /* Historically used for Legacy Advertising */
 439         return OAL_STATUS_NOT_SUPPORT;
 440 }
 441
 442 oal_status_t gatts_set_scan_response(int instance_id, uint16_t manufac_len, char* manufac_data)
 443 {
 444         int ret = OAL_STATUS_SUCCESS;
 445
 446         API_TRACE("Set Scan Response data");
 447         CHECK_OAL_GATT_ENABLED();
 448         CHECK_SERVER_INSTANCE(instance_id);
 449         CHECK_SERVER_REGISTRATION(instance_id);
 450
 451         /* Historically used for Legacy Advertising */
 452         return OAL_STATUS_NOT_SUPPORT;
 453 }
 454 #endif
 455
 456 oal_status_t gatts_multi_adv_enable(int instance_id)
 457 {
 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);
 461
 462         CHECK_OAL_GATT_ENABLED();
 463         CHECK_SERVER_INSTANCE(instance_id);
 464         CHECK_SERVER_REGISTRATION(instance_id);
 465
 466         if (gatt_api->server->multi_adv_enable == NULL)
 467                 return OAL_STATUS_NOT_SUPPORT;
 468
 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;
 474         }
 475 */
 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;
 480         }
 481
 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;
 486         }
 487
 488         gatt_servers[instance_id - 1].state = GATT_INS_ENABLING;
 489
 490         ret = gatt_api->server->multi_adv_enable(gatt_servers[instance_id - 1].server_id);
 491
 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);
 497         }
 498         return OAL_STATUS_SUCCESS;
 499 }
 500
 501 oal_status_t gatts_multi_adv_disable(int instance_id)
 502 {
 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);
 506
 507         CHECK_OAL_GATT_ENABLED();
 508         CHECK_SERVER_INSTANCE(instance_id);
 509         CHECK_SERVER_REGISTRATION(instance_id);
 510
 511         if (gatt_api->server->multi_adv_disable == NULL)
 512                 return OAL_STATUS_NOT_SUPPORT;
 513
 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;
 518         }
 519
 520         ret = gatt_api->server->multi_adv_disable(gatt_servers[instance_id - 1].server_id);
 521
 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);
 526         }
 527         return OAL_STATUS_SUCCESS;
 528 }
 529
 530 oal_status_t gatts_set_filter_policy(int filter_policy)
 531 {
 532         int ret = OAL_STATUS_SUCCESS;
 533
 534         CHECK_OAL_GATT_ENABLED();
 535
 536         /* send the filter_policy value to the HAL Layer */
 537         ret = gatt_api->server->set_filter_policy(filter_policy);
 538
 539         if (ret != BT_STATUS_SUCCESS) {
 540                 BT_ERR("set_filter_policy failed: %d",ret);
 541                 return convert_to_oal_status(ret);
 542         }
 543
 544         return OAL_STATUS_SUCCESS;
 545 }
 546
 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)
 551 {
 552         int ret = OAL_STATUS_SUCCESS;
 553         API_TRACE("Multi advertising Update");
 554
 555         CHECK_OAL_GATT_ENABLED();
 556         CHECK_SERVER_INSTANCE(instance_id);
 557         CHECK_SERVER_REGISTRATION(instance_id);
 558
 559         if (gatt_api->server->multi_adv_update == NULL)
 560                 return OAL_STATUS_NOT_SUPPORT;
 561
 562         ret = gatt_api->server->multi_adv_update(gatt_servers[instance_id - 1].server_id,
 563                         min_intv, max_intv,
 564                         adv_type, chnl_map,
 565                         tx_power, timeout_s);
 566
 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);
 571         }
 572         return OAL_STATUS_SUCCESS;
 573 }
 574
 575 oal_status_t gatts_multi_adv_set_inst_data(int instance_id,
 576                 oal_ble_multi_adv_param_setup_t *adv_param_setup)
 577 {
 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);
 582
 583         CHECK_OAL_GATT_ENABLED();
 584         CHECK_SERVER_INSTANCE(instance_id);
 585         CHECK_SERVER_REGISTRATION(instance_id);
 586
 587         if (gatt_api->server->multi_adv_set_inst_data == NULL)
 588                 return OAL_STATUS_NOT_SUPPORT;
 589
 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;
 593         }
 594
 595         gatt_servers[instance_id - 1].state = GATT_INS_DATA_SETTING;
 596
 597
 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;
 618
 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);
 623         }
 624
 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);
 628         }
 629
 630
 631         ret = gatt_api->server->multi_adv_set_inst_data(adv_setup);
 632
 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);
 637         }
 638         return OAL_STATUS_SUCCESS;
 639 }
 640
 641 oal_status_t gatts_disconnect(int instance_id, bt_address_t *device_address, int conn_id)
 642 {
 643         int ret = OAL_STATUS_SUCCESS;
 644         bdstr_t bdstr;
 645
 646         API_TRACE("Server Disonnect: instance_id = %d, conn_id = %d", instance_id, conn_id);
 647
 648         CHECK_OAL_GATT_ENABLED();
 649         CHECK_SERVER_INSTANCE(instance_id);
 650         CHECK_SERVER_REGISTRATION(instance_id);
 651
 652         API_TRACE("[%s]", bdt_bd2str(device_address, &bdstr));
 653
 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);
 658         }
 659         return OAL_STATUS_SUCCESS;
 660 }
 661
 662
 663 /************************************GATT Server Functions*************************************/
 664 /*Server Callbacks*/
 665 static void cb_gatts_register_app(int status, int server_if, bt_uuid_t *uuid)
 666 {
 667         int i;
 668         char str[2*BT_UUID_STRING_MAX];
 669         uuid_to_stringname((service_uuid_t*)uuid, str);
 670
 671         event_gatts_register_t *event = g_malloc0(sizeof(event_gatts_register_t));
 672
 673         BT_INFO("BTGATT SERVER REGISTER APP CB, status:%d, server_if:%d", status, server_if);
 674         BT_INFO("UUID: [%s]", str);
 675
 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));
 683                         break;
 684                 }
 685         }
 686         send_event(OAL_EVENT_BLE_SERVER_INSTANCE_INITIALISED, event, sizeof(event_gatts_register_t));
 687 }
 688
 689 static void cb_gatts_listen(int status, int server_if)
 690 {
 691         gboolean prev_state[NUM_SERVER_INST];
 692         gboolean new_state;
 693         event_ble_adv_status *event = g_malloc0(sizeof(event_ble_adv_status));
 694         int instance_id;
 695
 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;
 699                         break;
 700                 } else {
 701                         BT_WARN("Server ID:%d recevied server Id:%d\n", gatt_servers[instance_id - 1].server_id, server_if);
 702                 }
 703         }
 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;
 708         } else {
 709                 BT_ERR("Invalid Callback...");
 710                 g_free(event);
 711                 return;
 712         }
 713
 714         BT_INFO("Adv State of server instance %d :%d", instance_id, new_state);
 715
 716         if (TRUE == new_state)
 717                 send_event(OAL_EVENT_BLE_ADVERTISING_STARTED, event, sizeof(event_ble_adv_status));
 718         else
 719                 send_event(OAL_EVENT_BLE_ADVERTISING_STOPPED, event, sizeof(event_ble_adv_status));
 720 }
 721
 722 static void cb_gatts_multi_adv_enable(int server_if, int status)
 723 {
 724
 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));
 727         int instance_id;
 728
 729         if (status != BT_STATUS_SUCCESS)
 730                 BT_ERR("MULTI ADV ENABLE failed, status:%d, srv_if: %d", status, server_if);
 731
 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;
 736                         goto sendevent;
 737                 }
 738         }
 739         BT_ERR("Invalid Interface, srv_if: %d", server_if);
 740         event->server_inst = -1;
 741 sendevent:
 742         event->status = convert_to_oal_status(status);
 743         send_event(OAL_EVENT_BLE_MULTI_ADVERTISING_ENABLE, event, sizeof(event_ble_multiadv_status));
 744 }
 745
 746 static void cb_gatts_multi_adv_disable(int server_if, int status)
 747 {
 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));
 750         int instance_id;
 751
 752         if (status != BT_STATUS_SUCCESS)
 753                 BT_ERR("MULTI ADV DISABLE failed, status:%d, srv_if: %d", status, server_if);
 754
 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;
 759                         goto sendevent;
 760                 }
 761         }
 762         BT_ERR("Invalid Interface, srv_if: %d", server_if);
 763         event->server_inst = -1;
 764 sendevent:
 765         event->status = convert_to_oal_status(status);
 766         send_event(OAL_EVENT_BLE_MULTI_ADVERTISING_DISABLE, event, sizeof(event_ble_multiadv_status));
 767 }
 768
 769 static void cb_gatts_multi_adv_update(int server_if, int status)
 770 {
 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));
 773         int instance_id;
 774
 775         if (status != BT_STATUS_SUCCESS)
 776                 BT_ERR("MULTI ADV UPDATE failed, status:%d, srv_if: %d", status, server_if);
 777
 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;
 781                         goto sendevent;
 782                 }
 783         }
 784         BT_ERR("Invalid Interface, srv_if: %d", server_if);
 785         event->server_inst = -1;
 786 sendevent:
 787         event->status = convert_to_oal_status(status);
 788         send_event(OAL_EVENT_BLE_MULTI_ADVERTISING_UPDATE, event, sizeof(event_ble_multiadv_status));
 789 }
 790
 791 static void cb_gatts_multi_adv_set_inst_data(int server_if, int status)
 792 {
 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));
 795         int instance_id;
 796
 797         if (status != BT_STATUS_SUCCESS)
 798                 BT_ERR("MULTI ADV SET DATA failed, status:%d, srv_if: %d", status, server_if);
 799
 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;
 804                         goto sendevent;
 805                 }
 806         }
 807         BT_ERR("Invalid Interface, srv_if: %d", server_if);
 808         event->server_inst = -1;
 809 sendevent:
 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));
 812 }
 813
 814 oal_status_t gatts_get_att_mtu(int conn_id, int *mtu)
 815 {
 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);
 820
 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;
 825         }
 826
 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);
 831         }
 832
 833         BT_INFO("Current ATT MTU Size: %d", *mtu);
 834         return OAL_STATUS_SUCCESS;
 835 }
 836 oal_status_t gatt_send_response_acquire(int conn_id, int trans_id,
 837                 int status, int fd, int mtu , void * fdlist)
 838 {
 839         int ret = OAL_STATUS_SUCCESS;
 840
 841         API_TRACE("Server Send Response : ConnId = %d, TransId = %d,  %d", conn_id, trans_id, fd);
 842         CHECK_OAL_GATT_ENABLED();
 843
 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);
 848         }
 849         return OAL_STATUS_SUCCESS;
 850
 851 }
 852 oal_status_t gatts_add_service(int instance_id, oal_gatt_srvc_id_t *gatt_serv_id,
 853                 int num_handles)
 854 {
 855         int ret = OAL_STATUS_SUCCESS;
 856         btgatt_srvc_id_t btgatt_srvc_id;
 857         char str[2*BT_UUID_STRING_MAX];
 858
 859         API_TRACE("Server Add Service : instance_id = %d, num_handles = %d", instance_id, num_handles);
 860         CHECK_OAL_GATT_ENABLED();
 861
 862         CHECK_SERVER_INSTANCE(instance_id);
 863         CHECK_SERVER_REGISTRATION(instance_id);
 864
 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;
 871         } else {
 872                 BT_INFO("GATT Server Service Id is NULL");
 873                 return OAL_STATUS_INVALID_PARAM;
 874         }
 875
 876         ret = gatt_api->server->add_service(gatt_servers[instance_id - 1].server_id, &btgatt_srvc_id, num_handles);
 877
 878         if (ret != BT_STATUS_SUCCESS) {
 879                 BT_ERR("GATT Server add service failed: %s", status2string(ret));
 880                 return convert_to_oal_status(ret);
 881         }
 882         return OAL_STATUS_SUCCESS;
 883 }
 884
 885 oal_status_t gatts_add_included_services(int instance_id, int serv_handle,
 886                 int incl_handle)
 887 {
 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();
 892
 893         CHECK_SERVER_INSTANCE(instance_id);
 894
 895         CHECK_SERVER_REGISTRATION(instance_id);
 896
 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);
 901         }
 902         return OAL_STATUS_SUCCESS;
 903 }
 904
 905 oal_status_t gatts_add_characteristics(int instance_id, int serv_handle,
 906                         oal_uuid_t* charc_uuid, int propts, int permsn)
 907 {
 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();
 916
 917         CHECK_SERVER_INSTANCE(instance_id);
 918
 919         CHECK_SERVER_REGISTRATION(instance_id);
 920
 921         if (charc_uuid != NULL) {
 922                 uuid_to_stringname(charc_uuid, str);
 923                 API_TRACE("uuid: [%s]", str);
 924         }
 925
 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);
 931         }
 932         return OAL_STATUS_SUCCESS;
 933 }
 934
 935 oal_status_t gatts_add_descriptor(int instance_id, int serv_handle,
 936                 oal_uuid_t* desc_uuid, int permsn)
 937 {
 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();
 945
 946         CHECK_SERVER_INSTANCE(instance_id);
 947
 948         CHECK_SERVER_REGISTRATION(instance_id);
 949
 950         if (desc_uuid != NULL) {
 951                 uuid_to_stringname(desc_uuid, str);
 952                 API_TRACE("uuid: [%s]", str);
 953         }
 954
 955         ret = gatt_api->server->add_descriptor(gatt_servers[instance_id - 1].server_id,
 956                                 serv_handle, (bt_uuid_t*)desc_uuid, permsn);
 957
 958         if (ret != BT_STATUS_SUCCESS) {
 959                 BT_ERR("GATT Server Add Descriptor failed: %s", status2string(ret));
 960                 return convert_to_oal_status(ret);
 961         }
 962         return OAL_STATUS_SUCCESS;
 963 }
 964
 965 oal_status_t gatts_start_service(int instance_id, int svc_handle, int transport)
 966 {
 967         int ret = OAL_STATUS_SUCCESS;
 968
 969         API_TRACE("Server Start Service : Ins_id = %d, srvHndl = %d, transport = %d",
 970                                 instance_id, svc_handle, transport);
 971         CHECK_OAL_GATT_ENABLED();
 972
 973         CHECK_SERVER_INSTANCE(instance_id);
 974
 975         CHECK_SERVER_REGISTRATION(instance_id);
 976
 977         ret = gatt_api->server->start_service(gatt_servers[instance_id - 1].server_id, svc_handle, transport);
 978
 979         if (ret != BT_STATUS_SUCCESS) {
 980                 BT_ERR("GATT Server Start Service failed: %s", status2string(ret));
 981                 return convert_to_oal_status(ret);
 982         }
 983         return OAL_STATUS_SUCCESS;
 984 }
 985
 986 oal_status_t gatts_stop_service(int ins_id, int srv_hdl)
 987 {
 988         int ret = OAL_STATUS_SUCCESS;
 989
 990         API_TRACE("Server Stop Service : Ins_id = %d, srvHndl = %d, ", ins_id, srv_hdl);
 991         CHECK_OAL_GATT_ENABLED();
 992
 993         CHECK_SERVER_INSTANCE(ins_id);
 994         CHECK_SERVER_REGISTRATION(ins_id);
 995
 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);
1000         }
1001         return OAL_STATUS_SUCCESS;
1002 }
1003
1004 oal_status_t gatts_delete_service(int ins_id, int srv_hdl)
1005 {
1006         int ret = OAL_STATUS_SUCCESS;
1007
1008         API_TRACE("Server Delete Service : Ins_id = %d, srvHndl = %d, ", ins_id, srv_hdl);
1009         CHECK_OAL_GATT_ENABLED();
1010
1011         CHECK_SERVER_INSTANCE(ins_id);
1012
1013         CHECK_SERVER_REGISTRATION(ins_id);
1014
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);
1019         }
1020         return OAL_STATUS_SUCCESS;
1021 }
1022
1023 oal_status_t gatts_send_response(int conn_id, int trans_id, int resp_status, oal_gatt_response_t *response)
1024 {
1025         int ret = OAL_STATUS_SUCCESS;
1026
1027         API_TRACE("Server Send Response : ConnId = %d, TransId = %d, ", conn_id, trans_id);
1028         CHECK_OAL_GATT_ENABLED();
1029
1030         if (response == NULL) {
1031                 BT_ERR("GATT Server attribute value is empty");
1032                 return OAL_STATUS_INVALID_PARAM;
1033         }
1034
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);
1039         }
1040         return OAL_STATUS_SUCCESS;
1041 }
1042
1043 oal_status_t gatts_send_indication(int ins_id, int attr_hndl, int conn_id, int len, int confirm, char* value)
1044 {
1045         int ret = OAL_STATUS_SUCCESS;
1046
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();
1050
1051         CHECK_SERVER_INSTANCE(ins_id);
1052
1053         CHECK_SERVER_REGISTRATION(ins_id);
1054
1055         if (value == NULL || len == 0) {
1056                 BT_ERR("GATT Server attribute value is empty");
1057                 return OAL_STATUS_INVALID_PARAM;
1058         }
1059
1060         ret = gatt_api->server->send_indication(gatt_servers[ins_id - 1].server_id,
1061                         attr_hndl, conn_id, len, confirm, value);
1062
1063         if (ret != BT_STATUS_SUCCESS) {
1064                 BT_ERR("GATT Server Send Indication failed: %s", status2string(ret));
1065                 return convert_to_oal_status(ret);
1066         }
1067         return OAL_STATUS_SUCCESS;
1068 }
1069
1070 oal_status_t gatts_update_att_value(int ins_id, oal_gatt_value_t *value)
1071 {
1072         int ret = OAL_STATUS_SUCCESS;
1073
1074         CHECK_OAL_GATT_ENABLED();
1075
1076         CHECK_SERVER_INSTANCE(ins_id);
1077
1078         CHECK_SERVER_REGISTRATION(ins_id);
1079
1080         if (value == NULL || value->len == 0) {
1081                 BT_ERR("GATT Server attribute value is empty");
1082                 return OAL_STATUS_INVALID_PARAM;
1083         }
1084
1085         API_TRACE("Server Update Value: Ins_id = [%d], att handle = [%d] data len [%d]",
1086                         ins_id, value->handle, value->len);
1087
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);
1090
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);
1094         }
1095         return OAL_STATUS_SUCCESS;
1096 }
1097
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)
1101 {
1102         int instance_id;
1103
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);
1106
1107         CHECK_CORRECT_SERVER_ID(instance_id, server_if, event->gatt_srvc_stat.server_inst);
1108
1109         BT_ERR("Invalid Interface, srv_if: %d", server_if);
1110         event->gatt_srvc_stat.server_inst = -1;
1111 sendevent:
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;
1118         }
1119
1120         event->gatt_srvc_stat.status = convert_to_oal_status(status);
1121
1122         send_event(OAL_EVENT_GATTS_SERVICE_ADDED, event, sizeof(event_gatts_srvc_prm_t));
1123 }
1124
1125 static void cb_gatts_included_service_added(int status, int server_if,
1126                 int srvc_handle,
1127                 int incl_srvc_handle)
1128 {
1129         int ins_id ;
1130         BT_INFO("BTGATT SERVER INCLUDED SERVICE ADDED CB, status:%d, srvc handle:%d, incl handle:%d",
1131                         status, srvc_handle, incl_srvc_handle);
1132
1133         event_gatts_incld_srvc_t* event = g_new0(event_gatts_incld_srvc_t, 1);
1134
1135         CHECK_CORRECT_SERVER_ID(ins_id, server_if, event->gatt_srvc_stat.server_inst);
1136
1137         BT_ERR("Invalid Interface, srv_if: %d", server_if);
1138         event->gatt_srvc_stat.server_inst = -1;
1139 sendevent:
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));
1144 }
1145
1146 static void cb_gatts_characteristic_added(int status, int server_if, bt_uuid_t *char_id,
1147                 int srvc_handle, int char_handle)
1148 {
1149         int Ins_id ;
1150
1151         BT_INFO("BTGATT SERVER CHARACTERISTIC ADDED CB, status:%d, srvc handle:%d, char handle:%d",
1152                         status, srvc_handle, char_handle);
1153
1154         event_gatts_srvc_charctr_t* event = g_new0(event_gatts_srvc_charctr_t, 1);
1155
1156         CHECK_CORRECT_SERVER_ID(Ins_id, server_if, event->gatt_srvc_stat.server_inst);
1157
1158         BT_ERR("Invalid Interface, srv_if: %d", server_if);
1159         event->gatt_srvc_stat.server_inst = -1;
1160 sendevent:
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));
1166 }
1167
1168 static void cb_gatts_descriptor_added(int status, int server_if,
1169                 bt_uuid_t *descr_id, int srvc_handle,
1170                 int descr_handle)
1171 {
1172         int Ins_id ;
1173         BT_INFO("BTGATT SERVER DESCRIPTOR ADDED CB, status:%d, srvc handle:%d, desc handle:%d",
1174                         status, srvc_handle, descr_handle);
1175
1176         event_gatts_srvc_descr_t* event = g_new0(event_gatts_srvc_descr_t, 1);
1177
1178         CHECK_CORRECT_SERVER_ID(Ins_id, server_if, event->gatt_srvc_stat.server_inst);
1179
1180         BT_ERR("Invalid Interface, srv_if: %d", server_if);
1181         event->gatt_srvc_stat.server_inst = -1;
1182 sendevent:
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));
1188 }
1189
1190 static void cb_gatts_service_started(int status, int server_if, int srvc_handle)
1191 {
1192         int Ins_id ;
1193         BT_INFO("BTGATT SERVER SERVICE STARTED CB, status:%d, srvc_handle:%d", status, srvc_handle);
1194
1195         event_gatts_srvc_t* event = g_new0(event_gatts_srvc_t, 1);
1196
1197         CHECK_CORRECT_SERVER_ID(Ins_id, server_if, event->server_inst);
1198
1199         BT_ERR("Invalid Interface, srv_if: %d", server_if);
1200         event->server_inst = -1;
1201 sendevent:
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));
1205 }
1206
1207 static void cb_gatts_service_stopped(int status, int server_if, int srvc_handle)
1208 {
1209         int ins_id ;
1210         BT_INFO("BTGATT SERVER SERVICE STOPPED CB, status:%d, srvc_handle:%d", status, srvc_handle);
1211
1212         event_gatts_srvc_t* event = g_new0(event_gatts_srvc_t, 1);
1213
1214         CHECK_CORRECT_SERVER_ID(ins_id, server_if, event->server_inst);
1215
1216         BT_ERR("Invalid Interface, srv_if: %d", server_if);
1217         event->server_inst = -1;
1218 sendevent:
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));
1222 }
1223
1224 static void cb_gatts_service_deleted(int status, int server_if, int srvc_handle)
1225 {
1226         int ins_id;
1227         BT_INFO("BTGATT SERVER SERVICE DELETED CB, status:%d, srvc_handle:%d", status, srvc_handle);
1228
1229         event_gatts_srvc_t* event = g_new0(event_gatts_srvc_t, 1);
1230
1231         CHECK_CORRECT_SERVER_ID(ins_id, server_if, event->server_inst);
1232
1233         BT_ERR("Invalid Interface, srv_if: %d", server_if);
1234         event->server_inst = -1;
1235 sendevent:
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));
1239 }
1240
1241 static void cb_gatts_connection(int conn_id, int server_if, int connected, bt_bdaddr_t *bda)
1242 {
1243         int ins_id ;
1244         oal_event_t event_type;
1245
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);
1248
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;
1252                         break;
1253                 } else {
1254                         BT_INFO("Server ID:%d recevied server Id:%d\n", gatt_servers[ins_id - 1].server_id, server_if);
1255                 }
1256         }
1257         if (ins_id == NUM_SERVER_INST+1) {
1258                 BT_WARN("Incorrect Server Interface received: %d\n",  server_if);
1259                 g_free(event);
1260                 return;
1261         }
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;
1266
1267         send_event(event_type, event, sizeof(event_gatts_conn_t));
1268 }
1269
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)
1272 {
1273         BT_INFO("BTGATT SERVER REQUEST READ CB: conn_id:%d", conn_id);
1274
1275         event_gatts_srvc_read_attr_t* event = g_new0(event_gatts_srvc_read_attr_t, 1);
1276
1277         memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1278
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;
1284
1285         send_event(OAL_EVENT_GATTS_REQUEST_READ, event, sizeof(event_gatts_srvc_read_attr_t));
1286 }
1287
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)
1292 {
1293         BT_INFO("BTGATT SERVER REQUEST WRITE conn_id:%d", conn_id);
1294
1295         event_gatts_srvc_write_attr_t* event = g_new0(event_gatts_srvc_write_attr_t, 1);
1296
1297         memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1298
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;
1305
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;
1311         }
1312         send_event(OAL_EVENT_GATTS_REQUEST_WRITE, event, sizeof(event_gatts_srvc_write_attr_t));
1313 }
1314
1315 static void cb_gatts_acquire_write(int mtu, int conn_id, int trans_id, int attr_handle , bt_bdaddr_t *bda)
1316
1317 {
1318         BT_INFO("BTGATT SERVER REQUEST ACQUIRE WRITE conn_id:%d", conn_id);
1319
1320         event_gatts_srvc_acquire_attr_t* event = g_new0(event_gatts_srvc_acquire_attr_t, 1);
1321
1322         event->attr_trans.attr_handle = attr_handle;
1323         event->attr_trans.conn_id = conn_id;
1324         event->attr_trans.trans_id = trans_id;
1325         event->mtu = mtu;
1326         memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1327
1328         send_event(OAL_EVENT_GATTS_REQUEST_ACQUIRE_WRITE, event, sizeof(event_gatts_srvc_acquire_attr_t));
1329 }
1330
1331 static void cb_gatts_acquire_notify(int mtu, int conn_id, int trans_id, int attr_handle)
1332 {
1333         BT_INFO("BTGATT SERVER REQUEST ACQUIRE NOTIFY conn_id:%d", conn_id);
1334
1335         event_gatts_srvc_acquire_attr_t* event = g_new0(event_gatts_srvc_acquire_attr_t, 1);
1336
1337         event->attr_trans.attr_handle = attr_handle;
1338         event->attr_trans.conn_id = conn_id;
1339         event->attr_trans.trans_id = trans_id;
1340         event->mtu = mtu;
1341
1342         send_event(OAL_EVENT_GATTS_REQUEST_ACQUIRE_NOTIFY, event, sizeof(event_gatts_srvc_acquire_attr_t));
1343
1344 }
1345
1346 static void cb_gatts_response_confirmation(int status, int handle)
1347 {
1348         BT_INFO("BTGATT SERVER RESPONSE CONFIRMATION CB, status:%d, handle:%d", status, handle);
1349
1350         event_gatts_respons_t* event = g_new0(event_gatts_respons_t, 1);
1351
1352         event->hndl = handle;
1353         event->status = convert_to_oal_status(status);
1354
1355         send_event(OAL_EVENT_GATTS_RESPONSE_CONFIRMED, event, sizeof(event_gatts_respons_t));
1356 }
1357
1358 static void cb_indication_confirmation(int conn_id, int trans_id, int attr_handle, bt_bdaddr_t *bda)
1359 {
1360         BT_INFO("BTGATT SERVER Indication Confirmation CB, conn_id:%d, trans_id:%d attr_handle:%d",
1361                         conn_id, trans_id, attr_handle);
1362
1363         event_gatts_ind_cnfrm_t* event = g_new0(event_gatts_ind_cnfrm_t, 1);
1364
1365         memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1366
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));
1371 }
1372
1373 static void cb_gatts_mtu_changed(int conn_id, int mtu)
1374 {
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));
1380 }
1381
1382 #ifdef TIZEN_BT_HAL
1383 static void cb_notifcation_changed(int conn_id, int trans_id, int attr_handle, bool notify,  bt_bdaddr_t *bda)
1384 {
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);
1387
1388         event_gatts_notif_t* event = g_new0(event_gatts_notif_t, 1);
1389
1390         memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1391
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));
1397 }
1398 #endif
1399
1400
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)
1405 {
1406         char uuid_str[BT_UUID_STRING_MAX];
1407         event_gattc_register_t *event;
1408
1409         BT_INFO("+");
1410
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);
1414
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));
1421 }
1422
1423 static void cb_gattc_scan_result(bt_bdaddr_t* bdaddress, int rssi, uint8_t *adv_data)
1424 {
1425         event_ble_scan_result_info *event;
1426
1427         event = g_new0(event_ble_scan_result_info, 1);
1428         event->rssi = rssi;
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);
1433 }
1434
1435 static void cb_gattc_connection(int conn_id, int status, int client_if, bt_bdaddr_t* bda)
1436 {
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);
1440
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;
1444
1445         if (BT_STATUS_SUCCESS != status) {
1446                 event->status = OAL_STATUS_INTERNAL_ERROR;
1447                 BT_ERR("gattc connection Error: %d", status);
1448         } else {
1449                 event->conn_id = conn_id;
1450                 event->status = OAL_STATUS_SUCCESS;
1451         }
1452
1453         send_event_bda_trace(OAL_EVENT_GATTC_CONNECTION_COMPLETED, event,
1454                                         sizeof(*event), (bt_address_t *)bda);
1455 }
1456
1457
1458 static void cb_gattc_disconnect(int conn_id, int status, int client_if, bt_bdaddr_t* bda)
1459 {
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);
1470 }
1471
1472 static void cb_gattc_search_result(int conn_id, btgatt_srvc_id_t *srvc_id)
1473 {
1474         char uuid_str[2*BT_UUID_STRING_MAX];
1475
1476         BT_INFO("BTGATT Client Service Search Result cb, conn_id:%d", conn_id);
1477
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");
1481
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));
1486
1487         send_event(OAL_EVENT_GATTC_SERVICE_SEARCH_RESULT, event, sizeof(*event));
1488 }
1489
1490 static void cb_gattc_search_complete(int conn_id, int status)
1491 {
1492         BT_INFO("BTGATT Client Service Search Complete cb, status:%d, conn_id:%d",
1493         status, conn_id);
1494
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);
1498
1499         send_event(OAL_EVENT_GATTC_SERVICE_SEARCH_DONE, event, sizeof(*event));
1500 }
1501
1502
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)
1505 {
1506         char uuid_str1[2*BT_UUID_STRING_MAX];
1507         char uuid_str2[2*BT_UUID_STRING_MAX];
1508         char str[50];
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");
1513
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));
1518
1519         if (status == 0) {
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));
1525         }
1526         send_event(OAL_EVENT_GATTC_CHARAC_SERACH_RESULT, event, sizeof(*event));
1527 }
1528
1529
1530
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)
1532 {
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);
1542
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));
1548
1549         if (status == 0) {
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));
1553         }
1554         send_event(OAL_EVENT_GATTC_DESC_SERACH_RESULT, event, sizeof(*event));
1555 }
1556
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)
1558 {
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);
1567
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));
1574
1575         send_event(event_type, event, sizeof(*event));
1576 }
1577
1578 static void cb_gattc_notify(int conn_id, btgatt_notify_params_t *p_data)
1579 {
1580         bdstr_t bdstr;
1581         char uuid_str1[2*BT_UUID_STRING_MAX];
1582         char uuid_str2[2*BT_UUID_STRING_MAX];
1583
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);
1587
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);
1590
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);
1594
1595         if (p_data->len > 0) {
1596                 char *data = NULL;
1597                 data = g_malloc(3*p_data->len+1);
1598                 if (!data) {
1599                         BT_ERR("memory allocation failed");
1600                         return;
1601                 }
1602
1603                 convert_hex_2_str((unsigned char *)p_data->value, p_data->len, data);
1604                 BT_INFO("Notified Data: [%s]", data);
1605
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));
1613
1614                 send_event_bda_trace(OAL_EVENT_GATTC_NOTIFY_DATA, event, sizeof(*event), (bt_address_t *)&p_data->bda);
1615                 g_free(data);
1616         }
1617 }
1618
1619
1620 static void cb_gattc_read_characteristic(int conn_id, int status, btgatt_read_params_t *p_data)
1621 {
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);
1625
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));
1632         if (status == 0) {
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) {
1640                         char *data = NULL;
1641                         data = g_malloc(3*p_data->value.len+1);
1642                         if (!data) {
1643                                 BT_ERR("memory allocation failed");
1644                                 g_free(event);
1645                                 return;
1646                         }
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);
1651                         g_free(data);
1652                 }
1653         }
1654         send_event(OAL_EVENT_GATTC_READ_CHARAC, event, sizeof(*event));
1655 }
1656
1657 static void cb_gattc_write_characteristic(int conn_id, int status, btgatt_write_params_t *p_data)
1658 {
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);
1662
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));
1668         if (status == 0) {
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);
1674         }
1675         send_event(OAL_EVENT_GATTC_WRITE_CHARAC, event, sizeof(*event));
1676 }
1677
1678 static void cb_gattc_write_descriptor(int conn_id, int status, btgatt_write_params_t *p_data)
1679 {
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);
1684
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));
1691         if (status == 0) {
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);
1699         }
1700         send_event(OAL_EVENT_GATTC_WRITE_DESCR, event, sizeof(*event));
1701 }
1702
1703
1704
1705 static void cb_gattc_read_descriptor(int conn_id, int status, btgatt_read_params_t *p_data)
1706 {
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);
1711
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));
1719
1720         if (status == 0) {
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) {
1730                         char *data = NULL;
1731                         data = g_malloc(3*p_data->value.len+1);
1732                         if (!data) {
1733                                 BT_ERR("memory allocation failed");
1734                                 g_free(event);
1735                                 return;
1736                         }
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);
1741                         g_free(data);
1742                 }
1743         }
1744         send_event(OAL_EVENT_GATTC_READ_DESCR, event, sizeof(*event));
1745 }
1746
1747 oal_status_t gattc_start_le_discovery(int client_id)
1748 {
1749
1750         int ret = OAL_STATUS_SUCCESS;
1751
1752         API_TRACE("BTGATT CLIENT SCAN START");
1753         CHECK_OAL_GATT_ENABLED();
1754         CHECK_CLIENT_REGISTRATION(client_id);
1755
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);
1760         }
1761         return OAL_STATUS_SUCCESS;
1762 }
1763
1764 oal_status_t gattc_stop_le_discovery(int client_id)
1765 {
1766
1767         int ret = OAL_STATUS_SUCCESS;
1768
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);
1776         }
1777         return OAL_STATUS_SUCCESS;
1778 }
1779
1780 oal_status_t gattc_set_le_scan_param(int scan_type, int itv, int win)
1781 {
1782         int ret;
1783
1784         API_TRACE("Scan is stopped");
1785         CHECK_OAL_GATT_ENABLED();
1786
1787 #ifdef TIZEN_BT_HAL
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);
1792         }
1793 #else
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);
1798         }
1799 #endif
1800
1801         return OAL_STATUS_SUCCESS;
1802 }
1803 /************************************ GATT Client ***********************************/
1804 oal_status_t gattc_register(oal_uuid_t* client_uuid)
1805 {
1806
1807         char str[2*BT_UUID_STRING_MAX];
1808         int ret = OAL_STATUS_SUCCESS;
1809
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);
1818         }
1819         return OAL_STATUS_SUCCESS;
1820 }
1821
1822 oal_status_t gattc_deregister(int client_id)
1823 {
1824         int ret = OAL_STATUS_SUCCESS;
1825
1826         API_TRACE("GATT client deregister");
1827         CHECK_OAL_GATT_ENABLED();
1828         CHECK_CLIENT_REGISTRATION(client_id);
1829
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);
1834         }
1835
1836         return OAL_STATUS_SUCCESS;
1837 }
1838
1839 oal_status_t gattc_connect(int client_id, bt_address_t *device_address, int isDirect)
1840 {
1841         int ret = OAL_STATUS_SUCCESS;
1842         bdstr_t bdstr;
1843
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);
1848
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);
1854         }
1855         return OAL_STATUS_SUCCESS;
1856 }
1857
1858 oal_status_t gattc_disconnect(int client_id, bt_address_t *device_address, int conn_id)
1859 {
1860
1861         int ret = OAL_STATUS_SUCCESS;
1862         bdstr_t bdstr;
1863
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);
1869
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);
1875         }
1876         return OAL_STATUS_SUCCESS;
1877 }
1878
1879
1880 oal_status_t gattc_search_service(int conn_id, oal_uuid_t *service_uuid)
1881 {
1882         int ret = OAL_STATUS_SUCCESS;
1883         char uuid_str[2*BT_UUID_STRING_MAX];
1884
1885         if (service_uuid) {
1886                 uuid_to_stringname(service_uuid, uuid_str);
1887                 API_TRACE("Client Service Search UUID: [%s]", uuid_str);
1888         } else
1889                 API_TRACE("Client Service Search All");
1890
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);
1894
1895         if (ret != BT_STATUS_SUCCESS) {
1896                 BT_ERR("GATT client service search failed: %s", status2string(ret));
1897                 return convert_to_oal_status(ret);
1898         }
1899         return OAL_STATUS_SUCCESS;
1900 }
1901
1902 oal_status_t gattc_get_characteristic(int conn_id, oal_gatt_srvc_id_t *srvc_id, oal_gatt_id_t *char_id)
1903 {
1904         int ret = OAL_STATUS_SUCCESS;
1905         char uuid_str[2*BT_UUID_STRING_MAX];
1906
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);
1917         }
1918         return OAL_STATUS_SUCCESS;
1919 }
1920
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)
1923 {
1924         int ret = OAL_STATUS_SUCCESS;
1925         char uuid_str1[2*BT_UUID_STRING_MAX];
1926         char uuid_str2[2*BT_UUID_STRING_MAX];
1927
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);
1940         }
1941         return OAL_STATUS_SUCCESS;
1942 }
1943
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];
1949         bdstr_t bdstr;
1950
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);
1959
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);
1964         }
1965
1966         return OAL_STATUS_SUCCESS;
1967 }
1968
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];
1974         bdstr_t bdstr;
1975
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);
1984
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);
1989         }
1990
1991         return OAL_STATUS_SUCCESS;
1992 }
1993
1994
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)
1997 {
1998         int ret = OAL_STATUS_SUCCESS;
1999         char uuid_str1[2*BT_UUID_STRING_MAX];
2000         char uuid_str2[2*BT_UUID_STRING_MAX];
2001
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);
2009
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);
2015         }
2016
2017         return OAL_STATUS_SUCCESS;
2018 }
2019
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)
2022 {
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];
2027
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);
2038
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);
2044         }
2045
2046         return OAL_STATUS_SUCCESS;
2047 }
2048
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)
2051 {
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);
2062
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);
2068         }
2069
2070         return OAL_STATUS_SUCCESS;
2071 }
2072
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)
2075 {
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);
2086
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);
2092         }
2093
2094         return OAL_STATUS_SUCCESS;
2095 }
2096
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)
2100 {
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);
2112
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);
2118         }
2119
2120         return OAL_STATUS_SUCCESS;
2121 }
2122
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)
2126 {
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);
2142
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);
2148         }
2149
2150         return OAL_STATUS_SUCCESS;
2151 }
2152
2153 oal_status_t gattc_conn_param_update(bt_address_t * address, int min, int max, int latency, int timeout)
2154 {
2155         int ret;
2156         bdstr_t bdstr;
2157
2158         OAL_CHECK_PARAMETER(address, return);
2159         API_TRACE("Conn Param Update: [%s]", bdt_bd2str(address, &bdstr));
2160         CHECK_OAL_GATT_ENABLED();
2161
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);
2167         }
2168         return OAL_STATUS_SUCCESS;
2169 }
2170
2171 oal_status_t gattc_unregister_scan_filter(int slot_id)
2172 {
2173         int ret;
2174         int client_if = 0;
2175
2176         API_TRACE("");
2177         CHECK_OAL_GATT_ENABLED();
2178
2179         BT_INFO("Remove Scan filter Slot ID is: [%d]", slot_id);
2180
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);
2185         }
2186         return OAL_STATUS_SUCCESS;
2187 }
2188
2189 oal_status_t gattc_enable_scan_filter(int client_if)
2190 {
2191         int ret;
2192
2193         API_TRACE("");
2194         CHECK_OAL_GATT_ENABLED();
2195
2196         BT_INFO("Enable Scan filter. Client If: %d", client_if);
2197
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);
2202         }
2203         return OAL_STATUS_SUCCESS;
2204 }
2205
2206 oal_status_t gattc_disable_scan_filter(int client_if)
2207 {
2208         int ret;
2209
2210         API_TRACE("");
2211         CHECK_OAL_GATT_ENABLED();
2212
2213         BT_INFO("Disable Scan filter. Client If: %d", client_if);
2214
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);
2219         }
2220         return OAL_STATUS_SUCCESS;
2221 }
2222
2223 oal_status_t gattc_register_scan_filter(oal_ble_scan_filter_t* filter_data)
2224 {
2225         int ret;
2226         int client_info = 0;
2227         int action = 0;
2228         int company_id = 0;
2229         int company_id_mask = 0;
2230         int address_type = 0;
2231         int feature_selection = 0;
2232
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,
2237                                                                 .dely_mode = 0,
2238                                                                 .found_timeout = 0,
2239                                                                 .lost_timeout = 0,
2240                                                                 .found_timeout_cnt = 0
2241                                                                 };
2242
2243         OAL_CHECK_PARAMETER(filter_data, return);
2244         API_TRACE();
2245         CHECK_OAL_GATT_ENABLED();
2246
2247         if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS){
2248                 bdstr_t bdstr;
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,
2252                                                                 action,
2253                                                                 OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS,
2254                                                                 filter_data->slot_id,
2255                                                                 company_id,
2256                                                                 company_id_mask,
2257                                                                 NULL,
2258                                                                 NULL,
2259                                                                 (bt_bdaddr_t*)filter_data->device_address,
2260                                                                 address_type,
2261                                                                 0,
2262                                                                 NULL,
2263                                                                 0,
2264                                                                 NULL
2265                                                                 );
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);
2271                 }
2272
2273                 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS;
2274         }
2275         if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_NAME){
2276                 ret = gatt_api->client->scan_filter_add_remove(client_info,
2277                                                                 action,
2278                                                                 OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_NAME,
2279                                                                 filter_data->slot_id,
2280                                                                 company_id,
2281                                                                 company_id_mask,
2282                                                                 NULL,
2283                                                                 NULL,
2284                                                                 NULL,
2285                                                                 address_type,
2286                                                                 0,
2287                                                                 filter_data->device_name,     // device_name as p_data in HAL
2288                                                                 0,
2289                                                                 NULL
2290                                                                 );
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);
2296                 }
2297
2298                 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_NAME;
2299         }
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];
2304
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);
2307
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,
2310                                                                 action,
2311                                                                 OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_UUID,
2312                                                                 filter_data->slot_id,
2313                                                                 company_id,
2314                                                                 company_id_mask,
2315                                                                 (bt_uuid_t*)filter_data->service_uuid,
2316                                                                 (bt_uuid_t*)filter_data->service_uuid_mask,
2317                                                                 NULL,
2318                                                                 address_type,
2319                                                                 filter_data->service_uuid_len,   // service_uuid_len as data_len in HAL
2320                                                                 NULL,
2321                                                                 filter_data->service_uuid_mask_len,
2322                                                                 NULL
2323                                                                 );
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);
2329                 }
2330
2331                 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_UUID;
2332         }
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,
2341                                                                 action,
2342                                                                 OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID,
2343                                                                 filter_data->slot_id,
2344                                                                 company_id,
2345                                                                 company_id_mask,
2346                                                                 (bt_uuid_t*)filter_data->service_solicitation_uuid,
2347                                                                 (bt_uuid_t*)filter_data->service_solicitation_uuid_mask,
2348                                                                 NULL,
2349                                                                 address_type,
2350                                                                 filter_data->service_solicitation_uuid_len,   // service_solicitation_uuid_len as data_len in HAL
2351                                                                 NULL,
2352                                                                 filter_data->service_solicitation_uuid_mask_len,
2353                                                                 NULL
2354                                                                 );
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);
2360                 }
2361
2362                 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID;
2363         }
2364         if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_DATA){
2365                 ret = gatt_api->client->scan_filter_add_remove(client_info,
2366                                                                 action,
2367                                                                 OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_DATA,
2368                                                                 filter_data->slot_id,
2369                                                                 company_id,
2370                                                                 company_id_mask,
2371                                                                 NULL,
2372                                                                 NULL,
2373                                                                 NULL,
2374                                                                 address_type,
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
2379                                                                 );
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);
2385                 }
2386
2387                 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_DATA;
2388         }
2389         if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA){
2390                 ret = gatt_api->client->scan_filter_add_remove(client_info,
2391                                                                 action,
2392                                                                 OAL_BLE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA,
2393                                                                 filter_data->slot_id,
2394                                                                 filter_data->manufacturer_id,
2395                                                                 company_id_mask,
2396                                                                 NULL,
2397                                                                 NULL,
2398                                                                 NULL,
2399                                                                 address_type,
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
2404                                                                 );
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);
2411                 }
2412
2413                 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA;
2414         }
2415
2416         BT_DBG("Filter selection 0x%.2x", feature_selection);
2417
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);
2426         }
2427         return OAL_STATUS_SUCCESS;
2428 }