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