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-audio.h"
  40
  41 static DBusGConnection *manager_conn;
  42 static DBusGConnection *obexd_conn;
  43
  44 static guint event_id;
  45
  46 static gboolean __bt_parse_device_properties(DBusMessageIter *item_iter,
  47                                                 bt_remote_dev_info_t *dev_info)
  48 {
  49         DBusMessageIter value_iter;
  50         char *value;
  51
  52         if (dbus_message_iter_get_arg_type(item_iter) != DBUS_TYPE_ARRAY)
  53                 return FALSE;
  54
  55         dbus_message_iter_recurse(item_iter, &value_iter);
  56
  57         while (dbus_message_iter_get_arg_type(&value_iter) ==
  58                                                 DBUS_TYPE_DICT_ENTRY) {
  59                 char *key;
  60                 DBusMessageIter dict_entry;
  61                 DBusMessageIter iter_dict_val;
  62
  63                 dbus_message_iter_recurse(&value_iter, &dict_entry);
  64
  65                 dbus_message_iter_get_basic(&dict_entry, &key);
  66                 if (key == NULL) {
  67                         dbus_message_iter_next(&value_iter);
  68                         continue;
  69                 }
  70
  71                 if (!dbus_message_iter_next(&dict_entry)) {
  72                         dbus_message_iter_next(&value_iter);
  73                         continue;
  74                 }
  75                 dbus_message_iter_recurse(&dict_entry, &iter_dict_val);
  76                 if (strcasecmp(key, "Class") == 0) {
  77                         dbus_message_iter_get_basic(&iter_dict_val, &dev_info->class);
  78                 } else if (strcasecmp(key, "name") == 0) {
  79                         dbus_message_iter_get_basic(&iter_dict_val, &value);
  80                         if (dev_info->name == NULL)
  81                                 dev_info->name = g_strdup(value);
  82                 } else if (strcasecmp(key, "Connected") == 0) {
  83                         dbus_message_iter_get_basic(&iter_dict_val,
  84                                                 &dev_info->connected);
  85                 } else if (strcasecmp(key, "paired") == 0) {
  86                         dbus_message_iter_get_basic(&iter_dict_val,
  87                                                 &dev_info->paired);
  88                 } else if (strcasecmp(key, "Trusted") == 0) {
  89                         dbus_message_iter_get_basic(&iter_dict_val,
  90                                                 &dev_info->trust);
  91                 } else if (strcasecmp(key, "RSSI") == 0) {
  92                         dbus_message_iter_get_basic(&iter_dict_val,
  93                                                 &dev_info->rssi);
  94                 } else if (strcasecmp(key, "UUIDs") == 0) {
  95                         DBusMessageIter uuid_iter;
  96                         DBusMessageIter tmp_iter;
  97                         int i = 0;
  98
  99                         dbus_message_iter_recurse(&iter_dict_val, &uuid_iter);
 100
 101                         tmp_iter = uuid_iter;
 102
 103                         /* Store the uuid count */
 104                         while (dbus_message_iter_get_arg_type(&tmp_iter) != DBUS_TYPE_INVALID) {
 105                                 dbus_message_iter_get_basic(&tmp_iter,
 106                                                         &value);
 107
 108                                 dev_info->uuid_count++;
 109                                 if (!dbus_message_iter_next(&tmp_iter))
 110                                         break;
 111                         }
 112
 113                         /* Store the uuids */
 114                         if (dev_info->uuid_count > 0) {
 115                                 dev_info->uuids = g_new0(char *,
 116                                                 dev_info->uuid_count + 1);
 117                         } else {
 118                                 continue;
 119                         }
 120
 121                         while (dbus_message_iter_get_arg_type(&uuid_iter) != DBUS_TYPE_INVALID) {
 122                                 dbus_message_iter_get_basic(&uuid_iter,
 123                                                         &value);
 124                                 dev_info->uuids[i] = g_strdup(value);
 125                                 i++;
 126                                 if (!dbus_message_iter_next(&uuid_iter)) {
 127                                         break;
 128                                 }
 129                         }
 130
 131                 }
 132
 133                 dbus_message_iter_next(&value_iter);
 134         }
 135
 136         return TRUE;
 137 }
 138
 139 char *__bt_get_headset_name(char *address)
 140 {
 141         bluetooth_device_address_t device_address = { {0} };
 142         bluetooth_device_info_t dev_info;
 143
 144         retv_if(address == NULL, strdup(""));
 145
 146         _bt_convert_addr_string_to_type(device_address.addr, address);
 147
 148         memset(&dev_info, 0x00, sizeof(bluetooth_device_info_t));
 149
 150         _bt_get_bonded_device_info(&device_address, &dev_info);
 151
 152         return g_strdup(dev_info.device_name.name);
 153 }
 154
 155 static int __bt_get_owner_info(DBusMessage *msg, char **name,
 156                                 char **previous, char **current)
 157 {
 158         DBusMessageIter item_iter;
 159
 160         dbus_message_iter_init(msg, &item_iter);
 161
 162         if (dbus_message_iter_get_arg_type(&item_iter)
 163                                         != DBUS_TYPE_STRING) {
 164                 BT_ERR("This is bad format dbus\n");
 165                 return BLUETOOTH_ERROR_INTERNAL;
 166         }
 167
 168         dbus_message_iter_get_basic(&item_iter, name);
 169
 170         retv_if(*name == NULL, BLUETOOTH_ERROR_INTERNAL);
 171
 172         dbus_message_iter_next(&item_iter);
 173
 174         if (dbus_message_iter_get_arg_type(&item_iter)
 175                                         != DBUS_TYPE_STRING) {
 176                 BT_ERR("This is bad format dbus\n");
 177                 return BLUETOOTH_ERROR_INTERNAL;
 178         }
 179
 180         dbus_message_iter_get_basic(&item_iter, previous);
 181
 182         retv_if(*previous == NULL, BLUETOOTH_ERROR_INTERNAL);
 183
 184         dbus_message_iter_next(&item_iter);
 185
 186         if (dbus_message_iter_get_arg_type(&item_iter)
 187                                         != DBUS_TYPE_STRING) {
 188                 BT_ERR("This is bad format dbus\n");
 189                 return BLUETOOTH_ERROR_INTERNAL;
 190         }
 191
 192         dbus_message_iter_get_basic(&item_iter, current);
 193
 194         retv_if(*current == NULL, BLUETOOTH_ERROR_INTERNAL);
 195
 196         return BLUETOOTH_ERROR_NONE;
 197 }
 198
 199 static int __bt_get_agent_signal_info(DBusMessage *msg, char **address,
 200                                 char **name, char **uuid)
 201 {
 202         DBusMessageIter item_iter;
 203
 204         dbus_message_iter_init(msg, &item_iter);
 205
 206         if (dbus_message_iter_get_arg_type(&item_iter)
 207                                         != DBUS_TYPE_STRING) {
 208                 BT_ERR("This is bad format dbus\n");
 209                 return BLUETOOTH_ERROR_INTERNAL;
 210         }
 211
 212         dbus_message_iter_get_basic(&item_iter, address);
 213
 214         dbus_message_iter_next(&item_iter);
 215
 216         if (dbus_message_iter_get_arg_type(&item_iter)
 217                                         != DBUS_TYPE_STRING) {
 218                 BT_ERR("This is bad format dbus\n");
 219                 return BLUETOOTH_ERROR_INTERNAL;
 220         }
 221
 222         dbus_message_iter_get_basic(&item_iter, name);
 223
 224         dbus_message_iter_next(&item_iter);
 225
 226         if (dbus_message_iter_get_arg_type(&item_iter)
 227                                         != DBUS_TYPE_STRING) {
 228                 BT_ERR("This is bad format dbus\n");
 229                 return BLUETOOTH_ERROR_INTERNAL;
 230         }
 231
 232         dbus_message_iter_get_basic(&item_iter, uuid);
 233
 234         return BLUETOOTH_ERROR_NONE;
 235 }
 236
 237 gboolean _bt_discovery_finished_cb(gpointer user_data)
 238 {
 239         int result = BLUETOOTH_ERROR_NONE;
 240         event_id = 0;
 241
 242         if (_bt_get_discoverying_property() == FALSE) {
 243                 if (_bt_get_cancel_by_user() == TRUE) {
 244                         result = BLUETOOTH_ERROR_CANCEL_BY_USER;
 245                 }
 246
 247                 _bt_set_cancel_by_user(FALSE);
 248                 _bt_set_discovery_status(FALSE);
 249                 _bt_send_event(BT_ADAPTER_EVENT,
 250                         BLUETOOTH_EVENT_DISCOVERY_FINISHED,
 251                         DBUS_TYPE_INT32, &result,
 252                         DBUS_TYPE_INVALID);
 253         }
 254
 255         return FALSE;
 256 }
 257
 258 void _bt_handle_adapter_event(DBusMessage *msg)
 259 {
 260         int mode = 0;
 261         int result = BLUETOOTH_ERROR_NONE;
 262         DBusGProxy *adapter_proxy;
 263         DBusMessageIter item_iter;
 264         DBusMessageIter value_iter;
 265         GValue timeout = { 0 };
 266         const char *member = dbus_message_get_member(msg);
 267         const char *property = NULL;
 268
 269         ret_if(member == NULL);
 270
 271         if (strcasecmp(member, "PropertyChanged") == 0) {
 272                 dbus_message_iter_init(msg, &item_iter);
 273
 274                 if (dbus_message_iter_get_arg_type(&item_iter)
 275                                                 != DBUS_TYPE_STRING) {
 276                         BT_ERR("This is bad format dbus\n");
 277                         return;
 278                 }
 279
 280                 dbus_message_iter_get_basic(&item_iter, &property);
 281                 BT_DBG("member = PropertyChanged[%s]", property);
 282
 283                 ret_if(property == NULL);
 284
 285                 if (strcasecmp(property, "Discovering") == 0) {
 286                         gboolean discovering = FALSE;
 287                         dbus_message_iter_next(&item_iter);
 288                         dbus_message_iter_recurse(&item_iter, &value_iter);
 289                         dbus_message_iter_get_basic(&value_iter, &discovering);
 290
 291                         /* Send event to application */
 292                         if (discovering == TRUE) {
 293                                 _bt_set_discovery_status(TRUE);
 294                                 _bt_send_event(BT_ADAPTER_EVENT,
 295                                         BLUETOOTH_EVENT_DISCOVERY_STARTED,
 296                                         DBUS_TYPE_INT32, &result,
 297                                         DBUS_TYPE_INVALID);
 298                         } else {
 299                                 ret_if(event_id > 0);
 300
 301                                 adapter_proxy = _bt_get_adapter_proxy();
 302                                 ret_if(adapter_proxy == NULL);
 303
 304                                 /* Need to stop searching */
 305                                 dbus_g_proxy_call(adapter_proxy,
 306                                                         "StopDiscovery",
 307                                                         NULL,
 308                                                         G_TYPE_INVALID,
 309                                                         G_TYPE_INVALID);
 310
 311                                 event_id = g_timeout_add(BT_DISCOVERY_FINISHED_DELAY,
 312                                               (GSourceFunc)_bt_discovery_finished_cb, NULL);
 313                         }
 314                 } else if (strcasecmp(property, "Name") == 0) {
 315                         char *name = NULL;
 316                         dbus_message_iter_next(&item_iter);
 317                         dbus_message_iter_recurse(&item_iter, &value_iter);
 318                         dbus_message_iter_get_basic(&value_iter, &name);
 319
 320                         /* Send event to application */
 321                         _bt_send_event(BT_ADAPTER_EVENT,
 322                                         BLUETOOTH_EVENT_LOCAL_NAME_CHANGED,
 323                                         DBUS_TYPE_INT32, &result,
 324                                         DBUS_TYPE_STRING, &name,
 325                                         DBUS_TYPE_INVALID);
 326                 } else if (strcasecmp(property, "Discoverable") == 0) {
 327                         gboolean discoverable = FALSE;
 328                         dbus_message_iter_next(&item_iter);
 329                         dbus_message_iter_recurse(&item_iter, &value_iter);
 330                         dbus_message_iter_get_basic(&value_iter, &discoverable);
 331
 332                         if (discoverable == FALSE) {
 333                                 if (_bt_get_discoverable_timeout_property() > 0) {
 334                                         g_value_init(&timeout, G_TYPE_UINT);
 335                                         g_value_set_uint(&timeout, 0);
 336
 337                                         adapter_proxy = _bt_get_adapter_proxy();
 338                                         ret_if(adapter_proxy == NULL);
 339
 340                                         dbus_g_proxy_call_no_reply(adapter_proxy, "SetProperty",
 341                                                                    G_TYPE_STRING, "DiscoverableTimeout",
 342                                                                    G_TYPE_VALUE, &timeout,
 343                                                                    G_TYPE_INVALID);
 344
 345                                         g_value_unset(&timeout);
 346                                 }
 347
 348                                 mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE;
 349
 350                                 /* Send event to application */
 351                                 _bt_send_event(BT_ADAPTER_EVENT,
 352                                                 BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED,
 353                                                 DBUS_TYPE_INT32, &result,
 354                                                 DBUS_TYPE_INT16, &mode,
 355                                                 DBUS_TYPE_INVALID);
 356                         } else {
 357                                 _bt_get_discoverable_mode(&mode);
 358
 359                                 /* Event will be sent by "DiscoverableTimeout" signal */
 360                                 ret_if(mode != BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE);
 361
 362                                 /* Send event to application */
 363                                 _bt_send_event(BT_ADAPTER_EVENT,
 364                                                 BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED,
 365                                                 DBUS_TYPE_INT32, &result,
 366                                                 DBUS_TYPE_INT16, &mode,
 367                                                 DBUS_TYPE_INVALID);
 368                         }
 369                 } else if (strcasecmp(property, "DiscoverableTimeout") == 0) {
 370                         _bt_get_discoverable_mode(&mode);
 371
 372                         /* Event was already sent by "Discoverable" signal */
 373                         ret_if(mode == BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE);
 374
 375                         /* Send event to application */
 376                         _bt_send_event(BT_ADAPTER_EVENT,
 377                                         BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED,
 378                                         DBUS_TYPE_INT32, &result,
 379                                         DBUS_TYPE_INT16, &mode,
 380                                         DBUS_TYPE_INVALID);
 381                 } else if (strcasecmp(property, "Powered") == 0) {
 382                         gboolean powered = FALSE;
 383                         dbus_message_iter_next(&item_iter);
 384                         dbus_message_iter_recurse(&item_iter, &value_iter);
 385                         dbus_message_iter_get_basic(&value_iter, &powered);
 386                         BT_DBG("Powered = %d", powered);
 387                         if (powered == FALSE)
 388                                 _bt_disable_adapter();
 389                 }
 390         } else if (strcasecmp(member, "DeviceFound") == 0) {
 391                 const char *bdaddr;
 392                 bt_remote_dev_info_t *dev_info;
 393
 394                 ret_if(_bt_is_discovering() == FALSE);
 395
 396                 dev_info = g_malloc0(sizeof(bt_remote_dev_info_t));
 397
 398                 dbus_message_iter_init(msg, &item_iter);
 399                 dbus_message_iter_get_basic(&item_iter, &bdaddr);
 400                 dbus_message_iter_next(&item_iter);
 401
 402                 dev_info->address = g_strdup(bdaddr);
 403
 404                 if (__bt_parse_device_properties(&item_iter, dev_info) == FALSE) {
 405                         BT_ERR("Fail to parse the properies");
 406                         _bt_free_device_info(dev_info);
 407                         return;
 408                 }
 409
 410                 if (dev_info->name == NULL)
 411                         dev_info->name = g_strdup("");
 412
 413                 _bt_send_event(BT_ADAPTER_EVENT,
 414                         BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND,
 415                         DBUS_TYPE_INT32, &result,
 416                         DBUS_TYPE_STRING, &dev_info->address,
 417                         DBUS_TYPE_UINT32, &dev_info->class,
 418                         DBUS_TYPE_INT16, &dev_info->rssi,
 419                         DBUS_TYPE_STRING, &dev_info->name,
 420                         DBUS_TYPE_BOOLEAN, &dev_info->paired,
 421                         DBUS_TYPE_BOOLEAN, &dev_info->connected,
 422                         DBUS_TYPE_BOOLEAN, &dev_info->trust,
 423                         DBUS_TYPE_ARRAY, DBUS_TYPE_STRING,
 424                         &dev_info->uuids, dev_info->uuid_count,
 425                         DBUS_TYPE_INVALID);
 426
 427                 _bt_free_device_info(dev_info);
 428         } else if (strcasecmp(member, "DeviceCreated") == 0) {
 429                 const char *object_path = NULL;
 430                 char *address;
 431                 bt_remote_dev_info_t *remote_dev_info;
 432
 433                 ret_if(_bt_is_device_creating() == FALSE);
 434
 435                 /* Bonding from remote device */
 436                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
 437
 438                 dbus_message_iter_init(msg, &item_iter);
 439                 dbus_message_iter_get_basic(&item_iter, &object_path);
 440                 dbus_message_iter_next(&item_iter);
 441
 442                 _bt_convert_device_path_to_address(object_path, address);
 443
 444                 remote_dev_info = _bt_get_remote_device_info(address);
 445                 if (remote_dev_info == NULL) {
 446                         g_free(address);
 447                         return;
 448                 }
 449
 450                 _bt_free_device_info(remote_dev_info);
 451                 g_free(address);
 452         } else if (strcasecmp(member, "DeviceRemoved") == 0) {
 453                 const char *object_path = NULL;
 454                 char *address;
 455
 456                 /* Bonding from remote device */
 457                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
 458
 459                 dbus_message_iter_init(msg, &item_iter);
 460                 dbus_message_iter_get_basic(&item_iter, &object_path);
 461                 dbus_message_iter_next(&item_iter);
 462
 463                 _bt_convert_device_path_to_address(object_path, address);
 464
 465                 _bt_send_event(BT_ADAPTER_EVENT,
 466                         BLUETOOTH_EVENT_BONDED_DEVICE_REMOVED,
 467                         DBUS_TYPE_INT32, &result,
 468                         DBUS_TYPE_STRING, &address,
 469                         DBUS_TYPE_INVALID);
 470
 471                 g_free(address);
 472         }
 473 }
 474
 475 void _bt_handle_input_event(DBusMessage *msg)
 476 {
 477         int result = BLUETOOTH_ERROR_NONE;
 478         DBusMessageIter item_iter;
 479         DBusMessageIter value_iter;
 480         gboolean property_flag = FALSE;
 481         const char *member = dbus_message_get_member(msg);
 482         const char *path = dbus_message_get_path(msg);
 483         const char *property = NULL;
 484
 485         ret_if(member == NULL);
 486
 487         dbus_message_iter_init(msg, &item_iter);
 488
 489         if (dbus_message_iter_get_arg_type(&item_iter)
 490                                         != DBUS_TYPE_STRING) {
 491                 BT_ERR("This is bad format dbus\n");
 492                 return;
 493         }
 494
 495         dbus_message_iter_get_basic(&item_iter, &property);
 496
 497         ret_if(property == NULL);
 498
 499         if (strcasecmp(property, "Connected") == 0) {
 500                 int event = BLUETOOTH_EVENT_NONE;
 501                 char *address;
 502
 503                 dbus_message_iter_next(&item_iter);
 504                 dbus_message_iter_recurse(&item_iter, &value_iter);
 505                 dbus_message_iter_get_basic(&value_iter, &property_flag);
 506
 507                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
 508
 509                 _bt_convert_device_path_to_address(path, address);
 510
 511                 event = (property_flag == TRUE) ?
 512                                 BLUETOOTH_HID_CONNECTED :
 513                                 BLUETOOTH_HID_DISCONNECTED;
 514
 515                 _bt_send_event(BT_HID_EVENT, event,
 516                         DBUS_TYPE_INT32, &result,
 517                         DBUS_TYPE_STRING, &address,
 518                         DBUS_TYPE_INVALID);
 519
 520                 g_free(address);
 521         }
 522  }
 523
 524 void _bt_handle_network_server_event(DBusMessage *msg)
 525 {
 526         int result = BLUETOOTH_ERROR_NONE;
 527         char *address = NULL;
 528         char *device = NULL;
 529         const char *member = dbus_message_get_member(msg);
 530
 531         ret_if(member == NULL);
 532
 533         if (strcasecmp(member, "PeerConnected") == 0) {
 534                 if (!dbus_message_get_args(msg, NULL,
 535                         DBUS_TYPE_STRING, &device,
 536                         DBUS_TYPE_STRING, &address,
 537                         DBUS_TYPE_INVALID)) {
 538                         BT_ERR("Unexpected parameters in signal");
 539                         return;
 540                 }
 541
 542                 _bt_send_event(BT_NETWORK_EVENT, BLUETOOTH_EVENT_NETWORK_SERVER_CONNECTED,
 543                         DBUS_TYPE_INT32, &result,
 544                         DBUS_TYPE_STRING, &device,
 545                         DBUS_TYPE_STRING, &address,
 546                         DBUS_TYPE_INVALID);
 547         } else if (strcasecmp(member, "PeerDisconnected") == 0) {
 548                 if (!dbus_message_get_args(msg, NULL,
 549                         DBUS_TYPE_STRING, &device,
 550                         DBUS_TYPE_STRING, &address,
 551                         DBUS_TYPE_INVALID)) {
 552                         BT_ERR("Unexpected parameters in signal");
 553                         return;
 554                 }
 555
 556                 _bt_send_event(BT_NETWORK_EVENT, BLUETOOTH_EVENT_NETWORK_SERVER_DISCONNECTED,
 557                         DBUS_TYPE_INT32, &result,
 558                         DBUS_TYPE_STRING, &device,
 559                         DBUS_TYPE_STRING, &address,
 560                         DBUS_TYPE_INVALID);
 561         }
 562 }
 563
 564 void _bt_handle_network_client_event(DBusMessage *msg)
 565 {
 566         int result = BLUETOOTH_ERROR_NONE;
 567         DBusMessageIter item_iter;
 568         DBusMessageIter value_iter;
 569         gboolean property_flag = FALSE;
 570         const char *member = dbus_message_get_member(msg);
 571         const char *path = dbus_message_get_path(msg);
 572         const char *property = NULL;
 573
 574         ret_if(member == NULL);
 575
 576         dbus_message_iter_init(msg, &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;
 582         }
 583
 584         dbus_message_iter_get_basic(&item_iter, &property);
 585
 586         ret_if(property == NULL);
 587
 588         if (strcasecmp(property, "Connected") == 0) {
 589                 int event = BLUETOOTH_EVENT_NONE;
 590                 char *address;
 591
 592                 dbus_message_iter_next(&item_iter);
 593                 dbus_message_iter_recurse(&item_iter, &value_iter);
 594                 dbus_message_iter_get_basic(&value_iter, &property_flag);
 595
 596                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
 597
 598                 _bt_convert_device_path_to_address(path, address);
 599
 600                 if (property_flag == TRUE) {
 601                         event = BLUETOOTH_EVENT_NETWORK_CONNECTED;
 602                 } else {
 603                         event = BLUETOOTH_EVENT_NETWORK_DISCONNECTED;
 604                 }
 605
 606                 _bt_send_event(BT_NETWORK_EVENT, event,
 607                         DBUS_TYPE_INT32, &result,
 608                         DBUS_TYPE_STRING, &address,
 609                         DBUS_TYPE_INVALID);
 610
 611                 g_free(address);
 612         }
 613 }
 614
 615 void _bt_handle_device_event(DBusMessage *msg)
 616 {
 617         int event;
 618         int result = BLUETOOTH_ERROR_NONE;
 619         DBusMessageIter item_iter;
 620         DBusMessageIter value_iter;
 621         char *address;
 622         const char *member = dbus_message_get_member(msg);
 623         const char *path = dbus_message_get_path(msg);
 624         const char *property = NULL;
 625
 626         ret_if(path == NULL);
 627         ret_if(member == NULL);
 628
 629         if (strcasecmp(member, "PropertyChanged") == 0) {
 630                 dbus_message_iter_init(msg, &item_iter);
 631
 632                 if (dbus_message_iter_get_arg_type(&item_iter)
 633                                                 != DBUS_TYPE_STRING) {
 634                         BT_ERR("This is bad format dbus\n");
 635                         return;
 636                 }
 637
 638                 dbus_message_iter_get_basic(&item_iter, &property);
 639
 640                 ret_if(property == NULL);
 641
 642                 if (strcasecmp(property, "Connected") == 0) {
 643                         gboolean connected = FALSE;
 644                         dbus_message_iter_next(&item_iter);
 645                         dbus_message_iter_recurse(&item_iter, &value_iter);
 646                         dbus_message_iter_get_basic(&value_iter, &connected);
 647
 648                         event = connected ? BLUETOOTH_EVENT_DEVICE_CONNECTED :
 649                                         BLUETOOTH_EVENT_DEVICE_DISCONNECTED;
 650
 651                         address = g_malloc0(BT_ADDRESS_STRING_SIZE);
 652
 653                         _bt_convert_device_path_to_address(path, address);
 654
 655                         BT_DBG("connected: %d", connected);
 656                         BT_DBG("address: %s", address);
 657
 658                         /* Send event to application */
 659                         _bt_send_event(BT_DEVICE_EVENT,
 660                                         event,
 661                                         DBUS_TYPE_INT32, &result,
 662                                         DBUS_TYPE_STRING, &address,
 663                                         DBUS_TYPE_INVALID);
 664
 665                         g_free(address);
 666                 } else if (strcasecmp(property, "Paired") == 0) {
 667                         gboolean paired = FALSE;
 668                         bt_remote_dev_info_t *remote_dev_info;
 669                         dbus_message_iter_next(&item_iter);
 670                         dbus_message_iter_recurse(&item_iter, &value_iter);
 671                         dbus_message_iter_get_basic(&value_iter, &paired);
 672
 673                         ret_if(paired == FALSE);
 674
 675                         /* BlueZ sends paired signal for each paired device */
 676                         /* during activation, We should ignore this, otherwise*/
 677                         /* application thinks that a new device got paired */
 678                         if (_bt_adapter_get_status() != BT_ACTIVATED) {
 679                                 BT_DBG("BT is not activated, so ignore this");
 680                                 return;
 681                         }
 682
 683                         if (_bt_is_device_creating() == TRUE) {
 684                                 BT_DBG("Try to Pair by me");
 685                                 return;
 686                         }
 687
 688                         address = g_malloc0(BT_ADDRESS_STRING_SIZE);
 689
 690                         _bt_convert_device_path_to_address(path, address);
 691
 692                         remote_dev_info = _bt_get_remote_device_info(address);
 693                         if (remote_dev_info == NULL) {
 694                                 g_free(address);
 695                                 return;
 696                         }
 697
 698                         _bt_send_event(BT_ADAPTER_EVENT,
 699                                 BLUETOOTH_EVENT_BONDING_FINISHED,
 700                                 DBUS_TYPE_INT32, &result,
 701                                 DBUS_TYPE_STRING, &address,
 702                                 DBUS_TYPE_UINT32, &remote_dev_info->class,
 703                                 DBUS_TYPE_INT16, &remote_dev_info->rssi,
 704                                 DBUS_TYPE_STRING, &remote_dev_info->name,
 705                                 DBUS_TYPE_BOOLEAN, &remote_dev_info->paired,
 706                                 DBUS_TYPE_BOOLEAN, &remote_dev_info->connected,
 707                                 DBUS_TYPE_BOOLEAN, &remote_dev_info->trust,
 708                                 DBUS_TYPE_ARRAY, DBUS_TYPE_STRING,
 709                                 &remote_dev_info->uuids, remote_dev_info->uuid_count,
 710                                 DBUS_TYPE_INVALID);
 711
 712                         _bt_free_device_info(remote_dev_info);
 713                         g_free(address);
 714                 }
 715         }
 716 }
 717
 718 void __bt_set_audio_values(gboolean connected, char *address)
 719 {
 720         char *name = NULL;
 721         int bt_device_state = VCONFKEY_BT_DEVICE_NONE;
 722
 723         /*  Set the headset name */
 724         if (connected == TRUE) {
 725                 name = __bt_get_headset_name(address);
 726         } else {
 727                 name = g_strdup("");
 728         }
 729
 730         if (vconf_set_str(VCONFKEY_BT_HEADSET_NAME,
 731                                         name) != 0) {
 732                 BT_ERR("vconf_set_str failed");
 733         }
 734
 735         g_free(name);
 736
 737         /*  Set the headset state */
 738         if (vconf_get_int(VCONFKEY_BT_DEVICE,
 739                                 &bt_device_state) != 0) {
 740                 BT_ERR("vconf_get_str failed");
 741         }
 742
 743         if (connected == TRUE) {
 744                 bt_device_state |= VCONFKEY_BT_DEVICE_HEADSET_CONNECTED;
 745         } else if (bt_device_state & VCONFKEY_BT_DEVICE_HEADSET_CONNECTED) {
 746                 bt_device_state ^= VCONFKEY_BT_DEVICE_HEADSET_CONNECTED;
 747         }
 748
 749         if (vconf_set_int(VCONFKEY_BT_DEVICE,
 750                                 bt_device_state) != 0) {
 751                 BT_ERR("vconf_set_int failed");
 752         }
 753 }
 754
 755 void _bt_handle_headset_event(DBusMessage *msg)
 756 {
 757         int result = BLUETOOTH_ERROR_NONE;
 758         DBusMessageIter item_iter;
 759         DBusMessageIter value_iter;
 760         gboolean property_flag = FALSE;
 761         const char *member = dbus_message_get_member(msg);
 762         const char *path = dbus_message_get_path(msg);
 763         const char *property = NULL;
 764
 765         ret_if(member == NULL);
 766
 767         dbus_message_iter_init(msg, &item_iter);
 768
 769         if (dbus_message_iter_get_arg_type(&item_iter)
 770                                         != DBUS_TYPE_STRING) {
 771                 BT_ERR("This is bad format dbus\n");
 772                 return;
 773         }
 774
 775         dbus_message_iter_get_basic(&item_iter, &property);
 776
 777         ret_if(property == NULL);
 778
 779         BT_DBG("Property = %s \n", property);
 780
 781         /* We allow only 1 headset connection (HSP or HFP)*/
 782         if (strcasecmp(property, "Connected") == 0) {
 783                 int event = BLUETOOTH_EVENT_NONE;
 784                 bt_headset_wait_t *wait_list;
 785                 char *address;
 786
 787                 dbus_message_iter_next(&item_iter);
 788                 dbus_message_iter_recurse(&item_iter, &value_iter);
 789                 dbus_message_iter_get_basic(&value_iter, &property_flag);
 790
 791                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
 792
 793                 _bt_convert_device_path_to_address(path, address);
 794
 795                 if (property_flag == TRUE) {
 796                         event = BLUETOOTH_EVENT_AG_CONNECTED;
 797                 } else {
 798                         event = BLUETOOTH_EVENT_AG_DISCONNECTED;
 799                 }
 800
 801                 __bt_set_audio_values(property_flag, address);
 802
 803                 _bt_send_event(BT_HEADSET_EVENT, event,
 804                         DBUS_TYPE_INT32, &result,
 805                         DBUS_TYPE_STRING, &address,
 806                         DBUS_TYPE_INVALID);
 807
 808                 if (event == BLUETOOTH_EVENT_AG_DISCONNECTED) {
 809                         /* Remove data from the connected list */
 810                         _bt_remove_headset_from_list(BT_AUDIO_HSP, address);
 811
 812                         wait_list = _bt_get_audio_wait_data();
 813                         if (wait_list == NULL) {
 814                                 g_free(address);
 815                                 return;
 816                         }
 817
 818                         bluetooth_device_address_t device_address;
 819
 820                         _bt_set_audio_wait_data_flag(TRUE);
 821
 822                         _bt_convert_addr_string_to_type(device_address.addr,
 823                                                         wait_list->address);
 824                         _bt_audio_connect(wait_list->req_id, wait_list->type,
 825                                         &device_address, wait_list->out_param1);
 826                 } else if (event == BLUETOOTH_EVENT_AG_CONNECTED) {
 827                         /* Add data to the connected list */
 828                         _bt_add_headset_to_list(BT_AUDIO_HSP,
 829                                                 BT_STATE_CONNECTED, address);
 830                 }
 831                 g_free(address);
 832         } else if (strcasecmp(property, "State") == 0) {
 833                 int event = BLUETOOTH_EVENT_NONE;
 834                 int sco_connected = FALSE;
 835                 char *state = NULL;
 836                 char *address;
 837
 838                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
 839
 840                 _bt_convert_device_path_to_address(path, address);
 841
 842                 dbus_message_iter_next(&item_iter);
 843                 dbus_message_iter_recurse(&item_iter, &value_iter);
 844                 dbus_message_iter_get_basic(&value_iter, &state);
 845
 846                 /* This code assumes we support only 1 headset connection */
 847                 /* Need to use the headset list, if we support multi-headsets */
 848                 if (strcasecmp(state, "Playing") == 0) {
 849                         event = BLUETOOTH_EVENT_AG_AUDIO_CONNECTED;
 850                         sco_connected = TRUE;
 851                 } else if (strcasecmp(state, "connected") == 0 ||
 852                             strcasecmp(state, "disconnected") == 0) {
 853                         event = BLUETOOTH_EVENT_AG_AUDIO_DISCONNECTED;
 854                         sco_connected = FALSE;
 855                 } else {
 856                         BT_ERR("Not handled state - %s", state);
 857                         g_free(address);
 858                         return;
 859                 }
 860
 861                 if (vconf_set_bool(VCONFKEY_BT_HEADSET_SCO, sco_connected) < 0)
 862                         BT_ERR("vconf_set_bool - Failed\n");
 863
 864                 _bt_send_event(BT_HEADSET_EVENT, event,
 865                         DBUS_TYPE_INT32, &result,
 866                         DBUS_TYPE_STRING, &address,
 867                         DBUS_TYPE_INVALID);
 868
 869                 g_free(address);
 870         } else if (strcasecmp(property, "SpeakerGain") == 0) {
 871                 guint16 spkr_gain;
 872                 char *address;
 873
 874                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
 875
 876                 _bt_convert_device_path_to_address(path, address);
 877
 878                 dbus_message_iter_next(&item_iter);
 879                 dbus_message_iter_recurse(&item_iter, &value_iter);
 880                 dbus_message_iter_get_basic(&value_iter, &spkr_gain);
 881
 882                 _bt_send_event(BT_HEADSET_EVENT, BLUETOOTH_EVENT_AG_SPEAKER_GAIN,
 883                         DBUS_TYPE_INT32, &result,
 884                         DBUS_TYPE_STRING, &address,
 885                         DBUS_TYPE_UINT16, &spkr_gain,
 886                         DBUS_TYPE_INVALID);
 887
 888                 g_free(address);
 889         } else if (strcasecmp(property, "MicrophoneGain") == 0) {
 890                 guint16 mic_gain;
 891                 char *address;
 892
 893                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
 894
 895                 _bt_convert_device_path_to_address(path, address);
 896
 897                 dbus_message_iter_next(&item_iter);
 898                 dbus_message_iter_recurse(&item_iter, &value_iter);
 899                 dbus_message_iter_get_basic(&value_iter, &mic_gain);
 900
 901                 _bt_send_event(BT_HEADSET_EVENT, BLUETOOTH_EVENT_AG_MIC_GAIN,
 902                         DBUS_TYPE_INT32, &result,
 903                         DBUS_TYPE_STRING, &address,
 904                         DBUS_TYPE_UINT16, &mic_gain,
 905                         DBUS_TYPE_INVALID);
 906
 907                 g_free(address);
 908         }
 909 }
 910
 911 void _bt_handle_sink_event(DBusMessage *msg)
 912 {
 913         int result = BLUETOOTH_ERROR_NONE;
 914         DBusMessageIter item_iter;
 915         DBusMessageIter value_iter;
 916         gboolean property_flag = FALSE;
 917         const char *member = dbus_message_get_member(msg);
 918         const char *path = dbus_message_get_path(msg);
 919         const char *property = NULL;
 920
 921         bt_headset_wait_t *wait_list;
 922
 923         ret_if(member == NULL);
 924
 925         dbus_message_iter_init(msg, &item_iter);
 926
 927         if (dbus_message_iter_get_arg_type(&item_iter)
 928                                         != DBUS_TYPE_STRING) {
 929                 BT_ERR("This is bad format dbus\n");
 930                 return;
 931         }
 932
 933         dbus_message_iter_get_basic(&item_iter, &property);
 934
 935         ret_if(property == NULL);
 936
 937         if (strcasecmp(property, "Connected") == 0) {
 938                 int event = BLUETOOTH_EVENT_NONE;
 939                 char *address;
 940
 941                 dbus_message_iter_next(&item_iter);
 942                 dbus_message_iter_recurse(&item_iter, &value_iter);
 943                 dbus_message_iter_get_basic(&value_iter, &property_flag);
 944
 945                 address = g_malloc0(BT_ADDRESS_STRING_SIZE);
 946
 947                 _bt_convert_device_path_to_address(path, address);
 948
 949                 event = (property_flag == TRUE) ?
 950                                 BLUETOOTH_EVENT_AV_CONNECTED :
 951                                 BLUETOOTH_EVENT_AV_DISCONNECTED;
 952
 953                 _bt_send_event(BT_HEADSET_EVENT, event,
 954                         DBUS_TYPE_INT32, &result,
 955                         DBUS_TYPE_STRING, &address,
 956                         DBUS_TYPE_INVALID);
 957
 958                 _bt_send_event(BT_AVRCP_EVENT, event,
 959                         DBUS_TYPE_INT32, &result,
 960                         DBUS_TYPE_STRING, &address,
 961                         DBUS_TYPE_INVALID);
 962
 963                 if (event == BLUETOOTH_EVENT_AV_DISCONNECTED) {
 964                         /* Remove data from the connected list */
 965                         _bt_remove_headset_from_list(BT_AUDIO_A2DP, address);
 966                         wait_list = _bt_get_audio_wait_data();
 967                         if (wait_list == NULL) {
 968                                 g_free(address);
 969                                 return;
 970                         }
 971
 972                         if (((wait_list->type == BT_AUDIO_ALL) &&
 973                                 (wait_list->ag_flag == TRUE)) ||
 974                                 (wait_list->type == BT_AUDIO_A2DP) ||
 975                                 (wait_list->disconnection_type == BT_AUDIO_A2DP)) {
 976                                 bluetooth_device_address_t device_address;
 977                                 _bt_convert_addr_string_to_type(
 978                                                         device_address.addr,
 979                                                         wait_list->address);
 980
 981                                 _bt_audio_connect(wait_list->req_id,
 982                                                         wait_list->type,
 983                                                         &device_address,
 984                                                         wait_list->out_param1);
 985                         }
 986                 } else if (event == BLUETOOTH_EVENT_AV_CONNECTED){
 987                         /* Check for existing Media device to disconnect */
 988                         char connected_address[BT_ADDRESS_STRING_SIZE + 1];
 989                         bluetooth_device_address_t device_address;
 990                         gboolean connected;
 991
 992                         connected = _bt_is_headset_type_connected(BT_AUDIO_A2DP,
 993                                                                 connected_address);
 994                         if (connected) {
 995                                 /* Match connected device address */
 996                                 if (g_strcmp0(connected_address, address) != 0) {
 997                                         /* Convert BD adress from string type */
 998                                         _bt_convert_addr_string_to_type(
 999                                                         device_address.addr,
1000                                                         connected_address);
1001                                         _bt_audio_disconnect(0, BT_AUDIO_A2DP,
1002                                                         &device_address, NULL);
1003                                 }
1004                         }
1005
1006                         /* Add data to the connected list */
1007                         _bt_add_headset_to_list(BT_AUDIO_A2DP,
1008                                         BT_STATE_CONNECTED, address);
1009                 }
1010                 g_free(address);
1011         }
1012 }
1013
1014 void _bt_handle_agent_event(DBusMessage *msg)
1015 {
1016         const char *member = dbus_message_get_member(msg);
1017         int result = BLUETOOTH_ERROR_NONE;
1018         char *address = NULL;
1019         char *name = NULL;
1020         char *uuid = NULL;
1021
1022         ret_if(member == NULL);
1023
1024         if (strcasecmp(member, "ObexAuthorize") == 0) {
1025                 __bt_get_agent_signal_info(msg, &address, &name, &uuid);
1026
1027                 _bt_send_event(BT_OPP_SERVER_EVENT,
1028                         BLUETOOTH_EVENT_OBEX_SERVER_CONNECTION_AUTHORIZE,
1029                         DBUS_TYPE_INT32, &result,
1030                         DBUS_TYPE_STRING, &address,
1031                         DBUS_TYPE_STRING, &name,
1032                         DBUS_TYPE_INVALID);
1033         } else if (strcasecmp(member, "RfcommAuthorize") == 0) {
1034                 bt_rfcomm_server_info_t *server_info;
1035
1036                 __bt_get_agent_signal_info(msg, &address, &name, &uuid);
1037
1038                 server_info = _bt_rfcomm_get_server_info_using_uuid(uuid);
1039                 ret_if(server_info == NULL);
1040                 ret_if(server_info->server_type != BT_CUSTOM_SERVER);
1041
1042                 _bt_send_event(BT_RFCOMM_SERVER_EVENT,
1043                         BLUETOOTH_EVENT_RFCOMM_AUTHORIZE,
1044                         DBUS_TYPE_INT32, &result,
1045                         DBUS_TYPE_STRING, &address,
1046                         DBUS_TYPE_STRING, &uuid,
1047                         DBUS_TYPE_STRING, &name,
1048                         DBUS_TYPE_INT16, &server_info->control_fd,
1049                         DBUS_TYPE_INVALID);
1050         }
1051 }
1052
1053 static DBusHandlerResult __bt_manager_event_filter(DBusConnection *conn,
1054                                            DBusMessage *msg, void *data)
1055 {
1056         const char *member = dbus_message_get_member(msg);
1057
1058         if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL)
1059                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1060
1061         retv_if(member == NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
1062
1063         if (strcasecmp(member, "AdapterAdded") == 0) {
1064                 BT_DBG("AdapterAdded");
1065                 _bt_handle_adapter_added();
1066         } else if (strcasecmp(member, "AdapterRemoved") == 0) {
1067                 BT_DBG("AdapterRemoved");
1068         } else if (strcasecmp(member, "NameOwnerChanged") == 0) {
1069                 gboolean value;
1070                 char *name = NULL;
1071                 char *previous = NULL;
1072                 char *current = NULL;
1073
1074                 if (__bt_get_owner_info(msg, &name, &previous, &current)) {
1075                         BT_ERR("Fail to get the owner info");
1076                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1077                 }
1078
1079                 if (*current != '\0')
1080                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1081
1082                 if (strcasecmp(name, "org.bluez") == 0) {
1083                         BT_DBG("Bluetoothd is terminated");
1084                         _bt_handle_adapter_removed();
1085                 }
1086
1087                 _bt_obex_server_check_allocation(&value);
1088
1089                 if (value == TRUE) {
1090                         /* Check if the obex server was terminated abnormally */
1091                         _bt_obex_server_check_termination(name);
1092                 }
1093
1094                 _bt_rfcomm_server_check_existence(&value);
1095
1096                 if (value == TRUE) {
1097                         /* The obex server was terminated abnormally */
1098                         _bt_rfcomm_server_check_termination(name);
1099                 }
1100         } else  if (dbus_message_has_interface(msg, BT_ADAPTER_INTERFACE)) {
1101                 _bt_handle_adapter_event(msg);
1102         } else  if (dbus_message_has_interface(msg, BT_INPUT_INTERFACE)) {
1103                 _bt_handle_input_event(msg);
1104         } else  if (dbus_message_has_interface(msg, BT_NETWORK_SERVER_INTERFACE)) {
1105                 _bt_handle_network_server_event(msg);
1106         } else  if (dbus_message_has_interface(msg, BT_NETWORK_CLIENT_INTERFACE)) {
1107                 _bt_handle_network_client_event(msg);
1108         } else  if (dbus_message_has_interface(msg, BT_HEADSET_INTERFACE)) {
1109                 _bt_handle_headset_event(msg);
1110         } else  if (dbus_message_has_interface(msg, BT_SINK_INTERFACE)) {
1111                 _bt_handle_sink_event(msg);
1112         } else  if (dbus_message_has_interface(msg, BT_AGENT_INTERFACE)) {
1113                 _bt_handle_agent_event(msg);
1114         } else  if (dbus_message_has_interface(msg, BT_DEVICE_INTERFACE)) {
1115                 _bt_handle_device_event(msg);
1116         }
1117
1118         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1119 }
1120
1121 static DBusHandlerResult __bt_obexd_event_filter(DBusConnection *conn,
1122                                            DBusMessage *msg, void *data)
1123 {
1124         const char *path = dbus_message_get_path(msg);
1125         const char *member = dbus_message_get_member(msg);
1126
1127         if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL)
1128                 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1129
1130         retv_if(member == NULL, DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
1131
1132         if (strcasecmp(member, "TransferStarted") == 0) {
1133                 char *transfer_path = NULL;
1134
1135                 if (!dbus_message_get_args(msg, NULL,
1136                         DBUS_TYPE_OBJECT_PATH, &transfer_path,
1137                         DBUS_TYPE_INVALID)) {
1138                         BT_ERR("Unexpected parameters in signal");
1139                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1140                 }
1141
1142                 _bt_obex_transfer_started(transfer_path);
1143         } else if (strcasecmp(member, "Progress") == 0) {
1144                 gint total = 0;
1145                 gint transfer = 0;
1146
1147                 if (!dbus_message_get_args(msg, NULL,
1148                         DBUS_TYPE_INT32, &total,
1149                         DBUS_TYPE_INT32, &transfer,
1150                         DBUS_TYPE_INVALID)) {
1151                         BT_ERR("Unexpected parameters in signal");
1152                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1153                 }
1154
1155                 _bt_obex_transfer_progress(path, total, transfer);
1156         } else if (strcasecmp(member, "TransferCompleted") == 0) {
1157                 char *transfer_path = NULL;
1158                 gboolean success;
1159
1160                 if (!dbus_message_get_args(msg, NULL,
1161                         DBUS_TYPE_OBJECT_PATH, &transfer_path,
1162                         DBUS_TYPE_BOOLEAN, &success,
1163                         DBUS_TYPE_INVALID)) {
1164                         BT_ERR("Unexpected parameters in signal");
1165                         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1166                 }
1167
1168                 _bt_obex_transfer_completed(transfer_path, success);
1169         }
1170
1171         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1172 }
1173
1174 int _bt_register_service_event(DBusGConnection *g_conn, int event_type)
1175 {
1176         DBusError dbus_error;
1177         char *match1 = NULL;
1178         char *match2 = NULL;
1179         DBusConnection *conn;
1180         DBusHandleMessageFunction event_func = NULL;
1181
1182         retv_if(g_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
1183
1184         conn = dbus_g_connection_get_connection(g_conn);
1185         retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
1186
1187         switch (event_type) {
1188         case BT_MANAGER_EVENT:
1189                 event_func = __bt_manager_event_filter;
1190                 match1 = g_strdup_printf(MANAGER_EVENT_MATCH_RULE,
1191                                         BT_MANAGER_INTERFACE,
1192                                         BT_MANAGER_PATH);
1193
1194                 match2 = g_strdup_printf(MANAGER_EVENT_MATCH_RULE,
1195                                         BT_FREEDESKTOP_INTERFACE,
1196                                         BT_FREEDESKTOP_PATH);
1197                 break;
1198         case BT_DEVICE_EVENT:
1199                 match1 = g_strdup_printf(EVENT_MATCH_RULE,
1200                                         BT_DEVICE_INTERFACE);
1201                 break;
1202         case BT_HID_EVENT:
1203                 match1 = g_strdup_printf(EVENT_MATCH_RULE,
1204                                         BT_INPUT_INTERFACE);
1205                 break;
1206         case BT_NETWORK_EVENT:
1207                 match1 = g_strdup_printf(EVENT_MATCH_RULE,
1208                                         BT_NETWORK_SERVER_INTERFACE);
1209
1210                 match2 = g_strdup_printf(EVENT_MATCH_RULE,
1211                                         BT_NETWORK_CLIENT_INTERFACE);
1212                 break;
1213         case BT_HEADSET_EVENT:
1214                 match1 = g_strdup_printf(EVENT_MATCH_RULE,
1215                                         BT_HEADSET_INTERFACE);
1216
1217                 match2 = g_strdup_printf(EVENT_MATCH_RULE,
1218                                         BT_SINK_INTERFACE);
1219                 break;
1220         case BT_OPP_SERVER_EVENT:
1221                 event_func = __bt_obexd_event_filter;
1222                 match1 = g_strdup_printf(MANAGER_EVENT_MATCH_RULE,
1223                                         BT_OBEXD_MANAGER_INTERFACE,
1224                                         BT_MANAGER_PATH);
1225
1226                 match2 = g_strdup_printf(EVENT_MATCH_RULE,
1227                                         BT_OBEXD_TRANSFER_INTERFACE);
1228                 break;
1229         default:
1230                 BT_ERR("Unknown event");
1231                 return BLUETOOTH_ERROR_INTERNAL;
1232         }
1233
1234         if (event_func) {
1235                 if (!dbus_connection_add_filter(conn, event_func,
1236                                                 NULL, NULL)) {
1237                         BT_ERR("Fail to add filter");
1238                         goto fail;
1239                 }
1240         }
1241
1242         dbus_error_init(&dbus_error);
1243
1244         if (match1)
1245                 dbus_bus_add_match(conn, match1, &dbus_error);
1246
1247         if (dbus_error_is_set(&dbus_error)) {
1248                 BT_ERR("Fail to add match: %s\n", dbus_error.message);
1249                 dbus_error_free(&dbus_error);
1250                 goto fail;
1251         }
1252
1253         if (match2)
1254                 dbus_bus_add_match(conn, match2, &dbus_error);
1255
1256         if (dbus_error_is_set(&dbus_error)) {
1257                 BT_ERR("Fail to add match: %s\n", dbus_error.message);
1258                 dbus_error_free(&dbus_error);
1259                 goto fail;
1260         }
1261
1262         g_free(match1);
1263         g_free(match2);
1264
1265         return BLUETOOTH_ERROR_NONE;
1266 fail:
1267         g_free(match1);
1268         g_free(match2);
1269         return BLUETOOTH_ERROR_INTERNAL;
1270 }
1271
1272 void _bt_unregister_service_event(DBusGConnection *g_conn, int event_type)
1273 {
1274         DBusConnection *conn;
1275         DBusHandleMessageFunction event_func;
1276
1277         ret_if(g_conn == NULL);
1278         conn = dbus_g_connection_get_connection(g_conn);
1279
1280         switch (event_type) {
1281         case BT_MANAGER_EVENT:
1282                 event_func = __bt_manager_event_filter;
1283                 break;
1284         case BT_OPP_SERVER_EVENT:
1285                 event_func = __bt_obexd_event_filter;
1286                 break;
1287         default:
1288                 BT_ERR("Unknown event");
1289                 return;
1290         }
1291
1292         ret_if(conn == NULL);
1293
1294         dbus_connection_remove_filter(conn, event_func, NULL);
1295 }
1296
1297 static int __bt_init_manager_receiver(void)
1298 {
1299         GError *error = NULL;
1300
1301         if (manager_conn == NULL) {
1302                 manager_conn = dbus_g_bus_get(DBUS_BUS_SYSTEM, &error);
1303                 if (error != NULL) {
1304                         BT_ERR("ERROR: Can't get on system bus [%s]", error->message);
1305                         g_error_free(error);
1306                 }
1307                 retv_if(manager_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
1308         }
1309
1310         if (_bt_register_service_event(manager_conn,
1311                                 BT_MANAGER_EVENT) != BLUETOOTH_ERROR_NONE)
1312                 goto fail;
1313
1314         if (_bt_register_service_event(manager_conn,
1315                                 BT_DEVICE_EVENT) != BLUETOOTH_ERROR_NONE)
1316                 goto fail;
1317
1318         if (_bt_register_service_event(manager_conn,
1319                                 BT_HID_EVENT) != BLUETOOTH_ERROR_NONE)
1320                 goto fail;
1321
1322         if (_bt_register_service_event(manager_conn,
1323                                 BT_HEADSET_EVENT) != BLUETOOTH_ERROR_NONE)
1324                 goto fail;
1325
1326         if (_bt_register_service_event(manager_conn,
1327                                 BT_NETWORK_EVENT) != BLUETOOTH_ERROR_NONE)
1328                 goto fail;
1329
1330         return BLUETOOTH_ERROR_NONE;
1331 fail:
1332         if (manager_conn) {
1333                 dbus_g_connection_unref(manager_conn);
1334                 manager_conn = NULL;
1335         }
1336
1337         return BLUETOOTH_ERROR_INTERNAL;
1338 }
1339
1340 static int __bt_init_obexd_receiver(void)
1341 {
1342         GError *error = NULL;
1343
1344         if (obexd_conn == NULL) {
1345                 obexd_conn = dbus_g_bus_get(DBUS_BUS_SESSION, &error);
1346                 if (error != NULL) {
1347                         BT_ERR("ERROR: Can't get on session bus [%s]", error->message);
1348                         g_error_free(error);
1349                 }
1350                 retv_if(obexd_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
1351         }
1352
1353         if (_bt_register_service_event(obexd_conn,
1354                                 BT_OPP_SERVER_EVENT) != BLUETOOTH_ERROR_NONE) {
1355                 dbus_g_connection_unref(obexd_conn);
1356                 obexd_conn = NULL;
1357                 return BLUETOOTH_ERROR_INTERNAL;
1358         }
1359
1360         return BLUETOOTH_ERROR_NONE;
1361 }
1362
1363 /* To receive the event from bluez */
1364 int _bt_init_service_event_receiver(void)
1365 {
1366         int result;
1367
1368         result = __bt_init_manager_receiver();
1369         retv_if(result != BLUETOOTH_ERROR_NONE, result);
1370
1371         result = __bt_init_obexd_receiver();
1372         if (result != BLUETOOTH_ERROR_NONE)
1373                 BT_ERR("Fail to init obexd receiver");
1374
1375         return BLUETOOTH_ERROR_NONE;
1376 }
1377
1378 void _bt_deinit_service_event_reciever(void)
1379 {
1380         _bt_unregister_service_event(manager_conn, BT_MANAGER_EVENT);
1381
1382         _bt_unregister_service_event(obexd_conn, BT_OPP_SERVER_EVENT);
1383
1384         if (manager_conn) {
1385                 dbus_g_connection_unref(manager_conn);
1386                 manager_conn = NULL;
1387         }
1388
1389         if (obexd_conn) {
1390                 dbus_g_connection_unref(obexd_conn);
1391                 obexd_conn = NULL;
1392         }
1393
1394         if (event_id > 0)
1395                 g_source_remove(event_id);
1396 }