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 static void cb_gattc_configure_mtu_cmpl(int conn_id, int status, int mtu);
 217
 218 /*TODO GATT CLient callbacks will be implemented in subsequent patches */
 219 static const btgatt_client_callbacks_t btgatt_client_callbacks = {
 220         .register_client_cb = cb_gattc_register_app,
 221         .scan_result_cb = cb_gattc_scan_result,
 222         .open_cb = cb_gattc_connection,
 223         .close_cb = cb_gattc_disconnect,
 224         .search_complete_cb = cb_gattc_search_complete,
 225         .search_result_cb = cb_gattc_search_result,
 226         .get_characteristic_cb = cb_gattc_get_characteristics,
 227         .get_descriptor_cb = cb_gattc_get_descriptor,
 228         .get_included_service_cb = NULL,
 229         .register_for_notification_cb = cb_gattc_register_for_notification,
 230         .notify_cb = cb_gattc_notify,
 231         .read_characteristic_cb = cb_gattc_read_characteristic,
 232         .write_characteristic_cb = cb_gattc_write_characteristic,
 233         .read_descriptor_cb = cb_gattc_read_descriptor,
 234         .write_descriptor_cb = cb_gattc_write_descriptor,
 235         .execute_write_cb = NULL,
 236         .read_remote_rssi_cb = NULL,
 237         .configure_mtu_cb = cb_gattc_configure_mtu_cmpl,
 238 #ifdef PLATFORM_ANDROID_HAL
 239         .scan_filter_cfg_cb = NULL,
 240         .scan_filter_param_cb = NULL,
 241         .scan_filter_status_cb = NULL,
 242         .congestion_cb = NULL,
 243         .batchscan_cfg_storage_cb = NULL,
 244         .batchscan_enb_disable_cb = NULL,
 245         .batchscan_reports_cb = NULL,
 246         .batchscan_threshold_cb = NULL,
 247         .track_adv_event_cb = NULL,
 248 #endif
 249 };
 250
 251 static btgatt_callbacks_t btgatt_callbacks = {
 252         sizeof(btgatt_callbacks_t),
 253         &btgatt_client_callbacks,
 254         &btgatt_server_callbacks
 255 };
 256
 257 /*******************************GATT Initialisation - Deinitialisation********************************/
 258 oal_status_t gatt_enable(void)
 259 {
 260         const bt_interface_t * blued_api;
 261         int ret;
 262         int i = 0;
 263
 264         for (i = 0; i < NUM_SERVER_INST; i++) {
 265                 gatt_servers[i].server_id = -1;
 266                 gatt_servers[i].state = GATT_INS_DISABLED;
 267                 memset(&gatt_servers[i].uuid, 0, sizeof(oal_uuid_t));
 268                 cur_adv_state[i] = FALSE;
 269         }
 270
 271         /* Get stack interface */
 272         blued_api = (const bt_interface_t *) adapter_get_stack_interface();
 273
 274         if (blued_api == NULL) {
 275                 BT_ERR("Stack is not initialized");
 276                 return OAL_STATUS_NOT_READY;
 277         }
 278
 279         if (gatt_api) {
 280                 BT_WARN("GATT Interface is already initialized...");
 281                 return OAL_STATUS_ALREADY_DONE;
 282         }
 283
 284         gatt_api = (const btgatt_interface_t *)blued_api->get_profile_interface(BT_PROFILE_GATT_ID);
 285         if (gatt_api == NULL) {
 286                 BT_ERR("GATT interface failed");
 287                 return OAL_STATUS_INTERNAL_ERROR;
 288         }
 289
 290         if ((ret = gatt_api->init(&btgatt_callbacks)) != BT_STATUS_SUCCESS) {
 291                 BT_ERR("Error: Unable to initialise GATT :%s", status2string(ret));
 292                 gatt_api->cleanup();
 293                 gatt_api = NULL;
 294                 return convert_to_oal_status(ret);
 295         }
 296
 297         BT_INFO("GATT successfully initialized");
 298         return OAL_STATUS_SUCCESS;
 299 }
 300
 301 oal_status_t gatt_disable(void)
 302 {
 303         int i;
 304         if (gatt_api) {
 305                 gatt_api->cleanup();
 306                 gatt_api = NULL;
 307         }
 308
 309         for (i = 0; i < NUM_SERVER_INST; i++) {
 310                 gatt_servers[i].server_id = -1;
 311                 gatt_servers[i].state = GATT_INS_DISABLED;
 312                 memset(&gatt_servers[i].uuid, 0, sizeof(oal_uuid_t));
 313         }
 314         return OAL_STATUS_SUCCESS;
 315 }
 316
 317 /************************************GATT Server Functions*************************************/
 318 /*Public */
 319 oal_status_t gatts_register(oal_uuid_t* server_uuid)
 320 {
 321         char str[2*BT_UUID_STRING_MAX];
 322         int ret = OAL_STATUS_SUCCESS;
 323         int i;
 324
 325         CHECK_OAL_GATT_ENABLED();
 326         uuid_to_stringname((service_uuid_t*)server_uuid->uuid, str);
 327         API_TRACE("Register the server instance: UUID: [%s]", str);
 328
 329         for (i = 0; i < NUM_SERVER_INST; i++) {
 330                 if (memcmp(server_uuid->uuid, gatt_servers[i].uuid.uuid, sizeof(oal_uuid_t)) == 0) {
 331                         if (gatt_servers[i].server_id != -1) {
 332                                 BT_ERR("This is resevered UUID for easy set up application i = %d \
 333                                                 gatt_servers[i].server_id = %d", i, gatt_servers[i].server_id);
 334                                 return OAL_STATUS_ALREADY_DONE;
 335                         }
 336                 }
 337         }
 338
 339         ret = gatt_api->server->register_server((bt_uuid_t*)server_uuid);
 340
 341         if (ret != BT_STATUS_SUCCESS) {
 342                 BT_ERR("GATT server registration with UUID:%s failed: %s", str, status2string(ret));
 343                 return convert_to_oal_status(ret);
 344         }
 345         return OAL_STATUS_SUCCESS;
 346 }
 347
 348 oal_status_t gatts_unregister(int instance_id)
 349 {
 350         int ret = OAL_STATUS_SUCCESS;
 351         API_TRACE("Unregister the registered server, instance_id: %d", instance_id);
 352
 353         CHECK_OAL_GATT_ENABLED();
 354         CHECK_SERVER_INSTANCE(instance_id);
 355         CHECK_SERVER_REGISTRATION(instance_id);
 356
 357         ret = gatt_api->server->unregister_server(gatt_servers[instance_id - 1].server_id);
 358
 359         if (ret != BT_STATUS_SUCCESS) {
 360                 BT_ERR("GATT server unregistration failed: %d", instance_id);
 361                 return convert_to_oal_status(ret);
 362         }
 363
 364         gatt_servers[instance_id-1].server_id = -1;
 365         gatt_servers[instance_id-1].state = GATT_INS_DISABLED;
 366
 367         if (instance_id != 1 && instance_id != 2)
 368                 memset(&gatt_servers[instance_id-1].uuid, 0, sizeof(oal_uuid_t));
 369
 370         return OAL_STATUS_SUCCESS;
 371 }
 372
 373 /* Legacy Advertisement */
 374 oal_status_t gatts_start_listen(int instance_id, gboolean enable)
 375 {
 376         int ret = OAL_STATUS_SUCCESS;
 377         API_TRACE("server-id:%d enable: %d", gatt_servers[instance_id-1].server_id, enable);
 378
 379         CHECK_OAL_GATT_ENABLED();
 380         CHECK_SERVER_INSTANCE(instance_id);
 381         CHECK_SERVER_REGISTRATION(instance_id);
 382
 383         ret = gatt_api->server->listen(gatt_servers[instance_id-1].server_id, enable);
 384
 385         if (ret != BT_STATUS_SUCCESS) {
 386                 BT_ERR("Error:Advertising start/stop on server-id:%d failed With Status: [%s]",
 387                                 gatt_servers[instance_id-1].server_id, status2string(ret));
 388                 return convert_to_oal_status(ret);
 389         }
 390
 391         return OAL_STATUS_SUCCESS;
 392 }
 393
 394 oal_status_t gatts_stop_advertising(int instance_id)
 395 {
 396         int ret = OAL_STATUS_SUCCESS;
 397         API_TRACE("Stop advertising");
 398
 399         CHECK_OAL_GATT_ENABLED();
 400         CHECK_SERVER_INSTANCE(instance_id);
 401         CHECK_SERVER_REGISTRATION(instance_id);
 402
 403         ret = gatt_api->server->listen(gatt_servers[instance_id - 1].server_id, FALSE);
 404
 405         if (ret != BT_STATUS_SUCCESS) {
 406                 BT_ERR("Stop Advertising failed for server Instance:%d With Status: %s",
 407                         instance_id, status2string(ret));
 408                 return convert_to_oal_status(ret);
 409         }
 410         return OAL_STATUS_SUCCESS;
 411 }
 412
 413 #if 0
 414 /* Below API's need to be removed as they are hardcoded API's.
 415    If at all, product specific API's are required to set specific data, then new naming should
 416    be adopted for these API's */
 417 oal_status_t gatts_set_advertising_params(int instance_id, float min_intv, float max_intv)
 418 {
 419         int ret = OAL_STATUS_SUCCESS;
 420
 421         API_TRACE("Set advertising params min_int:%f, max_int:%f", min_intv, max_intv);
 422         CHECK_OAL_GATT_ENABLED();
 423         CHECK_SERVER_INSTANCE(instance_id);
 424         CHECK_SERVER_REGISTRATION(instance_id);
 425
 426         /* Historically used for Legacy Advertising */
 427         return OAL_STATUS_NOT_SUPPORT;
 428 }
 429
 430 oal_status_t gatts_set_advertising_data(int instance_id, uint16_t manufac_len, char* manufac_data)
 431 {
 432         int ret = OAL_STATUS_SUCCESS;
 433
 434         API_TRACE("Set advertising data");
 435         CHECK_OAL_GATT_ENABLED();
 436         CHECK_SERVER_INSTANCE(instance_id);
 437         CHECK_SERVER_REGISTRATION(instance_id);
 438
 439         /* Historically used for Legacy Advertising */
 440         return OAL_STATUS_NOT_SUPPORT;
 441 }
 442
 443 oal_status_t gatts_set_scan_response(int instance_id, uint16_t manufac_len, char* manufac_data)
 444 {
 445         int ret = OAL_STATUS_SUCCESS;
 446
 447         API_TRACE("Set Scan Response data");
 448         CHECK_OAL_GATT_ENABLED();
 449         CHECK_SERVER_INSTANCE(instance_id);
 450         CHECK_SERVER_REGISTRATION(instance_id);
 451
 452         /* Historically used for Legacy Advertising */
 453         return OAL_STATUS_NOT_SUPPORT;
 454 }
 455 #endif
 456
 457 oal_status_t gatts_multi_adv_enable(int instance_id)
 458 {
 459         int ret = OAL_STATUS_SUCCESS;
 460         API_TRACE("Start Multi advertising, srv_if: %d, instance_id: %d",
 461                         gatt_servers[instance_id - 1].server_id, instance_id);
 462
 463         CHECK_OAL_GATT_ENABLED();
 464         CHECK_SERVER_INSTANCE(instance_id);
 465         CHECK_SERVER_REGISTRATION(instance_id);
 466
 467         if (gatt_api->server->multi_adv_enable == NULL)
 468                 return OAL_STATUS_NOT_SUPPORT;
 469
 470 /* Platform Requirement: Advertising to be enabled even when no data is set: i.e Empty Advertisement
 471         if (gatt_servers[instance_id - 1].state != GATT_INS_DATA_SET){
 472                 BT_ERR("Not allowed, state: %d, instance_id: %d",
 473                                 gatt_servers[instance_id - 1].state, instance_id);
 474                 return OAL_STATUS_BUSY;
 475         }
 476 */
 477         if (gatt_servers[instance_id - 1].state == GATT_INS_ENABLED) {
 478                 BT_ERR("Not allowed, state: %d, instance_id: %d",
 479                                 gatt_servers[instance_id - 1].state, instance_id);
 480                 return OAL_STATUS_ALREADY_DONE;
 481         }
 482
 483         if (gatt_servers[instance_id - 1].state == GATT_INS_ENABLING) {
 484                 BT_ERR("Not allowed, state: %d, instance_id: %d",
 485                                 gatt_servers[instance_id - 1].state, instance_id);
 486                 return OAL_STATUS_BUSY;
 487         }
 488
 489         gatt_servers[instance_id - 1].state = GATT_INS_ENABLING;
 490
 491         ret = gatt_api->server->multi_adv_enable(gatt_servers[instance_id - 1].server_id);
 492
 493         if (ret != BT_STATUS_SUCCESS) {
 494                 BT_ERR("GATT enable multi advertising failed for server Instance: %d With Status: %s",
 495                                 instance_id, status2string(ret));
 496 //              gatt_servers[instance_id - 1].state = GATT_INS_DATA_SET;
 497                 return convert_to_oal_status(ret);
 498         }
 499         return OAL_STATUS_SUCCESS;
 500 }
 501
 502 oal_status_t gatts_multi_adv_disable(int instance_id)
 503 {
 504         int ret = OAL_STATUS_SUCCESS;
 505         API_TRACE("Stop Multi advertising, srv_if: %d, instance_id: %d",
 506                         gatt_servers[instance_id - 1].server_id, instance_id);
 507
 508         CHECK_OAL_GATT_ENABLED();
 509         CHECK_SERVER_INSTANCE(instance_id);
 510         CHECK_SERVER_REGISTRATION(instance_id);
 511
 512         if (gatt_api->server->multi_adv_disable == NULL)
 513                 return OAL_STATUS_NOT_SUPPORT;
 514
 515         if ((gatt_servers[instance_id - 1].state != GATT_INS_ENABLED)) {
 516                 BT_ERR("Not Allowed, state: %d, instance_id: %d",
 517                         gatt_servers[instance_id - 1].state, instance_id);
 518                 return OAL_STATUS_BUSY;
 519         }
 520
 521         ret = gatt_api->server->multi_adv_disable(gatt_servers[instance_id - 1].server_id);
 522
 523         if (ret != BT_STATUS_SUCCESS) {
 524                 BT_ERR("GATT disable multi advertising failed for server Instance: %d With Status: %s",
 525                                 instance_id, status2string(ret));
 526                 return convert_to_oal_status(ret);
 527         }
 528         return OAL_STATUS_SUCCESS;
 529 }
 530
 531 oal_status_t gatts_set_filter_policy(int filter_policy)
 532 {
 533         int ret = OAL_STATUS_SUCCESS;
 534
 535         CHECK_OAL_GATT_ENABLED();
 536
 537         /* send the filter_policy value to the HAL Layer */
 538         ret = gatt_api->server->set_filter_policy(filter_policy);
 539
 540         if (ret != BT_STATUS_SUCCESS) {
 541                 BT_ERR("set_filter_policy failed: %d",ret);
 542                 return convert_to_oal_status(ret);
 543         }
 544
 545         return OAL_STATUS_SUCCESS;
 546 }
 547
 548 oal_status_t gatts_multi_adv_update(int instance_id,
 549                 int min_intv, int max_intv,
 550                 int adv_type, int chnl_map,
 551                 int tx_power, int timeout_s)
 552 {
 553         int ret = OAL_STATUS_SUCCESS;
 554         API_TRACE("Multi advertising Update");
 555
 556         CHECK_OAL_GATT_ENABLED();
 557         CHECK_SERVER_INSTANCE(instance_id);
 558         CHECK_SERVER_REGISTRATION(instance_id);
 559
 560         if (gatt_api->server->multi_adv_update == NULL)
 561                 return OAL_STATUS_NOT_SUPPORT;
 562
 563         ret = gatt_api->server->multi_adv_update(gatt_servers[instance_id - 1].server_id,
 564                         min_intv, max_intv,
 565                         adv_type, chnl_map,
 566                         tx_power, timeout_s);
 567
 568         if (ret != BT_STATUS_SUCCESS) {
 569                 BT_ERR("GATT update multi advertising failed for server Instance: %d With Status: %s",
 570                                 instance_id, status2string(ret));
 571                 return convert_to_oal_status(ret);
 572         }
 573         return OAL_STATUS_SUCCESS;
 574 }
 575
 576 oal_status_t gatts_multi_adv_set_inst_data(int instance_id,
 577                 oal_ble_multi_adv_param_setup_t *adv_param_setup)
 578 {
 579         int ret = OAL_STATUS_SUCCESS;
 580         btgatt_adv_param_setup_t adv_setup;
 581         API_TRACE("Set Multi advertising data, srv_if: %d, instance_id: %d",
 582                         gatt_servers[instance_id - 1].server_id, instance_id);
 583
 584         CHECK_OAL_GATT_ENABLED();
 585         CHECK_SERVER_INSTANCE(instance_id);
 586         CHECK_SERVER_REGISTRATION(instance_id);
 587
 588         if (gatt_api->server->multi_adv_set_inst_data == NULL)
 589                 return OAL_STATUS_NOT_SUPPORT;
 590
 591         if ((gatt_servers[instance_id - 1].state >= GATT_INS_DATA_SETTING) && (gatt_servers[instance_id - 1].state != GATT_INS_DATA_SET)) {
 592                 BT_ERR("Not Allowed, state: %d, instance_id: %d", gatt_servers[instance_id - 1].state, instance_id);
 593                 return OAL_STATUS_BUSY;
 594         }
 595
 596         gatt_servers[instance_id - 1].state = GATT_INS_DATA_SETTING;
 597
 598
 599         adv_setup.set_scan_rsp = adv_param_setup->set_scan_rsp;
 600         adv_setup.include_name = adv_param_setup->include_name;
 601         adv_setup.include_txpower = adv_param_setup->include_txpower;
 602         adv_setup.appearance = adv_param_setup->appearance;
 603         adv_setup.manufacturer_data = adv_param_setup->manufacturer_data;
 604         adv_setup.manufacturer_data_len = adv_param_setup->manufacturer_data_len;
 605         adv_setup.service_data = adv_param_setup->service_data;
 606         adv_setup.service_data_len = adv_param_setup->service_data_len;
 607         adv_setup.service_uuid = adv_param_setup->service_uuid;
 608         adv_setup.service_uuid_len = adv_param_setup->service_uuid_len;
 609         /* Solicit UUID handler: Start */
 610         adv_setup.solicit_uuid = adv_param_setup->solicit_uuid;
 611         adv_setup.solicit_uuid_len = adv_param_setup->solicit_uuid_len;
 612         /* Solicit UUID handler: End */
 613         adv_setup.min_interval = adv_param_setup->min_interval;
 614         adv_setup.max_interval = adv_param_setup->min_interval;
 615         adv_setup.adv_type = adv_param_setup->adv_type;
 616         adv_setup.chnl_map = adv_param_setup->chnl_map;
 617         adv_setup.tx_power = adv_param_setup->tx_power;
 618         adv_setup.timeout_s = adv_param_setup->timeout_s;
 619
 620         adv_setup.server_if = gatt_servers[instance_id - 1].server_id;
 621         if (adv_setup.manufacturer_data_len > 0 && adv_setup.manufacturer_data != NULL) {
 622                 BT_INFO("Manufacture data.....\n");
 623                 PRINT_ADV_DATA(adv_setup.manufacturer_data_len, (unsigned char *)adv_setup.manufacturer_data, adv_setup.set_scan_rsp);
 624         }
 625
 626         if (adv_setup.service_uuid_len > 0 && adv_setup.service_uuid != NULL) {
 627                 BT_INFO("Service uuid.....\n");
 628                 PRINT_ADV_DATA(adv_setup.service_uuid_len, (unsigned char*)adv_setup.service_uuid, FALSE);
 629         }
 630
 631
 632         ret = gatt_api->server->multi_adv_set_inst_data(adv_setup);
 633
 634         if (ret != BT_STATUS_SUCCESS) {
 635                 BT_ERR("GATT Set Multi advertising data failed: %s", status2string(ret));
 636                 gatt_servers[instance_id - 1].state = GATT_INS_DISABLED;
 637                 return convert_to_oal_status(ret);
 638         }
 639         return OAL_STATUS_SUCCESS;
 640 }
 641
 642 oal_status_t gatts_disconnect(int instance_id, bt_address_t *device_address, int conn_id)
 643 {
 644         int ret = OAL_STATUS_SUCCESS;
 645         bdstr_t bdstr;
 646
 647         API_TRACE("Server Disonnect: instance_id = %d, conn_id = %d", instance_id, conn_id);
 648
 649         CHECK_OAL_GATT_ENABLED();
 650         CHECK_SERVER_INSTANCE(instance_id);
 651         CHECK_SERVER_REGISTRATION(instance_id);
 652
 653         API_TRACE("[%s]", bdt_bd2str(device_address, &bdstr));
 654
 655         ret = gatt_api->server->disconnect(gatt_servers[instance_id - 1].server_id, (bt_bdaddr_t *) device_address, conn_id);
 656         if (ret != BT_STATUS_SUCCESS) {
 657                 BT_ERR("GATT Server disconnect failed: %s", status2string(ret));
 658                 return convert_to_oal_status(ret);
 659         }
 660         return OAL_STATUS_SUCCESS;
 661 }
 662
 663
 664 /************************************GATT Server Functions*************************************/
 665 /*Server Callbacks*/
 666 static void cb_gatts_register_app(int status, int server_if, bt_uuid_t *uuid)
 667 {
 668         int i;
 669         char str[2*BT_UUID_STRING_MAX];
 670         uuid_to_stringname((service_uuid_t*)uuid, str);
 671
 672         event_gatts_register_t *event = g_malloc0(sizeof(event_gatts_register_t));
 673
 674         BT_INFO("BTGATT SERVER REGISTER APP CB, status:%d, server_if:%d", status, server_if);
 675         BT_INFO("UUID: [%s]", str);
 676
 677         for (i = 0; i < NUM_SERVER_INST; i++) {
 678                 if (gatt_servers[i].server_id == -1) {
 679                         BT_INFO("Server Instance registered with stack [%d]", i+1);
 680                         gatt_servers[i].server_id = server_if;
 681                         event->server_inst = i+1;
 682                         memcpy(gatt_servers[i].uuid.uuid, uuid->uu, sizeof(bt_uuid_t));
 683                         memcpy(event->server_uuid.uuid, uuid->uu, sizeof(bt_uuid_t));
 684                         break;
 685                 }
 686         }
 687         send_event(OAL_EVENT_BLE_SERVER_INSTANCE_INITIALISED, event, sizeof(event_gatts_register_t));
 688 }
 689
 690 static void cb_gatts_listen(int status, int server_if)
 691 {
 692         gboolean prev_state[NUM_SERVER_INST];
 693         gboolean new_state;
 694         event_ble_adv_status *event = g_malloc0(sizeof(event_ble_adv_status));
 695         int instance_id;
 696
 697         for (instance_id = 1 ; instance_id <= NUM_SERVER_INST ; instance_id++) {
 698                 if (gatt_servers[instance_id - 1].server_id == server_if) {
 699                         event->server_inst = instance_id;
 700                         break;
 701                 } else {
 702                         BT_WARN("Server ID:%d recevied server Id:%d\n", gatt_servers[instance_id - 1].server_id, server_if);
 703                 }
 704         }
 705         if ((event->server_inst > 0) && (event->server_inst <= 10)) {
 706                 prev_state[event->server_inst - 1] = cur_adv_state[event->server_inst - 1];
 707                 new_state = (status == BT_STATUS_SUCCESS) ? !(prev_state[event->server_inst - 1]) : (prev_state[event->server_inst - 1]);
 708                 cur_adv_state[event->server_inst - 1] = new_state;
 709         } else {
 710                 BT_ERR("Invalid Callback...");
 711                 g_free(event);
 712                 return;
 713         }
 714
 715         BT_INFO("Adv State of server instance %d :%d", instance_id, new_state);
 716
 717         if (TRUE == new_state)
 718                 send_event(OAL_EVENT_BLE_ADVERTISING_STARTED, event, sizeof(event_ble_adv_status));
 719         else
 720                 send_event(OAL_EVENT_BLE_ADVERTISING_STOPPED, event, sizeof(event_ble_adv_status));
 721 }
 722
 723 static void cb_gatts_multi_adv_enable(int server_if, int status)
 724 {
 725
 726         BT_INFO("BTGATT SERVER MULTI ADV ENABLE CB, status:%d, srv_if: %d", status, server_if);
 727         event_ble_multiadv_status *event = g_malloc0(sizeof(event_ble_multiadv_status));
 728         int instance_id;
 729
 730         if (status != BT_STATUS_SUCCESS)
 731                 BT_ERR("MULTI ADV ENABLE failed, status:%d, srv_if: %d", status, server_if);
 732
 733         for (instance_id = 1 ; instance_id <= NUM_SERVER_INST ; instance_id++) {
 734                 if (gatt_servers[instance_id - 1].server_id == server_if) {
 735                         event->server_inst = instance_id;
 736                         gatt_servers[instance_id - 1].state = GATT_INS_ENABLED;
 737                         goto sendevent;
 738                 }
 739         }
 740         BT_ERR("Invalid Interface, srv_if: %d", server_if);
 741         event->server_inst = -1;
 742 sendevent:
 743         event->status = convert_to_oal_status(status);
 744         send_event(OAL_EVENT_BLE_MULTI_ADVERTISING_ENABLE, event, sizeof(event_ble_multiadv_status));
 745 }
 746
 747 static void cb_gatts_multi_adv_disable(int server_if, int status)
 748 {
 749         BT_INFO("BTGATT SERVER MULTI ADV DISABLE CB, status:%d, srv_if: %d", status, server_if);
 750         event_ble_multiadv_status *event = g_malloc0(sizeof(event_ble_multiadv_status));
 751         int instance_id;
 752
 753         if (status != BT_STATUS_SUCCESS)
 754                 BT_ERR("MULTI ADV DISABLE failed, status:%d, srv_if: %d", status, server_if);
 755
 756         for (instance_id = 1 ; instance_id <= NUM_SERVER_INST; instance_id++) {
 757                 if (gatt_servers[instance_id - 1].server_id == server_if) {
 758                         event->server_inst = instance_id;
 759                         gatt_servers[instance_id - 1].state = GATT_INS_DISABLED;
 760                         goto sendevent;
 761                 }
 762         }
 763         BT_ERR("Invalid Interface, srv_if: %d", server_if);
 764         event->server_inst = -1;
 765 sendevent:
 766         event->status = convert_to_oal_status(status);
 767         send_event(OAL_EVENT_BLE_MULTI_ADVERTISING_DISABLE, event, sizeof(event_ble_multiadv_status));
 768 }
 769
 770 static void cb_gatts_multi_adv_update(int server_if, int status)
 771 {
 772         BT_INFO("BTGATT SERVER MULTI ADV UPDATE CB, status:%d, srv_if: %d", status, server_if);
 773         event_ble_multiadv_status *event = g_malloc0(sizeof(event_ble_multiadv_status));
 774         int instance_id;
 775
 776         if (status != BT_STATUS_SUCCESS)
 777                 BT_ERR("MULTI ADV UPDATE failed, status:%d, srv_if: %d", status, server_if);
 778
 779         for (instance_id = 1 ; instance_id <= NUM_SERVER_INST ; instance_id++) {
 780                 if (gatt_servers[instance_id - 1].server_id == server_if) {
 781                         event->server_inst = instance_id;
 782                         goto sendevent;
 783                 }
 784         }
 785         BT_ERR("Invalid Interface, srv_if: %d", server_if);
 786         event->server_inst = -1;
 787 sendevent:
 788         event->status = convert_to_oal_status(status);
 789         send_event(OAL_EVENT_BLE_MULTI_ADVERTISING_UPDATE, event, sizeof(event_ble_multiadv_status));
 790 }
 791
 792 static void cb_gatts_multi_adv_set_inst_data(int server_if, int status)
 793 {
 794         BT_INFO("BTGATT SERVER MULTI ADV SET INST DATA CB, status:%d, srv_if: %d", status, server_if);
 795         event_ble_multiadv_status *event = g_malloc0(sizeof(event_ble_multiadv_status));
 796         int instance_id;
 797
 798         if (status != BT_STATUS_SUCCESS)
 799                 BT_ERR("MULTI ADV SET DATA failed, status:%d, srv_if: %d", status, server_if);
 800
 801         for (instance_id = 1 ; instance_id <= NUM_SERVER_INST ; instance_id++) {
 802                 if (gatt_servers[instance_id - 1].server_id == server_if) {
 803                         event->server_inst = instance_id;
 804                         gatt_servers[instance_id - 1].state = GATT_INS_DATA_SET;
 805                         goto sendevent;
 806                 }
 807         }
 808         BT_ERR("Invalid Interface, srv_if: %d", server_if);
 809         event->server_inst = -1;
 810 sendevent:
 811         event->status = convert_to_oal_status(status);
 812         send_event(OAL_EVENT_BLE_MULTI_ADVERTISING_SET_INST_DATA, event, sizeof(event_ble_multiadv_status));
 813 }
 814
 815 oal_status_t gatts_get_att_mtu(int conn_id, int *mtu)
 816 {
 817         int ret = OAL_STATUS_SUCCESS;
 818         API_TRACE("Get ATT MTU, conn_id: %d", conn_id);
 819         CHECK_OAL_GATT_ENABLED();
 820         OAL_CHECK_PARAMETER(mtu, return);
 821
 822         /* To prevent crash in case other libraries not support this api */
 823         if (gatt_api->server->get_att_mtu == NULL) {
 824                 BT_WARN("get_att_mtu is NULL");
 825                 return OAL_STATUS_NOT_SUPPORT;
 826         }
 827
 828         ret = gatt_api->server->get_att_mtu(conn_id, mtu);
 829         if (ret != BT_STATUS_SUCCESS) {
 830                 BT_ERR("GATT MTU Size failed, status: %s", status2string(ret));
 831                 return convert_to_oal_status(ret);
 832         }
 833
 834         BT_INFO("Current ATT MTU Size: %d", *mtu);
 835         return OAL_STATUS_SUCCESS;
 836 }
 837 oal_status_t gatt_send_response_acquire(int conn_id, int trans_id,
 838                 int status, int fd, int mtu , void * fdlist)
 839 {
 840         int ret = OAL_STATUS_SUCCESS;
 841
 842         API_TRACE("Server Send Response : ConnId = %d, TransId = %d,  %d", conn_id, trans_id, fd);
 843         CHECK_OAL_GATT_ENABLED();
 844
 845         ret = gatt_api->server->send_response_acquire(conn_id, trans_id, status, fd, mtu, fdlist);
 846         if (ret != BT_STATUS_SUCCESS) {
 847                 BT_ERR("GATT Server Send Response failed: %s", status2string(ret));
 848                 return convert_to_oal_status(ret);
 849         }
 850         return OAL_STATUS_SUCCESS;
 851
 852 }
 853 oal_status_t gatts_add_service(int instance_id, oal_gatt_srvc_id_t *gatt_serv_id,
 854                 int num_handles)
 855 {
 856         int ret = OAL_STATUS_SUCCESS;
 857         btgatt_srvc_id_t btgatt_srvc_id;
 858         char str[2*BT_UUID_STRING_MAX];
 859
 860         API_TRACE("Server Add Service : instance_id = %d, num_handles = %d", instance_id, num_handles);
 861         CHECK_OAL_GATT_ENABLED();
 862
 863         CHECK_SERVER_INSTANCE(instance_id);
 864         CHECK_SERVER_REGISTRATION(instance_id);
 865
 866         if (gatt_serv_id != NULL) {
 867                 uuid_to_stringname(&(gatt_serv_id->id.uuid), str);
 868                 API_TRACE("Service uuid: [%s]", str);
 869                 memcpy(btgatt_srvc_id.id.uuid.uu,  gatt_serv_id->id.uuid.uuid, sizeof(gatt_serv_id->id.uuid));
 870                 btgatt_srvc_id.id.inst_id  = gatt_serv_id->id.inst_id;
 871                 btgatt_srvc_id.is_primary = gatt_serv_id->is_prmry;
 872         } else {
 873                 BT_INFO("GATT Server Service Id is NULL");
 874                 return OAL_STATUS_INVALID_PARAM;
 875         }
 876
 877         ret = gatt_api->server->add_service(gatt_servers[instance_id - 1].server_id, &btgatt_srvc_id, num_handles);
 878
 879         if (ret != BT_STATUS_SUCCESS) {
 880                 BT_ERR("GATT Server add service failed: %s", status2string(ret));
 881                 return convert_to_oal_status(ret);
 882         }
 883         return OAL_STATUS_SUCCESS;
 884 }
 885
 886 oal_status_t gatts_add_included_services(int instance_id, int serv_handle,
 887                 int incl_handle)
 888 {
 889         int ret = OAL_STATUS_SUCCESS;
 890         API_TRACE("Server Add included Service : instance_id = %d, serv_handle = %d, incl_handle = %d",
 891                         instance_id, serv_handle, incl_handle);
 892         CHECK_OAL_GATT_ENABLED();
 893
 894         CHECK_SERVER_INSTANCE(instance_id);
 895
 896         CHECK_SERVER_REGISTRATION(instance_id);
 897
 898         ret = gatt_api->server->add_included_service(gatt_servers[instance_id - 1].server_id, serv_handle, incl_handle);
 899         if (ret != BT_STATUS_SUCCESS) {
 900                 BT_ERR("GATT Server Add included Service failed: %s", status2string(ret));
 901                 return convert_to_oal_status(ret);
 902         }
 903         return OAL_STATUS_SUCCESS;
 904 }
 905
 906 oal_status_t gatts_add_characteristics(int instance_id, int serv_handle,
 907                         oal_uuid_t* charc_uuid, int propts, int permsn)
 908 {
 909         int ret = OAL_STATUS_SUCCESS;
 910         char str[2*BT_UUID_STRING_MAX];
 911         char prop[MAX_PROP_LEN], perm[MAX_PERM_LEN];
 912         char_prop_to_string(propts, prop);
 913         char_perm_to_string(permsn, perm);
 914         API_TRACE("Server Add Characteristic : instance_id = %d, serv_handle = %d, Properties =%s, Permisison = %s",
 915                 instance_id, serv_handle, prop, perm);
 916         CHECK_OAL_GATT_ENABLED();
 917
 918         CHECK_SERVER_INSTANCE(instance_id);
 919
 920         CHECK_SERVER_REGISTRATION(instance_id);
 921
 922         if (charc_uuid != NULL) {
 923                 uuid_to_stringname(charc_uuid, str);
 924                 API_TRACE("uuid: [%s]", str);
 925         }
 926
 927         ret = gatt_api->server->add_characteristic(gatt_servers[instance_id - 1].server_id,
 928                         serv_handle, (bt_uuid_t*)charc_uuid, propts, permsn);
 929         if (ret != BT_STATUS_SUCCESS) {
 930                 BT_ERR("GATT Server Add Characteristic failed: %s", status2string(ret));
 931                 return convert_to_oal_status(ret);
 932         }
 933         return OAL_STATUS_SUCCESS;
 934 }
 935
 936 oal_status_t gatts_add_descriptor(int instance_id, int serv_handle,
 937                 oal_uuid_t* desc_uuid, int permsn)
 938 {
 939         int ret = OAL_STATUS_SUCCESS;
 940         char str[2*BT_UUID_STRING_MAX];
 941         char perm[MAX_PERM_LEN];
 942         char_perm_to_string(permsn, perm);
 943         API_TRACE("Server Add Descriptor : instance_id = %d, serv_handle = %d, Permisison = %s",
 944                         instance_id, serv_handle, perm);
 945         CHECK_OAL_GATT_ENABLED();
 946
 947         CHECK_SERVER_INSTANCE(instance_id);
 948
 949         CHECK_SERVER_REGISTRATION(instance_id);
 950
 951         if (desc_uuid != NULL) {
 952                 uuid_to_stringname(desc_uuid, str);
 953                 API_TRACE("uuid: [%s]", str);
 954         }
 955
 956         ret = gatt_api->server->add_descriptor(gatt_servers[instance_id - 1].server_id,
 957                                 serv_handle, (bt_uuid_t*)desc_uuid, permsn);
 958
 959         if (ret != BT_STATUS_SUCCESS) {
 960                 BT_ERR("GATT Server Add Descriptor failed: %s", status2string(ret));
 961                 return convert_to_oal_status(ret);
 962         }
 963         return OAL_STATUS_SUCCESS;
 964 }
 965
 966 oal_status_t gatts_start_service(int instance_id, int svc_handle, int transport)
 967 {
 968         int ret = OAL_STATUS_SUCCESS;
 969
 970         API_TRACE("Server Start Service : Ins_id = %d, srvHndl = %d, transport = %d",
 971                                 instance_id, svc_handle, transport);
 972         CHECK_OAL_GATT_ENABLED();
 973
 974         CHECK_SERVER_INSTANCE(instance_id);
 975
 976         CHECK_SERVER_REGISTRATION(instance_id);
 977
 978         ret = gatt_api->server->start_service(gatt_servers[instance_id - 1].server_id, svc_handle, transport);
 979
 980         if (ret != BT_STATUS_SUCCESS) {
 981                 BT_ERR("GATT Server Start Service failed: %s", status2string(ret));
 982                 return convert_to_oal_status(ret);
 983         }
 984         return OAL_STATUS_SUCCESS;
 985 }
 986
 987 oal_status_t gatts_stop_service(int ins_id, int srv_hdl)
 988 {
 989         int ret = OAL_STATUS_SUCCESS;
 990
 991         API_TRACE("Server Stop Service : Ins_id = %d, srvHndl = %d, ", ins_id, srv_hdl);
 992         CHECK_OAL_GATT_ENABLED();
 993
 994         CHECK_SERVER_INSTANCE(ins_id);
 995         CHECK_SERVER_REGISTRATION(ins_id);
 996
 997         ret = gatt_api->server->stop_service(gatt_servers[ins_id - 1].server_id, srv_hdl);
 998         if (ret != BT_STATUS_SUCCESS) {
 999                 BT_ERR("GATT Server Stop Service failed: %s", status2string(ret));
1000                 return convert_to_oal_status(ret);
1001         }
1002         return OAL_STATUS_SUCCESS;
1003 }
1004
1005 oal_status_t gatts_delete_service(int ins_id, int srv_hdl)
1006 {
1007         int ret = OAL_STATUS_SUCCESS;
1008
1009         API_TRACE("Server Delete Service : Ins_id = %d, srvHndl = %d, ", ins_id, srv_hdl);
1010         CHECK_OAL_GATT_ENABLED();
1011
1012         CHECK_SERVER_INSTANCE(ins_id);
1013
1014         CHECK_SERVER_REGISTRATION(ins_id);
1015
1016         ret = gatt_api->server->delete_service(gatt_servers[ins_id - 1].server_id, srv_hdl);
1017         if (ret != BT_STATUS_SUCCESS) {
1018                 BT_ERR("GATT Server Delete Service failed: %s", status2string(ret));
1019                 return convert_to_oal_status(ret);
1020         }
1021         return OAL_STATUS_SUCCESS;
1022 }
1023
1024 oal_status_t gatts_send_response(int conn_id, int trans_id, int resp_status, oal_gatt_response_t *response)
1025 {
1026         int ret = OAL_STATUS_SUCCESS;
1027
1028         API_TRACE("Server Send Response : ConnId = %d, TransId = %d, ", conn_id, trans_id);
1029         CHECK_OAL_GATT_ENABLED();
1030
1031         if (response == NULL) {
1032                 BT_ERR("GATT Server attribute value is empty");
1033                 return OAL_STATUS_INVALID_PARAM;
1034         }
1035
1036         ret = gatt_api->server->send_response(conn_id, trans_id, resp_status, (btgatt_response_t *)response);
1037         if (ret != BT_STATUS_SUCCESS) {
1038                 BT_ERR("GATT Server Send Response failed: %s", status2string(ret));
1039                 return convert_to_oal_status(ret);
1040         }
1041         return OAL_STATUS_SUCCESS;
1042 }
1043
1044 oal_status_t gatts_send_indication(int ins_id, int attr_hndl, int conn_id, int len, int confirm, char* value)
1045 {
1046         int ret = OAL_STATUS_SUCCESS;
1047
1048         API_TRACE("Server Send Indication : Ins_id = %d, srvHndl = %d, [%s]",
1049                         ins_id, attr_hndl, confirm == TRUE ? "INDICATION" : "NOTIFICATION");
1050         CHECK_OAL_GATT_ENABLED();
1051
1052         CHECK_SERVER_INSTANCE(ins_id);
1053
1054         CHECK_SERVER_REGISTRATION(ins_id);
1055
1056         if (value == NULL || len == 0) {
1057                 BT_ERR("GATT Server attribute value is empty");
1058                 return OAL_STATUS_INVALID_PARAM;
1059         }
1060
1061         ret = gatt_api->server->send_indication(gatt_servers[ins_id - 1].server_id,
1062                         attr_hndl, conn_id, len, confirm, value);
1063
1064         if (ret != BT_STATUS_SUCCESS) {
1065                 BT_ERR("GATT Server Send Indication failed: %s", status2string(ret));
1066                 return convert_to_oal_status(ret);
1067         }
1068         return OAL_STATUS_SUCCESS;
1069 }
1070
1071 oal_status_t gatts_update_att_value(int ins_id, oal_gatt_value_t *value)
1072 {
1073         int ret = OAL_STATUS_SUCCESS;
1074
1075         CHECK_OAL_GATT_ENABLED();
1076
1077         CHECK_SERVER_INSTANCE(ins_id);
1078
1079         CHECK_SERVER_REGISTRATION(ins_id);
1080
1081         if (value == NULL || value->len == 0) {
1082                 BT_ERR("GATT Server attribute value is empty");
1083                 return OAL_STATUS_INVALID_PARAM;
1084         }
1085
1086         API_TRACE("Server Update Value: Ins_id = [%d], att handle = [%d] data len [%d]",
1087                         ins_id, value->handle, value->len);
1088
1089         ret = gatt_api->server->update_att_value(gatt_servers[ins_id - 1].server_id,
1090                         (int)value->handle, (int)value->len, (char*)value->value);
1091
1092         if (ret != BT_STATUS_SUCCESS) {
1093                 BT_ERR("GATT Server Update Attribute Value failed: [%s]", status2string(ret));
1094                 return convert_to_oal_status(ret);
1095         }
1096         return OAL_STATUS_SUCCESS;
1097 }
1098
1099 /* GATT Server Callbacks:Start */
1100 static void cb_gatts_service_added(int status, int server_if,
1101                 btgatt_srvc_id_t *psrvc_id, int srvc_handle)
1102 {
1103         int instance_id;
1104
1105         BT_INFO("BTGATT SERVER SERVICE ADDED CB, status:%d, handle:%d", status, srvc_handle);
1106         event_gatts_srvc_prm_t* event = g_new0(event_gatts_srvc_prm_t, 1);
1107
1108         CHECK_CORRECT_SERVER_ID(instance_id, server_if, event->gatt_srvc_stat.server_inst);
1109
1110         BT_ERR("Invalid Interface, srv_if: %d", server_if);
1111         event->gatt_srvc_stat.server_inst = -1;
1112 sendevent:
1113         event->gatt_srvc_stat.servic_hndl = srvc_handle;
1114         if (psrvc_id != NULL) {
1115                 event->gatt_srvc_id.id.inst_id = psrvc_id->id.inst_id;
1116                 //event->gatt_srvc_id.id.uuid = psrvc_id->id.uuid;
1117                 memcpy(event->gatt_srvc_id.id.uuid.uuid,  psrvc_id->id.uuid.uu, sizeof(psrvc_id->id.uuid));
1118                 event->gatt_srvc_id.is_prmry = psrvc_id->is_primary;
1119         }
1120
1121         event->gatt_srvc_stat.status = convert_to_oal_status(status);
1122
1123         send_event(OAL_EVENT_GATTS_SERVICE_ADDED, event, sizeof(event_gatts_srvc_prm_t));
1124 }
1125
1126 static void cb_gatts_included_service_added(int status, int server_if,
1127                 int srvc_handle,
1128                 int incl_srvc_handle)
1129 {
1130         int ins_id ;
1131         BT_INFO("BTGATT SERVER INCLUDED SERVICE ADDED CB, status:%d, srvc handle:%d, incl handle:%d",
1132                         status, srvc_handle, incl_srvc_handle);
1133
1134         event_gatts_incld_srvc_t* event = g_new0(event_gatts_incld_srvc_t, 1);
1135
1136         CHECK_CORRECT_SERVER_ID(ins_id, server_if, event->gatt_srvc_stat.server_inst);
1137
1138         BT_ERR("Invalid Interface, srv_if: %d", server_if);
1139         event->gatt_srvc_stat.server_inst = -1;
1140 sendevent:
1141         event->gatt_srvc_stat.servic_hndl = srvc_handle;
1142         event->incl_srvc_hndl = incl_srvc_handle;
1143         event->gatt_srvc_stat.status = convert_to_oal_status(status);
1144         send_event(OAL_EVENT_GATTS_INCLUDED_SERVICE_ADDED, event, sizeof(event_gatts_incld_srvc_t));
1145 }
1146
1147 static void cb_gatts_characteristic_added(int status, int server_if, bt_uuid_t *char_id,
1148                 int srvc_handle, int char_handle)
1149 {
1150         int Ins_id ;
1151
1152         BT_INFO("BTGATT SERVER CHARACTERISTIC ADDED CB, status:%d, srvc handle:%d, char handle:%d",
1153                         status, srvc_handle, char_handle);
1154
1155         event_gatts_srvc_charctr_t* event = g_new0(event_gatts_srvc_charctr_t, 1);
1156
1157         CHECK_CORRECT_SERVER_ID(Ins_id, server_if, event->gatt_srvc_stat.server_inst);
1158
1159         BT_ERR("Invalid Interface, srv_if: %d", server_if);
1160         event->gatt_srvc_stat.server_inst = -1;
1161 sendevent:
1162         event->gatt_srvc_stat.servic_hndl = srvc_handle;
1163         event->charctr_hndl = char_handle;
1164         event->gatt_srvc_stat.status = convert_to_oal_status(status);
1165         memcpy(event->charctr_uuid.uuid, char_id->uu, sizeof(bt_uuid_t));
1166         send_event(OAL_EVENT_GATTS_CHARACTERISTIC_ADDED, event, sizeof(event_gatts_srvc_charctr_t));
1167 }
1168
1169 static void cb_gatts_descriptor_added(int status, int server_if,
1170                 bt_uuid_t *descr_id, int srvc_handle,
1171                 int descr_handle)
1172 {
1173         int Ins_id ;
1174         BT_INFO("BTGATT SERVER DESCRIPTOR ADDED CB, status:%d, srvc handle:%d, desc handle:%d",
1175                         status, srvc_handle, descr_handle);
1176
1177         event_gatts_srvc_descr_t* event = g_new0(event_gatts_srvc_descr_t, 1);
1178
1179         CHECK_CORRECT_SERVER_ID(Ins_id, server_if, event->gatt_srvc_stat.server_inst);
1180
1181         BT_ERR("Invalid Interface, srv_if: %d", server_if);
1182         event->gatt_srvc_stat.server_inst = -1;
1183 sendevent:
1184         event->gatt_srvc_stat.servic_hndl = srvc_handle;
1185         event->descrptr_hndl = descr_handle;
1186         event->gatt_srvc_stat.status = convert_to_oal_status(status);
1187         memcpy(event->descrptr_uuid.uuid, descr_id->uu, sizeof(bt_uuid_t));
1188         send_event(OAL_EVENT_GATTS_DESCRIPTOR_ADDED, event, sizeof(event_gatts_srvc_descr_t));
1189 }
1190
1191 static void cb_gatts_service_started(int status, int server_if, int srvc_handle)
1192 {
1193         int Ins_id ;
1194         BT_INFO("BTGATT SERVER SERVICE STARTED CB, status:%d, srvc_handle:%d", status, srvc_handle);
1195
1196         event_gatts_srvc_t* event = g_new0(event_gatts_srvc_t, 1);
1197
1198         CHECK_CORRECT_SERVER_ID(Ins_id, server_if, event->server_inst);
1199
1200         BT_ERR("Invalid Interface, srv_if: %d", server_if);
1201         event->server_inst = -1;
1202 sendevent:
1203         event->servic_hndl = srvc_handle;
1204         event->status = convert_to_oal_status(status);
1205         send_event(OAL_EVENT_GATTS_SERVICE_STARTED, event, sizeof(event_gatts_srvc_t));
1206 }
1207
1208 static void cb_gatts_service_stopped(int status, int server_if, int srvc_handle)
1209 {
1210         int ins_id ;
1211         BT_INFO("BTGATT SERVER SERVICE STOPPED CB, status:%d, srvc_handle:%d", status, srvc_handle);
1212
1213         event_gatts_srvc_t* event = g_new0(event_gatts_srvc_t, 1);
1214
1215         CHECK_CORRECT_SERVER_ID(ins_id, server_if, event->server_inst);
1216
1217         BT_ERR("Invalid Interface, srv_if: %d", server_if);
1218         event->server_inst = -1;
1219 sendevent:
1220         event->servic_hndl = srvc_handle;
1221         event->status = convert_to_oal_status(status);
1222         send_event(OAL_EVENT_GATTS_SERVICE_STOPED, event, sizeof(event_gatts_srvc_t));
1223 }
1224
1225 static void cb_gatts_service_deleted(int status, int server_if, int srvc_handle)
1226 {
1227         int ins_id;
1228         BT_INFO("BTGATT SERVER SERVICE DELETED CB, status:%d, srvc_handle:%d", status, srvc_handle);
1229
1230         event_gatts_srvc_t* event = g_new0(event_gatts_srvc_t, 1);
1231
1232         CHECK_CORRECT_SERVER_ID(ins_id, server_if, event->server_inst);
1233
1234         BT_ERR("Invalid Interface, srv_if: %d", server_if);
1235         event->server_inst = -1;
1236 sendevent:
1237         event->servic_hndl = srvc_handle;
1238         event->status = convert_to_oal_status(status);
1239         send_event(OAL_EVENT_GATTS_SERVICE_DELETED, event, sizeof(event_gatts_srvc_t));
1240 }
1241
1242 static void cb_gatts_connection(int conn_id, int server_if, int connected, bt_bdaddr_t *bda)
1243 {
1244         int ins_id ;
1245         oal_event_t event_type;
1246
1247         BT_INFO("BTGATT SERVER CONNECTION  connnected:%d, conn_id:%d server_if:%d", connected, conn_id, server_if);
1248         event_gatts_conn_t *event = g_new0(event_gatts_conn_t, 1);
1249
1250         for (ins_id = 1 ; ins_id <= NUM_SERVER_INST ; ins_id++) {
1251                 if ((gatt_servers[ins_id - 1].server_id == server_if)) {
1252                         event->server_inst = ins_id;
1253                         break;
1254                 } else {
1255                         BT_INFO("Server ID:%d recevied server Id:%d\n", gatt_servers[ins_id - 1].server_id, server_if);
1256                 }
1257         }
1258         if (ins_id == NUM_SERVER_INST+1) {
1259                 BT_WARN("Incorrect Server Interface received: %d\n",  server_if);
1260                 g_free(event);
1261                 return;
1262         }
1263         memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1264         event->conn_id = conn_id;
1265         event_type = ((connected == TRUE) ? OAL_EVENT_GATTS_CONNECTION_COMPLETED : OAL_EVENT_GATTS_DISCONNECTION_COMPLETED);
1266         event->status = OAL_STATUS_SUCCESS;
1267
1268         send_event(event_type, event, sizeof(event_gatts_conn_t));
1269 }
1270
1271 static void cb_gatts_request_read(int conn_id, int trans_id, bt_bdaddr_t *bda,
1272                 int attr_handle, int offset, bool is_long)
1273 {
1274         BT_INFO("BTGATT SERVER REQUEST READ CB: conn_id:%d", conn_id);
1275
1276         event_gatts_srvc_read_attr_t* event = g_new0(event_gatts_srvc_read_attr_t, 1);
1277
1278         memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1279
1280         event->attr_trans.attr_handle = attr_handle;
1281         event->attr_trans.conn_id = conn_id;
1282         event->attr_trans.trans_id = trans_id;
1283         event->attr_trans.offset = offset;
1284         event->is_long = is_long;
1285
1286         send_event(OAL_EVENT_GATTS_REQUEST_READ, event, sizeof(event_gatts_srvc_read_attr_t));
1287 }
1288
1289 static void cb_gatts_request_write(int conn_id, int trans_id,
1290                 bt_bdaddr_t *bda, int attr_handle,
1291                 int offset, int length,
1292                 bool need_rsp, bool is_prep, uint8_t* value)
1293 {
1294         BT_INFO("BTGATT SERVER REQUEST WRITE conn_id:%d", conn_id);
1295
1296         event_gatts_srvc_write_attr_t* event = g_new0(event_gatts_srvc_write_attr_t, 1);
1297
1298         memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1299
1300         event->attr_trans.attr_handle = attr_handle;
1301         event->attr_trans.conn_id = conn_id;
1302         event->attr_trans.trans_id = trans_id;
1303         event->attr_trans.offset = offset;
1304         event->need_rsp = need_rsp;
1305         event->is_prep = is_prep;
1306
1307         if (length > 0 && value != NULL) {
1308                 if (length > OAL_GATT_MAX_ATTR_LEN)
1309                         length = OAL_GATT_MAX_ATTR_LEN;
1310                 memcpy(event->value, value, length);
1311                 event->length = length;
1312         }
1313         send_event(OAL_EVENT_GATTS_REQUEST_WRITE, event, sizeof(event_gatts_srvc_write_attr_t));
1314 }
1315
1316 static void cb_gatts_acquire_write(int mtu, int conn_id, int trans_id, int attr_handle , bt_bdaddr_t *bda)
1317
1318 {
1319         BT_INFO("BTGATT SERVER REQUEST ACQUIRE WRITE conn_id:%d", conn_id);
1320
1321         event_gatts_srvc_acquire_attr_t* event = g_new0(event_gatts_srvc_acquire_attr_t, 1);
1322
1323         event->attr_trans.attr_handle = attr_handle;
1324         event->attr_trans.conn_id = conn_id;
1325         event->attr_trans.trans_id = trans_id;
1326         event->mtu = mtu;
1327         memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1328
1329         send_event(OAL_EVENT_GATTS_REQUEST_ACQUIRE_WRITE, event, sizeof(event_gatts_srvc_acquire_attr_t));
1330 }
1331
1332 static void cb_gatts_acquire_notify(int mtu, int conn_id, int trans_id, int attr_handle)
1333 {
1334         BT_INFO("BTGATT SERVER REQUEST ACQUIRE NOTIFY conn_id:%d", conn_id);
1335
1336         event_gatts_srvc_acquire_attr_t* event = g_new0(event_gatts_srvc_acquire_attr_t, 1);
1337
1338         event->attr_trans.attr_handle = attr_handle;
1339         event->attr_trans.conn_id = conn_id;
1340         event->attr_trans.trans_id = trans_id;
1341         event->mtu = mtu;
1342
1343         send_event(OAL_EVENT_GATTS_REQUEST_ACQUIRE_NOTIFY, event, sizeof(event_gatts_srvc_acquire_attr_t));
1344
1345 }
1346
1347 static void cb_gatts_response_confirmation(int status, int handle)
1348 {
1349         BT_INFO("BTGATT SERVER RESPONSE CONFIRMATION CB, status:%d, handle:%d", status, handle);
1350
1351         event_gatts_respons_t* event = g_new0(event_gatts_respons_t, 1);
1352
1353         event->hndl = handle;
1354         event->status = convert_to_oal_status(status);
1355
1356         send_event(OAL_EVENT_GATTS_RESPONSE_CONFIRMED, event, sizeof(event_gatts_respons_t));
1357 }
1358
1359 static void cb_indication_confirmation(int conn_id, int trans_id, int attr_handle, bt_bdaddr_t *bda)
1360 {
1361         BT_INFO("BTGATT SERVER Indication Confirmation CB, conn_id:%d, trans_id:%d attr_handle:%d",
1362                         conn_id, trans_id, attr_handle);
1363
1364         event_gatts_ind_cnfrm_t* event = g_new0(event_gatts_ind_cnfrm_t, 1);
1365
1366         memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1367
1368         event->attr_handle = attr_handle;
1369         event->conn_id = conn_id;
1370         event->trans_id = trans_id;
1371         send_event(OAL_EVENT_GATTS_IND_CONFIRM, event, sizeof(event_gatts_ind_cnfrm_t));
1372 }
1373
1374 static void cb_gatts_mtu_changed(int conn_id, int mtu)
1375 {
1376         BT_INFO("BTGATT SERVER MTU CHANGED CB, conn_id: %d, mtu_size: %d", conn_id, mtu);
1377         event_gatts_mtu_changed_t *event = g_new0(event_gatts_mtu_changed_t, 1);
1378         event->conn_id = conn_id;
1379         event->mtu_size = mtu;
1380         send_event(OAL_EVENT_GATTS_MTU_CHANGED, event, sizeof(event_gatts_mtu_changed_t));
1381 }
1382
1383 #ifdef TIZEN_BT_HAL
1384 static void cb_notifcation_changed(int conn_id, int trans_id, int attr_handle, bool notify,  bt_bdaddr_t *bda)
1385 {
1386         BT_INFO("BTGATT SERVER Notication CB, conn_id:%d, trans_id:%d attr_handle:%d Notify:%d",
1387                         conn_id, trans_id, attr_handle, notify);
1388
1389         event_gatts_notif_t* event = g_new0(event_gatts_notif_t, 1);
1390
1391         memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1392
1393         event->attr_handle = attr_handle;
1394         event->conn_id = conn_id;
1395         event->trans_id = trans_id;
1396         event->notify = notify;
1397         send_event(OAL_EVENT_GATTS_NOTIFICATION, event, sizeof(event_gatts_notif_t));
1398 }
1399 #endif
1400
1401
1402 /* GATT Server Callbacks: End */
1403 /************************************ GATT Client ***********************************/
1404 /* Client Callbacks */
1405 static void cb_gattc_register_app(int status, int clientIf, bt_uuid_t *app_uuid)
1406 {
1407         char uuid_str[BT_UUID_STRING_MAX];
1408         event_gattc_register_t *event;
1409
1410         BT_INFO("+");
1411
1412         /* Check if GATT client registered for Default GATT client UUID */
1413         uuid_to_string((service_uuid_t *)app_uuid, uuid_str);
1414         BT_INFO("UUID:%s", uuid_str);
1415
1416         BT_INFO("BTGATT CLIENT REGISTER APP CB, status:%d, clientIf:%d", status, clientIf);
1417         event = g_new0(event_gattc_register_t, 1);
1418         event->client_if = clientIf;
1419         event->status = (status == 0 ? OAL_STATUS_SUCCESS : OAL_STATUS_INTERNAL_ERROR);
1420         memcpy(event->client_uuid.uuid, app_uuid->uu, sizeof(oal_uuid_t));
1421         send_event(OAL_EVENT_GATTC_REGISTRATION, event, sizeof(event_gattc_register_t));
1422 }
1423
1424 static void cb_gattc_scan_result(bt_bdaddr_t* bdaddress, int rssi, uint8_t *adv_data)
1425 {
1426         event_ble_scan_result_info *event;
1427
1428         event = g_new0(event_ble_scan_result_info, 1);
1429         event->rssi = rssi;
1430         memcpy(event->address.addr, bdaddress->address, BT_ADDRESS_BYTES_NUM);
1431         memcpy(event->adv_data, adv_data, BLE_ADV_DATA_LENGTH);
1432         send_event_bda_trace(OAL_EVENT_BLE_REMOTE_DEVICE_FOUND, event,
1433                         sizeof(event_ble_scan_result_info), (bt_address_t *)bdaddress);
1434 }
1435
1436 static void cb_gattc_connection(int conn_id, int status, int client_if, bt_bdaddr_t* bda)
1437 {
1438         event_gattc_conn_t *event;
1439         BT_INFO("BTGATT CLIENT CONNECTED CB, status:[%d] client_if[%d] id[%d]",
1440                                                         status, client_if, conn_id);
1441
1442         event = g_new0(event_gattc_conn_t, 1);
1443         memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1444         event->client_if = client_if;
1445
1446         if (BT_STATUS_SUCCESS != status) {
1447                 event->status = OAL_STATUS_INTERNAL_ERROR;
1448                 BT_ERR("gattc connection Error: %d", status);
1449         } else {
1450                 event->conn_id = conn_id;
1451                 event->status = OAL_STATUS_SUCCESS;
1452         }
1453
1454         send_event_bda_trace(OAL_EVENT_GATTC_CONNECTION_COMPLETED, event,
1455                                         sizeof(*event), (bt_address_t *)bda);
1456 }
1457
1458
1459 static void cb_gattc_disconnect(int conn_id, int status, int client_if, bt_bdaddr_t* bda)
1460 {
1461         event_gattc_conn_t *event;
1462         BT_INFO("BTGATT Client Disconnect Complete cb, status:[%d], client_if[%d] id[%d]",
1463                                                         status, client_if, conn_id);
1464         event = g_new0(event_gattc_conn_t, 1);
1465         event->status = convert_to_oal_status(status);
1466         event->client_if = client_if;
1467         event->conn_id = conn_id;
1468         memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1469         send_event_bda_trace(OAL_EVENT_GATTC_DISCONNECTION_COMPLETED, event,
1470                                         sizeof(*event), (bt_address_t *)bda);
1471 }
1472
1473 static void cb_gattc_search_result(int conn_id, btgatt_srvc_id_t *srvc_id)
1474 {
1475         char uuid_str[2*BT_UUID_STRING_MAX];
1476
1477         BT_INFO("BTGATT Client Service Search Result cb, conn_id:%d", conn_id);
1478
1479         uuid_to_stringname((oal_uuid_t *)&(srvc_id->id.uuid), uuid_str);
1480         BT_INFO("Service=> UUID: [%s], Inst_id: [%u], Type: [%s]",
1481                 uuid_str, srvc_id->id.inst_id, srvc_id->is_primary ? "Primary" : "Secondary");
1482
1483         event_gattc_service_result_t *event = g_new0(event_gattc_service_result_t, 1);
1484         event->conn_status.status = OAL_STATUS_SUCCESS;
1485         event->conn_status.conn_id = conn_id;
1486         memcpy(&(event->srvc_id), srvc_id, sizeof(oal_gatt_srvc_id_t));
1487
1488         send_event(OAL_EVENT_GATTC_SERVICE_SEARCH_RESULT, event, sizeof(*event));
1489 }
1490
1491 static void cb_gattc_search_complete(int conn_id, int status)
1492 {
1493         BT_INFO("BTGATT Client Service Search Complete cb, status:%d, conn_id:%d",
1494         status, conn_id);
1495
1496         event_gattc_conn_status_t *event = g_new0(event_gattc_conn_status_t, 1);
1497         event->conn_id = conn_id;
1498         event->status = convert_to_oal_status(status);
1499
1500         send_event(OAL_EVENT_GATTC_SERVICE_SEARCH_DONE, event, sizeof(*event));
1501 }
1502
1503
1504 static void cb_gattc_get_characteristics(int conn_id, int status, btgatt_srvc_id_t *srvc_id,
1505                                                 btgatt_gatt_id_t *char_id, int char_prop)
1506 {
1507         char uuid_str1[2*BT_UUID_STRING_MAX];
1508         char uuid_str2[2*BT_UUID_STRING_MAX];
1509         char str[50];
1510         BT_INFO("BTGATT Client Get Characteristic Callback, conn_id:%d, status:%d", conn_id, status);
1511         uuid_to_stringname((oal_uuid_t *)&(srvc_id->id.uuid), uuid_str1);
1512         BT_INFO("Service=> UUID: [%s], Inst_id: [%u], Type: [%s]",
1513                 uuid_str1, srvc_id->id.inst_id, srvc_id->is_primary ? "Primary" : "Secondary");
1514
1515         event_gattc_characteristic_result_t *event = g_new0(event_gattc_characteristic_result_t, 1);
1516         event->conn_status.conn_id = conn_id;
1517         event->conn_status.status = convert_to_oal_status(status);
1518         memcpy(&(event->srvc_id), srvc_id, sizeof(oal_gatt_srvc_id_t));
1519
1520         if (status == 0) {
1521                 uuid_to_stringname((oal_uuid_t *)&(char_id->uuid), uuid_str2);
1522                 BT_INFO("Charac=> UUID: [%s], Inst_id: [%u], Prop: [%s]",
1523                         uuid_str2, char_id->inst_id, char_prop_to_string(char_prop, str));
1524                 event->char_prop = char_prop;
1525                 memcpy(&(event->char_id), char_id, sizeof(oal_gatt_id_t));
1526         }
1527         send_event(OAL_EVENT_GATTC_CHARAC_SERACH_RESULT, event, sizeof(*event));
1528 }
1529
1530
1531
1532 static void cb_gattc_get_descriptor(int conn_id, int status, btgatt_srvc_id_t *srvc_id, btgatt_gatt_id_t *char_id, btgatt_gatt_id_t *descr_id)
1533 {
1534         char uuid_str1[2*BT_UUID_STRING_MAX];
1535         char uuid_str2[2*BT_UUID_STRING_MAX];
1536         char uuid_str3[2*BT_UUID_STRING_MAX];
1537         BT_INFO("BTGATT Client Get Descriptor Callback, conn_id:%d, status:%d", conn_id, status);
1538         uuid_to_stringname((oal_uuid_t *)&(srvc_id->id.uuid), uuid_str1);
1539         uuid_to_stringname((oal_uuid_t *)&(char_id->uuid), uuid_str2);
1540         BT_INFO("Service=> UUID: [%s], Inst_id: [%u], Type: [%s]",
1541                 uuid_str1, srvc_id->id.inst_id, srvc_id->is_primary ? "Primary" : "Secondary");
1542         BT_INFO("Charac=> UUID: [%s], Inst_id: [%u]", uuid_str2, char_id->inst_id);
1543
1544         event_gattc_descriptor_result_t *event = g_new0(event_gattc_descriptor_result_t, 1);
1545         event->conn_status.conn_id = conn_id;
1546         event->conn_status.status = convert_to_oal_status(status);
1547         memcpy(&(event->srvc_id), srvc_id, sizeof(oal_gatt_srvc_id_t));
1548         memcpy(&(event->char_id), char_id, sizeof(oal_gatt_id_t));
1549
1550         if (status == 0) {
1551                 uuid_to_stringname((oal_uuid_t *)&(descr_id->uuid), uuid_str3);
1552                 BT_INFO("Desc=> UUID: [%s], Inst_id: [%u]", uuid_str3, descr_id->inst_id);
1553                 memcpy(&(event->descr_id), descr_id, sizeof(oal_gatt_id_t));
1554         }
1555         send_event(OAL_EVENT_GATTC_DESC_SERACH_RESULT, event, sizeof(*event));
1556 }
1557
1558 static void cb_gattc_register_for_notification(int client_if, int registered, int status, btgatt_srvc_id_t *srvc_id, btgatt_gatt_id_t *char_id)
1559 {
1560         char uuid_str1[2*BT_UUID_STRING_MAX];
1561         char uuid_str2[2*BT_UUID_STRING_MAX];
1562         BT_INFO("BTGATT Client Register For Notification Callback, client_if:%d, status:%d, registered: %s",
1563                 client_if, status, registered == 1 ? "REGISTERED" : "DEREGISTERED");
1564         uuid_to_stringname((oal_uuid_t *)&(srvc_id->id.uuid), uuid_str1);
1565         uuid_to_stringname((oal_uuid_t *)&(char_id->uuid), uuid_str2);
1566         BT_INFO("Service=> UUID: [%s], Inst_id: [%u], Type: [%s]", uuid_str1, srvc_id->id.inst_id, srvc_id->is_primary ? "Primary" : "Secondary");
1567         BT_INFO("Charac=> UUID: [%s], Inst_id: [%u]", uuid_str2, char_id->inst_id);
1568
1569         event_gattc_regdereg_notify_t *event = g_new0(event_gattc_regdereg_notify_t, 1);
1570         oal_event_t event_type = (registered == 1 ? OAL_EVENT_GATTC_NOTIFICATION_REGISTERED : OAL_EVENT_GATTC_NOTIFICATION_DEREGISTERED);
1571         event->client_if = client_if;
1572         event->status = convert_to_oal_status(status);
1573         memcpy(&(event->srvc_id), srvc_id, sizeof(oal_gatt_srvc_id_t));
1574         memcpy(&(event->char_id), char_id, sizeof(oal_gatt_id_t));
1575
1576         send_event(event_type, event, sizeof(*event));
1577 }
1578
1579 static void cb_gattc_notify(int conn_id, btgatt_notify_params_t *p_data)
1580 {
1581         bdstr_t bdstr;
1582         char uuid_str1[2*BT_UUID_STRING_MAX];
1583         char uuid_str2[2*BT_UUID_STRING_MAX];
1584
1585         BT_INFO("BTGATT Client Notify Callback, conn_id:%d", conn_id);
1586         BT_INFO("Server Address:[%s], is_notify:[%d], len:[%d]",
1587                 bdt_bd2str((bt_address_t *)&(p_data->bda), &bdstr), p_data->is_notify, p_data->len);
1588
1589         uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
1590         uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
1591
1592         BT_INFO("Service=> UUID: [%s], Inst_id: [%u], Type: [%s]",
1593                 uuid_str1, p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
1594         BT_INFO("Charac=> UUID: [%s], Inst_id: [%u]", uuid_str2, p_data->char_id.inst_id);
1595
1596         if (p_data->len > 0) {
1597                 char *data = NULL;
1598                 data = g_malloc(3*p_data->len+1);
1599                 if (!data) {
1600                         BT_ERR("memory allocation failed");
1601                         return;
1602                 }
1603
1604                 convert_hex_2_str((unsigned char *)p_data->value, p_data->len, data);
1605                 BT_INFO("Notified Data: [%s]", data);
1606
1607                 event_gattc_notify_data *event = g_new0(event_gattc_notify_data, 1);
1608                 memcpy(event->address.addr, p_data->bda.address, BT_ADDRESS_BYTES_NUM);
1609                 event->is_notify = p_data->is_notify;
1610                 event->data_len = p_data->len;
1611                 memcpy(event->data, p_data->value, event->data_len);
1612                 memcpy(&(event->char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
1613                 memcpy(&(event->srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
1614
1615                 send_event_bda_trace(OAL_EVENT_GATTC_NOTIFY_DATA, event, sizeof(*event), (bt_address_t *)&p_data->bda);
1616                 g_free(data);
1617         }
1618 }
1619
1620
1621 static void cb_gattc_read_characteristic(int conn_id, int status, btgatt_read_params_t *p_data)
1622 {
1623         char uuid_str1[2*BT_UUID_STRING_MAX];
1624         char uuid_str2[2*BT_UUID_STRING_MAX];
1625         BT_INFO("BTGATT Client Read Charcateristic Callback, conn_id:%d, read_status:%d", conn_id, status);
1626
1627         event_gattc_read_data *event = g_new0(event_gattc_read_data, 1);
1628         event->uuid_status.conn_status.conn_id = conn_id;
1629         event->uuid_status.conn_status.status = convert_to_oal_status(status);
1630         event->value_type = p_data->value_type;
1631         memcpy(&(event->uuid_status.srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
1632         memcpy(&(event->uuid_status.char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
1633         if (status == 0) {
1634                 uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
1635                 uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
1636                 BT_INFO("Service=> UUID: [%s], Inst_id: [%u], Type: [%s]", uuid_str1,
1637                         p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
1638                 BT_INFO("Charac=> UUID: [%s], Inst_id: [%u]", uuid_str2, p_data->char_id.inst_id);
1639                 BT_INFO("Len: %u, value_type: %u", p_data->value.len, p_data->value_type);
1640                 if (p_data->value.len > 0 && event->value_type == GATTC_READ_VALUE_TYPE_VALUE) {
1641                         char *data = NULL;
1642                         data = g_malloc(3*p_data->value.len+1);
1643                         if (!data) {
1644                                 BT_ERR("memory allocation failed");
1645                                 g_free(event);
1646                                 return;
1647                         }
1648                         convert_hex_2_str((unsigned char *)p_data->value.value, p_data->value.len, data);
1649                         BT_INFO("Read Data: [%s]", data);
1650                         event->data_len = p_data->value.len;
1651                         memcpy(&(event->data), &(p_data->value.value), event->data_len);
1652                         g_free(data);
1653                 }
1654         }
1655         send_event(OAL_EVENT_GATTC_READ_CHARAC, event, sizeof(*event));
1656 }
1657
1658 static void cb_gattc_write_characteristic(int conn_id, int status, btgatt_write_params_t *p_data)
1659 {
1660         char uuid_str1[2*BT_UUID_STRING_MAX];
1661         char uuid_str2[2*BT_UUID_STRING_MAX];
1662         BT_INFO("BTGATT Client Write Charcateristic Callback, conn_id:%d, write_status:%d", conn_id, status);
1663
1664         event_gattc_write_data *event = g_new0(event_gattc_write_data, 1);
1665         event->conn_status.conn_id = conn_id;
1666         event->conn_status.status = convert_to_oal_status(status);
1667         memcpy(&(event->srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
1668         memcpy(&(event->char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
1669         if (status == 0) {
1670                 uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
1671                 uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
1672                 BT_INFO("Service=> UUID: [%s], Inst_id: [%u], Type: [%s]", uuid_str1,
1673                         p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
1674                 BT_INFO("Charac=> UUID: [%s], Inst_id: [%u]", uuid_str2, p_data->char_id.inst_id);
1675         }
1676         send_event(OAL_EVENT_GATTC_WRITE_CHARAC, event, sizeof(*event));
1677 }
1678
1679 static void cb_gattc_write_descriptor(int conn_id, int status, btgatt_write_params_t *p_data)
1680 {
1681         char uuid_str1[2*BT_UUID_STRING_MAX];
1682         char uuid_str2[2*BT_UUID_STRING_MAX];
1683         char uuid_str3[2*BT_UUID_STRING_MAX];
1684         BT_INFO("BTGATT Client Write Descriptor Callback, conn_id:%d, write_status:%d", conn_id, status);
1685
1686         event_gattc_write_data *event = g_new0(event_gattc_write_data, 1);
1687         event->conn_status.conn_id = conn_id;
1688         event->conn_status.status = convert_to_oal_status(status);
1689         memcpy(&(event->srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
1690         memcpy(&(event->char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
1691         memcpy(&(event->descr_id), &(p_data->descr_id), sizeof(oal_gatt_id_t));
1692         if (status == 0) {
1693                 uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
1694                 uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
1695                 uuid_to_stringname((oal_uuid_t *)&(p_data->descr_id.uuid), uuid_str3);
1696                 BT_INFO("Service=> UUID: [%s], Inst_id: [%u], Type: [%s]", uuid_str1,
1697                         p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
1698                 BT_INFO("Charac=> UUID: [%s], Inst_id: [%u]", uuid_str2, p_data->char_id.inst_id);
1699                 BT_INFO("Desc=> UUID: [%s], Inst_id: [%u]", uuid_str3, p_data->descr_id.inst_id);
1700         }
1701         send_event(OAL_EVENT_GATTC_WRITE_DESCR, event, sizeof(*event));
1702 }
1703
1704
1705
1706 static void cb_gattc_read_descriptor(int conn_id, int status, btgatt_read_params_t *p_data)
1707 {
1708         char uuid_str1[2*BT_UUID_STRING_MAX];
1709         char uuid_str2[2*BT_UUID_STRING_MAX];
1710         char uuid_str3[2*BT_UUID_STRING_MAX];
1711         BT_INFO("BTGATT Client Read Descriptor Callback, conn_id:%d, read_status:%d", conn_id, status);
1712
1713         event_gattc_read_data *event = g_new0(event_gattc_read_data, 1);
1714         event->uuid_status.conn_status.conn_id = conn_id;
1715         event->uuid_status.conn_status.status = convert_to_oal_status(status);
1716         event->value_type = p_data->value_type;
1717         memcpy(&(event->uuid_status.srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
1718         memcpy(&(event->uuid_status.char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
1719         memcpy(&(event->uuid_status.descr_id), &(p_data->descr_id), sizeof(oal_gatt_id_t));
1720
1721         if (status == 0) {
1722                 uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
1723                 uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
1724                 uuid_to_stringname((oal_uuid_t *)&(p_data->descr_id.uuid), uuid_str3);
1725                 BT_INFO("Service=> UUID: [%s], Inst_id: [%u], Type: [%s]", uuid_str1,
1726                         p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
1727                 BT_INFO("Charac=> UUID: [%s], Inst_id: [%u]", uuid_str2, p_data->char_id.inst_id);
1728                 BT_INFO("Desc=> UUID: [%s], Inst_id: [%u]", uuid_str3, p_data->descr_id.inst_id);
1729                 BT_INFO("Len: %u, value_type: %u", p_data->value.len, p_data->value_type);
1730                 if (p_data->value.len > 0 && event->value_type == GATTC_READ_VALUE_TYPE_VALUE) {
1731                         char *data = NULL;
1732                         data = g_malloc(3*p_data->value.len+1);
1733                         if (!data) {
1734                                 BT_ERR("memory allocation failed");
1735                                 g_free(event);
1736                                 return;
1737                         }
1738                         convert_hex_2_str((unsigned char *)p_data->value.value, p_data->value.len, data);
1739                         BT_INFO("Read Data: [%s]", data);
1740                         event->data_len = p_data->value.len;
1741                         memcpy(&(event->data), &(p_data->value.value), event->data_len);
1742                         g_free(data);
1743                 }
1744         }
1745         send_event(OAL_EVENT_GATTC_READ_DESCR, event, sizeof(*event));
1746 }
1747
1748 oal_status_t gattc_start_le_discovery(int client_id)
1749 {
1750
1751         int ret = OAL_STATUS_SUCCESS;
1752
1753         API_TRACE("BTGATT CLIENT SCAN START");
1754         CHECK_OAL_GATT_ENABLED();
1755         CHECK_CLIENT_REGISTRATION(client_id);
1756
1757         ret = gatt_api->client->scan(client_id, 1);
1758         if (ret != BT_STATUS_SUCCESS) {
1759                 BT_ERR("Error:Start LE Discovery failed: %s", status2string(ret));
1760                 return convert_to_oal_status(ret);
1761         }
1762         return OAL_STATUS_SUCCESS;
1763 }
1764
1765 oal_status_t gattc_stop_le_discovery(int client_id)
1766 {
1767
1768         int ret = OAL_STATUS_SUCCESS;
1769
1770         API_TRACE("Scan is stopped");
1771         CHECK_OAL_GATT_ENABLED();
1772         CHECK_CLIENT_REGISTRATION(client_id);
1773         ret = gatt_api->client->scan(client_id, 0);
1774         if (ret != BT_STATUS_SUCCESS) {
1775                 BT_ERR("Error:Stop LE Discovery failed: %s", status2string(ret));
1776                 return convert_to_oal_status(ret);
1777         }
1778         return OAL_STATUS_SUCCESS;
1779 }
1780
1781 oal_status_t gattc_set_le_scan_param(int scan_type, int itv, int win)
1782 {
1783         int ret;
1784
1785         API_TRACE("Scan is stopped");
1786         CHECK_OAL_GATT_ENABLED();
1787
1788 #ifdef TIZEN_BT_HAL
1789         ret = gatt_api->client->set_scan_parameters(scan_type, itv, win);
1790         if (ret != BT_STATUS_SUCCESS) {
1791                 BT_ERR("Error:Set scan parameters failed: %s", status2string(ret));
1792                 return convert_to_oal_status(ret);
1793         }
1794 #else
1795         ret = gatt_api->client->set_scan_parameters(itv, win);
1796         if (ret != BT_STATUS_SUCCESS) {
1797                 BT_ERR("Error:Set scan parameters failed: %s", status2string(ret));
1798                 return convert_to_oal_status(ret);
1799         }
1800 #endif
1801
1802         return OAL_STATUS_SUCCESS;
1803 }
1804
1805 static void cb_gattc_configure_mtu_cmpl(int conn_id, int status, int mtu)
1806 {
1807         event_gattc_mtu_configured_t *event;
1808         BT_INFO("BTGATT Client configure mtu complete Callback, conn_id: %d, status: %d, mtu: %d",
1809                         conn_id, status, mtu);
1810         event = g_new0(event_gattc_mtu_configured_t, 1);
1811         event->conn_id = conn_id;
1812         event->mtu = mtu;
1813         event->status = convert_to_oal_status(status);
1814         send_event(OAL_EVENT_GATTC_MTU_EXCHANGE_COMPLETED, event, sizeof(*event));
1815 }
1816
1817 /************************************ GATT Client ***********************************/
1818 oal_status_t gattc_register(oal_uuid_t* client_uuid)
1819 {
1820
1821         char str[2*BT_UUID_STRING_MAX];
1822         int ret = OAL_STATUS_SUCCESS;
1823
1824         CHECK_OAL_GATT_ENABLED();
1825         uuid_to_stringname(client_uuid, str);
1826         API_TRACE("uuid: [%s]", str);
1827         /* We will perform actual registration in cb_gattc_register_app callback */
1828         ret = gatt_api->client->register_client((bt_uuid_t *)client_uuid);
1829         if (ret != BT_STATUS_SUCCESS) {
1830                 BT_ERR("GATT client register failed: %s", status2string(ret));
1831                 return convert_to_oal_status(ret);
1832         }
1833         return OAL_STATUS_SUCCESS;
1834 }
1835
1836 oal_status_t gattc_deregister(int client_id)
1837 {
1838         int ret = OAL_STATUS_SUCCESS;
1839
1840         API_TRACE("GATT client deregister");
1841         CHECK_OAL_GATT_ENABLED();
1842         CHECK_CLIENT_REGISTRATION(client_id);
1843
1844         ret = gatt_api->client->unregister_client(client_id);
1845         if (ret != BT_STATUS_SUCCESS) {
1846                 BT_ERR("GATT client deregister failed: %s", status2string(ret));
1847                 return convert_to_oal_status(ret);
1848         }
1849
1850         return OAL_STATUS_SUCCESS;
1851 }
1852
1853 oal_status_t gattc_connect(int client_id, bt_address_t *device_address, int isDirect)
1854 {
1855         int ret = OAL_STATUS_SUCCESS;
1856         bdstr_t bdstr;
1857
1858         OAL_CHECK_PARAMETER(device_address, return);
1859         API_TRACE("Client Connect: [%s]", bdt_bd2str(device_address, &bdstr));
1860         CHECK_OAL_GATT_ENABLED();
1861         CHECK_CLIENT_REGISTRATION(client_id);
1862
1863         /* Handle the actual connection in cb_gattc_connection callback */
1864         ret = gatt_api->client->connect(client_id, (bt_bdaddr_t *)device_address, isDirect);
1865         if (ret != BT_STATUS_SUCCESS) {
1866                 BT_ERR("GATT client connect failed: %s", status2string(ret));
1867                 return convert_to_oal_status(ret);
1868         }
1869         return OAL_STATUS_SUCCESS;
1870 }
1871
1872 oal_status_t gattc_disconnect(int client_id, bt_address_t *device_address, int conn_id)
1873 {
1874
1875         int ret = OAL_STATUS_SUCCESS;
1876         bdstr_t bdstr;
1877
1878         OAL_CHECK_PARAMETER(device_address, return);
1879         API_TRACE("Client Disconnect: [%s]", bdt_bd2str(device_address, &bdstr));
1880         CHECK_OAL_GATT_ENABLED();
1881         CHECK_CLIENT_REGISTRATION(client_id);
1882         CHECK_CLIENT_CONNECTION(conn_id);
1883
1884         /* Handle actual disconnection in callback */
1885         ret = gatt_api->client->disconnect(client_id, (bt_bdaddr_t *) device_address, conn_id);
1886         if (ret != BT_STATUS_SUCCESS) {
1887                 BT_ERR("GATT client disconnect failed: %s", status2string(ret));
1888                 return convert_to_oal_status(ret);
1889         }
1890         return OAL_STATUS_SUCCESS;
1891 }
1892
1893
1894 oal_status_t gattc_search_service(int conn_id, oal_uuid_t *service_uuid)
1895 {
1896         int ret = OAL_STATUS_SUCCESS;
1897         char uuid_str[2*BT_UUID_STRING_MAX];
1898
1899         if (service_uuid) {
1900                 uuid_to_stringname(service_uuid, uuid_str);
1901                 API_TRACE("Client Service Search UUID: [%s]", uuid_str);
1902         } else
1903                 API_TRACE("Client Service Search All");
1904
1905         CHECK_OAL_GATT_ENABLED();
1906         CHECK_CLIENT_CONNECTION(conn_id);
1907         ret = gatt_api->client->search_service(conn_id, (bt_uuid_t *)service_uuid);
1908
1909         if (ret != BT_STATUS_SUCCESS) {
1910                 BT_ERR("GATT client service search failed: %s", status2string(ret));
1911                 return convert_to_oal_status(ret);
1912         }
1913         return OAL_STATUS_SUCCESS;
1914 }
1915
1916 oal_status_t gattc_get_characteristic(int conn_id, oal_gatt_srvc_id_t *srvc_id, oal_gatt_id_t *char_id)
1917 {
1918         int ret = OAL_STATUS_SUCCESS;
1919         char uuid_str[2*BT_UUID_STRING_MAX];
1920
1921         OAL_CHECK_PARAMETER(srvc_id, return);
1922         uuid_to_stringname(&(srvc_id->id.uuid), uuid_str);
1923         API_TRACE("Client Get Characteristic, Service_uuid: [%s]", uuid_str);
1924         CHECK_OAL_GATT_ENABLED();
1925         CHECK_CLIENT_CONNECTION(conn_id);
1926         ret = gatt_api->client->get_characteristic(conn_id, (btgatt_srvc_id_t *)srvc_id,
1927                                         (btgatt_gatt_id_t *)char_id);
1928         if (ret != BT_STATUS_SUCCESS) {
1929                 BT_ERR("GATT client get characteristic failed: %s", status2string(ret));
1930                 return convert_to_oal_status(ret);
1931         }
1932         return OAL_STATUS_SUCCESS;
1933 }
1934
1935 oal_status_t gattc_get_descriptor(int conn_id, oal_gatt_srvc_id_t *srvc_id,
1936                                 oal_gatt_id_t *char_id, oal_gatt_id_t *desc_id)
1937 {
1938         int ret = OAL_STATUS_SUCCESS;
1939         char uuid_str1[2*BT_UUID_STRING_MAX];
1940         char uuid_str2[2*BT_UUID_STRING_MAX];
1941
1942         OAL_CHECK_PARAMETER(srvc_id, return);
1943         OAL_CHECK_PARAMETER(char_id, return);
1944         uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
1945         uuid_to_stringname(&(char_id->uuid), uuid_str2);
1946         API_TRACE("Client Get Descriptor, Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
1947         CHECK_OAL_GATT_ENABLED();
1948         CHECK_CLIENT_CONNECTION(conn_id);
1949         ret = gatt_api->client->get_descriptor(conn_id, (btgatt_srvc_id_t *)srvc_id,
1950                                 (btgatt_gatt_id_t *)char_id, (btgatt_gatt_id_t *)desc_id);
1951         if (ret != BT_STATUS_SUCCESS) {
1952                 BT_ERR("GATT client get descriptor failed: %s", status2string(ret));
1953                 return convert_to_oal_status(ret);
1954         }
1955         return OAL_STATUS_SUCCESS;
1956 }
1957
1958 oal_status_t gattc_register_for_notification(int client_id, bt_address_t * address,
1959                         oal_gatt_srvc_id_t *srvc_id, oal_gatt_id_t *char_id) {
1960         int ret = OAL_STATUS_SUCCESS;
1961         char uuid_str1[2*BT_UUID_STRING_MAX];
1962         char uuid_str2[2*BT_UUID_STRING_MAX];
1963         bdstr_t bdstr;
1964
1965         OAL_CHECK_PARAMETER(address, return);
1966         OAL_CHECK_PARAMETER(srvc_id, return);
1967         OAL_CHECK_PARAMETER(char_id, return);
1968         uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
1969         uuid_to_stringname(&(char_id->uuid), uuid_str2);
1970         API_TRACE("Client Register Notification: [%s], Service_uuid: [%s], Char_uuid: [%s]", bdt_bd2str(address, &bdstr), uuid_str1, uuid_str2);
1971         CHECK_OAL_GATT_ENABLED();
1972         CHECK_CLIENT_REGISTRATION(client_id);
1973
1974         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);
1975         if (ret != BT_STATUS_SUCCESS) {
1976                 BT_ERR("GATT client register notification failed: %s", status2string(ret));
1977                 return convert_to_oal_status(ret);
1978         }
1979
1980         return OAL_STATUS_SUCCESS;
1981 }
1982
1983 oal_status_t gattc_deregister_for_notification(int client_id, bt_address_t * address,
1984                         oal_gatt_srvc_id_t *srvc_id, oal_gatt_id_t *char_id) {
1985         int ret = OAL_STATUS_SUCCESS;
1986         char uuid_str1[2*BT_UUID_STRING_MAX];
1987         char uuid_str2[2*BT_UUID_STRING_MAX];
1988         bdstr_t bdstr;
1989
1990         OAL_CHECK_PARAMETER(address, return);
1991         OAL_CHECK_PARAMETER(srvc_id, return);
1992         OAL_CHECK_PARAMETER(char_id, return);
1993         uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
1994         uuid_to_stringname(&(char_id->uuid), uuid_str2);
1995         API_TRACE("Client Deregister Notification: [%s], Service_uuid: [%s], Char_uuid: [%s]", bdt_bd2str(address, &bdstr), uuid_str1, uuid_str2);
1996         CHECK_OAL_GATT_ENABLED();
1997         CHECK_CLIENT_REGISTRATION(client_id);
1998
1999         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);
2000         if (ret != BT_STATUS_SUCCESS) {
2001                 BT_ERR("GATT client deregister notification failed: %s", status2string(ret));
2002                 return convert_to_oal_status(ret);
2003         }
2004
2005         return OAL_STATUS_SUCCESS;
2006 }
2007
2008
2009 oal_status_t gattc_read_characteristic(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2010                                 oal_gatt_id_t *char_id, oal_gatt_auth_req_t auth_req)
2011 {
2012         int ret = OAL_STATUS_SUCCESS;
2013         char uuid_str1[2*BT_UUID_STRING_MAX];
2014         char uuid_str2[2*BT_UUID_STRING_MAX];
2015
2016         OAL_CHECK_PARAMETER(srvc_id, return);
2017         OAL_CHECK_PARAMETER(char_id, return);
2018         uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2019         uuid_to_stringname(&(char_id->uuid), uuid_str2);
2020         API_TRACE("Client Read Characteristic: Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
2021         CHECK_OAL_GATT_ENABLED();
2022         CHECK_CLIENT_CONNECTION(conn_id);
2023
2024         ret = gatt_api->client->read_characteristic(conn_id, (btgatt_srvc_id_t *)srvc_id,
2025                                         (btgatt_gatt_id_t *)char_id, auth_req);
2026         if (ret != BT_STATUS_SUCCESS) {
2027                 BT_ERR("GATT client read characteristic failed: %s", status2string(ret));
2028                 return convert_to_oal_status(ret);
2029         }
2030
2031         return OAL_STATUS_SUCCESS;
2032 }
2033
2034 oal_status_t gattc_read_descriptor(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2035                 oal_gatt_id_t *char_id, oal_gatt_id_t *desc_id, oal_gatt_auth_req_t auth_req)
2036 {
2037         int ret = OAL_STATUS_SUCCESS;
2038         char uuid_str1[2*BT_UUID_STRING_MAX];
2039         char uuid_str2[2*BT_UUID_STRING_MAX];
2040         char uuid_str3[2*BT_UUID_STRING_MAX];
2041
2042         OAL_CHECK_PARAMETER(srvc_id, return);
2043         OAL_CHECK_PARAMETER(char_id, return);
2044         OAL_CHECK_PARAMETER(desc_id, return);
2045         uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2046         uuid_to_stringname(&(char_id->uuid), uuid_str2);
2047         uuid_to_stringname(&(desc_id->uuid), uuid_str3);
2048         API_TRACE("Client Read Descriptor: Service_uuid: [%s], Char_uuid: [%s], Desc_uuid: [%s]",
2049                         uuid_str1, uuid_str2, uuid_str3);
2050         CHECK_OAL_GATT_ENABLED();
2051         CHECK_CLIENT_CONNECTION(conn_id);
2052
2053         ret = gatt_api->client->read_descriptor(conn_id, (btgatt_srvc_id_t *)srvc_id,
2054                                 (btgatt_gatt_id_t *)char_id, (btgatt_gatt_id_t *)desc_id, auth_req);
2055         if (ret != BT_STATUS_SUCCESS) {
2056                 BT_ERR("GATT client read descriptor failed: %s", status2string(ret));
2057                 return convert_to_oal_status(ret);
2058         }
2059
2060         return OAL_STATUS_SUCCESS;
2061 }
2062
2063 oal_status_t gattc_acquire_notify(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2064                 oal_gatt_id_t *char_id,  int *fd, int *mtu)
2065 {
2066         int ret = OAL_STATUS_SUCCESS;
2067         char uuid_str1[2*BT_UUID_STRING_MAX];
2068         char uuid_str2[2*BT_UUID_STRING_MAX];
2069         OAL_CHECK_PARAMETER(srvc_id, return);
2070         OAL_CHECK_PARAMETER(char_id, return);
2071         uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2072         uuid_to_stringname(&(char_id->uuid), uuid_str2);
2073         API_TRACE("Client Write Characteristic: Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
2074         CHECK_OAL_GATT_ENABLED();
2075         CHECK_CLIENT_CONNECTION(conn_id);
2076
2077         ret = gatt_api->client->acquire_notify(conn_id, (btgatt_srvc_id_t *)srvc_id,
2078                         (btgatt_gatt_id_t *)char_id, fd, mtu);
2079         if (ret != BT_STATUS_SUCCESS) {
2080                 BT_ERR("GATT client write characteristic failed: %s", status2string(ret));
2081                 return convert_to_oal_status(ret);
2082         }
2083
2084         return OAL_STATUS_SUCCESS;
2085 }
2086
2087 oal_status_t gattc_acquire_write(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2088                 oal_gatt_id_t *char_id,  oal_gatt_auth_req_t auth_req , int *fd, int*mtu)
2089 {
2090         int ret = OAL_STATUS_SUCCESS;
2091         char uuid_str1[2*BT_UUID_STRING_MAX];
2092         char uuid_str2[2*BT_UUID_STRING_MAX];
2093         OAL_CHECK_PARAMETER(srvc_id, return);
2094         OAL_CHECK_PARAMETER(char_id, return);
2095         uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2096         uuid_to_stringname(&(char_id->uuid), uuid_str2);
2097         API_TRACE("Client Write Characteristic: Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
2098         CHECK_OAL_GATT_ENABLED();
2099         CHECK_CLIENT_CONNECTION(conn_id);
2100
2101         ret = gatt_api->client->acquire_write(conn_id, (btgatt_srvc_id_t *)srvc_id,
2102                         (btgatt_gatt_id_t *)char_id,  auth_req, fd, mtu);
2103         if (ret != BT_STATUS_SUCCESS) {
2104                 BT_ERR("GATT client write characteristic failed: %s", status2string(ret));
2105                 return convert_to_oal_status(ret);
2106         }
2107
2108         return OAL_STATUS_SUCCESS;
2109 }
2110
2111 oal_status_t gattc_write_characteristic(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2112                 oal_gatt_id_t *char_id, oal_gatt_write_type_t write_type,
2113                 int len, oal_gatt_auth_req_t auth_req, char* data)
2114 {
2115         int ret = OAL_STATUS_SUCCESS;
2116         char uuid_str1[2*BT_UUID_STRING_MAX];
2117         char uuid_str2[2*BT_UUID_STRING_MAX];
2118         OAL_CHECK_PARAMETER(srvc_id, return);
2119         OAL_CHECK_PARAMETER(char_id, return);
2120         OAL_CHECK_PARAMETER(data, return);
2121         uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2122         uuid_to_stringname(&(char_id->uuid), uuid_str2);
2123         API_TRACE("Client Write Characteristic: Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
2124         CHECK_OAL_GATT_ENABLED();
2125         CHECK_CLIENT_CONNECTION(conn_id);
2126
2127         ret = gatt_api->client->write_characteristic(conn_id, (btgatt_srvc_id_t *)srvc_id,
2128                         (btgatt_gatt_id_t *)char_id, write_type, len, auth_req, data);
2129         if (ret != BT_STATUS_SUCCESS) {
2130                 BT_ERR("GATT client write characteristic failed: %s", status2string(ret));
2131                 return convert_to_oal_status(ret);
2132         }
2133
2134         return OAL_STATUS_SUCCESS;
2135 }
2136
2137 oal_status_t gattc_write_descriptor(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2138                 oal_gatt_id_t *char_id, oal_gatt_id_t *desc_id,
2139                 oal_gatt_write_type_t write_type, int len, oal_gatt_auth_req_t auth_req, char* data)
2140 {
2141         int ret = OAL_STATUS_SUCCESS;
2142         char uuid_str1[2*BT_UUID_STRING_MAX];
2143         char uuid_str2[2*BT_UUID_STRING_MAX];
2144         char uuid_str3[2*BT_UUID_STRING_MAX];
2145         OAL_CHECK_PARAMETER(srvc_id, return);
2146         OAL_CHECK_PARAMETER(char_id, return);
2147         OAL_CHECK_PARAMETER(desc_id, return);
2148         OAL_CHECK_PARAMETER(data, return);
2149         uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2150         uuid_to_stringname(&(char_id->uuid), uuid_str2);
2151         uuid_to_stringname(&(desc_id->uuid), uuid_str3);
2152         API_TRACE("Client Write Descriptor: Service_uuid: [%s], Char_uuid: [%s], Desc_uuid: [%s]",
2153                                 uuid_str1, uuid_str2, uuid_str3);
2154         CHECK_OAL_GATT_ENABLED();
2155         CHECK_CLIENT_CONNECTION(conn_id);
2156
2157         ret = gatt_api->client->write_descriptor(conn_id, (btgatt_srvc_id_t *)srvc_id,
2158                         (btgatt_gatt_id_t *)char_id, (btgatt_gatt_id_t *)desc_id, write_type, len, auth_req, data);
2159         if (ret != BT_STATUS_SUCCESS) {
2160                 BT_ERR("GATT client write characteristic failed: %s", status2string(ret));
2161                 return convert_to_oal_status(ret);
2162         }
2163
2164         return OAL_STATUS_SUCCESS;
2165 }
2166
2167 oal_status_t gattc_conn_param_update(bt_address_t * address, int min, int max, int latency, int timeout)
2168 {
2169         int ret;
2170         bdstr_t bdstr;
2171
2172         OAL_CHECK_PARAMETER(address, return);
2173         API_TRACE("Conn Param Update: [%s]", bdt_bd2str(address, &bdstr));
2174         CHECK_OAL_GATT_ENABLED();
2175
2176         BT_INFO("[%s] min[%d] max[%d] latency[%d] timeout[%d]", bdt_bd2str(address, &bdstr), min, max, latency, timeout);
2177         ret = gatt_api->client->conn_parameter_update((bt_bdaddr_t *)address, min, max, latency, timeout);
2178         if (ret != BT_STATUS_SUCCESS) {
2179                 BT_ERR("error: %s", status2string(ret));
2180                 return convert_to_oal_status(ret);
2181         }
2182         return OAL_STATUS_SUCCESS;
2183 }
2184
2185 oal_status_t gattc_unregister_scan_filter(int slot_id)
2186 {
2187         int ret;
2188         int client_if = 0;
2189
2190         API_TRACE("");
2191         CHECK_OAL_GATT_ENABLED();
2192
2193         BT_INFO("Remove Scan filter Slot ID is: [%d]", slot_id);
2194
2195         ret = gatt_api->client->scan_filter_clear(client_if, slot_id);
2196         if (ret != BT_STATUS_SUCCESS) {
2197                 BT_ERR("error: %s", status2string(ret));
2198                 return convert_to_oal_status(ret);
2199         }
2200         return OAL_STATUS_SUCCESS;
2201 }
2202
2203 oal_status_t gattc_enable_scan_filter(int client_if)
2204 {
2205         int ret;
2206
2207         API_TRACE("");
2208         CHECK_OAL_GATT_ENABLED();
2209
2210         BT_INFO("Enable Scan filter. Client If: %d", client_if);
2211
2212         ret = gatt_api->client->scan_filter_enable(client_if, TRUE);
2213         if (ret != BT_STATUS_SUCCESS) {
2214                 BT_ERR("error: %s", status2string(ret));
2215                 return convert_to_oal_status(ret);
2216         }
2217         return OAL_STATUS_SUCCESS;
2218 }
2219
2220 oal_status_t gattc_disable_scan_filter(int client_if)
2221 {
2222         int ret;
2223
2224         API_TRACE("");
2225         CHECK_OAL_GATT_ENABLED();
2226
2227         BT_INFO("Disable Scan filter. Client If: %d", client_if);
2228
2229         ret = gatt_api->client->scan_filter_enable(client_if, FALSE);
2230         if (ret != BT_STATUS_SUCCESS) {
2231                 BT_ERR("error: %s", status2string(ret));
2232                 return convert_to_oal_status(ret);
2233         }
2234         return OAL_STATUS_SUCCESS;
2235 }
2236
2237 oal_status_t gattc_register_scan_filter(oal_ble_scan_filter_t* filter_data)
2238 {
2239         int ret;
2240         int client_info = 0;
2241         int action = 0;
2242         int company_id = 0;
2243         int company_id_mask = 0;
2244         int address_type = 0;
2245         int feature_selection = 0;
2246
2247         oal_ble_scan_filter_param_setup_t scan_filter_setup = {.list_logic_type = 0,
2248                                                                 .filt_logic_type = 1,
2249                                                                 .rssi_high_thres = -127,
2250                                                                 .rssi_low_thres = -127,
2251                                                                 .dely_mode = 0,
2252                                                                 .found_timeout = 0,
2253                                                                 .lost_timeout = 0,
2254                                                                 .found_timeout_cnt = 0
2255                                                                 };
2256
2257         OAL_CHECK_PARAMETER(filter_data, return);
2258         API_TRACE();
2259         CHECK_OAL_GATT_ENABLED();
2260
2261         if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS){
2262                 bdstr_t bdstr;
2263                 BT_INFO("OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS is being added");
2264                 BT_INFO("BT remote Device address is %s", bdt_bd2str(filter_data->device_address, &bdstr));
2265                 ret = gatt_api->client->scan_filter_add_remove(client_info,
2266                                                                 action,
2267                                                                 OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS,
2268                                                                 filter_data->slot_id,
2269                                                                 company_id,
2270                                                                 company_id_mask,
2271                                                                 NULL,
2272                                                                 NULL,
2273                                                                 (bt_bdaddr_t*)filter_data->device_address,
2274                                                                 address_type,
2275                                                                 0,
2276                                                                 NULL,
2277                                                                 0,
2278                                                                 NULL
2279                                                                 );
2280                 if (ret != BT_STATUS_SUCCESS){
2281                         BT_ERR("error: %s", status2string(ret));
2282                         BT_INFO("unregistering already set filter features.");
2283                         gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
2284                         return convert_to_oal_status(ret);
2285                 }
2286
2287                 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS;
2288         }
2289         if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_NAME){
2290                 ret = gatt_api->client->scan_filter_add_remove(client_info,
2291                                                                 action,
2292                                                                 OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_NAME,
2293                                                                 filter_data->slot_id,
2294                                                                 company_id,
2295                                                                 company_id_mask,
2296                                                                 NULL,
2297                                                                 NULL,
2298                                                                 NULL,
2299                                                                 address_type,
2300                                                                 0,
2301                                                                 filter_data->device_name,     // device_name as p_data in HAL
2302                                                                 0,
2303                                                                 NULL
2304                                                                 );
2305                 if (ret != BT_STATUS_SUCCESS){
2306                         BT_ERR("error: %s", status2string(ret));
2307                         BT_INFO("unregistering already set filter features.");
2308                         gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
2309                         return convert_to_oal_status(ret);
2310                 }
2311
2312                 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_NAME;
2313         }
2314         if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_UUID){
2315                 BT_INFO("OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_UUID is being added");
2316                 char uuid_str1[2*BT_UUID_STRING_MAX];
2317                 char uuid_str2[2*BT_UUID_STRING_MAX];
2318
2319                 uuid_to_stringname((service_uuid_t*)filter_data->service_uuid, uuid_str1);
2320                 uuid_to_stringname((service_uuid_t*)filter_data->service_uuid_mask, uuid_str2);
2321
2322                 BT_INFO("Service UUID  is [%s] and Service UUID mask is [%s]", uuid_str1, uuid_str2);
2323                 ret = gatt_api->client->scan_filter_add_remove(client_info,
2324                                                                 action,
2325                                                                 OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_UUID,
2326                                                                 filter_data->slot_id,
2327                                                                 company_id,
2328                                                                 company_id_mask,
2329                                                                 (bt_uuid_t*)filter_data->service_uuid,
2330                                                                 (bt_uuid_t*)filter_data->service_uuid_mask,
2331                                                                 NULL,
2332                                                                 address_type,
2333                                                                 filter_data->service_uuid_len,   // service_uuid_len as data_len in HAL
2334                                                                 NULL,
2335                                                                 filter_data->service_uuid_mask_len,
2336                                                                 NULL
2337                                                                 );
2338                 if (ret != BT_STATUS_SUCCESS){
2339                         BT_ERR("error: %s", status2string(ret));
2340                         BT_INFO("unregistering already set filter features.");
2341                         gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
2342                         return convert_to_oal_status(ret);
2343                 }
2344
2345                 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_UUID;
2346         }
2347         if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID){
2348                 BT_INFO("OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID is being added");
2349                 char uuid_str1[2*BT_UUID_STRING_MAX];
2350                 char uuid_str2[2*BT_UUID_STRING_MAX];
2351                 uuid_to_stringname((service_uuid_t*)filter_data->service_solicitation_uuid, uuid_str1);
2352                 uuid_to_stringname((service_uuid_t*)filter_data->service_solicitation_uuid_mask, uuid_str2);
2353                 BT_INFO("Service Solicitation UUID  is [%s] and Service Solicitation UUID mask is [%s]", uuid_str1, uuid_str2);
2354                 ret = gatt_api->client->scan_filter_add_remove(client_info,
2355                                                                 action,
2356                                                                 OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID,
2357                                                                 filter_data->slot_id,
2358                                                                 company_id,
2359                                                                 company_id_mask,
2360                                                                 (bt_uuid_t*)filter_data->service_solicitation_uuid,
2361                                                                 (bt_uuid_t*)filter_data->service_solicitation_uuid_mask,
2362                                                                 NULL,
2363                                                                 address_type,
2364                                                                 filter_data->service_solicitation_uuid_len,   // service_solicitation_uuid_len as data_len in HAL
2365                                                                 NULL,
2366                                                                 filter_data->service_solicitation_uuid_mask_len,
2367                                                                 NULL
2368                                                                 );
2369                 if (ret != BT_STATUS_SUCCESS){
2370                         BT_ERR("error: %s", status2string(ret));
2371                         BT_INFO("unregistering already set filter features.");
2372                         gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
2373                         return convert_to_oal_status(ret);
2374                 }
2375
2376                 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID;
2377         }
2378         if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_DATA){
2379                 ret = gatt_api->client->scan_filter_add_remove(client_info,
2380                                                                 action,
2381                                                                 OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_DATA,
2382                                                                 filter_data->slot_id,
2383                                                                 company_id,
2384                                                                 company_id_mask,
2385                                                                 NULL,
2386                                                                 NULL,
2387                                                                 NULL,
2388                                                                 address_type,
2389                                                                 filter_data->service_data_len,    //service_data_len as data_len in HAL
2390                                                                 (char*)filter_data->service_data,
2391                                                                 filter_data->service_data_mask_len,
2392                                                                 (char*)filter_data->service_data_mask
2393                                                                 );
2394                 if (ret != BT_STATUS_SUCCESS){
2395                         BT_ERR("error: %s", status2string(ret));
2396                         BT_INFO("unregistering already set filter features.");
2397                         gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
2398                         return convert_to_oal_status(ret);
2399                 }
2400
2401                 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_DATA;
2402         }
2403         if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA){
2404                 ret = gatt_api->client->scan_filter_add_remove(client_info,
2405                                                                 action,
2406                                                                 OAL_BLE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA,
2407                                                                 filter_data->slot_id,
2408                                                                 filter_data->manufacturer_id,
2409                                                                 company_id_mask,
2410                                                                 NULL,
2411                                                                 NULL,
2412                                                                 NULL,
2413                                                                 address_type,
2414                                                                 filter_data->manufacturer_data_len,    //manufacturer_data_len as data_len in HAL
2415                                                                 (char*)filter_data->manufacturer_data,
2416                                                                 filter_data->manufacturer_data_mask_len,
2417                                                                 (char*)filter_data->manufacturer_data_mask
2418                                                                 );
2419                 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA;
2420                 if (ret != BT_STATUS_SUCCESS){
2421                         BT_ERR("error: %s", status2string(ret));
2422                         BT_INFO("unregistering already set filter features.");
2423                         gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
2424                         return convert_to_oal_status(ret);
2425                 }
2426
2427                 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA;
2428         }
2429
2430         BT_DBG("Filter selection 0x%.2x", feature_selection);
2431
2432         ret = gatt_api->client->scan_filter_param_setup(client_info, action, filter_data->slot_id, feature_selection,
2433                                                         scan_filter_setup.list_logic_type, scan_filter_setup.filt_logic_type,
2434                                                         scan_filter_setup.rssi_high_thres, scan_filter_setup.rssi_low_thres,
2435                                                         scan_filter_setup.dely_mode, scan_filter_setup.found_timeout,
2436                                                         scan_filter_setup.lost_timeout, scan_filter_setup.found_timeout_cnt);
2437         if (ret != BT_STATUS_SUCCESS){
2438                 BT_ERR("error: %s", status2string(ret));
2439                 return convert_to_oal_status(ret);
2440         }
2441         return OAL_STATUS_SUCCESS;
2442 }
2443
2444 oal_status_t gattc_configure_mtu(int conn_id, int mtu)
2445 {
2446         int ret;
2447
2448         API_TRACE("Configure MTU Size: [%d]", mtu);
2449         CHECK_OAL_GATT_ENABLED();
2450         CHECK_CLIENT_CONNECTION(conn_id);
2451
2452         /* To prevent crash in case other libraries not support this api */
2453         if (gatt_api->client->configure_mtu == NULL) {
2454                 BT_WARN("configure_mtu is NULL");
2455                 return OAL_STATUS_NOT_SUPPORT;
2456         }
2457
2458         ret = gatt_api->client->configure_mtu(conn_id, mtu);
2459         if (ret != BT_STATUS_SUCCESS) {
2460                 BT_ERR("Gatt client configure_mtu error: %s", status2string(ret));
2461                 return convert_to_oal_status(ret);
2462         }
2463         return OAL_STATUS_SUCCESS;
2464 }