bt-service/bt-service-event-receiver.c

   1 /*
   2  * Bluetooth-frwk
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact:  Hocheol Seo <hocheol.seo@samsung.com>
   7  *               Girishashok Joshi <girish.joshi@samsung.com>
   8  *               Chanyeol Park <chanyeol.park@samsung.com>
   9  *
  10  * Licensed under the Apache License, Version 2.0 (the "License");
  11  * you may not use this file except in compliance with the License.
  12  * You may obtain a copy of the License at
  13  *
  14  *              http://www.apache.org/licenses/LICENSE-2.0
  15  *
  16  * Unless required by applicable law or agreed to in writing, software
  17  * distributed under the License is distributed on an "AS IS" BASIS,
  18  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  19  * See the License for the specific language governing permissions and
  20  * limitations under the License.
  21  *
  22  */
  23
  24 #include <dbus/dbus-glib.h>
  25 #include <dbus/dbus-glib-lowlevel.h>
  26 #include <dbus/dbus.h>
  27 #include <glib.h>
  28 #include <string.h>
  29 #include <dlog.h>
  30 #include <vconf.h>
  31 #include <vconf-internal-bt-keys.h>
  32 //#include <journal/device.h>
  33
  34 #include "bluetooth-api.h"
  35 #include "bt-internal-types.h"
  36
  37 #include "bt-service-common.h"
  38 #include "bt-service-event.h"
  39 #include "bt-service-main.h"
  40 #include "bt-service-adapter.h"
  41 #include "bt-service-adapter-le.h"
  42 #include "bt-service-device.h"
  43 #include "bt-service-avrcp.h"
  44 #include "bt-service-obex-server.h"
  45 #include "bt-service-rfcomm-server.h"
  46 #include "bt-service-audio.h"
  47 #include "bt-service-agent.h"
  48 #include "bt-service-pbap.h"
  49 #include "bt-service-headset-connection.h"
  50 #include "bt-service-opp-client.h"
  51
  52 static DBusGConnection *manager_conn;
  53 static DBusGConnection *obexd_conn;
  54 static GList *p_cache_list = NULL;
  55 static DBusGConnection *opc_obexd_conn = NULL;
  56
  57
  58 static guint event_id;
  59 guint nap_connected_device_count = 0;
  60 static guint hid_connected_device_count = 0;
  61 static GList *p_adv_ind_list;
  62
  63 typedef struct {
  64         char *addr;
  65         int data_len;
  66         char *data;
  67 } bt_le_adv_info_t;
  68
  69 typedef struct {
  70         bt_remote_dev_info_t *dev_info;
  71 } bt_cache_info_t;
  72
  73 /**
  74  * obexd connection type
  75  */
  76 typedef enum {
  77         OBEX_OPP = (1 << 1),
  78         OBEX_FTP = (1 << 2),
  79         OBEX_BIP = (1 << 3),
  80         OBEX_PBAP = (1 << 4),
  81         OBEX_IRMC = (1 << 5),
  82         OBEX_PCSUITE = (1 << 6),
  83         OBEX_SYNCEVOLUTION =    (1 << 7),
  84         OBEX_MAS = (1 << 8),
  85 } bluetooth_obex_connection_type_t;
  86
  87 void _bt_handle_property_changed_event(DBusMessage *msg);
  88 void _bt_opc_property_changed_event(DBusMessage *msg);
  89 int _bt_register_service_event(DBusGConnection *g_conn, int event_type);
  90 void _bt_unregister_service_event(DBusGConnection *g_conn, int event_type);
  91 void _bt_opp_client_event_deinit(void);
  92
  93 static void __bt_free_bt_le_adv_info_t(bt_le_adv_info_t *adv_info)
  94 {
  95         g_free(adv_info->addr);
  96         g_free(adv_info->data);
  97         g_free(adv_info);
  98 }
  99
 100 static bt_le_adv_info_t *__bt_get_adv_ind_info(char *addr)
 101 {
 102         retv_if(!addr, NULL);
 103         bt_le_adv_info_t *adv_info = NULL;
 104         GList *current = g_list_first((GList *)p_adv_ind_list);
 105         while(current && current->data) {
 106                 adv_info = (bt_le_adv_info_t *)current->data;
 107                 retv_if(adv_info && !g_strcmp0(adv_info->addr, addr), adv_info);
 108                 current = g_list_next(current);
 109         }
 110         return NULL;
 111 }
 112
 113 static void __bt_add_adv_ind_info(bt_le_adv_info_t *adv_info)
 114 {
 115         ret_if(!adv_info);
 116         if (__bt_get_adv_ind_info(adv_info->addr) != NULL) {
 117                 BT_ERR("adv_info is already added");
 118                 __bt_free_bt_le_adv_info_t(adv_info);
 119                 return;
 120         }
 121         p_adv_ind_list = g_list_append(p_adv_ind_list, adv_info);
 122 }
 123
 124 static void __bt_del_adv_ind_info(char *addr)
 125 {
 126         ret_if(!addr);
 127         ret_if(!p_adv_ind_list);
 128         bt_le_adv_info_t *adv_info = NULL;
 129         GList *current = g_list_first((GList *)p_adv_ind_list);
 130         while(current && current->data) {
 131                 adv_info = (bt_le_adv_info_t *)current->data;
 132                 if (adv_info && !g_strcmp0(adv_info->addr, addr)) {
 133                         p_adv_ind_list = g_list_remove(p_adv_ind_list, adv_info);
 134                         __bt_free_bt_le_adv_info_t(adv_info);
 135                         return;
 136                 }
 137                 current = g_list_next(current);
 138         }
 139 }
 140
 141 static void __bt_free_cache_info(bt_cache_info_t *cache_info)
 142 {
 143         ret_if(cache_info == NULL);
 144
 145         _bt_free_device_info(cache_info->dev_info);
 146         g_free(cache_info);
 147 }
 148
 149 static gboolean __bt_parse_device_properties(DBusMessageIter *item_iter,
 150                                                 bt_remote_dev_info_t *dev_info)
 151 {
 152         BT_DBG("+");
 153         DBusMessageIter value_iter;
 154         char *value;
 155
 156         dbus_message_iter_recurse(item_iter, &value_iter);
 157
 158         if (dbus_message_iter_get_arg_type(&value_iter) != DBUS_TYPE_DICT_ENTRY) {
 159                 BT_DBG("No entry");
 160                 return FALSE;
 161         }
 162
 163         while (dbus_message_iter_get_arg_type(&value_iter) ==
 164                                                 DBUS_TYPE_DICT_ENTRY) {
 165                 char *key;
 166                 DBusMessageIter dict_entry;
 167                 DBusMessageIter iter_dict_val;
 168
 169                 dbus_message_iter_recurse(&value_iter, &dict_entry);
 170
 171                 dbus_message_iter_get_basic(&dict_entry, &key);
 172
 173                 if (key == NULL) {
 174                         dbus_message_iter_next(&value_iter);
 175                         continue;
 176                 }
 177
 178                 if (!dbus_message_iter_next(&dict_entry)) {
 179                         dbus_message_iter_next(&value_iter);
 180                         continue;
 181                 }
 182                 dbus_message_iter_recurse(&dict_entry, &iter_dict_val);
 183
 184                 if (dev_info) {
 185                         if (strcasecmp(key, "Address") == 0) {
 186                                 const char *address = NULL;
 187                                 dbus_message_iter_get_basic(&iter_dict_val, &address);
 188                                 dev_info->address = g_strdup(address);
 189                         } else if (strcasecmp(key, "Class") == 0) {
 190                                 dbus_message_iter_get_basic(&iter_dict_val, &dev_info->class);
 191                         } else if (strcasecmp(key, "name") == 0) {
 192                                 dbus_message_iter_get_basic(&iter_dict_val, &value);
 193                                 if (dev_info->name == NULL)
 194                                         dev_info->name = g_strdup(value);
 195                         } else if (strcasecmp(key, "Connected") == 0) {
 196                                 dbus_message_iter_get_basic(&iter_dict_val,
 197                                                 &dev_info->connected);
 198                         } else if (strcasecmp(key, "paired") == 0) {
 199                                 dbus_message_iter_get_basic(&iter_dict_val,
 200                                                 &dev_info->paired);
 201                         } else if (strcasecmp(key, "Trusted") == 0) {
 202                                 dbus_message_iter_get_basic(&iter_dict_val,
 203                                                 &dev_info->trust);
 204                         } else if (strcasecmp(key, "RSSI") == 0) {
 205                                 dbus_message_iter_get_basic(&iter_dict_val,
 206                                                 &dev_info->rssi);
 207                         } else if (strcasecmp(key, "LastAddrType") == 0) {
 208                                 dbus_message_iter_get_basic(&iter_dict_val,
 209                                                 &dev_info->addr_type);
 210                         } else if (strcasecmp(key, "UUIDs") == 0) {
 211                                 DBusMessageIter uuid_iter;
 212                                 DBusMessageIter tmp_iter;
 213                                 int i = 0;
 214
 215                                 dbus_message_iter_recurse(&iter_dict_val, &uuid_iter);
 216
 217                                 tmp_iter = uuid_iter;
 218
 219                                 /* Store the uuid count */
 220                                 while (dbus_message_iter_get_arg_type(&tmp_iter) != DBUS_TYPE_INVALID) {
 221                                         dbus_message_iter_get_basic(&tmp_iter,
 222                                                         &value);
 223
 224                                         dev_info->uuid_count++;
 225                                         if (!dbus_message_iter_next(&tmp_iter))
 226                                                 break;
 227                                 }
 228
 229                                 /* Store the uuids */
 230                                 if (dev_info->uuid_count > 0) {
 231                                         dev_info->uuids = g_new0(char *,
 232                                                         dev_info->uuid_count + 1);
 233                                 } else {
 234                                         dbus_message_iter_next(&value_iter);
 235                                         continue;
 236                                 }
 237
 238                                 while (dbus_message_iter_get_arg_type(&uuid_iter) != DBUS_TYPE_INVALID) {
 239                                         dbus_message_iter_get_basic(&uuid_iter,
 240                                                         &value);
 241                                         dev_info->uuids[i] = g_strdup(value);
 242                                         i++;
 243                                         if (!dbus_message_iter_next(&uuid_iter)) {
 244                                                 break;
 245                                         }
 246                                 }
 247                         } else if (strcasecmp(key, "ManufacturerDataLen") == 0) {
 248                                 dbus_message_iter_get_basic(&iter_dict_val,
 249                                                                         &dev_info->manufacturer_data_len);
 250
 251                                 if (dev_info->manufacturer_data_len > BLUETOOTH_MANUFACTURER_DATA_LENGTH_MAX) {
 252                                         BT_ERR("manufacturer_data_len is too long(len = %d)", dev_info->manufacturer_data_len);
 253                                         dev_info->manufacturer_data_len = BLUETOOTH_MANUFACTURER_DATA_LENGTH_MAX;
 254                                 }
 255
 256                                 if (dev_info->manufacturer_data_len == 0)
 257                                         dev_info->manufacturer_data = g_strdup("");
 258                         } else if (strcasecmp(key, "ManufacturerData") == 0) {
 259                                 DBusMessageIter manufacturer_iter;
 260                                 int i = 0;
 261                                 int len = 0;
 262                                 char *manufacturer_data = NULL;
 263                                 char byte = 0;
 264
 265                                 dbus_message_iter_recurse(&iter_dict_val, &manufacturer_iter);
 266                                 len = dbus_message_iter_get_array_len(&manufacturer_iter);
 267
 268                                 dev_info->manufacturer_data = g_malloc0(len);
 269                                 manufacturer_data = dev_info->manufacturer_data;
 270
 271                                 while (dbus_message_iter_get_arg_type(&manufacturer_iter) == DBUS_TYPE_BYTE) {
 272                                         dbus_message_iter_get_basic(&manufacturer_iter, &byte);
 273                                         manufacturer_data[i] = byte;
 274                                         i++;
 275                                         dbus_message_iter_next(&manufacturer_iter);
 276                                 }
 277                         }
 278                 }
 279
 280                 dbus_message_iter_next(&value_iter);
 281         }
 282
 283         BT_DBG("-");
 284         return TRUE;
 285 }
 286
 287 static gboolean __bt_parse_interface(DBusMessage *msg,
 288                                         bt_remote_dev_info_t *dev_info)
 289 {
 290         BT_DBG("+");
 291
 292         DBusMessageIter msg_iter;
 293         DBusMessageIter value_iter;
 294         char *object_path = NULL;
 295
 296         retv_if(dbus_message_iter_init(msg, &msg_iter) == FALSE, FALSE);
 297
 298         dbus_message_iter_get_basic(&msg_iter, &object_path);
 299         retv_if(object_path == NULL, FALSE);
 300
 301         /* object array (oa) */
 302         retv_if(dbus_message_iter_next(&msg_iter) == FALSE, FALSE);
 303         retv_if(dbus_message_iter_get_arg_type(&msg_iter) !=
 304                                 DBUS_TYPE_ARRAY, FALSE);
 305
 306         dbus_message_iter_recurse(&msg_iter, &value_iter);
 307
 308         /* string array (sa) */
 309         while (dbus_message_iter_get_arg_type(&value_iter) ==
 310                                         DBUS_TYPE_DICT_ENTRY) {
 311                 char *interface_name = NULL;
 312                 DBusMessageIter interface_iter;
 313
 314                 dbus_message_iter_recurse(&value_iter, &interface_iter);
 315
 316                 retv_if(dbus_message_iter_get_arg_type(&interface_iter) !=
 317                         DBUS_TYPE_STRING, FALSE);
 318
 319                 dbus_message_iter_get_basic(&interface_iter, &interface_name);
 320
 321                 retv_if(dbus_message_iter_next(&interface_iter) == FALSE, FALSE);
 322
 323                 retv_if(dbus_message_iter_get_arg_type(&interface_iter) !=
 324                         DBUS_TYPE_ARRAY, FALSE);
 325
 326                 BT_DBG("interface: %s", interface_name);
 327
 328                 if (g_strcmp0(interface_name, "org.bluez.Device1") == 0) {
 329                         BT_DBG("Found a device: %s", object_path);
 330
 331                         if (__bt_parse_device_properties(&interface_iter,
 332                                         dev_info) == FALSE) {
 333                                 BT_ERR("Fail to parse the properies");
 334                                 return FALSE;
 335                         } else {
 336                                 return TRUE;
 337                         }
 338                 }
 339
 340                 dbus_message_iter_next(&value_iter);
 341         }
 342
 343         BT_DBG("-");
 344
 345         return FALSE;
 346 }
 347
 348 char *__bt_get_headset_name(char *address)
 349 {
 350         bluetooth_device_address_t device_address = { {0} };
 351         bluetooth_device_info_t dev_info;
 352
 353         retv_if(address == NULL, strdup(""));
 354
 355         _bt_convert_addr_string_to_type(device_address.addr, address);
 356
 357         memset(&dev_info, 0x00, sizeof(bluetooth_device_info_t));
 358
 359         _bt_get_bonded_device_info(&device_address, &dev_info);
 360
 361         return g_strdup(dev_info.device_name.name);
 362 }
 363
 364 static int __bt_get_owner_info(DBusMessage *msg, char **name,
 365                                 char **previous, char **current)
 366 {
 367         DBusMessageIter item_iter;
 368
 369         dbus_message_iter_init(msg, &item_iter);
 370
 371         if (dbus_message_iter_get_arg_type(&item_iter)
 372                                         != DBUS_TYPE_STRING) {
 373                 BT_ERR("This is bad format dbus");
 374                 return BLUETOOTH_ERROR_INTERNAL;
 375         }
 376
 377         dbus_message_iter_get_basic(&item_iter, name);
 378
 379         retv_if(*name == NULL, BLUETOOTH_ERROR_INTERNAL);
 380
 381         dbus_message_iter_next(&item_iter);
 382
 383         if (dbus_message_iter_get_arg_type(&item_iter)
 384                                         != DBUS_TYPE_STRING) {
 385                 BT_ERR("This is bad format dbus");
 386                 return BLUETOOTH_ERROR_INTERNAL;
 387         }
 388
 389         dbus_message_iter_get_basic(&item_iter, previous);
 390
 391         retv_if(*previous == NULL, BLUETOOTH_ERROR_INTERNAL);
 392
 393         dbus_message_iter_next(&item_iter);
 394
 395         if (dbus_message_iter_get_arg_type(&item_iter)
 396                                         != DBUS_TYPE_STRING) {
 397                 BT_ERR("This is bad format dbus");
 398                 return BLUETOOTH_ERROR_INTERNAL;
 399         }
 400
 401         dbus_message_iter_get_basic(&item_iter, current);
 402
 403         retv_if(*current == NULL, BLUETOOTH_ERROR_INTERNAL);
 404
 405         return BLUETOOTH_ERROR_NONE;
 406 }
 407
 408 static int __bt_get_agent_signal_info(DBusMessage *msg, char **address,
 409                                 char **name, char **uuid)
 410 {
 411         BT_DBG("+");
 412
 413         DBusMessageIter item_iter;
 414
 415         dbus_message_iter_init(msg, &item_iter);
 416
 417         if (dbus_message_iter_get_arg_type(&item_iter)
 418                                         != DBUS_TYPE_STRING) {
 419                 BT_ERR("This is bad format dbus");
 420                 return BLUETOOTH_ERROR_INTERNAL;
 421         }
 422
 423         dbus_message_iter_get_basic(&item_iter, address);
 424
 425         dbus_message_iter_next(&item_iter);
 426
 427         if (dbus_message_iter_get_arg_type(&item_iter)
 428                                         != DBUS_TYPE_STRING) {
 429                 BT_ERR("This is bad format dbus");
 430                 return BLUETOOTH_ERROR_INTERNAL;
 431         }
 432
 433         dbus_message_iter_get_basic(&item_iter, name);
 434
 435         dbus_message_iter_next(&item_iter);
 436
 437         if (dbus_message_iter_get_arg_type(&item_iter)
 438                                         != DBUS_TYPE_STRING) {
 439                 BT_ERR("This is bad format dbus");
 440                 return BLUETOOTH_ERROR_INTERNAL;
 441         }
 442
 443         dbus_message_iter_get_basic(&item_iter, uuid);
 444
 445         BT_DBG("-");
 446
 447         return BLUETOOTH_ERROR_NONE;
 448 }
 449
 450 void __bt_set_device_values(gboolean connected, int state)
 451 {
 452         int bt_device_state = VCONFKEY_BT_DEVICE_NONE;
 453
 454         if (vconf_get_int(VCONFKEY_BT_DEVICE, &bt_device_state) != 0) {
 455                 BT_ERR("vconf_get_int failed");
 456         }
 457
 458         if (connected == TRUE)
 459                 bt_device_state |= state;
 460         else if (bt_device_state & state)
 461                 bt_device_state ^= state;
 462
 463         if (vconf_set_int(VCONFKEY_BT_DEVICE, bt_device_state) != 0) {
 464                 BT_ERR("vconf_set_int failed");
 465         }
 466 }
 467
 468 gboolean _bt_discovery_finished_cb(gpointer user_data)
 469 {
 470         int result = BLUETOOTH_ERROR_NONE;
 471         event_id = 0;
 472
 473         if (_bt_get_discovering_property(DISCOVERY_ROLE_BREDR) == FALSE) {
 474                 if (_bt_get_cancel_by_user() == TRUE) {
 475                         result = BLUETOOTH_ERROR_CANCEL_BY_USER;
 476                 }
 477
 478                 _bt_set_cancel_by_user(FALSE);
 479                 _bt_set_discovery_status(FALSE);
 480                 _bt_send_event(BT_ADAPTER_EVENT,
 481                         BLUETOOTH_EVENT_DISCOVERY_FINISHED,
 482                         DBUS_TYPE_INT32, &result,
 483                         DBUS_TYPE_INVALID);
 484         }
 485
 486         return FALSE;
 487 }
 488
 489 static gboolean __bt_le_discovery_finished_cb(gpointer user_data)
 490 {
 491         int result = BLUETOOTH_ERROR_NONE;
 492         event_id = 0;
 493
 494         if (_bt_get_discovering_property(DISCOVERY_ROLE_LE) == FALSE) {
 495                 if (_bt_get_cancel_by_user() == TRUE) {
 496                         result = BLUETOOTH_ERROR_CANCEL_BY_USER;
 497                 }
 498
 499                 _bt_set_cancel_by_user(FALSE);
 500                 _bt_set_le_discovery_status(FALSE);
 501                 _bt_send_event(BT_LE_ADAPTER_EVENT,
 502                         BLUETOOTH_EVENT_LE_DISCOVERY_FINISHED,
 503                         DBUS_TYPE_INT32, &result,
 504                         DBUS_TYPE_INVALID);
 505         }
 506
 507         return FALSE;
 508 }
 509
 510 void __bt_update_remote_cache_devinfo(const char *address, gboolean paired_status)
 511 {
 512         BT_DBG("+");
 513
 514         ret_if(address == NULL);
 515
 516         GList * node;
 517         bt_cache_info_t *cache_info;
 518         bt_remote_dev_info_t *dev_info;
 519
 520         node = g_list_first(p_cache_list);
 521
 522         while (node != NULL){
 523                 cache_info = (bt_cache_info_t *)node->data;
 524
 525                 if (cache_info == NULL) {
 526                         node = g_list_next(node);
 527                         continue;
 528                 }
 529
 530                 dev_info = cache_info->dev_info;
 531                 if (strcasecmp(dev_info->address,
 532                                         address) == 0) {
 533                         BT_DBG("Device Found");
 534                         if (paired_status == TRUE)
 535                                 cache_info->dev_info->paired = TRUE;
 536                         else
 537                                 cache_info->dev_info->paired = FALSE;
 538                         break;
 539                 }
 540                 node = g_list_next(node);
 541         }
 542         BT_DBG("-");
 543 }
 544
 545 static void __bt_device_remote_connected_properties(
 546                                 bt_remote_dev_info_t *remote_dev_info,
 547                                 char *address, gboolean connected)
 548 {
 549         int result = BLUETOOTH_ERROR_NONE;
 550         int i;
 551
 552         BT_DBG("+");
 553
 554         if (remote_dev_info->uuid_count > 0 ) {
 555                 for (i = 0; i<remote_dev_info->uuid_count; i++) {
 556                         char *uuid = remote_dev_info->uuids[i];
 557                         if (strcasecmp(uuid, HID_UUID) == 0){
 558                                 int event = BLUETOOTH_EVENT_NONE;
 559
 560                                 event = (connected == TRUE) ?
 561                                         BLUETOOTH_HID_CONNECTED :
 562                                         BLUETOOTH_HID_DISCONNECTED;
 563
 564                                 _bt_send_event(BT_HID_EVENT, event,
 565                                         DBUS_TYPE_INT32, &result,
 566                                         DBUS_TYPE_STRING, &address,
 567                                         DBUS_TYPE_INVALID);
 568                                 break;
 569                         }
 570                 }
 571         }
 572
 573         BT_DBG("-");
 574 }
 575
 576 void _bt_handle_adapter_event(DBusMessage *msg)
 577 {
 578         BT_DBG("+");
 579
 580         int result = BLUETOOTH_ERROR_NONE;
 581         DBusMessageIter item_iter;
 582         const char *member = dbus_message_get_member(msg);
 583
 584         ret_if(member == NULL);
 585
 586         if (strcasecmp(member, "DeviceCreated") == 0) {
 587                 const char *object_path = NULL;
 588                 char *address;
 589                 bt_remote_dev_info_t *remote_dev_info;
 590
 591                 ret_if(_bt_is_device_creating() == FALSE);
 592
 593                 /* Bonding from remote device */
 594                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
 595
 596                 dbus_message_iter_init(msg, &item_iter);
 597                 dbus_message_iter_get_basic(&item_iter, &object_path);
 598                 dbus_message_iter_next(&item_iter);
 599
 600                 _bt_convert_device_path_to_address(object_path, address);
 601
 602                 remote_dev_info = _bt_get_remote_device_info(address);
 603                 if (remote_dev_info == NULL) {
 604                         g_free(address);
 605                         return;
 606                 }
 607
 608                 _bt_free_device_info(remote_dev_info);
 609                 g_free(address);
 610         } else if (strcasecmp(member, "InterfacesRemoved") == 0) {
 611                 const char *object_path = NULL;
 612                 char *address;
 613                 bt_cache_info_t *cache_info;
 614                 bt_remote_dev_info_t *dev_info;
 615                 GList * node;
 616
 617                 /* Bonding from remote device */
 618                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
 619
 620                 dbus_message_iter_init(msg, &item_iter);
 621                 dbus_message_iter_get_basic(&item_iter, &object_path);
 622                 dbus_message_iter_next(&item_iter);
 623
 624                 _bt_convert_device_path_to_address(object_path, address);
 625
 626                 node = g_list_first(p_cache_list);
 627
 628                 while (node != NULL){
 629                         cache_info = (bt_cache_info_t *)node->data;
 630
 631                         if (cache_info == NULL) {
 632                                 node = g_list_next(node);
 633                                 continue;
 634                         }
 635
 636                         dev_info = cache_info->dev_info;
 637                         if (strcasecmp(dev_info->address,
 638                                                 address) == 0) {
 639                                 p_cache_list = g_list_remove(p_cache_list,
 640                                                 cache_info);
 641                                 __bt_free_cache_info(cache_info);
 642                                 break;
 643                         }
 644                         node = g_list_next(node);
 645                 }
 646
 647                 g_free(address);
 648         } else if (strcasecmp(member, "AdvertisingEnabled") == 0) {
 649                 BT_DBG("Advertising Enabled");
 650                 int slot_id;
 651                 const char *sender;
 652                 gboolean status = FALSE;
 653
 654                 dbus_message_iter_init(msg, &item_iter);
 655
 656                 dbus_message_iter_get_basic(&item_iter, &slot_id);
 657                 dbus_message_iter_next(&item_iter);
 658                 dbus_message_iter_get_basic(&item_iter, &status);
 659
 660                 BT_DBG("Advertising Enabled : slot_id [%d]  status [%d]", slot_id, status);
 661
 662                 /* Send event to application */
 663                 _bt_set_advertising_status(slot_id, status);
 664
 665                 sender = _bt_get_adv_slot_owner(slot_id);
 666                 if (status) {
 667                         bluetooth_advertising_params_t adv_params = {0, };
 668
 669                         _bt_get_advertising_params(&adv_params);
 670                         _bt_send_event_to_dest(sender, BT_ADAPTER_EVENT,
 671                                         BLUETOOTH_EVENT_ADVERTISING_STARTED,
 672                                         DBUS_TYPE_INT32, &result,
 673                                         DBUS_TYPE_DOUBLE, &adv_params.interval_min,
 674                                         DBUS_TYPE_DOUBLE, &adv_params.interval_max,
 675                                         DBUS_TYPE_INVALID);
 676                 } else {
 677                         _bt_send_event_to_dest(sender, BT_ADAPTER_EVENT,
 678                                         BLUETOOTH_EVENT_ADVERTISING_STOPPED,
 679                                         DBUS_TYPE_INT32, &result,
 680                                         DBUS_TYPE_INVALID);
 681                 }
 682         } else if (strcasecmp(member, "RssiEnabled") == 0) {
 683                 BT_DBG("RSSI Enabled");
 684                 gboolean status = FALSE;
 685                 char *address = NULL;
 686                 int link_type;
 687
 688                 dbus_message_iter_init(msg, &item_iter);
 689                 dbus_message_iter_get_basic(&item_iter, &address);
 690                 dbus_message_iter_next(&item_iter);
 691                 dbus_message_iter_get_basic(&item_iter, &link_type);
 692                 dbus_message_iter_next(&item_iter);
 693                 dbus_message_iter_get_basic(&item_iter, &status);
 694
 695                 BT_DBG("RSSI Enabled [%s %d]", address, status);
 696                 _bt_send_event(BT_DEVICE_EVENT,
 697                                 BLUETOOTH_EVENT_RSSI_ENABLED,
 698                                 DBUS_TYPE_INT32, &result,
 699                                 DBUS_TYPE_STRING, &address,
 700                                 DBUS_TYPE_INT32, &link_type,
 701                                 DBUS_TYPE_BOOLEAN, &status,
 702                                 DBUS_TYPE_INVALID);
 703         } else if (strcasecmp(member, "RssiAlert") == 0) {
 704                 BT_DBG("RSSI Alert");
 705                 int alert_type;
 706                 int rssi_dbm;
 707                 int link_type;
 708                 char *address = NULL;
 709
 710                 dbus_message_iter_init(msg, &item_iter);
 711                 dbus_message_iter_get_basic(&item_iter, &address);
 712                 dbus_message_iter_next(&item_iter);
 713                 dbus_message_iter_get_basic(&item_iter, &link_type);
 714                 dbus_message_iter_next(&item_iter);
 715                 dbus_message_iter_get_basic(&item_iter, &alert_type);
 716                 dbus_message_iter_next(&item_iter);
 717                 dbus_message_iter_get_basic(&item_iter, &rssi_dbm);
 718
 719                 BT_DBG("RSSI Alert: [Address %s LinkType %d] [Type %d DBM %d]",
 720                                 address, alert_type, rssi_dbm);
 721
 722                 _bt_send_event(BT_DEVICE_EVENT,
 723                                 BLUETOOTH_EVENT_RSSI_ALERT,
 724                                 DBUS_TYPE_INT32, &result,
 725                                 DBUS_TYPE_STRING, &address,
 726                                 DBUS_TYPE_INT32, &link_type,
 727                                 DBUS_TYPE_INT32, &alert_type,
 728                                 DBUS_TYPE_INT32, &rssi_dbm,
 729                                 DBUS_TYPE_INVALID);
 730         } else if (strcasecmp(member, "RawRssi") == 0) {
 731                 BT_DBG("RSSI Raw");
 732                 int rssi_dbm;
 733                 int link_type;
 734                 char *address = NULL;
 735
 736                 dbus_message_iter_init(msg, &item_iter);
 737                 dbus_message_iter_get_basic(&item_iter, &address);
 738                 dbus_message_iter_next(&item_iter);
 739                 dbus_message_iter_get_basic(&item_iter, &link_type);
 740                 dbus_message_iter_next(&item_iter);
 741                 dbus_message_iter_get_basic(&item_iter, &rssi_dbm);
 742
 743                 BT_DBG("Raw RSSI: [Address %s] [Link Type %d][RSSI DBM %d]",
 744                                 address, link_type, rssi_dbm);
 745
 746                 _bt_send_event(BT_DEVICE_EVENT,
 747                                 BLUETOOTH_EVENT_RAW_RSSI,
 748                                 DBUS_TYPE_INT32, &result,
 749                                 DBUS_TYPE_STRING, &address,
 750                                 DBUS_TYPE_INT32, &link_type,
 751                                 DBUS_TYPE_INT32, &rssi_dbm,
 752                                 DBUS_TYPE_INVALID);
 753         } else if (strcasecmp(member, BT_HARDWARE_ERROR) == 0) {
 754                 BT_ERR_C("Hardware error received from BLUEZ");
 755                 _bt_recover_adapter();
 756         } else if (strcasecmp(member, BT_TX_TIMEOUT_ERROR) == 0) {
 757                 BT_ERR_C("Tx timeout error received from BLUEZ");
 758                 _bt_recover_adapter();
 759         }
 760         BT_DBG("-");
 761 }
 762
 763 static void __bt_adapter_property_changed_event(DBusMessageIter *msg_iter, const char *path)
 764 {
 765         DBusGProxy *adapter_proxy;
 766         int mode = 0;
 767         int result = BLUETOOTH_ERROR_NONE;
 768         DBusMessageIter value_iter;
 769         DBusMessageIter dict_iter;
 770         DBusMessageIter item_iter;
 771         GValue timeout = { 0 };
 772         const char *property = NULL;
 773
 774         dbus_message_iter_recurse(msg_iter, &item_iter);
 775
 776         if (dbus_message_iter_get_arg_type(&item_iter)
 777                                         != DBUS_TYPE_DICT_ENTRY) {
 778                 BT_ERR("This is bad format dbus");
 779                 return;
 780         }
 781
 782         do {
 783                 dbus_message_iter_recurse(&item_iter, &dict_iter);
 784
 785                 dbus_message_iter_get_basic(&dict_iter, &property);
 786                 ret_if(property == NULL);
 787
 788                 ret_if(!dbus_message_iter_next(&dict_iter));
 789
 790                 if (strcasecmp(property, "Discovering") == 0) {
 791                         gboolean discovering = FALSE;
 792
 793                         dbus_message_iter_recurse(&dict_iter, &value_iter);
 794                         dbus_message_iter_get_basic(&value_iter, &discovering);
 795
 796                         /* Send event to application */
 797                         if (discovering == TRUE) {
 798                                 _bt_set_discovery_status(TRUE);
 799                                 _bt_send_event(BT_ADAPTER_EVENT,
 800                                         BLUETOOTH_EVENT_DISCOVERY_STARTED,
 801                                         DBUS_TYPE_INT32, &result,
 802                                         DBUS_TYPE_INVALID);
 803                         } else {
 804                                 ret_if(event_id > 0);
 805
 806                                 adapter_proxy = _bt_get_adapter_proxy();
 807                                 ret_if(adapter_proxy == NULL);
 808
 809                                 /* Need to stop searching */
 810                                 dbus_g_proxy_call(adapter_proxy,
 811                                                         "StopDiscovery",
 812                                                         NULL,
 813                                                         G_TYPE_INVALID,
 814                                                         G_TYPE_INVALID);
 815
 816                                 event_id = g_timeout_add(BT_DISCOVERY_FINISHED_DELAY,
 817                                                   (GSourceFunc)_bt_discovery_finished_cb, NULL);
 818                         }
 819                 } else if (strcasecmp(property, "LEDiscovering") == 0) {
 820                         gboolean le_discovering = FALSE;
 821
 822                         dbus_message_iter_recurse(&dict_iter, &value_iter);
 823                         dbus_message_iter_get_basic(&value_iter, &le_discovering);
 824
 825                         /* Send event to application */
 826                         if (le_discovering == TRUE) {
 827                                 _bt_set_le_discovery_status(TRUE);
 828                                 _bt_send_event(BT_LE_ADAPTER_EVENT,
 829                                         BLUETOOTH_EVENT_LE_DISCOVERY_STARTED,
 830                                         DBUS_TYPE_INT32, &result,
 831                                         DBUS_TYPE_INVALID);
 832                         } else {
 833                                 ret_if(event_id > 0);
 834
 835                                 adapter_proxy = _bt_get_adapter_proxy();
 836                                 ret_if(adapter_proxy == NULL);
 837
 838                                 /* Need to stop searching */
 839                                 dbus_g_proxy_call(adapter_proxy,
 840                                                         "LEStopDiscovery",
 841                                                         NULL,
 842                                                         G_TYPE_INVALID,
 843                                                         G_TYPE_INVALID);
 844
 845                                 event_id = g_timeout_add(BT_DISCOVERY_FINISHED_DELAY,
 846                                                   (GSourceFunc)__bt_le_discovery_finished_cb, NULL);
 847                         }
 848                 } else if (strcasecmp(property, "Name") == 0) {
 849                         char *name = NULL;
 850
 851                         dbus_message_iter_recurse(&dict_iter, &value_iter);
 852                         dbus_message_iter_get_basic(&value_iter, &name);
 853
 854                         /* Send event to application */
 855                         _bt_send_event(BT_ADAPTER_EVENT,
 856                                         BLUETOOTH_EVENT_LOCAL_NAME_CHANGED,
 857                                         DBUS_TYPE_INT32, &result,
 858                                         DBUS_TYPE_STRING, &name,
 859                                         DBUS_TYPE_INVALID);
 860                 } else if (strcasecmp(property, "Alias") == 0) {
 861                         char *alias = NULL;
 862
 863                         dbus_message_iter_recurse(&dict_iter, &value_iter);
 864                         dbus_message_iter_get_basic(&value_iter, &alias);
 865
 866                         /* Send event to application */
 867                         _bt_send_event(BT_ADAPTER_EVENT,
 868                                         BLUETOOTH_EVENT_LOCAL_NAME_CHANGED,
 869                                         DBUS_TYPE_INT32, &result,
 870                                         DBUS_TYPE_STRING, &alias,
 871                                         DBUS_TYPE_INVALID);
 872                 } else if (strcasecmp(property, "Discoverable") == 0) {
 873                         gboolean discoverable = FALSE;
 874
 875                         dbus_message_iter_recurse(&dict_iter, &value_iter);
 876                         dbus_message_iter_get_basic(&value_iter, &discoverable);
 877
 878                         if (discoverable == FALSE) {
 879                                 if (_bt_get_discoverable_timeout_property() > 0) {
 880                                         g_value_init(&timeout, G_TYPE_UINT);
 881                                         g_value_set_uint(&timeout, 0);
 882
 883                                         adapter_proxy = _bt_get_adapter_properties_proxy();
 884                                         ret_if(adapter_proxy == NULL);
 885
 886                                         dbus_g_proxy_call_no_reply(adapter_proxy, "Set",
 887                                                         G_TYPE_STRING, BT_ADAPTER_INTERFACE,
 888                                                         G_TYPE_STRING, "DiscoverableTimeout",
 889                                                         G_TYPE_VALUE, &timeout,
 890                                                         G_TYPE_INVALID);
 891
 892                                         g_value_unset(&timeout);
 893                                 }
 894
 895                                 mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
 896
 897                                 /* Send event to application */
 898                                 BT_INFO("[Connectable]");
 899                                 _bt_send_event(BT_ADAPTER_EVENT,
 900                                                 BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED,
 901                                                 DBUS_TYPE_INT32, &result,
 902                                                 DBUS_TYPE_INT16, &mode,
 903                                                 DBUS_TYPE_INVALID);
 904                         } else {
 905                                 _bt_get_discoverable_mode(&mode);
 906
 907                                 /* Event will be sent by "DiscoverableTimeout" signal */
 908                                 if (mode != BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE)
 909                                         return;
 910
 911                                 /* Send event to application */
 912                                 BT_INFO("[General Discoverable]");
 913                                 _bt_send_event(BT_ADAPTER_EVENT,
 914                                                 BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED,
 915                                                 DBUS_TYPE_INT32, &result,
 916                                                 DBUS_TYPE_INT16, &mode,
 917                                                 DBUS_TYPE_INVALID);
 918                         }
 919                 } else if (strcasecmp(property, "DiscoverableTimeout") == 0) {
 920                         _bt_get_discoverable_mode(&mode);
 921
 922                         /* Event was already sent by "Discoverable" signal */
 923                         if (mode == BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE ||
 924                                 mode == BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE)
 925                                 return;
 926
 927                         /* Send event to application */
 928                         BT_INFO("[Limited Discoverable (Timeout %u secs)]",
 929                                         _bt_get_discoverable_timeout_property());
 930
 931                         _bt_send_event(BT_ADAPTER_EVENT,
 932                                         BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED,
 933                                         DBUS_TYPE_INT32, &result,
 934                                         DBUS_TYPE_INT16, &mode,
 935                                         DBUS_TYPE_INVALID);
 936                 } else if (strcasecmp(property, "Powered") == 0) {
 937         /* TODO: Need to check this operation!! */
 938                         gboolean powered = FALSE;
 939                         int bt_state;
 940
 941                         dbus_message_iter_recurse(&dict_iter, &value_iter);
 942                         dbus_message_iter_get_basic(&value_iter, &powered);
 943                         BT_DBG("Powered = %d", powered);
 944                         if (powered == FALSE) {
 945                                 if (vconf_get_int(VCONFKEY_BT_STATUS, &bt_state) == 0 &&
 946                                         bt_state != VCONFKEY_BT_STATUS_OFF) {
 947                                         _bt_disable_adapter();
 948                                 }
 949 #ifdef ENABLE_TIZEN_2_4
 950                                 if (vconf_get_int(VCONFKEY_BT_LE_STATUS, &bt_state) == 0 &&
 951                                         bt_state != VCONFKEY_BT_LE_STATUS_OFF) {
 952                                         _bt_set_le_disabled(BLUETOOTH_ERROR_NONE);
 953                                 }
 954 #endif
 955                         }
 956                 } else if (strcasecmp(property, "Connectable") == 0) {
 957                         gboolean connectable = FALSE;
 958
 959                         dbus_message_iter_recurse(&dict_iter, &value_iter);
 960                         dbus_message_iter_get_basic(&value_iter, &connectable);
 961
 962                         BT_DBG("Connectable property is changed : %d", connectable);
 963
 964                         _bt_send_event(BT_ADAPTER_EVENT,
 965                                         BLUETOOTH_EVENT_CONNECTABLE_CHANGED,
 966                                         DBUS_TYPE_BOOLEAN, &connectable,
 967                                         DBUS_TYPE_INVALID);
 968
 969                         if (_bt_adapter_get_status() == BT_DEACTIVATING &&
 970                                 _bt_adapter_get_le_status() == BT_LE_ACTIVATED &&
 971                                 connectable == 0)
 972                                         _bt_set_disabled(BLUETOOTH_ERROR_NONE);
 973                 } else if (strcasecmp(property, "SupportedLEFeatures") == 0) {
 974                         char *name = NULL;
 975                         char *val = NULL;
 976                         DBusMessageIter array_iter;
 977
 978                         dbus_message_iter_recurse(&dict_iter, &value_iter);
 979
 980                         if(dbus_message_iter_get_arg_type(&value_iter) == DBUS_TYPE_ARRAY) {
 981                                 dbus_message_iter_recurse(&value_iter, &array_iter);
 982
 983                                 while (dbus_message_iter_get_arg_type(&array_iter) !=
 984                                                         DBUS_TYPE_INVALID) {
 985                                         dbus_message_iter_get_basic(&array_iter, &name);
 986                                         if (!dbus_message_iter_next(&array_iter))
 987                                                 break;
 988
 989                                         dbus_message_iter_get_basic(&array_iter, &val);
 990
 991                                         BT_DBG("name[%s] value[%s]", name, val);
 992
 993                                         if (FALSE == _bt_update_le_feature_support(name, val))
 994                                                 BT_INFO("Fail to update LE feature info");
 995
 996                                         if (!dbus_message_iter_next(&array_iter))
 997                                                 break;
 998                                 }
 999                         }
1000                 } else {
1001                         BT_DBG("property : [%s]", property);
1002                 }
1003         } while(dbus_message_iter_next(&item_iter));
1004 }
1005
1006 static void __bt_obex_property_changed_event(DBusMessageIter *msg_iter, const char *path)
1007 {
1008         BT_DBG("+");
1009
1010         DBusMessageIter value_iter;
1011         DBusMessageIter dict_iter;
1012         DBusMessageIter item_iter;
1013         const char *property = NULL;
1014
1015         dbus_message_iter_recurse(msg_iter, &item_iter);
1016
1017         if (dbus_message_iter_get_arg_type(&item_iter)
1018                                         != DBUS_TYPE_DICT_ENTRY) {
1019                 BT_ERR("This is bad format dbus");
1020                 return;
1021         }
1022
1023         do {
1024                 dbus_message_iter_recurse(&item_iter, &dict_iter);
1025
1026                 dbus_message_iter_get_basic(&dict_iter, &property);
1027                 ret_if(property == NULL);
1028
1029                 ret_if(!dbus_message_iter_next(&dict_iter));
1030
1031                 BT_DBG("property :%s", property);
1032
1033                 if (strcasecmp(property, "Status") == 0) {
1034                         const char  *status;
1035                         dbus_message_iter_recurse(&dict_iter, &value_iter);
1036                         dbus_message_iter_get_basic(&value_iter, &status);
1037
1038                         if (strcasecmp(status, "active") == 0){
1039                                 _bt_obex_transfer_started(path);
1040                         } else if (strcasecmp(status, "complete") == 0) {
1041                                 _bt_obex_transfer_completed(path, TRUE);
1042                                 _bt_pbap_obex_transfer_completed(path, TRUE);
1043                         } else if (strcasecmp(status, "error") == 0){
1044                                 _bt_obex_transfer_completed(path, FALSE);
1045                                 _bt_pbap_obex_transfer_completed(path, FALSE);
1046                         }
1047                 } else if (strcasecmp(property, "Transferred") == 0) {
1048                         static int transferred  = 0;
1049                         dbus_message_iter_recurse(&dict_iter, &value_iter);
1050                         dbus_message_iter_get_basic(&value_iter, &transferred);
1051
1052                         _bt_obex_transfer_progress(path,transferred);
1053                 }
1054
1055                 dbus_message_iter_next(&item_iter);
1056         } while (dbus_message_iter_get_arg_type(&item_iter) ==
1057                         DBUS_TYPE_DICT_ENTRY);
1058
1059         BT_DBG("-");
1060 }
1061
1062 static void __bt_device_property_changed_event(DBusMessageIter *msg_iter, const char *path)
1063 {
1064         BT_DBG("+");
1065
1066         int event;
1067         int result = BLUETOOTH_ERROR_NONE;
1068         DBusMessageIter value_iter;
1069         DBusMessageIter dict_iter;
1070         DBusMessageIter item_iter;
1071         const char *property = NULL;
1072         char *address;
1073         bt_remote_dev_info_t *remote_dev_info;
1074
1075         dbus_message_iter_recurse(msg_iter, &item_iter);
1076
1077         if (dbus_message_iter_get_arg_type(&item_iter)
1078                                         != DBUS_TYPE_DICT_ENTRY) {
1079                 BT_ERR("This is bad format dbus");
1080                 return;
1081         }
1082
1083         do {
1084                 dbus_message_iter_recurse(&item_iter, &dict_iter);
1085
1086                 dbus_message_iter_get_basic(&dict_iter, &property);
1087                 ret_if(property == NULL);
1088
1089                 ret_if(!dbus_message_iter_next(&dict_iter));
1090
1091                 if (strcasecmp(property, "Connected") == 0) {
1092                         gboolean connected = FALSE;
1093
1094                         dbus_message_iter_recurse(&dict_iter, &value_iter);
1095                         dbus_message_iter_get_basic(&value_iter, &connected);
1096
1097                         event = connected ? BLUETOOTH_EVENT_DEVICE_CONNECTED :
1098                                         BLUETOOTH_EVENT_DEVICE_DISCONNECTED;
1099
1100                         address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1101
1102                         _bt_convert_device_path_to_address(path, address);
1103
1104                         BT_DBG("connected: %d", connected);
1105                         BT_DBG("address: %s", address);
1106
1107                         remote_dev_info = _bt_get_remote_device_info(address);
1108
1109                         if (remote_dev_info != NULL) {
1110                                 __bt_device_remote_connected_properties(
1111                                 remote_dev_info, address, connected);
1112                                 _bt_free_device_info(remote_dev_info);
1113                         }
1114
1115                         /* Send event to application */
1116                         _bt_send_event(BT_DEVICE_EVENT,
1117                                         event,
1118                                         DBUS_TYPE_INT32, &result,
1119                                         DBUS_TYPE_STRING, &address,
1120                                         DBUS_TYPE_INVALID);
1121
1122                         g_free(address);
1123                 } else if (strcasecmp(property, "RSSI") == 0) {
1124                         bt_remote_dev_info_t *remote_dev_info;
1125
1126                         address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1127
1128                         _bt_convert_device_path_to_address(path, address);
1129                         BT_DBG("address: %s", address);
1130
1131                         remote_dev_info = _bt_get_remote_device_info(address);
1132                         if (remote_dev_info == NULL) {
1133                                 g_free(address);
1134                                 return;
1135                         }
1136                         BT_DBG("Address type  %d", remote_dev_info->addr_type);
1137
1138                         if (remote_dev_info && remote_dev_info->addr_type == 0) {
1139                                 BT_DBG("Name %s", remote_dev_info->name);
1140
1141                                 _bt_send_event(BT_ADAPTER_EVENT,
1142                                 BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND,
1143                                 DBUS_TYPE_INT32, &result,
1144                                 DBUS_TYPE_STRING, &remote_dev_info->address,
1145                                 DBUS_TYPE_UINT32, &remote_dev_info->class,
1146                                 DBUS_TYPE_INT16, &remote_dev_info->rssi,
1147                                 DBUS_TYPE_STRING, &remote_dev_info->name,
1148                                 DBUS_TYPE_BOOLEAN, &remote_dev_info->paired,
1149                                 DBUS_TYPE_BOOLEAN, &remote_dev_info->connected,
1150                                 DBUS_TYPE_BOOLEAN, &remote_dev_info->trust,
1151                                 DBUS_TYPE_ARRAY, DBUS_TYPE_STRING,
1152                                 &remote_dev_info->uuids, remote_dev_info->uuid_count,
1153                                 DBUS_TYPE_INT16, &remote_dev_info->manufacturer_data_len,
1154                                 DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE,
1155                                 &remote_dev_info->manufacturer_data, remote_dev_info->manufacturer_data_len,
1156                                 DBUS_TYPE_INVALID);
1157                         }
1158                         _bt_free_device_info(remote_dev_info);
1159                         g_free(address);
1160                 } else if (strcasecmp(property, "GattConnected") == 0) {
1161                         gboolean gatt_connected = FALSE;
1162
1163                         dbus_message_iter_recurse(&dict_iter, &value_iter);
1164                         dbus_message_iter_get_basic(&value_iter, &gatt_connected);
1165
1166                         event = gatt_connected ? BLUETOOTH_EVENT_GATT_CONNECTED :
1167                                         BLUETOOTH_EVENT_GATT_DISCONNECTED;
1168
1169                         address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1170
1171                         _bt_convert_device_path_to_address(path, address);
1172
1173                         BT_DBG("gatt_connected: %d", gatt_connected);
1174                         BT_DBG("address: %s", address);
1175
1176                         /* Send event to application */
1177                         _bt_send_event(BT_DEVICE_EVENT,
1178                                         event,
1179                                         DBUS_TYPE_INT32, &result,
1180                                         DBUS_TYPE_STRING, &address,
1181                                         DBUS_TYPE_INVALID);
1182
1183                         g_free(address);
1184                 } else if (strcasecmp(property, "Paired") == 0) {
1185                         gboolean paired = FALSE;
1186                         bt_remote_dev_info_t *remote_dev_info;
1187
1188                         dbus_message_iter_recurse(&dict_iter, &value_iter);
1189                         dbus_message_iter_get_basic(&value_iter, &paired);
1190
1191                         _bt_agent_set_canceled(FALSE);
1192                         /* BlueZ sends paired signal for each paired device */
1193                         /* during activation, We should ignore this, otherwise*/
1194                         /* application thinks that a new device got paired */
1195                         if (_bt_adapter_get_status() != BT_ACTIVATED) {
1196                                 BT_DBG("BT is not activated, so ignore this");
1197                                 return;
1198                         }
1199
1200                         address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1201
1202                         _bt_convert_device_path_to_address(path, address);
1203
1204                         remote_dev_info = _bt_get_remote_device_info(address);
1205                         if (remote_dev_info == NULL) {
1206                                 g_free(address);
1207                                 return;
1208                         }
1209
1210                         if(paired == FALSE) {
1211                                 BT_INFO("Unpaired: %s", address);
1212                                 __bt_update_remote_cache_devinfo(address, FALSE);
1213                                 _bt_send_event(BT_ADAPTER_EVENT,
1214                                         BLUETOOTH_EVENT_BONDED_DEVICE_REMOVED,
1215                                         DBUS_TYPE_INT32, &result,
1216                                         DBUS_TYPE_STRING, &address,
1217                                         DBUS_TYPE_INVALID);
1218                         } else {
1219                                 BT_INFO("Paired: %s", address);
1220                                 __bt_update_remote_cache_devinfo(address, TRUE);
1221
1222                                 if (_bt_is_device_creating() == TRUE) {
1223                                         BT_DBG("Try to Pair by me");
1224                                         _bt_free_device_info(remote_dev_info);
1225                                         g_free(address);
1226                                         return;
1227                                 }
1228
1229                                 _bt_send_event(BT_ADAPTER_EVENT,
1230                                         BLUETOOTH_EVENT_BONDING_FINISHED,
1231                                         DBUS_TYPE_INT32, &result,
1232                                         DBUS_TYPE_STRING, &address,
1233                                         DBUS_TYPE_UINT32, &remote_dev_info->class,
1234                                         DBUS_TYPE_INT16, &remote_dev_info->rssi,
1235                                         DBUS_TYPE_STRING, &remote_dev_info->name,
1236                                         DBUS_TYPE_BOOLEAN, &remote_dev_info->paired,
1237                                         DBUS_TYPE_BOOLEAN, &remote_dev_info->connected,
1238                                         DBUS_TYPE_BOOLEAN, &remote_dev_info->trust,
1239                                         DBUS_TYPE_ARRAY, DBUS_TYPE_STRING,
1240                                         &remote_dev_info->uuids, remote_dev_info->uuid_count,
1241                                         DBUS_TYPE_INT16, &remote_dev_info->manufacturer_data_len,
1242                                         DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE,
1243                                         &remote_dev_info->manufacturer_data, remote_dev_info->manufacturer_data_len,
1244                                         DBUS_TYPE_INVALID);
1245                         }
1246                         _bt_free_device_info(remote_dev_info);
1247                         g_free(address);
1248                 } else if (strcasecmp(property, "LegacyPaired") == 0) {
1249                         gboolean paired = FALSE;
1250                         bt_remote_dev_info_t *remote_dev_info;
1251
1252                         if (_bt_adapter_get_status() != BT_ACTIVATED) {
1253                                 BT_DBG("BT is not activated, so ignore this");
1254                                 return;
1255                         }
1256
1257                         dbus_message_iter_recurse(&dict_iter, &value_iter);
1258                         dbus_message_iter_get_basic(&value_iter, &paired);
1259                         address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1260                         BT_DBG("LegacyPaired: %d", paired);
1261                         _bt_convert_device_path_to_address(path, address);
1262
1263                         remote_dev_info = _bt_get_remote_device_info(address);
1264                         if (remote_dev_info == NULL) {
1265                                 g_free(address);
1266                                 return;
1267                         }
1268
1269                         BT_DBG("LegacyPairing Failed with %s. Show Error Popup",
1270                                         remote_dev_info->name);
1271                         _bt_launch_system_popup(BT_AGENT_EVENT_LEGACY_PAIR_FAILED_FROM_REMOTE,
1272                                                 remote_dev_info->name, NULL, NULL, NULL);
1273
1274                         _bt_free_device_info(remote_dev_info);
1275                         g_free(address);
1276                 } else if (strcasecmp(property, "Trusted") == 0) {
1277                         gboolean trusted = FALSE;
1278
1279                         dbus_message_iter_recurse(&dict_iter, &value_iter);
1280                         dbus_message_iter_get_basic(&value_iter, &trusted);
1281
1282                         event = trusted ? BLUETOOTH_EVENT_DEVICE_AUTHORIZED :
1283                                         BLUETOOTH_EVENT_DEVICE_UNAUTHORIZED;
1284
1285                         address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1286
1287                         _bt_convert_device_path_to_address(path, address);
1288
1289                         BT_DBG("trusted: %d", trusted);
1290                         BT_DBG("address: %s", address);
1291
1292                         /* Send event to application */
1293                         _bt_send_event(BT_DEVICE_EVENT,
1294                                         event,
1295                                         DBUS_TYPE_INT32, &result,
1296                                         DBUS_TYPE_STRING, &address,
1297                                         DBUS_TYPE_INVALID);
1298
1299                         g_free(address);
1300                 }
1301                 dbus_message_iter_next(&item_iter);
1302         } while (dbus_message_iter_get_arg_type(&item_iter) ==
1303                         DBUS_TYPE_DICT_ENTRY);
1304         BT_DBG("-");
1305 }
1306
1307 static void __bt_media_control_changed_event(DBusMessageIter *msg_iter, const char *path)
1308 {
1309         int event;
1310         int result = BLUETOOTH_ERROR_NONE;
1311         DBusMessageIter value_iter;
1312         DBusMessageIter dict_iter;
1313         DBusMessageIter item_iter;
1314         const char *property = NULL;
1315         char *address;
1316         bt_remote_dev_info_t *remote_dev_info;
1317
1318         dbus_message_iter_recurse(msg_iter, &item_iter);
1319
1320         if (dbus_message_iter_get_arg_type(&item_iter)
1321                                         != DBUS_TYPE_DICT_ENTRY) {
1322                 BT_ERR("This is bad format dbus");
1323                 return;
1324         }
1325
1326         dbus_message_iter_recurse(&item_iter, &dict_iter);
1327
1328         dbus_message_iter_get_basic(&dict_iter, &property);
1329         ret_if(property == NULL);
1330
1331         ret_if(!dbus_message_iter_next(&dict_iter));
1332
1333         if (strcasecmp(property, "Connected") == 0) {
1334                 gboolean connected = FALSE;
1335
1336                 dbus_message_iter_recurse(&dict_iter, &value_iter);
1337                 dbus_message_iter_get_basic(&value_iter, &connected);
1338
1339                 event = connected ? BLUETOOTH_EVENT_AVRCP_CONNECTED :
1340                                 BLUETOOTH_EVENT_AVRCP_DISCONNECTED;
1341
1342                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1343
1344                 _bt_convert_device_path_to_address(path, address);
1345
1346                 BT_DBG("connected: %d", connected);
1347                 BT_DBG("address: %s", address);
1348
1349                 remote_dev_info = _bt_get_remote_device_info(address);
1350
1351                 if (remote_dev_info != NULL) {
1352                         __bt_device_remote_connected_properties(
1353                         remote_dev_info, address, connected);
1354                         _bt_free_device_info(remote_dev_info);
1355                 }
1356
1357                 /* Send event to application */
1358                 _bt_send_event(BT_AVRCP_EVENT,
1359                         event,
1360                         DBUS_TYPE_INT32, &result,
1361                         DBUS_TYPE_STRING, &address,
1362                         DBUS_TYPE_INVALID);
1363                 g_free(address);
1364         }
1365
1366         BT_DBG("-");
1367 }
1368
1369 void _bt_handle_property_changed_event(DBusMessage *msg)
1370 {
1371         DBusMessageIter item_iter;
1372         const char *member = dbus_message_get_member(msg);
1373         const char *interface_name = NULL;
1374
1375         ret_if(member == NULL);
1376
1377         dbus_message_iter_init(msg, &item_iter);
1378
1379         if (dbus_message_iter_get_arg_type(&item_iter)
1380                                         != DBUS_TYPE_STRING) {
1381                 BT_ERR("This is bad format dbus");
1382                 return;
1383         }
1384
1385         dbus_message_iter_get_basic(&item_iter, &interface_name);
1386
1387         ret_if(interface_name == NULL);
1388
1389         ret_if(dbus_message_iter_next(&item_iter) == FALSE);
1390
1391         ret_if(dbus_message_iter_get_arg_type(&item_iter) != DBUS_TYPE_ARRAY);
1392
1393         if (strcasecmp(interface_name, BT_ADAPTER_INTERFACE) == 0) {
1394                 __bt_adapter_property_changed_event(&item_iter,
1395                                         dbus_message_get_path(msg));
1396         } else if (strcasecmp(interface_name, BT_DEVICE_INTERFACE) == 0) {
1397                 __bt_device_property_changed_event(&item_iter,
1398                                         dbus_message_get_path(msg));
1399         } else if (strcasecmp(interface_name, BT_OBEX_TRANSFER_INTERFACE) == 0) {
1400                 BT_DBG("BT_OBEX_TRANSFER_INTERFACE");
1401                 __bt_obex_property_changed_event(&item_iter,
1402                                         dbus_message_get_path(msg));
1403         } else if (strcasecmp(interface_name, BT_MEDIA_CONTROL_INTERFACE) == 0) {
1404                 __bt_media_control_changed_event(&item_iter,
1405                                         dbus_message_get_path(msg));
1406         } else if (strcasecmp(interface_name, BT_PLAYER_CONTROL_INTERFACE) == 0) {
1407                 _bt_handle_avrcp_control_event(&item_iter,
1408                                         dbus_message_get_path(msg));
1409         } else if (strcasecmp(interface_name, BT_NETWORK_CLIENT_INTERFACE) == 0) {
1410                 BT_DBG("BT_NETWORK_CLIENT_INTERFACE");
1411                 _bt_handle_network_client_event(&item_iter,
1412                                         dbus_message_get_path(msg));
1413         }
1414 }
1415
1416 void __bt_opc_property_changed_event(DBusMessageIter *msg_iter,
1417                                                 const char *path)
1418 {
1419         DBusMessageIter value_iter;
1420         DBusMessageIter dict_iter;
1421         DBusMessageIter item_iter;
1422         const char *property = NULL;
1423
1424         dbus_message_iter_recurse(msg_iter, &item_iter);
1425
1426         if (dbus_message_iter_get_arg_type(&item_iter)
1427                                 != DBUS_TYPE_DICT_ENTRY) {
1428                 BT_ERR("This is bad format dbus");
1429                 return;
1430         }
1431
1432         dbus_message_iter_recurse(&item_iter, &dict_iter);
1433
1434         dbus_message_iter_get_basic(&dict_iter, &property);
1435         ret_if(property == NULL);
1436
1437         ret_if(!dbus_message_iter_next(&dict_iter));
1438
1439         if (strcasecmp(property, "Status") == 0) {
1440                 const char *status = NULL;
1441                 dbus_message_iter_recurse(&dict_iter, &value_iter);
1442                 dbus_message_iter_get_basic(&value_iter, &status);
1443
1444                 BT_INFO("Status is %s", status);
1445
1446                 if(strcasecmp(status, "active") == 0){
1447                         _bt_obex_client_started(path);
1448                 }else if (strcasecmp(status, "complete") == 0) {
1449                         _bt_obex_client_completed(path, TRUE);
1450                 }else if (strcasecmp(status, "error") == 0){
1451                         _bt_obex_client_completed(path, FALSE);
1452                 }
1453         } else if (strcasecmp(property, "Transferred") == 0) {
1454                 static int transferred  = 0;
1455                 dbus_message_iter_recurse(&dict_iter, &value_iter);
1456                 dbus_message_iter_get_basic(&value_iter, &transferred);
1457
1458                 _bt_obex_client_progress(path, transferred);
1459         } else {
1460                 BT_DBG("property : [%s]", property);
1461         }
1462 }
1463
1464 void _bt_opc_property_changed_event(DBusMessage *msg)
1465 {
1466         DBusMessageIter item_iter;
1467         const char *member = dbus_message_get_member(msg);
1468         const char *interface_name = NULL;
1469
1470         ret_if(member == NULL);
1471
1472         dbus_message_iter_init(msg, &item_iter);
1473
1474         if (dbus_message_iter_get_arg_type(&item_iter)
1475                                 != DBUS_TYPE_STRING) {
1476                 BT_ERR("This is bad format dbus");
1477                 return;
1478         }
1479
1480         dbus_message_iter_get_basic(&item_iter, &interface_name);
1481
1482         ret_if(interface_name == NULL);
1483
1484         BT_DBG("interface: %s", interface_name);
1485
1486         ret_if(dbus_message_iter_next(&item_iter) == FALSE);
1487
1488         ret_if(dbus_message_iter_get_arg_type(&item_iter) != DBUS_TYPE_ARRAY);
1489
1490         if (strcasecmp(interface_name, BT_OBEX_TRANSFER_INTERFACE) == 0) {
1491                 __bt_opc_property_changed_event(&item_iter,
1492                                         dbus_message_get_path(msg));
1493         } else {
1494                 BT_DBG("interface_name : [%s]", interface_name);
1495         }
1496 }
1497
1498
1499 void _bt_handle_input_event(DBusMessage *msg)
1500 {
1501         int result = BLUETOOTH_ERROR_NONE;
1502         DBusMessageIter item_iter;
1503         DBusMessageIter value_iter;
1504         gboolean property_flag = FALSE;
1505         const char *member = dbus_message_get_member(msg);
1506         const char *path = dbus_message_get_path(msg);
1507         const char *property = NULL;
1508         bt_remote_dev_info_t *remote_dev_info;
1509
1510         ret_if(member == NULL);
1511
1512         dbus_message_iter_init(msg, &item_iter);
1513
1514         if (dbus_message_iter_get_arg_type(&item_iter)
1515                                         != DBUS_TYPE_STRING) {
1516                 BT_ERR("This is bad format dbus");
1517                 return;
1518         }
1519
1520         dbus_message_iter_get_basic(&item_iter, &property);
1521
1522         ret_if(property == NULL);
1523
1524         if (strcasecmp(property, "Connected") == 0) {
1525                 int event = BLUETOOTH_EVENT_NONE;
1526                 char *address;
1527
1528                 dbus_message_iter_next(&item_iter);
1529                 dbus_message_iter_recurse(&item_iter, &value_iter);
1530                 dbus_message_iter_get_basic(&value_iter, &property_flag);
1531
1532                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1533
1534                 _bt_convert_device_path_to_address(path, address);
1535
1536                 event = (property_flag == TRUE) ?
1537                                 BLUETOOTH_HID_CONNECTED :
1538                                 BLUETOOTH_HID_DISCONNECTED;
1539
1540                 _bt_send_event(BT_HID_EVENT, event,
1541                         DBUS_TYPE_INT32, &result,
1542                         DBUS_TYPE_STRING, &address,
1543                         DBUS_TYPE_INVALID);
1544
1545                 /* Check HID connection type (Keyboard or Mouse) and update the status */
1546                 remote_dev_info = _bt_get_remote_device_info(address);
1547
1548                 if (property_flag == TRUE) {
1549                         hid_connected_device_count++;
1550                         __bt_set_device_values(TRUE,
1551                                         VCONFKEY_BT_DEVICE_HID_CONNECTED);
1552                 } else {
1553                         hid_connected_device_count--;
1554                         if (hid_connected_device_count == 0)
1555                                 __bt_set_device_values(FALSE,
1556                                                 VCONFKEY_BT_DEVICE_HID_CONNECTED);
1557                 }
1558
1559                 if (remote_dev_info != NULL) {
1560                         BT_DBG("HID device class [%x]", remote_dev_info->class);
1561                         if (remote_dev_info->class &
1562                                         BLUETOOTH_DEVICE_MINOR_CLASS_KEY_BOARD) {
1563 #ifdef ENABLE_TIZEN_2_4
1564                                 __bt_set_device_values(property_flag,
1565                                                 VCONFKEY_BT_DEVICE_HID_KEYBOARD_CONNECTED);
1566 #endif
1567
1568                         }
1569
1570                         if (remote_dev_info->class &
1571                                         BLUETOOTH_DEVICE_MINOR_CLASS_POINTING_DEVICE)
1572                         {
1573 #ifdef ENABLE_TIZEN_2_4
1574                                 __bt_set_device_values(property_flag,
1575                                                 VCONFKEY_BT_DEVICE_HID_MOUSE_CONNECTED);
1576 #endif
1577                         }
1578                         _bt_free_device_info(remote_dev_info);
1579                 }
1580
1581                 g_free(address);
1582         }
1583  }
1584
1585 void _bt_handle_network_server_event(DBusMessage *msg)
1586 {
1587         int result = BLUETOOTH_ERROR_NONE;
1588         char *address = NULL;
1589         char *device = NULL;
1590         const char *member = dbus_message_get_member(msg);
1591
1592         ret_if(member == NULL);
1593
1594         if (strcasecmp(member, "PeerConnected") == 0) {
1595                 if (!dbus_message_get_args(msg, NULL,
1596                         DBUS_TYPE_STRING, &device,
1597                         DBUS_TYPE_STRING, &address,
1598                         DBUS_TYPE_INVALID)) {
1599                         BT_ERR("Unexpected parameters in signal");
1600                         return;
1601                 }
1602
1603                 __bt_set_device_values(TRUE,
1604                                 VCONFKEY_BT_DEVICE_PAN_CONNECTED);
1605
1606                 _bt_send_event(BT_NETWORK_EVENT, BLUETOOTH_EVENT_NETWORK_SERVER_CONNECTED,
1607                         DBUS_TYPE_INT32, &result,
1608                         DBUS_TYPE_STRING, &device,
1609                         DBUS_TYPE_STRING, &address,
1610                         DBUS_TYPE_INVALID);
1611                  nap_connected_device_count++;
1612         } else if (strcasecmp(member, "PeerDisconnected") == 0) {
1613                 if (!dbus_message_get_args(msg, NULL,
1614                         DBUS_TYPE_STRING, &device,
1615                         DBUS_TYPE_STRING, &address,
1616                         DBUS_TYPE_INVALID)) {
1617                         BT_ERR("Unexpected parameters in signal");
1618                         return;
1619                 }
1620                 nap_connected_device_count--;
1621                 if (nap_connected_device_count == 0)
1622                         __bt_set_device_values(FALSE,
1623                                 VCONFKEY_BT_DEVICE_PAN_CONNECTED);
1624
1625                 _bt_send_event(BT_NETWORK_EVENT, BLUETOOTH_EVENT_NETWORK_SERVER_DISCONNECTED,
1626                         DBUS_TYPE_INT32, &result,
1627                         DBUS_TYPE_STRING, &device,
1628                         DBUS_TYPE_STRING, &address,
1629                         DBUS_TYPE_INVALID);
1630         }
1631 }
1632
1633 void _bt_handle_network_client_event(DBusMessageIter *msg_iter,
1634                                 const char *path)
1635 {
1636         BT_DBG("+");
1637
1638         int result = BLUETOOTH_ERROR_NONE;
1639         DBusMessageIter item_iter;
1640         DBusMessageIter dict_iter;
1641         DBusMessageIter value_iter;
1642         gboolean property_flag = FALSE;
1643         const char *property = NULL;
1644
1645         dbus_message_iter_recurse(msg_iter, &item_iter);
1646
1647         if (dbus_message_iter_get_arg_type(&item_iter)
1648                                         != DBUS_TYPE_DICT_ENTRY) {
1649                 BT_ERR("This is bad format dbus");
1650                 return;
1651         }
1652
1653         dbus_message_iter_recurse(&item_iter, &dict_iter);
1654         dbus_message_iter_get_basic(&dict_iter, &property);
1655
1656         ret_if(property == NULL);
1657         ret_if(!dbus_message_iter_next(&dict_iter));
1658
1659         if (strcasecmp(property, "Connected") == 0) {
1660                 int event = BLUETOOTH_EVENT_NONE;
1661                 char *address;
1662
1663                 dbus_message_iter_recurse(&dict_iter, &value_iter);
1664                 dbus_message_iter_get_basic(&value_iter, &property_flag);
1665
1666                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1667
1668                 _bt_convert_device_path_to_address(path, address);
1669
1670                 BT_DBG("property_flag %d", property_flag);
1671                 if (property_flag == TRUE) {
1672                         event = BLUETOOTH_EVENT_NETWORK_CONNECTED;
1673                         nap_connected_device_count++;
1674                         __bt_set_device_values(TRUE,
1675                                 VCONFKEY_BT_DEVICE_PAN_CONNECTED);
1676                 } else {
1677                         event = BLUETOOTH_EVENT_NETWORK_DISCONNECTED;
1678                         nap_connected_device_count--;
1679                         if (nap_connected_device_count == 0)
1680                                 __bt_set_device_values(FALSE,
1681                                         VCONFKEY_BT_DEVICE_PAN_CONNECTED);
1682                 }
1683
1684                 _bt_send_event(BT_NETWORK_EVENT, event,
1685                         DBUS_TYPE_INT32, &result,
1686                         DBUS_TYPE_STRING, &address,
1687                         DBUS_TYPE_INVALID);
1688
1689                 g_free(address);
1690         }
1691         BT_DBG("-");
1692 }
1693
1694 void _bt_handle_device_event(DBusMessage *msg)
1695 {
1696         int event;
1697         int result = BLUETOOTH_ERROR_NONE;
1698         DBusMessageIter item_iter;
1699         DBusMessageIter value_iter;
1700         char *address;
1701         const char *member = dbus_message_get_member(msg);
1702         const char *path = dbus_message_get_path(msg);
1703         const char *property = NULL;
1704
1705         ret_if(path == NULL);
1706         ret_if(member == NULL);
1707
1708         if (strcasecmp(member, "PropertyChanged") == 0) {
1709                 dbus_message_iter_init(msg, &item_iter);
1710
1711                 if (dbus_message_iter_get_arg_type(&item_iter)
1712                                                 != DBUS_TYPE_STRING) {
1713                         BT_ERR("This is bad format dbus");
1714                         return;
1715                 }
1716
1717                 dbus_message_iter_get_basic(&item_iter, &property);
1718
1719                 ret_if(property == NULL);
1720
1721                 if (strcasecmp(property, "GattConnected") == 0) {
1722                         gboolean connected = FALSE;
1723                         char *address;
1724
1725                         address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1726                         _bt_convert_device_path_to_address(path, address);
1727
1728                         dbus_message_iter_next(&item_iter);
1729                         dbus_message_iter_recurse(&item_iter, &value_iter);
1730                         dbus_message_iter_get_basic(&value_iter, &connected);
1731
1732                         event = connected ? BLUETOOTH_EVENT_GATT_CONNECTED :
1733                                         BLUETOOTH_EVENT_GATT_DISCONNECTED;
1734
1735                         _bt_send_event(BT_DEVICE_EVENT,
1736                                         event,
1737                                         DBUS_TYPE_INT32, &result,
1738                                         DBUS_TYPE_STRING, &address,
1739                                         DBUS_TYPE_INVALID);
1740
1741                         g_free(address);
1742                 } else if (strcasecmp(property, "Paired") == 0) {
1743                         gboolean paired = FALSE;
1744                         bt_remote_dev_info_t *remote_dev_info;
1745                         dbus_message_iter_next(&item_iter);
1746                         dbus_message_iter_recurse(&item_iter, &value_iter);
1747                         dbus_message_iter_get_basic(&value_iter, &paired);
1748
1749                         ret_if(paired == FALSE);
1750
1751                         /* BlueZ sends paired signal for each paired device */
1752                         /* during activation, We should ignore this, otherwise*/
1753                         /* application thinks that a new device got paired */
1754                         if (_bt_adapter_get_status() != BT_ACTIVATED) {
1755                                 BT_DBG("BT is not activated, so ignore this");
1756                                 return;
1757                         }
1758
1759                         if (_bt_is_device_creating() == TRUE) {
1760                                 BT_DBG("Try to Pair by me");
1761                                 return;
1762                         }
1763
1764                         address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1765
1766                         _bt_convert_device_path_to_address(path, address);
1767
1768                         remote_dev_info = _bt_get_remote_device_info(address);
1769                         if (remote_dev_info == NULL) {
1770                                 g_free(address);
1771                                 return;
1772                         }
1773
1774                         _bt_send_event(BT_ADAPTER_EVENT,
1775                                 BLUETOOTH_EVENT_BONDING_FINISHED,
1776                                 DBUS_TYPE_INT32, &result,
1777                                 DBUS_TYPE_STRING, &address,
1778                                 DBUS_TYPE_UINT32, &remote_dev_info->class,
1779                                 DBUS_TYPE_INT16, &remote_dev_info->rssi,
1780                                 DBUS_TYPE_STRING, &remote_dev_info->name,
1781                                 DBUS_TYPE_BOOLEAN, &remote_dev_info->paired,
1782                                 DBUS_TYPE_BOOLEAN, &remote_dev_info->connected,
1783                                 DBUS_TYPE_BOOLEAN, &remote_dev_info->trust,
1784                                 DBUS_TYPE_ARRAY, DBUS_TYPE_STRING,
1785                                 &remote_dev_info->uuids, remote_dev_info->uuid_count,
1786                                 DBUS_TYPE_INT16, &remote_dev_info->manufacturer_data_len,
1787                                 DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE,
1788                                 &remote_dev_info->manufacturer_data, remote_dev_info->manufacturer_data_len,
1789                                 DBUS_TYPE_INVALID);
1790
1791                         _bt_free_device_info(remote_dev_info);
1792                         g_free(address);
1793
1794                 } else if (strcasecmp(property, "UUIDs") == 0) {
1795                         /* Once we get the updated uuid information after
1796                          * reverse service search, update it to application */
1797
1798                         bt_remote_dev_info_t *remote_dev_info;
1799
1800                         ret_if(_bt_is_device_creating() == TRUE);
1801
1802                         address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1803
1804                         _bt_convert_device_path_to_address(path, address);
1805
1806                         remote_dev_info = _bt_get_remote_device_info(address);
1807                         if (remote_dev_info == NULL) {
1808                                 g_free(address);
1809                                 return;
1810                         }
1811
1812                         BT_DBG("UUID's count = %d", remote_dev_info->uuid_count);
1813                         if (remote_dev_info->paired && remote_dev_info->uuid_count)
1814                                 _bt_send_event(BT_ADAPTER_EVENT,
1815                                         BLUETOOTH_EVENT_SERVICE_SEARCHED,
1816                                         DBUS_TYPE_INT32, &result,
1817                                         DBUS_TYPE_STRING, &address,
1818                                         DBUS_TYPE_UINT32, &remote_dev_info->class,
1819                                         DBUS_TYPE_INT16, &remote_dev_info->rssi,
1820                                         DBUS_TYPE_STRING, &remote_dev_info->name,
1821                                         DBUS_TYPE_BOOLEAN, &remote_dev_info->paired,
1822                                         DBUS_TYPE_BOOLEAN, &remote_dev_info->connected,
1823                                         DBUS_TYPE_BOOLEAN, &remote_dev_info->trust,
1824                                         DBUS_TYPE_ARRAY, DBUS_TYPE_STRING,
1825                                         &remote_dev_info->uuids, remote_dev_info->uuid_count,
1826                                         DBUS_TYPE_INVALID);
1827
1828                         _bt_free_device_info(remote_dev_info);
1829                         g_free(address);
1830                 }
1831         } else if (strcasecmp(member, "DeviceConnected") == 0) {
1832                 unsigned char addr_type = 0;
1833
1834                 dbus_message_iter_init(msg, &item_iter);
1835                 dbus_message_iter_get_basic(&item_iter, &addr_type);
1836
1837                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1838
1839                 _bt_convert_device_path_to_address(path, address);
1840
1841                 BT_INFO("Address : %s Type : %d", address, addr_type);
1842                 BT_ERR_C("Connected [%s]", !addr_type ? "BREDR" : "LE");
1843
1844                 _bt_logging_connection(TRUE, addr_type);
1845 //              journal_bt_connected();
1846
1847                 /*Send event to application*/
1848                 _bt_send_event(BT_DEVICE_EVENT,
1849                                         BLUETOOTH_EVENT_DEVICE_CONNECTED,
1850                                         DBUS_TYPE_INT32, &result,
1851                                         DBUS_TYPE_STRING, &address,
1852                                         DBUS_TYPE_BYTE, &addr_type,
1853                                         DBUS_TYPE_INVALID);
1854
1855                 g_free(address);
1856         } else if (strcasecmp(member, "Disconnected") == 0) {
1857                 unsigned char disc_reason = 0;
1858                 unsigned char addr_type = 0;
1859                 gboolean sending = FALSE;
1860
1861                 if (!dbus_message_get_args(msg, NULL,
1862                                 DBUS_TYPE_BYTE, &addr_type,
1863                                 DBUS_TYPE_BYTE, &disc_reason,
1864                                 DBUS_TYPE_INVALID))
1865                         return;
1866
1867                 result = disc_reason;
1868
1869                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1870
1871                 _bt_convert_device_path_to_address(path, address);
1872 //              journal_bt_disconnected();
1873
1874                 /* 0x00 BDADDR_BRDER
1875                       0x01 BDADDR_LE_PUBLIC
1876                       0x02 BDADDR_LE_RANDOM */
1877                 BT_INFO("Address : %s Type : %d", address, addr_type);
1878                 BT_ERR_C("Disconnected [%s] [%d : %s]", !addr_type ? "BREDR" : "LE",
1879                                 disc_reason, _bt_convert_disc_reason_to_string(disc_reason));
1880
1881                 _bt_headset_set_local_connection(FALSE);
1882                 _bt_logging_connection(FALSE, addr_type);
1883
1884                 /*Check for any OPP transfer on the device and cancel
1885                  * the transfer
1886                  */
1887                 _bt_obex_check_pending_transfer(address);
1888                 _bt_opp_client_is_sending(&sending);
1889                 if(sending == TRUE)
1890                         _bt_opp_client_check_pending_transfer(address);
1891
1892                 _bt_send_event(BT_DEVICE_EVENT,
1893                                         BLUETOOTH_EVENT_DEVICE_DISCONNECTED,
1894                                         DBUS_TYPE_INT32, &result,
1895                                         DBUS_TYPE_STRING, &address,
1896                                         DBUS_TYPE_BYTE, &addr_type,
1897                                         DBUS_TYPE_INVALID);
1898
1899                 g_free(address);
1900         } else if (strcasecmp(member, "ProfileStateChanged") == 0) {
1901                 int state = 0;
1902                 char *profile_uuid = NULL;
1903                 bt_headset_wait_t *wait_list;
1904
1905                 if (!dbus_message_get_args(msg, NULL,
1906                                 DBUS_TYPE_STRING, &profile_uuid,
1907                                 DBUS_TYPE_INT32, &state,
1908                                 DBUS_TYPE_INVALID)) {
1909                         return;
1910                 }
1911                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1912
1913                 _bt_convert_device_path_to_address(path, address);
1914
1915                 BT_DBG("Address: %s", address);
1916                 BT_DBG("Profile UUID: %s", profile_uuid);
1917                 BT_DBG("State: %d", state);
1918
1919                 if ((strcmp(profile_uuid, A2DP_SINK_UUID) == 0)  &&
1920                         (state == BT_PROFILE_STATE_CONNECTED)) {
1921
1922                         int event = BLUETOOTH_EVENT_AV_CONNECTED;
1923                         char connected_address[BT_ADDRESS_STRING_SIZE + 1];
1924                         bluetooth_device_address_t device_address;
1925                         gboolean connected;
1926                         bt_headset_wait_t *wait_list;
1927
1928                         __bt_set_device_values(TRUE,
1929                                 VCONFKEY_BT_DEVICE_A2DP_HEADSET_CONNECTED);
1930
1931                         __bt_connection_manager_set_state(address, event);
1932
1933                         if (_bt_headset_get_local_connection() == FALSE)
1934                                 _bt_start_timer_for_connection(address, BT_AUDIO_HSP);
1935                         else {
1936                                 /* Connection Started from local device therefore no need to
1937                                  * intiate connection for pending profile */
1938                                 _bt_headset_set_local_connection(FALSE);
1939                         }
1940
1941                         _bt_send_event(BT_HEADSET_EVENT, event,
1942                                 DBUS_TYPE_INT32, &result,
1943                                 DBUS_TYPE_STRING, &address,
1944                                 DBUS_TYPE_INVALID);
1945
1946                         connected = _bt_is_headset_type_connected(BT_AUDIO_A2DP,
1947                                                 connected_address);
1948                         if (connected) {
1949                                 if (g_strcmp0(connected_address, address) != 0) {
1950                                         _bt_convert_addr_string_to_type(
1951                                                 device_address.addr,
1952                                                 connected_address);
1953                                         _bt_audio_disconnect(0, BT_AUDIO_A2DP,
1954                                                 &device_address, NULL);
1955                                 }
1956                         }
1957
1958                         _bt_add_headset_to_list(BT_AUDIO_A2DP,
1959                                                 BT_STATE_CONNECTED, address);
1960
1961                         wait_list = _bt_get_audio_wait_data();
1962                         if (wait_list != NULL &&
1963                                 (g_strcmp0(wait_list->address, address) == 0))
1964                                 _bt_rel_wait_data();
1965
1966                 } else if ((strcmp(profile_uuid, A2DP_SINK_UUID) == 0)  &&
1967                         (state == BT_PROFILE_STATE_DISCONNECTED)) {
1968
1969                         int event = BLUETOOTH_EVENT_AV_DISCONNECTED;
1970
1971                         if (!_bt_is_service_connected(address, BT_AUDIO_A2DP)) {
1972                                 g_free(address);
1973                                 return;
1974                         }
1975
1976                         __bt_set_device_values(FALSE,
1977                                 VCONFKEY_BT_DEVICE_A2DP_HEADSET_CONNECTED);
1978
1979                         __bt_connection_manager_set_state(address, event);
1980
1981                         _bt_send_event(BT_HEADSET_EVENT, event,
1982                                 DBUS_TYPE_INT32, &result,
1983                                 DBUS_TYPE_STRING, &address,
1984                                 DBUS_TYPE_INVALID);
1985
1986                         /* Remove data from the connected list */
1987                         _bt_remove_headset_from_list(BT_AUDIO_A2DP, address);
1988                         wait_list = _bt_get_audio_wait_data();
1989
1990                         if (wait_list == NULL) {
1991                                 g_free(address);
1992                                 return;
1993                         }
1994
1995                         if (((wait_list->type == BT_AUDIO_ALL) &&
1996                                 (wait_list->ag_flag == TRUE)) ||
1997                                 (wait_list->type == BT_AUDIO_A2DP) ||
1998                                 (wait_list->disconnection_type == BT_AUDIO_A2DP)) {
1999                                 bluetooth_device_address_t device_address;
2000                                 _bt_convert_addr_string_to_type(
2001                                                         device_address.addr,
2002                                                         wait_list->address);
2003
2004                                 _bt_audio_connect(wait_list->req_id,
2005                                                         wait_list->type,
2006                                                         &device_address,
2007                                                         wait_list->out_param1);
2008                         }
2009                 } else if (strcmp(profile_uuid, AVRCP_TARGET_UUID) == 0) {
2010
2011                         if (state == BT_PROFILE_STATE_CONNECTED) {
2012                                 int event = BLUETOOTH_EVENT_AVRCP_CONTROL_CONNECTED;
2013                                 char connected_address[BT_ADDRESS_STRING_SIZE + 1];
2014                                 bluetooth_device_address_t device_address;
2015                                 gboolean connected;
2016
2017                                 _bt_send_event(BT_AVRCP_CONTROL_EVENT, event,
2018                                         DBUS_TYPE_INT32, &result,
2019                                         DBUS_TYPE_STRING, &address,
2020                                         DBUS_TYPE_INVALID);
2021                                 connected = _bt_is_headset_type_connected(
2022                                                         BT_AVRCP,
2023                                                         connected_address);
2024                                 if (connected) {
2025                                         if (g_strcmp0(connected_address,
2026                                                                 address) != 0) {
2027                                                 _bt_convert_addr_string_to_type(
2028                                                         device_address.addr,
2029                                                         connected_address);
2030                                                 _bt_audio_disconnect(0,
2031                                                         BT_AVRCP,
2032                                                         &device_address, NULL);
2033                                         }
2034                                 }
2035                                 BT_DBG("device Path: %s", path);
2036                                 _bt_add_headset_to_list(BT_AVRCP,
2037                                                 BT_STATE_CONNECTED, address);
2038                         } else if (state == BT_PROFILE_STATE_DISCONNECTED) {
2039                                 int event = BLUETOOTH_EVENT_AVRCP_CONTROL_DISCONNECTED;
2040
2041                                 _bt_send_event(BT_AVRCP_CONTROL_EVENT, event,
2042                                         DBUS_TYPE_INT32, &result,
2043                                         DBUS_TYPE_STRING, &address,
2044                                         DBUS_TYPE_INVALID);
2045
2046                                 /* Remove data from the connected list */
2047                                 _bt_remove_headset_from_list(BT_AVRCP, address);
2048                         }
2049                 } else if ((strcmp(profile_uuid, HID_UUID) == 0) &&
2050                         ((state == BT_PROFILE_STATE_CONNECTED) ||
2051                                 (state == BT_PROFILE_STATE_DISCONNECTED))) {
2052                         int event;
2053                         if (state == BT_PROFILE_STATE_CONNECTED)
2054                                 event = BLUETOOTH_HID_CONNECTED;
2055                         else
2056                                 event = BLUETOOTH_HID_DISCONNECTED;
2057
2058                         _bt_send_event(BT_HID_EVENT, event,
2059                                 DBUS_TYPE_INT32, &result,
2060                                 DBUS_TYPE_STRING, &address,
2061                                 DBUS_TYPE_INVALID);
2062                 }
2063                 g_free(address);
2064         } else if (strcasecmp(member, "AdvReport") == 0) {
2065
2066                 bt_remote_le_dev_info_t *le_dev_info = NULL;
2067                 char *buffer = NULL;
2068                 int buffer_len = 0;
2069                 bt_le_adv_info_t *adv_info = NULL;
2070
2071                 ret_if(_bt_is_le_discovering() == FALSE);
2072
2073                 le_dev_info = g_malloc0(sizeof(bt_remote_le_dev_info_t));
2074
2075                 if (!dbus_message_get_args(msg, NULL,
2076                                 DBUS_TYPE_STRING, &le_dev_info->address,
2077                                 DBUS_TYPE_BYTE, &le_dev_info->addr_type,
2078                                 DBUS_TYPE_BYTE, &le_dev_info->adv_type,
2079                                 DBUS_TYPE_INT32, &le_dev_info->rssi,
2080                                 DBUS_TYPE_INT32, &le_dev_info->adv_data_len,
2081                                 DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &buffer, &buffer_len,
2082                                 DBUS_TYPE_INVALID)) {
2083                         g_free(le_dev_info);
2084                         return;
2085                 }
2086
2087                 le_dev_info->adv_data = g_memdup(buffer, buffer_len);
2088
2089                 if (_bt_get_le_discovery_type() == BT_LE_PASSIVE_SCAN) {
2090                                 int len = 0;
2091                                 _bt_send_event(BT_LE_ADAPTER_EVENT,
2092                                                 BLUETOOTH_EVENT_REMOTE_LE_DEVICE_FOUND,
2093                                                 DBUS_TYPE_INT32, &result,
2094                                                 DBUS_TYPE_STRING, &le_dev_info->address,
2095                                                 DBUS_TYPE_INT16, &le_dev_info->addr_type,
2096                                                 DBUS_TYPE_INT16, &le_dev_info->rssi,
2097                                                 DBUS_TYPE_INT16, &le_dev_info->adv_data_len,
2098                                                 DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE,
2099                                                 &le_dev_info->adv_data, le_dev_info->adv_data_len,
2100                                                 DBUS_TYPE_INT16, &len,
2101                                                 DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE,
2102                                                 &le_dev_info->adv_data, len,
2103                                                 DBUS_TYPE_INVALID);
2104                         _bt_free_le_device_info(le_dev_info);
2105                         return;
2106                 }
2107
2108                 if (le_dev_info->adv_type != BT_LE_ADV_SCAN_RSP) {       /* ADV_IND */
2109                         adv_info = g_malloc0(sizeof(bt_le_adv_info_t));
2110                         adv_info->addr = g_strdup(le_dev_info->address);
2111                         adv_info->data_len = le_dev_info->adv_data_len;
2112                         adv_info->data = g_malloc0(le_dev_info->adv_data_len);
2113                         memcpy(adv_info->data, le_dev_info->adv_data,
2114                                         le_dev_info->adv_data_len);
2115
2116                         __bt_add_adv_ind_info(adv_info);
2117
2118                 } else {     /* SCAN_RSP */
2119                         adv_info = __bt_get_adv_ind_info(le_dev_info->address);
2120                         if (adv_info) {
2121                                 _bt_send_event(BT_LE_ADAPTER_EVENT,
2122                                                 BLUETOOTH_EVENT_REMOTE_LE_DEVICE_FOUND,
2123                                                 DBUS_TYPE_INT32, &result,
2124                                                 DBUS_TYPE_STRING, &le_dev_info->address,
2125                                                 DBUS_TYPE_INT16, &le_dev_info->addr_type,
2126                                                 DBUS_TYPE_INT16, &le_dev_info->rssi,
2127                                                 DBUS_TYPE_INT16, &adv_info->data_len,
2128                                                 DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE,
2129                                                 &adv_info->data, adv_info->data_len,
2130                                                 DBUS_TYPE_INT16, &le_dev_info->adv_data_len,
2131                                                 DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE,
2132                                                 &le_dev_info->adv_data, le_dev_info->adv_data_len,
2133                                                 DBUS_TYPE_INVALID);
2134                                 __bt_del_adv_ind_info(le_dev_info->address);
2135                         }
2136                 }
2137                 _bt_free_le_device_info(le_dev_info);
2138         }
2139 }
2140
2141 void __bt_set_audio_values(gboolean connected, char *address)
2142 {
2143         char *name = NULL;
2144         int bt_device_state = VCONFKEY_BT_DEVICE_NONE;
2145
2146         /*  Set the headset name */
2147         if (connected == TRUE) {
2148                 name = __bt_get_headset_name(address);
2149         } else {
2150                 name = g_strdup("");
2151         }
2152
2153         if (vconf_set_str(VCONFKEY_BT_HEADSET_NAME,
2154                                         name) != 0) {
2155                 BT_ERR("vconf_set_str failed");
2156         }
2157
2158         g_free(name);
2159
2160         /*  Set the headset state */
2161         if (vconf_get_int(VCONFKEY_BT_DEVICE,
2162                                 &bt_device_state) != 0) {
2163                 BT_ERR("vconf_get_str failed");
2164         }
2165
2166 #ifdef TIZEN_SUPPORT_DUAL_HF
2167         if ((connected == TRUE) &&
2168                 (FALSE == __bt_is_companion_device(address))) {
2169                 bt_device_state |= VCONFKEY_BT_DEVICE_HEADSET_CONNECTED;
2170         } else if ((bt_device_state & VCONFKEY_BT_DEVICE_HEADSET_CONNECTED) &&
2171                         (FALSE == __bt_is_companion_device(address))) {
2172                 bt_device_state ^= VCONFKEY_BT_DEVICE_HEADSET_CONNECTED;
2173         }
2174 #else
2175         if (connected == TRUE) {
2176                 bt_device_state |= VCONFKEY_BT_DEVICE_HEADSET_CONNECTED;
2177         } else if (bt_device_state & VCONFKEY_BT_DEVICE_HEADSET_CONNECTED) {
2178                 bt_device_state ^= VCONFKEY_BT_DEVICE_HEADSET_CONNECTED;
2179         }
2180 #endif
2181
2182         if (vconf_set_int(VCONFKEY_BT_DEVICE,
2183                                 bt_device_state) != 0) {
2184                 BT_ERR("vconf_set_int failed");
2185         }
2186 }
2187
2188 void _bt_handle_headset_event(DBusMessage *msg)
2189 {
2190         int result = BLUETOOTH_ERROR_NONE;
2191         DBusMessageIter item_iter;
2192         DBusMessageIter value_iter;
2193         gboolean property_flag = FALSE;
2194         const char *member = dbus_message_get_member(msg);
2195         const char *path = dbus_message_get_path(msg);
2196         const char *property = NULL;
2197
2198         ret_if(member == NULL);
2199
2200         dbus_message_iter_init(msg, &item_iter);
2201
2202         if (dbus_message_iter_get_arg_type(&item_iter)
2203                                         != DBUS_TYPE_STRING) {
2204                 BT_ERR("This is bad format dbus");
2205                 return;
2206         }
2207
2208         dbus_message_iter_get_basic(&item_iter, &property);
2209
2210         ret_if(property == NULL);
2211
2212         BT_DBG("Property = %s \n", property);
2213
2214         /* We allow only 1 headset connection (HSP or HFP)*/
2215         if (strcasecmp(property, "Connected") == 0) {
2216                 int event = BLUETOOTH_EVENT_NONE;
2217                 bt_headset_wait_t *wait_list;
2218                 char *address;
2219
2220                 dbus_message_iter_next(&item_iter);
2221                 dbus_message_iter_recurse(&item_iter, &value_iter);
2222                 dbus_message_iter_get_basic(&value_iter, &property_flag);
2223
2224                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
2225
2226                 _bt_convert_device_path_to_address(path, address);
2227
2228                 if (property_flag == TRUE) {
2229                         event = BLUETOOTH_EVENT_AG_CONNECTED;
2230                         if (_bt_headset_get_local_connection() == FALSE)
2231                                 _bt_start_timer_for_connection(address, BT_AUDIO_A2DP);
2232                         else
2233                                 _bt_headset_set_local_connection(FALSE);
2234                 } else {
2235                         int previous_state;
2236
2237                         event = BLUETOOTH_EVENT_AG_DISCONNECTED;
2238
2239                         previous_state = _bt_get_device_state_from_list(BT_AUDIO_HSP, address);
2240                         if (previous_state == BT_STATE_DISCONNECTING)
2241                                 _bt_send_hf_local_term_event(address);
2242                 }
2243                 /* Set the State machine here */
2244                 __bt_connection_manager_set_state(address, event);
2245                 __bt_set_audio_values(property_flag, address);
2246
2247                 _bt_send_event(BT_HEADSET_EVENT, event,
2248                         DBUS_TYPE_INT32, &result,
2249                         DBUS_TYPE_STRING, &address,
2250                         DBUS_TYPE_INVALID);
2251
2252                 if (event == BLUETOOTH_EVENT_AG_DISCONNECTED) {
2253                         /* Remove data from the connected list */
2254                         _bt_remove_headset_from_list(BT_AUDIO_HSP, address);
2255
2256                         wait_list = _bt_get_audio_wait_data();
2257                         if (wait_list == NULL) {
2258                                 g_free(address);
2259                                 return;
2260                         }
2261
2262                         bluetooth_device_address_t device_address;
2263
2264                         _bt_set_audio_wait_data_flag(TRUE);
2265
2266                         _bt_convert_addr_string_to_type(device_address.addr,
2267                                                         wait_list->address);
2268                         _bt_audio_connect(wait_list->req_id, wait_list->type,
2269                                         &device_address, wait_list->out_param1);
2270                         _bt_rel_wait_data();
2271                 } else if (event == BLUETOOTH_EVENT_AG_CONNECTED) {
2272                         /* Add data to the connected list */
2273                         _bt_add_headset_to_list(BT_AUDIO_HSP,
2274                                                 BT_STATE_CONNECTED, address);
2275
2276                         wait_list = _bt_get_audio_wait_data();
2277                         if (wait_list != NULL &&
2278                                 (g_strcmp0(wait_list->address, address) == 0))
2279                         _bt_rel_wait_data();
2280
2281                         BT_INFO("Check A2DP pending connect");
2282                         _bt_audio_check_pending_connect();
2283                 }
2284                 g_free(address);
2285         } else if (strcasecmp(property, "State") == 0) {
2286                 char *state = NULL;
2287
2288                 dbus_message_iter_next(&item_iter);
2289                 dbus_message_iter_recurse(&item_iter, &value_iter);
2290                 dbus_message_iter_get_basic(&value_iter, &state);
2291
2292                 /* This code assumes we support only 1 headset connection */
2293                 /* Need to use the headset list, if we support multi-headsets */
2294                 if (strcasecmp(state, "Playing") == 0) {
2295                         BT_DBG("Playing: Sco Connected");
2296                 } else if (strcasecmp(state, "connected") == 0 ||
2297                                 strcasecmp(state, "disconnected") == 0) {
2298                         BT_DBG("connected/disconnected: Sco Disconnected");
2299                 } else {
2300                         BT_ERR("Not handled state - %s", state);
2301                         return;
2302                 }
2303         } else if (strcasecmp(property, "SpeakerGain") == 0) {
2304                 guint16 spkr_gain;
2305                 char *address;
2306
2307                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
2308
2309                 _bt_convert_device_path_to_address(path, address);
2310
2311                 dbus_message_iter_next(&item_iter);
2312                 dbus_message_iter_recurse(&item_iter, &value_iter);
2313                 dbus_message_iter_get_basic(&value_iter, &spkr_gain);
2314
2315                 _bt_send_event(BT_HEADSET_EVENT, BLUETOOTH_EVENT_AG_SPEAKER_GAIN,
2316                         DBUS_TYPE_INT32, &result,
2317                         DBUS_TYPE_STRING, &address,
2318                         DBUS_TYPE_UINT16, &spkr_gain,
2319                         DBUS_TYPE_INVALID);
2320
2321                 g_free(address);
2322         } else if (strcasecmp(property, "MicrophoneGain") == 0) {
2323                 guint16 mic_gain;
2324                 char *address;
2325
2326                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
2327
2328                 _bt_convert_device_path_to_address(path, address);
2329
2330                 dbus_message_iter_next(&item_iter);
2331                 dbus_message_iter_recurse(&item_iter, &value_iter);
2332                 dbus_message_iter_get_basic(&value_iter, &mic_gain);
2333
2334                 _bt_send_event(BT_HEADSET_EVENT, BLUETOOTH_EVENT_AG_MIC_GAIN,
2335                         DBUS_TYPE_INT32, &result,
2336                         DBUS_TYPE_STRING, &address,
2337                         DBUS_TYPE_UINT16, &mic_gain,
2338                         DBUS_TYPE_INVALID);
2339
2340                 g_free(address);
2341         }
2342 }
2343
2344 void _bt_handle_sink_event(DBusMessage *msg)
2345 {
2346         int result = BLUETOOTH_ERROR_NONE;
2347         DBusMessageIter item_iter;
2348         DBusMessageIter value_iter;
2349         const char *member = dbus_message_get_member(msg);
2350         const char *path = dbus_message_get_path(msg);
2351         const char *property = NULL;
2352
2353         bt_headset_wait_t *wait_list;
2354
2355         ret_if(member == NULL);
2356
2357         dbus_message_iter_init(msg, &item_iter);
2358
2359         if (dbus_message_iter_get_arg_type(&item_iter)
2360                                         != DBUS_TYPE_STRING) {
2361                 BT_ERR("This is bad format dbus");
2362                 return;
2363         }
2364
2365         dbus_message_iter_get_basic(&item_iter, &property);
2366
2367         ret_if(property == NULL);
2368
2369         BT_DBG("Property: %s", property);
2370
2371         if (strcasecmp(property, "State") == 0) {
2372
2373                 const char *value;
2374
2375                 dbus_message_iter_next(&item_iter);
2376                 dbus_message_iter_recurse(&item_iter, &value_iter);
2377                 dbus_message_iter_get_basic(&value_iter, &value);
2378
2379                 BT_DBG("value: %s", value);
2380
2381                 if (g_strcmp0(value, "disconnected") == 0) {
2382                         char *address;
2383
2384                         address = g_malloc0(BT_ADDRESS_STRING_SIZE);
2385
2386                         _bt_convert_device_path_to_address(path, address);
2387
2388                         __bt_set_device_values(FALSE,
2389                                 VCONFKEY_BT_DEVICE_A2DP_HEADSET_CONNECTED);
2390
2391                         _bt_send_event(BT_HEADSET_EVENT,
2392                                 BLUETOOTH_EVENT_AV_DISCONNECTED,
2393                                 DBUS_TYPE_INT32, &result,
2394                                 DBUS_TYPE_STRING, &address,
2395                                 DBUS_TYPE_INVALID);
2396
2397                         /* Remove data from the connected list */
2398                         _bt_remove_headset_from_list(BT_AUDIO_A2DP, address);
2399                         wait_list = _bt_get_audio_wait_data();
2400                         if (wait_list == NULL) {
2401                                 g_free(address);
2402                                 return;
2403                         }
2404
2405                         if (((wait_list->type == BT_AUDIO_ALL) &&
2406                                 (wait_list->ag_flag == TRUE)) ||
2407                                 (wait_list->type == BT_AUDIO_A2DP) ||
2408                                 (wait_list->disconnection_type == BT_AUDIO_A2DP)) {
2409                                 bluetooth_device_address_t device_address;
2410                                 _bt_convert_addr_string_to_type(
2411                                                         device_address.addr,
2412                                                         wait_list->address);
2413
2414                                 _bt_audio_connect(wait_list->req_id,
2415                                                         wait_list->type,
2416                                                         &device_address,
2417                                                         wait_list->out_param1);
2418                         }
2419                         g_free(address);
2420                 }else if (strcasecmp(value, "Connected") == 0) {
2421                         char *address;
2422                         char connected_address[BT_ADDRESS_STRING_SIZE + 1];
2423                         bluetooth_device_address_t device_address;
2424                         gboolean connected;
2425
2426                         address = g_malloc0(BT_ADDRESS_STRING_SIZE);
2427
2428                         _bt_convert_device_path_to_address(path, address);
2429
2430                         __bt_set_device_values(TRUE,
2431                                         VCONFKEY_BT_DEVICE_A2DP_HEADSET_CONNECTED);
2432
2433                         _bt_send_event(BT_HEADSET_EVENT,
2434                                 BLUETOOTH_EVENT_AV_CONNECTED,
2435                                 DBUS_TYPE_INT32, &result,
2436                                 DBUS_TYPE_STRING, &address,
2437                                 DBUS_TYPE_INVALID);
2438
2439                         /* Check for existing Media device to disconnect */
2440                         connected = _bt_is_headset_type_connected(BT_AUDIO_A2DP,
2441                                                                 connected_address);
2442                         if (connected) {
2443                                 /* Match connected device address */
2444                                 if (g_strcmp0(connected_address, address) != 0) {
2445                                         /* Convert BD adress from string type */
2446                                         _bt_convert_addr_string_to_type(
2447                                                         device_address.addr,
2448                                                         connected_address);
2449                                         _bt_audio_disconnect(0, BT_AUDIO_A2DP,
2450                                                         &device_address, NULL);
2451                                 }
2452                         }
2453
2454                         /* Add data to the connected list */
2455                         _bt_add_headset_to_list(BT_AUDIO_A2DP,
2456                                         BT_STATE_CONNECTED, address);
2457
2458                         g_free(address);
2459                 }
2460         }
2461 }
2462
2463 void _bt_handle_agent_event(DBusMessage *msg)
2464 {
2465         const char *member = dbus_message_get_member(msg);
2466         int result = BLUETOOTH_ERROR_NONE;
2467         char *address = NULL;
2468         char *name = NULL;
2469         char *uuid = NULL;
2470
2471         ret_if(member == NULL);
2472
2473         if (strcasecmp(member, "ObexAuthorize") == 0) {
2474                 __bt_get_agent_signal_info(msg, &address, &name, &uuid);
2475
2476                 _bt_send_event(BT_OPP_SERVER_EVENT,
2477                         BLUETOOTH_EVENT_OBEX_SERVER_CONNECTION_AUTHORIZE,
2478                         DBUS_TYPE_INT32, &result,
2479                         DBUS_TYPE_STRING, &address,
2480                         DBUS_TYPE_STRING, &name,
2481                         DBUS_TYPE_INVALID);
2482         } else if (strcasecmp(member, "RfcommAuthorize") == 0) {
2483                 bt_rfcomm_server_info_t *server_info;
2484
2485                 __bt_get_agent_signal_info(msg, &address, &name, &uuid);
2486
2487                 server_info = _bt_rfcomm_get_server_info_using_uuid(uuid);
2488                 ret_if(server_info == NULL);
2489                 ret_if(server_info->server_type != BT_CUSTOM_SERVER);
2490
2491                 _bt_send_event(BT_RFCOMM_SERVER_EVENT,
2492                         BLUETOOTH_EVENT_RFCOMM_AUTHORIZE,
2493                         DBUS_TYPE_INT32, &result,
2494                         DBUS_TYPE_STRING, &address,
2495                         DBUS_TYPE_STRING, &uuid,
2496                         DBUS_TYPE_STRING, &name,
2497                         DBUS_TYPE_INT16, &server_info->control_fd,
2498                         DBUS_TYPE_INVALID);
2499         }
2500 }
2501
2502 static int __bt_get_object_path(DBusMessage *msg, char **path)
2503 {
2504         DBusMessageIter item_iter;
2505
2506         dbus_message_iter_init(msg, &item_iter);
2507
2508         if (dbus_message_iter_get_arg_type(&item_iter)
2509                                         != DBUS_TYPE_OBJECT_PATH) {
2510                 BT_ERR("This is bad format dbus");
2511                 return BLUETOOTH_ERROR_INTERNAL;
2512         }
2513
2514         dbus_message_iter_get_basic(&item_iter, path);
2515
2516         if (*path == NULL)
2517                 return BLUETOOTH_ERROR_INTERNAL;
2518
2519         return BLUETOOTH_ERROR_NONE;
2520 }
2521
2522 static int __bt_parse_event(DBusMessage *msg)
2523 {
2524         DBusMessageIter msg_iter;
2525         DBusMessageIter value_iter;
2526
2527         retv_if(dbus_message_iter_init(msg, &msg_iter) == FALSE, 0);
2528
2529         /* object array (oa) */
2530         retv_if(dbus_message_iter_next(&msg_iter) == FALSE, 0);
2531         retv_if(dbus_message_iter_get_arg_type(&msg_iter) !=
2532                                         DBUS_TYPE_ARRAY, 0);
2533
2534         dbus_message_iter_recurse(&msg_iter, &value_iter);
2535
2536         /* string array (sa) */
2537         while (dbus_message_iter_get_arg_type(&value_iter) ==
2538                                         DBUS_TYPE_DICT_ENTRY) {
2539                 char *interface_name = NULL;
2540                 DBusMessageIter interface_iter;
2541
2542                 dbus_message_iter_recurse(&value_iter, &interface_iter);
2543
2544                 retv_if(dbus_message_iter_get_arg_type(&interface_iter) !=
2545                                                 DBUS_TYPE_STRING, 0);
2546
2547                 dbus_message_iter_get_basic(&interface_iter,
2548                                                 &interface_name);
2549
2550                 retv_if(dbus_message_iter_next(&interface_iter) == FALSE,
2551                                                                 0);
2552
2553                 retv_if(dbus_message_iter_get_arg_type(&interface_iter) !=
2554                                         DBUS_TYPE_ARRAY, 0);
2555
2556                 BT_DBG("interface: %s", interface_name);
2557
2558                 if (g_strcmp0(interface_name,
2559                                 BT_DEVICE_INTERFACE) == 0) {
2560                         return BT_DEVICE_EVENT;
2561                 } else if (g_strcmp0(interface_name,
2562                                 BT_MEDIATRANSPORT_INTERFACE) == 0) {
2563                         return BT_MEDIA_TRANSFER_EVENT;
2564                 } else if (g_strcmp0(interface_name,
2565                                 BT_PLAYER_CONTROL_INTERFACE) == 0) {
2566                         return BT_AVRCP_CONTROL_EVENT;
2567                 }
2568                 dbus_message_iter_next(&value_iter);
2569         }
2570
2571         return 0;
2572 }
2573
2574 static int __bt_parse_remove_event(DBusMessage *msg)
2575 {
2576         DBusMessageIter msg_iter;
2577         DBusMessageIter value_iter;
2578
2579         retv_if(dbus_message_iter_init(msg, &msg_iter) ==
2580                                         FALSE, 0);
2581
2582         retv_if(dbus_message_iter_next(&msg_iter) == FALSE,
2583                                                 0);
2584         retv_if(dbus_message_iter_get_arg_type(&msg_iter) !=
2585                                         DBUS_TYPE_ARRAY, 0);
2586
2587         dbus_message_iter_recurse(&msg_iter, &value_iter);
2588
2589         while (dbus_message_iter_get_arg_type(&value_iter)
2590                                         != DBUS_TYPE_INVALID) {
2591                 char *key;
2592
2593                 dbus_message_iter_get_basic(&value_iter, &key);
2594
2595                 if (key == NULL) {
2596                         dbus_message_iter_next(&value_iter);
2597                         continue;
2598                 }
2599
2600                 BT_DBG("key = %s", key);
2601
2602                 if (g_strcmp0(key, BT_MEDIATRANSPORT_INTERFACE) == 0) {
2603                         return BT_MEDIA_TRANSFER_EVENT;
2604                 } else if (g_strcmp0(key, BT_DEVICE_INTERFACE) == 0) {
2605                         return BT_DEVICE_EVENT;
2606                 } else if (g_strcmp0(key, BT_PLAYER_CONTROL_INTERFACE) == 0) {
2607                         return BT_AVRCP_CONTROL_EVENT;
2608                 }
2609                 dbus_message_iter_next(&value_iter);
2610         }
2611
2612         return 0;
2613 }
2614
2615 static void __bt_devices_list_free(void)
2616 {
2617         bt_cache_info_t *cache_info;
2618         GList *node;
2619
2620         node = g_list_first(p_cache_list);
2621
2622         while (node != NULL){
2623                 cache_info = (bt_cache_info_t *)node->data;
2624
2625                 p_cache_list = g_list_remove(p_cache_list, cache_info);
2626                 __bt_free_cache_info(cache_info);
2627
2628                 node = g_list_next(node);
2629         }
2630 }
2631
2632 static DBusHandlerResult __bt_manager_event_filter(DBusConnection *conn,
2633                                            DBusMessage *msg, void *data)
2634 {
2635         const char *member = dbus_message_get_member(msg);
2636         bt_event_type_t bt_event;
2637         int result = BLUETOOTH_ERROR_NONE;
2638
2639         if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL)
2640                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2641
2642         retv_if(member == NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
2643
2644         if (strcasecmp(member, "InterfacesAdded") == 0) {
2645                 char *object_path = NULL;
2646
2647                 BT_DBG("InterfacesAdded");
2648
2649                 if (__bt_get_object_path(msg, &object_path)) {
2650                         BT_ERR("Fail to get the path");
2651                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2652                 }
2653
2654                 if (strcasecmp(object_path, BT_BLUEZ_HCI_PATH) == 0) {
2655                         _bt_handle_adapter_added();
2656                 } else {
2657                         bt_event = __bt_parse_event(msg);
2658                         if (bt_event == BT_DEVICE_EVENT) {
2659                                 bt_cache_info_t *cache_info;
2660                                 bt_remote_dev_info_t *dev_info;
2661
2662                                 retv_if(_bt_is_discovering() == FALSE &&
2663                                                 _bt_is_le_discovering() == FALSE,
2664                                                         DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
2665
2666                                 cache_info = g_malloc0(sizeof(bt_cache_info_t));
2667                                 dev_info = g_malloc0(sizeof(bt_remote_dev_info_t));
2668                                 cache_info->dev_info = dev_info;
2669
2670                                 if (__bt_parse_interface(msg, dev_info) == FALSE) {
2671                                         BT_ERR("Fail to parse the properies");
2672                                         __bt_free_cache_info(cache_info);
2673                                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2674                                 }
2675
2676                                 if (dev_info->addr_type != BDADDR_BREDR) {
2677                                         /* Whenever emit the property changed from bluez,
2678                                                 some property doesn't reach to bt-service.
2679                                                 So LE device is handled as AdvReport signal */
2680                                         __bt_free_cache_info(cache_info);
2681                                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2682                                 }
2683
2684                                 if (dev_info->name == NULL)
2685                                         /* If Remote device name is NULL or still RNR is not done
2686                                          * then display address as name.
2687                                          */
2688                                         dev_info->name = g_strdup(dev_info->address);
2689
2690                                 _bt_send_event(BT_ADAPTER_EVENT,
2691                                         BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND,
2692                                         DBUS_TYPE_INT32, &result,
2693                                         DBUS_TYPE_STRING, &dev_info->address,
2694                                         DBUS_TYPE_UINT32, &dev_info->class,
2695                                         DBUS_TYPE_INT16, &dev_info->rssi,
2696                                         DBUS_TYPE_STRING, &dev_info->name,
2697                                         DBUS_TYPE_BOOLEAN, &dev_info->paired,
2698                                         DBUS_TYPE_BOOLEAN, &dev_info->connected,
2699                                         DBUS_TYPE_BOOLEAN, &dev_info->trust,
2700                                         DBUS_TYPE_ARRAY, DBUS_TYPE_STRING,
2701                                         &dev_info->uuids, dev_info->uuid_count,
2702                                         DBUS_TYPE_INT16, &dev_info->manufacturer_data_len,
2703                                         DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE,
2704                                         &dev_info->manufacturer_data, dev_info->manufacturer_data_len,
2705                                         DBUS_TYPE_INVALID);
2706
2707                                 p_cache_list = g_list_append(p_cache_list, cache_info);
2708                         } else if (bt_event == BT_AVRCP_CONTROL_EVENT) {
2709                                 BT_DBG("Device path : %s ", object_path);
2710                                 _bt_set_control_device_path(object_path);
2711                         }
2712                 }
2713         } else if (strcasecmp(member, "InterfacesRemoved") == 0) {
2714                 bt_event = __bt_parse_remove_event(msg);
2715
2716                 if ((bt_event != 0) && (bt_event != BT_MEDIA_TRANSFER_EVENT)) {
2717                         _bt_handle_adapter_event(msg);
2718                         if (bt_event == BT_AVRCP_CONTROL_EVENT) {
2719                                 char *object_path = NULL;
2720                                 result = __bt_get_object_path(msg, &object_path);
2721                                 if (result == BLUETOOTH_ERROR_NONE)
2722                                         _bt_remove_control_device_path(object_path);
2723                         }
2724                 }
2725
2726         } else if (strcasecmp(member, "NameOwnerChanged") == 0) {
2727                 gboolean value;
2728                 char *name = NULL;
2729                 char *previous = NULL;
2730                 char *current = NULL;
2731
2732                 if (__bt_get_owner_info(msg, &name, &previous, &current)) {
2733                         BT_ERR("Fail to get the owner info");
2734                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2735                 }
2736
2737                 if (*current != '\0')
2738                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2739
2740                 if (strcasecmp(name, BT_BLUEZ_NAME) == 0) {
2741                         BT_DBG("Bluetoothd is terminated");
2742                         if (_bt_adapter_get_status() != BT_DEACTIVATING) {
2743                                  __bt_disable_cb();
2744                         }
2745                         _bt_handle_adapter_removed();
2746                         __bt_devices_list_free();
2747                 }
2748
2749                 _bt_obex_server_check_allocation(&value);
2750
2751                 if (value == TRUE) {
2752                         /* Check if the obex server was terminated abnormally */
2753                         _bt_obex_server_check_termination(name);
2754                 }
2755
2756                 _bt_rfcomm_server_check_existence(&value);
2757
2758                 if (value == TRUE) {
2759                         /* The obex server was terminated abnormally */
2760                         _bt_rfcomm_server_check_termination(name);
2761                 }
2762
2763                 /* Stop advertising started by terminated process */
2764                 _bt_stop_advertising_by_terminated_process(name);
2765         } else  if (dbus_message_has_interface(msg, BT_PROPERTIES_INTERFACE)) {
2766                 const char *path = dbus_message_get_path(msg);
2767
2768                 if (strncmp(path, BT_MEDIA_OBJECT_PATH,
2769                                 strlen(BT_MEDIA_OBJECT_PATH)) == 0)
2770                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2771
2772                 _bt_handle_property_changed_event(msg);
2773         } else  if (dbus_message_has_interface(msg, BT_ADAPTER_INTERFACE)) {
2774                 _bt_handle_adapter_event(msg);
2775         } else  if (dbus_message_has_interface(msg, BT_INPUT_INTERFACE)) {
2776                 _bt_handle_input_event(msg);
2777         } else  if (dbus_message_has_interface(msg, BT_NETWORK_SERVER_INTERFACE)) {
2778                 _bt_handle_network_server_event(msg);
2779         } else  if (dbus_message_has_interface(msg, BT_HEADSET_INTERFACE)) {
2780                 _bt_handle_headset_event(msg);
2781         } else  if (dbus_message_has_interface(msg, BT_SINK_INTERFACE)) {
2782                 _bt_handle_sink_event(msg);
2783         } else  if (dbus_message_has_interface(msg, BT_AGENT_INTERFACE)) {
2784                 _bt_handle_agent_event(msg);
2785         } else  if (dbus_message_has_interface(msg, BT_DEVICE_INTERFACE)) {
2786                 _bt_handle_device_event(msg);
2787         }
2788
2789         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2790 }
2791
2792 static gboolean __bt_is_obexd_event(DBusMessage *msg)
2793 {
2794         const char *member = dbus_message_get_member(msg);
2795
2796         if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL)
2797                 return FALSE;
2798
2799         retv_if(member == NULL, FALSE);
2800
2801         if (dbus_message_has_interface(msg, BT_PROPERTIES_INTERFACE)) {
2802
2803                 DBusMessageIter item_iter;
2804                 const char *interface_name = NULL;
2805
2806                 dbus_message_iter_init(msg, &item_iter);
2807
2808                 if (dbus_message_iter_get_arg_type(&item_iter)
2809                                         != DBUS_TYPE_STRING) {
2810                         BT_ERR("This is bad format dbus");
2811                         return FALSE;
2812                 }
2813
2814                 dbus_message_iter_get_basic(&item_iter, &interface_name);
2815
2816                 retv_if(interface_name == NULL, FALSE);
2817
2818                 BT_DBG("interface: %s", interface_name);
2819
2820                 retv_if(dbus_message_iter_next(&item_iter) == FALSE, FALSE);
2821
2822                 retv_if(dbus_message_iter_get_arg_type(&item_iter) != DBUS_TYPE_ARRAY,
2823                                                                         FALSE);
2824
2825                 if (strcasecmp(interface_name, BT_OBEX_TRANSFER_INTERFACE) == 0) {
2826                         BT_DBG("BT_OBEX_TRANSFER_INTERFACE");
2827                         return TRUE;
2828                 }
2829         }
2830
2831         return FALSE;
2832 }
2833
2834 static DBusHandlerResult __bt_obexd_event_filter(DBusConnection *conn,
2835                                                 DBusMessage *msg, void *data)
2836 {
2837         const char *member = dbus_message_get_member(msg);
2838         char *object_path = NULL;
2839
2840         if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL)
2841                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2842
2843         retv_if(member == NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
2844
2845         if (strcasecmp(member, "InterfacesAdded") == 0) {
2846                 BT_DBG("InterfacesAdded");
2847                 if (__bt_get_object_path(msg, &object_path)) {
2848                         BT_ERR("Fail to get the path");
2849                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2850                 }
2851
2852                 BT_INFO("object_path = [%s]", object_path);
2853
2854                 /*Handle OPP_SERVER_CONNECTED_EVENT here */
2855                 if (strncmp(object_path, BT_SESSION_BASEPATH_SERVER,
2856                                 strlen(BT_SESSION_BASEPATH_SERVER)) != 0)
2857                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2858
2859                 if (g_strrstr(object_path, "session") && g_strrstr(object_path, "transfer")) {
2860                         BT_DBG("Obex_Server_Session_Transfer connected");
2861                         _bt_obex_transfer_connected();
2862                 }
2863         } else if (strcasecmp(member, "InterfacesRemoved") == 0) {
2864                 /*Handle OPP_SERVER_DISCONNECTED_EVENT here */
2865                 BT_DBG("InterfacesRemoved");
2866                 if (__bt_get_object_path(msg, &object_path)) {
2867                         BT_ERR("Fail to get the path");
2868                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2869                 }
2870
2871                 BT_INFO("object_path = [%s]", object_path);
2872
2873                 if (strncmp(object_path, BT_SESSION_BASEPATH_SERVER,
2874                                 strlen(BT_SESSION_BASEPATH_SERVER)) != 0)
2875                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2876
2877                 if (g_strrstr(object_path, "session") && g_strrstr(object_path, "transfer")) {
2878                         BT_DBG("Obex_Server_Session_Transfer disconnected");
2879                         _bt_obex_transfer_disconnected();
2880                 }
2881         } else if (__bt_is_obexd_event(msg) == TRUE) {
2882                 const char *path = dbus_message_get_path(msg);
2883
2884                 if (strncmp(path, BT_SESSION_BASEPATH_SERVER,
2885                                 strlen(BT_SESSION_BASEPATH_SERVER)) != 0 &&
2886                         strncmp(path, BT_SESSION_BASEPATH_CLIENT,
2887                                 strlen(BT_SESSION_BASEPATH_CLIENT)) != 0) {
2888                         BT_DBG("DBUS_HANDLER_RESULT_NOT_YET_HANDLED");
2889                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2890                 }
2891
2892                 _bt_handle_property_changed_event(msg);
2893         }
2894         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2895 }
2896
2897 static gboolean __bt_is_obexd_client_event(DBusMessage *msg)
2898 {
2899         BT_DBG("+");
2900
2901         const char *member = dbus_message_get_member(msg);
2902
2903         if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL)
2904                 return FALSE;
2905
2906         retv_if(member == NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
2907
2908         if (dbus_message_has_interface(msg, BT_PROPERTIES_INTERFACE)) {
2909                 DBusMessageIter item_iter;
2910                 const char *interface_name = NULL;
2911
2912                 dbus_message_iter_init(msg, &item_iter);
2913
2914                 if (dbus_message_iter_get_arg_type(&item_iter)
2915                                                 != DBUS_TYPE_STRING) {
2916                         BT_ERR("This is bad format dbus");
2917                         return FALSE;
2918                 }
2919
2920                 dbus_message_iter_get_basic(&item_iter, &interface_name);
2921
2922                 retv_if(interface_name == NULL, FALSE);
2923
2924                 BT_DBG("interface: %s", interface_name);
2925
2926                 retv_if(dbus_message_iter_next(&item_iter) == FALSE,
2927                                                                 FALSE);
2928
2929                 retv_if(dbus_message_iter_get_arg_type(&item_iter)
2930                                         != DBUS_TYPE_ARRAY, FALSE);
2931
2932                 if (strcasecmp(interface_name,
2933                                         BT_OBEX_TRANSFER_INTERFACE) == 0) {
2934                         BT_DBG("-");
2935                         return TRUE;
2936                 }
2937         }
2938
2939         BT_DBG("-");
2940
2941         return FALSE;
2942 }
2943
2944 static DBusHandlerResult __bt_opc_event_filter(DBusConnection *conn,
2945                                                 DBusMessage *msg, void *data)
2946 {
2947         const char *member = dbus_message_get_member(msg);
2948
2949         if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL)
2950                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2951
2952         retv_if(member == NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
2953
2954         if (strcasecmp(member, "InterfacesAdded") == 0) {
2955                 BT_DBG("InterfacesAdded");
2956         }else if (strcasecmp(member, "InterfacesRemoved") == 0) {
2957                 char *object_path = NULL;
2958
2959                 BT_DBG("InterfacesRemoved");
2960
2961                 if (__bt_get_object_path(msg, &object_path)) {
2962                         BT_ERR("Fail to get the path");
2963                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2964                 }
2965
2966                 BT_DBG("object_path =%s",object_path);
2967
2968                 if (strncmp(object_path, BT_SESSION_BASEPATH_CLIENT,
2969                                 strlen(BT_SESSION_BASEPATH_CLIENT)) != 0
2970                                 || strstr(object_path, "transfer") == NULL)
2971                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2972                 else if (strncmp(object_path, BT_SESSION_BASEPATH_CLIENT,
2973                                 strlen(BT_SESSION_BASEPATH_CLIENT)) == 0) {
2974                         BT_DBG("Going to call opc disconnected");
2975                         _bt_opc_disconnected(object_path);
2976                 }
2977
2978                 _bt_sending_files();
2979
2980         }else if (__bt_is_obexd_client_event(msg) == TRUE){
2981                 const char *path = dbus_message_get_path(msg);
2982
2983                 if (strncmp(path, BT_SESSION_BASEPATH_CLIENT,
2984                         strlen(BT_SESSION_BASEPATH_CLIENT)) != 0) {
2985                         BT_DBG("NOT BT_SESSION_BASEPATH_CLIENT");
2986                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2987                 }
2988
2989                 _bt_opc_property_changed_event(msg);
2990         }
2991
2992         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
2993 }
2994
2995 int _bt_opp_client_event_init(void)
2996 {
2997         GError *error = NULL;
2998
2999         if (opc_obexd_conn == NULL) {
3000                 opc_obexd_conn = dbus_g_bus_get(DBUS_BUS_SESSION, &error);
3001                 if (error != NULL) {
3002                         BT_ERR("ERROR: Can't get on session bus [%s]",
3003                                                          error->message);
3004                         g_error_free(error);
3005                         return BLUETOOTH_ERROR_INTERNAL;
3006                 }
3007
3008                 retv_if(opc_obexd_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
3009         }
3010
3011         if (_bt_register_service_event(opc_obexd_conn,
3012                         BT_OPP_CLIENT_EVENT) != BLUETOOTH_ERROR_NONE) {
3013                 dbus_g_connection_unref(opc_obexd_conn);
3014                 opc_obexd_conn = NULL;
3015                 return BLUETOOTH_ERROR_INTERNAL;
3016         }
3017
3018         return BLUETOOTH_ERROR_NONE;
3019 }
3020
3021 void _bt_opp_client_event_deinit(void)
3022 {
3023         if (opc_obexd_conn) {
3024                 _bt_unregister_service_event(opc_obexd_conn,
3025                                                 BT_OPP_CLIENT_EVENT);
3026                 dbus_g_connection_unref(opc_obexd_conn);
3027                 opc_obexd_conn = NULL;
3028         }
3029 }
3030
3031 int _bt_register_service_event(DBusGConnection *g_conn, int event_type)
3032 {
3033         BT_DBG("+");
3034
3035         DBusError dbus_error;
3036         char *match1 = NULL;
3037         char *match2 = NULL;
3038         char *match3 = NULL;
3039         char *match4 = NULL;
3040         DBusConnection *conn;
3041         DBusHandleMessageFunction event_func = NULL;
3042
3043         retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
3044
3045         conn = dbus_g_connection_get_connection(g_conn);
3046         retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
3047
3048         switch (event_type) {
3049         case BT_MANAGER_EVENT:
3050                 event_func = __bt_manager_event_filter;
3051                 match1 = g_strdup_printf(MANAGER_EVENT_MATCH_RULE,
3052                                         BT_MANAGER_INTERFACE,
3053                                         BT_INTERFACES_ADDED);
3054
3055                 match2 = g_strdup_printf(MANAGER_EVENT_MATCH_RULE,
3056                                         BT_MANAGER_INTERFACE,
3057                                         BT_INTERFACES_REMOVED);
3058
3059                 match3 = g_strdup_printf(MANAGER_EVENT_MATCH_RULE,
3060                                         BT_FREEDESKTOP_INTERFACE,
3061                                         BT_NAME_OWNER_CHANGED);
3062
3063                 match4 = g_strdup_printf(MANAGER_EVENT_MATCH_RULE,
3064                                         BT_PROPERTIES_INTERFACE,
3065                                         BT_PROPERTIES_CHANGED);
3066                 break;
3067         case BT_DEVICE_EVENT:
3068                 match1 = g_strdup_printf(EVENT_MATCH_RULE,
3069                                         BT_DEVICE_INTERFACE);
3070                 break;
3071         case BT_HID_EVENT:
3072                 match1 = g_strdup_printf(EVENT_MATCH_RULE,
3073                                         BT_INPUT_INTERFACE);
3074                 break;
3075         case BT_NETWORK_EVENT:
3076                 match1 = g_strdup_printf(EVENT_MATCH_RULE,
3077                                         BT_NETWORK_SERVER_INTERFACE);
3078
3079                 match2 = g_strdup_printf(EVENT_MATCH_RULE,
3080                                         BT_NETWORK_CLIENT_INTERFACE);
3081                 break;
3082         case BT_HEADSET_EVENT:
3083                 match1 = g_strdup_printf(EVENT_MATCH_RULE,
3084                                         BT_HEADSET_INTERFACE);
3085
3086                 match2 = g_strdup_printf(EVENT_MATCH_RULE,
3087                                         BT_SINK_INTERFACE);
3088                 break;
3089         case BT_OPP_SERVER_EVENT:
3090                 BT_ERR("BT_OPP_SERVER_EVENT: register service event");
3091                 event_func = __bt_obexd_event_filter;
3092                 match1 = g_strdup_printf(MANAGER_EVENT_MATCH_RULE,
3093                                         BT_PROPERTIES_INTERFACE,
3094                                         BT_PROPERTIES_CHANGED);
3095
3096                 match2 = g_strdup_printf(MANAGER_EVENT_MATCH_RULE,
3097                                         BT_MANAGER_INTERFACE,
3098                                         BT_INTERFACES_ADDED);
3099
3100                 match3 = g_strdup_printf(MANAGER_EVENT_MATCH_RULE,
3101                                         BT_MANAGER_INTERFACE,
3102                                         BT_INTERFACES_REMOVED);
3103                 break;
3104         case BT_OPP_CLIENT_EVENT:
3105                 BT_ERR("BT_OPP_CLIENT_EVENT: register service event");
3106                 event_func = __bt_opc_event_filter;
3107                 match1 = g_strdup_printf(MANAGER_EVENT_MATCH_RULE,
3108                                         BT_PROPERTIES_INTERFACE,
3109                                         BT_PROPERTIES_CHANGED);
3110
3111                 match2 = g_strdup_printf(MANAGER_EVENT_MATCH_RULE,
3112                                         BT_MANAGER_INTERFACE,
3113                                         BT_INTERFACES_ADDED);
3114
3115                 match3 = g_strdup_printf(MANAGER_EVENT_MATCH_RULE,
3116                                         BT_MANAGER_INTERFACE,
3117                                         BT_INTERFACES_REMOVED);
3118                 break;
3119         default:
3120                 BT_ERR("Unknown event");
3121                 return BLUETOOTH_ERROR_INTERNAL;
3122         }
3123
3124         if (event_func) {
3125                 if (!dbus_connection_add_filter(conn, event_func,
3126                                                 NULL, NULL)) {
3127                         BT_ERR("Fail to add filter");
3128                         goto fail;
3129                 }
3130         }
3131
3132         dbus_error_init(&dbus_error);
3133
3134         if (match1)
3135                 dbus_bus_add_match(conn, match1, &dbus_error);
3136
3137         if (dbus_error_is_set(&dbus_error)) {
3138                 BT_ERR("Fail to add match: %s\n", dbus_error.message);
3139                 dbus_error_free(&dbus_error);
3140                 goto fail;
3141         }
3142
3143         if (match2)
3144                 dbus_bus_add_match(conn, match2, &dbus_error);
3145
3146         if (dbus_error_is_set(&dbus_error)) {
3147                 BT_ERR("Fail to add match: %s\n", dbus_error.message);
3148                 dbus_error_free(&dbus_error);
3149                 goto fail;
3150         }
3151
3152         if (match3)
3153                 dbus_bus_add_match(conn, match3, &dbus_error);
3154
3155         if (dbus_error_is_set(&dbus_error)) {
3156                 BT_ERR("Fail to add match: %s\n", dbus_error.message);
3157                 dbus_error_free(&dbus_error);
3158                 goto fail;
3159         }
3160
3161         if (match4)
3162                 dbus_bus_add_match(conn, match4, &dbus_error);
3163
3164         if (dbus_error_is_set(&dbus_error)) {
3165                 BT_ERR("Fail to add match: %s\n", dbus_error.message);
3166                 dbus_error_free(&dbus_error);
3167                 goto fail;
3168         }
3169
3170         g_free(match3);
3171         g_free(match4);
3172
3173         g_free(match1);
3174         g_free(match2);
3175
3176         return BLUETOOTH_ERROR_NONE;
3177 fail:
3178         g_free(match1);
3179         g_free(match2);
3180
3181         g_free(match3);
3182         g_free(match4);
3183
3184         BT_DBG("-");
3185
3186         return BLUETOOTH_ERROR_INTERNAL;
3187 }
3188
3189 void _bt_unregister_service_event(DBusGConnection *g_conn, int event_type)
3190 {
3191         BT_DBG("+");
3192
3193         DBusConnection *conn;
3194         DBusHandleMessageFunction event_func;
3195
3196         ret_if(g_conn == NULL);
3197         conn = dbus_g_connection_get_connection(g_conn);
3198
3199         switch (event_type) {
3200         case BT_MANAGER_EVENT:
3201                 event_func = __bt_manager_event_filter;
3202                 break;
3203         case BT_OPP_SERVER_EVENT:
3204                 event_func = __bt_obexd_event_filter;
3205                 break;
3206         case BT_OPP_CLIENT_EVENT:
3207                 event_func = __bt_opc_event_filter;
3208                 break;
3209         default:
3210                 BT_ERR("Unknown event");
3211                 return;
3212         }
3213
3214         ret_if(conn == NULL);
3215
3216         dbus_connection_remove_filter(conn, event_func, NULL);
3217         BT_DBG("-");
3218 }
3219
3220 static int __bt_init_manager_receiver(void)
3221 {
3222         BT_DBG("+");
3223
3224         GError *error = NULL;
3225
3226         if (manager_conn == NULL) {
3227                 manager_conn = dbus_g_bus_get(DBUS_BUS_SYSTEM, &error);
3228                 if (error != NULL) {
3229                         BT_ERR("ERROR: Can't get on system bus [%s]", error->message);
3230                         g_error_free(error);
3231                 }
3232                 retv_if(manager_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
3233         }
3234
3235         if (_bt_register_service_event(manager_conn,
3236                                 BT_MANAGER_EVENT) != BLUETOOTH_ERROR_NONE)
3237                 goto fail;
3238
3239         if (_bt_register_service_event(manager_conn,
3240                                 BT_DEVICE_EVENT) != BLUETOOTH_ERROR_NONE)
3241                 goto fail;
3242
3243         if (_bt_register_service_event(manager_conn,
3244                                 BT_HID_EVENT) != BLUETOOTH_ERROR_NONE)
3245                 goto fail;
3246
3247         if (_bt_register_service_event(manager_conn,
3248                                 BT_HEADSET_EVENT) != BLUETOOTH_ERROR_NONE)
3249                 goto fail;
3250
3251         if (_bt_register_service_event(manager_conn,
3252                                 BT_NETWORK_EVENT) != BLUETOOTH_ERROR_NONE)
3253                 goto fail;
3254
3255         return BLUETOOTH_ERROR_NONE;
3256 fail:
3257         if (manager_conn) {
3258                 dbus_g_connection_unref(manager_conn);
3259                 manager_conn = NULL;
3260         }
3261
3262         BT_DBG("-");
3263
3264         return BLUETOOTH_ERROR_INTERNAL;
3265 }
3266
3267 static int __bt_init_obexd_receiver(void)
3268 {
3269         BT_DBG("+");
3270         GError *error = NULL;
3271
3272         if (obexd_conn == NULL) {
3273                 obexd_conn = dbus_g_bus_get(DBUS_BUS_SESSION, &error);
3274                 if (error != NULL) {
3275                         BT_ERR("ERROR: Can't get on session bus [%s]", error->message);
3276                         g_error_free(error);
3277                 }
3278                 retv_if(obexd_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
3279         }
3280
3281         if (_bt_register_service_event(obexd_conn,
3282                                 BT_OPP_SERVER_EVENT) != BLUETOOTH_ERROR_NONE) {
3283                 dbus_g_connection_unref(obexd_conn);
3284                 obexd_conn = NULL;
3285                 return BLUETOOTH_ERROR_INTERNAL;
3286         }
3287
3288         BT_DBG("-");
3289
3290         return BLUETOOTH_ERROR_NONE;
3291 }
3292
3293 /* To receive the event from bluez */
3294 int _bt_init_service_event_receiver(void)
3295 {
3296         BT_DBG("+");
3297
3298         int result;
3299
3300         result = __bt_init_manager_receiver();
3301         retv_if(result != BLUETOOTH_ERROR_NONE, result);
3302
3303         result = __bt_init_obexd_receiver();
3304         if (result != BLUETOOTH_ERROR_NONE)
3305                 BT_ERR("Fail to init obexd receiver");
3306
3307         BT_DBG("-");
3308
3309         return BLUETOOTH_ERROR_NONE;
3310 }
3311
3312 void _bt_deinit_service_event_receiver(void)
3313 {
3314         BT_DBG("+");
3315
3316         _bt_unregister_service_event(manager_conn, BT_MANAGER_EVENT);
3317
3318         _bt_unregister_service_event(obexd_conn, BT_OPP_SERVER_EVENT);
3319
3320         if (manager_conn) {
3321                 dbus_g_connection_unref(manager_conn);
3322                 manager_conn = NULL;
3323         }
3324
3325         if (obexd_conn) {
3326                 dbus_g_connection_unref(obexd_conn);
3327                 obexd_conn = NULL;
3328         }
3329
3330         if (event_id > 0)
3331                 g_source_remove(event_id);
3332
3333         BT_DBG("-");
3334 }