bt-oal/oal-gatt.c

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