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 gboolean _bt_stop_discovery_timeout_cb(gpointer user_data)
 601 {
 602         DBusGProxy *adapter_proxy;
 603
 604         event_id = 0;
 605
 606         adapter_proxy = _bt_get_adapter_proxy();
 607         retv_if(adapter_proxy == NULL, FALSE);
 608
 609         /* Need to stop searching */
 610         dbus_g_proxy_call(adapter_proxy,
 611                                 "StopDiscovery",
 612                                 NULL,
 613                                 G_TYPE_INVALID,
 614                                 G_TYPE_INVALID);
 615
 616         return FALSE;
 617 }
 618
 619 void _bt_stop_discovery_timeout(void)
 620 {
 621         if (event_id > 0)
 622                 return;
 623
 624         event_id = g_timeout_add(BT_STOP_DISCOVERY_TIMEOUT,
 625                 (GSourceFunc)_bt_stop_discovery_timeout_cb, NULL);
 626 }
 627
 628 static gboolean __bt_discovery_finished()
 629 {
 630         int result = BLUETOOTH_ERROR_NONE;
 631
 632         if (_bt_get_cancel_by_user() == TRUE) {
 633                 result = BLUETOOTH_ERROR_CANCEL_BY_USER;
 634         }
 635
 636         _bt_set_cancel_by_user(FALSE);
 637         _bt_set_discovery_status(FALSE);
 638         _bt_send_event(BT_ADAPTER_EVENT,
 639                 BLUETOOTH_EVENT_DISCOVERY_FINISHED,
 640                 DBUS_TYPE_INT32, &result,
 641                 DBUS_TYPE_INVALID);
 642
 643         return FALSE;
 644 }
 645
 646 void __bt_adapter_property_changed_event(DBusMessageIter *msg_iter, const char *path)
 647 {
 648         int mode = 0;
 649         int result = BLUETOOTH_ERROR_NONE;
 650         DBusMessageIter value_iter;
 651         DBusMessageIter dict_iter;
 652         DBusMessageIter item_iter;
 653         GValue timeout = { 0 };
 654         const char *property = NULL;
 655
 656         dbus_message_iter_recurse(msg_iter, &item_iter);
 657
 658         if (dbus_message_iter_get_arg_type(&item_iter)
 659                                         != DBUS_TYPE_DICT_ENTRY) {
 660                 BT_ERR("This is bad format dbus\n");
 661                 return;
 662         }
 663
 664         dbus_message_iter_recurse(&item_iter, &dict_iter);
 665
 666         dbus_message_iter_get_basic(&dict_iter, &property);
 667         ret_if(property == NULL);
 668
 669         ret_if(!dbus_message_iter_next(&dict_iter));
 670
 671         if (strcasecmp(property, "Discovering") == 0) {
 672                 gboolean discovering = FALSE;
 673
 674                 dbus_message_iter_recurse(&dict_iter, &value_iter);
 675                 dbus_message_iter_get_basic(&value_iter, &discovering);
 676
 677                 /* Send event to application */
 678                 if (discovering == TRUE) {
 679                         _bt_set_discovery_status(TRUE);
 680                         _bt_send_event(BT_ADAPTER_EVENT,
 681                                 BLUETOOTH_EVENT_DISCOVERY_STARTED,
 682                                 DBUS_TYPE_INT32, &result,
 683                                 DBUS_TYPE_INVALID);
 684                         _bt_get_temp_remote_devinfo();
 685                 } else {
 686                         if (event_id > 0){
 687                                 g_source_remove(event_id);
 688                                 event_id = 0;
 689                         }
 690                         __bt_discovery_finished();
 691                 }
 692         } else if (strcasecmp(property, "Alias") == 0) {
 693                 char *name = NULL;
 694
 695                 dbus_message_iter_recurse(&dict_iter, &value_iter);
 696                 dbus_message_iter_get_basic(&value_iter, &name);
 697
 698                 /* Send event to application */
 699                 _bt_send_event(BT_ADAPTER_EVENT,
 700                                 BLUETOOTH_EVENT_LOCAL_NAME_CHANGED,
 701                                 DBUS_TYPE_INT32, &result,
 702                                 DBUS_TYPE_STRING, &name,
 703                                 DBUS_TYPE_INVALID);
 704         } else if (strcasecmp(property, "Powered") == 0) {
 705                 gboolean power = FALSE;
 706
 707                 dbus_message_iter_recurse(&dict_iter, &value_iter);
 708                 dbus_message_iter_get_basic(&value_iter, &power);
 709
 710                 BT_DBG("power state changed: %d", power);
 711
 712                 if (power == TRUE)
 713                         _bt_set_enabled();
 714                 else
 715                         _bt_set_disabled();
 716
 717         } else if (strcasecmp(property, "Discoverable") == 0) {
 718                 gboolean discoverable = FALSE;
 719
 720                 dbus_message_iter_recurse(&dict_iter, &value_iter);
 721                 dbus_message_iter_get_basic(&value_iter, &discoverable);
 722
 723                 if (discoverable == FALSE) {
 724                         if (_bt_get_discoverable_timeout_property() > 0) {
 725                                 DBusGProxy *adapter_proxy;
 726                                 g_value_init(&timeout, G_TYPE_UINT);
 727                                 g_value_set_uint(&timeout, 0);
 728
 729                                 adapter_proxy = _bt_get_adapter_properties_proxy();
 730                                 ret_if(adapter_proxy == NULL);
 731
 732                                 dbus_g_proxy_call_no_reply(adapter_proxy, "Set",
 733                                                 G_TYPE_STRING, BT_ADAPTER_INTERFACE,
 734                                                 G_TYPE_STRING, "DiscoverableTimeout",
 735                                                 G_TYPE_VALUE, &timeout,
 736                                                 G_TYPE_INVALID);
 737
 738                                 g_value_unset(&timeout);
 739                         }
 740
 741                         mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
 742
 743                         /* Send event to application */
 744                         _bt_send_event(BT_ADAPTER_EVENT,
 745                                         BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED,
 746                                         DBUS_TYPE_INT32, &result,
 747                                         DBUS_TYPE_INT16, &mode,
 748                                         DBUS_TYPE_INVALID);
 749                 } else {
 750                         _bt_get_discoverable_mode(&mode);
 751
 752                         /* Event will be sent by "DiscoverableTimeout" signal */
 753                         ret_if(mode != BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE);
 754
 755                         /* Send event to application */
 756                         _bt_send_event(BT_ADAPTER_EVENT,
 757                                         BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED,
 758                                         DBUS_TYPE_INT32, &result,
 759                                         DBUS_TYPE_INT16, &mode,
 760                                         DBUS_TYPE_INVALID);
 761                 }
 762         } else if (strcasecmp(property, "DiscoverableTimeout") == 0) {
 763                 _bt_get_discoverable_mode(&mode);
 764
 765                 /* Event was already sent by "Discoverable" signal */
 766                 ret_if(mode == BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE);
 767
 768                 /* Send event to application */
 769                 _bt_send_event(BT_ADAPTER_EVENT,
 770                                 BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED,
 771                                 DBUS_TYPE_INT32, &result,
 772                                 DBUS_TYPE_INT16, &mode,
 773                                 DBUS_TYPE_INVALID);
 774         }
 775 }
 776
 777 static void __bt_device_remote_connected_properties(
 778                                 bt_remote_dev_info_t *remote_dev_info,
 779                                 char *address, gboolean connected)
 780 {
 781         int result = BLUETOOTH_ERROR_NONE;
 782         int i;
 783
 784         BT_DBG("+");
 785
 786         if (remote_dev_info->uuid_count > 0 ) {
 787                 for (i = 0; i<remote_dev_info->uuid_count; i++) {
 788                         char *uuid = remote_dev_info->uuids[i];
 789                         if (strcasecmp(uuid, HID_UUID) == 0){
 790                                 int event = (connected == TRUE) ?
 791                                         BLUETOOTH_HID_CONNECTED :
 792                                         BLUETOOTH_HID_DISCONNECTED;
 793
 794                                 _bt_send_event(BT_HID_EVENT, event,
 795                                         DBUS_TYPE_INT32, &result,
 796                                         DBUS_TYPE_STRING, &address,
 797                                         DBUS_TYPE_INVALID);
 798                                 break;
 799                         }
 800                 }
 801         }
 802
 803         BT_DBG("-");
 804 }
 805
 806 void __bt_device_property_changed_event(DBusMessageIter *msg_iter, const char *path)
 807 {
 808         int event;
 809         int result = BLUETOOTH_ERROR_NONE;
 810         DBusMessageIter value_iter;
 811         DBusMessageIter dict_iter;
 812         DBusMessageIter item_iter;
 813         const char *property = NULL;
 814         char *address;
 815         bt_remote_dev_info_t *remote_dev_info;
 816
 817         dbus_message_iter_recurse(msg_iter, &item_iter);
 818
 819         do {
 820                 if (dbus_message_iter_get_arg_type(&item_iter)
 821                                                 != DBUS_TYPE_DICT_ENTRY) {
 822                         BT_ERR("This is bad format dbus\n");
 823                         return;
 824                 }
 825
 826                 dbus_message_iter_recurse(&item_iter, &dict_iter);
 827
 828                 dbus_message_iter_get_basic(&dict_iter, &property);
 829                 ret_if(property == NULL);
 830
 831                 ret_if(!dbus_message_iter_next(&dict_iter));
 832
 833                 if (strcasecmp(property, "Connected") == 0) {
 834                         gboolean connected = FALSE;
 835
 836                         dbus_message_iter_recurse(&dict_iter, &value_iter);
 837                         dbus_message_iter_get_basic(&value_iter, &connected);
 838
 839                         event = connected ? BLUETOOTH_EVENT_DEVICE_CONNECTED :
 840                                         BLUETOOTH_EVENT_DEVICE_DISCONNECTED;
 841
 842                         address = g_malloc0(BT_ADDRESS_STRING_SIZE);
 843
 844                         _bt_convert_device_path_to_address(path, address);
 845
 846                         BT_DBG("connected: %d", connected);
 847                         BT_DBG("address: %s", address);
 848
 849                         remote_dev_info = _bt_get_remote_device_info(address);
 850
 851                         if (remote_dev_info != NULL) {
 852                                 __bt_device_remote_connected_properties(
 853                                 remote_dev_info, address, connected);
 854                         }
 855
 856                         /* Send event to application */
 857                         _bt_send_event(BT_DEVICE_EVENT,
 858                                         event,
 859                                         DBUS_TYPE_INT32, &result,
 860                                         DBUS_TYPE_STRING, &address,
 861                                         DBUS_TYPE_INVALID);
 862
 863                         g_free(address);
 864
 865                 } else if (strcasecmp(property, "Paired") == 0) {
 866                         gboolean paired = FALSE;
 867                         GList *node;
 868
 869                         dbus_message_iter_recurse(&dict_iter, &value_iter);
 870                         dbus_message_iter_get_basic(&value_iter, &paired);
 871
 872                         ret_if(paired == FALSE);
 873
 874                         /* BlueZ sends paired signal for each paired device */
 875                         /* during activation, We should ignore this, otherwise*/
 876                         /* application thinks that a new device got paired */
 877                         if (_bt_adapter_get_status() != BT_ACTIVATED) {
 878                                 BT_DBG("BT is not activated, so ignore this");
 879                                 return;
 880                         }
 881
 882                         address = g_malloc0(BT_ADDRESS_STRING_SIZE);
 883
 884                         _bt_convert_device_path_to_address(path, address);
 885
 886                         remote_dev_info = _bt_get_remote_device_info(address);
 887                         if (remote_dev_info == NULL) {
 888                                 g_free(address);
 889                                 return;
 890                         }
 891
 892                         node = g_list_first(g_list);
 893
 894                         while (node != NULL) {
 895                                 bt_remote_dev_info_t *dev_info;
 896                                 dev_info = (bt_remote_dev_info_t *)node->data;
 897                                 if (strcasecmp(dev_info->address, address) == 0) {
 898                                         g_list = g_list_remove(g_list, dev_info);
 899                                         _bt_free_device_info(dev_info);
 900                                 }
 901                                 node = g_list_next(node);
 902                         }
 903
 904                         if (_bt_is_device_creating() == TRUE) {
 905                                 BT_DBG("Try to Pair by me or already paired");
 906                         } else {
 907                                 _bt_send_event(BT_ADAPTER_EVENT,
 908                                         BLUETOOTH_EVENT_BONDING_FINISHED,
 909                                         DBUS_TYPE_INT32, &result,
 910                                         DBUS_TYPE_STRING, &address,
 911                                         DBUS_TYPE_UINT32, &remote_dev_info->class,
 912                                         DBUS_TYPE_INT16, &remote_dev_info->rssi,
 913                                         DBUS_TYPE_STRING, &remote_dev_info->name,
 914                                         DBUS_TYPE_BOOLEAN, &remote_dev_info->paired,
 915                                         DBUS_TYPE_BOOLEAN, &remote_dev_info->connected,
 916                                         DBUS_TYPE_BOOLEAN, &remote_dev_info->trust,
 917                                         DBUS_TYPE_ARRAY, DBUS_TYPE_STRING,
 918                                         &remote_dev_info->uuids, remote_dev_info->uuid_count,
 919                                         DBUS_TYPE_INVALID);
 920                         }
 921
 922                         _bt_free_device_info(remote_dev_info);
 923                         g_free(address);
 924                 }
 925         } while (dbus_message_iter_next(&item_iter));
 926 }
 927
 928 void __bt_obex_property_changed_event(DBusMessageIter *msg_iter, const char *path)
 929 {
 930         DBusMessageIter value_iter;
 931         DBusMessageIter dict_iter;
 932         DBusMessageIter item_iter;
 933         const char *property = NULL;
 934
 935         dbus_message_iter_recurse(msg_iter, &item_iter);
 936
 937         if (dbus_message_iter_get_arg_type(&item_iter)
 938                                         != DBUS_TYPE_DICT_ENTRY) {
 939                 BT_ERR("This is bad format dbus\n");
 940                 return;
 941         }
 942
 943         dbus_message_iter_recurse(&item_iter, &dict_iter);
 944
 945         dbus_message_iter_get_basic(&dict_iter, &property);
 946         ret_if(property == NULL);
 947
 948         ret_if(!dbus_message_iter_next(&dict_iter));
 949
 950         if (strcasecmp(property, "Status") == 0) {
 951                 const char  *status;
 952                 dbus_message_iter_recurse(&dict_iter, &value_iter);
 953                 dbus_message_iter_get_basic(&value_iter, &status);
 954
 955                 if (strcasecmp(status, "active") == 0){
 956                         _bt_obex_transfer_started(path);
 957                 }else if (strcasecmp(status, "complete") == 0) {
 958                         _bt_obex_transfer_completed(path, TRUE);
 959                 }else if (strcasecmp(status, "error") == 0){
 960                         _bt_obex_transfer_completed(path, FALSE);
 961                 }
 962         } else if (strcasecmp(property, "Transferred") == 0) {
 963                 static int transferred  = 0;
 964                 dbus_message_iter_recurse(&dict_iter, &value_iter);
 965                 dbus_message_iter_get_basic(&value_iter, &transferred);
 966
 967                 _bt_obex_transfer_progress(path,transferred);
 968         }
 969 }
 970
 971 void _bt_handle_input_event(DBusMessage *msg)
 972 {
 973         int result = BLUETOOTH_ERROR_NONE;
 974         DBusMessageIter item_iter;
 975         DBusMessageIter value_iter;
 976         gboolean property_flag = FALSE;
 977         const char *member = dbus_message_get_member(msg);
 978         const char *path = dbus_message_get_path(msg);
 979         const char *property = NULL;
 980
 981         ret_if(member == NULL);
 982
 983         dbus_message_iter_init(msg, &item_iter);
 984
 985         if (dbus_message_iter_get_arg_type(&item_iter)
 986                                         != DBUS_TYPE_STRING) {
 987                 BT_ERR("This is bad format dbus\n");
 988                 return;
 989         }
 990
 991         dbus_message_iter_get_basic(&item_iter, &property);
 992
 993         ret_if(property == NULL);
 994
 995         if (strcasecmp(property, "Connected") == 0) {
 996                 int event;
 997                 char *address;
 998
 999                 dbus_message_iter_next(&item_iter);
1000                 dbus_message_iter_recurse(&item_iter, &value_iter);
1001                 dbus_message_iter_get_basic(&value_iter, &property_flag);
1002
1003                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1004
1005                 _bt_convert_device_path_to_address(path, address);
1006
1007                 event = (property_flag == TRUE) ?
1008                                 BLUETOOTH_HID_CONNECTED :
1009                                 BLUETOOTH_HID_DISCONNECTED;
1010
1011                 _bt_send_event(BT_HID_EVENT, event,
1012                         DBUS_TYPE_INT32, &result,
1013                         DBUS_TYPE_STRING, &address,
1014                         DBUS_TYPE_INVALID);
1015
1016                 g_free(address);
1017         }
1018  }
1019
1020 void _bt_handle_network_server_event(DBusMessage *msg)
1021 {
1022         int result = BLUETOOTH_ERROR_NONE;
1023         char *address = NULL;
1024         char *device = NULL;
1025         const char *member = dbus_message_get_member(msg);
1026
1027         ret_if(member == NULL);
1028
1029         if (strcasecmp(member, "PeerConnected") == 0) {
1030                 if (!dbus_message_get_args(msg, NULL,
1031                         DBUS_TYPE_STRING, &device,
1032                         DBUS_TYPE_STRING, &address,
1033                         DBUS_TYPE_INVALID)) {
1034                         BT_ERR("Unexpected parameters in signal");
1035                         return;
1036                 }
1037
1038                 _bt_send_event(BT_NETWORK_EVENT, BLUETOOTH_EVENT_NETWORK_SERVER_CONNECTED,
1039                         DBUS_TYPE_INT32, &result,
1040                         DBUS_TYPE_STRING, &device,
1041                         DBUS_TYPE_STRING, &address,
1042                         DBUS_TYPE_INVALID);
1043         } else if (strcasecmp(member, "PeerDisconnected") == 0) {
1044                 if (!dbus_message_get_args(msg, NULL,
1045                         DBUS_TYPE_STRING, &device,
1046                         DBUS_TYPE_STRING, &address,
1047                         DBUS_TYPE_INVALID)) {
1048                         BT_ERR("Unexpected parameters in signal");
1049                         return;
1050                 }
1051
1052                 _bt_send_event(BT_NETWORK_EVENT, BLUETOOTH_EVENT_NETWORK_SERVER_DISCONNECTED,
1053                         DBUS_TYPE_INT32, &result,
1054                         DBUS_TYPE_STRING, &device,
1055                         DBUS_TYPE_STRING, &address,
1056                         DBUS_TYPE_INVALID);
1057         }
1058 }
1059
1060 void __bt_handle_network_client_event(DBusMessageIter *msg_iter, const char *path)
1061 {
1062         int result = BLUETOOTH_ERROR_NONE;
1063         DBusMessageIter item_iter;
1064         DBusMessageIter value_iter;
1065         DBusMessageIter dict_iter;
1066         gboolean property_flag = FALSE;
1067         const char *property = NULL;
1068
1069         dbus_message_iter_recurse(msg_iter, &item_iter);
1070
1071         if (dbus_message_iter_get_arg_type(&item_iter)
1072                                 != DBUS_TYPE_DICT_ENTRY) {
1073                 BT_ERR("This is bad format dbus\n");
1074                 return;
1075         }
1076
1077         dbus_message_iter_recurse(&item_iter, &dict_iter);
1078         dbus_message_iter_get_basic(&dict_iter, &property);
1079
1080         ret_if(property == NULL);
1081
1082         ret_if(!dbus_message_iter_next(&dict_iter));
1083
1084         if (strcasecmp(property, "Connected") == 0) {
1085                 int event = BLUETOOTH_EVENT_NONE;
1086                 char *address;
1087
1088                 dbus_message_iter_recurse(&dict_iter, &value_iter);
1089                 dbus_message_iter_get_basic(&value_iter, &property_flag);
1090
1091                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1092
1093                 _bt_convert_device_path_to_address(path, address);
1094
1095                 if (property_flag == TRUE) {
1096                         event = BLUETOOTH_EVENT_NETWORK_CONNECTED;
1097                 } else {
1098                         event = BLUETOOTH_EVENT_NETWORK_DISCONNECTED;
1099                 }
1100
1101                 _bt_send_event(BT_NETWORK_EVENT, event,
1102                         DBUS_TYPE_INT32, &result,
1103                         DBUS_TYPE_STRING, &address,
1104                         DBUS_TYPE_INVALID);
1105
1106                 g_free(address);
1107         }
1108 }
1109
1110 void _bt_handle_device_event(DBusMessage *msg)
1111 {
1112         int result = BLUETOOTH_ERROR_NONE;
1113         DBusMessageIter item_iter;
1114         DBusMessageIter value_iter;
1115         char *address;
1116         const char *member = dbus_message_get_member(msg);
1117         const char *path = dbus_message_get_path(msg);
1118         const char *property = NULL;
1119
1120         ret_if(path == NULL);
1121         ret_if(member == NULL);
1122
1123         if (strcasecmp(member, "PropertyChanged") == 0) {
1124                 dbus_message_iter_init(msg, &item_iter);
1125
1126                 if (dbus_message_iter_get_arg_type(&item_iter)
1127                                                 != DBUS_TYPE_STRING) {
1128                         BT_ERR("This is bad format dbus\n");
1129                         return;
1130                 }
1131
1132                 dbus_message_iter_get_basic(&item_iter, &property);
1133
1134                 ret_if(property == NULL);
1135
1136                 if (strcasecmp(property, "Connected") == 0) {
1137                         int event;
1138                         gboolean connected = FALSE;
1139                         dbus_message_iter_next(&item_iter);
1140                         dbus_message_iter_recurse(&item_iter, &value_iter);
1141                         dbus_message_iter_get_basic(&value_iter, &connected);
1142
1143                         event = connected ? BLUETOOTH_EVENT_DEVICE_CONNECTED :
1144                                         BLUETOOTH_EVENT_DEVICE_DISCONNECTED;
1145
1146                         address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1147
1148                         _bt_convert_device_path_to_address(path, address);
1149
1150                         BT_DBG("connected: %d", connected);
1151                         BT_DBG("address: %s", address);
1152
1153                         /* Send event to application */
1154                         _bt_send_event(BT_DEVICE_EVENT,
1155                                         event,
1156                                         DBUS_TYPE_INT32, &result,
1157                                         DBUS_TYPE_STRING, &address,
1158                                         DBUS_TYPE_INVALID);
1159
1160                         g_free(address);
1161                 } else if (strcasecmp(property, "Paired") == 0) {
1162                         gboolean paired = FALSE;
1163                         bt_remote_dev_info_t *remote_dev_info;
1164                         dbus_message_iter_next(&item_iter);
1165                         dbus_message_iter_recurse(&item_iter, &value_iter);
1166                         dbus_message_iter_get_basic(&value_iter, &paired);
1167
1168                         ret_if(paired == FALSE);
1169
1170                         /* BlueZ sends paired signal for each paired device */
1171                         /* during activation, We should ignore this, otherwise*/
1172                         /* application thinks that a new device got paired */
1173                         if (_bt_adapter_get_status() != BT_ACTIVATED) {
1174                                 BT_DBG("BT is not activated, so ignore this");
1175                                 return;
1176                         }
1177
1178                         if (_bt_is_device_creating() == TRUE) {
1179                                 BT_DBG("Try to Pair by me");
1180                                 return;
1181                         }
1182
1183                         address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1184
1185                         _bt_convert_device_path_to_address(path, address);
1186
1187                         remote_dev_info = _bt_get_remote_device_info(address);
1188                         if (remote_dev_info == NULL) {
1189                                 g_free(address);
1190                                 return;
1191                         }
1192
1193                         _bt_send_event(BT_ADAPTER_EVENT,
1194                                 BLUETOOTH_EVENT_BONDING_FINISHED,
1195                                 DBUS_TYPE_INT32, &result,
1196                                 DBUS_TYPE_STRING, &address,
1197                                 DBUS_TYPE_UINT32, &remote_dev_info->class,
1198                                 DBUS_TYPE_INT16, &remote_dev_info->rssi,
1199                                 DBUS_TYPE_STRING, &remote_dev_info->name,
1200                                 DBUS_TYPE_BOOLEAN, &remote_dev_info->paired,
1201                                 DBUS_TYPE_BOOLEAN, &remote_dev_info->connected,
1202                                 DBUS_TYPE_BOOLEAN, &remote_dev_info->trust,
1203                                 DBUS_TYPE_ARRAY, DBUS_TYPE_STRING,
1204                                 &remote_dev_info->uuids, remote_dev_info->uuid_count,
1205                                 DBUS_TYPE_INVALID);
1206
1207                         _bt_free_device_info(remote_dev_info);
1208                         g_free(address);
1209                 }
1210         }
1211 }
1212
1213 void __bt_handle_media_control_event(DBusMessageIter *msg_iter,
1214                                                 const char *path)
1215 {
1216         int result = BLUETOOTH_ERROR_NONE;
1217         DBusMessageIter item_iter;
1218         DBusMessageIter value_iter;
1219         DBusMessageIter dict_iter;
1220         gboolean property_flag = FALSE;
1221         const char *property = NULL;
1222
1223         dbus_message_iter_recurse(msg_iter, &item_iter);
1224
1225         if (dbus_message_iter_get_arg_type(&item_iter)
1226                                 != DBUS_TYPE_DICT_ENTRY) {
1227                 BT_ERR("This is bad format dbus\n");
1228                 return;
1229         }
1230
1231         dbus_message_iter_recurse(&item_iter, &dict_iter);
1232
1233         dbus_message_iter_get_basic(&dict_iter, &property);
1234         ret_if(property == NULL);
1235
1236         ret_if(!dbus_message_iter_next(&dict_iter));
1237
1238         if (strcasecmp(property, "Connected") == 0) {
1239                 int event;
1240                 char *address;
1241
1242                 dbus_message_iter_recurse(&dict_iter, &value_iter);
1243                 dbus_message_iter_get_basic(&value_iter, &property_flag);
1244
1245                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1246
1247                 _bt_convert_device_path_to_address(path, address);
1248
1249                 event = (property_flag == TRUE) ?
1250                                 BLUETOOTH_EVENT_AV_CONNECTED :
1251                                 BLUETOOTH_EVENT_AV_DISCONNECTED;
1252
1253                 _bt_send_event(BT_AVRCP_EVENT, event,
1254                         DBUS_TYPE_INT32, &result,
1255                         DBUS_TYPE_STRING, &address,
1256                 DBUS_TYPE_INVALID);
1257
1258                 g_free(address);
1259         }
1260 }
1261
1262 void _bt_handle_property_changed_event(DBusMessage *msg)
1263 {
1264         DBusMessageIter item_iter;
1265         const char *member = dbus_message_get_member(msg);
1266         const char *interface_name = NULL;
1267
1268         ret_if(member == NULL);
1269
1270         dbus_message_iter_init(msg, &item_iter);
1271
1272         if (dbus_message_iter_get_arg_type(&item_iter)
1273                                         != DBUS_TYPE_STRING) {
1274                 BT_ERR("This is bad format dbus\n");
1275                 return;
1276         }
1277
1278         dbus_message_iter_get_basic(&item_iter, &interface_name);
1279
1280         ret_if(interface_name == NULL);
1281
1282         BT_DBG("interface: %s", interface_name);
1283
1284         ret_if(dbus_message_iter_next(&item_iter) == FALSE);
1285
1286         ret_if(dbus_message_iter_get_arg_type(&item_iter) != DBUS_TYPE_ARRAY);
1287
1288         if (strcasecmp(interface_name, BT_ADAPTER_INTERFACE) == 0) {
1289                 __bt_adapter_property_changed_event(&item_iter,
1290                                         dbus_message_get_path(msg));
1291         } else if (strcasecmp(interface_name, BT_DEVICE_INTERFACE) == 0) {
1292                 __bt_device_property_changed_event(&item_iter,
1293                                         dbus_message_get_path(msg));
1294         } else if (strcasecmp(interface_name,
1295                                         BT_OBEX_TRANSFER_INTERFACE) == 0) {
1296                 __bt_obex_property_changed_event(&item_iter,
1297                                         dbus_message_get_path(msg));
1298         } else if (strcasecmp(interface_name,
1299                                         BT_MEDIA_CONTROL_INTERFACE) == 0) {
1300                 __bt_handle_media_control_event(&item_iter,
1301                                         dbus_message_get_path(msg));
1302         } else if (strcasecmp(interface_name,
1303                                         BT_NETWORK_CLIENT_INTERFACE) == 0) {
1304                 __bt_handle_network_client_event(&item_iter,
1305                                         dbus_message_get_path(msg));
1306         } else {
1307                 BT_DBG("No bluez interface");
1308         }
1309 }
1310
1311 void __bt_set_audio_values(gboolean connected, char *address)
1312 {
1313         char *name = NULL;
1314         int bt_device_state = VCONFKEY_BT_DEVICE_NONE;
1315
1316         /*  Set the headset name */
1317         if (connected == TRUE) {
1318                 name = __bt_get_headset_name(address);
1319         } else {
1320                 name = g_strdup("");
1321         }
1322
1323         if (vconf_set_str(VCONFKEY_BT_HEADSET_NAME,
1324                                         name) != 0) {
1325                 BT_ERR("vconf_set_str failed");
1326         }
1327
1328         g_free(name);
1329
1330         /*  Set the headset state */
1331         if (vconf_get_int(VCONFKEY_BT_DEVICE,
1332                                 &bt_device_state) != 0) {
1333                 BT_ERR("vconf_get_str failed");
1334         }
1335
1336         if (connected == TRUE) {
1337                 bt_device_state |= VCONFKEY_BT_DEVICE_HEADSET_CONNECTED;
1338         } else if (bt_device_state & VCONFKEY_BT_DEVICE_HEADSET_CONNECTED) {
1339                 bt_device_state ^= VCONFKEY_BT_DEVICE_HEADSET_CONNECTED;
1340         }
1341
1342         if (vconf_set_int(VCONFKEY_BT_DEVICE,
1343                                 bt_device_state) != 0) {
1344                 BT_ERR("vconf_set_int failed");
1345         }
1346 }
1347
1348 void _bt_handle_headset_event(DBusMessage *msg)
1349 {
1350         int result = BLUETOOTH_ERROR_NONE;
1351         DBusMessageIter item_iter;
1352         DBusMessageIter value_iter;
1353         gboolean property_flag = FALSE;
1354         const char *member = dbus_message_get_member(msg);
1355         const char *path = dbus_message_get_path(msg);
1356         const char *property = NULL;
1357
1358         ret_if(member == NULL);
1359
1360         dbus_message_iter_init(msg, &item_iter);
1361
1362         if (dbus_message_iter_get_arg_type(&item_iter)
1363                                         != DBUS_TYPE_STRING) {
1364                 BT_ERR("This is bad format dbus\n");
1365                 return;
1366         }
1367
1368         dbus_message_iter_get_basic(&item_iter, &property);
1369
1370         ret_if(property == NULL);
1371
1372         /* We allow only 1 headset connection (HSP or HFP)*/
1373         if (strcasecmp(property, "Connected") == 0) {
1374                 int event = BLUETOOTH_EVENT_NONE;
1375                 char *address;
1376
1377                 dbus_message_iter_next(&item_iter);
1378                 dbus_message_iter_recurse(&item_iter, &value_iter);
1379                 dbus_message_iter_get_basic(&value_iter, &property_flag);
1380
1381                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1382
1383                 _bt_convert_device_path_to_address(path, address);
1384
1385                 if (property_flag == TRUE) {
1386                         event = BLUETOOTH_EVENT_AG_CONNECTED;
1387                 } else {
1388                         event = BLUETOOTH_EVENT_AG_DISCONNECTED;
1389                 }
1390
1391                 __bt_set_audio_values(property_flag, address);
1392
1393                 _bt_send_event(BT_HEADSET_EVENT, event,
1394                         DBUS_TYPE_INT32, &result,
1395                         DBUS_TYPE_STRING, &address,
1396                         DBUS_TYPE_INVALID);
1397
1398                 g_free(address);
1399         } else if (strcasecmp(property, "State") == 0) {
1400                 int event = BLUETOOTH_EVENT_NONE;
1401                 int sco_connected = FALSE;
1402                 char *state = NULL;
1403                 char *address;
1404
1405                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1406
1407                 _bt_convert_device_path_to_address(path, address);
1408
1409                 dbus_message_iter_next(&item_iter);
1410                 dbus_message_iter_recurse(&item_iter, &value_iter);
1411                 dbus_message_iter_get_basic(&value_iter, &state);
1412
1413                 /* This code assumes we support only 1 headset connection */
1414                 /* Need to use the headset list, if we support multi-headsets */
1415                 if (strcasecmp(property, "Playing") == 0) {
1416                         event = BLUETOOTH_EVENT_AG_AUDIO_CONNECTED;
1417                         sco_connected = TRUE;
1418                 } else if (strcasecmp(property, "connected") == 0 ||
1419                             strcasecmp(property, "disconnected") == 0) {
1420                         event = BLUETOOTH_EVENT_AG_AUDIO_DISCONNECTED;
1421                         sco_connected = FALSE;
1422                 } else {
1423                         BT_ERR("Not handled state");
1424                         g_free(address);
1425                         return;
1426                 }
1427
1428                 if (vconf_set_bool(VCONFKEY_BT_HEADSET_SCO, sco_connected) < 0)
1429                         BT_ERR("vconf_set_bool - Failed\n");
1430
1431                 _bt_send_event(BT_HEADSET_EVENT, event,
1432                         DBUS_TYPE_INT32, &result,
1433                         DBUS_TYPE_STRING, &address,
1434                         DBUS_TYPE_INVALID);
1435
1436                 g_free(address);
1437         } else if (strcasecmp(property, "SpeakerGain") == 0) {
1438                 guint16 spkr_gain;
1439                 char *address;
1440
1441                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1442
1443                 _bt_convert_device_path_to_address(path, address);
1444
1445                 dbus_message_iter_next(&item_iter);
1446                 dbus_message_iter_recurse(&item_iter, &value_iter);
1447                 dbus_message_iter_get_basic(&value_iter, &spkr_gain);
1448
1449                 _bt_send_event(BT_HEADSET_EVENT, BLUETOOTH_EVENT_AG_SPEAKER_GAIN,
1450                         DBUS_TYPE_INT32, &result,
1451                         DBUS_TYPE_STRING, &address,
1452                         DBUS_TYPE_UINT16, &spkr_gain,
1453                         DBUS_TYPE_INVALID);
1454
1455                 g_free(address);
1456         } else if (strcasecmp(property, "MicrophoneGain") == 0) {
1457                 guint16 mic_gain;
1458                 char *address;
1459
1460                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1461
1462                 _bt_convert_device_path_to_address(path, address);
1463
1464                 dbus_message_iter_next(&item_iter);
1465                 dbus_message_iter_recurse(&item_iter, &value_iter);
1466                 dbus_message_iter_get_basic(&value_iter, &mic_gain);
1467
1468                 _bt_send_event(BT_HEADSET_EVENT, BLUETOOTH_EVENT_AG_MIC_GAIN,
1469                         DBUS_TYPE_INT32, &result,
1470                         DBUS_TYPE_STRING, &address,
1471                         DBUS_TYPE_UINT16, &mic_gain,
1472                         DBUS_TYPE_INVALID);
1473
1474                 g_free(address);
1475         }
1476 }
1477
1478 void _bt_handle_agent_event(DBusMessage *msg)
1479 {
1480         const char *member = dbus_message_get_member(msg);
1481         int result = BLUETOOTH_ERROR_NONE;
1482         char *address = NULL;
1483         char *name = NULL;
1484         char *uuid = NULL;
1485
1486         ret_if(member == NULL);
1487
1488         if (strcasecmp(member, "ObexAuthorize") == 0) {
1489                 __bt_get_agent_signal_info(msg, &address, &name, &uuid);
1490
1491                 _bt_send_event(BT_OPP_SERVER_EVENT,
1492                         BLUETOOTH_EVENT_OBEX_SERVER_CONNECTION_AUTHORIZE,
1493                         DBUS_TYPE_INT32, &result,
1494                         DBUS_TYPE_STRING, &address,
1495                         DBUS_TYPE_STRING, &name,
1496                         DBUS_TYPE_INVALID);
1497         } else if (strcasecmp(member, "RfcommAuthorize") == 0) {
1498                 bt_rfcomm_server_info_t *server_info;
1499
1500                 __bt_get_agent_signal_info(msg, &address, &name, &uuid);
1501
1502                 server_info = _bt_rfcomm_get_server_info_using_uuid(uuid);
1503                 ret_if(server_info == NULL);
1504                 ret_if(server_info->server_type != BT_CUSTOM_SERVER);
1505
1506                 _bt_send_event(BT_RFCOMM_SERVER_EVENT,
1507                         BLUETOOTH_EVENT_RFCOMM_AUTHORIZE,
1508                         DBUS_TYPE_INT32, &result,
1509                         DBUS_TYPE_STRING, &address,
1510                         DBUS_TYPE_STRING, &uuid,
1511                         DBUS_TYPE_STRING, &name,
1512                         DBUS_TYPE_INT16, &server_info->control_fd,
1513                         DBUS_TYPE_INVALID);
1514         }
1515 }
1516
1517 static int __bt_get_object_path(DBusMessage *msg, char **path)
1518 {
1519         DBusMessageIter item_iter;
1520
1521         dbus_message_iter_init(msg, &item_iter);
1522
1523         if (dbus_message_iter_get_arg_type(&item_iter)
1524                                         != DBUS_TYPE_OBJECT_PATH) {
1525                 BT_ERR("This is bad format dbus\n");
1526                 return BLUETOOTH_ERROR_INTERNAL;
1527         }
1528
1529         dbus_message_iter_get_basic(&item_iter, path);
1530
1531         if (*path == NULL)
1532                 return BLUETOOTH_ERROR_INTERNAL;
1533
1534         return BLUETOOTH_ERROR_NONE;
1535 }
1536
1537 static void __bt_devices_list_free()
1538 {
1539         GList *node;
1540
1541         node = g_list_first(g_list);
1542
1543         while (node != NULL){
1544                 bt_remote_dev_info_t *dev_info;
1545                 dev_info = (bt_remote_dev_info_t *)node->data;
1546
1547                 g_list = g_list_remove(g_list, dev_info);
1548                 _bt_free_device_info(dev_info);
1549
1550                 node = g_list_next(node);
1551         }
1552 }
1553
1554 static DBusHandlerResult __bt_manager_event_filter(DBusConnection *conn,
1555                                            DBusMessage *msg, void *data)
1556 {
1557         const char *member = dbus_message_get_member(msg);
1558         bt_event_type_t bt_event;
1559
1560         if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL)
1561                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1562
1563         retv_if(member == NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
1564
1565         BT_DBG("interface: %s | member: %s", dbus_message_get_interface(msg), member);
1566
1567         if (strcasecmp(member, "InterfacesAdded") == 0) {
1568                 char *object_path = NULL;
1569
1570                 if (__bt_get_object_path(msg, &object_path)) {
1571                         BT_ERR("Fail to get the path");
1572                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1573                 }
1574
1575                 bt_event = __bt_parse_event(msg);
1576
1577                 if (bt_event == BT_DEVICE_EVENT) {
1578                         bt_remote_dev_info_t *dev_info;
1579                         int result = BLUETOOTH_ERROR_NONE;
1580
1581                         retv_if(_bt_is_discovering() == FALSE,
1582                                 DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
1583
1584                         dev_info = __bt_parse_interface(msg);
1585
1586                         if (dev_info == NULL) {
1587                                 BT_ERR("Fail to parse the properies");
1588                                 return
1589                                 DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1590                         }
1591
1592                         if (dev_info->name == NULL)
1593                                 dev_info->name = g_strdup("");
1594
1595                         _bt_send_event(BT_ADAPTER_EVENT,
1596                                 BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND,
1597                                 DBUS_TYPE_INT32, &result,
1598                                 DBUS_TYPE_STRING, &dev_info->address,
1599                                 DBUS_TYPE_UINT32, &dev_info->class,
1600                                 DBUS_TYPE_INT16, &dev_info->rssi,
1601                                 DBUS_TYPE_STRING, &dev_info->name,
1602                                 DBUS_TYPE_BOOLEAN, &dev_info->paired,
1603                                 DBUS_TYPE_BOOLEAN,
1604                                                 &dev_info->connected,
1605                                 DBUS_TYPE_BOOLEAN, &dev_info->trust,
1606                                 DBUS_TYPE_ARRAY, DBUS_TYPE_STRING,
1607                                 &dev_info->uuids, dev_info->uuid_count,
1608                                 DBUS_TYPE_INVALID);
1609                         if (!dev_info->paired)
1610                                 g_list = g_list_append(g_list, dev_info);
1611                         else
1612                                 _bt_free_device_info(dev_info);
1613                 } else if (bt_event == BT_MEDIA_TRANSFER_EVENT) {
1614                         __bt_parse_audio_properties(msg);
1615                 }
1616
1617         } else if (strcasecmp(member, "InterfacesRemoved") == 0) {
1618
1619                 bt_event = __bt_parse_remove_event(msg);
1620
1621                 if (bt_event == BT_MEDIA_TRANSFER_EVENT){
1622                         _bt_parse_audio_remove_properties(msg);
1623                 } else if (bt_event == BT_DEVICE_EVENT) {
1624                         char *object_path = NULL;
1625                         if (__bt_get_object_path(msg, &object_path)) {
1626                                 BT_ERR("Fail to get the path");
1627                                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1628                         }
1629
1630                         if (strncasecmp(object_path, BT_BLUEZ_HCI_DEV_PATH, strlen(BT_BLUEZ_HCI_DEV_PATH)) == 0) {
1631                                 int result = BLUETOOTH_ERROR_NONE;
1632                                 char *address;
1633                                 bt_remote_dev_info_t *dev_info;
1634                                 GList * node;
1635                                 gboolean is_in_glist = FALSE;
1636
1637                                 BT_DBG("device interface removed | path: %s", object_path);
1638
1639                                 /* Remove bonding from remote device */
1640                                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
1641
1642                                 _bt_convert_device_path_to_address(object_path, address);
1643
1644                                 node = g_list_first(g_list);
1645
1646                                 while (node != NULL) {
1647                                         dev_info = (bt_remote_dev_info_t *)node->data;
1648                                         if (strcasecmp(dev_info->address, address) == 0) {
1649                                                 is_in_glist = TRUE;
1650
1651                                                 BT_DBG("Bluez removes device %s, send device disappear event", dev_info->name);
1652                                                 _bt_send_event(BT_ADAPTER_EVENT,
1653                                                         BLUETOOTH_EVENT_REMOTE_DEVICE_DISAPPEARED,
1654                                                         DBUS_TYPE_INT32, &result,
1655                                                         DBUS_TYPE_STRING, &dev_info->address,
1656                                                         DBUS_TYPE_UINT32, &dev_info->class,
1657                                                         DBUS_TYPE_INT16, &dev_info->rssi,
1658                                                         DBUS_TYPE_STRING, &dev_info->name,
1659                                                         DBUS_TYPE_BOOLEAN, &dev_info->paired,
1660                                                         DBUS_TYPE_BOOLEAN, &dev_info->connected,
1661                                                         DBUS_TYPE_BOOLEAN, &dev_info->trust,
1662                                                         DBUS_TYPE_ARRAY, DBUS_TYPE_STRING,
1663                                                         &dev_info->uuids, dev_info->uuid_count,
1664                                                         DBUS_TYPE_INVALID);
1665
1666                                                 g_list = g_list_remove(g_list, dev_info);
1667                                                 _bt_free_device_info(dev_info);
1668                                                 break;
1669                                         }
1670                                         node = g_list_next(node);
1671                                 }
1672                                 /* if device is not in glist, we need to trig destroy bonding event */
1673                                 if (!is_in_glist) {
1674                                         BT_DBG("send bt bond destroy event");
1675                                         _bt_send_event(BT_ADAPTER_EVENT,
1676                                                 BLUETOOTH_EVENT_BONDED_DEVICE_REMOVED,
1677                                                 DBUS_TYPE_INT32, &result,
1678                                                 DBUS_TYPE_STRING, &address,
1679                                                 DBUS_TYPE_INVALID);
1680                                 }
1681                                 g_free(address);
1682                         }
1683                 } else {
1684                         char *object_path = NULL;
1685                         if (__bt_get_object_path(msg, &object_path)) {
1686                                 BT_ERR("Fail to get the path");
1687                                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1688                         }
1689                 }
1690         } else if (strcasecmp(member, "NameOwnerChanged") == 0) {
1691                 gboolean value;
1692                 char *name = NULL;
1693                 char *previous = NULL;
1694                 char *current = NULL;
1695
1696                 BT_DBG("NameOwnerChanged");
1697
1698                 if (__bt_get_owner_info(msg, &name, &previous, &current)) {
1699                         BT_ERR("Fail to get the owner info");
1700                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1701                 }
1702
1703                 if (*current != '\0')
1704                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1705
1706                 if (strcasecmp(name, "org.bluez") == 0) {
1707                         BT_DBG("Bluetoothd is terminated");
1708                         _bt_handle_adapter_removed();
1709                         __bt_devices_list_free();
1710                 }
1711
1712                 _bt_obex_server_check_allocation(&value);
1713
1714                 if (value == TRUE) {
1715                         /* Check if the obex server was terminated abnormally */
1716                         _bt_obex_server_check_termination(name);
1717                 }
1718
1719                 _bt_rfcomm_server_check_existence(&value);
1720
1721                 if (value == TRUE) {
1722                         /* The obex server was terminated abnormally */
1723                         _bt_rfcomm_server_check_termination(name);
1724                 }
1725         } else  if (dbus_message_has_interface(msg, BT_PROPERTIES_INTERFACE)) {
1726                 _bt_handle_property_changed_event(msg);
1727         } else  if (dbus_message_has_interface(msg, BT_INPUT_INTERFACE)) {
1728                 _bt_handle_input_event(msg);
1729         } else  if (dbus_message_has_interface(msg, BT_NETWORK_SERVER_INTERFACE)) {
1730                 _bt_handle_network_server_event(msg);
1731         } else  if (dbus_message_has_interface(msg, BT_HFP_AGENT_INTERFACE)) {
1732                 _bt_handle_headset_event(msg);
1733         } else  if (dbus_message_has_interface(msg, BT_AGENT_INTERFACE)) {
1734                 _bt_handle_agent_event(msg);
1735         } else  if (dbus_message_has_interface(msg, BT_DEVICE_INTERFACE)) {
1736                 _bt_handle_device_event(msg);
1737         }
1738
1739         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1740 }
1741
1742 static gboolean __bt_is_obexd_event(DBusMessage *msg)
1743 {
1744         const char *member = dbus_message_get_member(msg);
1745
1746         if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL)
1747                 return FALSE;
1748
1749         retv_if(member == NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
1750
1751         if (dbus_message_has_interface(msg, BT_PROPERTIES_INTERFACE)) {
1752
1753                 DBusMessageIter item_iter;
1754                 const char *interface_name = NULL;
1755
1756                 dbus_message_iter_init(msg, &item_iter);
1757
1758                 if (dbus_message_iter_get_arg_type(&item_iter)
1759                                         != DBUS_TYPE_STRING) {
1760                         BT_ERR("This is bad format dbus\n");
1761                         return FALSE;
1762                 }
1763
1764                 dbus_message_iter_get_basic(&item_iter, &interface_name);
1765
1766                 retv_if(interface_name == NULL, FALSE);
1767
1768                 BT_DBG("interface: %s", interface_name);
1769
1770                 retv_if(dbus_message_iter_next(&item_iter) == FALSE, FALSE);
1771
1772                 retv_if(dbus_message_iter_get_arg_type(&item_iter) != DBUS_TYPE_ARRAY,
1773                                                                         FALSE);
1774
1775                 if (strcasecmp(interface_name, BT_OBEX_TRANSFER_INTERFACE) == 0)
1776                         return TRUE;
1777         }
1778
1779         return FALSE;
1780 }
1781
1782 void __bt_opc_property_changed_event(DBusMessageIter *msg_iter,
1783                                                 const char *path)
1784 {
1785         DBusMessageIter value_iter;
1786         DBusMessageIter dict_iter;
1787         DBusMessageIter item_iter;
1788         const char *property = NULL;
1789
1790         dbus_message_iter_recurse(msg_iter, &item_iter);
1791
1792         if (dbus_message_iter_get_arg_type(&item_iter)
1793                                 != DBUS_TYPE_DICT_ENTRY) {
1794                 BT_ERR("This is bad format dbus\n");
1795                 return;
1796         }
1797
1798         dbus_message_iter_recurse(&item_iter, &dict_iter);
1799
1800         dbus_message_iter_get_basic(&dict_iter, &property);
1801         ret_if(property == NULL);
1802
1803         ret_if(!dbus_message_iter_next(&dict_iter));
1804
1805         if (strcasecmp(property, "Status") == 0) {
1806                 const char *status = NULL;
1807                 dbus_message_iter_recurse(&dict_iter, &value_iter);
1808                 dbus_message_iter_get_basic(&value_iter, &status);
1809
1810                 if(strcasecmp(status, "active") == 0){
1811                         _bt_obex_client_started(path);
1812                 }else if (strcasecmp(status, "complete") == 0) {
1813                         _bt_obex_client_completed(TRUE);
1814                 }else if (strcasecmp(status, "error") == 0){
1815                         _bt_obex_client_completed(FALSE);
1816                 }
1817         } else if (strcasecmp(property, "Transferred") == 0) {
1818                 static int transferred  = 0;
1819                 dbus_message_iter_recurse(&dict_iter, &value_iter);
1820                 dbus_message_iter_get_basic(&value_iter, &transferred);
1821
1822                 _bt_obex_client_progress(transferred);
1823         }
1824 }
1825
1826 void _bt_opc_property_changed_event(DBusMessage *msg)
1827 {
1828         DBusMessageIter item_iter;
1829         const char *member = dbus_message_get_member(msg);
1830         const char *interface_name = NULL;
1831
1832         ret_if(member == NULL);
1833
1834         dbus_message_iter_init(msg, &item_iter);
1835
1836         if (dbus_message_iter_get_arg_type(&item_iter)
1837                                 != DBUS_TYPE_STRING) {
1838                 BT_ERR("This is bad format dbus\n");
1839                 return;
1840         }
1841
1842         dbus_message_iter_get_basic(&item_iter, &interface_name);
1843
1844         ret_if(interface_name == NULL);
1845
1846         BT_DBG("interface: %s", interface_name);
1847
1848         ret_if(dbus_message_iter_next(&item_iter) == FALSE);
1849
1850         ret_if(dbus_message_iter_get_arg_type(&item_iter) != DBUS_TYPE_ARRAY);
1851
1852         if (strcasecmp(interface_name, BT_OBEX_TRANSFER_INTERFACE) == 0) {
1853                 __bt_opc_property_changed_event(&item_iter,
1854                                         dbus_message_get_path(msg));
1855         } else {
1856                 BT_DBG("No bluez interface");
1857         }
1858 }
1859
1860 static gboolean __bt_is_obexd_client_event(DBusMessage *msg)
1861 {
1862         const char *member = dbus_message_get_member(msg);
1863
1864         if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL)
1865                 return FALSE;
1866
1867         retv_if(member == NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
1868
1869         if (dbus_message_has_interface(msg, BT_PROPERTIES_INTERFACE)) {
1870                 DBusMessageIter item_iter;
1871                 const char *interface_name = NULL;
1872
1873                 dbus_message_iter_init(msg, &item_iter);
1874
1875                 if (dbus_message_iter_get_arg_type(&item_iter)
1876                                                 != DBUS_TYPE_STRING) {
1877                         BT_ERR("This is bad format dbus\n");
1878                         return FALSE;
1879                 }
1880
1881                 dbus_message_iter_get_basic(&item_iter, &interface_name);
1882
1883                 retv_if(interface_name == NULL, FALSE);
1884
1885                 BT_DBG("interface: %s", interface_name);
1886
1887                 retv_if(dbus_message_iter_next(&item_iter) == FALSE,
1888                                                                 FALSE);
1889
1890                 retv_if(dbus_message_iter_get_arg_type(&item_iter)
1891                                         != DBUS_TYPE_ARRAY, FALSE);
1892
1893                 if (strcasecmp(interface_name,
1894                                         BT_OBEX_TRANSFER_INTERFACE) == 0)
1895                         return TRUE;
1896         }
1897
1898         return FALSE;
1899 }
1900
1901 static DBusHandlerResult __bt_opc_event_filter(DBusConnection *conn,
1902                                                 DBusMessage *msg, void *data)
1903 {
1904         const char *member = dbus_message_get_member(msg);
1905
1906         if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL)
1907                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1908
1909         retv_if(member == NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
1910
1911         if (strcasecmp(member, "InterfacesAdded") == 0) {
1912                 BT_DBG("InterfacesAdded");
1913         }else if (strcasecmp(member, "InterfacesRemoved") == 0) {
1914                 char *object_path = NULL;
1915
1916                 if (__bt_get_object_path(msg, &object_path)) {
1917                         BT_ERR("Fail to get the path");
1918                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1919                 }
1920
1921                 BT_DBG("object_path =%s",object_path);
1922
1923                 if (strncmp(object_path, BT_SESSION_BASEPATH_CLIENT,
1924                         strlen(BT_SESSION_BASEPATH_CLIENT)) != 0
1925                         || strstr(object_path, "transfer") == NULL)
1926                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1927
1928                 _bt_sending_files();
1929
1930         }else if (__bt_is_obexd_client_event(msg) == TRUE){
1931                 const char *path = dbus_message_get_path(msg);
1932
1933                 if (strncmp(path, BT_SESSION_BASEPATH_CLIENT,
1934                         strlen(BT_SESSION_BASEPATH_CLIENT)) != 0)
1935                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1936
1937                 _bt_opc_property_changed_event(msg);
1938         }
1939
1940         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1941 }
1942
1943 static DBusHandlerResult __bt_obexd_event_filter(DBusConnection *conn,
1944                                                 DBusMessage *msg, void *data)
1945 {
1946         const char *member = dbus_message_get_member(msg);
1947
1948         if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL)
1949                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1950
1951         retv_if(member == NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
1952
1953         if (__bt_is_obexd_event(msg) == TRUE){
1954                 const char *path = dbus_message_get_path(msg);
1955
1956                 if (strncmp(path, BT_SESSION_BASEPATH_SERVER,
1957                         strlen(BT_SESSION_BASEPATH_SERVER)) != 0)
1958                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1959
1960                 _bt_handle_property_changed_event(msg);
1961         }
1962
1963         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1964 }
1965
1966 int _bt_register_service_event(DBusGConnection *g_conn, int event_type)
1967 {
1968         DBusError dbus_error;
1969         char *match1 = NULL;
1970         char *match2 = NULL;
1971         char *match3 = NULL;
1972         char *match4 = NULL;
1973         DBusConnection *conn;
1974         DBusHandleMessageFunction event_func = NULL;
1975
1976         retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
1977
1978         conn = dbus_g_connection_get_connection(g_conn);
1979         retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
1980
1981         switch (event_type) {
1982         case BT_MANAGER_EVENT:
1983                 event_func = __bt_manager_event_filter;
1984                 match1 = g_strdup_printf(MANAGER_EVENT_MATCH_RULE,
1985                                         BT_MANAGER_INTERFACE,
1986                                         BT_INTERFACES_ADDED);
1987
1988                 match2 = g_strdup_printf(MANAGER_EVENT_MATCH_RULE,
1989                                         BT_MANAGER_INTERFACE,
1990                                         BT_INTERFACES_REMOVED);
1991
1992                 match3 = g_strdup_printf(MANAGER_EVENT_MATCH_RULE,
1993                                         BT_FREEDESKTOP_INTERFACE,
1994                                         BT_NAME_OWNER_CHANGED);
1995
1996                 match4 = g_strdup_printf(MANAGER_EVENT_MATCH_RULE,
1997                                         BT_PROPERTIES_INTERFACE,
1998                                         BT_PROPERTIES_CHANGED);
1999                 break;
2000         case BT_DEVICE_EVENT:
2001                 match1 = g_strdup_printf(EVENT_MATCH_RULE,
2002                                         BT_DEVICE_INTERFACE);
2003                 break;
2004         case BT_HID_EVENT:
2005                 match1 = g_strdup_printf(EVENT_MATCH_RULE,
2006                                         BT_INPUT_INTERFACE);
2007                 break;
2008         case BT_NETWORK_EVENT:
2009                 match1 = g_strdup_printf(EVENT_MATCH_RULE,
2010                                         BT_NETWORK_SERVER_INTERFACE);
2011
2012                 match2 = g_strdup_printf(EVENT_MATCH_RULE,
2013                                         BT_NETWORK_CLIENT_INTERFACE);
2014                 break;
2015         case BT_HEADSET_EVENT:
2016                 match1 = g_strdup_printf(EVENT_MATCH_RULE,
2017                                         BT_HFP_AGENT_INTERFACE);
2018
2019                 match2 = g_strdup_printf(EVENT_MATCH_RULE,
2020                                         BT_SINK_INTERFACE);
2021                 break;
2022         case BT_OPP_SERVER_EVENT:
2023                 event_func = __bt_obexd_event_filter;
2024                 match1 = g_strdup_printf(MANAGER_EVENT_MATCH_RULE,
2025                                         BT_PROPERTIES_INTERFACE,
2026                                         BT_PROPERTIES_CHANGED);
2027                 break;
2028         case BT_OPP_CLIENT_EVENT:
2029                 event_func = __bt_opc_event_filter;
2030                 match1 = g_strdup_printf(MANAGER_EVENT_MATCH_RULE,
2031                                         BT_PROPERTIES_INTERFACE,
2032                                         BT_PROPERTIES_CHANGED);
2033
2034                 match2 = g_strdup_printf(MANAGER_EVENT_MATCH_RULE,
2035                                         BT_MANAGER_INTERFACE,
2036                                         BT_INTERFACES_ADDED);
2037
2038                 match3 = g_strdup_printf(MANAGER_EVENT_MATCH_RULE,
2039                                         BT_MANAGER_INTERFACE,
2040                                         BT_INTERFACES_REMOVED);
2041                 break;
2042         default:
2043                 BT_ERR("Unknown event");
2044                 return BLUETOOTH_ERROR_INTERNAL;
2045         }
2046
2047         if (event_func) {
2048                 if (!dbus_connection_add_filter(conn, event_func,
2049                                                 NULL, NULL)) {
2050                         BT_ERR("Fail to add filter");
2051                         goto fail;
2052                 }
2053         }
2054
2055         dbus_error_init(&dbus_error);
2056
2057         if (match1)
2058                 dbus_bus_add_match(conn, match1, &dbus_error);
2059
2060         if (dbus_error_is_set(&dbus_error)) {
2061                 BT_ERR("Fail to add match: %s\n", dbus_error.message);
2062                 dbus_error_free(&dbus_error);
2063                 goto fail;
2064         }
2065
2066         if (match2)
2067                 dbus_bus_add_match(conn, match2, &dbus_error);
2068
2069         if (dbus_error_is_set(&dbus_error)) {
2070                 BT_ERR("Fail to add match: %s\n", dbus_error.message);
2071                 dbus_error_free(&dbus_error);
2072                 goto fail;
2073         }
2074
2075         if (match3)
2076                 dbus_bus_add_match(conn, match3, &dbus_error);
2077
2078         if (dbus_error_is_set(&dbus_error)) {
2079                 BT_ERR("Fail to add match: %s\n", dbus_error.message);
2080                 dbus_error_free(&dbus_error);
2081                 goto fail;
2082         }
2083
2084         if (match4)
2085                 dbus_bus_add_match(conn, match4, &dbus_error);
2086
2087         if (dbus_error_is_set(&dbus_error)) {
2088                 BT_ERR("Fail to add match: %s\n", dbus_error.message);
2089                 dbus_error_free(&dbus_error);
2090                 goto fail;
2091         }
2092
2093         g_free(match1);
2094         g_free(match2);
2095         g_free(match3);
2096         g_free(match4);
2097
2098         return BLUETOOTH_ERROR_NONE;
2099 fail:
2100         g_free(match1);
2101         g_free(match2);
2102         g_free(match3);
2103         g_free(match4);
2104         return BLUETOOTH_ERROR_INTERNAL;
2105 }
2106
2107 void _bt_unregister_service_event(DBusGConnection *g_conn, int event_type)
2108 {
2109         DBusConnection *conn;
2110         DBusHandleMessageFunction event_func;
2111
2112         ret_if(g_conn == NULL);
2113         conn = dbus_g_connection_get_connection(g_conn);
2114
2115         switch (event_type) {
2116         case BT_MANAGER_EVENT:
2117                 event_func = __bt_manager_event_filter;
2118                 break;
2119         case BT_OPP_SERVER_EVENT:
2120                 event_func = __bt_obexd_event_filter;
2121                 break;
2122         case BT_OPP_CLIENT_EVENT:
2123                 event_func = __bt_opc_event_filter;
2124                 break;
2125         default:
2126                 BT_ERR("Unknown event");
2127                 return;
2128         }
2129
2130         ret_if(conn == NULL);
2131
2132         dbus_connection_remove_filter(conn, event_func, NULL);
2133 }
2134
2135 static int __bt_init_manager_receiver(void)
2136 {
2137         GError *error = NULL;
2138
2139         if (manager_conn == NULL) {
2140                 manager_conn = dbus_g_bus_get(DBUS_BUS_SYSTEM, &error);
2141                 if (error != NULL) {
2142                         BT_ERR("ERROR: Can't get on system bus [%s]", error->message);
2143                         g_error_free(error);
2144                 }
2145                 retv_if(manager_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
2146         }
2147
2148         if (_bt_register_service_event(manager_conn,
2149                                 BT_MANAGER_EVENT) != BLUETOOTH_ERROR_NONE)
2150                 goto fail;
2151
2152         if (_bt_register_service_event(manager_conn,
2153                                 BT_DEVICE_EVENT) != BLUETOOTH_ERROR_NONE)
2154                 goto fail;
2155
2156         if (_bt_register_service_event(manager_conn,
2157                                 BT_HID_EVENT) != BLUETOOTH_ERROR_NONE)
2158                 goto fail;
2159
2160         if (_bt_register_service_event(manager_conn,
2161                                 BT_HEADSET_EVENT) != BLUETOOTH_ERROR_NONE)
2162                 goto fail;
2163
2164         if (_bt_register_service_event(manager_conn,
2165                                 BT_NETWORK_EVENT) != BLUETOOTH_ERROR_NONE)
2166                 goto fail;
2167
2168         return BLUETOOTH_ERROR_NONE;
2169 fail:
2170         if (manager_conn) {
2171                 dbus_g_connection_unref(manager_conn);
2172                 manager_conn = NULL;
2173         }
2174
2175         return BLUETOOTH_ERROR_INTERNAL;
2176 }
2177
2178 static int __bt_init_obexd_receiver(void)
2179 {
2180         GError *error = NULL;
2181
2182         if (obexd_conn == NULL) {
2183                 obexd_conn = dbus_g_bus_get(DBUS_BUS_SESSION, &error);
2184                 if (error != NULL) {
2185                         BT_ERR("ERROR: Can't get on session bus [%s]", error->message);
2186                         g_error_free(error);
2187                 }
2188                 retv_if(obexd_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
2189         }
2190
2191         if (_bt_register_service_event(obexd_conn,
2192                                 BT_OPP_SERVER_EVENT) != BLUETOOTH_ERROR_NONE) {
2193                 dbus_g_connection_unref(obexd_conn);
2194                 obexd_conn = NULL;
2195                 return BLUETOOTH_ERROR_INTERNAL;
2196         }
2197
2198         return BLUETOOTH_ERROR_NONE;
2199 }
2200
2201 /* To receive the event from bluez */
2202 int _bt_init_service_event_receiver(void)
2203 {
2204         int result;
2205
2206         result = __bt_init_manager_receiver();
2207         retv_if(result != BLUETOOTH_ERROR_NONE, result);
2208
2209         result = __bt_init_obexd_receiver();
2210         if (result != BLUETOOTH_ERROR_NONE)
2211                 BT_ERR("Fail to init obexd receiver");
2212
2213         return BLUETOOTH_ERROR_NONE;
2214 }
2215
2216 void _bt_deinit_service_event_reciever(void)
2217 {
2218         _bt_unregister_service_event(manager_conn, BT_MANAGER_EVENT);
2219
2220         _bt_unregister_service_event(obexd_conn, BT_OPP_SERVER_EVENT);
2221
2222         if (manager_conn) {
2223                 dbus_g_connection_unref(manager_conn);
2224                 manager_conn = NULL;
2225         }
2226
2227         if (obexd_conn) {
2228                 dbus_g_connection_unref(obexd_conn);
2229                 obexd_conn = NULL;
2230         }
2231
2232         if (event_id > 0)
2233                 g_source_remove(event_id);
2234 }
2235
2236 int _bt_opp_client_event_init(void)
2237 {
2238         GError *error = NULL;
2239
2240         if (opc_obexd_conn == NULL) {
2241                 opc_obexd_conn = dbus_g_bus_get(DBUS_BUS_SESSION, &error);
2242                 if (error != NULL) {
2243                         BT_ERR("ERROR: Can't get on session bus [%s]",
2244                                                          error->message);
2245                         g_error_free(error);
2246                 }
2247
2248                 retv_if(opc_obexd_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
2249         }
2250
2251         if (_bt_register_service_event(opc_obexd_conn,
2252                         BT_OPP_CLIENT_EVENT) != BLUETOOTH_ERROR_NONE) {
2253                 dbus_g_connection_unref(opc_obexd_conn);
2254                 opc_obexd_conn = NULL;
2255                 return BLUETOOTH_ERROR_INTERNAL;
2256         }
2257
2258         return BLUETOOTH_ERROR_NONE;
2259 }
2260
2261 void _bt_opp_client_event_deinit(void)
2262 {
2263         if (opc_obexd_conn) {
2264                 _bt_unregister_service_event(opc_obexd_conn,
2265                                                 BT_OPP_CLIENT_EVENT);
2266                 dbus_g_connection_unref(opc_obexd_conn);
2267                 opc_obexd_conn = NULL;
2268         }
2269 }
2270
2271 void _bt_get_temp_remote_devinfo(void)
2272 {
2273         bt_remote_dev_info_t *dev_info;
2274         GList *node;
2275         int result = BLUETOOTH_ERROR_NONE;
2276
2277         node = g_list_first(g_list);
2278
2279         while (node != NULL) {
2280                 dev_info = (bt_remote_dev_info_t *)node->data;
2281
2282                 _bt_send_event(BT_ADAPTER_EVENT,
2283                         BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND,
2284                         DBUS_TYPE_INT32, &result,
2285                         DBUS_TYPE_STRING, &dev_info->address,
2286                         DBUS_TYPE_UINT32, &dev_info->class,
2287                         DBUS_TYPE_INT16, &dev_info->rssi,
2288                         DBUS_TYPE_STRING, &dev_info->name,
2289                         DBUS_TYPE_BOOLEAN, &dev_info->paired,
2290                         DBUS_TYPE_BOOLEAN, &dev_info->connected,
2291                         DBUS_TYPE_BOOLEAN, &dev_info->trust,
2292                         DBUS_TYPE_ARRAY, DBUS_TYPE_STRING,
2293                         &dev_info->uuids, dev_info->uuid_count,
2294                         DBUS_TYPE_INVALID);
2295
2296                 node = g_list_next(node);
2297         }
2298 }