bt-oal/bluez_hal/src/bt-hal-gatt.c

   1 /*
   2  * BLUETOOOTH HAL
   3  *
   4  * Copyright (c) 2015 - 2016 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Anupam Roy <anupam.r@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at:
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21
  22
  23 /*******************************************************************************
  24  *
  25  * Description: GATT Profile Bluetooth Interface
  26  *
  27  *******************************************************************************/
  28
  29 #include <hardware/bluetooth.h>
  30 #include <hardware/bt_gatt.h>
  31 #include <stdio.h>
  32 #include <stdlib.h>
  33 #include <errno.h>
  34 #include <string.h>
  35 #include <dlog.h>
  36
  37 #include "bt-hal.h"
  38 #include "bt-hal-log.h"
  39 #include "bt-hal-msg.h"
  40 #include "bt-hal-utils.h"
  41
  42 #include "bt-hal-adapter-le.h"
  43 #include "bt-hal-gatt-server.h"
  44 #include "bt-hal-gatt-client.h"
  45 #include "bt_gatt_types.h"
  46
  47 /* Advertising report event types */
  48 #define BT_LE_ADV_IND   0x00
  49 #define BT_LE_ADV_DIRECT_IND    0x01
  50 #define BT_LE_ADV_SCAN_IND      0x02
  51 #define BT_LE_ADV_NONCONN_IND   0x03
  52 #define BT_LE_ADV_SCAN_RSP      0x04
  53
  54 #define BT_HAL_ADV_DATA_MAX_SIZE        31
  55 #define BT_HAL_GATTC_READ_VALUE_TYPE_VALUE          0x0000  /* Attribute value itself */
  56 typedef struct {
  57         char addr[18];
  58         uint8_t addr_type;
  59         uint8_t adv_type;
  60         int rssi;
  61         int data_len;
  62         uint8_t data[BT_HAL_ADV_DATA_MAX_SIZE * 2];
  63         guint timer_id;
  64 } bt_hal_le_adv_info_t;
  65
  66 /****************************************** Global Variables ******************************************/
  67 const btgatt_callbacks_t *bt_gatt_callbacks = NULL;
  68
  69 extern btgatt_client_interface_t btgatt_client_interface;
  70 extern btgatt_server_interface_t btgatt_server_interface;
  71
  72 static GSList *adv_ind_list = NULL;
  73 /****************************************** Forward Declarations *************************************/
  74 static void __bt_handle_gatt_client_registered(void *buf, uint16_t len);
  75 static void __bt_hal_handle_gatt_client_scan_result(void *buf, uint16_t len);
  76 static void __bt_handle_gatt_client_connected(void *buf, uint16_t len);
  77 static void __bt_handle_gatt_client_disconnected(void *buf, uint16_t len);
  78 static void __bt_handle_gatt_client_search_result(void *buf, uint16_t len);
  79 static void __bt_handle_gatt_client_search_complete(void *buf, uint16_t len);
  80 static void __bt_handle_gatt_client_search_char_result(void *buf, uint16_t len);
  81 static void __bt_handle_gatt_client_search_desc_result(void *buf, uint16_t len);
  82 static void __bt_handle_gatt_client_read_charac(void *buf, uint16_t len);
  83 static void __bt_handle_gatt_client_read_desc(void *buf, uint16_t len);
  84 static void __bt_handle_gatt_client_write_char(void *buf, uint16_t len);
  85 static void __bt_handle_gatt_client_write_desc(void *buf, uint16_t len);
  86 static void __bt_handle_gatt_client_watch_notification(void *buf, uint16_t len);
  87 /*****************************************************************************************************/
  88
  89 static bool interface_ready(void)
  90 {
  91         return bt_gatt_callbacks != NULL;
  92 }
  93
  94 static void __bt_hal_handle_server_instance_initialized(void *buf, uint16_t len)
  95 {
  96         struct hal_ev_server_instance_registered *ev = buf;
  97
  98         if (bt_gatt_callbacks->server->register_server_cb)
  99                 bt_gatt_callbacks->server->register_server_cb(ev->status, ev->server_instance, (bt_uuid_t*)&ev->app_uuid);
 100 }
 101
 102 static void __bt_hal_handle_multi_adv_data_set(void *buf, uint16_t len)
 103 {
 104         struct hal_ev_multi_adv_data_set *ev = buf;
 105
 106         if (bt_gatt_callbacks->server->multi_adv_data_cb)
 107                 bt_gatt_callbacks->server->multi_adv_data_cb(ev->server_instance, ev->status);
 108 }
 109
 110 static void __bt_hal_handle_multi_adv_data_update(void *buf, uint16_t len)
 111 {
 112         struct hal_ev_multi_adv_update *ev = buf;
 113
 114         if (bt_gatt_callbacks->server->multi_adv_update_cb)
 115                 bt_gatt_callbacks->server->multi_adv_update_cb(ev->server_instance, ev->status);
 116 }
 117
 118 static void __bt_hal_handle_multi_adv_enable(void *buf, uint16_t len)
 119 {
 120         struct hal_ev_multi_adv_enable *ev = buf;
 121
 122         if (bt_gatt_callbacks->server->multi_adv_enable_cb)
 123                 bt_gatt_callbacks->server->multi_adv_enable_cb(ev->server_instance, ev->status);
 124 }
 125
 126 static void __bt_hal_handle_multi_adv_disable(void *buf, uint16_t len)
 127 {
 128         struct hal_ev_multi_adv_disable *ev = buf;
 129
 130         if (bt_gatt_callbacks->server->multi_adv_disable_cb)
 131                 bt_gatt_callbacks->server->multi_adv_disable_cb(ev->server_instance, ev->status);
 132 }
 133
 134 /* Same callback for both Enable and DIsable */
 135 static void __bt_hal_handle_legacy_adv_status(void *buf, uint16_t len)
 136 {
 137         struct hal_ev_legacy_adv_status *ev = buf;
 138
 139         if (bt_gatt_callbacks->server->listen_cb)
 140                 bt_gatt_callbacks->server->listen_cb(ev->status, ev->server_instance);
 141 }
 142
 143 static void __bt_hal_handle_service_added(void *buf, uint16_t len)
 144 {
 145         struct hal_ev_gatt_service_added *ev = buf;
 146         btgatt_srvc_id_t srvc_id;
 147
 148         memset(&srvc_id, 0x00, sizeof(btgatt_srvc_id_t));
 149         srvc_id.is_primary = ev->is_primary;
 150         srvc_id.id.inst_id = ev->server_instance;
 151         memcpy(srvc_id.id.uuid.uu, ev->svc_uuid, sizeof(ev->svc_uuid));
 152
 153         if (bt_gatt_callbacks->server->service_added_cb)
 154                 bt_gatt_callbacks->server->service_added_cb(ev->status, ev->server_instance,
 155                                 &srvc_id, ev->service_handle);
 156 }
 157
 158 static void __bt_hal_handle_char_added(void *buf, uint16_t len)
 159 {
 160         struct hal_ev_gatt_char_added *ev = buf;
 161         bt_uuid_t uuid;
 162
 163         memcpy(uuid.uu, ev->char_uuid, sizeof(ev->char_uuid));
 164
 165         if (bt_gatt_callbacks->server->characteristic_added_cb)
 166                 bt_gatt_callbacks->server->characteristic_added_cb(ev->status, ev->server_instance,
 167                                 &uuid, ev->service_handle, ev->char_handle);
 168 }
 169
 170 static void __bt_hal_handle_desc_added(void *buf, uint16_t len)
 171 {
 172         struct hal_ev_gatt_desc_added *ev = buf;
 173         bt_uuid_t uuid;
 174
 175         memcpy(uuid.uu, ev->desc_uuid, sizeof(ev->desc_uuid));
 176
 177         if (bt_gatt_callbacks->server->descriptor_added_cb)
 178                 bt_gatt_callbacks->server->descriptor_added_cb(ev->status, ev->server_instance,
 179                                 &uuid, ev->service_handle, ev->desc_handle);
 180 }
 181
 182 static void __bt_hal_handle_service_started(void *buf, uint16_t len)
 183 {
 184         struct hal_ev_gatt_service_started *ev = buf;
 185
 186         if (bt_gatt_callbacks->server->service_started_cb)
 187                 bt_gatt_callbacks->server->service_started_cb(ev->status, ev->server_instance,
 188                                 ev->service_handle);
 189 }
 190
 191 static void __bt_hal_handle_service_deleted(void *buf, uint16_t len)
 192 {
 193         struct hal_ev_gatt_service_deleted *ev = buf;
 194
 195         if (bt_gatt_callbacks->server->service_deleted_cb)
 196                 bt_gatt_callbacks->server->service_deleted_cb(ev->status, ev->server_instance,
 197                                 ev->service_handle);
 198 }
 199
 200 static void __bt_hal_handle_gatt_server_connected(void *buf, uint16_t len)
 201 {
 202         struct hal_ev_gatt_server_connected *ev = buf;
 203         bt_bdaddr_t bd_addr;
 204
 205         memcpy(bd_addr.address, ev->bdaddr, 6);
 206
 207         if (bt_gatt_callbacks->server->connection_cb)
 208                 bt_gatt_callbacks->server->connection_cb(ev->conn_id, ev->server_instance,
 209                                 ev->connected, &bd_addr);
 210 }
 211
 212 static void __bt_hal_handle_gatt_server_read_requested(void *buf, uint16_t len)
 213 {
 214         struct hal_ev_gatt_server_read_req *ev = buf;
 215         bt_bdaddr_t bd_addr;
 216
 217         memcpy(bd_addr.address, ev->bdaddr, 6);
 218
 219         if (bt_gatt_callbacks->server->request_read_cb)
 220                 bt_gatt_callbacks->server->request_read_cb(ev->conn_id, ev->trans_id, &bd_addr,
 221                                         ev->att_handle, ev->offset, ev->is_long);
 222 }
 223
 224 static void __bt_hal_handle_gatt_server_write_requested(void *buf, uint16_t len)
 225 {
 226         struct hal_ev_gatt_server_write_req *ev = buf;
 227
 228         if (bt_gatt_callbacks->server->request_write_cb)
 229                 bt_gatt_callbacks->server->request_write_cb(ev->conn_id, ev->trans_id,
 230                                 (bt_bdaddr_t *) ev->bdaddr,
 231                                 ev->att_handle, ev->offset,
 232                                 ev->length, ev->need_rsp,
 233                                 ev->is_prep, ev->value);
 234 }
 235
 236 static void __bt_hal_handle_gatt_server_indicate_confirmed(void *buf, uint16_t len)
 237 {
 238         struct hal_ev_gatt_server_indicate_cfm *ev = buf;
 239
 240
 241         if (bt_gatt_callbacks->server->indication_confirmation_cb)
 242                 bt_gatt_callbacks->server->indication_confirmation_cb(ev->conn_id, ev->trans_id,
 243                                 ev->att_handle, (bt_bdaddr_t *) ev->bdaddr);
 244
 245 }
 246
 247 static void __bt_hal_gatt_events(int message, void *buf, uint16_t len)
 248 {
 249         DBG("+");
 250         /* Check if GATT interface is Ready */
 251         if (!interface_ready())
 252                 return;
 253
 254         switch (message) {
 255         case HAL_EV_SERVER_INSTANCE_INITIALIZED: {
 256                 __bt_hal_handle_server_instance_initialized(buf, len);
 257                 break;
 258         }
 259         case HAL_EV_MULTI_ADV_ENABLE: {
 260                 __bt_hal_handle_multi_adv_enable(buf, len);
 261                 break;
 262         }
 263         case HAL_EV_MULTI_ADV_DISABLE: {
 264                 __bt_hal_handle_multi_adv_disable(buf, len);
 265                 break;
 266         }
 267         case HAL_EV_MULTI_ADV_DATA_SET: {
 268                 __bt_hal_handle_multi_adv_data_set(buf, len);
 269                 break;
 270         }
 271         case HAL_EV_MULTI_ADV_UPDATE: {
 272                 __bt_hal_handle_multi_adv_data_update(buf, len);
 273                 break;
 274         }
 275         case HAL_EV_LEGACY_ADV_ENABLE: {
 276                 __bt_hal_handle_legacy_adv_status(buf, len);
 277                 break;
 278         }
 279         case HAL_EV_GATT_CLIENT_REGISTERED: {
 280                 __bt_handle_gatt_client_registered(buf, len);
 281                 break;
 282         }
 283         case HAL_EV_GATT_CLIENT_SCAN_RESULT: {
 284                 __bt_hal_handle_gatt_client_scan_result(buf, len);
 285                 break;
 286         }
 287         case HAL_EV_GATT_SERVICE_ADDED: {
 288                 __bt_hal_handle_service_added(buf, len);
 289                 break;
 290         }
 291         case HAL_EV_GATT_CHAR_ADDED: {
 292                 __bt_hal_handle_char_added(buf, len);
 293                 break;
 294         }
 295         case HAL_EV_GATT_DESC_ADDED: {
 296                 __bt_hal_handle_desc_added(buf, len);
 297                 break;
 298         }
 299         case HAL_EV_GATT_SERVICE_STARTED: {
 300                 __bt_hal_handle_service_started(buf, len);
 301                 break;
 302         }
 303         case HAL_EV_GATT_SERVICE_DELETED: {
 304                 __bt_hal_handle_service_deleted(buf, len);
 305                 break;
 306         }
 307         case HAL_EV_GATT_SERVER_CONNECTED: {
 308                 __bt_hal_handle_gatt_server_connected(buf, len);
 309                 break;
 310         }
 311         case HAL_EV_GATT_READ_REQUESTED: {
 312                 __bt_hal_handle_gatt_server_read_requested(buf, len);
 313                 break;
 314         }
 315         case HAL_EV_GATT_WRITE_REQUESTED: {
 316                 __bt_hal_handle_gatt_server_write_requested(buf, len);
 317                 break;
 318         }
 319         case HAL_EV_GATT_INDICATE_CFM: {
 320                 __bt_hal_handle_gatt_server_indicate_confirmed(buf, len);
 321                 break;
 322         }
 323         case HAL_EV_GATT_CLIENT_CONNECTED: {
 324                 __bt_handle_gatt_client_connected(buf, len);
 325                 break;
 326         }
 327         case HAL_EV_GATT_CLIENT_DISCONNECTED: {
 328                 __bt_handle_gatt_client_disconnected(buf, len);
 329                 break;
 330         }
 331         case HAL_EV_GATT_CLIENT_SEARCH_RESULT: {
 332                 __bt_handle_gatt_client_search_result(buf, len);
 333                 break;
 334         }
 335         case HAL_EV_GATT_CLIENT_SEARCH_COMPLETE: {
 336                 __bt_handle_gatt_client_search_complete(buf, len);
 337                 break;
 338         }
 339         case HAL_EV_GATT_CLIENT_CHARAC_SEARCH_RESULT: {
 340                 __bt_handle_gatt_client_search_char_result(buf, len);
 341                 break;
 342         }
 343         case HAL_EV_GATT_CLIENT_DESC_SEARCH_RESULT: {
 344                 __bt_handle_gatt_client_search_desc_result(buf, len);
 345                 break;
 346         }
 347         case HAL_EV_GATT_CLIENT_READ_CHARAC: {
 348                 __bt_handle_gatt_client_read_charac(buf, len);
 349                 break;
 350         }
 351         case HAL_EV_GATT_CLIENT_READ_DESC: {
 352                 __bt_handle_gatt_client_read_desc(buf, len);
 353                 break;
 354         }
 355         case HAL_EV_GATT_CLIENT_WRITE_CHARAC: {
 356                 __bt_handle_gatt_client_write_char(buf, len);
 357                 break;
 358         }
 359         case HAL_EV_GATT_CLIENT_WRITE_DESC: {
 360                 __bt_handle_gatt_client_write_desc(buf, len);
 361                 break;
 362         }
 363         case HAL_EV_GATT_CLIENT_WATCH_NOTIFICATION: {
 364                 __bt_handle_gatt_client_watch_notification(buf, len);
 365                 break;
 366         }
 367         default:
 368                 DBG("Event Currently not handled!!");
 369                 break;
 370         }
 371         DBG("-");
 372 }
 373
 374 /************************************* GATT CLIENT EVENTS ****************************************/
 375 static void __bt_handle_gatt_client_registered(void *buf, uint16_t len)
 376 {
 377         struct hal_ev_gatt_client_registered *ev = buf;
 378         bt_uuid_t uuid;
 379
 380         memcpy(uuid.uu, ev->app_uuid, 16);
 381         if (bt_gatt_callbacks->client->register_client_cb)
 382                 bt_gatt_callbacks->client->register_client_cb(
 383                                 ev->status, ev->client_if, &uuid);
 384 }
 385
 386 static void __bt_hal_send_le_scan_result_event(bt_hal_le_adv_info_t *adv_info)
 387 {
 388         bt_bdaddr_t bd_addr;
 389
 390         str2bt_bdaddr_t(adv_info->addr, &bd_addr);
 391         if (bt_gatt_callbacks->client->scan_result_cb)
 392                 bt_gatt_callbacks->client->scan_result_cb(
 393                                 &bd_addr, adv_info->rssi, adv_info->data);
 394 }
 395
 396 static void __bt_handle_gatt_client_connected(void *buf, uint16_t len)
 397 {
 398         struct hal_ev_gatt_client_connected  *ev = buf;
 399         bt_bdaddr_t bd_addr;
 400
 401         memcpy(bd_addr.address, ev->bdaddr, 6);
 402         if (bt_gatt_callbacks->client->open_cb)
 403                 bt_gatt_callbacks->client->open_cb(ev->conn_id,
 404                                 ev->status, ev->client_if, &bd_addr);
 405 }
 406
 407 static void __bt_handle_gatt_client_disconnected(void *buf, uint16_t len)
 408 {
 409         struct hal_ev_gatt_client_connected  *ev = buf;
 410         bt_bdaddr_t bd_addr;
 411
 412         memcpy(bd_addr.address, ev->bdaddr, 6);
 413         if (bt_gatt_callbacks->client->close_cb)
 414                 bt_gatt_callbacks->client->close_cb(ev->conn_id,
 415                                 ev->status, ev->client_if, &bd_addr);
 416 }
 417
 418 static void __bt_handle_gatt_client_search_result(void *buf, uint16_t len)
 419 {
 420         struct hal_ev_gatt_client_search_result  *ev = buf;
 421         btgatt_srvc_id_t gatt_srvc_id;
 422
 423         gatt_srvc_id.is_primary = ev->is_primary;
 424         gatt_srvc_id.id.inst_id = ev->inst_id;
 425         memcpy(gatt_srvc_id.id.uuid.uu, ev->uuid, 16);
 426
 427         if (bt_gatt_callbacks->client->search_result_cb)
 428                 bt_gatt_callbacks->client->search_result_cb(ev->conn_id,
 429                                                         &gatt_srvc_id);
 430 }
 431
 432 static void __bt_handle_gatt_client_search_complete(void *buf, uint16_t len)
 433 {
 434         struct hal_ev_gatt_client_search_complete  *ev = buf;
 435
 436         if (bt_gatt_callbacks->client->search_complete_cb)
 437                 bt_gatt_callbacks->client->search_complete_cb(ev->conn_id,
 438                                                                 ev->status);
 439 }
 440
 441 static void __bt_handle_gatt_client_search_char_result(void *buf, uint16_t len)
 442 {
 443         struct hal_ev_gatt_client_char_search_result *ev = buf;
 444         btgatt_srvc_id_t gatt_srvc_id;
 445         btgatt_gatt_id_t gatt_char_id;
 446
 447         gatt_srvc_id.is_primary = ev->is_primary;
 448         gatt_srvc_id.id.inst_id = ev->inst_id;
 449         memcpy(gatt_srvc_id.id.uuid.uu, ev->svc_uuid, 16);
 450
 451         if (BT_STATUS_SUCCESS == ev->status) {
 452                 memcpy(gatt_char_id.uuid.uu, ev->char_uuid, 16);
 453                 gatt_char_id.inst_id = ev->inst_id;
 454         }
 455
 456         if (bt_gatt_callbacks->client->get_characteristic_cb)
 457                 bt_gatt_callbacks->client->get_characteristic_cb(ev->conn_id,
 458                         ev->status, &gatt_srvc_id, &gatt_char_id, ev->char_prop);
 459 }
 460
 461 static void __bt_handle_gatt_client_search_desc_result(void *buf, uint16_t len)
 462 {
 463         struct hal_ev_gatt_client_desc_search_result *ev = buf;
 464         btgatt_srvc_id_t gatt_srvc_id;
 465         btgatt_gatt_id_t gatt_char_id;
 466         btgatt_gatt_id_t gatt_desc_id;
 467
 468
 469         gatt_srvc_id.is_primary = ev->is_primary;
 470         gatt_srvc_id.id.inst_id = ev->inst_id;
 471         memcpy(gatt_srvc_id.id.uuid.uu, ev->svc_uuid, 16);
 472
 473         memcpy(gatt_char_id.uuid.uu, ev->char_uuid, 16);
 474         gatt_char_id.inst_id = ev->inst_id;
 475
 476         if (BT_STATUS_SUCCESS == ev->status) {
 477                 memcpy(gatt_desc_id.uuid.uu, ev->desc_uuid, 16);
 478                 gatt_desc_id.inst_id = ev->inst_id;
 479         }
 480
 481         if (bt_gatt_callbacks->client->get_descriptor_cb)
 482                 bt_gatt_callbacks->client->get_descriptor_cb(ev->conn_id,
 483                         ev->status, &gatt_srvc_id, &gatt_char_id, &gatt_desc_id);
 484 }
 485
 486 static void __bt_handle_gatt_client_read_charac(void *buf, uint16_t len)
 487 {
 488         struct hal_ev_gatt_client_read_data *ev = buf;
 489         btgatt_read_params_t char_read_parm;
 490
 491         char_read_parm.srvc_id.is_primary = ev->is_primary;
 492         char_read_parm.srvc_id.id.inst_id = ev->inst_id;
 493         memcpy(char_read_parm.srvc_id.id.uuid.uu, ev->svc_uuid, 16);
 494
 495         char_read_parm.char_id.inst_id = ev->inst_id;
 496         memcpy(char_read_parm.char_id.uuid.uu, ev->char_uuid, 16);
 497
 498         char_read_parm.value.len = ev->len;
 499         if (ev->len > 0) {
 500                 memcpy(char_read_parm.value.value, ev->value, ev->len);
 501                 char_read_parm.value_type = BT_HAL_GATTC_READ_VALUE_TYPE_VALUE;
 502         }
 503
 504         if (bt_gatt_callbacks->client->read_characteristic_cb)
 505                 bt_gatt_callbacks->client->read_characteristic_cb(ev->conn_id,
 506                                         ev->status, &char_read_parm);
 507 }
 508
 509 static void __bt_handle_gatt_client_read_desc(void *buf, uint16_t len)
 510 {
 511         struct hal_ev_gatt_client_read_data *ev = buf;
 512         btgatt_read_params_t desc_read_parm;
 513
 514         desc_read_parm.srvc_id.is_primary = ev->is_primary;
 515         desc_read_parm.srvc_id.id.inst_id = ev->inst_id;
 516         memcpy(desc_read_parm.srvc_id.id.uuid.uu, ev->svc_uuid, 16);
 517
 518         desc_read_parm.char_id.inst_id = ev->inst_id;
 519         memcpy(desc_read_parm.char_id.uuid.uu, ev->char_uuid, 16);
 520
 521         desc_read_parm.descr_id.inst_id = ev->inst_id;
 522         memcpy(desc_read_parm.descr_id.uuid.uu, ev->desc_uuid, 16);
 523
 524         desc_read_parm.value.len = ev->len;
 525         if (ev->len > 0) {
 526                 memcpy(desc_read_parm.value.value, ev->value, ev->len);
 527                 desc_read_parm.value_type = BT_HAL_GATTC_READ_VALUE_TYPE_VALUE;
 528         }
 529
 530         if (bt_gatt_callbacks->client->read_descriptor_cb)
 531                 bt_gatt_callbacks->client->read_descriptor_cb(ev->conn_id,
 532                                         ev->status, &desc_read_parm);
 533 }
 534
 535 static void __bt_handle_gatt_client_write_char(void *buf, uint16_t len)
 536 {
 537         struct hal_ev_gatt_client_write_result *ev = buf;
 538         btgatt_write_params_t char_write_parm;
 539
 540         char_write_parm.srvc_id.is_primary = ev->is_primary;
 541         char_write_parm.srvc_id.id.inst_id = ev->inst_id;
 542         memcpy(char_write_parm.srvc_id.id.uuid.uu, ev->svc_uuid, 16);
 543
 544         char_write_parm.char_id.inst_id = ev->inst_id;
 545         memcpy(char_write_parm.char_id.uuid.uu, ev->char_uuid, 16);
 546
 547         if (bt_gatt_callbacks->client->write_characteristic_cb)
 548                 bt_gatt_callbacks->client->write_characteristic_cb(ev->conn_id,
 549                                         ev->status, &char_write_parm);
 550 }
 551
 552 static void __bt_handle_gatt_client_write_desc(void *buf, uint16_t len)
 553 {
 554         struct hal_ev_gatt_client_write_result *ev = buf;
 555         btgatt_write_params_t desc_write_parm;
 556
 557         desc_write_parm.srvc_id.is_primary = ev->is_primary;
 558         desc_write_parm.srvc_id.id.inst_id = ev->inst_id;
 559         memcpy(desc_write_parm.srvc_id.id.uuid.uu, ev->svc_uuid, 16);
 560
 561         desc_write_parm.char_id.inst_id = ev->inst_id;
 562         memcpy(desc_write_parm.char_id.uuid.uu, ev->char_uuid, 16);
 563
 564         desc_write_parm.descr_id.inst_id = ev->inst_id;
 565         memcpy(desc_write_parm.descr_id.uuid.uu, ev->desc_uuid, 16);
 566
 567         if (bt_gatt_callbacks->client->write_descriptor_cb)
 568                 bt_gatt_callbacks->client->write_descriptor_cb(ev->conn_id,
 569                                         ev->status, &desc_write_parm);
 570 }
 571
 572 static void __bt_handle_gatt_client_watch_notification(void *buf, uint16_t len)
 573 {
 574         struct hal_ev_gatt_client_watch_notification *ev = buf;
 575         btgatt_srvc_id_t gatt_srvc_id;
 576         btgatt_gatt_id_t gatt_char_id;
 577
 578         gatt_srvc_id.is_primary = ev->is_primary;
 579         gatt_srvc_id.id.inst_id = ev->inst_id;
 580         memcpy(gatt_srvc_id.id.uuid.uu, ev->svc_uuid, 16);
 581
 582         memcpy(gatt_char_id.uuid.uu, ev->char_uuid, 16);
 583         gatt_char_id.inst_id = ev->inst_id;
 584
 585         if (bt_gatt_callbacks->client->register_for_notification_cb)
 586                 bt_gatt_callbacks->client->register_for_notification_cb(ev->client_if,
 587                                 ev->registered, ev->status, &gatt_srvc_id, &gatt_char_id);
 588 }
 589
 590 static bt_hal_le_adv_info_t *__bt_hal_get_adv_ind_info(char *addr)
 591 {
 592         GSList *l;
 593
 594         if (!addr)
 595                 return NULL;
 596
 597         for (l = adv_ind_list; NULL != l; l = g_slist_next(l)) {
 598                 bt_hal_le_adv_info_t *adv_info = l->data;
 599
 600                 if (!adv_info)
 601                         continue;
 602
 603                 if (!g_strcmp0(adv_info->addr, addr))
 604                         return adv_info;
 605         }
 606
 607         return NULL;
 608 }
 609
 610 static int __bt_hal_add_adv_ind_info(bt_hal_le_adv_info_t *adv_info)
 611 {
 612         if (!adv_info)
 613                 return -1;
 614
 615         if (__bt_hal_get_adv_ind_info(adv_info->addr) != NULL) {
 616                 DBG("Adv info already present");
 617                 return -1;
 618         }
 619
 620         adv_ind_list = g_slist_append(adv_ind_list, adv_info);
 621         return 0;
 622 }
 623
 624 static gboolean __bt_hal_adv_scan_req_timeout_cb(gpointer user_data)
 625 {
 626         bt_hal_le_adv_info_t *adv_info = user_data;
 627
 628         __bt_hal_send_le_scan_result_event(adv_info);
 629         adv_ind_list = g_slist_remove(adv_ind_list, adv_info);
 630         g_free(adv_info);
 631         return FALSE;
 632 }
 633
 634 static void __bt_hal_handle_gatt_client_scan_result(void *buf, uint16_t len)
 635 {
 636         bt_bdaddr_t bd_addr;
 637         char address[18];
 638         struct hal_ev_gatt_client_scan_result *ev = buf;
 639         bt_hal_le_adv_info_t *adv_info;
 640         int data_len = 0;
 641
 642         memcpy(bd_addr.address, ev->bd_addr, 6);
 643         bt_bdaddr_t2str(&bd_addr, address);
 644         data_len = (ev->len < BT_HAL_ADV_DATA_MAX_SIZE) ? ev->len : BT_HAL_ADV_DATA_MAX_SIZE;
 645         if (data_len == 0 && ev->adv_type != BT_LE_ADV_SCAN_RSP) {
 646                 ERR("Unexpected: Data len is 0");
 647                 return;
 648         }
 649
 650         if (ev->adv_type == BT_LE_ADV_SCAN_RSP) { /* SCAN_RSP */
 651                 adv_info = __bt_hal_get_adv_ind_info(address);
 652                 if (adv_info) {
 653                         /* Copy scan response data in data field and send event */
 654                         memcpy(&(adv_info->data[adv_info->data_len]), ev->adv_data, data_len);
 655                         __bt_hal_send_le_scan_result_event(adv_info);
 656                         adv_ind_list = g_slist_remove(adv_ind_list, adv_info);
 657                         if (adv_info->timer_id)
 658                                 g_source_remove(adv_info->timer_id);
 659                         g_free(adv_info);
 660                 }
 661                 return;
 662         }
 663
 664         /* ADV_IND */
 665         adv_info = g_malloc0(sizeof(bt_hal_le_adv_info_t));
 666         if (!adv_info) {
 667                 ERR("Not enough memory");
 668                 return;
 669         }
 670
 671         g_strlcpy(adv_info->addr, address, 18);
 672         adv_info->addr_type = ev->addr_type;
 673         adv_info->adv_type = ev->adv_type;
 674         adv_info->rssi = ev->rssi;
 675         adv_info->data_len = data_len;
 676         memcpy(adv_info->data, ev->adv_data, data_len);
 677
 678 #ifdef TIZEN_BT_HAL
 679         if (_bt_hal_gatt_client_get_le_scan_type() == BT_GATTC_LE_SCAN_TYPE_PASSIVE) {
 680                 __bt_hal_send_le_scan_result_event(adv_info);
 681                 g_free(adv_info);
 682                 return;
 683         }
 684 #endif
 685         if (__bt_hal_add_adv_ind_info(adv_info))
 686                 adv_info->timer_id = g_timeout_add(1000,
 687                                 __bt_hal_adv_scan_req_timeout_cb,
 688                                 (void *)adv_info);
 689 }
 690
 691 /*******************************************************************************
 692  **
 693  ** Function            gatt_init
 694  **
 695  ** Description         Initializes the GATT interface
 696  **
 697  ** Returns             bt_status_t
 698  **
 699  *******************************************************************************/
 700 static bt_status_t gatt_init(const btgatt_callbacks_t* callbacks)
 701 {
 702         bt_gatt_callbacks = callbacks;
 703         DBG("Register A2DP Src events callback function");
 704         _bt_hal_register_gatt_le_dbus_handler_cb(__bt_hal_gatt_events);
 705         _bt_hal_register_gatt_server_handler_cb(__bt_hal_gatt_events);
 706         _bt_hal_register_gatt_client_handler_cb(__bt_hal_gatt_events);
 707         _bt_hal_register_event_handler_cb(HAL_GATT, __bt_hal_gatt_events);
 708
 709         return BT_STATUS_SUCCESS;
 710 }
 711
 712 /*******************************************************************************
 713  **
 714  ** Function    gatt_cleanup
 715  **
 716  ** Description Closes the GATT interface
 717  **
 718  ** Returns     void
 719  **
 720  *******************************************************************************/
 721 static void gatt_cleanup(void)
 722 {
 723         _bt_hal_unregister_gatt_le_dbus_handler_cb();
 724         _bt_hal_unregister_gatt_client_handler_cb();
 725         _bt_hal_unregister_gatt_server_handler_cb();
 726         _bt_hal_unregister_event_handler_cb(HAL_GATT);
 727
 728         if (bt_gatt_callbacks)
 729                 bt_gatt_callbacks = NULL;
 730 }
 731
 732 static const btgatt_interface_t btgatt_interface = {
 733         sizeof(btgatt_interface),
 734
 735         gatt_init,
 736         gatt_cleanup,
 737
 738         &btgatt_client_interface,
 739         &btgatt_server_interface,
 740 };
 741
 742 /*******************************************************************************
 743  **
 744  ** Function            bt_get_gatt_interface
 745  **
 746  ** Description         Get the gatt callback interface
 747  **
 748  ** Returns             btgatt_interface_t
 749  **
 750  *******************************************************************************/
 751 const btgatt_interface_t *bt_get_gatt_interface()
 752 {
 753         return &btgatt_interface;
 754 }