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