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