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

   1 /*
   2  * bluetooth-frwk
   3  *
   4  * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *              http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  *
  18  */
  19
  20 #include <dbus/dbus-glib.h>
  21 #include <dbus/dbus-glib-lowlevel.h>
  22 #include <dbus/dbus.h>
  23 #include <glib.h>
  24 #include <string.h>
  25 #include <dlog.h>
  26 #include <vconf.h>
  27 #include <vconf-internal-bt-keys.h>
  28
  29 #include "bluetooth-api.h"
  30 #include "bt-internal-types.h"
  31
  32 #include "bt-service-common.h"
  33 #include "bt-service-event.h"
  34 #include "bt-service-main.h"
  35 #include "bt-service-adapter.h"
  36 #include "bt-service-device.h"
  37 #include "bt-service-obex-server.h"
  38 #include "bt-service-rfcomm-server.h"
  39 #include "bt-service-opp-client.h"
  40 #include "bt-service-audio.h"
  41
  42 static DBusGConnection *manager_conn = NULL;
  43 static DBusGConnection *obexd_conn = NULL;
  44 static DBusGConnection *opc_obexd_conn = NULL;
  45 static GList *g_list = NULL;
  46
  47 static guint event_id;
  48
  49 static bt_remote_dev_info_t *__bt_parse_device_properties(DBusMessageIter *item_iter)
  50 {
  51         DBusMessageIter value_iter;
  52         char *value;
  53         bt_remote_dev_info_t *dev_info;
  54
  55         dbus_message_iter_recurse(item_iter, &value_iter);
  56
  57         if (dbus_message_iter_get_arg_type(&value_iter) != DBUS_TYPE_DICT_ENTRY) {
  58                 BT_DBG("No entry");
  59                 return NULL;
  60         }
  61
  62         dev_info = g_malloc0(sizeof(bt_remote_dev_info_t));
  63
  64         while (dbus_message_iter_get_arg_type(&value_iter) ==
  65                                                 DBUS_TYPE_DICT_ENTRY) {
  66                 char *key;
  67                 DBusMessageIter dict_entry;
  68                 DBusMessageIter iter_dict_val;
  69
  70                 dbus_message_iter_recurse(&value_iter, &dict_entry);
  71
  72                 dbus_message_iter_get_basic(&dict_entry, &key);
  73
  74                 if (key == NULL) {
  75                         dbus_message_iter_next(&value_iter);
  76                         continue;
  77                 }
  78
  79                 if (!dbus_message_iter_next(&dict_entry)) {
  80                         dbus_message_iter_next(&value_iter);
  81                         continue;
  82                 }
  83                 dbus_message_iter_recurse(&dict_entry, &iter_dict_val);
  84
  85                 if (strcasecmp(key, "Address") == 0) {
  86                         const char *address = NULL;
  87                         dbus_message_iter_get_basic(&iter_dict_val, &address);
  88                         dev_info->address = g_strdup(address);
  89                 } else if (strcasecmp(key, "Class") == 0) {
  90                         dbus_message_iter_get_basic(&iter_dict_val, &dev_info->class);
  91                 } else if (strcasecmp(key, "Name") == 0) {
  92                         dbus_message_iter_get_basic(&iter_dict_val, &value);
  93                         if (dev_info->name == NULL)
  94                                 dev_info->name = g_strdup(value);
  95                 } else if (strcasecmp(key, "Connected") == 0) {
  96                         dbus_message_iter_get_basic(&iter_dict_val,
  97                                                 &dev_info->connected);
  98                 } else if (strcasecmp(key, "Paired") == 0) {
  99                         dbus_message_iter_get_basic(&iter_dict_val,
 100                                                 &dev_info->paired);
 101                 } else if (strcasecmp(key, "Trusted") == 0) {
 102                         dbus_message_iter_get_basic(&iter_dict_val,
 103                                                 &dev_info->trust);
 104                 } else if (strcasecmp(key, "RSSI") == 0) {
 105                         dbus_message_iter_get_basic(&iter_dict_val,
 106                                                 &dev_info->rssi);
 107                 } else if (strcasecmp(key, "UUIDs") == 0) {
 108                         DBusMessageIter uuid_iter;
 109                         DBusMessageIter tmp_iter;
 110                         int i = 0;
 111
 112                         dbus_message_iter_recurse(&iter_dict_val, &uuid_iter);
 113
 114                         tmp_iter = uuid_iter;
 115
 116                         /* Store the uuid count */
 117                         while (dbus_message_iter_get_arg_type(&tmp_iter) != DBUS_TYPE_INVALID) {
 118                                 dbus_message_iter_get_basic(&tmp_iter,
 119                                                         &value);
 120
 121                                 dev_info->uuid_count++;
 122                                 if (!dbus_message_iter_next(&tmp_iter))
 123                                         break;
 124                         }
 125
 126                         /* Store the uuids */
 127                         if (dev_info->uuid_count > 0) {
 128                                 dev_info->uuids = g_new0(char *,
 129                                                 dev_info->uuid_count + 1);
 130                         } else {
 131                                 dbus_message_iter_next(&value_iter);
 132                                 continue;
 133                         }
 134
 135                         while (dbus_message_iter_get_arg_type(&uuid_iter) != DBUS_TYPE_INVALID) {
 136                                 dbus_message_iter_get_basic(&uuid_iter,
 137                                                         &value);
 138                                 dev_info->uuids[i] = g_strdup(value);
 139                                 i++;
 140                                 if (!dbus_message_iter_next(&uuid_iter)) {
 141                                         break;
 142                                 }
 143                         }
 144
 145                 }
 146
 147                 dbus_message_iter_next(&value_iter);
 148         }
 149
 150         return dev_info;
 151 }
 152
 153 void __bt_parse_media_properties(DBusMessageIter *item_iter)
 154 {
 155         DBusMessageIter value_iter;
 156         char *address = NULL;
 157         char *uuid = NULL;
 158         int result = BLUETOOTH_ERROR_NONE;
 159
 160         dbus_message_iter_recurse(item_iter, &value_iter);
 161
 162         if (dbus_message_iter_get_arg_type(&value_iter) !=
 163                                         DBUS_TYPE_DICT_ENTRY) {
 164                 BT_DBG("No entry");
 165                 return;
 166         }
 167
 168         while (dbus_message_iter_get_arg_type(&value_iter) ==
 169                                         DBUS_TYPE_DICT_ENTRY) {
 170                 char *key;
 171                 DBusMessageIter dict_entry;
 172                 DBusMessageIter iter_dict_val;
 173
 174                 dbus_message_iter_recurse(&value_iter, &dict_entry);
 175                 dbus_message_iter_get_basic(&dict_entry, &key);
 176
 177                 if (key == NULL) {
 178                         dbus_message_iter_next(&value_iter);
 179                         continue;
 180                 }
 181
 182                 if (!dbus_message_iter_next(&dict_entry)) {
 183                         dbus_message_iter_next(&value_iter);
 184                         continue;
 185                 }
 186
 187                 dbus_message_iter_recurse(&dict_entry, &iter_dict_val);
 188
 189                 BT_DBG("key: %s", key);
 190
 191                 if (strcasecmp(key, "Device") == 0) {
 192                         char *object_path = NULL;
 193
 194                         dbus_message_iter_get_basic(&iter_dict_val, &object_path);
 195                         address = g_malloc0(BT_ADDRESS_STRING_SIZE);
 196                         _bt_convert_device_path_to_address(object_path, address);
 197
 198                 }else if (strcasecmp(key, "UUID") == 0) {
 199                         dbus_message_iter_get_basic(&iter_dict_val, &uuid);
 200                 }
 201
 202                 dbus_message_iter_next(&value_iter);
 203         }
 204
 205         if (address != NULL && uuid != NULL){
 206                 int event = BLUETOOTH_EVENT_AV_CONNECTED;
 207                 char connected_address[BT_ADDRESS_STRING_SIZE + 1];
 208                 bluetooth_device_address_t device_address;
 209                 gboolean connected;
 210
 211                 _bt_send_event(BT_HEADSET_EVENT, event,
 212                         DBUS_TYPE_INT32, &result,
 213                         DBUS_TYPE_STRING, &address,
 214                         DBUS_TYPE_INVALID);
 215
 216                 connected = _bt_is_headset_type_connected(BT_AUDIO_A2DP,
 217                                                 connected_address);
 218                 if (connected) {
 219                         if (g_strcmp0(connected_address, address) != 0) {
 220                                 _bt_convert_addr_string_to_type(
 221                                         device_address.addr,
 222                                         connected_address);
 223                                 _bt_audio_disconnect(0, BT_AUDIO_A2DP,
 224                                         &device_address, NULL);
 225                         }
 226                 }
 227
 228                 _bt_add_headset_to_list(BT_AUDIO_A2DP,
 229                                         BT_STATE_CONNECTED, address);
 230
 231                 g_free(address);
 232         }
 233 }
 234
 235 static void __bt_parse_audio_properties(DBusMessage *msg)
 236 {
 237         DBusMessageIter msg_iter;
 238         DBusMessageIter value_iter;
 239
 240         ret_if(dbus_message_iter_init(msg, &msg_iter) == FALSE);
 241
 242         /* object array (oa) */
 243         ret_if(dbus_message_iter_next(&msg_iter) == FALSE);
 244         ret_if(dbus_message_iter_get_arg_type(&msg_iter) !=
 245                                         DBUS_TYPE_ARRAY);
 246
 247         dbus_message_iter_recurse(&msg_iter, &value_iter);
 248
 249         /* string array (sa) */
 250         while (dbus_message_iter_get_arg_type(&value_iter) ==
 251                                         DBUS_TYPE_DICT_ENTRY) {
 252                 char *interface_name = NULL;
 253                 DBusMessageIter interface_iter;
 254
 255                 dbus_message_iter_recurse(&value_iter, &interface_iter);
 256
 257                 ret_if(dbus_message_iter_get_arg_type(&interface_iter) !=
 258                                                 DBUS_TYPE_STRING);
 259
 260                 dbus_message_iter_get_basic(&interface_iter, &interface_name);
 261
 262                 ret_if(dbus_message_iter_next(&interface_iter) == FALSE);
 263
 264                 ret_if(dbus_message_iter_get_arg_type(&interface_iter) !=
 265                                         DBUS_TYPE_ARRAY);
 266
 267                 BT_DBG("interface: %s", interface_name);
 268
 269                 if (g_strcmp0(interface_name,
 270                                 "org.bluez.MediaTransport1") == 0) {
 271                         __bt_parse_media_properties(&interface_iter);
 272                         return;
 273                 }
 274                 dbus_message_iter_next(&value_iter);
 275         }
 276
 277         return;
 278 }
 279
 280 static int __bt_parse_event(DBusMessage *msg)
 281 {
 282         DBusMessageIter msg_iter;
 283         DBusMessageIter value_iter;
 284
 285         retv_if(dbus_message_iter_init(msg, &msg_iter) == FALSE, 0);
 286
 287         /* object array (oa) */
 288         retv_if(dbus_message_iter_next(&msg_iter) == FALSE, 0);
 289         retv_if(dbus_message_iter_get_arg_type(&msg_iter) !=
 290                                         DBUS_TYPE_ARRAY, 0);
 291
 292         dbus_message_iter_recurse(&msg_iter, &value_iter);
 293
 294         /* string array (sa) */
 295         while (dbus_message_iter_get_arg_type(&value_iter) ==
 296                                         DBUS_TYPE_DICT_ENTRY) {
 297                 char *interface_name = NULL;
 298                 DBusMessageIter interface_iter;
 299
 300                 dbus_message_iter_recurse(&value_iter, &interface_iter);
 301
 302                 retv_if(dbus_message_iter_get_arg_type(&interface_iter) !=
 303                                                 DBUS_TYPE_STRING, 0);
 304
 305                 dbus_message_iter_get_basic(&interface_iter,
 306                                                 &interface_name);
 307
 308                 retv_if(dbus_message_iter_next(&interface_iter) == FALSE,
 309                                                                 0);
 310
 311                 retv_if(dbus_message_iter_get_arg_type(&interface_iter) !=
 312                                         DBUS_TYPE_ARRAY, 0);
 313
 314                 BT_DBG("interface: %s", interface_name);
 315
 316                 if (g_strcmp0(interface_name,
 317                                         "org.bluez.Device1") == 0) {
 318                         return BT_DEVICE_EVENT;
 319                 }else if (g_strcmp0(interface_name,
 320                                 "org.bluez.MediaTransport1") == 0) {
 321                         return BT_MEDIA_TRANSFER_EVENT;
 322                 }
 323                 dbus_message_iter_next(&value_iter);
 324         }
 325
 326         return 0;
 327 }
 328
 329 static int __bt_parse_remove_event(DBusMessage *msg)
 330 {
 331         DBusMessageIter msg_iter;
 332         DBusMessageIter value_iter;
 333
 334         retv_if(dbus_message_iter_init(msg, &msg_iter) ==
 335                                         FALSE, 0);
 336
 337         retv_if(dbus_message_iter_next(&msg_iter) == FALSE,
 338                                                 0);
 339         retv_if(dbus_message_iter_get_arg_type(&msg_iter) !=
 340                                         DBUS_TYPE_ARRAY, 0);
 341
 342         dbus_message_iter_recurse(&msg_iter, &value_iter);
 343
 344         while (dbus_message_iter_get_arg_type(&value_iter)
 345                                         != DBUS_TYPE_INVALID) {
 346                 char *key;
 347
 348                 dbus_message_iter_get_basic(&value_iter, &key);
 349
 350                 if (key == NULL) {
 351                         dbus_message_iter_next(&value_iter);
 352                         continue;
 353                 }
 354
 355                 BT_DBG("key = %s", key);
 356
 357                 if (g_strcmp0(key, "org.bluez.MediaTransport1") == 0) {
 358                         return BT_MEDIA_TRANSFER_EVENT;
 359                 }else if (g_strcmp0(key, "org.bluez.Device1") == 0) {
 360                         return BT_DEVICE_EVENT;
 361                 }
 362                 dbus_message_iter_next(&value_iter);
 363         }
 364
 365         return 0;
 366 }
 367
 368 gboolean  _bt_parse_audio_remove_properties(DBusMessage *msg)
 369 {
 370         DBusMessageIter msg_iter;
 371         DBusMessageIter value_iter;
 372         char *object_path = NULL;
 373         char *address = NULL;
 374         int result = BLUETOOTH_ERROR_NONE;
 375         bt_headset_wait_t *wait_list;
 376
 377         retv_if(dbus_message_iter_init(msg, &msg_iter) == FALSE, FALSE);
 378
 379         dbus_message_iter_get_basic(&msg_iter, &object_path);
 380         retv_if(object_path == NULL, FALSE);
 381
 382         address = g_malloc0(BT_ADDRESS_STRING_SIZE);
 383         _bt_convert_device_path_to_address(object_path, address);
 384
 385         retv_if(dbus_message_iter_next(&msg_iter) == FALSE, FALSE);
 386         retv_if(dbus_message_iter_get_arg_type(&msg_iter) !=
 387                                         DBUS_TYPE_ARRAY, FALSE);
 388
 389         dbus_message_iter_recurse(&msg_iter, &value_iter);
 390
 391         while (dbus_message_iter_get_arg_type(&value_iter)
 392                                         != DBUS_TYPE_INVALID) {
 393                 char *key;
 394
 395                 dbus_message_iter_get_basic(&value_iter, &key);
 396
 397                 if (key == NULL) {
 398                         dbus_message_iter_next(&value_iter);
 399                         continue;
 400                 }
 401
 402                 BT_DBG("key = %s", key);
 403
 404                 if (g_strcmp0(key, "org.bluez.MediaTransport1") == 0) {
 405                         int event = BLUETOOTH_EVENT_AV_DISCONNECTED;
 406
 407                                 _bt_send_event(BT_HEADSET_EVENT, event,
 408                                         DBUS_TYPE_INT32, &result,
 409                                         DBUS_TYPE_STRING, &address,
 410                                         DBUS_TYPE_INVALID);
 411
 412                         /* Remove data from the connected list */
 413                         _bt_remove_headset_from_list(BT_AUDIO_A2DP, address);
 414                         wait_list = _bt_get_audio_wait_data();
 415
 416                         if (wait_list == NULL) {
 417                                 g_free(address);
 418                                 return TRUE;
 419                         }
 420
 421                         if (((wait_list->type == BT_AUDIO_ALL) &&
 422                                 (wait_list->ag_flag == TRUE)) ||
 423                                 (wait_list->type == BT_AUDIO_A2DP) ||
 424                                 (wait_list->disconnection_type == BT_AUDIO_A2DP)) {
 425                                 bluetooth_device_address_t device_address;
 426                                 _bt_convert_addr_string_to_type(
 427                                                         device_address.addr,
 428                                                         wait_list->address);
 429
 430                                 _bt_audio_connect(wait_list->req_id,
 431                                                         wait_list->type,
 432                                                         &device_address,
 433                                                         wait_list->out_param1);
 434                         }
 435
 436                         g_free(address);
 437                         return TRUE;
 438                 }
 439                 dbus_message_iter_next(&value_iter);
 440         }
 441
 442         g_free(address);
 443         return FALSE;
 444 }
 445
 446 static bt_remote_dev_info_t *__bt_parse_interface(DBusMessage *msg)
 447 {
 448         DBusMessageIter msg_iter;
 449         DBusMessageIter value_iter;
 450         char *object_path = NULL;
 451         bt_remote_dev_info_t *dev_info = NULL;
 452
 453         retv_if(dbus_message_iter_init(msg, &msg_iter) == FALSE, NULL);
 454
 455         dbus_message_iter_get_basic(&msg_iter, &object_path);
 456         retv_if(object_path == NULL, NULL);
 457
 458         /* object array (oa) */
 459         retv_if(dbus_message_iter_next(&msg_iter) == FALSE, NULL);
 460         retv_if(dbus_message_iter_get_arg_type(&msg_iter) !=
 461                                 DBUS_TYPE_ARRAY, NULL);
 462
 463         dbus_message_iter_recurse(&msg_iter, &value_iter);
 464
 465         /* string array (sa) */
 466         while (dbus_message_iter_get_arg_type(&value_iter) ==
 467                                         DBUS_TYPE_DICT_ENTRY) {
 468                 char *interface_name = NULL;
 469                 DBusMessageIter interface_iter;
 470
 471                 dbus_message_iter_recurse(&value_iter, &interface_iter);
 472
 473                 retv_if(dbus_message_iter_get_arg_type(&interface_iter) !=
 474                         DBUS_TYPE_STRING, NULL);
 475
 476                 dbus_message_iter_get_basic(&interface_iter, &interface_name);
 477
 478                 retv_if(dbus_message_iter_next(&interface_iter) == FALSE, NULL);
 479
 480                 retv_if(dbus_message_iter_get_arg_type(&interface_iter) !=
 481                         DBUS_TYPE_ARRAY, NULL);
 482
 483                 BT_DBG("interface: %s", interface_name);
 484
 485                 if (g_strcmp0(interface_name, "org.bluez.Device1") == 0) {
 486                         BT_DBG("Found a device: %s", object_path);
 487
 488                         dev_info = __bt_parse_device_properties(&interface_iter);
 489
 490                         if (dev_info == NULL) {
 491                                 BT_ERR("Fail to parse the properies");
 492                                 return NULL;
 493                         }
 494                 }
 495
 496                 dbus_message_iter_next(&value_iter);
 497         }
 498
 499         return dev_info;
 500 }
 501
 502 char *__bt_get_headset_name(char *address)
 503 {
 504         bluetooth_device_address_t device_address = { {0} };
 505         bluetooth_device_info_t dev_info;
 506
 507         retv_if(address == NULL, strdup(""));
 508
 509         _bt_convert_addr_string_to_type(device_address.addr, address);
 510
 511         memset(&dev_info, 0x00, sizeof(bluetooth_device_info_t));
 512
 513         _bt_get_bonded_device_info(&device_address, &dev_info);
 514
 515         return g_strdup(dev_info.device_name.name);
 516 }
 517
 518 static int __bt_get_owner_info(DBusMessage *msg, char **name,
 519                                 char **previous, char **current)
 520 {
 521         DBusMessageIter item_iter;
 522
 523         dbus_message_iter_init(msg, &item_iter);
 524
 525         if (dbus_message_iter_get_arg_type(&item_iter)
 526                                         != DBUS_TYPE_STRING) {
 527                 BT_ERR("This is bad format dbus\n");
 528                 return BLUETOOTH_ERROR_INTERNAL;
 529         }
 530
 531         dbus_message_iter_get_basic(&item_iter, name);
 532
 533         retv_if(*name == NULL, BLUETOOTH_ERROR_INTERNAL);
 534
 535         dbus_message_iter_next(&item_iter);
 536
 537         if (dbus_message_iter_get_arg_type(&item_iter)
 538                                         != DBUS_TYPE_STRING) {
 539                 BT_ERR("This is bad format dbus\n");
 540                 return BLUETOOTH_ERROR_INTERNAL;
 541         }
 542
 543         dbus_message_iter_get_basic(&item_iter, previous);
 544
 545         retv_if(*previous == NULL, BLUETOOTH_ERROR_INTERNAL);
 546
 547         dbus_message_iter_next(&item_iter);
 548
 549         if (dbus_message_iter_get_arg_type(&item_iter)
 550                                         != DBUS_TYPE_STRING) {
 551                 BT_ERR("This is bad format dbus\n");
 552                 return BLUETOOTH_ERROR_INTERNAL;
 553         }
 554
 555         dbus_message_iter_get_basic(&item_iter, current);
 556
 557         retv_if(*current == NULL, BLUETOOTH_ERROR_INTERNAL);
 558
 559         return BLUETOOTH_ERROR_NONE;
 560 }
 561
 562 static int __bt_get_agent_signal_info(DBusMessage *msg, char **address,
 563                                 char **name, char **uuid)
 564 {
 565         DBusMessageIter item_iter;
 566
 567         dbus_message_iter_init(msg, &item_iter);
 568
 569         if (dbus_message_iter_get_arg_type(&item_iter)
 570                                         != DBUS_TYPE_STRING) {
 571                 BT_ERR("This is bad format dbus\n");
 572                 return BLUETOOTH_ERROR_INTERNAL;
 573         }
 574
 575         dbus_message_iter_get_basic(&item_iter, address);
 576
 577         dbus_message_iter_next(&item_iter);
 578
 579         if (dbus_message_iter_get_arg_type(&item_iter)
 580                                         != DBUS_TYPE_STRING) {
 581                 BT_ERR("This is bad format dbus\n");
 582                 return BLUETOOTH_ERROR_INTERNAL;
 583         }
 584
 585         dbus_message_iter_get_basic(&item_iter, name);
 586
 587         dbus_message_iter_next(&item_iter);
 588
 589         if (dbus_message_iter_get_arg_type(&item_iter)
 590                                         != DBUS_TYPE_STRING) {
 591                 BT_ERR("This is bad format dbus\n");
 592                 return BLUETOOTH_ERROR_INTERNAL;
 593         }
 594
 595         dbus_message_iter_get_basic(&item_iter, uuid);
 596
 597         return BLUETOOTH_ERROR_NONE;
 598 }
 599
 600 void _bt_handle_adapter_event(DBusMessage *msg)
 601 {
 602         int result = BLUETOOTH_ERROR_NONE;
 603         DBusMessageIter item_iter;
 604         const char *member = dbus_message_get_member(msg);
 605
 606         ret_if(member == NULL);
 607
 608         if (strcasecmp(member, "DeviceCreated") == 0) {
 609                 const char *object_path = NULL;
 610                 char *address;
 611                 bt_remote_dev_info_t *remote_dev_info;
 612
 613                 ret_if(_bt_is_device_creating() == FALSE);
 614
 615                 /* Bonding from remote device */
 616                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
 617
 618                 dbus_message_iter_init(msg, &item_iter);
 619                 dbus_message_iter_get_basic(&item_iter, &object_path);
 620                 dbus_message_iter_next(&item_iter);
 621
 622                 _bt_convert_device_path_to_address(object_path, address);
 623
 624                 remote_dev_info = _bt_get_remote_device_info(address);
 625                 if (remote_dev_info == NULL) {
 626                         g_free(address);
 627                         return;
 628                 }
 629
 630                 _bt_free_device_info(remote_dev_info);
 631                 g_free(address);
 632         } else if (strcasecmp(member, "InterfacesRemoved") == 0) {
 633                 const char *object_path = NULL;
 634                 char *address;
 635                 bt_remote_dev_info_t * dev_info;
 636                 GList * node;
 637
 638                 /* Bonding from remote device */
 639                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
 640
 641                 dbus_message_iter_init(msg, &item_iter);
 642                 dbus_message_iter_get_basic(&item_iter, &object_path);
 643                 dbus_message_iter_next(&item_iter);
 644
 645                 _bt_convert_device_path_to_address(object_path, address);
 646
 647                 _bt_send_event(BT_ADAPTER_EVENT,
 648                         BLUETOOTH_EVENT_BONDED_DEVICE_REMOVED,
 649                         DBUS_TYPE_INT32, &result,
 650                         DBUS_TYPE_STRING, &address,
 651                         DBUS_TYPE_INVALID);
 652
 653                 node = g_list_first(g_list);
 654
 655                 while (node != NULL){
 656                         dev_info = (bt_remote_dev_info_t *)node->data;
 657                         if (strcasecmp(dev_info->address,
 658                                                         address) == 0) {
 659                                 g_list = g_list_remove(g_list, dev_info);
 660                                 _bt_free_device_info(dev_info);
 661                                 break;
 662                         }
 663                         node = g_list_next(node);
 664                 }
 665
 666                 g_free(address);
 667         }
 668 }
 669
 670 gboolean _bt_stop_discovery_timeout_cb(gpointer user_data)
 671 {
 672         DBusGProxy *adapter_proxy;
 673
 674         event_id = 0;
 675
 676         adapter_proxy = _bt_get_adapter_proxy();
 677         retv_if(adapter_proxy == NULL, FALSE);
 678
 679         /* Need to stop searching */
 680         dbus_g_proxy_call(adapter_proxy,
 681                                 "StopDiscovery",
 682                                 NULL,
 683                                 G_TYPE_INVALID,
 684                                 G_TYPE_INVALID);
 685
 686         return FALSE;
 687 }
 688
 689 void _bt_stop_discovery_timeout(void)
 690 {
 691         if (event_id > 0)
 692                 return;
 693
 694         event_id = g_timeout_add(BT_STOP_DISCOVERY_TIMEOUT,
 695                 (GSourceFunc)_bt_stop_discovery_timeout_cb, NULL);
 696 }
 697
 698 static gboolean __bt_discovery_finished()
 699 {
 700         int result = BLUETOOTH_ERROR_NONE;
 701
 702         if (_bt_get_cancel_by_user() == TRUE) {
 703                 result = BLUETOOTH_ERROR_CANCEL_BY_USER;
 704         }
 705
 706         _bt_set_cancel_by_user(FALSE);
 707         _bt_set_discovery_status(FALSE);
 708         _bt_send_event(BT_ADAPTER_EVENT,
 709                 BLUETOOTH_EVENT_DISCOVERY_FINISHED,
 710                 DBUS_TYPE_INT32, &result,
 711                 DBUS_TYPE_INVALID);
 712
 713         return FALSE;
 714 }
 715
 716 void __bt_adapter_property_changed_event(DBusMessageIter *msg_iter, const char *path)
 717 {
 718         DBusGProxy *adapter_proxy;
 719         int mode = 0;
 720         int result = BLUETOOTH_ERROR_NONE;
 721         DBusMessageIter value_iter;
 722         DBusMessageIter dict_iter;
 723         DBusMessageIter item_iter;
 724         GValue timeout = { 0 };
 725         const char *property = NULL;
 726
 727         dbus_message_iter_recurse(msg_iter, &item_iter);
 728
 729         if (dbus_message_iter_get_arg_type(&item_iter)
 730                                         != DBUS_TYPE_DICT_ENTRY) {
 731                 BT_ERR("This is bad format dbus\n");
 732                 return;
 733         }
 734
 735         dbus_message_iter_recurse(&item_iter, &dict_iter);
 736
 737         dbus_message_iter_get_basic(&dict_iter, &property);
 738         ret_if(property == NULL);
 739
 740         ret_if(!dbus_message_iter_next(&dict_iter));
 741
 742         if (strcasecmp(property, "Discovering") == 0) {
 743                 gboolean discovering = FALSE;
 744
 745                 dbus_message_iter_recurse(&dict_iter, &value_iter);
 746                 dbus_message_iter_get_basic(&value_iter, &discovering);
 747
 748                 /* Send event to application */
 749                 if (discovering == TRUE) {
 750                         _bt_set_discovery_status(TRUE);
 751                         _bt_send_event(BT_ADAPTER_EVENT,
 752                                 BLUETOOTH_EVENT_DISCOVERY_STARTED,
 753                                 DBUS_TYPE_INT32, &result,
 754                                 DBUS_TYPE_INVALID);
 755                         _bt_get_temp_remote_devinfo();
 756                 } else {
 757                         if (event_id > 0){
 758                                 g_source_remove(event_id);
 759                                 event_id = 0;
 760                         }
 761                         __bt_discovery_finished();
 762                 }
 763         } else if (strcasecmp(property, "Alias") == 0) {
 764                 char *name = NULL;
 765
 766                 dbus_message_iter_recurse(&dict_iter, &value_iter);
 767                 dbus_message_iter_get_basic(&value_iter, &name);
 768
 769                 /* Send event to application */
 770                 _bt_send_event(BT_ADAPTER_EVENT,
 771                                 BLUETOOTH_EVENT_LOCAL_NAME_CHANGED,
 772                                 DBUS_TYPE_INT32, &result,
 773                                 DBUS_TYPE_STRING, &name,
 774                                 DBUS_TYPE_INVALID);
 775         } else if (strcasecmp(property, "Powered") == 0) {
 776                 gboolean power = FALSE;
 777                 int power_event;
 778
 779                 dbus_message_iter_recurse(&dict_iter, &value_iter);
 780                 dbus_message_iter_get_basic(&value_iter, &power);
 781
 782                 power_event = (power == TRUE) ? BLUETOOTH_EVENT_ENABLED :
 783                                 BLUETOOTH_EVENT_DISABLED;
 784
 785                 BT_ERR("send power state: %d", power);
 786                 /* Send event to application */
 787                 _bt_send_event(BT_ADAPTER_EVENT,
 788                                         power_event,
 789                                         DBUS_TYPE_INT32, &result,
 790                                         DBUS_TYPE_INVALID);
 791         } else if (strcasecmp(property, "Discoverable") == 0) {
 792                 gboolean discoverable = FALSE;
 793
 794                 dbus_message_iter_recurse(&dict_iter, &value_iter);
 795                 dbus_message_iter_get_basic(&value_iter, &discoverable);
 796
 797                 if (discoverable == FALSE) {
 798                         if (_bt_get_discoverable_timeout_property() > 0) {
 799                                 g_value_init(&timeout, G_TYPE_UINT);
 800                                 g_value_set_uint(&timeout, 0);
 801
 802                                 adapter_proxy = _bt_get_adapter_properties_proxy();
 803                                 ret_if(adapter_proxy == NULL);
 804
 805                                 dbus_g_proxy_call_no_reply(adapter_proxy, "Set",
 806                                                 G_TYPE_STRING, BT_ADAPTER_INTERFACE,
 807                                                 G_TYPE_STRING, "DiscoverableTimeout",
 808                                                 G_TYPE_VALUE, &timeout,
 809                                                 G_TYPE_INVALID);
 810
 811                                 g_value_unset(&timeout);
 812                         }
 813
 814                         mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
 815
 816                         /* Send event to application */
 817                         _bt_send_event(BT_ADAPTER_EVENT,
 818                                         BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED,
 819                                         DBUS_TYPE_INT32, &result,
 820                                         DBUS_TYPE_INT16, &mode,
 821                                         DBUS_TYPE_INVALID);
 822                 } else {
 823                         _bt_get_discoverable_mode(&mode);
 824
 825                         /* Event will be sent by "DiscoverableTimeout" signal */
 826                         ret_if(mode != BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE);
 827
 828                         /* Send event to application */
 829                         _bt_send_event(BT_ADAPTER_EVENT,
 830                                         BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED,
 831                                         DBUS_TYPE_INT32, &result,
 832                                         DBUS_TYPE_INT16, &mode,
 833                                         DBUS_TYPE_INVALID);
 834                 }
 835         } else if (strcasecmp(property, "DiscoverableTimeout") == 0) {
 836                 _bt_get_discoverable_mode(&mode);
 837
 838                 /* Event was already sent by "Discoverable" signal */
 839                 ret_if(mode == BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE);
 840
 841                 /* Send event to application */
 842                 _bt_send_event(BT_ADAPTER_EVENT,
 843                                 BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED,
 844                                 DBUS_TYPE_INT32, &result,
 845                                 DBUS_TYPE_INT16, &mode,
 846                                 DBUS_TYPE_INVALID);
 847         }
 848 }
 849
 850 static void __bt_device_remote_connected_properties(
 851                                 bt_remote_dev_info_t *remote_dev_info,
 852                                 char *address, gboolean connected)
 853 {
 854         int result = BLUETOOTH_ERROR_NONE;
 855         int i;
 856
 857         BT_DBG("+");
 858
 859         if (remote_dev_info->uuid_count > 0 ) {
 860                 for (i = 0; i<remote_dev_info->uuid_count; i++) {
 861                         char *uuid = remote_dev_info->uuids[i];
 862                         if (strcasecmp(uuid, HID_UUID) == 0){
 863                                 int event = BLUETOOTH_EVENT_NONE;
 864
 865                                 event = (connected == TRUE) ?
 866                                         BLUETOOTH_HID_CONNECTED :
 867                                         BLUETOOTH_HID_DISCONNECTED;
 868
 869                                 _bt_send_event(BT_HID_EVENT, event,
 870                                         DBUS_TYPE_INT32, &result,
 871                                         DBUS_TYPE_STRING, &address,
 872                                         DBUS_TYPE_INVALID);
 873                                 break;
 874                         }
 875                 }
 876         }
 877
 878         BT_DBG("-");
 879 }
 880
 881 void __bt_device_property_changed_event(DBusMessageIter *msg_iter, const char *path)
 882 {
 883         int event;
 884         int result = BLUETOOTH_ERROR_NONE;
 885         DBusMessageIter value_iter;
 886         DBusMessageIter dict_iter;
 887         DBusMessageIter item_iter;
 888         const char *property = NULL;
 889         char *address;
 890         bt_remote_dev_info_t *remote_dev_info;
 891
 892         dbus_message_iter_recurse(msg_iter, &item_iter);
 893
 894         do {
 895                 if (dbus_message_iter_get_arg_type(&item_iter)
 896                                                 != DBUS_TYPE_DICT_ENTRY) {
 897                         BT_ERR("This is bad format dbus\n");
 898                         return;
 899                 }
 900
 901                 dbus_message_iter_recurse(&item_iter, &dict_iter);
 902
 903                 dbus_message_iter_get_basic(&dict_iter, &property);
 904                 ret_if(property == NULL);
 905
 906                 ret_if(!dbus_message_iter_next(&dict_iter));
 907
 908                 if (strcasecmp(property, "Connected") == 0) {
 909                         gboolean connected = FALSE;
 910
 911                         dbus_message_iter_recurse(&dict_iter, &value_iter);
 912                         dbus_message_iter_get_basic(&value_iter, &connected);
 913
 914                         event = connected ? BLUETOOTH_EVENT_DEVICE_CONNECTED :
 915                                         BLUETOOTH_EVENT_DEVICE_DISCONNECTED;
 916
 917                         address = g_malloc0(BT_ADDRESS_STRING_SIZE);
 918
 919                         _bt_convert_device_path_to_address(path, address);
 920
 921                         BT_DBG("connected: %d", connected);
 922                         BT_DBG("address: %s", address);
 923
 924                         remote_dev_info = _bt_get_remote_device_info(address);
 925
 926                         if (remote_dev_info != NULL) {
 927                                 __bt_device_remote_connected_properties(
 928                                 remote_dev_info, address, connected);
 929                         }
 930
 931                         /* Send event to application */
 932                         _bt_send_event(BT_DEVICE_EVENT,
 933                                         event,
 934                                         DBUS_TYPE_INT32, &result,
 935                                         DBUS_TYPE_STRING, &address,
 936                                         DBUS_TYPE_INVALID);
 937
 938                         g_free(address);
 939
 940                 } else if (strcasecmp(property, "Paired") == 0) {
 941                         gboolean paired = FALSE;
 942                         bt_remote_dev_info_t *remote_dev_info;
 943
 944                         dbus_message_iter_recurse(&dict_iter, &value_iter);
 945                         dbus_message_iter_get_basic(&value_iter, &paired);
 946
 947                         ret_if(paired == FALSE);
 948
 949                         /* BlueZ sends paired signal for each paired device */
 950                         /* during activation, We should ignore this, otherwise*/
 951                         /* application thinks that a new device got paired */
 952                         if (_bt_adapter_get_status() != BT_ACTIVATED) {
 953                                 BT_DBG("BT is not activated, so ignore this");
 954                                 return;
 955                         }
 956
 957                         if (_bt_is_device_creating() == TRUE) {
 958                                 BT_DBG("Try to Pair by me");
 959                                 return;
 960                         }
 961
 962                         address = g_malloc0(BT_ADDRESS_STRING_SIZE);
 963
 964                         _bt_convert_device_path_to_address(path, address);
 965
 966                         remote_dev_info = _bt_get_remote_device_info(address);
 967                         if (remote_dev_info == NULL) {
 968                                 g_free(address);
 969                                 return;
 970                         }
 971
 972                         _bt_send_event(BT_ADAPTER_EVENT,
 973                                 BLUETOOTH_EVENT_BONDING_FINISHED,
 974                                 DBUS_TYPE_INT32, &result,
 975                                 DBUS_TYPE_STRING, &address,
 976                                 DBUS_TYPE_UINT32, &remote_dev_info->class,
 977                                 DBUS_TYPE_INT16, &remote_dev_info->rssi,
 978                                 DBUS_TYPE_STRING, &remote_dev_info->name,
 979                                 DBUS_TYPE_BOOLEAN, &remote_dev_info->paired,
 980                                 DBUS_TYPE_BOOLEAN, &remote_dev_info->connected,
 981                                 DBUS_TYPE_BOOLEAN, &remote_dev_info->trust,
 982                                 DBUS_TYPE_ARRAY, DBUS_TYPE_STRING,
 983                                 &remote_dev_info->uuids, remote_dev_info->uuid_count,
 984                                 DBUS_TYPE_INVALID);
 985
 986                         _bt_free_device_info(remote_dev_info);
 987                         g_free(address);
 988                 }
 989         } while (dbus_message_iter_next(&item_iter));
 990 }
 991
 992 void __bt_obex_property_changed_event(DBusMessageIter *msg_iter, const char *path)
 993 {
 994         DBusMessageIter value_iter;
 995         DBusMessageIter dict_iter;
 996         DBusMessageIter item_iter;
 997         const char *property = NULL;
 998
 999         dbus_message_iter_recurse(msg_iter, &item_iter);
1000
1001         if (dbus_message_iter_get_arg_type(&item_iter)
1002                                         != DBUS_TYPE_DICT_ENTRY) {
1003                 BT_ERR("This is bad format dbus\n");
1004                 return;
1005         }
1006
1007         dbus_message_iter_recurse(&item_iter, &dict_iter);
1008
1009         dbus_message_iter_get_basic(&dict_iter, &property);
1010         ret_if(property == NULL);
1011
1012         ret_if(!dbus_message_iter_next(&dict_iter));
1013
1014         if (strcasecmp(property, "Status") == 0) {
1015                 const char  *status;
1016                 dbus_message_iter_recurse(&dict_iter, &value_iter);
1017                 dbus_message_iter_get_basic(&value_iter, &status);
1018
1019                 if (strcasecmp(status, "active") == 0){
1020                         _bt_obex_transfer_started(path);
1021                 }else if (strcasecmp(status, "complete") == 0) {
1022                         _bt_obex_transfer_completed(path, TRUE);
1023                 }else if (strcasecmp(status, "error") == 0){
1024                         _bt_obex_transfer_completed(path, FALSE);
1025                 }
1026         } else if (strcasecmp(property, "Transferred") == 0) {
1027                 static int transferred  = 0;
1028                 dbus_message_iter_recurse(&dict_iter, &value_iter);
1029                 dbus_message_iter_get_basic(&value_iter, &transferred);
1030
1031                 _bt_obex_transfer_progress(path,transferred);
1032         }
1033 }
1034
1035 void _bt_handle_input_event(DBusMessage *msg)
1036 {
1037         int result = BLUETOOTH_ERROR_NONE;
1038         DBusMessageIter item_iter;
1039         DBusMessageIter value_iter;
1040         gboolean property_flag = FALSE;
1041         const char *member = dbus_message_get_member(msg);
1042         const char *path = dbus_message_get_path(msg);
1043         const char *property = NULL;
1044
1045         ret_if(member == NULL);
1046
1047         dbus_message_iter_init(msg, &item_iter);
1048
1049         if (dbus_message_iter_get_arg_type(&item_iter)
1050                                         != DBUS_TYPE_STRING) {
1051                 BT_ERR("This is bad format dbus\n");
1052                 return;
1053         }
1054
1055         dbus_message_iter_get_basic(&item_iter, &property);
1056
1057         ret_if(property == NULL);
1058
1059         if (strcasecmp(property, "Connected") == 0) {
1060                 int event = BLUETOOTH_EVENT_NONE;
1061                 char *address;
1062
1063                 dbus_message_iter_next(&item_iter);
1064                 dbus_message_iter_recurse(&item_iter, &value_iter);
1065                 dbus_message_iter_get_basic(&value_iter, &property_flag);
1066
1067                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1068
1069                 _bt_convert_device_path_to_address(path, address);
1070
1071                 event = (property_flag == TRUE) ?
1072                                 BLUETOOTH_HID_CONNECTED :
1073                                 BLUETOOTH_HID_DISCONNECTED;
1074
1075                 _bt_send_event(BT_HID_EVENT, event,
1076                         DBUS_TYPE_INT32, &result,
1077                         DBUS_TYPE_STRING, &address,
1078                         DBUS_TYPE_INVALID);
1079
1080                 g_free(address);
1081         }
1082  }
1083
1084 void _bt_handle_network_server_event(DBusMessage *msg)
1085 {
1086         int result = BLUETOOTH_ERROR_NONE;
1087         char *address = NULL;
1088         char *device = NULL;
1089         const char *member = dbus_message_get_member(msg);
1090
1091         ret_if(member == NULL);
1092
1093         if (strcasecmp(member, "PeerConnected") == 0) {
1094                 if (!dbus_message_get_args(msg, NULL,
1095                         DBUS_TYPE_STRING, &device,
1096                         DBUS_TYPE_STRING, &address,
1097                         DBUS_TYPE_INVALID)) {
1098                         BT_ERR("Unexpected parameters in signal");
1099                         return;
1100                 }
1101
1102                 _bt_send_event(BT_NETWORK_EVENT, BLUETOOTH_EVENT_NETWORK_SERVER_CONNECTED,
1103                         DBUS_TYPE_INT32, &result,
1104                         DBUS_TYPE_STRING, &device,
1105                         DBUS_TYPE_STRING, &address,
1106                         DBUS_TYPE_INVALID);
1107         } else if (strcasecmp(member, "PeerDisconnected") == 0) {
1108                 if (!dbus_message_get_args(msg, NULL,
1109                         DBUS_TYPE_STRING, &device,
1110                         DBUS_TYPE_STRING, &address,
1111                         DBUS_TYPE_INVALID)) {
1112                         BT_ERR("Unexpected parameters in signal");
1113                         return;
1114                 }
1115
1116                 _bt_send_event(BT_NETWORK_EVENT, BLUETOOTH_EVENT_NETWORK_SERVER_DISCONNECTED,
1117                         DBUS_TYPE_INT32, &result,
1118                         DBUS_TYPE_STRING, &device,
1119                         DBUS_TYPE_STRING, &address,
1120                         DBUS_TYPE_INVALID);
1121         }
1122 }
1123
1124 void __bt_handle_network_client_event(DBusMessageIter *msg_iter, const char *path)
1125 {
1126         int result = BLUETOOTH_ERROR_NONE;
1127         DBusMessageIter item_iter;
1128         DBusMessageIter value_iter;
1129         DBusMessageIter dict_iter;
1130         gboolean property_flag = FALSE;
1131         const char *property = NULL;
1132
1133         dbus_message_iter_recurse(msg_iter, &item_iter);
1134
1135         if (dbus_message_iter_get_arg_type(&item_iter)
1136                                 != DBUS_TYPE_DICT_ENTRY) {
1137                 BT_ERR("This is bad format dbus\n");
1138                 return;
1139         }
1140
1141         dbus_message_iter_recurse(&item_iter, &dict_iter);
1142         dbus_message_iter_get_basic(&dict_iter, &property);
1143
1144         ret_if(property == NULL);
1145
1146         ret_if(!dbus_message_iter_next(&dict_iter));
1147
1148         if (strcasecmp(property, "Connected") == 0) {
1149                 int event = BLUETOOTH_EVENT_NONE;
1150                 char *address;
1151
1152                 dbus_message_iter_recurse(&dict_iter, &value_iter);
1153                 dbus_message_iter_get_basic(&value_iter, &property_flag);
1154
1155                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1156
1157                 _bt_convert_device_path_to_address(path, address);
1158
1159                 if (property_flag == TRUE) {
1160                         event = BLUETOOTH_EVENT_NETWORK_CONNECTED;
1161                 } else {
1162                         event = BLUETOOTH_EVENT_NETWORK_DISCONNECTED;
1163                 }
1164
1165                 _bt_send_event(BT_NETWORK_EVENT, event,
1166                         DBUS_TYPE_INT32, &result,
1167                         DBUS_TYPE_STRING, &address,
1168                         DBUS_TYPE_INVALID);
1169
1170                 g_free(address);
1171         }
1172 }
1173
1174 void _bt_handle_device_event(DBusMessage *msg)
1175 {
1176         int event;
1177         int result = BLUETOOTH_ERROR_NONE;
1178         DBusMessageIter item_iter;
1179         DBusMessageIter value_iter;
1180         char *address;
1181         const char *member = dbus_message_get_member(msg);
1182         const char *path = dbus_message_get_path(msg);
1183         const char *property = NULL;
1184
1185         ret_if(path == NULL);
1186         ret_if(member == NULL);
1187
1188         if (strcasecmp(member, "PropertyChanged") == 0) {
1189                 dbus_message_iter_init(msg, &item_iter);
1190
1191                 if (dbus_message_iter_get_arg_type(&item_iter)
1192                                                 != DBUS_TYPE_STRING) {
1193                         BT_ERR("This is bad format dbus\n");
1194                         return;
1195                 }
1196
1197                 dbus_message_iter_get_basic(&item_iter, &property);
1198
1199                 ret_if(property == NULL);
1200
1201                 if (strcasecmp(property, "Connected") == 0) {
1202                         gboolean connected = FALSE;
1203                         dbus_message_iter_next(&item_iter);
1204                         dbus_message_iter_recurse(&item_iter, &value_iter);
1205                         dbus_message_iter_get_basic(&value_iter, &connected);
1206
1207                         event = connected ? BLUETOOTH_EVENT_DEVICE_CONNECTED :
1208                                         BLUETOOTH_EVENT_DEVICE_DISCONNECTED;
1209
1210                         address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1211
1212                         _bt_convert_device_path_to_address(path, address);
1213
1214                         BT_DBG("connected: %d", connected);
1215                         BT_DBG("address: %s", address);
1216
1217                         /* Send event to application */
1218                         _bt_send_event(BT_DEVICE_EVENT,
1219                                         event,
1220                                         DBUS_TYPE_INT32, &result,
1221                                         DBUS_TYPE_STRING, &address,
1222                                         DBUS_TYPE_INVALID);
1223
1224                         g_free(address);
1225                 } else if (strcasecmp(property, "Paired") == 0) {
1226                         gboolean paired = FALSE;
1227                         bt_remote_dev_info_t *remote_dev_info;
1228                         dbus_message_iter_next(&item_iter);
1229                         dbus_message_iter_recurse(&item_iter, &value_iter);
1230                         dbus_message_iter_get_basic(&value_iter, &paired);
1231
1232                         ret_if(paired == FALSE);
1233
1234                         /* BlueZ sends paired signal for each paired device */
1235                         /* during activation, We should ignore this, otherwise*/
1236                         /* application thinks that a new device got paired */
1237                         if (_bt_adapter_get_status() != BT_ACTIVATED) {
1238                                 BT_DBG("BT is not activated, so ignore this");
1239                                 return;
1240                         }
1241
1242                         if (_bt_is_device_creating() == TRUE) {
1243                                 BT_DBG("Try to Pair by me");
1244                                 return;
1245                         }
1246
1247                         address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1248
1249                         _bt_convert_device_path_to_address(path, address);
1250
1251                         remote_dev_info = _bt_get_remote_device_info(address);
1252                         if (remote_dev_info == NULL) {
1253                                 g_free(address);
1254                                 return;
1255                         }
1256
1257                         _bt_send_event(BT_ADAPTER_EVENT,
1258                                 BLUETOOTH_EVENT_BONDING_FINISHED,
1259                                 DBUS_TYPE_INT32, &result,
1260                                 DBUS_TYPE_STRING, &address,
1261                                 DBUS_TYPE_UINT32, &remote_dev_info->class,
1262                                 DBUS_TYPE_INT16, &remote_dev_info->rssi,
1263                                 DBUS_TYPE_STRING, &remote_dev_info->name,
1264                                 DBUS_TYPE_BOOLEAN, &remote_dev_info->paired,
1265                                 DBUS_TYPE_BOOLEAN, &remote_dev_info->connected,
1266                                 DBUS_TYPE_BOOLEAN, &remote_dev_info->trust,
1267                                 DBUS_TYPE_ARRAY, DBUS_TYPE_STRING,
1268                                 &remote_dev_info->uuids, remote_dev_info->uuid_count,
1269                                 DBUS_TYPE_INVALID);
1270
1271                         _bt_free_device_info(remote_dev_info);
1272                         g_free(address);
1273                 }
1274         }
1275 }
1276
1277 void __bt_handle_media_control_event(DBusMessageIter *msg_iter,
1278                                                 const char *path)
1279 {
1280         int result = BLUETOOTH_ERROR_NONE;
1281         DBusMessageIter item_iter;
1282         DBusMessageIter value_iter;
1283         DBusMessageIter dict_iter;
1284         gboolean property_flag = FALSE;
1285         const char *property = NULL;
1286
1287         dbus_message_iter_recurse(msg_iter, &item_iter);
1288
1289         if (dbus_message_iter_get_arg_type(&item_iter)
1290                                 != DBUS_TYPE_DICT_ENTRY) {
1291                 BT_ERR("This is bad format dbus\n");
1292                 return;
1293         }
1294
1295         dbus_message_iter_recurse(&item_iter, &dict_iter);
1296
1297         dbus_message_iter_get_basic(&dict_iter, &property);
1298         ret_if(property == NULL);
1299
1300         ret_if(!dbus_message_iter_next(&dict_iter));
1301
1302         if (strcasecmp(property, "Connected") == 0) {
1303                 int event = BLUETOOTH_EVENT_NONE;
1304                 char *address;
1305
1306                 dbus_message_iter_recurse(&dict_iter, &value_iter);
1307                 dbus_message_iter_get_basic(&value_iter, &property_flag);
1308
1309                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1310
1311                 _bt_convert_device_path_to_address(path, address);
1312
1313                 event = (property_flag == TRUE) ?
1314                                 BLUETOOTH_EVENT_AV_CONNECTED :
1315                                 BLUETOOTH_EVENT_AV_DISCONNECTED;
1316
1317                 _bt_send_event(BT_AVRCP_EVENT, event,
1318                         DBUS_TYPE_INT32, &result,
1319                         DBUS_TYPE_STRING, &address,
1320                 DBUS_TYPE_INVALID);
1321
1322                 g_free(address);
1323         }
1324 }
1325
1326 void _bt_handle_property_changed_event(DBusMessage *msg)
1327 {
1328         DBusMessageIter item_iter;
1329         const char *member = dbus_message_get_member(msg);
1330         const char *interface_name = NULL;
1331
1332         ret_if(member == NULL);
1333
1334         dbus_message_iter_init(msg, &item_iter);
1335
1336         if (dbus_message_iter_get_arg_type(&item_iter)
1337                                         != DBUS_TYPE_STRING) {
1338                 BT_ERR("This is bad format dbus\n");
1339                 return;
1340         }
1341
1342         dbus_message_iter_get_basic(&item_iter, &interface_name);
1343
1344         ret_if(interface_name == NULL);
1345
1346         BT_DBG("interface: %s", interface_name);
1347
1348         ret_if(dbus_message_iter_next(&item_iter) == FALSE);
1349
1350         ret_if(dbus_message_iter_get_arg_type(&item_iter) != DBUS_TYPE_ARRAY);
1351
1352         if (strcasecmp(interface_name, BT_ADAPTER_INTERFACE) == 0) {
1353                 __bt_adapter_property_changed_event(&item_iter,
1354                                         dbus_message_get_path(msg));
1355         } else if (strcasecmp(interface_name, BT_DEVICE_INTERFACE) == 0) {
1356                 __bt_device_property_changed_event(&item_iter,
1357                                         dbus_message_get_path(msg));
1358         } else if (strcasecmp(interface_name,
1359                                         BT_OBEX_TRANSFER_INTERFACE) == 0) {
1360                 __bt_obex_property_changed_event(&item_iter,
1361                                         dbus_message_get_path(msg));
1362         } else if (strcasecmp(interface_name,
1363                                         BT_MEDIA_CONTROL_INTERFACE) == 0) {
1364                 __bt_handle_media_control_event(&item_iter,
1365                                         dbus_message_get_path(msg));
1366         } else if (strcasecmp(interface_name,
1367                                         BT_NETWORK_CLIENT_INTERFACE) == 0) {
1368                 __bt_handle_network_client_event(&item_iter,
1369                                         dbus_message_get_path(msg));
1370         } else {
1371                 BT_DBG("No bluez interface");
1372         }
1373 }
1374
1375 void __bt_set_audio_values(gboolean connected, char *address)
1376 {
1377         char *name = NULL;
1378         int bt_device_state = VCONFKEY_BT_DEVICE_NONE;
1379
1380         /*  Set the headset name */
1381         if (connected == TRUE) {
1382                 name = __bt_get_headset_name(address);
1383         } else {
1384                 name = g_strdup("");
1385         }
1386
1387         if (vconf_set_str(VCONFKEY_BT_HEADSET_NAME,
1388                                         name) != 0) {
1389                 BT_ERR("vconf_set_str failed");
1390         }
1391
1392         g_free(name);
1393
1394         /*  Set the headset state */
1395         if (vconf_get_int(VCONFKEY_BT_DEVICE,
1396                                 &bt_device_state) != 0) {
1397                 BT_ERR("vconf_get_str failed");
1398         }
1399
1400         if (connected == TRUE) {
1401                 bt_device_state |= VCONFKEY_BT_DEVICE_HEADSET_CONNECTED;
1402         } else if (bt_device_state & VCONFKEY_BT_DEVICE_HEADSET_CONNECTED) {
1403                 bt_device_state ^= VCONFKEY_BT_DEVICE_HEADSET_CONNECTED;
1404         }
1405
1406         if (vconf_set_int(VCONFKEY_BT_DEVICE,
1407                                 bt_device_state) != 0) {
1408                 BT_ERR("vconf_set_int failed");
1409         }
1410 }
1411
1412 void _bt_handle_headset_event(DBusMessage *msg)
1413 {
1414         int result = BLUETOOTH_ERROR_NONE;
1415         DBusMessageIter item_iter;
1416         DBusMessageIter value_iter;
1417         gboolean property_flag = FALSE;
1418         const char *member = dbus_message_get_member(msg);
1419         const char *path = dbus_message_get_path(msg);
1420         const char *property = NULL;
1421
1422         ret_if(member == NULL);
1423
1424         dbus_message_iter_init(msg, &item_iter);
1425
1426         if (dbus_message_iter_get_arg_type(&item_iter)
1427                                         != DBUS_TYPE_STRING) {
1428                 BT_ERR("This is bad format dbus\n");
1429                 return;
1430         }
1431
1432         dbus_message_iter_get_basic(&item_iter, &property);
1433
1434         ret_if(property == NULL);
1435
1436         /* We allow only 1 headset connection (HSP or HFP)*/
1437         if (strcasecmp(property, "Connected") == 0) {
1438                 int event = BLUETOOTH_EVENT_NONE;
1439                 char *address;
1440
1441                 dbus_message_iter_next(&item_iter);
1442                 dbus_message_iter_recurse(&item_iter, &value_iter);
1443                 dbus_message_iter_get_basic(&value_iter, &property_flag);
1444
1445                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1446
1447                 _bt_convert_device_path_to_address(path, address);
1448
1449                 if (property_flag == TRUE) {
1450                         event = BLUETOOTH_EVENT_AG_CONNECTED;
1451                 } else {
1452                         event = BLUETOOTH_EVENT_AG_DISCONNECTED;
1453                 }
1454
1455                 __bt_set_audio_values(property_flag, address);
1456
1457                 _bt_send_event(BT_HEADSET_EVENT, event,
1458                         DBUS_TYPE_INT32, &result,
1459                         DBUS_TYPE_STRING, &address,
1460                         DBUS_TYPE_INVALID);
1461
1462                 g_free(address);
1463         } else if (strcasecmp(property, "State") == 0) {
1464                 int event = BLUETOOTH_EVENT_NONE;
1465                 int sco_connected = FALSE;
1466                 char *state = NULL;
1467                 char *address;
1468
1469                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1470
1471                 _bt_convert_device_path_to_address(path, address);
1472
1473                 dbus_message_iter_next(&item_iter);
1474                 dbus_message_iter_recurse(&item_iter, &value_iter);
1475                 dbus_message_iter_get_basic(&value_iter, &state);
1476
1477                 /* This code assumes we support only 1 headset connection */
1478                 /* Need to use the headset list, if we support multi-headsets */
1479                 if (strcasecmp(property, "Playing") == 0) {
1480                         event = BLUETOOTH_EVENT_AG_AUDIO_CONNECTED;
1481                         sco_connected = TRUE;
1482                 } else if (strcasecmp(property, "connected") == 0 ||
1483                             strcasecmp(property, "disconnected") == 0) {
1484                         event = BLUETOOTH_EVENT_AG_AUDIO_DISCONNECTED;
1485                         sco_connected = FALSE;
1486                 } else {
1487                         BT_ERR("Not handled state");
1488                         g_free(address);
1489                         return;
1490                 }
1491
1492                 if (vconf_set_bool(VCONFKEY_BT_HEADSET_SCO, sco_connected) < 0)
1493                         BT_ERR("vconf_set_bool - Failed\n");
1494
1495                 _bt_send_event(BT_HEADSET_EVENT, event,
1496                         DBUS_TYPE_INT32, &result,
1497                         DBUS_TYPE_STRING, &address,
1498                         DBUS_TYPE_INVALID);
1499
1500                 g_free(address);
1501         } else if (strcasecmp(property, "SpeakerGain") == 0) {
1502                 guint16 spkr_gain;
1503                 char *address;
1504
1505                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1506
1507                 _bt_convert_device_path_to_address(path, address);
1508
1509                 dbus_message_iter_next(&item_iter);
1510                 dbus_message_iter_recurse(&item_iter, &value_iter);
1511                 dbus_message_iter_get_basic(&value_iter, &spkr_gain);
1512
1513                 _bt_send_event(BT_HEADSET_EVENT, BLUETOOTH_EVENT_AG_SPEAKER_GAIN,
1514                         DBUS_TYPE_INT32, &result,
1515                         DBUS_TYPE_STRING, &address,
1516                         DBUS_TYPE_UINT16, &spkr_gain,
1517                         DBUS_TYPE_INVALID);
1518
1519                 g_free(address);
1520         } else if (strcasecmp(property, "MicrophoneGain") == 0) {
1521                 guint16 mic_gain;
1522                 char *address;
1523
1524                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1525
1526                 _bt_convert_device_path_to_address(path, address);
1527
1528                 dbus_message_iter_next(&item_iter);
1529                 dbus_message_iter_recurse(&item_iter, &value_iter);
1530                 dbus_message_iter_get_basic(&value_iter, &mic_gain);
1531
1532                 _bt_send_event(BT_HEADSET_EVENT, BLUETOOTH_EVENT_AG_MIC_GAIN,
1533                         DBUS_TYPE_INT32, &result,
1534                         DBUS_TYPE_STRING, &address,
1535                         DBUS_TYPE_UINT16, &mic_gain,
1536                         DBUS_TYPE_INVALID);
1537
1538                 g_free(address);
1539         }
1540 }
1541
1542 void _bt_handle_agent_event(DBusMessage *msg)
1543 {
1544         const char *member = dbus_message_get_member(msg);
1545         int result = BLUETOOTH_ERROR_NONE;
1546         char *address = NULL;
1547         char *name = NULL;
1548         char *uuid = NULL;
1549
1550         ret_if(member == NULL);
1551
1552         if (strcasecmp(member, "ObexAuthorize") == 0) {
1553                 __bt_get_agent_signal_info(msg, &address, &name, &uuid);
1554
1555                 _bt_send_event(BT_OPP_SERVER_EVENT,
1556                         BLUETOOTH_EVENT_OBEX_SERVER_CONNECTION_AUTHORIZE,
1557                         DBUS_TYPE_INT32, &result,
1558                         DBUS_TYPE_STRING, &address,
1559                         DBUS_TYPE_STRING, &name,
1560                         DBUS_TYPE_INVALID);
1561         } else if (strcasecmp(member, "RfcommAuthorize") == 0) {
1562                 bt_rfcomm_server_info_t *server_info;
1563
1564                 __bt_get_agent_signal_info(msg, &address, &name, &uuid);
1565
1566                 server_info = _bt_rfcomm_get_server_info_using_uuid(uuid);
1567                 ret_if(server_info == NULL);
1568                 ret_if(server_info->server_type != BT_CUSTOM_SERVER);
1569
1570                 _bt_send_event(BT_RFCOMM_SERVER_EVENT,
1571                         BLUETOOTH_EVENT_RFCOMM_AUTHORIZE,
1572                         DBUS_TYPE_INT32, &result,
1573                         DBUS_TYPE_STRING, &address,
1574                         DBUS_TYPE_STRING, &uuid,
1575                         DBUS_TYPE_STRING, &name,
1576                         DBUS_TYPE_INT16, &server_info->control_fd,
1577                         DBUS_TYPE_INVALID);
1578         }
1579 }
1580
1581 static int __bt_get_object_path(DBusMessage *msg, char **path)
1582 {
1583         DBusMessageIter item_iter;
1584
1585         dbus_message_iter_init(msg, &item_iter);
1586
1587         if (dbus_message_iter_get_arg_type(&item_iter)
1588                                         != DBUS_TYPE_OBJECT_PATH) {
1589                 BT_ERR("This is bad format dbus\n");
1590                 return BLUETOOTH_ERROR_INTERNAL;
1591         }
1592
1593         dbus_message_iter_get_basic(&item_iter, path);
1594
1595         if (*path == NULL)
1596                 return BLUETOOTH_ERROR_INTERNAL;
1597
1598         return BLUETOOTH_ERROR_NONE;
1599 }
1600
1601 static void __bt_devices_list_free()
1602 {
1603         bt_remote_dev_info_t *dev_info;
1604         GList *node;
1605
1606         node = g_list_first(g_list);
1607
1608         while (node != NULL){
1609                 dev_info = (bt_remote_dev_info_t *)node->data;
1610
1611                 g_list = g_list_remove(g_list, dev_info);
1612                 _bt_free_device_info(dev_info);
1613
1614                 node = g_list_next(node);
1615         }
1616 }
1617
1618 static DBusHandlerResult __bt_manager_event_filter(DBusConnection *conn,
1619                                            DBusMessage *msg, void *data)
1620 {
1621         const char *member = dbus_message_get_member(msg);
1622         bt_event_type_t bt_event;
1623
1624         if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL)
1625                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1626
1627         retv_if(member == NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
1628
1629         if (strcasecmp(member, "InterfacesAdded") == 0) {
1630                 char *object_path = NULL;
1631
1632                 BT_DBG("InterfacesAdded");
1633
1634                 if (__bt_get_object_path(msg, &object_path)) {
1635                         BT_ERR("Fail to get the path");
1636                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1637                 }
1638
1639                 if (strcasecmp(object_path, BT_BLUEZ_HCI_PATH) == 0) {
1640                         _bt_handle_adapter_added();
1641                 } else {
1642                         bt_event = __bt_parse_event(msg);
1643
1644                         if (bt_event == BT_DEVICE_EVENT) {
1645                                 bt_remote_dev_info_t *dev_info;
1646                                 int result = BLUETOOTH_ERROR_NONE;
1647
1648                                 retv_if(_bt_is_discovering() == FALSE,
1649                                         DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
1650
1651                                 dev_info = __bt_parse_interface(msg);
1652
1653                                 if (dev_info == NULL) {
1654                                         BT_ERR("Fail to parse the properies");
1655                                         return
1656                                         DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1657                                 }
1658
1659                                 if (dev_info->name == NULL)
1660                                         dev_info->name = g_strdup("");
1661
1662                                 _bt_send_event(BT_ADAPTER_EVENT,
1663                                         BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND,
1664                                         DBUS_TYPE_INT32, &result,
1665                                         DBUS_TYPE_STRING, &dev_info->address,
1666                                         DBUS_TYPE_UINT32, &dev_info->class,
1667                                         DBUS_TYPE_INT16, &dev_info->rssi,
1668                                         DBUS_TYPE_STRING, &dev_info->name,
1669                                         DBUS_TYPE_BOOLEAN, &dev_info->paired,
1670                                         DBUS_TYPE_BOOLEAN,
1671                                                         &dev_info->connected,
1672                                         DBUS_TYPE_BOOLEAN, &dev_info->trust,
1673                                         DBUS_TYPE_ARRAY, DBUS_TYPE_STRING,
1674                                         &dev_info->uuids, dev_info->uuid_count,
1675                                         DBUS_TYPE_INVALID);
1676
1677                                 g_list = g_list_append(g_list, dev_info);
1678                         }else if (bt_event == BT_MEDIA_TRANSFER_EVENT) {
1679                                 __bt_parse_audio_properties(msg);
1680                         }
1681                 }
1682         } else if (strcasecmp(member, "InterfacesRemoved") == 0) {
1683                 BT_DBG("InterfacesRemoved");
1684                 bt_event = __bt_parse_remove_event(msg);
1685
1686                 if (bt_event == BT_MEDIA_TRANSFER_EVENT){
1687                         _bt_parse_audio_remove_properties(msg);
1688                 }else{
1689                         _bt_handle_adapter_event(msg);
1690                 }
1691         } else if (strcasecmp(member, "NameOwnerChanged") == 0) {
1692                 gboolean value;
1693                 char *name = NULL;
1694                 char *previous = NULL;
1695                 char *current = NULL;
1696
1697                 BT_DBG("NameOwnerChanged");
1698
1699                 if (__bt_get_owner_info(msg, &name, &previous, &current)) {
1700                         BT_ERR("Fail to get the owner info");
1701                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1702                 }
1703
1704                 if (*current != '\0')
1705                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1706
1707                 if (strcasecmp(name, "org.bluez") == 0) {
1708                         BT_DBG("Bluetoothd is terminated");
1709                         _bt_handle_adapter_removed();
1710                         __bt_devices_list_free();
1711                 }
1712
1713                 _bt_obex_server_check_allocation(&value);
1714
1715                 if (value == TRUE) {
1716                         /* Check if the obex server was terminated abnormally */
1717                         _bt_obex_server_check_termination(name);
1718                 }
1719
1720                 _bt_rfcomm_server_check_existence(&value);
1721
1722                 if (value == TRUE) {
1723                         /* The obex server was terminated abnormally */
1724                         _bt_rfcomm_server_check_termination(name);
1725                 }
1726         } else  if (dbus_message_has_interface(msg, BT_PROPERTIES_INTERFACE)) {
1727                 _bt_handle_property_changed_event(msg);
1728         } else  if (dbus_message_has_interface(msg, BT_ADAPTER_INTERFACE)) {
1729                 _bt_handle_adapter_event(msg);
1730         } else  if (dbus_message_has_interface(msg, BT_INPUT_INTERFACE)) {
1731                 _bt_handle_input_event(msg);
1732         } else  if (dbus_message_has_interface(msg, BT_NETWORK_SERVER_INTERFACE)) {
1733                 _bt_handle_network_server_event(msg);
1734         } else  if (dbus_message_has_interface(msg, BT_HFP_AGENT_INTERFACE)) {
1735                 _bt_handle_headset_event(msg);
1736         } else  if (dbus_message_has_interface(msg, BT_AGENT_INTERFACE)) {
1737                 _bt_handle_agent_event(msg);
1738         } else  if (dbus_message_has_interface(msg, BT_DEVICE_INTERFACE)) {
1739                 _bt_handle_device_event(msg);
1740         }
1741
1742         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1743 }
1744
1745 static gboolean __bt_is_obexd_event(DBusMessage *msg)
1746 {
1747         const char *member = dbus_message_get_member(msg);
1748
1749         if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL)
1750                 return FALSE;
1751
1752         retv_if(member == NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
1753
1754         if (dbus_message_has_interface(msg, BT_PROPERTIES_INTERFACE)) {
1755
1756                 DBusMessageIter item_iter;
1757                 const char *interface_name = NULL;
1758
1759                 dbus_message_iter_init(msg, &item_iter);
1760
1761                 if (dbus_message_iter_get_arg_type(&item_iter)
1762                                         != DBUS_TYPE_STRING) {
1763                         BT_ERR("This is bad format dbus\n");
1764                         return FALSE;
1765                 }
1766
1767                 dbus_message_iter_get_basic(&item_iter, &interface_name);
1768
1769                 retv_if(interface_name == NULL, FALSE);
1770
1771                 BT_DBG("interface: %s", interface_name);
1772
1773                 retv_if(dbus_message_iter_next(&item_iter) == FALSE, FALSE);
1774
1775                 retv_if(dbus_message_iter_get_arg_type(&item_iter) != DBUS_TYPE_ARRAY,
1776                                                                         FALSE);
1777
1778                 if (strcasecmp(interface_name, BT_OBEX_TRANSFER_INTERFACE) == 0)
1779                         return TRUE;
1780         }
1781
1782         return FALSE;
1783 }
1784
1785 void __bt_opc_property_changed_event(DBusMessageIter *msg_iter,
1786                                                 const char *path)
1787 {
1788         DBusMessageIter value_iter;
1789         DBusMessageIter dict_iter;
1790         DBusMessageIter item_iter;
1791         const char *property = NULL;
1792
1793         dbus_message_iter_recurse(msg_iter, &item_iter);
1794
1795         if (dbus_message_iter_get_arg_type(&item_iter)
1796                                 != DBUS_TYPE_DICT_ENTRY) {
1797                 BT_ERR("This is bad format dbus\n");
1798                 return;
1799         }
1800
1801         dbus_message_iter_recurse(&item_iter, &dict_iter);
1802
1803         dbus_message_iter_get_basic(&dict_iter, &property);
1804         ret_if(property == NULL);
1805
1806         ret_if(!dbus_message_iter_next(&dict_iter));
1807
1808         if (strcasecmp(property, "Status") == 0) {
1809                 const char *status = NULL;
1810                 dbus_message_iter_recurse(&dict_iter, &value_iter);
1811                 dbus_message_iter_get_basic(&value_iter, &status);
1812
1813                 if(strcasecmp(status, "active") == 0){
1814                         _bt_obex_client_started(path);
1815                 }else if (strcasecmp(status, "complete") == 0) {
1816                         _bt_obex_client_completed(TRUE);
1817                 }else if (strcasecmp(status, "error") == 0){
1818                         _bt_obex_client_completed(FALSE);
1819                 }
1820         } else if (strcasecmp(property, "Transferred") == 0) {
1821                 static int transferred  = 0;
1822                 dbus_message_iter_recurse(&dict_iter, &value_iter);
1823                 dbus_message_iter_get_basic(&value_iter, &transferred);
1824
1825                 _bt_obex_client_progress(transferred);
1826         }
1827 }
1828
1829 void _bt_opc_property_changed_event(DBusMessage *msg)
1830 {
1831         DBusMessageIter item_iter;
1832         const char *member = dbus_message_get_member(msg);
1833         const char *interface_name = NULL;
1834
1835         ret_if(member == NULL);
1836
1837         dbus_message_iter_init(msg, &item_iter);
1838
1839         if (dbus_message_iter_get_arg_type(&item_iter)
1840                                 != DBUS_TYPE_STRING) {
1841                 BT_ERR("This is bad format dbus\n");
1842                 return;
1843         }
1844
1845         dbus_message_iter_get_basic(&item_iter, &interface_name);
1846
1847         ret_if(interface_name == NULL);
1848
1849         BT_DBG("interface: %s", interface_name);
1850
1851         ret_if(dbus_message_iter_next(&item_iter) == FALSE);
1852
1853         ret_if(dbus_message_iter_get_arg_type(&item_iter) != DBUS_TYPE_ARRAY);
1854
1855         if (strcasecmp(interface_name, BT_OBEX_TRANSFER_INTERFACE) == 0) {
1856                 __bt_opc_property_changed_event(&item_iter,
1857                                         dbus_message_get_path(msg));
1858         } else {
1859                 BT_DBG("No bluez interface");
1860         }
1861 }
1862
1863 static gboolean __bt_is_obexd_client_event(DBusMessage *msg)
1864 {
1865         const char *member = dbus_message_get_member(msg);
1866
1867         if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL)
1868                 return FALSE;
1869
1870         retv_if(member == NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
1871
1872         if (dbus_message_has_interface(msg, BT_PROPERTIES_INTERFACE)) {
1873                 DBusMessageIter item_iter;
1874                 const char *interface_name = NULL;
1875
1876                 dbus_message_iter_init(msg, &item_iter);
1877
1878                 if (dbus_message_iter_get_arg_type(&item_iter)
1879                                                 != DBUS_TYPE_STRING) {
1880                         BT_ERR("This is bad format dbus\n");
1881                         return FALSE;
1882                 }
1883
1884                 dbus_message_iter_get_basic(&item_iter, &interface_name);
1885
1886                 retv_if(interface_name == NULL, FALSE);
1887
1888                 BT_DBG("interface: %s", interface_name);
1889
1890                 retv_if(dbus_message_iter_next(&item_iter) == FALSE,
1891                                                                 FALSE);
1892
1893                 retv_if(dbus_message_iter_get_arg_type(&item_iter)
1894                                         != DBUS_TYPE_ARRAY, FALSE);
1895
1896                 if (strcasecmp(interface_name,
1897                                         BT_OBEX_TRANSFER_INTERFACE) == 0)
1898                         return TRUE;
1899         }
1900
1901         return FALSE;
1902 }
1903
1904 static DBusHandlerResult __bt_opc_event_filter(DBusConnection *conn,
1905                                                 DBusMessage *msg, void *data)
1906 {
1907         const char *member = dbus_message_get_member(msg);
1908
1909         if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL)
1910                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1911
1912         retv_if(member == NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
1913
1914         if (strcasecmp(member, "InterfacesAdded") == 0) {
1915                 BT_DBG("InterfacesAdded");
1916         }else if (strcasecmp(member, "InterfacesRemoved") == 0) {
1917                 char *object_path = NULL;
1918
1919                 if (__bt_get_object_path(msg, &object_path)) {
1920                         BT_ERR("Fail to get the path");
1921                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1922                 }
1923
1924                 BT_DBG("object_path =%s",object_path);
1925
1926                 if (strncmp(object_path, BT_SESSION_BASEPATH_CLIENT,
1927                         strlen(BT_SESSION_BASEPATH_CLIENT)) != 0
1928                         || strstr(object_path, "transfer") == NULL)
1929                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1930
1931                 _bt_sending_files();
1932
1933         }else if (__bt_is_obexd_client_event(msg) == TRUE){
1934                 const char *path = dbus_message_get_path(msg);
1935
1936                 if (strncmp(path, BT_SESSION_BASEPATH_CLIENT,
1937                         strlen(BT_SESSION_BASEPATH_CLIENT)) != 0)
1938                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1939
1940                 _bt_opc_property_changed_event(msg);
1941         }
1942
1943         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1944 }
1945
1946 static DBusHandlerResult __bt_obexd_event_filter(DBusConnection *conn,
1947                                                 DBusMessage *msg, void *data)
1948 {
1949         const char *member = dbus_message_get_member(msg);
1950
1951         if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL)
1952                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1953
1954         retv_if(member == NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
1955
1956         if (__bt_is_obexd_event(msg) == TRUE){
1957                 const char *path = dbus_message_get_path(msg);
1958
1959                 if (strncmp(path, BT_SESSION_BASEPATH_SERVER,
1960                         strlen(BT_SESSION_BASEPATH_SERVER)) != 0)
1961                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1962
1963                 _bt_handle_property_changed_event(msg);
1964         }
1965
1966         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1967 }
1968
1969 int _bt_register_service_event(DBusGConnection *g_conn, int event_type)
1970 {
1971         DBusError dbus_error;
1972         char *match1 = NULL;
1973         char *match2 = NULL;
1974         char *match3 = NULL;
1975         char *match4 = NULL;
1976         DBusConnection *conn;
1977         DBusHandleMessageFunction event_func = NULL;
1978
1979         retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
1980
1981         conn = dbus_g_connection_get_connection(g_conn);
1982         retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
1983
1984         switch (event_type) {
1985         case BT_MANAGER_EVENT:
1986                 event_func = __bt_manager_event_filter;
1987                 match1 = g_strdup_printf(MANAGER_EVENT_MATCH_RULE,
1988                                         BT_MANAGER_INTERFACE,
1989                                         BT_INTERFACES_ADDED);
1990
1991                 match2 = g_strdup_printf(MANAGER_EVENT_MATCH_RULE,
1992                                         BT_MANAGER_INTERFACE,
1993                                         BT_INTERFACES_REMOVED);
1994
1995                 match3 = g_strdup_printf(MANAGER_EVENT_MATCH_RULE,
1996                                         BT_FREEDESKTOP_INTERFACE,
1997                                         BT_NAME_OWNER_CHANGED);
1998
1999                 match4 = g_strdup_printf(MANAGER_EVENT_MATCH_RULE,
2000                                         BT_PROPERTIES_INTERFACE,
2001                                         BT_PROPERTIES_CHANGED);
2002                 break;
2003         case BT_DEVICE_EVENT:
2004                 match1 = g_strdup_printf(EVENT_MATCH_RULE,
2005                                         BT_DEVICE_INTERFACE);
2006                 break;
2007         case BT_HID_EVENT:
2008                 match1 = g_strdup_printf(EVENT_MATCH_RULE,
2009                                         BT_INPUT_INTERFACE);
2010                 break;
2011         case BT_NETWORK_EVENT:
2012                 match1 = g_strdup_printf(EVENT_MATCH_RULE,
2013                                         BT_NETWORK_SERVER_INTERFACE);
2014
2015                 match2 = g_strdup_printf(EVENT_MATCH_RULE,
2016                                         BT_NETWORK_CLIENT_INTERFACE);
2017                 break;
2018         case BT_HEADSET_EVENT:
2019                 match1 = g_strdup_printf(EVENT_MATCH_RULE,
2020                                         BT_HFP_AGENT_INTERFACE);
2021
2022                 match2 = g_strdup_printf(EVENT_MATCH_RULE,
2023                                         BT_SINK_INTERFACE);
2024                 break;
2025         case BT_OPP_SERVER_EVENT:
2026                 event_func = __bt_obexd_event_filter;
2027                 match1 = g_strdup_printf(MANAGER_EVENT_MATCH_RULE,
2028                                         BT_PROPERTIES_INTERFACE,
2029                                         BT_PROPERTIES_CHANGED);
2030                 break;
2031         case BT_OPP_CLIENT_EVENT:
2032                 event_func = __bt_opc_event_filter;
2033                 match1 = g_strdup_printf(MANAGER_EVENT_MATCH_RULE,
2034                                         BT_PROPERTIES_INTERFACE,
2035                                         BT_PROPERTIES_CHANGED);
2036
2037                 match2 = g_strdup_printf(MANAGER_EVENT_MATCH_RULE,
2038                                         BT_MANAGER_INTERFACE,
2039                                         BT_INTERFACES_ADDED);
2040
2041                 match3 = g_strdup_printf(MANAGER_EVENT_MATCH_RULE,
2042                                         BT_MANAGER_INTERFACE,
2043                                         BT_INTERFACES_REMOVED);
2044                 break;
2045         default:
2046                 BT_ERR("Unknown event");
2047                 return BLUETOOTH_ERROR_INTERNAL;
2048         }
2049
2050         if (event_func) {
2051                 if (!dbus_connection_add_filter(conn, event_func,
2052                                                 NULL, NULL)) {
2053                         BT_ERR("Fail to add filter");
2054                         goto fail;
2055                 }
2056         }
2057
2058         dbus_error_init(&dbus_error);
2059
2060         if (match1)
2061                 dbus_bus_add_match(conn, match1, &dbus_error);
2062
2063         if (dbus_error_is_set(&dbus_error)) {
2064                 BT_ERR("Fail to add match: %s\n", dbus_error.message);
2065                 dbus_error_free(&dbus_error);
2066                 goto fail;
2067         }
2068
2069         if (match2)
2070                 dbus_bus_add_match(conn, match2, &dbus_error);
2071
2072         if (dbus_error_is_set(&dbus_error)) {
2073                 BT_ERR("Fail to add match: %s\n", dbus_error.message);
2074                 dbus_error_free(&dbus_error);
2075                 goto fail;
2076         }
2077
2078         if (match3)
2079                 dbus_bus_add_match(conn, match3, &dbus_error);
2080
2081         if (dbus_error_is_set(&dbus_error)) {
2082                 BT_ERR("Fail to add match: %s\n", dbus_error.message);
2083                 dbus_error_free(&dbus_error);
2084                 goto fail;
2085         }
2086
2087         if (match4)
2088                 dbus_bus_add_match(conn, match4, &dbus_error);
2089
2090         if (dbus_error_is_set(&dbus_error)) {
2091                 BT_ERR("Fail to add match: %s\n", dbus_error.message);
2092                 dbus_error_free(&dbus_error);
2093                 goto fail;
2094         }
2095
2096         g_free(match1);
2097         g_free(match2);
2098         g_free(match3);
2099         g_free(match4);
2100
2101         return BLUETOOTH_ERROR_NONE;
2102 fail:
2103         g_free(match1);
2104         g_free(match2);
2105         g_free(match3);
2106         g_free(match4);
2107         return BLUETOOTH_ERROR_INTERNAL;
2108 }
2109
2110 void _bt_unregister_service_event(DBusGConnection *g_conn, int event_type)
2111 {
2112         DBusConnection *conn;
2113         DBusHandleMessageFunction event_func;
2114
2115         ret_if(g_conn == NULL);
2116         conn = dbus_g_connection_get_connection(g_conn);
2117
2118         switch (event_type) {
2119         case BT_MANAGER_EVENT:
2120                 event_func = __bt_manager_event_filter;
2121                 break;
2122         case BT_OPP_SERVER_EVENT:
2123                 event_func = __bt_obexd_event_filter;
2124                 break;
2125         case BT_OPP_CLIENT_EVENT:
2126                 event_func = __bt_opc_event_filter;
2127                 break;
2128         default:
2129                 BT_ERR("Unknown event");
2130                 return;
2131         }
2132
2133         ret_if(conn == NULL);
2134
2135         dbus_connection_remove_filter(conn, event_func, NULL);
2136 }
2137
2138 static int __bt_init_manager_receiver(void)
2139 {
2140         GError *error = NULL;
2141
2142         if (manager_conn == NULL) {
2143                 manager_conn = dbus_g_bus_get(DBUS_BUS_SYSTEM, &error);
2144                 if (error != NULL) {
2145                         BT_ERR("ERROR: Can't get on system bus [%s]", error->message);
2146                         g_error_free(error);
2147                 }
2148                 retv_if(manager_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
2149         }
2150
2151         if (_bt_register_service_event(manager_conn,
2152                                 BT_MANAGER_EVENT) != BLUETOOTH_ERROR_NONE)
2153                 goto fail;
2154
2155         if (_bt_register_service_event(manager_conn,
2156                                 BT_DEVICE_EVENT) != BLUETOOTH_ERROR_NONE)
2157                 goto fail;
2158
2159         if (_bt_register_service_event(manager_conn,
2160                                 BT_HID_EVENT) != BLUETOOTH_ERROR_NONE)
2161                 goto fail;
2162
2163         if (_bt_register_service_event(manager_conn,
2164                                 BT_HEADSET_EVENT) != BLUETOOTH_ERROR_NONE)
2165                 goto fail;
2166
2167         if (_bt_register_service_event(manager_conn,
2168                                 BT_NETWORK_EVENT) != BLUETOOTH_ERROR_NONE)
2169                 goto fail;
2170
2171         return BLUETOOTH_ERROR_NONE;
2172 fail:
2173         if (manager_conn) {
2174                 dbus_g_connection_unref(manager_conn);
2175                 manager_conn = NULL;
2176         }
2177
2178         return BLUETOOTH_ERROR_INTERNAL;
2179 }
2180
2181 static int __bt_init_obexd_receiver(void)
2182 {
2183         GError *error = NULL;
2184
2185         if (obexd_conn == NULL) {
2186                 obexd_conn = dbus_g_bus_get(DBUS_BUS_SESSION, &error);
2187                 if (error != NULL) {
2188                         BT_ERR("ERROR: Can't get on session bus [%s]", error->message);
2189                         g_error_free(error);
2190                 }
2191                 retv_if(obexd_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
2192         }
2193
2194         if (_bt_register_service_event(obexd_conn,
2195                                 BT_OPP_SERVER_EVENT) != BLUETOOTH_ERROR_NONE) {
2196                 dbus_g_connection_unref(obexd_conn);
2197                 obexd_conn = NULL;
2198                 return BLUETOOTH_ERROR_INTERNAL;
2199         }
2200
2201         return BLUETOOTH_ERROR_NONE;
2202 }
2203
2204 /* To receive the event from bluez */
2205 int _bt_init_service_event_receiver(void)
2206 {
2207         int result;
2208
2209         result = __bt_init_manager_receiver();
2210         retv_if(result != BLUETOOTH_ERROR_NONE, result);
2211
2212         result = __bt_init_obexd_receiver();
2213         if (result != BLUETOOTH_ERROR_NONE)
2214                 BT_ERR("Fail to init obexd receiver");
2215
2216         return BLUETOOTH_ERROR_NONE;
2217 }
2218
2219 void _bt_deinit_service_event_reciever(void)
2220 {
2221         _bt_unregister_service_event(manager_conn, BT_MANAGER_EVENT);
2222
2223         _bt_unregister_service_event(obexd_conn, BT_OPP_SERVER_EVENT);
2224
2225         if (manager_conn) {
2226                 dbus_g_connection_unref(manager_conn);
2227                 manager_conn = NULL;
2228         }
2229
2230         if (obexd_conn) {
2231                 dbus_g_connection_unref(obexd_conn);
2232                 obexd_conn = NULL;
2233         }
2234
2235         if (event_id > 0)
2236                 g_source_remove(event_id);
2237 }
2238
2239 int _bt_opp_client_event_init(void)
2240 {
2241         GError *error = NULL;
2242
2243         if (opc_obexd_conn == NULL) {
2244                 opc_obexd_conn = dbus_g_bus_get(DBUS_BUS_SESSION, &error);
2245                 if (error != NULL) {
2246                         BT_ERR("ERROR: Can't get on session bus [%s]",
2247                                                          error->message);
2248                         g_error_free(error);
2249                 }
2250
2251                 retv_if(opc_obexd_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
2252         }
2253
2254         if (_bt_register_service_event(opc_obexd_conn,
2255                         BT_OPP_CLIENT_EVENT) != BLUETOOTH_ERROR_NONE) {
2256                 dbus_g_connection_unref(opc_obexd_conn);
2257                 opc_obexd_conn = NULL;
2258                 return BLUETOOTH_ERROR_INTERNAL;
2259         }
2260
2261         return BLUETOOTH_ERROR_NONE;
2262 }
2263
2264 void _bt_opp_client_event_deinit(void)
2265 {
2266         if (opc_obexd_conn) {
2267                 _bt_unregister_service_event(opc_obexd_conn,
2268                                                 BT_OPP_CLIENT_EVENT);
2269                 dbus_g_connection_unref(opc_obexd_conn);
2270                 opc_obexd_conn = NULL;
2271         }
2272 }
2273
2274 void _bt_get_temp_remote_devinfo(void)
2275 {
2276         bt_remote_dev_info_t *dev_info;
2277         GList *node;
2278         int result = BLUETOOTH_ERROR_NONE;
2279
2280         node = g_list_first(g_list);
2281
2282         while (node != NULL){
2283                 dev_info = (bt_remote_dev_info_t *)node->data;
2284
2285                 _bt_send_event(BT_ADAPTER_EVENT,
2286                         BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND,
2287                         DBUS_TYPE_INT32, &result,
2288                         DBUS_TYPE_STRING, &dev_info->address,
2289                         DBUS_TYPE_UINT32, &dev_info->class,
2290                         DBUS_TYPE_INT16, &dev_info->rssi,
2291                         DBUS_TYPE_STRING, &dev_info->name,
2292                         DBUS_TYPE_BOOLEAN, &dev_info->paired,
2293                         DBUS_TYPE_BOOLEAN, &dev_info->connected,
2294                         DBUS_TYPE_BOOLEAN, &dev_info->trust,
2295                         DBUS_TYPE_ARRAY, DBUS_TYPE_STRING,
2296                         &dev_info->uuids, dev_info->uuid_count,
2297                         DBUS_TYPE_INVALID);
2298
2299                 node = g_list_next(node);
2300         }
2301 }