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