bt-service/bt-service-event-sender.c

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *              http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 #include <glib.h>
  19 #include <dlog.h>
  20 #include <gio/gio.h>
  21 #include "bluetooth-api.h"
  22 #include "bt-internal-types.h"
  23
  24 #include "bt-service-common.h"
  25 #include "bt-service-event.h"
  26
  27 static GDBusConnection *event_conn;
  28 static GDBusConnection *hf_local_term_event_conn;
  29
  30 #ifdef HPS_FEATURE
  31 int _bt_send_to_hps(void)
  32 {
  33         gboolean ret = FALSE;
  34         GError *error = NULL;
  35
  36         BT_DBG(" ");
  37
  38         retv_if(event_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
  39
  40         ret = g_dbus_connection_emit_signal(event_conn, NULL,
  41                                         "/org/projectx/httpproxy",
  42                                         "org.projectx.httpproxy_service",
  43                                         BT_LE_ENABLED,
  44                                         NULL, &error);
  45         if (!ret) {
  46                 if (error != NULL) {
  47                         BT_ERR("D-Bus API failure: errCode[%x], \
  48                                         message[%s]",
  49                                         error->code, error->message);
  50                         g_clear_error(&error);
  51                 }
  52                 return BLUETOOTH_ERROR_INTERNAL;
  53         }
  54
  55         return BLUETOOTH_ERROR_NONE;
  56 }
  57 #endif
  58
  59 int _bt_send_event(int event_type, int event, GVariant *param)
  60 {
  61         char *path;
  62         char *signal;
  63         GDBusMessage *msg1 = NULL;
  64
  65         retv_if(event_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
  66
  67         BT_DBG("event_type [%d], event [%d]", event_type, event);
  68
  69         switch (event_type) {
  70         case BT_ADAPTER_EVENT:
  71                 path = BT_ADAPTER_PATH;
  72                 break;
  73         case BT_LE_ADAPTER_EVENT:
  74                 path = BT_LE_ADAPTER_PATH;
  75                 break;
  76         case BT_DEVICE_EVENT:
  77                 path = BT_DEVICE_PATH;
  78                 break;
  79         case BT_HID_EVENT:
  80                 path = BT_HID_PATH;
  81                 break;
  82         case BT_HID_DEVICE_EVENT:
  83                 path = BT_HID_DEVICE_PATH;
  84                 break;
  85         case BT_HEADSET_EVENT:
  86                 path = BT_HEADSET_PATH;
  87                 break;
  88         case BT_AVRCP_EVENT:
  89                 path = BT_AVRCP_PATH;
  90                 break;
  91         case BT_AVRCP_CONTROL_EVENT:
  92                 path = BT_AVRCP_CONTROL_PATH;
  93                 break;
  94         case BT_NETWORK_EVENT:
  95                 path = BT_NETWORK_PATH;
  96                 break;
  97         case BT_OPP_CLIENT_EVENT:
  98                 path = BT_OPP_CLIENT_PATH;
  99                 break;
 100         case BT_OPP_SERVER_EVENT:
 101                 path = BT_OPP_SERVER_PATH;
 102                 break;
 103         case BT_PBAP_CLIENT_EVENT:
 104                 path = BT_PBAP_CLIENT_PATH;
 105                 break;
 106         case BT_RFCOMM_CLIENT_EVENT:
 107                 path = BT_RFCOMM_CLIENT_PATH;
 108                 break;
 109         case BT_RFCOMM_SERVER_EVENT:
 110                 path = BT_RFCOMM_SERVER_PATH;
 111                 break;
 112         case BT_A2DP_SOURCE_EVENT:
 113                 path = BT_A2DP_SOURCE_PATH;
 114                 break;
 115         default:
 116                 BT_ERR("Unknown event");
 117                 return BLUETOOTH_ERROR_INTERNAL;
 118         }
 119
 120         switch (event) {
 121         case BLUETOOTH_EVENT_ENABLED:
 122                 signal = BT_ENABLED;
 123                 BT_INFO_C("### BT Enabled");
 124                 break;
 125         case BLUETOOTH_EVENT_DISABLED:
 126                 signal = BT_DISABLED;
 127                 BT_INFO_C("### BT Disabled");
 128                 break;
 129         case BLUETOOTH_EVENT_LE_ENABLED:
 130                 signal = BT_LE_ENABLED;
 131                 break;
 132         case BLUETOOTH_EVENT_LE_DISABLED:
 133                 signal = BT_LE_DISABLED;
 134                 break;
 135         case BLUETOOTH_EVENT_LOCAL_NAME_CHANGED:
 136                 signal = BT_ADAPTER_NAME_CHANGED;
 137                 break;
 138         case BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED:
 139                 signal = BT_DISCOVERABLE_MODE_CHANGED;
 140                 break;
 141         case BLUETOOTH_EVENT_DISCOVERABLE_TIMEOUT_CHANGED:
 142                 signal = BT_DISCOVERABLE_TIMEOUT_CHANGED;
 143                 break;
 144         case BLUETOOTH_EVENT_CONNECTABLE_CHANGED:
 145                 signal = BT_CONNECTABLE_CHANGED;
 146                 break;
 147         case BLUETOOTH_EVENT_DISCOVERY_STARTED:
 148                 signal = BT_DISCOVERY_STARTED;
 149                 break;
 150         case BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND:
 151                 signal = BT_DEVICE_FOUND;
 152                 break;
 153         case BLUETOOTH_EVENT_DISCOVERY_FINISHED:
 154                 signal = BT_DISCOVERY_FINISHED;
 155                 break;
 156         case BLUETOOTH_EVENT_LE_DISCOVERY_STARTED:
 157                 signal = BT_LE_DISCOVERY_STARTED;
 158                 break;
 159         case BLUETOOTH_EVENT_REMOTE_LE_DEVICE_FOUND:
 160                 signal = BT_LE_DEVICE_FOUND;
 161                 break;
 162         case BLUETOOTH_EVENT_LE_DISCOVERY_FINISHED:
 163                 signal = BT_LE_DISCOVERY_FINISHED;
 164                 break;
 165         case BLUETOOTH_EVENT_ADVERTISING_STARTED:
 166                 signal = BT_ADVERTISING_STARTED;
 167                 break;
 168         case BLUETOOTH_EVENT_ADVERTISING_STOPPED:
 169                 signal = BT_ADVERTISING_STOPPED;
 170                 break;
 171         case BLUETOOTH_EVENT_ADVERTISING_MANUFACTURER_DATA_CHANGED:
 172                 signal = BT_ADVERTISING_MANUFACTURER_DATA_CHANGED;
 173                 break;
 174         case BLUETOOTH_EVENT_SCAN_RESPONSE_MANUFACTURER_DATA_CHANGED:
 175                 signal = BT_SCAN_RESPONSE_MANUFACTURER_DATA_CHANGED;
 176                 break;
 177         case BLUETOOTH_EVENT_MANUFACTURER_DATA_CHANGED:
 178                 signal = BT_MANUFACTURER_DATA_CHANGED;
 179                 break;
 180         case BLUETOOTH_EVENT_BONDING_FINISHED:
 181                 signal = BT_BOND_CREATED;
 182                 break;
 183         case BLUETOOTH_EVENT_BONDED_DEVICE_REMOVED:
 184                 signal = BT_BOND_DESTROYED;
 185                 break;
 186         case BLUETOOTH_EVENT_DEVICE_AUTHORIZED:
 187                 signal = BT_DEVICE_AUTHORIZED;
 188                 break;
 189         case BLUETOOTH_EVENT_DEVICE_UNAUTHORIZED:
 190                 signal = BT_DEVICE_UNAUTHORIZED;
 191                 break;
 192         case BLUETOOTH_EVENT_RSSI_ENABLED:
 193                 signal = BT_RSSI_MONITORING_ENABLED;
 194                 break;
 195         case BLUETOOTH_EVENT_RSSI_ALERT:
 196                 signal = BT_RSSI_ALERT;
 197                 break;
 198         case BLUETOOTH_EVENT_RAW_RSSI:
 199                 signal = BT_RAW_RSSI_EVENT;
 200                 break;
 201         case BLUETOOTH_EVENT_SUPPORTED_PROFILE_TRUSTED:
 202                 signal = BT_SUPPORTED_PROFILE_TRUSTED;
 203                 break;
 204         case BLUETOOTH_EVENT_KEYBOARD_PASSKEY_DISPLAY:
 205                 signal = BT_KBD_PASSKEY_DISPLAY_REQ_RECEIVED;
 206                 break;
 207         case BLUETOOTH_EVENT_PIN_REQUEST:
 208                 signal = BT_PIN_REQ_RECEIVED;
 209                 break;
 210         case BLUETOOTH_EVENT_PASSKEY_REQUEST:
 211                 signal = BT_PASSKEY_REQ_RECEIVED;
 212                 break;
 213         case BLUETOOTH_EVENT_PASSKEY_CONFIRM_REQUEST:
 214                 signal = BT_PASSKEY_CFM_REQ_RECEIVED;
 215                 break;
 216         case BLUETOOTH_EVENT_SERVICE_SEARCHED:
 217                 signal = BT_SERVICE_SEARCHED;
 218                 break;
 219         case BLUETOOTH_HID_CONNECTED:
 220                 signal = BT_INPUT_CONNECTED;
 221                 BT_INFO_C("### Connected [HID]");
 222                 break;
 223         case BLUETOOTH_HID_DISCONNECTED:
 224                 signal = BT_INPUT_DISCONNECTED;
 225                 BT_INFO_C("### Disconnected [HID]");
 226                 break;
 227         case BLUETOOTH_HID_DEVICE_CONNECTED:
 228                 signal = BT_INPUT_HID_DEVICE_CONNECTED;
 229                 BT_INFO_C("### Connected [HID Device]");
 230                 break;
 231         case BLUETOOTH_HID_DEVICE_DISCONNECTED:
 232                 signal = BT_INPUT_HID_DEVICE_DISCONNECTED;
 233                 BT_INFO_C("### Disconnected [HID Device]");
 234                 break;
 235         case BLUETOOTH_PBAP_CONNECTED:
 236                 signal = BT_PBAP_CONNECTED;
 237                 BT_INFO_C("### Connected [PBAP Client]");
 238                 break;
 239         case BLUETOOTH_PBAP_DISCONNECTED:
 240                 signal = BT_PBAP_DISCONNECTED;
 241                 BT_INFO_C("### Disconnected [PBAP Client]");
 242                 break;
 243         case BLUETOOTH_PBAP_PHONEBOOK_SIZE:
 244                 signal = BT_PBAP_PHONEBOOK_SIZE;
 245                 break;
 246         case BLUETOOTH_PBAP_PHONEBOOK_PULL:
 247                 signal = BT_PBAP_PHONEBOOK_PULL;
 248                 break;
 249         case BLUETOOTH_PBAP_VCARD_LIST:
 250                 signal = BT_PBAP_VCARD_LIST;
 251                 break;
 252         case BLUETOOTH_PBAP_VCARD_PULL:
 253                 signal = BT_PBAP_VCARD_PULL;
 254                 break;
 255         case BLUETOOTH_PBAP_PHONEBOOK_SEARCH:
 256                 signal = BT_PBAP_SEARCH_PHONEBOOK;
 257                 break;
 258         case BLUETOOTH_EVENT_AG_CONNECTED:
 259                 signal = BT_HEADSET_CONNECTED;
 260                 BT_INFO_C("Connected [HSP/HFP]");
 261                 break;
 262         case BLUETOOTH_EVENT_AG_DISCONNECTED:
 263                 signal = BT_HEADSET_DISCONNECTED;
 264                 BT_INFO_C("Disconnected [HSP/HFP]");
 265                 break;
 266         case BLUETOOTH_EVENT_AV_CONNECTED:
 267                 signal = BT_STEREO_HEADSET_CONNECTED;
 268                 BT_INFO_C("### Connected [A2DP]");
 269                 break;
 270         case BLUETOOTH_EVENT_AV_DISCONNECTED:
 271                 signal = BT_STEREO_HEADSET_DISCONNECTED;
 272                 BT_INFO_C("### Disconnected [A2DP]");
 273                 break;
 274         case BLUETOOTH_EVENT_AV_SOURCE_CONNECTED:
 275                 signal = BT_A2DP_SOURCE_CONNECTED;
 276                 BT_INFO_C("### Connected [A2DP Source]");
 277                 break;
 278         case BLUETOOTH_EVENT_AV_SOURCE_DISCONNECTED:
 279                 signal = BT_A2DP_SOURCE_DISCONNECTED;
 280                 BT_INFO_C("### Disconnected [A2DP Source]");
 281                 break;
 282         case BLUETOOTH_EVENT_AG_AUDIO_CONNECTED:
 283                 signal = BT_SCO_CONNECTED;
 284                 BT_INFO_C("Connected [SCO]");
 285                 break;
 286         case BLUETOOTH_EVENT_AG_AUDIO_DISCONNECTED:
 287                 signal = BT_SCO_DISCONNECTED;
 288                 BT_INFO_C("Disonnected [SCO]");
 289                 break;
 290         case BLUETOOTH_EVENT_AG_SPEAKER_GAIN:
 291                 signal = BT_SPEAKER_GAIN;
 292                 break;
 293         case BLUETOOTH_EVENT_AG_MIC_GAIN:
 294                 signal = BT_MICROPHONE_GAIN;
 295                 break;
 296         case BLUETOOTH_EVENT_NETWORK_CONNECTED:
 297                 signal = BT_NETWORK_CONNECTED;
 298                 BT_INFO_C("Connected [Newwork]");
 299                 break;
 300         case BLUETOOTH_EVENT_NETWORK_DISCONNECTED:
 301                 signal = BT_NETWORK_DISCONNECTED;
 302                 BT_INFO_C("Disconnected [Newwork]");
 303                 break;
 304         case BLUETOOTH_EVENT_NETWORK_SERVER_CONNECTED:
 305                 signal = BT_NETWORK_SERVER_CONNECTED;
 306                 BT_INFO_C("Connected [Network Server]");
 307                 break;
 308         case BLUETOOTH_EVENT_NETWORK_SERVER_DISCONNECTED:
 309                 signal = BT_NETWORK_SERVER_DISCONNECTED;
 310                 BT_INFO_C("Disconnected [Network Server]");
 311                 break;
 312         case BLUETOOTH_EVENT_OPC_CONNECTED:
 313                 signal = BT_OPP_CONNECTED;
 314                 BT_INFO_C("Connected [OPP]");
 315                 break;
 316         case BLUETOOTH_EVENT_OPC_DISCONNECTED:
 317                 signal = BT_OPP_DISCONNECTED;
 318                 BT_INFO_C("Disconnected [OPP]");
 319                 break;
 320         case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_CONNECTED:
 321                 signal = BT_TRANSFER_CONNECTED;
 322                 break;
 323         case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_DISCONNECTED:
 324                 signal = BT_TRANSFER_DISCONNECTED;
 325                 break;
 326         case BLUETOOTH_EVENT_OPC_TRANSFER_STARTED:
 327         case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_STARTED:
 328                 signal = BT_TRANSFER_STARTED;
 329                 break;
 330         case BLUETOOTH_EVENT_OPC_TRANSFER_PROGRESS:
 331         case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_PROGRESS:
 332                 signal = BT_TRANSFER_PROGRESS;
 333                 break;
 334         case BLUETOOTH_EVENT_OPC_TRANSFER_COMPLETE:
 335         case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_COMPLETED:
 336                 signal = BT_TRANSFER_COMPLETED;
 337                 break;
 338         case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_AUTHORIZE:
 339                 signal = BT_TRANSFER_AUTHORIZED;
 340                 break;
 341         case BLUETOOTH_EVENT_OBEX_SERVER_CONNECTION_AUTHORIZE:
 342         case BLUETOOTH_EVENT_RFCOMM_AUTHORIZE:
 343                 signal = BT_CONNECTION_AUTHORIZED;
 344                 break;
 345         case BLUETOOTH_EVENT_RFCOMM_CONNECTED:
 346                 signal = BT_RFCOMM_CONNECTED;
 347                 break;
 348         case BLUETOOTH_EVENT_RFCOMM_DISCONNECTED:
 349                 signal = BT_RFCOMM_DISCONNECTED;
 350                 break;
 351         case BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED:
 352                 signal = BT_RFCOMM_DATA_RECEIVED;
 353                 break;
 354         case BLUETOOTH_EVENT_RFCOMM_SERVER_REMOVED:
 355                 signal = BT_RFCOMM_SERVER_REMOVED;
 356                 break;
 357         case BLUETOOTH_EVENT_DEVICE_CONNECTED:
 358                 signal = BT_DEVICE_CONNECTED;
 359                 break;
 360         case BLUETOOTH_EVENT_DEVICE_DISCONNECTED:
 361                 signal = BT_DEVICE_DISCONNECTED;
 362                 break;
 363         case BLUETOOTH_EVENT_AVRCP_CONNECTED:
 364         case BLUETOOTH_EVENT_AVRCP_CONTROL_CONNECTED:
 365                 signal = BT_AVRCP_CONNECTED;
 366                 BT_INFO_C("Connected [AVRCP]");
 367                 break;
 368         case BLUETOOTH_EVENT_AVRCP_DISCONNECTED:
 369         case BLUETOOTH_EVENT_AVRCP_CONTROL_DISCONNECTED:
 370                 signal = BT_AVRCP_DISCONNECTED;
 371                 BT_INFO_C("Disconnected [AVRCP]");
 372                 break;
 373         case BLUETOOTH_EVENT_AVRCP_SETTING_SHUFFLE_STATUS:
 374         case BLUETOOTH_EVENT_AVRCP_CONTROL_SHUFFLE_STATUS:
 375                 signal = BT_MEDIA_SHUFFLE_STATUS;
 376                 break;
 377         case BLUETOOTH_EVENT_AVRCP_SETTING_EQUALIZER_STATUS:
 378         case BLUETOOTH_EVENT_AVRCP_CONTROL_EQUALIZER_STATUS:
 379                 signal = BT_MEDIA_EQUALIZER_STATUS;
 380                 break;
 381         case BLUETOOTH_EVENT_AVRCP_SETTING_REPEAT_STATUS:
 382         case BLUETOOTH_EVENT_AVRCP_CONTROL_REPEAT_STATUS:
 383                 signal = BT_MEDIA_REPEAT_STATUS;
 384                 break;
 385         case BLUETOOTH_EVENT_AVRCP_SETTING_SCAN_STATUS:
 386         case BLUETOOTH_EVENT_AVRCP_CONTROL_SCAN_STATUS:
 387                 signal = BT_MEDIA_SCAN_STATUS;
 388                 break;
 389         case BLUETOOTH_EVENT_AVRCP_SONG_POSITION_STATUS:
 390                 signal = BT_MEDIA_POSITION_STATUS;
 391                 break;
 392         case BLUETOOTH_EVENT_AVRCP_PLAY_STATUS_CHANGED:
 393                 signal = BT_MEDIA_PLAY_STATUS;
 394                 break;
 395         case BLUETOOTH_EVENT_AVRCP_TRACK_CHANGED:
 396                 signal = BT_MEDIA_TRACK_CHANGE;
 397                 break;
 398         case BLUETOOTH_EVENT_GATT_CONNECTED:
 399                 signal = BT_GATT_CONNECTED;
 400                 BT_INFO_C("### Connected [GATT]");
 401                 break;
 402         case BLUETOOTH_EVENT_GATT_DISCONNECTED:
 403                 signal = BT_GATT_DISCONNECTED;
 404                 BT_INFO_C("### Disconnected [GATT]");
 405                 break;
 406         case BLUETOOTH_EVENT_GATT_ATT_MTU_CHANGED:
 407                 signal = BT_GATT_REQ_ATT_MTU_CHANGED;
 408                 break;
 409         case BLUETOOTH_EVENT_IPSP_INIT_STATE_CHANGED:
 410                 signal = BT_IPSP_INITIALIZED;
 411                 break;
 412         case BLUETOOTH_EVENT_IPSP_CONNECTED:
 413                 signal = BT_IPSP_CONNECTED;
 414                 break;
 415         case BLUETOOTH_EVENT_IPSP_DISCONNECTED:
 416                 signal = BT_IPSP_DISCONNECTED;
 417                 break;
 418         case BLUETOOTH_EVENT_GATT_CHAR_VAL_CHANGED:
 419                 signal = BT_GATT_CHAR_VAL_CHANGED;
 420                 break;
 421         case BLUETOOTH_EVENT_LE_DATA_LENGTH_CHANGED:
 422                 signal = BT_LE_DATA_LENGTH_CHANGED;
 423                 break;
 424         case BLUETOOTH_EVENT_REMOTE_IBEACON_DEVICE_FOUND:
 425                 signal = BT_IBEACON_DEVICE_FOUND;
 426                 break;
 427         case BLUETOOTH_EVENT_PXP_PROPERTY_CHANGED:
 428                 signal = BT_PXP_PROPERTY_CHANGED;
 429                 break;
 430         default:
 431                 BT_ERR("Unknown event");
 432                 return BLUETOOTH_ERROR_INTERNAL;
 433         }
 434
 435         BT_DBG("Path : %s", path);
 436         BT_INFO_C("Signal : %s", signal);
 437
 438         msg1 = g_dbus_message_new_signal(path, BT_EVENT_SERVICE, signal);
 439         g_dbus_message_set_body(msg1, param);
 440         if (!g_dbus_connection_send_message(event_conn, msg1, G_DBUS_SEND_MESSAGE_FLAGS_NONE, 0, NULL))
 441                 BT_ERR("Error while sending");
 442
 443         g_object_unref(msg1);
 444
 445 #ifdef HPS_FEATURE
 446         if (g_strcmp0(signal, BT_LE_ENABLED) == 0)
 447                 _bt_send_to_hps();
 448 #endif
 449
 450         return BLUETOOTH_ERROR_NONE;
 451 }
 452
 453 int _bt_send_event_to_dest(const char* dest, int event_type,
 454                 int event, GVariant *param)
 455 {
 456         char *path;
 457         char *signal;
 458         GError *error = NULL;
 459
 460         retv_if(event_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
 461
 462         BT_DBG("event_type [%d], event [%d]", event_type, event);
 463
 464         switch (event_type) {
 465         case BT_ADAPTER_EVENT:
 466                 path = BT_ADAPTER_PATH;
 467                 break;
 468         case BT_LE_ADAPTER_EVENT:
 469                 path = BT_LE_ADAPTER_PATH;
 470                 break;
 471         case BT_DEVICE_EVENT:
 472                 path = BT_DEVICE_PATH;
 473                 break;
 474         default:
 475                 BT_ERR("Unknown event");
 476                 return BLUETOOTH_ERROR_INTERNAL;
 477         }
 478
 479         switch (event) {
 480         case BLUETOOTH_EVENT_ADVERTISING_STARTED:
 481                 signal = BT_ADVERTISING_STARTED;
 482                 break;
 483         case BLUETOOTH_EVENT_ADVERTISING_STOPPED:
 484                 signal = BT_ADVERTISING_STOPPED;
 485                 break;
 486         case BLUETOOTH_EVENT_PASSKEY_NOTIFICATION:
 487                 signal = BT_PASSKEY_NOTIFICATION;
 488                 break;
 489         case BLUETOOTH_EVENT_LE_DISCOVERY_STARTED:
 490                 signal = BT_LE_DISCOVERY_STARTED;
 491                 break;
 492         case BLUETOOTH_EVENT_REMOTE_LE_DEVICE_FOUND:
 493                 signal = BT_LE_DEVICE_FOUND;
 494                 break;
 495         case BLUETOOTH_EVENT_LE_DISCOVERY_FINISHED:
 496                 signal = BT_LE_DISCOVERY_FINISHED;
 497                 break;
 498         case BLUETOOTH_EVENT_GATT_CHAR_VAL_CHANGED:
 499                 signal = BT_GATT_CHAR_VAL_CHANGED;
 500                 break;
 501         default:
 502                 BT_ERR("Unknown event");
 503                 return BLUETOOTH_ERROR_INTERNAL;
 504         }
 505
 506         BT_INFO_C("Signal : %s", signal);
 507
 508         if (!g_dbus_connection_emit_signal(event_conn, dest, path, BT_EVENT_SERVICE,
 509                         signal, param, &error)) {
 510                 BT_ERR("Error while sending Signal: %s", signal);
 511                 if (error) {
 512                         BT_ERR("Error Code [%d], Error Message [%s]",
 513                                         error->code, error->message);
 514                         g_clear_error(&error);
 515                 }
 516         }
 517
 518         return BLUETOOTH_ERROR_NONE;
 519 }
 520
 521 int _bt_send_hf_local_term_event(char *address)
 522 {
 523         GError *error = NULL;
 524
 525         retv_if(hf_local_term_event_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
 526
 527         if (!g_dbus_connection_emit_signal(hf_local_term_event_conn, NULL,
 528                         BT_HF_LOCAL_TERM_EVENT_PATH,
 529                         BT_HF_LOCAL_TERM_EVENT_INTERFACE,
 530                         BT_HF_LOCAL_TERM, g_variant_new("s", address),
 531                         &error)) {
 532                 BT_ERR("Error while sending Signal: %s", signal);
 533                 if (error) {
 534                         BT_ERR("Error Code [%d], Error Message [%s]",
 535                                         error->code, error->message);
 536                         g_clear_error(&error);
 537                 }
 538         }
 539
 540         return BLUETOOTH_ERROR_NONE;
 541 }
 542
 543 /* To send the event from service daemon to application*/
 544 int _bt_init_service_event_sender(void)
 545 {
 546         GDBusConnection *conn;
 547         GError *err = NULL;
 548
 549         if (event_conn) {
 550                 BT_ERR("Event handler is already exist");
 551                 return BLUETOOTH_ERROR_INTERNAL;
 552         }
 553
 554         conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &err);
 555         if (conn == NULL) {
 556                 BT_ERR("conn == NULL");
 557                 if (err) {
 558                         BT_ERR("Code[%d], Message[%s]",
 559                                         err->code, err->message);
 560                         g_clear_error(&err);
 561                 }
 562
 563                 return BLUETOOTH_ERROR_INTERNAL;
 564         }
 565
 566         event_conn = conn;
 567         return BLUETOOTH_ERROR_NONE;
 568 }
 569
 570 void _bt_deinit_service_event_sender(void)
 571 {
 572         if (event_conn) {
 573                 g_object_unref(event_conn);
 574                 event_conn = NULL;
 575         }
 576 }
 577
 578 int _bt_init_hf_local_term_event_sender(void)
 579 {
 580         GDBusConnection *conn;
 581         GError *err = NULL;
 582
 583         if (hf_local_term_event_conn) {
 584                 BT_ERR("Event handler is already exist");
 585                 return BLUETOOTH_ERROR_INTERNAL;
 586         }
 587
 588         conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &err);
 589         if (conn == NULL) {
 590                 BT_ERR("conn == NULL");
 591                 if (err) {
 592                         BT_ERR("Code[%d], Message[%s]",
 593                                         err->code, err->message);
 594                         g_clear_error(&err);
 595                 }
 596
 597                 return BLUETOOTH_ERROR_INTERNAL;
 598         }
 599
 600         hf_local_term_event_conn = conn;
 601
 602         return BLUETOOTH_ERROR_NONE;
 603 }
 604
 605 void _bt_deinit_hf_local_term_event_sender(void)
 606 {
 607         if (hf_local_term_event_conn) {
 608                 g_object_unref(hf_local_term_event_conn);
 609                 hf_local_term_event_conn = NULL;
 610         }
 611 }
 612
 613 int _bt_send_dump_signal(char *signal)
 614 {
 615         GError *error = NULL;
 616         int32_t pid = getpid();
 617
 618         retv_if(event_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
 619
 620         if (!g_dbus_connection_emit_signal(event_conn, NULL,
 621                         BT_DUMP_SERVICE_PATH,
 622                         BT_DUMP_SERVICE_INTERFACE,
 623                         signal, g_variant_new("(i)", pid),
 624                         &error)) {
 625                 BT_ERR("Error while sending Signal: %s", signal);
 626                 if (error) {
 627                         BT_ERR("Error Code [%d], Error Message [%s]",
 628                                         error->code, error->message);
 629                         g_clear_error(&error);
 630                 }
 631         }
 632
 633         return BLUETOOTH_ERROR_NONE;
 634 }