bt-service-adaptation/services/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 TIZEN_FEATURE_BT_HPS
  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_MAP_CLIENT_EVENT:
 104                 path = BT_MAP_CLIENT_PATH;
 105                 break;
 106         case BT_PBAP_CLIENT_EVENT:
 107                 path = BT_PBAP_CLIENT_PATH;
 108                 break;
 109         case BT_RFCOMM_CLIENT_EVENT:
 110                 path = BT_RFCOMM_CLIENT_PATH;
 111                 break;
 112         case BT_RFCOMM_SERVER_EVENT:
 113                 path = BT_RFCOMM_SERVER_PATH;
 114                 break;
 115         case BT_A2DP_SOURCE_EVENT:
 116                 path = BT_A2DP_SOURCE_PATH;
 117                 break;
 118         case BT_OTP_EVENT:
 119                 path = BT_OTP_PATH;
 120                 break;
 121 #ifndef GATT_DIRECT
 122         case BT_GATT_SERVER_EVENT:
 123                 path = BT_GATT_SERVER_PATH;
 124                 break;
 125 #endif
 126 #ifdef TIZEN_GATT_CLIENT
 127         case BT_GATT_CLIENT_EVENT:
 128                 path = BT_GATT_CLIENT_PATH;
 129                 break;
 130 #endif
 131
 132         default:
 133                 BT_ERR("Unknown event");
 134                 return BLUETOOTH_ERROR_INTERNAL;
 135         }
 136
 137         switch (event) {
 138         case BLUETOOTH_EVENT_ENABLED:
 139                 signal = BT_ENABLED;
 140                 BT_INFO_C("### BT Enabled");
 141                 break;
 142         case BLUETOOTH_EVENT_DISABLED:
 143                 signal = BT_DISABLED;
 144                 BT_INFO_C("### BT Disabled");
 145                 break;
 146         case BLUETOOTH_EVENT_DISABLED_BATTERY_DATA:
 147                 signal = BT_DISABLED_BATTERY_DATA;
 148                 BT_INFO_C("### Sending battery data for last session");
 149                 break;
 150         case BLUETOOTH_EVENT_LE_ENABLED:
 151                 signal = BT_LE_ENABLED;
 152                 break;
 153         case BLUETOOTH_EVENT_LE_DISABLED:
 154                 signal = BT_LE_DISABLED;
 155                 break;
 156         case BLUETOOTH_EVENT_LOCAL_NAME_CHANGED:
 157                 signal = BT_ADAPTER_NAME_CHANGED;
 158                 break;
 159         case BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED:
 160                 signal = BT_DISCOVERABLE_MODE_CHANGED;
 161                 break;
 162         case BLUETOOTH_EVENT_DISCOVERABLE_TIMEOUT_CHANGED:
 163                 signal = BT_DISCOVERABLE_TIMEOUT_CHANGED;
 164                 break;
 165         case BLUETOOTH_EVENT_CONNECTABLE_CHANGED:
 166                 signal = BT_CONNECTABLE_CHANGED;
 167                 break;
 168         case BLUETOOTH_EVENT_DISCOVERY_STARTED:
 169                 signal = BT_DISCOVERY_STARTED;
 170                 break;
 171         case BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND:
 172                 signal = BT_DEVICE_FOUND;
 173                 break;
 174         case BLUETOOTH_EVENT_DISCOVERY_FINISHED:
 175                 signal = BT_DISCOVERY_FINISHED;
 176                 break;
 177         case BLUETOOTH_EVENT_LE_DISCOVERY_STARTED:
 178                 signal = BT_LE_DISCOVERY_STARTED;
 179                 break;
 180         case BLUETOOTH_EVENT_REMOTE_LE_DEVICE_FOUND:
 181                 signal = BT_LE_DEVICE_FOUND;
 182                 break;
 183         case BLUETOOTH_EVENT_LE_DISCOVERY_FINISHED:
 184                 signal = BT_LE_DISCOVERY_FINISHED;
 185                 break;
 186         case BLUETOOTH_EVENT_ADVERTISING_STARTED:
 187                 signal = BT_ADVERTISING_STARTED;
 188                 break;
 189         case BLUETOOTH_EVENT_ADVERTISING_STOPPED:
 190                 signal = BT_ADVERTISING_STOPPED;
 191                 break;
 192         case BLUETOOTH_EVENT_ADVERTISING_MANUFACTURER_DATA_CHANGED:
 193                 signal = BT_ADVERTISING_MANUFACTURER_DATA_CHANGED;
 194                 break;
 195         case BLUETOOTH_EVENT_SCAN_RESPONSE_MANUFACTURER_DATA_CHANGED:
 196                 signal = BT_SCAN_RESPONSE_MANUFACTURER_DATA_CHANGED;
 197                 break;
 198         case BLUETOOTH_EVENT_MANUFACTURER_DATA_CHANGED:
 199                 signal = BT_MANUFACTURER_DATA_CHANGED;
 200                 break;
 201         case BLUETOOTH_EVENT_BONDING_FINISHED:
 202                 signal = BT_BOND_CREATED;
 203                 break;
 204         case BLUETOOTH_EVENT_BONDED_DEVICE_REMOVED:
 205                 signal = BT_BOND_DESTROYED;
 206                 break;
 207         case BLUETOOTH_EVENT_DEVICE_AUTHORIZED:
 208                 signal = BT_DEVICE_AUTHORIZED;
 209                 break;
 210         case BLUETOOTH_EVENT_DEVICE_UNAUTHORIZED:
 211                 signal = BT_DEVICE_UNAUTHORIZED;
 212                 break;
 213         case BLUETOOTH_EVENT_RSSI_ENABLED:
 214                 signal = BT_RSSI_MONITORING_ENABLED;
 215                 break;
 216         case BLUETOOTH_EVENT_RSSI_ALERT:
 217                 signal = BT_RSSI_ALERT;
 218                 break;
 219         case BLUETOOTH_EVENT_RAW_RSSI:
 220                 signal = BT_RAW_RSSI_EVENT;
 221                 break;
 222         case BLUETOOTH_EVENT_SUPPORTED_PROFILE_TRUSTED:
 223                 signal = BT_SUPPORTED_PROFILE_TRUSTED;
 224                 break;
 225         case BLUETOOTH_EVENT_KEYBOARD_PASSKEY_DISPLAY:
 226                 signal = BT_KBD_PASSKEY_DISPLAY_REQ_RECEIVED;
 227                 break;
 228         case BLUETOOTH_EVENT_PIN_REQUEST:
 229                 signal = BT_PIN_REQ_RECEIVED;
 230                 break;
 231         case BLUETOOTH_EVENT_PASSKEY_REQUEST:
 232                 signal = BT_PASSKEY_REQ_RECEIVED;
 233                 break;
 234         case BLUETOOTH_EVENT_PASSKEY_CONFIRM_REQUEST:
 235                 signal = BT_PASSKEY_CFM_REQ_RECEIVED;
 236                 break;
 237         case BLUETOOTH_EVENT_SERVICE_SEARCHED:
 238                 signal = BT_SERVICE_SEARCHED;
 239                 break;
 240         case BLUETOOTH_HID_CONNECTED:
 241                 signal = BT_INPUT_CONNECTED;
 242                 BT_INFO_C("Connected [HID]");
 243                 break;
 244         case BLUETOOTH_HID_DISCONNECTED:
 245                 signal = BT_INPUT_DISCONNECTED;
 246                 BT_INFO_C("Disconnected [HID]");
 247                 break;
 248         case BLUETOOTH_HID_DEVICE_CONNECTED:
 249                 signal = BT_INPUT_HID_DEVICE_CONNECTED;
 250                 BT_INFO_C("Connected [HIDDevice]");
 251                 break;
 252         case BLUETOOTH_HID_DEVICE_DISCONNECTED:
 253                 signal = BT_INPUT_HID_DEVICE_DISCONNECTED;
 254                 BT_INFO_C("Disconnected [HIDDevice]");
 255                 break;
 256         case BLUETOOTH_PBAP_CONNECTED:
 257                 signal = BT_PBAP_CONNECTED;
 258                 BT_INFO_C("Connected [PBAP Client]");
 259                 break;
 260         case BLUETOOTH_PBAP_DISCONNECTED:
 261                 signal = BT_PBAP_DISCONNECTED;
 262                 BT_INFO_C("Disconnected [PBAP Client]");
 263                 break;
 264         case BLUETOOTH_PBAP_PHONEBOOK_SIZE:
 265                 signal = BT_PBAP_PHONEBOOK_SIZE;
 266                 break;
 267         case BLUETOOTH_PBAP_PHONEBOOK_PULL:
 268                 signal = BT_PBAP_PHONEBOOK_PULL;
 269                 break;
 270         case BLUETOOTH_PBAP_VCARD_LIST:
 271                 signal = BT_PBAP_VCARD_LIST;
 272                 break;
 273         case BLUETOOTH_PBAP_VCARD_PULL:
 274                 signal = BT_PBAP_VCARD_PULL;
 275                 break;
 276         case BLUETOOTH_PBAP_PHONEBOOK_SEARCH:
 277                 signal = BT_PBAP_SEARCH_PHONEBOOK;
 278                 break;
 279         case BLUETOOTH_EVENT_AG_CONNECTED:
 280                 signal = BT_HEADSET_CONNECTED;
 281                 BT_INFO_C("Connected [HSP/HFP]");
 282                 break;
 283         case BLUETOOTH_EVENT_AG_DISCONNECTED:
 284                 signal = BT_HEADSET_DISCONNECTED;
 285                 BT_INFO_C("Disconnected [HSP/HFP]");
 286                 break;
 287         case BLUETOOTH_EVENT_AV_CONNECTED:
 288                 signal = BT_STEREO_HEADSET_CONNECTED;
 289                 BT_INFO_C("Connected [A2DP]");
 290                 break;
 291         case BLUETOOTH_EVENT_AV_DISCONNECTED:
 292                 signal = BT_STEREO_HEADSET_DISCONNECTED;
 293                 BT_INFO_C("Disconnected [A2DP]");
 294                 break;
 295         case BLUETOOTH_EVENT_AV_SOURCE_CONNECTED:
 296                 signal = BT_A2DP_SOURCE_CONNECTED;
 297                 BT_INFO_C("Connected [A2DP Source]");
 298                 break;
 299         case BLUETOOTH_EVENT_AV_SOURCE_DISCONNECTED:
 300                 signal = BT_A2DP_SOURCE_DISCONNECTED;
 301                 BT_INFO_C("Disconnected [A2DP Source]");
 302                 break;
 303         case BLUETOOTH_EVENT_AG_AUDIO_CONNECTED:
 304                 signal = BT_SCO_CONNECTED;
 305                 BT_INFO_C("Connected [SCO]");
 306                 break;
 307         case BLUETOOTH_EVENT_AG_AUDIO_DISCONNECTED:
 308                 signal = BT_SCO_DISCONNECTED;
 309                 BT_INFO_C("Disonnected [SCO]");
 310                 break;
 311         case BLUETOOTH_EVENT_AG_SPEAKER_GAIN:
 312                 signal = BT_SPEAKER_GAIN;
 313                 break;
 314         case BLUETOOTH_EVENT_AG_MIC_GAIN:
 315                 signal = BT_MICROPHONE_GAIN;
 316                 break;
 317         case BLUETOOTH_EVENT_NETWORK_CONNECTED:
 318                 signal = BT_NETWORK_CONNECTED;
 319                 BT_INFO_C("Connected [Newwork]");
 320                 break;
 321         case BLUETOOTH_EVENT_NETWORK_DISCONNECTED:
 322                 signal = BT_NETWORK_DISCONNECTED;
 323                 BT_INFO_C("Disconnected [Newwork]");
 324                 break;
 325         case BLUETOOTH_EVENT_NETWORK_SERVER_CONNECTED:
 326                 signal = BT_NETWORK_SERVER_CONNECTED;
 327                 BT_INFO_C("Connected [Network Server]");
 328                 break;
 329         case BLUETOOTH_EVENT_NETWORK_SERVER_DISCONNECTED:
 330                 signal = BT_NETWORK_SERVER_DISCONNECTED;
 331                 BT_INFO_C("Disconnected [Network Server]");
 332                 break;
 333         case BLUETOOTH_EVENT_OPC_CONNECTED:
 334                 signal = BT_OPP_CONNECTED;
 335                 BT_INFO_C("Connected [OPP]");
 336                 break;
 337         case BLUETOOTH_EVENT_OPC_DISCONNECTED:
 338                 signal = BT_OPP_DISCONNECTED;
 339                 BT_INFO_C("Disconnected [OPP]");
 340                 break;
 341         case BLUETOOTH_EVENT_MAP_CONNECTED:
 342                 signal = BT_MAP_CONNECTED;
 343                 BT_INFO_C("Connected [MAP]");
 344                 break;
 345         case BLUETOOTH_EVENT_MAP_DISCONNECTED:
 346                 signal = BT_MAP_DISCONNECTED;
 347                 BT_INFO_C("Disconnected [MAP]");
 348                 break;
 349         case BLUETOOTH_EVENT_MAP_LIST_FOLDERS_COMPLETE:
 350                 signal = BT_MAP_LIST_FOLDERS_COMPLETE;
 351                 BT_INFO_C("Completed list folders operation[MAP]");
 352                 break;
 353         case BLUETOOTH_EVENT_MAP_LIST_FILTER_FIELD_COMPLETE:
 354                 signal = BT_MAP_FILTER_FIELDS_COMPLETE;
 355                 BT_INFO_C("Completed list filters field operation[MAP]");
 356                 break;
 357         case BLUETOOTH_EVENT_MAP_LIST_MESSAGES_COMPLETE:
 358                 signal = BT_MAP_LIST_MESSAGES_COMPLETE;
 359                 BT_INFO_C("Completed list messages operation [MAP]");
 360                 break;
 361         case BLUETOOTH_EVENT_MAP_GET_MESSAGE_COMPLETE:
 362                 signal = BT_MAP_GET_MESSAGE_COMPLETE;
 363                 BT_INFO_C("Completed get message operation [MAP]");
 364                 break;
 365         case BLUETOOTH_EVENT_MAP_PUSH_MESSAGE_COMPLETE:
 366                 signal = BT_MAP_PUSH_MESSAGE_COMPLETE;
 367                 BT_INFO_C("Completed push message operation [MAP]");
 368                 break;
 369         case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_CONNECTED:
 370                 signal = BT_TRANSFER_CONNECTED;
 371                 break;
 372         case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_DISCONNECTED:
 373                 signal = BT_TRANSFER_DISCONNECTED;
 374                 break;
 375         case BLUETOOTH_EVENT_OPC_TRANSFER_STARTED:
 376         case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_STARTED:
 377                 signal = BT_TRANSFER_STARTED;
 378                 break;
 379         case BLUETOOTH_EVENT_OPC_TRANSFER_PROGRESS:
 380         case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_PROGRESS:
 381                 signal = BT_TRANSFER_PROGRESS;
 382                 break;
 383         case BLUETOOTH_EVENT_OPC_TRANSFER_COMPLETE:
 384         case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_COMPLETED:
 385                 signal = BT_TRANSFER_COMPLETED;
 386                 break;
 387         case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_AUTHORIZE:
 388                 signal = BT_TRANSFER_AUTHORIZED;
 389                 break;
 390         case BLUETOOTH_EVENT_OBEX_SERVER_CONNECTION_AUTHORIZE:
 391         case BLUETOOTH_EVENT_RFCOMM_AUTHORIZE:
 392                 signal = BT_CONNECTION_AUTHORIZED;
 393                 break;
 394         case BLUETOOTH_EVENT_RFCOMM_CONNECTED:
 395                 signal = BT_RFCOMM_CONNECTED;
 396                 break;
 397         case BLUETOOTH_EVENT_RFCOMM_DISCONNECTED:
 398                 signal = BT_RFCOMM_DISCONNECTED;
 399                 break;
 400         case BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED:
 401                 signal = BT_RFCOMM_DATA_RECEIVED;
 402                 break;
 403         case BLUETOOTH_EVENT_RFCOMM_SERVER_REMOVED:
 404                 signal = BT_RFCOMM_SERVER_REMOVED;
 405                 break;
 406         case BLUETOOTH_EVENT_DEVICE_CONNECTED:
 407                 signal = BT_DEVICE_CONNECTED;
 408                 break;
 409         case BLUETOOTH_EVENT_DEVICE_DISCONNECTED:
 410                 signal = BT_DEVICE_DISCONNECTED;
 411                 break;
 412         case BLUETOOTH_EVENT_AVRCP_CONNECTED:
 413         case BLUETOOTH_EVENT_AVRCP_CONTROL_CONNECTED:
 414                 signal = BT_AVRCP_CONNECTED;
 415                 BT_INFO_C("Connected [AVRCP]");
 416                 break;
 417         case BLUETOOTH_EVENT_AVRCP_DISCONNECTED:
 418         case BLUETOOTH_EVENT_AVRCP_CONTROL_DISCONNECTED:
 419                 signal = BT_AVRCP_DISCONNECTED;
 420                 BT_INFO_C("Disconnected [AVRCP]");
 421                 break;
 422         case BLUETOOTH_EVENT_AVRCP_SETTING_SHUFFLE_STATUS:
 423         case BLUETOOTH_EVENT_AVRCP_CONTROL_SHUFFLE_STATUS:
 424                 signal = BT_MEDIA_SHUFFLE_STATUS;
 425                 break;
 426         case BLUETOOTH_EVENT_AVRCP_SETTING_EQUALIZER_STATUS:
 427         case BLUETOOTH_EVENT_AVRCP_CONTROL_EQUALIZER_STATUS:
 428                 signal = BT_MEDIA_EQUALIZER_STATUS;
 429                 break;
 430         case BLUETOOTH_EVENT_AVRCP_SETTING_REPEAT_STATUS:
 431         case BLUETOOTH_EVENT_AVRCP_CONTROL_REPEAT_STATUS:
 432                 signal = BT_MEDIA_REPEAT_STATUS;
 433                 break;
 434         case BLUETOOTH_EVENT_AVRCP_SETTING_SCAN_STATUS:
 435         case BLUETOOTH_EVENT_AVRCP_CONTROL_SCAN_STATUS:
 436                 signal = BT_MEDIA_SCAN_STATUS;
 437                 break;
 438         case BLUETOOTH_EVENT_AVRCP_SONG_POSITION_STATUS:
 439                 signal = BT_MEDIA_POSITION_STATUS;
 440                 break;
 441         case BLUETOOTH_EVENT_AVRCP_PLAY_STATUS_CHANGED:
 442                 signal = BT_MEDIA_PLAY_STATUS;
 443                 break;
 444         case BLUETOOTH_EVENT_AVRCP_TRACK_CHANGED:
 445                 signal = BT_MEDIA_TRACK_CHANGE;
 446                 break;
 447         case BLUETOOTH_EVENT_AVRCP_DELAY_CHANGED:
 448                 signal = BT_MEDIA_DELAY_CHANGE;
 449                 break;
 450 #ifdef TIZEN_GATT_CLIENT
 451         case BLUETOOTH_EVENT_GATT_SERVER_CONNECTED: /* GATT Server and Client */
 452                 signal = BT_GATT_SERVER_CONNECTED;
 453                 break;
 454         case BLUETOOTH_EVENT_GATT_SERVER_DISCONNECTED: /* GATT Client and Server */
 455                 signal = BT_GATT_SERVER_DISCONNECTED;
 456                 break;
 457         case BLUETOOTH_EVENT_GATT_CLIENT_CONNECTED: /* GATT Server and Client */
 458                 signal = BT_GATT_CLIENT_CONNECTED;
 459                 break;
 460         case BLUETOOTH_EVENT_GATT_CLIENT_DISCONNECTED: /* GATT Client and Server */
 461                 signal = BT_GATT_CLIENT_DISCONNECTED;
 462                 break;
 463 #else
 464         case BLUETOOTH_EVENT_GATT_CONNECTED:
 465                 signal = BT_GATT_CONNECTED;
 466                 BT_INFO_C("### Connected [GATT]");
 467                 break;
 468         case BLUETOOTH_EVENT_GATT_DISCONNECTED:
 469                 signal = BT_GATT_DISCONNECTED;
 470                 BT_INFO_C("### Disconnected [GATT]");
 471                 break;
 472 #endif
 473         case BLUETOOTH_EVENT_GATT_ATT_MTU_CHANGED:
 474                 signal = BT_GATT_REQ_ATT_MTU_CHANGED;
 475                 break;
 476         case BLUETOOTH_EVENT_GATT_SERVER_ATT_MTU_CHANGED:
 477                 signal = BT_GATT_SERVER_ATT_MTU_CHANGED;
 478                 break;
 479 #ifndef GATT_DIRECT
 480         case BLUETOOTH_EVENT_GATT_SERVER_VALUE_CHANGED:
 481                 signal = BT_GATT_VALUE_CHANGED;
 482                 break;
 483         case BLUETOOTH_EVENT_GATT_SERVER_READ_REQUESTED:
 484                 signal = BT_GATT_SERVER_READ_REQ;
 485                 break;
 486         case BLUETOOTH_EVENT_GATT_SERVER_NOTIFICATION_COMPLETED:
 487                 signal = BT_GATT_SERVER_NOTIFICATION_COMPLETED;
 488                 break;
 489         case BLUETOOTH_EVENT_GATT_SERVER_NOTIFICATION_STATE_CHANGED:
 490                 signal = BT_GATT_SERVER_NOTIFICATION_CHANGED;
 491                 break;
 492         case BLUETOOTH_EVENT_GATT_SERVER_ACQUIRE_WRITE:
 493                 signal = BT_GATT_SERVER_ACQUIRE_WRITE;
 494                 break;
 495         case BLUETOOTH_EVENT_GATT_SERVER_ACQUIRE_NOTIFY:
 496                 signal = BT_GATT_SERVER_ACQUIRE_NOTIFICATION;
 497                 break;
 498 #endif
 499 #ifdef TIZEN_GATT_CLIENT
 500         case BLUETOOTH_EVENT_GATT_READ_CHAR:       /* GATT Client */
 501                 signal = BT_GATT_CLIENT_READ_CHAR;
 502                 break;
 503         case BLUETOOTH_EVENT_GATT_WRITE_CHAR:      /* GATT Client */
 504                 signal = BT_GATT_CLIENT_WRITE_CHAR;
 505                 break;
 506         case BLUETOOTH_EVENT_GATT_READ_DESC:       /* GATT Client */
 507                 signal = BT_GATT_CLIENT_READ_DESC;
 508                 break;
 509         case BLUETOOTH_EVENT_GATT_WRITE_DESC:      /* GATT Client */
 510                 signal = BT_GATT_CLIENT_WRITE_DESC;
 511                 break;
 512 #endif
 513
 514         case BLUETOOTH_EVENT_IPSP_INIT_STATE_CHANGED:
 515                 signal = BT_IPSP_INITIALIZED;
 516                 break;
 517         case BLUETOOTH_EVENT_IPSP_CONNECTED:
 518                 signal = BT_IPSP_CONNECTED;
 519                 break;
 520         case BLUETOOTH_EVENT_IPSP_DISCONNECTED:
 521                 signal = BT_IPSP_DISCONNECTED;
 522                 break;
 523         case BLUETOOTH_EVENT_GATT_CHAR_VAL_CHANGED:
 524                 signal = BT_GATT_CHAR_VAL_CHANGED;
 525                 break;
 526         case BLUETOOTH_EVENT_LE_DATA_LENGTH_CHANGED:
 527                 signal = BT_LE_DATA_LENGTH_CHANGED;
 528                 break;
 529         case BLUETOOTH_EVENT_PXP_PROPERTY_CHANGED:
 530                 signal = BT_PXP_PROPERTY_CHANGED;
 531                 break;
 532         case BLUETOOTH_EVENT_OTP_SERVER_STATE_CHANGED:
 533                 signal = BT_OTP_SERVER_STATE_CHANGED;
 534                 break;
 535         case BLUETOOTH_EVENT_OTC_STATE_CHANGED:
 536                 signal = BT_OTC_STATE_CHANGED;
 537                 break;
 538         default:
 539                 BT_ERR("Unknown event");
 540                 return BLUETOOTH_ERROR_INTERNAL;
 541         }
 542
 543         BT_DBG("Path : %s", path);
 544         BT_INFO_C("Signal : %s", signal);
 545
 546         msg1 = g_dbus_message_new_signal(path, BT_EVENT_SERVICE, signal);
 547         g_dbus_message_set_body(msg1, param);
 548         if (!g_dbus_connection_send_message(event_conn, msg1, G_DBUS_SEND_MESSAGE_FLAGS_NONE, 0, NULL))
 549                 BT_ERR("Error while sending");
 550
 551         g_object_unref(msg1);
 552
 553 #ifdef TIZEN_FEATURE_BT_HPS
 554         if (g_strcmp0(signal, BT_LE_ENABLED) == 0)
 555                 _bt_send_to_hps();
 556 #endif
 557
 558         return BLUETOOTH_ERROR_NONE;
 559 }
 560
 561 int _bt_send_event_to_dest(const char* dest, int event_type,
 562                 int event, GVariant *param)
 563 {
 564         char *path;
 565         char *signal;
 566         GError *error = NULL;
 567
 568         retv_if(event_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
 569
 570         BT_DBG("event_type [%d], event [%d]", event_type, event);
 571
 572         switch (event_type) {
 573         case BT_ADAPTER_EVENT:
 574                 path = BT_ADAPTER_PATH;
 575                 break;
 576         case BT_LE_ADAPTER_EVENT:
 577                 path = BT_LE_ADAPTER_PATH;
 578                 break;
 579         case BT_DEVICE_EVENT:
 580                 path = BT_DEVICE_PATH;
 581                 break;
 582         case BT_TDS_EVENT:
 583                 path = BT_TDS_PATH;
 584                 break;
 585         case BT_OTP_EVENT:
 586                 path = BT_OTP_PATH;
 587                 break;
 588         case BT_HDP_EVENT:
 589                 path = BT_HDP_DEVICE_PATH;
 590                 break;
 591         default:
 592                 BT_ERR("Unknown event");
 593                 return BLUETOOTH_ERROR_INTERNAL;
 594         }
 595
 596         switch (event) {
 597         case BLUETOOTH_EVENT_ADVERTISING_STARTED:
 598                 signal = BT_ADVERTISING_STARTED;
 599                 break;
 600         case BLUETOOTH_EVENT_ADVERTISING_STOPPED:
 601                 signal = BT_ADVERTISING_STOPPED;
 602                 break;
 603         case BLUETOOTH_EVENT_PASSKEY_NOTIFICATION:
 604                 signal = BT_PASSKEY_NOTIFICATION;
 605                 break;
 606         case BLUETOOTH_EVENT_LE_DISCOVERY_STARTED:
 607                 signal = BT_LE_DISCOVERY_STARTED;
 608                 break;
 609         case BLUETOOTH_EVENT_REMOTE_LE_DEVICE_FOUND:
 610                 signal = BT_LE_DEVICE_FOUND;
 611                 break;
 612         case BLUETOOTH_EVENT_LE_DISCOVERY_FINISHED:
 613                 signal = BT_LE_DISCOVERY_FINISHED;
 614                 break;
 615         case BLUETOOTH_EVENT_GATT_CHAR_VAL_CHANGED:
 616                 signal = BT_GATT_CHAR_VAL_CHANGED;
 617                 break;
 618         case BLUETOOTH_EVENT_TDS_ACTIVATION_REQUESTED:
 619                 signal = BT_TDS_ACTIVATION_REQUESTED;
 620                 break;
 621         case BLUETOOTH_EVENT_TDS_TRANSPORT_DATA_RECEIVED:
 622                 signal = BT_TDS_TRANSPORT_DATA_RECEIVED;
 623                 break;
 624         case BLUETOOTH_EVENT_TDS_ACTIVATION_INDICATION:
 625                 signal = BT_TDS_ACTIVATION_INDICATION;
 626                 break;
 627         case BLUETOOTH_EVENT_TDS_CONTROL_POINT_ENABLED:
 628                 signal = BT_TDS_CONTROL_POINT_ENABLED;
 629                 break;
 630         case BLUETOOTH_EVENT_TDS_ACTIVATION_RESULT:
 631                 signal = BT_TDS_ACTIVATION_RESULT;
 632                 break;
 633         case BLUETOOTH_EVENT_OTP_READ_CHAR_VAL:
 634                 signal = BT_OTP_READ_CHAR_VAL;
 635                 break;
 636         case BLUETOOTH_EVENT_OTP_NOTIFICATION_ENABLED:
 637                 signal = BT_OTP_NOTIFICATION_ENABLED;
 638                 break;
 639         case BLUETOOTH_EVENT_OTP_WRITE_CHAR_VAL:
 640                 signal = BT_OTP_WRITE_CHAR_VAL;
 641                 break;
 642         case BLUETOOTH_EVENT_OTP_INDICATION:
 643                 signal = BT_OTP_INDICATION;
 644                 break;
 645         case BLUETOOTH_EVENT_HDP_CONNECTED:
 646                 signal = BT_HDP_CONNECTED;
 647                 break;
 648         case BLUETOOTH_EVENT_HDP_DISCONNECTED:
 649                 signal = BT_HDP_DISCONNECTED;
 650                 break;
 651         default:
 652                 BT_ERR("Unknown event");
 653                 return BLUETOOTH_ERROR_INTERNAL;
 654         }
 655
 656         BT_INFO_C("Signal : %s", signal);
 657
 658         if (!g_dbus_connection_emit_signal(event_conn, dest, path, BT_EVENT_SERVICE,
 659                         signal, param, &error)) {
 660                 BT_ERR("Error while sending Signal: %s", signal);
 661                 if (error) {
 662                         BT_ERR("Error Code [%d], Error Message [%s]",
 663                                         error->code, error->message);
 664                         g_clear_error(&error);
 665                 }
 666         }
 667
 668         return BLUETOOTH_ERROR_NONE;
 669 }
 670
 671 int _bt_send_hf_local_term_event(char *address)
 672 {
 673         GError *error = NULL;
 674
 675         retv_if(hf_local_term_event_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
 676
 677         if (!g_dbus_connection_emit_signal(hf_local_term_event_conn, NULL,
 678                         BT_HF_LOCAL_TERM_EVENT_PATH,
 679                         BT_HF_LOCAL_TERM_EVENT_INTERFACE,
 680                         BT_HF_LOCAL_TERM, g_variant_new("s", address),
 681                         &error)) {
 682                 BT_ERR("Error while sending Signal: %s", address);
 683                 if (error) {
 684                         BT_ERR("Error Code [%d], Error Message [%s]",
 685                                         error->code, error->message);
 686                         g_clear_error(&error);
 687                 }
 688         }
 689
 690         return BLUETOOTH_ERROR_NONE;
 691 }
 692
 693 /* To send the event from service daemon to application*/
 694 int _bt_init_service_event_sender(void)
 695 {
 696         GDBusConnection *conn;
 697         GError *err = NULL;
 698
 699         if (event_conn) {
 700                 BT_ERR("Event handler is already exist");
 701                 return BLUETOOTH_ERROR_INTERNAL;
 702         }
 703
 704         conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &err);
 705
 706         if (conn == NULL) {
 707                 BT_ERR("conn == NULL");
 708                 if (err) {
 709                         BT_ERR("Code[%d], Message[%s]",
 710                                         err->code, err->message);
 711                         g_clear_error(&err);
 712                 }
 713
 714                 return BLUETOOTH_ERROR_INTERNAL;
 715         }
 716
 717         event_conn = conn;
 718         return BLUETOOTH_ERROR_NONE;
 719 }
 720
 721 void _bt_deinit_service_event_sender(void)
 722 {
 723         if (event_conn) {
 724                 g_object_unref(event_conn);
 725                 event_conn = NULL;
 726         }
 727 }
 728
 729 int _bt_init_hf_local_term_event_sender(void)
 730 {
 731         GDBusConnection *conn;
 732         GError *err = NULL;
 733
 734         if (hf_local_term_event_conn) {
 735                 BT_ERR("Event handler is already exist");
 736                 return BLUETOOTH_ERROR_INTERNAL;
 737         }
 738
 739         conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &err);
 740
 741         if (conn == NULL) {
 742                 BT_ERR("conn == NULL");
 743                 if (err) {
 744                         BT_ERR("Code[%d], Message[%s]",
 745                                         err->code, err->message);
 746                         g_clear_error(&err);
 747                 }
 748
 749                 return BLUETOOTH_ERROR_INTERNAL;
 750         }
 751
 752         hf_local_term_event_conn = conn;
 753
 754         return BLUETOOTH_ERROR_NONE;
 755 }
 756
 757 void _bt_deinit_hf_local_term_event_sender(void)
 758 {
 759         if (hf_local_term_event_conn) {
 760                 g_object_unref(hf_local_term_event_conn);
 761                 hf_local_term_event_conn = NULL;
 762         }
 763 }
 764
 765 int _bt_send_dump_signal(char *signal)
 766 {
 767         GError *error = NULL;
 768         int32_t pid = getpid();
 769
 770         retv_if(event_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
 771
 772         if (!g_dbus_connection_emit_signal(event_conn, NULL,
 773                         BT_DUMP_SERVICE_PATH,
 774                         BT_DUMP_SERVICE_INTERFACE,
 775                         signal, g_variant_new("(i)", pid),
 776                         &error)) {
 777                 BT_ERR("Error while sending Signal: %s", signal);
 778                 if (error) {
 779                         BT_ERR("Error Code [%d], Error Message [%s]",
 780                                         error->code, error->message);
 781                         g_clear_error(&error);
 782                 }
 783         }
 784
 785         return BLUETOOTH_ERROR_NONE;
 786 }
 787