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