bt-oal/oal-gatt.c

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