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                                 (gatt_servers[ins_id - 1].state == GATT_INS_ENABLED)) {
1235                         event->server_inst = ins_id;
1236                         break;
1237                 } else {
1238                         BT_INFO("Server ID:%d recevied server Id:%d\n", gatt_servers[ins_id - 1].server_id, server_if);
1239                 }
1240         }
1241         if (ins_id == NUM_SERVER_INST+1) {
1242                 BT_WARN("Incorrect Server Interface received: %d\n",  server_if);
1243                 g_free(event);
1244                 return;
1245         }
1246         memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1247         event->conn_id = conn_id;
1248         event_type = ((connected == TRUE) ? OAL_EVENT_GATTS_CONNECTION_COMPLETED : OAL_EVENT_GATTS_DISCONNECTION_COMPLETED);
1249         event->status = OAL_STATUS_SUCCESS;
1250
1251         send_event(event_type, event, sizeof(event_gatts_conn_t));
1252 }
1253
1254 static void cb_gatts_request_read(int conn_id, int trans_id, bt_bdaddr_t *bda,
1255                 int attr_handle, int offset, bool is_long)
1256 {
1257         BT_INFO("BTGATT SERVER REQUEST READ CB: conn_id:%d", conn_id);
1258
1259         event_gatts_srvc_read_attr_t* event = g_new0(event_gatts_srvc_read_attr_t, 1);
1260
1261         memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1262
1263         event->attr_trans.attr_handle = attr_handle;
1264         event->attr_trans.conn_id = conn_id;
1265         event->attr_trans.trans_id = trans_id;
1266         event->attr_trans.offset = offset;
1267         event->is_long = is_long;
1268
1269         send_event(OAL_EVENT_GATTS_REQUEST_READ, event, sizeof(event_gatts_srvc_read_attr_t));
1270 }
1271
1272 static void cb_gatts_request_write(int conn_id, int trans_id,
1273                 bt_bdaddr_t *bda, int attr_handle,
1274                 int offset, int length,
1275                 bool need_rsp, bool is_prep, uint8_t* value)
1276 {
1277         BT_INFO("BTGATT SERVER REQUEST WRITE conn_id:%d", conn_id);
1278
1279         event_gatts_srvc_write_attr_t* event = g_new0(event_gatts_srvc_write_attr_t, 1);
1280
1281         memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1282
1283         event->attr_trans.attr_handle = attr_handle;
1284         event->attr_trans.conn_id = conn_id;
1285         event->attr_trans.trans_id = trans_id;
1286         event->attr_trans.offset = offset;
1287         event->need_rsp = need_rsp;
1288         event->is_prep = is_prep;
1289
1290         if (length > 0 && value != NULL) {
1291                 if (length > OAL_GATT_MAX_ATTR_LEN)
1292                         length = OAL_GATT_MAX_ATTR_LEN;
1293                 memcpy(event->value, value, length);
1294                 event->length = length;
1295         }
1296         send_event(OAL_EVENT_GATTS_REQUEST_WRITE, event, sizeof(event_gatts_srvc_write_attr_t));
1297 }
1298
1299 static void cb_gatts_acquire_write(int mtu, int conn_id, int trans_id, int attr_handle , bt_bdaddr_t *bda)
1300
1301 {
1302         BT_INFO("BTGATT SERVER REQUEST ACQUIRE WRITE conn_id:%d", conn_id);
1303
1304         event_gatts_srvc_acquire_attr_t* event = g_new0(event_gatts_srvc_acquire_attr_t, 1);
1305
1306         event->attr_trans.attr_handle = attr_handle;
1307         event->attr_trans.conn_id = conn_id;
1308         event->attr_trans.trans_id = trans_id;
1309         event->mtu = mtu;
1310         memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1311
1312         send_event(OAL_EVENT_GATTS_REQUEST_ACQUIRE_WRITE, event, sizeof(event_gatts_srvc_acquire_attr_t));
1313 }
1314
1315 static void cb_gatts_acquire_notify(int mtu, int conn_id, int trans_id, int attr_handle)
1316 {
1317         BT_INFO("BTGATT SERVER REQUEST ACQUIRE NOTIFY conn_id:%d", conn_id);
1318
1319         event_gatts_srvc_acquire_attr_t* event = g_new0(event_gatts_srvc_acquire_attr_t, 1);
1320
1321         event->attr_trans.attr_handle = attr_handle;
1322         event->attr_trans.conn_id = conn_id;
1323         event->attr_trans.trans_id = trans_id;
1324         event->mtu = mtu;
1325
1326         send_event(OAL_EVENT_GATTS_REQUEST_ACQUIRE_NOTIFY, event, sizeof(event_gatts_srvc_acquire_attr_t));
1327
1328 }
1329
1330 static void cb_gatts_response_confirmation(int status, int handle)
1331 {
1332         BT_INFO("BTGATT SERVER RESPONSE CONFIRMATION CB, status:%d, handle:%d", status, handle);
1333
1334         event_gatts_respons_t* event = g_new0(event_gatts_respons_t, 1);
1335
1336         event->hndl = handle;
1337         event->status = convert_to_oal_status(status);
1338
1339         send_event(OAL_EVENT_GATTS_RESPONSE_CONFIRMED, event, sizeof(event_gatts_respons_t));
1340 }
1341
1342 static void cb_indication_confirmation(int conn_id, int trans_id, int attr_handle, bt_bdaddr_t *bda)
1343 {
1344         BT_INFO("BTGATT SERVER Indication Confirmation CB, conn_id:%d, trans_id:%d attr_handle:%d",
1345                         conn_id, trans_id, attr_handle);
1346
1347         event_gatts_ind_cnfrm_t* event = g_new0(event_gatts_ind_cnfrm_t, 1);
1348
1349         memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1350
1351         event->attr_handle = attr_handle;
1352         event->conn_id = conn_id;
1353         event->trans_id = trans_id;
1354         send_event(OAL_EVENT_GATTS_IND_CONFIRM, event, sizeof(event_gatts_ind_cnfrm_t));
1355 }
1356
1357 static void cb_gatts_mtu_changed(int conn_id, int mtu)
1358 {
1359         BT_INFO("BTGATT SERVER MTU CHANGED CB, conn_id: %d, mtu_size: %d", conn_id, mtu);
1360         event_gatts_mtu_changed_t *event = g_new0(event_gatts_mtu_changed_t, 1);
1361         event->conn_id = conn_id;
1362         event->mtu_size = mtu;
1363         send_event(OAL_EVENT_GATTS_MTU_CHANGED, event, sizeof(event_gatts_mtu_changed_t));
1364 }
1365
1366 #ifdef TIZEN_BT_HAL
1367 static void cb_notifcation_changed(int conn_id, int trans_id, int attr_handle, bool notify,  bt_bdaddr_t *bda)
1368 {
1369         BT_INFO("BTGATT SERVER Notication CB, conn_id:%d, trans_id:%d attr_handle:%d Notify:%d",
1370                         conn_id, trans_id, attr_handle, notify);
1371
1372         event_gatts_notif_t* event = g_new0(event_gatts_notif_t, 1);
1373
1374         memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1375
1376         event->attr_handle = attr_handle;
1377         event->conn_id = conn_id;
1378         event->trans_id = trans_id;
1379         event->notify = notify;
1380         send_event(OAL_EVENT_GATTS_NOTIFICATION, event, sizeof(event_gatts_notif_t));
1381 }
1382 #endif
1383
1384
1385 /* GATT Server Callbacks: End */
1386 /************************************ GATT Client ***********************************/
1387 /* Client Callbacks */
1388 static void cb_gattc_register_app(int status, int clientIf, bt_uuid_t *app_uuid)
1389 {
1390         char uuid_str[BT_UUID_STRING_MAX];
1391         event_gattc_register_t *event;
1392
1393         BT_INFO("+");
1394
1395         /* Check if GATT client registered for Default GATT client UUID */
1396         uuid_to_string((service_uuid_t *)app_uuid, uuid_str);
1397         BT_INFO("UUID:%s", uuid_str);
1398
1399         BT_INFO("BTGATT CLIENT REGISTER APP CB, status:%d, clientIf:%d", status, clientIf);
1400         event = g_new0(event_gattc_register_t, 1);
1401         event->client_if = clientIf;
1402         event->status = (status == 0 ? OAL_STATUS_SUCCESS : OAL_STATUS_INTERNAL_ERROR);
1403         memcpy(event->client_uuid.uuid, app_uuid->uu, sizeof(oal_uuid_t));
1404         send_event(OAL_EVENT_GATTC_REGISTRATION, event, sizeof(event_gattc_register_t));
1405 }
1406
1407 static void cb_gattc_scan_result(bt_bdaddr_t* bdaddress, int rssi, uint8_t *adv_data)
1408 {
1409         event_ble_scan_result_info *event;
1410
1411         event = g_new0(event_ble_scan_result_info, 1);
1412         event->rssi = rssi;
1413         memcpy(event->address.addr, bdaddress->address, BT_ADDRESS_BYTES_NUM);
1414         memcpy(event->adv_data, adv_data, BLE_ADV_DATA_LENGTH);
1415         send_event_bda_trace(OAL_EVENT_BLE_REMOTE_DEVICE_FOUND, event,
1416                         sizeof(event_ble_scan_result_info), (bt_address_t *)bdaddress);
1417 }
1418
1419 static void cb_gattc_connection(int conn_id, int status, int client_if, bt_bdaddr_t* bda)
1420 {
1421         event_gattc_conn_t *event;
1422         BT_INFO("BTGATT CLIENT CONNECTED CB, status:[%d] client_if[%d] id[%d]",
1423                                                         status, client_if, conn_id);
1424
1425         event = g_new0(event_gattc_conn_t, 1);
1426         memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1427         event->client_if = client_if;
1428
1429         if (BT_STATUS_SUCCESS != status) {
1430                 event->status = OAL_STATUS_INTERNAL_ERROR;
1431                 BT_ERR("gattc connection Error: %d", status);
1432         } else {
1433                 event->conn_id = conn_id;
1434                 event->status = OAL_STATUS_SUCCESS;
1435         }
1436
1437         send_event_bda_trace(OAL_EVENT_GATTC_CONNECTION_COMPLETED, event,
1438                                         sizeof(*event), (bt_address_t *)bda);
1439 }
1440
1441
1442 static void cb_gattc_disconnect(int conn_id, int status, int client_if, bt_bdaddr_t* bda)
1443 {
1444         event_gattc_conn_t *event;
1445         BT_INFO("BTGATT Client Disconnect Complete cb, status:[%d], client_if[%d] id[%d]",
1446                                                         status, client_if, conn_id);
1447         event = g_new0(event_gattc_conn_t, 1);
1448         event->status = convert_to_oal_status(status);
1449         event->client_if = client_if;
1450         event->conn_id = conn_id;
1451         memcpy(event->address.addr, bda->address, BT_ADDRESS_BYTES_NUM);
1452         send_event_bda_trace(OAL_EVENT_GATTC_DISCONNECTION_COMPLETED, event,
1453                                         sizeof(*event), (bt_address_t *)bda);
1454 }
1455
1456 static void cb_gattc_search_result(int conn_id, btgatt_srvc_id_t *srvc_id)
1457 {
1458         char uuid_str[2*BT_UUID_STRING_MAX];
1459
1460         BT_INFO("BTGATT Client Service Search Result cb, conn_id:%d", conn_id);
1461
1462         uuid_to_stringname((oal_uuid_t *)&(srvc_id->id.uuid), uuid_str);
1463         BT_INFO("Service=> UUID: [%s], Inst_id: [%u], Type: [%s]",
1464                 uuid_str, srvc_id->id.inst_id, srvc_id->is_primary ? "Primary" : "Secondary");
1465
1466         event_gattc_service_result_t *event = g_new0(event_gattc_service_result_t, 1);
1467         event->conn_status.status = OAL_STATUS_SUCCESS;
1468         event->conn_status.conn_id = conn_id;
1469         memcpy(&(event->srvc_id), srvc_id, sizeof(oal_gatt_srvc_id_t));
1470
1471         send_event(OAL_EVENT_GATTC_SERVICE_SEARCH_RESULT, event, sizeof(*event));
1472 }
1473
1474 static void cb_gattc_search_complete(int conn_id, int status)
1475 {
1476         BT_INFO("BTGATT Client Service Search Complete cb, status:%d, conn_id:%d",
1477         status, conn_id);
1478
1479         event_gattc_conn_status_t *event = g_new0(event_gattc_conn_status_t, 1);
1480         event->conn_id = conn_id;
1481         event->status = convert_to_oal_status(status);
1482
1483         send_event(OAL_EVENT_GATTC_SERVICE_SEARCH_DONE, event, sizeof(*event));
1484 }
1485
1486
1487 static void cb_gattc_get_characteristics(int conn_id, int status, btgatt_srvc_id_t *srvc_id,
1488                                                 btgatt_gatt_id_t *char_id, int char_prop)
1489 {
1490         char uuid_str1[2*BT_UUID_STRING_MAX];
1491         char uuid_str2[2*BT_UUID_STRING_MAX];
1492         char str[50];
1493         BT_INFO("BTGATT Client Get Characteristic Callback, conn_id:%d, status:%d", conn_id, status);
1494         uuid_to_stringname((oal_uuid_t *)&(srvc_id->id.uuid), uuid_str1);
1495         BT_INFO("Service=> UUID: [%s], Inst_id: [%u], Type: [%s]",
1496                 uuid_str1, srvc_id->id.inst_id, srvc_id->is_primary ? "Primary" : "Secondary");
1497
1498         event_gattc_characteristic_result_t *event = g_new0(event_gattc_characteristic_result_t, 1);
1499         event->conn_status.conn_id = conn_id;
1500         event->conn_status.status = convert_to_oal_status(status);
1501         memcpy(&(event->srvc_id), srvc_id, sizeof(oal_gatt_srvc_id_t));
1502
1503         if (status == 0) {
1504                 uuid_to_stringname((oal_uuid_t *)&(char_id->uuid), uuid_str2);
1505                 BT_INFO("Charac=> UUID: [%s], Inst_id: [%u], Prop: [%s]",
1506                         uuid_str2, char_id->inst_id, char_prop_to_string(char_prop, str));
1507                 event->char_prop = char_prop;
1508                 memcpy(&(event->char_id), char_id, sizeof(oal_gatt_id_t));
1509         }
1510         send_event(OAL_EVENT_GATTC_CHARAC_SERACH_RESULT, event, sizeof(*event));
1511 }
1512
1513
1514
1515 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)
1516 {
1517         char uuid_str1[2*BT_UUID_STRING_MAX];
1518         char uuid_str2[2*BT_UUID_STRING_MAX];
1519         char uuid_str3[2*BT_UUID_STRING_MAX];
1520         BT_INFO("BTGATT Client Get Descriptor Callback, conn_id:%d, status:%d", conn_id, status);
1521         uuid_to_stringname((oal_uuid_t *)&(srvc_id->id.uuid), uuid_str1);
1522         uuid_to_stringname((oal_uuid_t *)&(char_id->uuid), uuid_str2);
1523         BT_INFO("Service=> UUID: [%s], Inst_id: [%u], Type: [%s]",
1524                 uuid_str1, srvc_id->id.inst_id, srvc_id->is_primary ? "Primary" : "Secondary");
1525         BT_INFO("Charac=> UUID: [%s], Inst_id: [%u]", uuid_str2, char_id->inst_id);
1526
1527         event_gattc_descriptor_result_t *event = g_new0(event_gattc_descriptor_result_t, 1);
1528         event->conn_status.conn_id = conn_id;
1529         event->conn_status.status = convert_to_oal_status(status);
1530         memcpy(&(event->srvc_id), srvc_id, sizeof(oal_gatt_srvc_id_t));
1531         memcpy(&(event->char_id), char_id, sizeof(oal_gatt_id_t));
1532
1533         if (status == 0) {
1534                 uuid_to_stringname((oal_uuid_t *)&(descr_id->uuid), uuid_str3);
1535                 BT_INFO("Desc=> UUID: [%s], Inst_id: [%u]", uuid_str3, descr_id->inst_id);
1536                 memcpy(&(event->descr_id), descr_id, sizeof(oal_gatt_id_t));
1537         }
1538         send_event(OAL_EVENT_GATTC_DESC_SERACH_RESULT, event, sizeof(*event));
1539 }
1540
1541 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)
1542 {
1543         char uuid_str1[2*BT_UUID_STRING_MAX];
1544         char uuid_str2[2*BT_UUID_STRING_MAX];
1545         BT_INFO("BTGATT Client Register For Notification Callback, client_if:%d, status:%d, registered: %s",
1546                 client_if, status, registered == 1 ? "REGISTERED" : "DEREGISTERED");
1547         uuid_to_stringname((oal_uuid_t *)&(srvc_id->id.uuid), uuid_str1);
1548         uuid_to_stringname((oal_uuid_t *)&(char_id->uuid), uuid_str2);
1549         BT_INFO("Service=> UUID: [%s], Inst_id: [%u], Type: [%s]", uuid_str1, srvc_id->id.inst_id, srvc_id->is_primary ? "Primary" : "Secondary");
1550         BT_INFO("Charac=> UUID: [%s], Inst_id: [%u]", uuid_str2, char_id->inst_id);
1551
1552         event_gattc_regdereg_notify_t *event = g_new0(event_gattc_regdereg_notify_t, 1);
1553         oal_event_t event_type = (registered == 1 ? OAL_EVENT_GATTC_NOTIFICATION_REGISTERED : OAL_EVENT_GATTC_NOTIFICATION_DEREGISTERED);
1554         event->client_if = client_if;
1555         event->status = convert_to_oal_status(status);
1556         memcpy(&(event->srvc_id), srvc_id, sizeof(oal_gatt_srvc_id_t));
1557         memcpy(&(event->char_id), char_id, sizeof(oal_gatt_id_t));
1558
1559         send_event(event_type, event, sizeof(*event));
1560 }
1561
1562 static void cb_gattc_notify(int conn_id, btgatt_notify_params_t *p_data)
1563 {
1564         bdstr_t bdstr;
1565         char uuid_str1[2*BT_UUID_STRING_MAX];
1566         char uuid_str2[2*BT_UUID_STRING_MAX];
1567
1568         BT_INFO("BTGATT Client Notify Callback, conn_id:%d", conn_id);
1569         BT_INFO("Server Address:[%s], is_notify:[%d], len:[%d]",
1570                 bdt_bd2str((bt_address_t *)&(p_data->bda), &bdstr), p_data->is_notify, p_data->len);
1571
1572         uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
1573         uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
1574
1575         BT_INFO("Service=> UUID: [%s], Inst_id: [%u], Type: [%s]",
1576                 uuid_str1, p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
1577         BT_INFO("Charac=> UUID: [%s], Inst_id: [%u]", uuid_str2, p_data->char_id.inst_id);
1578
1579         if (p_data->len > 0) {
1580                 char *data = NULL;
1581                 data = g_malloc(3*p_data->len+1);
1582                 if (!data) {
1583                         BT_ERR("memory allocation failed");
1584                         return;
1585                 }
1586
1587                 convert_hex_2_str((unsigned char *)p_data->value, p_data->len, data);
1588                 BT_INFO("Notified Data: [%s]", data);
1589
1590                 event_gattc_notify_data *event = g_new0(event_gattc_notify_data, 1);
1591                 memcpy(event->address.addr, p_data->bda.address, BT_ADDRESS_BYTES_NUM);
1592                 event->is_notify = p_data->is_notify;
1593                 event->data_len = p_data->len;
1594                 memcpy(event->data, p_data->value, event->data_len);
1595                 memcpy(&(event->char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
1596                 memcpy(&(event->srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
1597
1598                 send_event_bda_trace(OAL_EVENT_GATTC_NOTIFY_DATA, event, sizeof(*event), (bt_address_t *)&p_data->bda);
1599                 g_free(data);
1600         }
1601 }
1602
1603
1604 static void cb_gattc_read_characteristic(int conn_id, int status, btgatt_read_params_t *p_data)
1605 {
1606         char uuid_str1[2*BT_UUID_STRING_MAX];
1607         char uuid_str2[2*BT_UUID_STRING_MAX];
1608         BT_INFO("BTGATT Client Read Charcateristic Callback, conn_id:%d, read_status:%d", conn_id, status);
1609
1610         event_gattc_read_data *event = g_new0(event_gattc_read_data, 1);
1611         event->uuid_status.conn_status.conn_id = conn_id;
1612         event->uuid_status.conn_status.status = convert_to_oal_status(status);
1613         event->value_type = p_data->value_type;
1614         memcpy(&(event->uuid_status.srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
1615         memcpy(&(event->uuid_status.char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
1616         if (status == 0) {
1617                 uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
1618                 uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
1619                 BT_INFO("Service=> UUID: [%s], Inst_id: [%u], Type: [%s]", uuid_str1,
1620                         p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
1621                 BT_INFO("Charac=> UUID: [%s], Inst_id: [%u]", uuid_str2, p_data->char_id.inst_id);
1622                 BT_INFO("Len: %u, value_type: %u", p_data->value.len, p_data->value_type);
1623                 if (p_data->value.len > 0 && event->value_type == GATTC_READ_VALUE_TYPE_VALUE) {
1624                         char *data = NULL;
1625                         data = g_malloc(3*p_data->value.len+1);
1626                         if (!data) {
1627                                 BT_ERR("memory allocation failed");
1628                                 g_free(event);
1629                                 return;
1630                         }
1631                         convert_hex_2_str((unsigned char *)p_data->value.value, p_data->value.len, data);
1632                         BT_INFO("Read Data: [%s]", data);
1633                         event->data_len = p_data->value.len;
1634                         memcpy(&(event->data), &(p_data->value.value), event->data_len);
1635                         g_free(data);
1636                 }
1637         }
1638         send_event(OAL_EVENT_GATTC_READ_CHARAC, event, sizeof(*event));
1639 }
1640
1641 static void cb_gattc_write_characteristic(int conn_id, int status, btgatt_write_params_t *p_data)
1642 {
1643         char uuid_str1[2*BT_UUID_STRING_MAX];
1644         char uuid_str2[2*BT_UUID_STRING_MAX];
1645         BT_INFO("BTGATT Client Write Charcateristic Callback, conn_id:%d, write_status:%d", conn_id, status);
1646
1647         event_gattc_write_data *event = g_new0(event_gattc_write_data, 1);
1648         event->conn_status.conn_id = conn_id;
1649         event->conn_status.status = convert_to_oal_status(status);
1650         memcpy(&(event->srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
1651         memcpy(&(event->char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
1652         if (status == 0) {
1653                 uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
1654                 uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
1655                 BT_INFO("Service=> UUID: [%s], Inst_id: [%u], Type: [%s]", uuid_str1,
1656                         p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
1657                 BT_INFO("Charac=> UUID: [%s], Inst_id: [%u]", uuid_str2, p_data->char_id.inst_id);
1658         }
1659         send_event(OAL_EVENT_GATTC_WRITE_CHARAC, event, sizeof(*event));
1660 }
1661
1662 static void cb_gattc_write_descriptor(int conn_id, int status, btgatt_write_params_t *p_data)
1663 {
1664         char uuid_str1[2*BT_UUID_STRING_MAX];
1665         char uuid_str2[2*BT_UUID_STRING_MAX];
1666         char uuid_str3[2*BT_UUID_STRING_MAX];
1667         BT_INFO("BTGATT Client Write Descriptor Callback, conn_id:%d, write_status:%d", conn_id, status);
1668
1669         event_gattc_write_data *event = g_new0(event_gattc_write_data, 1);
1670         event->conn_status.conn_id = conn_id;
1671         event->conn_status.status = convert_to_oal_status(status);
1672         memcpy(&(event->srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
1673         memcpy(&(event->char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
1674         memcpy(&(event->descr_id), &(p_data->descr_id), sizeof(oal_gatt_id_t));
1675         if (status == 0) {
1676                 uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
1677                 uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
1678                 uuid_to_stringname((oal_uuid_t *)&(p_data->descr_id.uuid), uuid_str3);
1679                 BT_INFO("Service=> UUID: [%s], Inst_id: [%u], Type: [%s]", uuid_str1,
1680                         p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
1681                 BT_INFO("Charac=> UUID: [%s], Inst_id: [%u]", uuid_str2, p_data->char_id.inst_id);
1682                 BT_INFO("Desc=> UUID: [%s], Inst_id: [%u]", uuid_str3, p_data->descr_id.inst_id);
1683         }
1684         send_event(OAL_EVENT_GATTC_WRITE_DESCR, event, sizeof(*event));
1685 }
1686
1687
1688
1689 static void cb_gattc_read_descriptor(int conn_id, int status, btgatt_read_params_t *p_data)
1690 {
1691         char uuid_str1[2*BT_UUID_STRING_MAX];
1692         char uuid_str2[2*BT_UUID_STRING_MAX];
1693         char uuid_str3[2*BT_UUID_STRING_MAX];
1694         BT_INFO("BTGATT Client Read Descriptor Callback, conn_id:%d, read_status:%d", conn_id, status);
1695
1696         event_gattc_read_data *event = g_new0(event_gattc_read_data, 1);
1697         event->uuid_status.conn_status.conn_id = conn_id;
1698         event->uuid_status.conn_status.status = convert_to_oal_status(status);
1699         event->value_type = p_data->value_type;
1700         memcpy(&(event->uuid_status.srvc_id), &(p_data->srvc_id), sizeof(oal_gatt_srvc_id_t));
1701         memcpy(&(event->uuid_status.char_id), &(p_data->char_id), sizeof(oal_gatt_id_t));
1702         memcpy(&(event->uuid_status.descr_id), &(p_data->descr_id), sizeof(oal_gatt_id_t));
1703
1704         if (status == 0) {
1705                 uuid_to_stringname((oal_uuid_t *)&(p_data->srvc_id.id.uuid), uuid_str1);
1706                 uuid_to_stringname((oal_uuid_t *)&(p_data->char_id.uuid), uuid_str2);
1707                 uuid_to_stringname((oal_uuid_t *)&(p_data->descr_id.uuid), uuid_str3);
1708                 BT_INFO("Service=> UUID: [%s], Inst_id: [%u], Type: [%s]", uuid_str1,
1709                         p_data->srvc_id.id.inst_id, p_data->srvc_id.is_primary ? "Primary" : "Secondary");
1710                 BT_INFO("Charac=> UUID: [%s], Inst_id: [%u]", uuid_str2, p_data->char_id.inst_id);
1711                 BT_INFO("Desc=> UUID: [%s], Inst_id: [%u]", uuid_str3, p_data->descr_id.inst_id);
1712                 BT_INFO("Len: %u, value_type: %u", p_data->value.len, p_data->value_type);
1713                 if (p_data->value.len > 0 && event->value_type == GATTC_READ_VALUE_TYPE_VALUE) {
1714                         char *data = NULL;
1715                         data = g_malloc(3*p_data->value.len+1);
1716                         if (!data) {
1717                                 BT_ERR("memory allocation failed");
1718                                 g_free(event);
1719                                 return;
1720                         }
1721                         convert_hex_2_str((unsigned char *)p_data->value.value, p_data->value.len, data);
1722                         BT_INFO("Read Data: [%s]", data);
1723                         event->data_len = p_data->value.len;
1724                         memcpy(&(event->data), &(p_data->value.value), event->data_len);
1725                         g_free(data);
1726                 }
1727         }
1728         send_event(OAL_EVENT_GATTC_READ_DESCR, event, sizeof(*event));
1729 }
1730
1731 oal_status_t gattc_start_le_discovery(int client_id)
1732 {
1733
1734         int ret = OAL_STATUS_SUCCESS;
1735
1736         API_TRACE("BTGATT CLIENT SCAN START");
1737         CHECK_OAL_GATT_ENABLED();
1738         CHECK_CLIENT_REGISTRATION(client_id);
1739
1740         ret = gatt_api->client->scan(client_id, 1);
1741         if (ret != BT_STATUS_SUCCESS) {
1742                 BT_ERR("Error:Start LE Discovery failed: %s", status2string(ret));
1743                 return convert_to_oal_status(ret);
1744         }
1745         send_event(OAL_EVENT_BLE_DISCOVERY_STARTED, NULL, 0);
1746         return OAL_STATUS_SUCCESS;
1747 }
1748
1749 oal_status_t gattc_stop_le_discovery(int client_id)
1750 {
1751
1752         int ret = OAL_STATUS_SUCCESS;
1753
1754         API_TRACE("Scan is stopped");
1755         CHECK_OAL_GATT_ENABLED();
1756         CHECK_CLIENT_REGISTRATION(client_id);
1757         ret = gatt_api->client->scan(client_id, 0);
1758         if (ret != BT_STATUS_SUCCESS) {
1759                 BT_ERR("Error:Stop LE Discovery failed: %s", status2string(ret));
1760                 return convert_to_oal_status(ret);
1761         } else
1762                 send_event(OAL_EVENT_BLE_DISCOVERY_STOPPED, NULL, 0);
1763         return OAL_STATUS_SUCCESS;
1764 }
1765
1766 oal_status_t gattc_set_le_scan_param(int scan_type, int itv, int win)
1767 {
1768         int ret;
1769
1770         API_TRACE("Scan is stopped");
1771         CHECK_OAL_GATT_ENABLED();
1772
1773 #ifdef TIZEN_BT_HAL
1774         ret = gatt_api->client->set_scan_parameters(scan_type, itv, win);
1775         if (ret != BT_STATUS_SUCCESS) {
1776                 BT_ERR("Error:Set scan parameters failed: %s", status2string(ret));
1777                 return convert_to_oal_status(ret);
1778         }
1779 #else
1780         ret = gatt_api->client->set_scan_parameters(itv, win);
1781         if (ret != BT_STATUS_SUCCESS) {
1782                 BT_ERR("Error:Set scan parameters failed: %s", status2string(ret));
1783                 return convert_to_oal_status(ret);
1784         }
1785 #endif
1786
1787         return OAL_STATUS_SUCCESS;
1788 }
1789 /************************************ GATT Client ***********************************/
1790 oal_status_t gattc_register(oal_uuid_t* client_uuid)
1791 {
1792
1793         char str[2*BT_UUID_STRING_MAX];
1794         int ret = OAL_STATUS_SUCCESS;
1795
1796         CHECK_OAL_GATT_ENABLED();
1797         uuid_to_stringname(client_uuid, str);
1798         API_TRACE("uuid: [%s]", str);
1799         /* We will perform actual registration in cb_gattc_register_app callback */
1800         ret = gatt_api->client->register_client((bt_uuid_t *)client_uuid);
1801         if (ret != BT_STATUS_SUCCESS) {
1802                 BT_ERR("GATT client register failed: %s", status2string(ret));
1803                 return convert_to_oal_status(ret);
1804         }
1805         return OAL_STATUS_SUCCESS;
1806 }
1807
1808 oal_status_t gattc_deregister(int client_id)
1809 {
1810         int ret = OAL_STATUS_SUCCESS;
1811
1812         API_TRACE("GATT client deregister");
1813         CHECK_OAL_GATT_ENABLED();
1814         CHECK_CLIENT_REGISTRATION(client_id);
1815
1816         ret = gatt_api->client->unregister_client(client_id);
1817         if (ret != BT_STATUS_SUCCESS) {
1818                 BT_ERR("GATT client deregister failed: %s", status2string(ret));
1819                 return convert_to_oal_status(ret);
1820         }
1821
1822         return OAL_STATUS_SUCCESS;
1823 }
1824
1825 oal_status_t gattc_connect(int client_id, bt_address_t *device_address, int isDirect)
1826 {
1827         int ret = OAL_STATUS_SUCCESS;
1828         bdstr_t bdstr;
1829
1830         OAL_CHECK_PARAMETER(device_address, return);
1831         API_TRACE("Client Connect: [%s]", bdt_bd2str(device_address, &bdstr));
1832         CHECK_OAL_GATT_ENABLED();
1833         CHECK_CLIENT_REGISTRATION(client_id);
1834
1835         /* Handle the actual connection in cb_gattc_connection callback */
1836         ret = gatt_api->client->connect(client_id, (bt_bdaddr_t *)device_address, isDirect);
1837         if (ret != BT_STATUS_SUCCESS) {
1838                 BT_ERR("GATT client connect failed: %s", status2string(ret));
1839                 return convert_to_oal_status(ret);
1840         }
1841         return OAL_STATUS_SUCCESS;
1842 }
1843
1844 oal_status_t gattc_disconnect(int client_id, bt_address_t *device_address, int conn_id)
1845 {
1846
1847         int ret = OAL_STATUS_SUCCESS;
1848         bdstr_t bdstr;
1849
1850         OAL_CHECK_PARAMETER(device_address, return);
1851         API_TRACE("Client Disconnect: [%s]", bdt_bd2str(device_address, &bdstr));
1852         CHECK_OAL_GATT_ENABLED();
1853         CHECK_CLIENT_REGISTRATION(client_id);
1854         CHECK_CLIENT_CONNECTION(conn_id);
1855
1856         /* Handle actual disconnection in callback */
1857         ret = gatt_api->client->disconnect(client_id, (bt_bdaddr_t *) device_address, conn_id);
1858         if (ret != BT_STATUS_SUCCESS) {
1859                 BT_ERR("GATT client disconnect failed: %s", status2string(ret));
1860                 return convert_to_oal_status(ret);
1861         }
1862         return OAL_STATUS_SUCCESS;
1863 }
1864
1865
1866 oal_status_t gattc_search_service(int conn_id, oal_uuid_t *service_uuid)
1867 {
1868         int ret = OAL_STATUS_SUCCESS;
1869         char uuid_str[2*BT_UUID_STRING_MAX];
1870
1871         if (service_uuid) {
1872                 uuid_to_stringname(service_uuid, uuid_str);
1873                 API_TRACE("Client Service Search UUID: [%s]", uuid_str);
1874         } else
1875                 API_TRACE("Client Service Search All");
1876
1877         CHECK_OAL_GATT_ENABLED();
1878         CHECK_CLIENT_CONNECTION(conn_id);
1879         ret = gatt_api->client->search_service(conn_id, (bt_uuid_t *)service_uuid);
1880
1881         if (ret != BT_STATUS_SUCCESS) {
1882                 BT_ERR("GATT client service search failed: %s", status2string(ret));
1883                 return convert_to_oal_status(ret);
1884         }
1885         return OAL_STATUS_SUCCESS;
1886 }
1887
1888 oal_status_t gattc_get_characteristic(int conn_id, oal_gatt_srvc_id_t *srvc_id, oal_gatt_id_t *char_id)
1889 {
1890         int ret = OAL_STATUS_SUCCESS;
1891         char uuid_str[2*BT_UUID_STRING_MAX];
1892
1893         OAL_CHECK_PARAMETER(srvc_id, return);
1894         uuid_to_stringname(&(srvc_id->id.uuid), uuid_str);
1895         API_TRACE("Client Get Characteristic, Service_uuid: [%s]", uuid_str);
1896         CHECK_OAL_GATT_ENABLED();
1897         CHECK_CLIENT_CONNECTION(conn_id);
1898         ret = gatt_api->client->get_characteristic(conn_id, (btgatt_srvc_id_t *)srvc_id,
1899                                         (btgatt_gatt_id_t *)char_id);
1900         if (ret != BT_STATUS_SUCCESS) {
1901                 BT_ERR("GATT client get characteristic failed: %s", status2string(ret));
1902                 return convert_to_oal_status(ret);
1903         }
1904         return OAL_STATUS_SUCCESS;
1905 }
1906
1907 oal_status_t gattc_get_descriptor(int conn_id, oal_gatt_srvc_id_t *srvc_id,
1908                                 oal_gatt_id_t *char_id, oal_gatt_id_t *desc_id)
1909 {
1910         int ret = OAL_STATUS_SUCCESS;
1911         char uuid_str1[2*BT_UUID_STRING_MAX];
1912         char uuid_str2[2*BT_UUID_STRING_MAX];
1913
1914         OAL_CHECK_PARAMETER(srvc_id, return);
1915         OAL_CHECK_PARAMETER(char_id, return);
1916         uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
1917         uuid_to_stringname(&(char_id->uuid), uuid_str2);
1918         API_TRACE("Client Get Descriptor, Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
1919         CHECK_OAL_GATT_ENABLED();
1920         CHECK_CLIENT_CONNECTION(conn_id);
1921         ret = gatt_api->client->get_descriptor(conn_id, (btgatt_srvc_id_t *)srvc_id,
1922                                 (btgatt_gatt_id_t *)char_id, (btgatt_gatt_id_t *)desc_id);
1923         if (ret != BT_STATUS_SUCCESS) {
1924                 BT_ERR("GATT client get descriptor failed: %s", status2string(ret));
1925                 return convert_to_oal_status(ret);
1926         }
1927         return OAL_STATUS_SUCCESS;
1928 }
1929
1930 oal_status_t gattc_register_for_notification(int client_id, bt_address_t * address,
1931                         oal_gatt_srvc_id_t *srvc_id, oal_gatt_id_t *char_id) {
1932         int ret = OAL_STATUS_SUCCESS;
1933         char uuid_str1[2*BT_UUID_STRING_MAX];
1934         char uuid_str2[2*BT_UUID_STRING_MAX];
1935         bdstr_t bdstr;
1936
1937         OAL_CHECK_PARAMETER(address, return);
1938         OAL_CHECK_PARAMETER(srvc_id, return);
1939         OAL_CHECK_PARAMETER(char_id, return);
1940         uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
1941         uuid_to_stringname(&(char_id->uuid), uuid_str2);
1942         API_TRACE("Client Register Notification: [%s], Service_uuid: [%s], Char_uuid: [%s]", bdt_bd2str(address, &bdstr), uuid_str1, uuid_str2);
1943         CHECK_OAL_GATT_ENABLED();
1944         CHECK_CLIENT_REGISTRATION(client_id);
1945
1946         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);
1947         if (ret != BT_STATUS_SUCCESS) {
1948                 BT_ERR("GATT client register notification failed: %s", status2string(ret));
1949                 return convert_to_oal_status(ret);
1950         }
1951
1952         return OAL_STATUS_SUCCESS;
1953 }
1954
1955 oal_status_t gattc_deregister_for_notification(int client_id, bt_address_t * address,
1956                         oal_gatt_srvc_id_t *srvc_id, oal_gatt_id_t *char_id) {
1957         int ret = OAL_STATUS_SUCCESS;
1958         char uuid_str1[2*BT_UUID_STRING_MAX];
1959         char uuid_str2[2*BT_UUID_STRING_MAX];
1960         bdstr_t bdstr;
1961
1962         OAL_CHECK_PARAMETER(address, return);
1963         OAL_CHECK_PARAMETER(srvc_id, return);
1964         OAL_CHECK_PARAMETER(char_id, return);
1965         uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
1966         uuid_to_stringname(&(char_id->uuid), uuid_str2);
1967         API_TRACE("Client Deregister Notification: [%s], Service_uuid: [%s], Char_uuid: [%s]", bdt_bd2str(address, &bdstr), uuid_str1, uuid_str2);
1968         CHECK_OAL_GATT_ENABLED();
1969         CHECK_CLIENT_REGISTRATION(client_id);
1970
1971         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);
1972         if (ret != BT_STATUS_SUCCESS) {
1973                 BT_ERR("GATT client deregister notification failed: %s", status2string(ret));
1974                 return convert_to_oal_status(ret);
1975         }
1976
1977         return OAL_STATUS_SUCCESS;
1978 }
1979
1980
1981 oal_status_t gattc_read_characteristic(int conn_id, oal_gatt_srvc_id_t *srvc_id,
1982                                 oal_gatt_id_t *char_id, oal_gatt_auth_req_t auth_req)
1983 {
1984         int ret = OAL_STATUS_SUCCESS;
1985         char uuid_str1[2*BT_UUID_STRING_MAX];
1986         char uuid_str2[2*BT_UUID_STRING_MAX];
1987
1988         OAL_CHECK_PARAMETER(srvc_id, return);
1989         OAL_CHECK_PARAMETER(char_id, return);
1990         uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
1991         uuid_to_stringname(&(char_id->uuid), uuid_str2);
1992         API_TRACE("Client Read Characteristic: Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
1993         CHECK_OAL_GATT_ENABLED();
1994         CHECK_CLIENT_CONNECTION(conn_id);
1995
1996         ret = gatt_api->client->read_characteristic(conn_id, (btgatt_srvc_id_t *)srvc_id,
1997                                         (btgatt_gatt_id_t *)char_id, auth_req);
1998         if (ret != BT_STATUS_SUCCESS) {
1999                 BT_ERR("GATT client read characteristic failed: %s", status2string(ret));
2000                 return convert_to_oal_status(ret);
2001         }
2002
2003         return OAL_STATUS_SUCCESS;
2004 }
2005
2006 oal_status_t gattc_read_descriptor(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2007                 oal_gatt_id_t *char_id, oal_gatt_id_t *desc_id, oal_gatt_auth_req_t auth_req)
2008 {
2009         int ret = OAL_STATUS_SUCCESS;
2010         char uuid_str1[2*BT_UUID_STRING_MAX];
2011         char uuid_str2[2*BT_UUID_STRING_MAX];
2012         char uuid_str3[2*BT_UUID_STRING_MAX];
2013
2014         OAL_CHECK_PARAMETER(srvc_id, return);
2015         OAL_CHECK_PARAMETER(char_id, return);
2016         OAL_CHECK_PARAMETER(desc_id, return);
2017         uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2018         uuid_to_stringname(&(char_id->uuid), uuid_str2);
2019         uuid_to_stringname(&(desc_id->uuid), uuid_str3);
2020         API_TRACE("Client Read Descriptor: Service_uuid: [%s], Char_uuid: [%s], Desc_uuid: [%s]",
2021                         uuid_str1, uuid_str2, uuid_str3);
2022         CHECK_OAL_GATT_ENABLED();
2023         CHECK_CLIENT_CONNECTION(conn_id);
2024
2025         ret = gatt_api->client->read_descriptor(conn_id, (btgatt_srvc_id_t *)srvc_id,
2026                                 (btgatt_gatt_id_t *)char_id, (btgatt_gatt_id_t *)desc_id, auth_req);
2027         if (ret != BT_STATUS_SUCCESS) {
2028                 BT_ERR("GATT client read descriptor failed: %s", status2string(ret));
2029                 return convert_to_oal_status(ret);
2030         }
2031
2032         return OAL_STATUS_SUCCESS;
2033 }
2034
2035 oal_status_t gattc_acquire_notify(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2036                 oal_gatt_id_t *char_id,  int *fd, int *mtu)
2037 {
2038         int ret = OAL_STATUS_SUCCESS;
2039         char uuid_str1[2*BT_UUID_STRING_MAX];
2040         char uuid_str2[2*BT_UUID_STRING_MAX];
2041         OAL_CHECK_PARAMETER(srvc_id, return);
2042         OAL_CHECK_PARAMETER(char_id, return);
2043         uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2044         uuid_to_stringname(&(char_id->uuid), uuid_str2);
2045         API_TRACE("Client Write Characteristic: Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
2046         CHECK_OAL_GATT_ENABLED();
2047         CHECK_CLIENT_CONNECTION(conn_id);
2048
2049         ret = gatt_api->client->acquire_notify(conn_id, (btgatt_srvc_id_t *)srvc_id,
2050                         (btgatt_gatt_id_t *)char_id, fd, mtu);
2051         if (ret != BT_STATUS_SUCCESS) {
2052                 BT_ERR("GATT client write characteristic failed: %s", status2string(ret));
2053                 return convert_to_oal_status(ret);
2054         }
2055
2056         return OAL_STATUS_SUCCESS;
2057 }
2058
2059 oal_status_t gattc_acquire_write(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2060                 oal_gatt_id_t *char_id,  oal_gatt_auth_req_t auth_req , int *fd, int*mtu)
2061 {
2062         int ret = OAL_STATUS_SUCCESS;
2063         char uuid_str1[2*BT_UUID_STRING_MAX];
2064         char uuid_str2[2*BT_UUID_STRING_MAX];
2065         OAL_CHECK_PARAMETER(srvc_id, return);
2066         OAL_CHECK_PARAMETER(char_id, return);
2067         uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2068         uuid_to_stringname(&(char_id->uuid), uuid_str2);
2069         API_TRACE("Client Write Characteristic: Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
2070         CHECK_OAL_GATT_ENABLED();
2071         CHECK_CLIENT_CONNECTION(conn_id);
2072
2073         ret = gatt_api->client->acquire_write(conn_id, (btgatt_srvc_id_t *)srvc_id,
2074                         (btgatt_gatt_id_t *)char_id,  auth_req, fd, mtu);
2075         if (ret != BT_STATUS_SUCCESS) {
2076                 BT_ERR("GATT client write characteristic failed: %s", status2string(ret));
2077                 return convert_to_oal_status(ret);
2078         }
2079
2080         return OAL_STATUS_SUCCESS;
2081 }
2082
2083 oal_status_t gattc_write_characteristic(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2084                 oal_gatt_id_t *char_id, oal_gatt_write_type_t write_type,
2085                 int len, oal_gatt_auth_req_t auth_req, char* data)
2086 {
2087         int ret = OAL_STATUS_SUCCESS;
2088         char uuid_str1[2*BT_UUID_STRING_MAX];
2089         char uuid_str2[2*BT_UUID_STRING_MAX];
2090         OAL_CHECK_PARAMETER(srvc_id, return);
2091         OAL_CHECK_PARAMETER(char_id, return);
2092         OAL_CHECK_PARAMETER(data, return);
2093         uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2094         uuid_to_stringname(&(char_id->uuid), uuid_str2);
2095         API_TRACE("Client Write Characteristic: Service_uuid: [%s], Char_uuid: [%s]", uuid_str1, uuid_str2);
2096         CHECK_OAL_GATT_ENABLED();
2097         CHECK_CLIENT_CONNECTION(conn_id);
2098
2099         ret = gatt_api->client->write_characteristic(conn_id, (btgatt_srvc_id_t *)srvc_id,
2100                         (btgatt_gatt_id_t *)char_id, write_type, len, auth_req, data);
2101         if (ret != BT_STATUS_SUCCESS) {
2102                 BT_ERR("GATT client write characteristic failed: %s", status2string(ret));
2103                 return convert_to_oal_status(ret);
2104         }
2105
2106         return OAL_STATUS_SUCCESS;
2107 }
2108
2109 oal_status_t gattc_write_descriptor(int conn_id, oal_gatt_srvc_id_t *srvc_id,
2110                 oal_gatt_id_t *char_id, oal_gatt_id_t *desc_id,
2111                 oal_gatt_write_type_t write_type, int len, oal_gatt_auth_req_t auth_req, char* data)
2112 {
2113         int ret = OAL_STATUS_SUCCESS;
2114         char uuid_str1[2*BT_UUID_STRING_MAX];
2115         char uuid_str2[2*BT_UUID_STRING_MAX];
2116         char uuid_str3[2*BT_UUID_STRING_MAX];
2117         OAL_CHECK_PARAMETER(srvc_id, return);
2118         OAL_CHECK_PARAMETER(char_id, return);
2119         OAL_CHECK_PARAMETER(desc_id, return);
2120         OAL_CHECK_PARAMETER(data, return);
2121         uuid_to_stringname(&(srvc_id->id.uuid), uuid_str1);
2122         uuid_to_stringname(&(char_id->uuid), uuid_str2);
2123         uuid_to_stringname(&(desc_id->uuid), uuid_str3);
2124         API_TRACE("Client Write Descriptor: Service_uuid: [%s], Char_uuid: [%s], Desc_uuid: [%s]",
2125                                 uuid_str1, uuid_str2, uuid_str3);
2126         CHECK_OAL_GATT_ENABLED();
2127         CHECK_CLIENT_CONNECTION(conn_id);
2128
2129         ret = gatt_api->client->write_descriptor(conn_id, (btgatt_srvc_id_t *)srvc_id,
2130                         (btgatt_gatt_id_t *)char_id, (btgatt_gatt_id_t *)desc_id, write_type, len, auth_req, data);
2131         if (ret != BT_STATUS_SUCCESS) {
2132                 BT_ERR("GATT client write characteristic failed: %s", status2string(ret));
2133                 return convert_to_oal_status(ret);
2134         }
2135
2136         return OAL_STATUS_SUCCESS;
2137 }
2138
2139 oal_status_t gattc_conn_param_update(bt_address_t * address, int min, int max, int latency, int timeout)
2140 {
2141         int ret;
2142         bdstr_t bdstr;
2143
2144         OAL_CHECK_PARAMETER(address, return);
2145         API_TRACE("Conn Param Update: [%s]", bdt_bd2str(address, &bdstr));
2146         CHECK_OAL_GATT_ENABLED();
2147
2148         BT_INFO("[%s] min[%d] max[%d] latency[%d] timeout[%d]", bdt_bd2str(address, &bdstr), min, max, latency, timeout);
2149         ret = gatt_api->client->conn_parameter_update((bt_bdaddr_t *)address, min, max, latency, timeout);
2150         if (ret != BT_STATUS_SUCCESS) {
2151                 BT_ERR("error: %s", status2string(ret));
2152                 return convert_to_oal_status(ret);
2153         }
2154         return OAL_STATUS_SUCCESS;
2155 }