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