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, uint8_t addr_type, 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, uint8_t addr_type, 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->addr_type = addr_type;
1420         event->rssi = rssi;
1421         memcpy(event->address.addr, bdaddress->address, BT_ADDRESS_BYTES_NUM);
1422         memcpy(event->adv_data, adv_data, BLE_ADV_DATA_LENGTH);
1423         event->adv_data_len = adv_data_len;
1424         memcpy(event->scan_rsp_data, scan_rsp_data, BLE_ADV_DATA_LENGTH);
1425         event->scan_rsp_data_len = scan_rsp_data_len;
1426         send_event_bda_trace(OAL_EVENT_BLE_REMOTE_DEVICE_FOUND, event,
1427                         sizeof(event_ble_scan_result_info), (bt_address_t *)bdaddress);
1428 }
1429
1430 static void cb_gattc_connection(int conn_id, int status, int client_if, bt_bdaddr_t* bda)
1431 {
1432         event_gattc_conn_t *event;
1433         BT_INFO("BTGATT CLIENT CONNECTED CB, status:[%d] client_if[%d] id[%d]",
1434                                                         status, client_if, conn_id);
1435
1436         event = g_new0(event_gattc_conn_t, 1);
1437         memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1438         event->client_if = client_if;
1439
1440         if (BT_STATUS_SUCCESS != status) {
1441                 event->status = OAL_STATUS_INTERNAL_ERROR;
1442                 BT_ERR("gattc connection Error: %d", status);
1443         } else {
1444                 event->conn_id = conn_id;
1445                 event->status = OAL_STATUS_SUCCESS;
1446         }
1447
1448         send_event_bda_trace(OAL_EVENT_GATTC_CONNECTION_COMPLETED, event,
1449                                         sizeof(*event), (bt_address_t *)bda);
1450 }
1451
1452
1453 static void cb_gattc_disconnect(int conn_id, int status, int client_if, bt_bdaddr_t* bda)
1454 {
1455         event_gattc_conn_t *event;
1456         BT_INFO("BTGATT Client Disconnect Complete cb, status:[%d], client_if[%d] id[%d]",
1457                                                         status, client_if, conn_id);
1458         event = g_new0(event_gattc_conn_t, 1);
1459         event->status = convert_to_oal_status(status);
1460         event->client_if = client_if;
1461         event->conn_id = conn_id;
1462         memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1463         send_event_bda_trace(OAL_EVENT_GATTC_DISCONNECTION_COMPLETED, event,
1464                                         sizeof(*event), (bt_address_t *)bda);
1465 }
1466
1467 static void cb_gattc_search_result(int conn_id, btgatt_srvc_id_t *srvc_id)
1468 {
1469         char uuid_str[2*BT_UUID_STRING_MAX];
1470
1471         BT_INFO("BTGATT Client Service Search Result cb, conn_id:%d", conn_id);
1472
1473         uuid_to_stringname((oal_uuid_t *)&(srvc_id->id.uuid), uuid_str);
1474         BT_INFO("Service=> [%s], Inst_id [%u], Type [%s]",
1475                 uuid_str, srvc_id->id.inst_id, srvc_id->is_primary ? "Primary" : "Secondary");
1476
1477         event_gattc_service_result_t *event = g_new0(event_gattc_service_result_t, 1);
1478         event->conn_status.status = OAL_STATUS_SUCCESS;
1479         event->conn_status.conn_id = conn_id;
1480         memcpy(&(event->srvc_id), srvc_id, sizeof(oal_gatt_srvc_id_t));
1481
1482         send_event(OAL_EVENT_GATTC_SERVICE_SEARCH_RESULT, event, sizeof(*event));
1483 }
1484
1485 static void cb_gattc_search_complete(int conn_id, int status)
1486 {
1487         BT_INFO("BTGATT Client Service Search Complete cb, status:%d, conn_id:%d",
1488         status, conn_id);
1489
1490         event_gattc_conn_status_t *event = g_new0(event_gattc_conn_status_t, 1);
1491         event->conn_id = conn_id;
1492         event->status = convert_to_oal_status(status);
1493
1494         send_event(OAL_EVENT_GATTC_SERVICE_SEARCH_DONE, event, sizeof(*event));
1495 }
1496
1497
1498 static void cb_gattc_get_characteristics(int conn_id, int status, btgatt_srvc_id_t *srvc_id,
1499                                                 btgatt_gatt_id_t *char_id, int char_prop)
1500 {
1501         char uuid_str1[2*BT_UUID_STRING_MAX];
1502         char uuid_str2[2*BT_UUID_STRING_MAX];
1503         char str[50];
1504
1505         BT_INFO("BTGATT Client Get Characteristic Callback, conn_id:%d, status:%d", conn_id, status);
1506         uuid_to_stringname((oal_uuid_t *)&(srvc_id->id.uuid), uuid_str1);
1507         BT_INFO("Service=> [%s], Inst_id [%u], Type [%s]",
1508                 uuid_str1, srvc_id->id.inst_id, srvc_id->is_primary ? "Primary" : "Secondary");
1509
1510         event_gattc_characteristic_result_t *event = g_new0(event_gattc_characteristic_result_t, 1);
1511         event->conn_status.conn_id = conn_id;
1512         event->conn_status.status = convert_to_oal_status(status);
1513         memcpy(&(event->srvc_id), srvc_id, sizeof(oal_gatt_srvc_id_t));
1514
1515         if (status == 0) {
1516                 uuid_to_stringname((oal_uuid_t *)&(char_id->uuid), uuid_str2);
1517                 BT_INFO("Charac => [%s], Inst_id [%u], Prop [%s]",
1518                         uuid_str2, char_id->inst_id, char_prop_to_string(char_prop, str));
1519                 event->char_prop = char_prop;
1520                 memcpy(&(event->char_id), char_id, sizeof(oal_gatt_id_t));
1521         }
1522         send_event(OAL_EVENT_GATTC_CHARAC_SERACH_RESULT, event, sizeof(*event));
1523 }
1524
1525
1526
1527 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)
1528 {
1529         char uuid_str1[2*BT_UUID_STRING_MAX];
1530         char uuid_str2[2*BT_UUID_STRING_MAX];
1531         char uuid_str3[2*BT_UUID_STRING_MAX];
1532         BT_INFO("BTGATT Client Get Descriptor Callback, conn_id:%d, status:%d", conn_id, status);
1533         uuid_to_stringname((oal_uuid_t *)&(srvc_id->id.uuid), uuid_str1);
1534         uuid_to_stringname((oal_uuid_t *)&(char_id->uuid), uuid_str2);
1535         BT_INFO("Service=> [%s], Inst_id [%u], Type [%s]",
1536                 uuid_str1, srvc_id->id.inst_id, srvc_id->is_primary ? "Primary" : "Secondary");
1537         BT_INFO("Charac => [%s], Inst_id [%u]", uuid_str2, char_id->inst_id);
1538
1539         event_gattc_descriptor_result_t *event = g_new0(event_gattc_descriptor_result_t, 1);
1540         event->conn_status.conn_id = conn_id;
1541         event->conn_status.status = convert_to_oal_status(status);
1542         memcpy(&(event->srvc_id), srvc_id, sizeof(oal_gatt_srvc_id_t));
1543         memcpy(&(event->char_id), char_id, sizeof(oal_gatt_id_t));
1544
1545         if (status == 0) {
1546                 uuid_to_stringname((oal_uuid_t *)&(descr_id->uuid), uuid_str3);
1547                 BT_INFO("Desc   => [%s], Inst_id [%u]", uuid_str3, descr_id->inst_id);
1548                 memcpy(&(event->descr_id), descr_id, sizeof(oal_gatt_id_t));
1549         }
1550         send_event(OAL_EVENT_GATTC_DESC_SERACH_RESULT, event, sizeof(*event));
1551 }
1552
1553 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)
1554 {
1555         char uuid_str1[2*BT_UUID_STRING_MAX];
1556         char uuid_str2[2*BT_UUID_STRING_MAX];
1557         BT_INFO("BTGATT Client Register For Notification Callback, client_if:%d, status:%d, registered: %s",
1558                 client_if, status, registered == 1 ? "REGISTERED" : "DEREGISTERED");
1559         uuid_to_stringname((oal_uuid_t *)&(srvc_id->id.uuid), uuid_str1);
1560         uuid_to_stringname((oal_uuid_t *)&(char_id->uuid), uuid_str2);
1561         BT_INFO("Service=> [%s], Inst_id [%u], Type [%s]", uuid_str1, srvc_id->id.inst_id, srvc_id->is_primary ? "Primary" : "Secondary");
1562         BT_INFO("Charac => [%s], Inst_id [%u]", uuid_str2, char_id->inst_id);
1563
1564         event_gattc_regdereg_notify_t *event = g_new0(event_gattc_regdereg_notify_t, 1);
1565         oal_event_t event_type = (registered == 1 ? OAL_EVENT_GATTC_NOTIFICATION_REGISTERED : OAL_EVENT_GATTC_NOTIFICATION_DEREGISTERED);
1566         event->client_if = client_if;
1567         event->status = convert_to_oal_status(status);
1568         memcpy(&(event->srvc_id), srvc_id, sizeof(oal_gatt_srvc_id_t));
1569         memcpy(&(event->char_id), char_id, sizeof(oal_gatt_id_t));
1570
1571         send_event(event_type, event, sizeof(*event));
1572 }
1573
1574 static void cb_gattc_notify(int conn_id, btgatt_notify_params_t *p_data)
1575 {
1576         bdstr_t bdstr;
1577         char uuid_str1[2*BT_UUID_STRING_MAX];
1578         char uuid_str2[2*BT_UUID_STRING_MAX];
1579
1580         BT_INFO("BTGATT Client Notify Callback, conn_id:%d", conn_id);
1581         BT_INFO("Server Address:[%s], is_notify:[%d], len:[%d]",
1582                 bdt_bd2str((bt_address_t *)&(p_data->bda), &bdstr), p_data->is_notify, p_data->len);
1583
1584         uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
1585         uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
1586
1587         BT_INFO("Service=> [%s], Inst_id [%u], Type [%s]",
1588                 uuid_str1, p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
1589         BT_INFO("Charac => [%s], Inst_id [%u]", uuid_str2, p_data->char_id.inst_id);
1590
1591         if (p_data->len > 0) {
1592                 char *data = NULL;
1593                 data = g_malloc(3*p_data->len+1);
1594                 if (!data) {
1595                         BT_ERR("memory allocation failed");
1596                         return;
1597                 }
1598
1599                 convert_hex_2_str((unsigned char *)p_data->value, p_data->len, data);
1600                 BT_INFO("Notified Data: [%s]", data);
1601
1602                 event_gattc_notify_data *event = g_new0(event_gattc_notify_data, 1);
1603                 memcpy(event->address.addr, p_data->bda.address, BT_ADDRESS_BYTES_NUM);
1604                 event->is_notify = p_data->is_notify;
1605                 event->data_len = p_data->len;
1606                 memcpy(event->data, p_data->value, event->data_len);
1607                 memcpy(&(event->char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
1608                 memcpy(&(event->srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
1609
1610                 send_event_bda_trace(OAL_EVENT_GATTC_NOTIFY_DATA, event, sizeof(*event), (bt_address_t *)&p_data->bda);
1611                 g_free(data);
1612         }
1613 }
1614
1615 static void cb_gattc_service_changed(bt_bdaddr_t *bd_addr, int change_type, uint8_t *uuid, int conn_id, int inst_id)
1616 {
1617         event_gattc_service_changed_data *event = g_new0(event_gattc_service_changed_data, 1);
1618
1619         memcpy(event->address.addr, bd_addr->address, 6);
1620         event->change_type = change_type;
1621         memcpy(event->uuid.uuid, uuid, sizeof(event->uuid.uuid));
1622         event->conn_id = conn_id;
1623         event->inst_id = inst_id;
1624
1625         send_event_bda_trace(OAL_EVENT_GATTC_SERVICE_CHANGED_IND, event, sizeof(*event), (bt_address_t *)bd_addr);
1626 }
1627
1628 static void cb_gattc_read_characteristic(int conn_id, int status, btgatt_read_params_t *p_data)
1629 {
1630         char uuid_str1[2*BT_UUID_STRING_MAX];
1631         char uuid_str2[2*BT_UUID_STRING_MAX];
1632         BT_INFO("BTGATT Client Read Charcateristic Callback, conn_id:%d, read_status:%d", conn_id, status);
1633
1634         event_gattc_read_data *event = g_new0(event_gattc_read_data, 1);
1635         event->uuid_status.conn_status.conn_id = conn_id;
1636         event->uuid_status.conn_status.status = convert_to_oal_status(status);
1637         event->value_type = p_data->value_type;
1638         memcpy(&(event->uuid_status.srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
1639         memcpy(&(event->uuid_status.char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
1640         if (status == 0) {
1641                 uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
1642                 uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
1643                 BT_INFO("Service=> [%s], Inst_id [%u], Type [%s]", uuid_str1,
1644                         p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
1645                 BT_INFO("Charac => [%s], Inst_id [%u]", uuid_str2, p_data->char_id.inst_id);
1646                 BT_DBG("Len: %u, value_type: %u", p_data->value.len, p_data->value_type);
1647                 if (p_data->value.len > 0 && event->value_type == GATTC_READ_VALUE_TYPE_VALUE) {
1648                         char *data = NULL;
1649                         data = g_malloc(3*p_data->value.len+1);
1650                         if (!data) {
1651                                 BT_ERR("memory allocation failed");
1652                                 g_free(event);
1653                                 return;
1654                         }
1655                         convert_hex_2_str((unsigned char *)p_data->value.value, p_data->value.len, data);
1656                         BT_DBG("Read Data: [%s]", data);
1657                         event->data_len = p_data->value.len;
1658                         memcpy(&(event->data), &(p_data->value.value), event->data_len);
1659                         g_free(data);
1660                 }
1661         }
1662         send_event(OAL_EVENT_GATTC_READ_CHARAC, event, sizeof(*event));
1663 }
1664
1665 static void cb_gattc_write_characteristic(int conn_id, int status, btgatt_write_params_t *p_data)
1666 {
1667         char uuid_str1[2*BT_UUID_STRING_MAX];
1668         char uuid_str2[2*BT_UUID_STRING_MAX];
1669         BT_INFO("BTGATT Client Write Charcateristic Callback, conn_id:%d, write_status:%d", conn_id, status);
1670
1671         event_gattc_write_data *event = g_new0(event_gattc_write_data, 1);
1672         event->conn_status.conn_id = conn_id;
1673         event->conn_status.status = convert_to_oal_status(status);
1674         memcpy(&(event->srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
1675         memcpy(&(event->char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
1676         if (status == 0) {
1677                 uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
1678                 uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
1679                 BT_INFO("Service=> [%s], Inst_id [%u], Type [%s]", uuid_str1,
1680                         p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
1681                 BT_INFO("Charac => [%s], Inst_id [%u]", uuid_str2, p_data->char_id.inst_id);
1682         }
1683         send_event(OAL_EVENT_GATTC_WRITE_CHARAC, event, sizeof(*event));
1684 }
1685
1686 static void cb_gattc_write_descriptor(int conn_id, int status, btgatt_write_params_t *p_data)
1687 {
1688         char uuid_str1[2*BT_UUID_STRING_MAX];
1689         char uuid_str2[2*BT_UUID_STRING_MAX];
1690         char uuid_str3[2*BT_UUID_STRING_MAX];
1691         BT_INFO("BTGATT Client Write Descriptor Callback, conn_id:%d, write_status:%d", conn_id, status);
1692
1693         event_gattc_write_data *event = g_new0(event_gattc_write_data, 1);
1694         event->conn_status.conn_id = conn_id;
1695         event->conn_status.status = convert_to_oal_status(status);
1696         memcpy(&(event->srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
1697         memcpy(&(event->char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
1698         memcpy(&(event->descr_id), &(p_data->descr_id), sizeof(oal_gatt_id_t));
1699         if (status == 0) {
1700                 uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
1701                 uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
1702                 uuid_to_stringname((oal_uuid_t *)&(p_data->descr_id.uuid), uuid_str3);
1703                 BT_INFO("Service=> [%s], Inst_id [%u], Type [%s]", uuid_str1,
1704                         p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
1705                 BT_INFO("Charac => [%s], Inst_id [%u]", uuid_str2, p_data->char_id.inst_id);
1706                 BT_INFO("Desc   => [%s], Inst_id [%u]", uuid_str3, p_data->descr_id.inst_id);
1707         }
1708         send_event(OAL_EVENT_GATTC_WRITE_DESCR, event, sizeof(*event));
1709 }
1710
1711
1712
1713 static void cb_gattc_read_descriptor(int conn_id, int status, btgatt_read_params_t *p_data)
1714 {
1715         char uuid_str1[2*BT_UUID_STRING_MAX];
1716         char uuid_str2[2*BT_UUID_STRING_MAX];
1717         char uuid_str3[2*BT_UUID_STRING_MAX];
1718         BT_INFO("BTGATT Client Read Descriptor Callback, conn_id:%d, read_status:%d", conn_id, status);
1719
1720         event_gattc_read_data *event = g_new0(event_gattc_read_data, 1);
1721         event->uuid_status.conn_status.conn_id = conn_id;
1722         event->uuid_status.conn_status.status = convert_to_oal_status(status);
1723         event->value_type = p_data->value_type;
1724         memcpy(&(event->uuid_status.srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
1725         memcpy(&(event->uuid_status.char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
1726         memcpy(&(event->uuid_status.descr_id), &(p_data->descr_id), sizeof(oal_gatt_id_t));
1727
1728         if (status == 0) {
1729                 uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
1730                 uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
1731                 uuid_to_stringname((oal_uuid_t *)&(p_data->descr_id.uuid), uuid_str3);
1732                 BT_INFO("Service=> [%s], Inst_id [%u], Type [%s]", uuid_str1,
1733                         p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
1734                 BT_INFO("Charac => [%s], Inst_id [%u]", uuid_str2, p_data->char_id.inst_id);
1735                 BT_INFO("Desc   => [%s], Inst_id [%u]", uuid_str3, p_data->descr_id.inst_id);
1736                 BT_DBG("Len: %u, value_type: %u", p_data->value.len, p_data->value_type);
1737                 if (p_data->value.len > 0 && event->value_type == GATTC_READ_VALUE_TYPE_VALUE) {
1738                         char *data = NULL;
1739                         data = g_malloc(3*p_data->value.len+1);
1740                         if (!data) {
1741                                 BT_ERR("memory allocation failed");
1742                                 g_free(event);
1743                                 return;
1744                         }
1745                         convert_hex_2_str((unsigned char *)p_data->value.value, p_data->value.len, data);
1746                         BT_DBG("Read Data: [%s]", data);
1747                         event->data_len = p_data->value.len;
1748                         memcpy(&(event->data), &(p_data->value.value), event->data_len);
1749                         g_free(data);
1750                 }
1751         }
1752         send_event(OAL_EVENT_GATTC_READ_DESCR, event, sizeof(*event));
1753 }
1754
1755 oal_status_t gattc_start_le_discovery(int client_id)
1756 {
1757
1758         int ret = OAL_STATUS_SUCCESS;
1759
1760         API_TRACE("BTGATT CLIENT SCAN START");
1761         CHECK_OAL_GATT_ENABLED();
1762         CHECK_CLIENT_REGISTRATION(client_id);
1763
1764         ret = gatt_api->client->scan(client_id, 1);
1765         if (ret != BT_STATUS_SUCCESS) {
1766                 BT_ERR("Error:Start LE Discovery failed: %s", status2string(ret));
1767                 return convert_to_oal_status(ret);
1768         }
1769         return OAL_STATUS_SUCCESS;
1770 }
1771
1772 oal_status_t gattc_stop_le_discovery(int client_id)
1773 {
1774
1775         int ret = OAL_STATUS_SUCCESS;
1776
1777         API_TRACE("Scan is stopped");
1778         CHECK_OAL_GATT_ENABLED();
1779         CHECK_CLIENT_REGISTRATION(client_id);
1780         ret = gatt_api->client->scan(client_id, 0);
1781         if (ret != BT_STATUS_SUCCESS) {
1782                 BT_ERR("Error:Stop LE Discovery failed: %s", status2string(ret));
1783                 return convert_to_oal_status(ret);
1784         }
1785         return OAL_STATUS_SUCCESS;
1786 }
1787
1788 oal_status_t gattc_set_le_scan_param(int scan_type, int itv, int win)
1789 {
1790         int ret;
1791
1792         API_TRACE("Scan is stopped");
1793         CHECK_OAL_GATT_ENABLED();
1794
1795 #ifdef TIZEN_BT_HAL
1796         ret = gatt_api->client->set_scan_parameters(scan_type, itv, win);
1797         if (ret != BT_STATUS_SUCCESS) {
1798                 BT_ERR("Error:Set scan parameters failed: %s", status2string(ret));
1799                 return convert_to_oal_status(ret);
1800         }
1801 #else
1802         ret = gatt_api->client->set_scan_parameters(itv, win);
1803         if (ret != BT_STATUS_SUCCESS) {
1804                 BT_ERR("Error:Set scan parameters failed: %s", status2string(ret));
1805                 return convert_to_oal_status(ret);
1806         }
1807 #endif
1808
1809         return OAL_STATUS_SUCCESS;
1810 }
1811
1812 static void cb_gattc_configure_mtu_cmpl(int conn_id, int status, int mtu)
1813 {
1814         event_gattc_mtu_configured_t *event;
1815         BT_INFO("BTGATT Client configure mtu complete Callback, conn_id: %d, status: %d, mtu: %d",
1816                         conn_id, status, mtu);
1817         event = g_new0(event_gattc_mtu_configured_t, 1);
1818         event->conn_id = conn_id;
1819         event->mtu = mtu;
1820         event->status = convert_to_oal_status(status);
1821         send_event(OAL_EVENT_GATTC_MTU_EXCHANGE_COMPLETED, event, sizeof(*event));
1822 }
1823
1824 /************************************ GATT Client ***********************************/
1825 oal_status_t gattc_register(oal_uuid_t* client_uuid)
1826 {
1827
1828         char str[2*BT_UUID_STRING_MAX];
1829         int ret = OAL_STATUS_SUCCESS;
1830
1831         CHECK_OAL_GATT_ENABLED();
1832         uuid_to_stringname(client_uuid, str);
1833         API_TRACE("uuid: [%s]", str);
1834         /* We will perform actual registration in cb_gattc_register_app callback */
1835         ret = gatt_api->client->register_client((bt_uuid_t *)client_uuid);
1836         if (ret != BT_STATUS_SUCCESS) {
1837                 BT_ERR("GATT client register failed: %s", status2string(ret));
1838                 return convert_to_oal_status(ret);
1839         }
1840         return OAL_STATUS_SUCCESS;
1841 }
1842
1843 oal_status_t gattc_deregister(int client_id)
1844 {
1845         int ret = OAL_STATUS_SUCCESS;
1846
1847         API_TRACE("GATT client deregister");
1848         CHECK_OAL_GATT_ENABLED();
1849         CHECK_CLIENT_REGISTRATION(client_id);
1850
1851         ret = gatt_api->client->unregister_client(client_id);
1852         if (ret != BT_STATUS_SUCCESS) {
1853                 BT_ERR("GATT client deregister failed: %s", status2string(ret));
1854                 return convert_to_oal_status(ret);
1855         }
1856
1857         return OAL_STATUS_SUCCESS;
1858 }
1859
1860 oal_status_t gattc_connect(int client_id, bt_address_t *device_address, int isDirect)
1861 {
1862         int ret = OAL_STATUS_SUCCESS;
1863         bdstr_t bdstr;
1864
1865         OAL_CHECK_PARAMETER(device_address, return);
1866         API_TRACE("Client Connect: [%s]", bdt_bd2str(device_address, &bdstr));
1867         CHECK_OAL_GATT_ENABLED();
1868         CHECK_CLIENT_REGISTRATION(client_id);
1869
1870         /* Handle the actual connection in cb_gattc_connection callback */
1871         ret = gatt_api->client->connect(client_id, (bt_bdaddr_t *)device_address, isDirect);
1872         if (ret != BT_STATUS_SUCCESS) {
1873                 BT_ERR("GATT client connect failed: %s", status2string(ret));
1874                 return convert_to_oal_status(ret);
1875         }
1876         return OAL_STATUS_SUCCESS;
1877 }
1878
1879 oal_status_t gattc_disconnect(int client_id, bt_address_t *device_address, int conn_id)
1880 {
1881
1882         int ret = OAL_STATUS_SUCCESS;
1883         bdstr_t bdstr;
1884
1885         OAL_CHECK_PARAMETER(device_address, return);
1886         API_TRACE("Client Disconnect: [%s]", bdt_bd2str(device_address, &bdstr));
1887         CHECK_OAL_GATT_ENABLED();
1888         CHECK_CLIENT_REGISTRATION(client_id);
1889         CHECK_CLIENT_CONNECTION(conn_id);
1890
1891         /* Handle actual disconnection in callback */
1892         ret = gatt_api->client->disconnect(client_id, (bt_bdaddr_t *) device_address, conn_id);
1893         if (ret != BT_STATUS_SUCCESS) {
1894                 BT_ERR("GATT client disconnect failed: %s", status2string(ret));
1895                 return convert_to_oal_status(ret);
1896         }
1897         return OAL_STATUS_SUCCESS;
1898 }
1899
1900
1901 oal_status_t gattc_search_service(int conn_id, oal_uuid_t *service_uuid)
1902 {
1903         int ret = OAL_STATUS_SUCCESS;
1904         char uuid_str[2*BT_UUID_STRING_MAX];
1905
1906         if (service_uuid) {
1907                 uuid_to_stringname(service_uuid, uuid_str);
1908                 API_TRACE("Client Service Search UUID: [%s]", uuid_str);
1909         } else
1910                 API_TRACE("Client Service Search All");
1911
1912         CHECK_OAL_GATT_ENABLED();
1913         CHECK_CLIENT_CONNECTION(conn_id);
1914         ret = gatt_api->client->search_service(conn_id, (bt_uuid_t *)service_uuid);
1915
1916         if (ret != BT_STATUS_SUCCESS) {
1917                 BT_ERR("GATT client service search failed: %s", status2string(ret));
1918                 return convert_to_oal_status(ret);
1919         }
1920         return OAL_STATUS_SUCCESS;
1921 }
1922
1923 oal_status_t gattc_get_characteristic(int conn_id, oal_gatt_srvc_id_t *srvc_id, oal_gatt_id_t *char_id)
1924 {
1925         int ret = OAL_STATUS_SUCCESS;
1926         char uuid_str[2*BT_UUID_STRING_MAX];
1927
1928         OAL_CHECK_PARAMETER(srvc_id, return);
1929         uuid_to_stringname(&(srvc_id->id.uuid), uuid_str);
1930         API_TRACE("Client Get Characteristic, Service_uuid: [%s]", uuid_str);
1931         CHECK_OAL_GATT_ENABLED();
1932         CHECK_CLIENT_CONNECTION(conn_id);
1933         ret = gatt_api->client->get_characteristic(conn_id, (btgatt_srvc_id_t *)srvc_id,
1934                                         (btgatt_gatt_id_t *)char_id);
1935         if (ret != BT_STATUS_SUCCESS) {
1936                 BT_ERR("GATT client get characteristic failed: %s", status2string(ret));
1937                 return convert_to_oal_status(ret);
1938         }
1939         return OAL_STATUS_SUCCESS;
1940 }
1941
1942 oal_status_t gattc_get_descriptor(int conn_id, oal_gatt_srvc_id_t *srvc_id,
1943                                 oal_gatt_id_t *char_id, oal_gatt_id_t *desc_id)
1944 {
1945         int ret = OAL_STATUS_SUCCESS;
1946         char uuid_str1[2*BT_UUID_STRING_MAX];
1947         char uuid_str2[2*BT_UUID_STRING_MAX];
1948
1949         OAL_CHECK_PARAMETER(srvc_id, return);
1950         OAL_CHECK_PARAMETER(char_id, return);
1951         uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
1952         uuid_to_stringname(&(char_id->uuid), uuid_str2);
1953         API_TRACE("Client Get Descriptor, Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
1954         CHECK_OAL_GATT_ENABLED();
1955         CHECK_CLIENT_CONNECTION(conn_id);
1956         ret = gatt_api->client->get_descriptor(conn_id, (btgatt_srvc_id_t *)srvc_id,
1957                                 (btgatt_gatt_id_t *)char_id, (btgatt_gatt_id_t *)desc_id);
1958         if (ret != BT_STATUS_SUCCESS) {
1959                 BT_ERR("GATT client get descriptor failed: %s", status2string(ret));
1960                 return convert_to_oal_status(ret);
1961         }
1962         return OAL_STATUS_SUCCESS;
1963 }
1964
1965 oal_status_t gattc_register_for_notification(int client_id, bt_address_t * address,
1966                         oal_gatt_srvc_id_t *srvc_id, oal_gatt_id_t *char_id) {
1967         int ret = OAL_STATUS_SUCCESS;
1968         char uuid_str1[2*BT_UUID_STRING_MAX];
1969         char uuid_str2[2*BT_UUID_STRING_MAX];
1970         bdstr_t bdstr;
1971
1972         OAL_CHECK_PARAMETER(address, return);
1973         OAL_CHECK_PARAMETER(srvc_id, return);
1974         OAL_CHECK_PARAMETER(char_id, return);
1975         uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
1976         uuid_to_stringname(&(char_id->uuid), uuid_str2);
1977         API_TRACE("Client Register Notification: [%s], Service_uuid: [%s], Char_uuid: [%s]", bdt_bd2str(address, &bdstr), uuid_str1, uuid_str2);
1978         CHECK_OAL_GATT_ENABLED();
1979         CHECK_CLIENT_REGISTRATION(client_id);
1980
1981         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);
1982         if (ret != BT_STATUS_SUCCESS) {
1983                 BT_ERR("GATT client register notification failed: %s", status2string(ret));
1984                 return convert_to_oal_status(ret);
1985         }
1986
1987         return OAL_STATUS_SUCCESS;
1988 }
1989
1990 oal_status_t gattc_deregister_for_notification(int client_id, bt_address_t * address,
1991                         oal_gatt_srvc_id_t *srvc_id, oal_gatt_id_t *char_id) {
1992         int ret = OAL_STATUS_SUCCESS;
1993         char uuid_str1[2*BT_UUID_STRING_MAX];
1994         char uuid_str2[2*BT_UUID_STRING_MAX];
1995         bdstr_t bdstr;
1996
1997         OAL_CHECK_PARAMETER(address, return);
1998         OAL_CHECK_PARAMETER(srvc_id, return);
1999         OAL_CHECK_PARAMETER(char_id, return);
2000         uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2001         uuid_to_stringname(&(char_id->uuid), uuid_str2);
2002         API_TRACE("Client Deregister Notification: [%s], Service_uuid: [%s], Char_uuid: [%s]", bdt_bd2str(address, &bdstr), uuid_str1, uuid_str2);
2003         CHECK_OAL_GATT_ENABLED();
2004         CHECK_CLIENT_REGISTRATION(client_id);
2005
2006         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);
2007         if (ret != BT_STATUS_SUCCESS) {
2008                 BT_ERR("GATT client deregister notification failed: %s", status2string(ret));
2009                 return convert_to_oal_status(ret);
2010         }
2011
2012         return OAL_STATUS_SUCCESS;
2013 }
2014
2015
2016 oal_status_t gattc_read_characteristic(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2017                                 oal_gatt_id_t *char_id, oal_gatt_auth_req_t auth_req)
2018 {
2019         int ret = OAL_STATUS_SUCCESS;
2020         char uuid_str1[2*BT_UUID_STRING_MAX];
2021         char uuid_str2[2*BT_UUID_STRING_MAX];
2022
2023         OAL_CHECK_PARAMETER(srvc_id, return);
2024         OAL_CHECK_PARAMETER(char_id, return);
2025         uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2026         uuid_to_stringname(&(char_id->uuid), uuid_str2);
2027         API_TRACE("Client Read Characteristic: Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
2028         CHECK_OAL_GATT_ENABLED();
2029         CHECK_CLIENT_CONNECTION(conn_id);
2030
2031         ret = gatt_api->client->read_characteristic(conn_id, (btgatt_srvc_id_t *)srvc_id,
2032                                         (btgatt_gatt_id_t *)char_id, auth_req);
2033         if (ret != BT_STATUS_SUCCESS) {
2034                 BT_ERR("GATT client read characteristic failed: %s", status2string(ret));
2035                 return convert_to_oal_status(ret);
2036         }
2037
2038         return OAL_STATUS_SUCCESS;
2039 }
2040
2041 oal_status_t gattc_read_descriptor(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2042                 oal_gatt_id_t *char_id, oal_gatt_id_t *desc_id, oal_gatt_auth_req_t auth_req)
2043 {
2044         int ret = OAL_STATUS_SUCCESS;
2045         char uuid_str1[2*BT_UUID_STRING_MAX];
2046         char uuid_str2[2*BT_UUID_STRING_MAX];
2047         char uuid_str3[2*BT_UUID_STRING_MAX];
2048
2049         OAL_CHECK_PARAMETER(srvc_id, return);
2050         OAL_CHECK_PARAMETER(char_id, return);
2051         OAL_CHECK_PARAMETER(desc_id, return);
2052         uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2053         uuid_to_stringname(&(char_id->uuid), uuid_str2);
2054         uuid_to_stringname(&(desc_id->uuid), uuid_str3);
2055         API_TRACE("Client Read Descriptor: Service_uuid: [%s], Char_uuid: [%s], Desc_uuid: [%s]",
2056                         uuid_str1, uuid_str2, uuid_str3);
2057         CHECK_OAL_GATT_ENABLED();
2058         CHECK_CLIENT_CONNECTION(conn_id);
2059
2060         ret = gatt_api->client->read_descriptor(conn_id, (btgatt_srvc_id_t *)srvc_id,
2061                                 (btgatt_gatt_id_t *)char_id, (btgatt_gatt_id_t *)desc_id, auth_req);
2062         if (ret != BT_STATUS_SUCCESS) {
2063                 BT_ERR("GATT client read descriptor failed: %s", status2string(ret));
2064                 return convert_to_oal_status(ret);
2065         }
2066
2067         return OAL_STATUS_SUCCESS;
2068 }
2069
2070 oal_status_t gattc_acquire_notify(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2071                 oal_gatt_id_t *char_id,  int *fd, int *mtu)
2072 {
2073         int ret = OAL_STATUS_SUCCESS;
2074         char uuid_str1[2*BT_UUID_STRING_MAX];
2075         char uuid_str2[2*BT_UUID_STRING_MAX];
2076         OAL_CHECK_PARAMETER(srvc_id, return);
2077         OAL_CHECK_PARAMETER(char_id, return);
2078         uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2079         uuid_to_stringname(&(char_id->uuid), uuid_str2);
2080         API_TRACE("Client Write Characteristic: Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
2081         CHECK_OAL_GATT_ENABLED();
2082         CHECK_CLIENT_CONNECTION(conn_id);
2083
2084         ret = gatt_api->client->acquire_notify(conn_id, (btgatt_srvc_id_t *)srvc_id,
2085                         (btgatt_gatt_id_t *)char_id, fd, mtu);
2086         if (ret != BT_STATUS_SUCCESS) {
2087                 BT_ERR("GATT client write characteristic failed: %s", status2string(ret));
2088                 return convert_to_oal_status(ret);
2089         }
2090
2091         return OAL_STATUS_SUCCESS;
2092 }
2093
2094 oal_status_t gattc_acquire_write(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2095                 oal_gatt_id_t *char_id,  oal_gatt_auth_req_t auth_req , int *fd, int*mtu)
2096 {
2097         int ret = OAL_STATUS_SUCCESS;
2098         char uuid_str1[2*BT_UUID_STRING_MAX];
2099         char uuid_str2[2*BT_UUID_STRING_MAX];
2100         OAL_CHECK_PARAMETER(srvc_id, return);
2101         OAL_CHECK_PARAMETER(char_id, return);
2102         uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2103         uuid_to_stringname(&(char_id->uuid), uuid_str2);
2104         API_TRACE("Client Write Characteristic: Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
2105         CHECK_OAL_GATT_ENABLED();
2106         CHECK_CLIENT_CONNECTION(conn_id);
2107
2108         ret = gatt_api->client->acquire_write(conn_id, (btgatt_srvc_id_t *)srvc_id,
2109                         (btgatt_gatt_id_t *)char_id,  auth_req, fd, mtu);
2110         if (ret != BT_STATUS_SUCCESS) {
2111                 BT_ERR("GATT client write characteristic failed: %s", status2string(ret));
2112                 return convert_to_oal_status(ret);
2113         }
2114
2115         return OAL_STATUS_SUCCESS;
2116 }
2117
2118 oal_status_t gattc_write_characteristic(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2119                 oal_gatt_id_t *char_id, oal_gatt_write_type_t write_type,
2120                 int len, oal_gatt_auth_req_t auth_req, char* data)
2121 {
2122         int ret = OAL_STATUS_SUCCESS;
2123         char uuid_str1[2*BT_UUID_STRING_MAX];
2124         char uuid_str2[2*BT_UUID_STRING_MAX];
2125         OAL_CHECK_PARAMETER(srvc_id, return);
2126         OAL_CHECK_PARAMETER(char_id, return);
2127         OAL_CHECK_PARAMETER(data, return);
2128         uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2129         uuid_to_stringname(&(char_id->uuid), uuid_str2);
2130         API_TRACE("Client Write Characteristic: Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
2131         CHECK_OAL_GATT_ENABLED();
2132         CHECK_CLIENT_CONNECTION(conn_id);
2133
2134         ret = gatt_api->client->write_characteristic(conn_id, (btgatt_srvc_id_t *)srvc_id,
2135                         (btgatt_gatt_id_t *)char_id, write_type, len, auth_req, data);
2136         if (ret != BT_STATUS_SUCCESS) {
2137                 BT_ERR("GATT client write characteristic failed: %s", status2string(ret));
2138                 return convert_to_oal_status(ret);
2139         }
2140
2141         return OAL_STATUS_SUCCESS;
2142 }
2143
2144 oal_status_t gattc_write_descriptor(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2145                 oal_gatt_id_t *char_id, oal_gatt_id_t *desc_id,
2146                 oal_gatt_write_type_t write_type, int len, oal_gatt_auth_req_t auth_req, char* data)
2147 {
2148         int ret = OAL_STATUS_SUCCESS;
2149         char uuid_str1[2*BT_UUID_STRING_MAX];
2150         char uuid_str2[2*BT_UUID_STRING_MAX];
2151         char uuid_str3[2*BT_UUID_STRING_MAX];
2152         OAL_CHECK_PARAMETER(srvc_id, return);
2153         OAL_CHECK_PARAMETER(char_id, return);
2154         OAL_CHECK_PARAMETER(desc_id, return);
2155         OAL_CHECK_PARAMETER(data, return);
2156         uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2157         uuid_to_stringname(&(char_id->uuid), uuid_str2);
2158         uuid_to_stringname(&(desc_id->uuid), uuid_str3);
2159         API_TRACE("Client Write Descriptor: Service_uuid: [%s], Char_uuid: [%s], Desc_uuid: [%s]",
2160                                 uuid_str1, uuid_str2, uuid_str3);
2161         CHECK_OAL_GATT_ENABLED();
2162         CHECK_CLIENT_CONNECTION(conn_id);
2163
2164         ret = gatt_api->client->write_descriptor(conn_id, (btgatt_srvc_id_t *)srvc_id,
2165                         (btgatt_gatt_id_t *)char_id, (btgatt_gatt_id_t *)desc_id, write_type, len, auth_req, data);
2166         if (ret != BT_STATUS_SUCCESS) {
2167                 BT_ERR("GATT client write characteristic failed: %s", status2string(ret));
2168                 return convert_to_oal_status(ret);
2169         }
2170
2171         return OAL_STATUS_SUCCESS;
2172 }
2173
2174 oal_status_t gattc_conn_param_update(bt_address_t * address, int min, int max, int latency, int timeout)
2175 {
2176         int ret;
2177         bdstr_t bdstr;
2178
2179         OAL_CHECK_PARAMETER(address, return);
2180         API_TRACE("Conn Param Update: [%s]", bdt_bd2str(address, &bdstr));
2181         CHECK_OAL_GATT_ENABLED();
2182
2183         BT_INFO("[%s] min[%d] max[%d] latency[%d] timeout[%d]", bdt_bd2str(address, &bdstr), min, max, latency, timeout);
2184         ret = gatt_api->client->conn_parameter_update((bt_bdaddr_t *)address, min, max, latency, timeout);
2185         if (ret != BT_STATUS_SUCCESS) {
2186                 BT_ERR("error: %s", status2string(ret));
2187                 return convert_to_oal_status(ret);
2188         }
2189         return OAL_STATUS_SUCCESS;
2190 }
2191
2192 oal_status_t gattc_unregister_scan_filter(int slot_id)
2193 {
2194         int ret;
2195         int client_if = 0;
2196
2197         API_TRACE("");
2198         CHECK_OAL_GATT_ENABLED();
2199
2200         BT_INFO("Remove Scan filter Slot ID is: [%d]", slot_id);
2201
2202         ret = gatt_api->client->scan_filter_clear(client_if, slot_id);
2203         if (ret != BT_STATUS_SUCCESS) {
2204                 BT_ERR("error: %s", status2string(ret));
2205                 return convert_to_oal_status(ret);
2206         }
2207         return OAL_STATUS_SUCCESS;
2208 }
2209
2210 oal_status_t gattc_enable_scan_filter(int client_if)
2211 {
2212         int ret;
2213
2214         API_TRACE("");
2215         CHECK_OAL_GATT_ENABLED();
2216
2217         BT_INFO("Enable Scan filter. Client If: %d", client_if);
2218
2219         ret = gatt_api->client->scan_filter_enable(client_if, TRUE);
2220         if (ret != BT_STATUS_SUCCESS) {
2221                 BT_ERR("error: %s", status2string(ret));
2222                 return convert_to_oal_status(ret);
2223         }
2224         return OAL_STATUS_SUCCESS;
2225 }
2226
2227 oal_status_t gattc_disable_scan_filter(int client_if)
2228 {
2229         int ret;
2230
2231         API_TRACE("");
2232         CHECK_OAL_GATT_ENABLED();
2233
2234         BT_INFO("Disable Scan filter. Client If: %d", client_if);
2235
2236         ret = gatt_api->client->scan_filter_enable(client_if, FALSE);
2237         if (ret != BT_STATUS_SUCCESS) {
2238                 BT_ERR("error: %s", status2string(ret));
2239                 return convert_to_oal_status(ret);
2240         }
2241         return OAL_STATUS_SUCCESS;
2242 }
2243
2244 oal_status_t gattc_register_scan_filter(oal_ble_scan_filter_t* filter_data)
2245 {
2246         int ret;
2247         int client_info = 0;
2248         int action = 0;
2249         int company_id = 0;
2250         int company_id_mask = 0;
2251         int address_type = 0;
2252         int feature_selection = 0;
2253
2254         oal_ble_scan_filter_param_setup_t scan_filter_setup = {.list_logic_type = 0,
2255                                                                 .filt_logic_type = 1,
2256                                                                 .rssi_high_thres = -127,
2257                                                                 .rssi_low_thres = -127,
2258                                                                 .dely_mode = 0,
2259                                                                 .found_timeout = 0,
2260                                                                 .lost_timeout = 0,
2261                                                                 .found_timeout_cnt = 0
2262                                                                 };
2263
2264         OAL_CHECK_PARAMETER(filter_data, return);
2265         API_TRACE();
2266         CHECK_OAL_GATT_ENABLED();
2267
2268         if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS){
2269                 bdstr_t bdstr;
2270                 BT_INFO("OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS is being added");
2271                 BT_INFO("BT remote Device address is %s", bdt_bd2str(filter_data->device_address, &bdstr));
2272                 ret = gatt_api->client->scan_filter_add_remove(client_info,
2273                                                                 action,
2274                                                                 OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS,
2275                                                                 filter_data->slot_id,
2276                                                                 company_id,
2277                                                                 company_id_mask,
2278                                                                 NULL,
2279                                                                 NULL,
2280                                                                 (bt_bdaddr_t*)filter_data->device_address,
2281                                                                 address_type,
2282                                                                 0,
2283                                                                 NULL,
2284                                                                 0,
2285                                                                 NULL
2286                                                                 );
2287                 if (ret != BT_STATUS_SUCCESS){
2288                         BT_ERR("error: %s", status2string(ret));
2289                         BT_INFO("unregistering already set filter features.");
2290                         gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
2291                         return convert_to_oal_status(ret);
2292                 }
2293
2294                 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS;
2295         }
2296         if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_NAME){
2297                 ret = gatt_api->client->scan_filter_add_remove(client_info,
2298                                                                 action,
2299                                                                 OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_NAME,
2300                                                                 filter_data->slot_id,
2301                                                                 company_id,
2302                                                                 company_id_mask,
2303                                                                 NULL,
2304                                                                 NULL,
2305                                                                 NULL,
2306                                                                 address_type,
2307                                                                 0,
2308                                                                 filter_data->device_name,     // device_name as p_data in HAL
2309                                                                 0,
2310                                                                 NULL
2311                                                                 );
2312                 if (ret != BT_STATUS_SUCCESS){
2313                         BT_ERR("error: %s", status2string(ret));
2314                         BT_INFO("unregistering already set filter features.");
2315                         gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
2316                         return convert_to_oal_status(ret);
2317                 }
2318
2319                 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_DEVICE_NAME;
2320         }
2321         if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_UUID){
2322                 BT_INFO("OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_UUID is being added");
2323                 char uuid_str1[2*BT_UUID_STRING_MAX];
2324                 char uuid_str2[2*BT_UUID_STRING_MAX];
2325
2326                 uuid_to_stringname((service_uuid_t*)filter_data->service_uuid, uuid_str1);
2327                 uuid_to_stringname((service_uuid_t*)filter_data->service_uuid_mask, uuid_str2);
2328
2329                 BT_INFO("Service UUID  is [%s] and Service UUID mask is [%s]", uuid_str1, uuid_str2);
2330                 ret = gatt_api->client->scan_filter_add_remove(client_info,
2331                                                                 action,
2332                                                                 OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_UUID,
2333                                                                 filter_data->slot_id,
2334                                                                 company_id,
2335                                                                 company_id_mask,
2336                                                                 (bt_uuid_t*)filter_data->service_uuid,
2337                                                                 (bt_uuid_t*)filter_data->service_uuid_mask,
2338                                                                 NULL,
2339                                                                 address_type,
2340                                                                 filter_data->service_uuid_len,   // service_uuid_len as data_len in HAL
2341                                                                 NULL,
2342                                                                 filter_data->service_uuid_mask_len,
2343                                                                 NULL
2344                                                                 );
2345                 if (ret != BT_STATUS_SUCCESS){
2346                         BT_ERR("error: %s", status2string(ret));
2347                         BT_INFO("unregistering already set filter features.");
2348                         gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
2349                         return convert_to_oal_status(ret);
2350                 }
2351
2352                 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_UUID;
2353         }
2354         if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID){
2355                 BT_INFO("OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID is being added");
2356                 char uuid_str1[2*BT_UUID_STRING_MAX];
2357                 char uuid_str2[2*BT_UUID_STRING_MAX];
2358                 uuid_to_stringname((service_uuid_t*)filter_data->service_solicitation_uuid, uuid_str1);
2359                 uuid_to_stringname((service_uuid_t*)filter_data->service_solicitation_uuid_mask, uuid_str2);
2360                 BT_INFO("Service Solicitation UUID  is [%s] and Service Solicitation UUID mask is [%s]", uuid_str1, uuid_str2);
2361                 ret = gatt_api->client->scan_filter_add_remove(client_info,
2362                                                                 action,
2363                                                                 OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID,
2364                                                                 filter_data->slot_id,
2365                                                                 company_id,
2366                                                                 company_id_mask,
2367                                                                 (bt_uuid_t*)filter_data->service_solicitation_uuid,
2368                                                                 (bt_uuid_t*)filter_data->service_solicitation_uuid_mask,
2369                                                                 NULL,
2370                                                                 address_type,
2371                                                                 filter_data->service_solicitation_uuid_len,   // service_solicitation_uuid_len as data_len in HAL
2372                                                                 NULL,
2373                                                                 filter_data->service_solicitation_uuid_mask_len,
2374                                                                 NULL
2375                                                                 );
2376                 if (ret != BT_STATUS_SUCCESS){
2377                         BT_ERR("error: %s", status2string(ret));
2378                         BT_INFO("unregistering already set filter features.");
2379                         gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
2380                         return convert_to_oal_status(ret);
2381                 }
2382
2383                 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID;
2384         }
2385         if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_DATA){
2386                 ret = gatt_api->client->scan_filter_add_remove(client_info,
2387                                                                 action,
2388                                                                 OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_DATA,
2389                                                                 filter_data->slot_id,
2390                                                                 company_id,
2391                                                                 company_id_mask,
2392                                                                 NULL,
2393                                                                 NULL,
2394                                                                 NULL,
2395                                                                 address_type,
2396                                                                 filter_data->service_data_len,    //service_data_len as data_len in HAL
2397                                                                 (char*)filter_data->service_data,
2398                                                                 filter_data->service_data_mask_len,
2399                                                                 (char*)filter_data->service_data_mask
2400                                                                 );
2401                 if (ret != BT_STATUS_SUCCESS){
2402                         BT_ERR("error: %s", status2string(ret));
2403                         BT_INFO("unregistering already set filter features.");
2404                         gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
2405                         return convert_to_oal_status(ret);
2406                 }
2407
2408                 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_SERVICE_DATA;
2409         }
2410         if (filter_data->added_features & OAL_BLE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA){
2411                 ret = gatt_api->client->scan_filter_add_remove(client_info,
2412                                                                 action,
2413                                                                 OAL_BLE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA,
2414                                                                 filter_data->slot_id,
2415                                                                 filter_data->manufacturer_id,
2416                                                                 company_id_mask,
2417                                                                 NULL,
2418                                                                 NULL,
2419                                                                 NULL,
2420                                                                 address_type,
2421                                                                 filter_data->manufacturer_data_len,    //manufacturer_data_len as data_len in HAL
2422                                                                 (char*)filter_data->manufacturer_data,
2423                                                                 filter_data->manufacturer_data_mask_len,
2424                                                                 (char*)filter_data->manufacturer_data_mask
2425                                                                 );
2426                 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA;
2427                 if (ret != BT_STATUS_SUCCESS){
2428                         BT_ERR("error: %s", status2string(ret));
2429                         BT_INFO("unregistering already set filter features.");
2430                         gatt_api->client->scan_filter_clear(client_info, filter_data->slot_id);
2431                         return convert_to_oal_status(ret);
2432                 }
2433
2434                 feature_selection |= OAL_BLE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA;
2435         }
2436
2437         BT_DBG("Filter selection 0x%.2x", feature_selection);
2438
2439         ret = gatt_api->client->scan_filter_param_setup(client_info, action, filter_data->slot_id, feature_selection,
2440                                                         scan_filter_setup.list_logic_type, scan_filter_setup.filt_logic_type,
2441                                                         scan_filter_setup.rssi_high_thres, scan_filter_setup.rssi_low_thres,
2442                                                         scan_filter_setup.dely_mode, scan_filter_setup.found_timeout,
2443                                                         scan_filter_setup.lost_timeout, scan_filter_setup.found_timeout_cnt);
2444         if (ret != BT_STATUS_SUCCESS){
2445                 BT_ERR("error: %s", status2string(ret));
2446                 return convert_to_oal_status(ret);
2447         }
2448         return OAL_STATUS_SUCCESS;
2449 }
2450
2451 oal_status_t gattc_configure_mtu(int conn_id, int mtu)
2452 {
2453         int ret;
2454
2455         API_TRACE("Configure MTU Size: [%d]", mtu);
2456         CHECK_OAL_GATT_ENABLED();
2457         CHECK_CLIENT_CONNECTION(conn_id);
2458
2459         /* To prevent crash in case other libraries not support this api */
2460         if (gatt_api->client->configure_mtu == NULL) {
2461                 BT_WARN("configure_mtu is NULL");
2462                 return OAL_STATUS_NOT_SUPPORT;
2463         }
2464
2465         ret = gatt_api->client->configure_mtu(conn_id, mtu);
2466         if (ret != BT_STATUS_SUCCESS) {
2467                 BT_ERR("Gatt client configure_mtu error: %s", status2string(ret));
2468                 return convert_to_oal_status(ret);
2469         }
2470         return OAL_STATUS_SUCCESS;
2471 }
2472
2473 oal_status_t gattc_add_connection_info(bt_address_t *device_address, int conn_id, int server_inst_id)
2474 {
2475         int ret = OAL_STATUS_SUCCESS;
2476         bdstr_t bdstr;
2477
2478         OAL_CHECK_PARAMETER(device_address, return);
2479         API_TRACE("Add connection info: [%s]", bdt_bd2str(device_address, &bdstr));
2480         CHECK_OAL_GATT_ENABLED();
2481         CHECK_SERVER_INSTANCE(server_inst_id);
2482         CHECK_SERVER_REGISTRATION(server_inst_id);
2483
2484         ret = gatt_api->client->add_connection_info((bt_bdaddr_t *)device_address, conn_id, server_inst_id);
2485         if (ret != BT_STATUS_SUCCESS) {
2486                 BT_ERR("GATT connection info add failed: %s", status2string(ret));
2487                 return convert_to_oal_status(ret);
2488         }
2489         return OAL_STATUS_SUCCESS;
2490 }
2491