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