bt-oal/bluez_hal/src/bt-hal-event-receiver.c

   1 /*
   2  * BLUETOOTH HAL
   3  *
   4  * Copyright (c) 2015 -2016 Samsung Electronics Co., Ltd All Rights Reserved.
   5  *
   6  * Contact: Anupam Roy <anupam.r@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *              http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21
  22 #include <glib.h>
  23 #include <string.h>
  24 #include <dlog.h>
  25 #include <vconf.h>
  26
  27 #include <glib.h>
  28 #include <gio/gio.h>
  29 #include <vconf.h>
  30
  31 /* BT HAL Headers */
  32 #include "bt-hal.h"
  33 #include "bt-hal-log.h"
  34 #include "bt-hal-msg.h"
  35 #include "bt-hal-internal.h"
  36 #include "bt-hal-event-receiver.h"
  37 #include "bt-hal-dbus-common-utils.h"
  38 #include "bt-hal-agent.h"
  39 #include "bt-hal-adapter-le.h"
  40 #include "bt-hal-gatt-server.h"
  41 #include "bt-hal-gatt-client.h"
  42 #include "bt-hal-adapter-dbus-handler.h"
  43
  44 #define BASELEN_PROP_CHANGED (sizeof(struct hal_ev_adapter_props_changed) \
  45                 + sizeof(struct hal_property))
  46
  47 /*TODO: Basic filters are currently added,
  48   Need to add different event filters like HID,
  49   Device etc in subsequent patches */
  50
  51 /* Global variables and structures */
  52 static GDBusConnection *manager_conn;
  53 static handle_stack_msg event_cb = NULL;
  54 static handle_stack_msg hid_event_cb = NULL;
  55 static handle_stack_msg hid_device_event_cb = NULL;
  56 static handle_stack_msg av_event_cb = NULL;
  57 static handle_stack_msg a2dp_sink_event_cb = NULL;
  58 static handle_stack_msg hf_event_cb = NULL;
  59 static handle_stack_msg hf_client_event_cb = NULL;
  60 static handle_stack_msg avrcp_ctrl_event_cb = NULL;
  61 static handle_stack_msg avrcp_tg_event_cb = NULL;
  62 static handle_stack_msg gatt_event_cb = NULL;
  63 static guint event_id;
  64
  65 /*State Management sepration Control for Adapter and LE */
  66 static gboolean is_adapter_activating = FALSE;
  67 static gboolean is_le_activating = FALSE;
  68
  69 typedef struct {
  70         gchar* sender_name;
  71         gchar* object_path;
  72         gchar* interface_name;
  73         gchar* signal_name;
  74         GVariant *parameters;
  75 } bt_hal_main_event_data_t;
  76
  77 /* Forward declarations */
  78 static gboolean __bt_hal_event_manager(gpointer param);
  79 static int __bt_hal_register_service_event(GDBusConnection *g_conn, int event_type);
  80 static int __bt_hal_register_manager_subscribe_signal(GDBusConnection *conn, int subscribe);
  81 static int __bt_hal_register_device_subscribe_signal(GDBusConnection *conn, int subscribe);
  82 static int __bt_hal_register_input_subscribe_signal(GDBusConnection *conn, int subscribe);
  83
  84 static int __bt_hal_parse_event(GVariant *msg);
  85 static int __bt_hal_get_owner_info(GVariant *msg, char **name, char **previous, char **current);
  86
  87 static void __bt_hal_handle_property_changed_event(GVariant *msg, const char *object_path);
  88 static void __bt_hal_adapter_property_changed_event(GVariant *msg);
  89 static  void __bt_hal_manager_event_filter(GDBusConnection *connection, const gchar *sender_name,
  90                         const gchar *object_path, const gchar *interface_name, const gchar *signal_name,
  91                         GVariant *parameters, gpointer user_data);
  92 static int __bt_hal_initialize_manager_receiver(void);
  93 static gboolean __bt_hal_parse_interface(GVariant *msg);
  94 static void __bt_hal_handle_device_event(GVariant *value, GVariant *parameters);
  95 static gboolean __bt_hal_parse_device_properties(GVariant *item);
  96 static gboolean __bt_hal_discovery_finished_cb(gpointer user_data);
  97 static void __bt_hal_device_property_changed_event(GVariant *msg, const char *path);
  98 static void __bt_hal_dbus_device_found_properties(const char *device_path);
  99 static void __bt_hal_device_properties_lookup(GVariant *result, char *address);
 100 static void __bt_hal_handle_device_specific_events(GVariant *msg, const char *member, const char *path);
 101 static void __bt_hal_send_device_acl_connection_state_event(int status, gboolean connected, const char *address);
 102 static void __bt_hal_handle_input_event(GVariant *msg, const char *path);
 103 static void __bt_hal_send_av_connection_state_event(gboolean connected, const char *address);
 104 static void __bt_hal_send_a2dp_sink_connection_state_event(gboolean connected, const char *address);
 105 static void __bt_hal_send_avrcp_ctrl_connection_state_event(gboolean connected, const char *address);
 106 static void __bt_hal_handle_avrcp_ctrl_events(GVariant *msg, const char *member, const char *path);
 107 static void __bt_hal_handle_avrcp_transport_events(GVariant *msg, const char *member, const char *path);
 108
 109 static void __bt_hal_send_device_trust_state_event(gboolean is_trusted, const char *address);
 110 static int __bt_hal_register_audio_subscribe_signal(GDBusConnection *conn, int subscribe);
 111 static void __bt_hal_handle_headset_events(GVariant *msg, const char *member, const char *path);
 112 static void __bt_hal_send_hf_audio_connection_state_event(gboolean connected, const char *address);
 113 static void __bt_hal_send_hf_connection_state_event(gboolean connected, const char *address);
 114 static void __bt_hal_send_device_trusted_profile_changed_event(uint32_t trust_val, const char *address);
 115 static void __bt_hal_handle_adv_report(GVariant *msg, const char *path);
 116 static void __bt_hal_handle_gatts_mtu_changed_event(char *address, int mtu);
 117 static void __bt_hal_send_hf_client_connection_state_event(gboolean connected, const char *address);
 118
 119
 120 static gboolean __bt_hal_discovery_finished_cb(gpointer user_data)
 121 {
 122         event_id = 0;
 123         DBG("+");
 124         struct hal_ev_discovery_state_changed ev;
 125         ev.state = HAL_DISCOVERY_STATE_STOPPED;
 126         event_cb(HAL_EV_DISCOVERY_STATE_CHANGED, &ev, sizeof(ev));
 127         DBG("-");
 128
 129         return FALSE;
 130 }
 131
 132 static int __bt_hal_parse_event(GVariant *msg)
 133 {
 134         GVariantIter iter;
 135         GVariant *child;
 136         char *interface_name = NULL;
 137         GVariant *inner_iter = NULL;
 138
 139         g_variant_iter_init(&iter, msg);
 140
 141         while ((child = g_variant_iter_next_value(&iter))) {
 142                 g_variant_get(child, "{&s@a{sv}}", &interface_name, &inner_iter);
 143                 if (g_strcmp0(interface_name,
 144                                         BT_HAL_DEVICE_INTERFACE) == 0) {
 145                         DBG("__bt_hal_parse_event: Interface: BT_HAL_DEVICE_INTERFACE");
 146                         g_variant_unref(inner_iter);
 147                         g_variant_unref(child);
 148                         return BT_HAL_DEVICE_EVENT;
 149                 } else if (g_strcmp0(interface_name,
 150                                         BT_HAL_MEDIATRANSPORT_INTERFACE) == 0) {
 151                         DBG("__bt_hal_parse_event: Interface: BT_HAL_MEDIATRANSPORT_INTERFACE");
 152                         g_variant_unref(inner_iter);
 153                         g_variant_unref(child);
 154                         return BT_HAL_MEDIA_TRANSFER_EVENT;
 155                 } else if (g_strcmp0(interface_name,
 156                                         BT_HAL_PLAYER_CONTROL_INTERFACE) == 0) {
 157                         DBG("__bt_hal_parse_event: Interface: BT_HAL_PLAYER_CONTROL_INTERFACE");
 158                         g_variant_unref(inner_iter);
 159                         g_variant_unref(child);
 160                         return BT_HAL_AVRCP_CONTROL_EVENT;
 161                 }
 162                 g_variant_unref(inner_iter);
 163                 g_variant_unref(child);
 164         }
 165
 166         return 0;
 167 }
 168
 169 static int __bt_hal_get_owner_info(GVariant *msg, char **name, char **previous, char **current)
 170 {
 171         g_variant_get(msg, "(&s&s&s)", name, previous, current);
 172         return BT_HAL_ERROR_NONE;
 173 }
 174
 175 int __bt_insert_hal_properties(void *buf, uint8_t type, uint16_t len, const void *val)
 176 {       struct hal_property *prop = buf;
 177
 178         prop->type = type;
 179         prop->len = len;
 180
 181         if (len)
 182                 memcpy(prop->val, val, len);
 183
 184         return sizeof(*prop) + len;
 185 }
 186
 187 handle_stack_msg _bt_hal_get_stack_message_handler(void)
 188 {
 189         return event_cb;
 190 }
 191
 192 static void __bt_hal_adapter_property_changed_event(GVariant *msg)
 193 {
 194         GVariantIter value_iter;
 195         GVariant *value = NULL;
 196         GDBusProxy *adapter_proxy;
 197         GError *err = NULL;
 198         char *key = NULL;
 199         g_variant_iter_init(&value_iter, msg);
 200
 201         /* Buffer and propety count management */
 202         uint8_t buf[BT_HAL_MAX_PROPERTY_BUF_SIZE];
 203         struct hal_ev_adapter_props_changed *ev = (void*) buf;
 204         size_t size = 0;
 205         const gchar *address = NULL;
 206         gchar *name = NULL;
 207         unsigned int cod = 0;
 208         unsigned int a2dp_role = 0;
 209         gboolean discoverable;
 210         gboolean connectable;
 211         unsigned int scan_mode = BT_SCAN_MODE_NONE;
 212         unsigned int disc_timeout;
 213         const gchar *version;
 214         gboolean ipsp_initialized;
 215         gboolean powered;
 216         gboolean pairable;
 217         unsigned int pairable_timeout;
 218         gboolean scan_mode_property_update = FALSE;
 219         gboolean is_discovering;
 220         gboolean is_le_discovering;
 221
 222         memset(buf, 0, sizeof(buf));
 223         size = sizeof(*ev);
 224         ev->num_props = 0;
 225         ev->status = BT_STATUS_SUCCESS;
 226
 227         DBG("+");
 228
 229         while (g_variant_iter_loop(&value_iter, "{sv}", &key, &value)) {
 230                 if (!g_strcmp0(key, "Address")) {
 231                         uint8_t bdaddr[6];
 232
 233                         address = g_variant_get_string(value, NULL);
 234                         DBG("##Address [%s]", address);
 235                         _bt_hal_convert_addr_string_to_type(bdaddr, address);
 236                         size += __bt_insert_hal_properties(buf + size,
 237                                         HAL_PROP_ADAPTER_ADDR, sizeof(bdaddr), bdaddr);
 238                         ev->num_props++;
 239                 } else if (!g_strcmp0(key, "Alias")) {
 240                         g_variant_get(value, "&s", &name);
 241                         DBG("##Alias [%s] ", name);
 242                         size += __bt_insert_hal_properties(buf + size,
 243                                         HAL_PROP_ADAPTER_NAME, strlen(name) + 1, name);
 244                         ev->num_props++;
 245                 } else if (!g_strcmp0(key, "Class")) {
 246                         cod = g_variant_get_uint32(value);
 247                         DBG("##Class [%d]", cod);
 248                         size += __bt_insert_hal_properties(buf + size,
 249                                         HAL_PROP_ADAPTER_CLASS, sizeof(unsigned int), &cod);
 250                         ev->num_props++;
 251                 } else if (!g_strcmp0(key, "Discoverable")) {
 252                         discoverable = g_variant_get_boolean(value);
 253                         DBG("##Discoverable [%d]", discoverable);
 254                         if (discoverable)
 255                                 scan_mode = BT_SCAN_MODE_CONNECTABLE_DISCOVERABLE;
 256                         else
 257                                 scan_mode = BT_SCAN_MODE_CONNECTABLE;
 258                         scan_mode_property_update = TRUE;
 259                 } else if (!g_strcmp0(key, "DiscoverableTimeout")) {
 260                         disc_timeout = g_variant_get_uint32(value);
 261                         DBG("##Discoverable Timeout [%d]", disc_timeout);
 262                         size += __bt_insert_hal_properties(buf + size,
 263                                         HAL_PROP_ADAPTER_DISC_TIMEOUT, sizeof(unsigned int), &disc_timeout);
 264                         ev->num_props++;
 265                 } else if (!g_strcmp0(key, "Connectable")) {
 266                         connectable = g_variant_get_boolean(value);
 267                         DBG("##Connectable [%d]", connectable);
 268                         if (!connectable)
 269                                 scan_mode = BT_SCAN_MODE_NONE;
 270                         else if (scan_mode == BT_SCAN_MODE_NONE)
 271                                 scan_mode = BT_SCAN_MODE_CONNECTABLE;
 272                         scan_mode_property_update = TRUE;
 273                 } else if (!g_strcmp0(key, "Version")) {
 274                         version = g_variant_get_string(value, NULL);
 275                         DBG("##Version [%s]", version);
 276                         size += __bt_insert_hal_properties(buf + size,
 277                                         HAL_PROP_ADAPTER_VERSION, strlen(version) + 1, version);
 278                         ev->num_props++;
 279                 } else if (!g_strcmp0(key, "Name")) {
 280                         g_variant_get(value, "&s", &name);
 281                         DBG("##Name [%s]", name);
 282                         size += __bt_insert_hal_properties(buf + size,
 283                                         HAL_PROP_ADAPTER_NAME, strlen(name) + 1, name);
 284                         ev->num_props++;
 285                 } else if (!g_strcmp0(key, "Powered")) {
 286                         powered = g_variant_get_boolean(value);
 287                         DBG("##Powered = %d", powered);
 288                         /* TODO: Need to check this operation!! */
 289                         if (powered == FALSE) {
 290                                 DBG("###### Adapter Powered Down ######");
 291                                 DBG("Pending disalbed event after bluetoothd is terminated");
 292 #if 0
 293                                 /* We should send the disable event for USB dongle type's target in here. So remain thie code */
 294
 295                                 struct hal_ev_adapter_state_changed ev;
 296                                 ev.state = HAL_POWER_OFF;
 297                                 event_cb(HAL_EV_ADAPTER_STATE_CHANGED, &ev, sizeof(ev));
 298 #ifdef TIZEN_BT_HAL
 299                                 struct hal_ev_le_state_changed le_ev;
 300                                 le_ev.state = HAL_POWER_OFF;
 301                                 event_cb(HAL_EV_LE_STATE_CHANGED, &le_ev, sizeof(le_ev));
 302 #endif
 303                                 /* Destroy Agent */
 304                                 _bt_hal_destroy_adapter_agent();
 305 #endif
 306                         } else {
 307                                 DBG("###### Adapter Powered Up ######");
 308                                 if (_bt_hal_get_adapter_request_state()) {
 309                                         DBG("Sending STATE CHANGE EVENT for Adapter... ");
 310                                         _bt_hal_set_adapter_request_state(FALSE);
 311                                         struct hal_ev_adapter_state_changed ev;
 312                                         ev.state = HAL_POWER_ON;
 313                                         event_cb(HAL_EV_ADAPTER_STATE_CHANGED, &ev, sizeof(ev));
 314                                 }
 315 #ifdef TIZEN_BT_HAL
 316                                 if (_bt_hal_get_le_request_state()) {
 317                                         DBG("Sending STATE CHANGE EVENT for LE... ");
 318                                         _bt_hal_set_le_request_state(FALSE);
 319                                         struct hal_ev_le_state_changed ev;
 320                                         ev.state = HAL_POWER_ON;
 321                                         event_cb(HAL_EV_LE_STATE_CHANGED, &ev, sizeof(ev));
 322                                 }
 323 #endif
 324                                 /* Create Agent */
 325                                 _bt_hal_initialize_adapter_agent();
 326                         }
 327
 328                 } else if (!g_strcmp0(key, "Pairable")) {
 329                         pairable = g_variant_get_boolean(value);
 330                         DBG("##Pairable [%d]", pairable);
 331                 } else if (!g_strcmp0(key, "PairableTimeout")) {
 332                         pairable_timeout = g_variant_get_uint32(value);
 333                         DBG("##Pairable Timeout = %d", pairable_timeout);
 334                 } else if (!g_strcmp0(key, "UUIDs")) {
 335                         char **uuid_value;
 336                         int uuid_count = 0;
 337                         gsize size1 = 0;
 338                         int i = 0;
 339                         size1 = g_variant_get_size(value);
 340                         int num_props_tmp = ev->num_props;
 341                         if (size1 > 0) {
 342                                 uuid_value = (char **)g_variant_get_strv(value, &size1);
 343                                 for (i = 0; uuid_value[i] != NULL; i++)
 344                                         uuid_count++;
 345                                 /* UUID collection */
 346                                 uint8_t uuids[BT_HAL_STACK_UUID_SIZE * uuid_count];
 347                                 for (i = 0; uuid_value[i] != NULL; i++) {
 348                                         char *uuid_str = NULL;
 349                                         uint8_t uuid[BT_HAL_STACK_UUID_SIZE];
 350                                         uuid_str = g_strdup(uuid_value[i]);
 351                                         DBG("##UUID string [%s]\n", uuid_str);
 352                                         _bt_hal_convert_uuid_string_to_type(uuid, uuid_str);
 353                                         memcpy(uuids+i*BT_HAL_STACK_UUID_SIZE, uuid, BT_HAL_STACK_UUID_SIZE);
 354                                         g_free(uuid_str);
 355                                 }
 356                                 size += __bt_insert_hal_properties(buf + size, HAL_PROP_ADAPTER_UUIDS,
 357                                                 (BT_HAL_STACK_UUID_SIZE * uuid_count),
 358                                                 uuids);
 359                                 ev->num_props = num_props_tmp + 1;
 360                                 g_free(uuid_value);
 361                         }
 362                 } else if (!g_strcmp0(key, "Discovering")) {
 363                         is_discovering = g_variant_get_boolean(value);
 364                         DBG("##Discovering = [%d]", is_discovering);
 365
 366                         if (is_discovering == FALSE) {
 367                                 DBG("###### Adapter Has stopped Discovering ######");
 368                                 /* In Tizen Bluez, this actually does not mean Discovery is stopped
 369                                    in Bluez. Tizen Bluez sends this event after a certain timeout,
 370                                    Therefore, we must forecefully call StopDiscovery to stop discovery in BlueZ */
 371                                 if (event_id > 0)
 372                                         continue;
 373
 374                                 adapter_proxy = _bt_hal_get_adapter_proxy();
 375
 376                                 if (adapter_proxy == NULL)
 377                                         continue;
 378
 379                                 /* Need to stop searching */
 380                                 DBG("Event though Bluez reported DIscovering stopped, we force stop Discovery ");
 381                                 g_dbus_proxy_call_sync(adapter_proxy, "StopDiscovery",
 382                                                 NULL,
 383                                                 G_DBUS_CALL_FLAGS_NONE,
 384                                                 DBUS_TIMEOUT, NULL,
 385                                                 &err);
 386                                 if (err) {
 387                                         ERR("Dbus Error : %s", err->message);
 388
 389                                         /* This error is thrown by Bluez, as Discovery is already stopped.
 390                                            Discovery is stopped if user cancels on going discovery.
 391                                            In order to maintain correct state of Bluetooth Discovery state,
 392                                            simply send Discovery stopped event to HAL user */
 393                                         struct hal_ev_discovery_state_changed ev;
 394                                         ev.state = HAL_DISCOVERY_STATE_STOPPED;
 395                                         event_cb(HAL_EV_DISCOVERY_STATE_CHANGED, &ev, sizeof(ev));
 396                                         g_clear_error(&err);
 397                                         continue;
 398
 399                                 } else {
 400                                         event_id = g_timeout_add(BT_HAL_DISCOVERY_FINISHED_DELAY,
 401                                                         (GSourceFunc)__bt_hal_discovery_finished_cb, NULL);
 402                                 }
 403
 404                         } else {
 405                                 DBG("###### Adapter Has started Discovering ######");
 406                                 struct hal_ev_discovery_state_changed ev;
 407                                 ev.state = HAL_DISCOVERY_STATE_STARTED;
 408                                 event_cb(HAL_EV_DISCOVERY_STATE_CHANGED, &ev, sizeof(ev));
 409                         }
 410
 411                 } else if (!g_strcmp0(key, "LEDiscovering")) {
 412                         GVariant *result;
 413
 414                         is_le_discovering = g_variant_get_boolean(value);
 415                         DBG("##LE Discovering = [%d]", is_le_discovering);
 416
 417                         if (is_le_discovering) {
 418                                 /* Send LE discovering started event */
 419                                 size += __bt_insert_hal_properties(buf + size,
 420                                         HAL_PROP_ADAPTER_LE_DISCOVERY_STARTED, 0, NULL);
 421                                 ev->num_props++;
 422                                 continue;
 423                         }
 424
 425                         adapter_proxy = _bt_hal_get_adapter_proxy();
 426                         if (adapter_proxy == NULL) {
 427                                 ERR("adapter_proxy == NULL");
 428                                 continue;
 429                         }
 430
 431                         /* Need to stop searching */
 432                         result = g_dbus_proxy_call_sync(adapter_proxy, "StopLEDiscovery",
 433                                         NULL, G_DBUS_CALL_FLAGS_NONE,
 434                                         DBUS_TIMEOUT, NULL, &err);
 435                         if (!result) {
 436                                 ERR("Error occured in Proxy call");
 437                                 if (err) {
 438                                         ERR("(Error: %s)", err->message);
 439                                         g_clear_error(&err);
 440                                 }
 441                         } else {
 442                                 g_variant_unref(result);
 443                         }
 444
 445                         /* Send LE discovering finished event */
 446                         size += __bt_insert_hal_properties(buf + size,
 447                                 HAL_PROP_ADAPTER_LE_DISCOVERY_STOPPED, 0, NULL);
 448                         ev->num_props++;
 449                 } else if (!g_strcmp0(key, "Modalias")) {
 450                         char *modalias = NULL;
 451                         g_variant_get(value, "s", &modalias);
 452                         DBG("##Adapter ModAlias [%s]", modalias);
 453                 } else if (!g_strcmp0(key, "SupportedLEFeatures")) {
 454                         DBG("##LE Supported features");
 455                         char *name = NULL;
 456                         char *val = NULL;
 457                         GVariantIter *iter = NULL;
 458                         g_variant_get(value, "as", &iter);
 459                         bt_local_le_features_t le_features;
 460                         gboolean le_features_present = FALSE;
 461
 462                         if (iter == NULL)
 463                                 continue;
 464
 465                         memset(&le_features, 0x00, sizeof(le_features));
 466
 467                         while (g_variant_iter_next(iter, "&s", &name) &&
 468                                         g_variant_iter_next(iter, "&s", &val)) {
 469                                 DBG("name = %s, Value = %s", name, val);
 470                                 if (FALSE == _bt_hal_update_le_feature_support(name, val, &le_features))
 471                                         ERR("Failed to update LE feature (name = %s, value = %s)", name, val);
 472                                 else
 473                                         le_features_present = TRUE;
 474                         }
 475
 476                         g_variant_iter_free(iter);
 477                         if (le_features_present) {
 478                                 size += __bt_insert_hal_properties(buf + size,
 479                                                 HAL_PROP_ADAPTER_LOCAL_LE_FEAT, sizeof(le_features), &le_features);
 480                                 ev->num_props++;
 481                         } else {
 482                                 DBG("le supported features values are NOT provided by Stack");
 483                         }
 484                 } else if (!g_strcmp0(key, "IpspInitStateChanged")) {
 485                         g_variant_get(value, "b" , &ipsp_initialized);
 486                         DBG("##IPSP Initialized = %d", ipsp_initialized);
 487                 } else if (!g_strcmp0(key, "A2dpRole")) {
 488                         a2dp_role = g_variant_get_uint32(value);
 489                         DBG("##A2dp Role [%d]", a2dp_role);
 490                         size += __bt_insert_hal_properties(buf + size,
 491                                         HAL_PROP_ADAPTER_A2DP_ROLE, sizeof(unsigned int), &a2dp_role);
 492                         ev->num_props++;
 493                 } else {
 494                         ERR("Unhandled Property:[%s]", key);
 495                 }
 496         }
 497
 498         if (scan_mode_property_update) {
 499                 size += __bt_insert_hal_properties(buf + size,
 500                                 HAL_PROP_ADAPTER_SCAN_MODE, sizeof(int), &scan_mode);
 501                 ev->num_props++;
 502         }
 503
 504
 505         if (size > 2) {
 506                 DBG("Send Adapter properties changed event to HAL user, Num Prop [%d] total size [%zd]", ev->num_props, size);
 507                 event_cb(HAL_EV_ADAPTER_PROPS_CHANGED, buf, size);
 508         }
 509
 510         DBG("-");
 511 }
 512
 513 static void __bt_hal_flight_ps_mode_cb(keynode_t *node, void *data)
 514 {
 515         gboolean flight_mode = FALSE;
 516         int type;
 517         DBG_SECURE("HAL callback hit");
 518         DBG_SECURE("key=%s", vconf_keynode_get_name(node));
 519         type = vconf_keynode_get_type(node);
 520         if (type == VCONF_TYPE_BOOL) {
 521                 flight_mode = vconf_keynode_get_bool(node);
 522                 if (flight_mode != TRUE) {
 523                         ERR("Ignore the event");
 524                         return;
 525                 } else {
 526                         ERR("Flight Mode == TRUE");
 527                 }
 528         } else {
 529                 ERR("Invaild vconf key type : %d", type);
 530                 return;
 531         }
 532         DBG("Enabling core now");
 533         _bt_hal_enable_core();
 534 }
 535
 536 static void _bt_hal_register_vconf_handler(void)
 537 {
 538         DBG("+");
 539
 540         if (vconf_notify_key_changed(VCONFKEY_TELEPHONY_FLIGHT_MODE,
 541                 (vconf_callback_fn)__bt_hal_flight_ps_mode_cb, NULL) < 0)
 542                         ERR("Unable to register key handler");
 543         DBG("Telephony is disabled");
 544         if (vconf_notify_key_changed(VCONFKEY_SETAPPL_PSMODE,
 545                 (vconf_callback_fn)__bt_hal_flight_ps_mode_cb, NULL) < 0)
 546                         ERR("Unable to register key handler");
 547 }
 548
 549 void _bt_hal_handle_adapter_event(GVariant *msg, const char *member)
 550 {
 551         DBG("+");
 552
 553         if (member == NULL)
 554                 return;
 555
 556         if (strcasecmp(member, "DeviceCreated") == 0) {
 557                 DBG("DeviceCreated: Unhandled");
 558         } else if (strcasecmp(member, "AdvertisingEnabled") == 0) {
 559                 DBG("AdvertisingEnabled");
 560                 DBG("Advertising Enabled");
 561                 int slot_id;
 562                 gboolean status = FALSE;
 563                 g_variant_get(msg, "(ib)", &slot_id, &status);
 564                 DBG("Advertising Enabled : server_slot_id [%d]  status [%d]", slot_id, status);
 565                 /* Send event to application */
 566                 _bt_hal_set_advertising_status(slot_id, status);
 567         } else if (strcasecmp(member, "RssiEnabled") == 0) {
 568                 struct hal_ev_rssi_monitor_state_changed ev;
 569                 gboolean status = FALSE;
 570                 char *address = NULL;
 571                 int link_type;
 572
 573                 g_variant_get(msg, "(sib)", &address, &link_type, &status);
 574                 DBG("RSSI monitoring %s for %s",
 575                                 (status ? "Enabled" : "Disabled"), address);
 576
 577                 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
 578                 ev.link_type = link_type;
 579                 ev.state = (status ? HAL_RSSI_MONITORING_ENABLED : HAL_RSSI_MONITORING_DISABLED);
 580                 if (!event_cb)
 581                         ERR("event_cb is NULL");
 582                 else
 583                         event_cb(HAL_EV_RSSI_MONITOR_STATE_CHANGED, &ev, sizeof(ev));
 584
 585                 g_free(address);
 586         } else if (strcasecmp(member, "RssiAlert") == 0) {
 587                 struct hal_ev_rssi_alert_recieved ev;
 588                 int alert_type;
 589                 int rssi_dbm;
 590                 int link_type;
 591                 char *address = NULL;
 592
 593                 g_variant_get(msg, "(siii)", &address, &link_type, &alert_type, &rssi_dbm);
 594                 DBG("RSSI Alert: [Address %s LinkType %d] [Type %d DBM %d]",
 595                                 address, alert_type, rssi_dbm, link_type);
 596
 597                 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
 598                 ev.link_type = link_type;
 599                 ev.alert_type = alert_type;
 600                 ev.rssi = rssi_dbm;
 601
 602                 if (!event_cb)
 603                         ERR("event_cb is NULL");
 604                 else
 605                         event_cb(HAL_EV_RSSI_ALERT_RECIEVED, &ev, sizeof(ev));
 606
 607                 g_free(address);
 608         } else if (strcasecmp(member, "RawRssi") == 0) {
 609                 struct hal_ev_raw_rssi_recieved ev;
 610                 int rssi_dbm;
 611                 int link_type;
 612                 char *address = NULL;
 613
 614                 g_variant_get(msg, "(sii)", &address, &link_type, &rssi_dbm);
 615                 DBG("Raw RSSI: [Address %s] [Link Type %d][RSSI DBM %d]",
 616                                 address, link_type, rssi_dbm);
 617
 618                 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
 619                 ev.link_type = link_type;
 620                 ev.rssi = rssi_dbm;
 621
 622                 if (!event_cb)
 623                         ERR("event_cb is NULL");
 624                 else
 625                         event_cb(HAL_EV_RAW_RSSI_RECIEVED, &ev, sizeof(ev));
 626
 627                 g_free(address);
 628         } else if (strcasecmp(member, BT_HAL_HARDWARE_ERROR) == 0) {
 629                 DBG("BT Hardware Error: Unhandled");
 630         } else if (strcasecmp(member, BT_HAL_TX_TIMEOUT_ERROR) == 0) {
 631                 DBG("BT TX Timeout Error: Unhandled");
 632         } else if (strcasecmp(member, BT_HAL_DBFW_PLUS_INFO) == 0) {
 633 #ifdef TIZEN_BT_HAL
 634                 DBG("### DBFW+ info received from BLUEZ");
 635                 struct hal_ev_dbfw_plus_info_recieved info;
 636                 int length;
 637                 char event_code;
 638                 unsigned char *buffer = NULL;
 639                 GVariant *value = NULL;
 640
 641                 g_variant_get(msg, "(y@ay)", &event_code, &value);
 642                 if (value == NULL) {
 643                         ERR("g_variant_get fails");
 644                 } else {
 645                         length = g_variant_get_size(value);
 646                         if (length <= 0) {
 647                                 ERR("Invalid g_variant len = %d", length);
 648                         } else {
 649                                 info.event_code = event_code;
 650                                 buffer = (unsigned char*)g_variant_get_data(value);
 651                                 info.data = g_memdup(buffer, length);
 652                                 info.data_len = length;
 653                                 if (!event_cb)
 654                                         ERR("event_cb is NULL");
 655                                 else
 656                                         event_cb(HAL_EV_DBFW_PLUS_INFO_RECIEVED, &info, sizeof(info));
 657                                 g_free(info.data);
 658                         }
 659                 }
 660 #endif
 661         }
 662
 663         DBG("-");
 664 }
 665
 666 static gboolean __bt_hal_parse_device_properties(GVariant *item)
 667 {
 668         GVariantIter iter;
 669         gchar *key;
 670         GVariant *val;
 671         gsize len = 0;
 672         gboolean is_bredr_dev = FALSE;
 673
 674         if (!item)
 675                 return FALSE;
 676         DBG("+");
 677
 678         /* Buffer and propety count management */
 679         uint8_t buf[BT_HAL_MAX_PROPERTY_BUF_SIZE];
 680         struct hal_ev_device_found *ev = (void *) buf;
 681         size_t size = 0;
 682         memset(buf, 0, sizeof(buf));
 683         size = sizeof(*ev);
 684         ev->num_props = 0;
 685
 686         g_variant_iter_init(&iter, item);
 687         while (g_variant_iter_loop(&iter, "{sv}", &key, &val)) {
 688
 689                 if (strcasecmp(key, "Address") == 0)  {
 690                         char * address = NULL;
 691                         address = g_variant_dup_string(val, &len);
 692                         uint8_t bdaddr[6];
 693                         _bt_hal_convert_addr_string_to_type(bdaddr, address);
 694
 695                         size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_ADDR,
 696                                         sizeof(bdaddr), bdaddr);
 697
 698                         ev->num_props++;
 699                         DBG("Device address [%s] property Num [%d]", address, ev->num_props);
 700                         g_free(address);
 701                 } else if (strcasecmp(key, "AddressType") == 0) {
 702                         char *addresstype = g_variant_dup_string(val, &len);
 703                         if (addresstype)
 704                                 DBG("AddressType [%s]", addresstype);
 705                         g_free(addresstype);
 706                 } else if (strcasecmp(key, "Class") == 0) {
 707                         unsigned int class = g_variant_get_uint32(val);
 708                         size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_CLASS,
 709                                         sizeof(unsigned int), &class);
 710                         ev->num_props++;
 711                         DBG("Device class [%d] Property num [%d]", class, ev->num_props);
 712                         is_bredr_dev = TRUE;
 713                 } else if (strcasecmp(key, "name") == 0) {
 714                         char *name = g_variant_dup_string(val, &len);
 715                         if (name) {
 716                                 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_NAME,
 717                                                 strlen(name) + 1, name);
 718                                 ev->num_props++;
 719                                 DBG("Device Name [%s] Property num [%d]", name, ev->num_props);
 720                         }
 721                         g_free(name);
 722                 } else if (strcasecmp(key, "Connected") == 0) {
 723                         unsigned int connected = g_variant_get_byte(val);
 724
 725                         size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_CONNECTED,
 726                                         sizeof(unsigned int), &connected);
 727                         ev->num_props++;
 728                         DBG("Device connected [%u] Property num [%d]", connected,  ev->num_props);
 729                 } else if (strcasecmp(key, "paired") == 0) {
 730                         uint8_t paired = (g_variant_get_boolean(val) ? 1 : 0);
 731                         size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_PAIRED,
 732                                         sizeof(uint8_t), &paired);
 733                         ev->num_props++;
 734                         DBG("Device Paired [%d] Property num [%d]", paired, ev->num_props);
 735                 } else if (strcasecmp(key, "Trusted") == 0) {
 736                         uint8_t trust = (g_variant_get_boolean(val) ? 1 : 0);
 737                         size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_TRUSTED,
 738                                         sizeof(uint8_t), &trust);
 739                         ev->num_props++;
 740                         DBG("Device trusted [%d] Property num [%d]", trust, ev->num_props);
 741                 } else if (strcasecmp(key, "RSSI") == 0) {
 742                         int rssi = g_variant_get_int16(val);
 743                         size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_RSSI,
 744                                         sizeof(int), &rssi);
 745                         ev->num_props++;
 746                         DBG("Device RSSI [%d] Property num [%d]", rssi, ev->num_props);
 747                 } else if (strcasecmp(key, "LastAddrType") == 0) {
 748                         /* TODO: To be handled later*/
 749                 } else if (!g_strcmp0(key, "IsAliasSet")) {
 750                         uint8_t is_alias_set = (g_variant_get_boolean(val) ? 1 : 0);
 751                         DBG("IsAliasSet: %s", (is_alias_set ? "TRUE" : "FALSE"));
 752                         size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_IS_ALIAS_SET,
 753                                         sizeof(uint8_t), &is_alias_set);
 754                         ev->num_props++;
 755                 } else if (strcasecmp(key, "UUIDs") == 0) {
 756                         char **uuid_value;
 757                         int uuid_count = 0;
 758                         gsize size1 = 0;
 759                         int i = 0;
 760                         size1 = g_variant_get_size(val);
 761                         DBG("UUID count from size  [%zu]\n", size1);
 762                         int num_props_tmp = ev->num_props;
 763
 764                         if (size1 > 0) {
 765                                 uuid_value = (char **)g_variant_get_strv(val, &size1);
 766                                 for (i = 0; uuid_value[i] != NULL; i++)
 767                                         uuid_count++;
 768                                 DBG("UUID count [%d]\n", uuid_count);
 769                                 /* UUID collection */
 770                                 uint8_t uuids[BT_HAL_STACK_UUID_SIZE * uuid_count];
 771
 772                                 for (i = 0; uuid_value[i] != NULL; i++) {
 773
 774                                         char *uuid_str = NULL;
 775                                         uint8_t uuid[BT_HAL_STACK_UUID_SIZE];
 776                                         memset(uuid, 0x00, BT_HAL_STACK_UUID_SIZE);
 777
 778                                         DBG("UUID string from Bluez [%s]\n", uuid_value[i]);
 779                                         uuid_str = g_strdup(uuid_value[i]);
 780                                         DBG("UUID string [%s]\n", uuid_str);
 781                                         _bt_hal_convert_uuid_string_to_type(uuid, uuid_str);
 782                                         memcpy(uuids+i*BT_HAL_STACK_UUID_SIZE, uuid, BT_HAL_STACK_UUID_SIZE);
 783                                         g_free(uuid_str);
 784                                 }
 785
 786                                 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_UUIDS,
 787                                                 (BT_HAL_STACK_UUID_SIZE * uuid_count),
 788                                                 uuids);
 789                                 ev->num_props = num_props_tmp + 1;
 790                                 g_free(uuid_value);
 791                         }
 792
 793                 } else if (strcasecmp(key, "LegacyManufacturerDataLen") == 0) {
 794                         /* TODO: To be handled later*/
 795                 } else if (strcasecmp(key, "LegacyManufacturerData") == 0) {
 796                         /* TODO: To be handled later*/
 797                 } else {
 798                         ERR("Unhandled Property:[%s]", key);
 799                 }
 800         }
 801         DBG("-");
 802
 803         if (size > 1 && is_bredr_dev) {
 804                 DBG("Send Device found event to HAL user, Num Prop [%d] total size [%zd]", ev->num_props, size);
 805                 event_cb(HAL_EV_DEVICE_FOUND, (void*) buf, size);
 806         }
 807
 808         return TRUE;
 809 }
 810
 811 static void __bt_hal_handle_avrcp_tg_events(GVariant *msg, const char *path)
 812 {
 813         int state;
 814         GVariantIter value_iter;
 815         char *property = NULL;
 816         char *address;
 817         GVariant *val = NULL;
 818         GVariant *child = NULL;
 819
 820         g_variant_iter_init(&value_iter, msg);
 821         while ((child = g_variant_iter_next_value(&value_iter))) {
 822                 g_variant_get(child, "{sv}", &property, &val);
 823                 INFO("Property %s", property);
 824                 if (strcasecmp(property, "Connected") == 0) {
 825                         struct hal_ev_avrcp_tg_conn_state ev;
 826
 827                         gboolean connected = FALSE;
 828
 829                         g_variant_get(val, "b", &connected);
 830
 831                         state = connected ? HAL_AVRCP_TG_STATE_CONNECTED :
 832                                 HAL_AVRCP_TG_STATE_DISCONNECTED;
 833
 834                         address = g_malloc0(BT_HAL_ADDRESS_STRING_SIZE);
 835
 836                         _bt_hal_convert_device_path_to_address(path, address);
 837
 838                         DBG("connected: %d", connected);
 839                         DBG("address: %s", address);
 840
 841                         /* Prepare to send AVRCP Target connection state event */
 842                         memset(&ev, 0, sizeof(ev));
 843                         _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
 844                         ev.state = state;
 845                         if (!avrcp_tg_event_cb)
 846                                 ERR("AVRCP target DBUS handler callback not registered");
 847                         else
 848                                 avrcp_tg_event_cb(HAL_EV_AVRCP_TG_CONN_STATE, (void *)&ev, sizeof(ev));
 849                         g_free(address);
 850                 }
 851                 g_free(property);
 852                 g_variant_unref(child);
 853                 g_variant_unref(val);
 854         }
 855
 856         DBG("-");
 857 }
 858
 859 static void __bt_hal_handle_property_changed_event(GVariant *msg, const char *object_path)
 860 {
 861         char *interface_name = NULL;
 862         GVariant *val = NULL;
 863
 864         g_variant_get(msg, "(&s@a{sv}@as)", &interface_name, &val, NULL);
 865
 866         if (!interface_name) {
 867                 DBG("Failed to get interface name");
 868
 869                 if (val)
 870                         g_variant_unref(val);
 871                 return;
 872         }
 873
 874         if (strcasecmp(interface_name, BT_HAL_ADAPTER_INTERFACE) == 0) {
 875                 DBG("Event: Property Changed: Interface: BT_HAL_ADAPTER_INTERFACE");
 876                 __bt_hal_adapter_property_changed_event(val);
 877         } else if (strcasecmp(interface_name, BT_HAL_DEVICE_INTERFACE) == 0) {
 878                 DBG("Event: Property Changed: Interface: BT_HAL_DEVICE_INTERFACE");
 879                 __bt_hal_device_property_changed_event(val, object_path);
 880         } else if (strcasecmp(interface_name, BT_HAL_OBEX_TRANSFER_INTERFACE) == 0) {
 881                 DBG("Event: Property Changed: Interface: BT_HAL_OBEX_TRANSFER_INTERFACE");
 882                 /* TODO: Handle event */
 883         } else if (strcasecmp(interface_name, BT_HAL_MEDIA_CONTROL_INTERFACE) == 0) {
 884                 DBG("Event: Property Changed: Interface: BT_HAL_MEDIA_CONTROL_INTERFACE");
 885                 /* Handle AVRCP target event */
 886                 __bt_hal_handle_avrcp_tg_events(val, object_path);
 887         } else if (strcasecmp(interface_name, BT_HAL_PLAYER_CONTROL_INTERFACE) == 0) {
 888                 DBG("Event: Property Changed: Interface: BT_HAL_PLAYER_CONTROL_INTERFACE");
 889                 __bt_hal_handle_avrcp_ctrl_events(val, NULL, object_path);
 890         } else if (strcasecmp(interface_name, BT_HAL_MEDIATRANSPORT_INTERFACE) == 0) {
 891                 DBG("Event: Property Changed: Interface: BT_HAL_MEDIATRANSPORT_INTERFACE");
 892                 __bt_hal_handle_avrcp_transport_events(val, NULL, object_path);
 893         } else if (strcasecmp(interface_name, BT_HAL_NETWORK_CLIENT_INTERFACE) == 0) {
 894                 DBG("Event: Property Changed: Interface: BT_HAL_NETWORK_CLIENT_INTERFACE");
 895                 /* TODO: Handle event */
 896         } else if (strcasecmp(interface_name, BT_HAL_GATT_CHAR_INTERFACE) == 0) {
 897                 DBG("Event: Property Changed: Interface: BT_HAL_GATT_CHAR_INTERFACE");
 898                 /* TODO: Handle event */
 899         } else if (strcasecmp(interface_name, BT_HAL_INPUT_INTERFACE) == 0) {
 900                 DBG("Event: Property Changed: Interface: BT_HAL_INPUT_INTERFACE");
 901                 __bt_hal_handle_input_event(val, object_path);
 902         }
 903         g_variant_unref(val);
 904 }
 905
 906 static void __bt_hal_handle_device_event(GVariant *value, GVariant *parameters)
 907 {
 908         DBG("+");
 909
 910         if (__bt_hal_parse_interface(parameters) == FALSE) {
 911                 ERR("Fail to parse the properies");
 912                 g_variant_unref(value);
 913                 return;
 914         }
 915
 916         DBG("-");
 917 }
 918
 919 static void __bt_hal_send_hid_connection_state_event(
 920                 gboolean connected, const char *address)
 921 {
 922         struct hal_ev_hidhost_conn_state ev;
 923
 924         ev.state = (connected == TRUE) ?
 925                 HAL_HIDHOST_STATE_CONNECTED :
 926                 HAL_HIDHOST_STATE_DISCONNECTED;
 927
 928         _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
 929
 930         if (!hid_event_cb)
 931                 ERR("HID event handler not registered");
 932         else
 933                 hid_event_cb(HAL_EV_HIDHOST_CONN_STATE, &ev, sizeof(ev));
 934 }
 935
 936 static void __bt_hal_send_hid_device_connection_state_event(
 937                 gboolean connected, const char *address)
 938 {
 939         struct hal_ev_hiddevice_conn_state ev;
 940
 941         ev.state = (connected == TRUE) ?
 942                 HAL_HIDDEVICE_STATE_CONNECTED :
 943                 HAL_HIDDEVICE_STATE_DISCONNECTED;
 944
 945         _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
 946
 947         if (!hid_device_event_cb)
 948                 ERR("HID device event handler not registered");
 949         else
 950                 hid_device_event_cb(HAL_EV_HIDDEVICE_CONN_STATE, &ev, sizeof(ev));
 951 }
 952
 953 static void __bt_hal_handle_input_event(GVariant *msg, const char *path)
 954 {
 955         gboolean property_flag = FALSE;
 956         GVariantIter value_iter;
 957         char *property = NULL;
 958         GVariant *child = NULL, *val = NULL;
 959
 960         DBG("+");
 961         g_variant_iter_init(&value_iter, msg);
 962         while ((child = g_variant_iter_next_value(&value_iter))) {
 963                 g_variant_get(child, "{sv}", &property, &val);
 964
 965                 if (property == NULL)
 966                         return;
 967
 968                 if (strcasecmp(property, "Connected") == 0) {
 969                         char *address;
 970
 971                         g_variant_get(val, "b", &property_flag);
 972                         address = g_malloc0(BT_HAL_ADDRESS_STRING_SIZE);
 973                         _bt_hal_convert_device_path_to_address(path, address);
 974                         __bt_hal_send_hid_connection_state_event(property_flag, address);
 975                         g_free(address);
 976                 }
 977                 g_free(property);
 978                 g_variant_unref(val);
 979                 g_variant_unref(child);
 980         }
 981
 982         DBG("-");
 983 }
 984
 985 static gboolean __bt_hal_parse_interface(GVariant *msg)
 986 {
 987         char *path = NULL;
 988         GVariant *optional_param;
 989         GVariantIter iter;
 990         GVariant *child;
 991         char *interface_name = NULL;
 992         GVariant *inner_iter = NULL;
 993         g_variant_get(msg, "(&o@a{sa{sv}})",
 994                         &path, &optional_param);
 995         g_variant_iter_init(&iter, optional_param);
 996
 997         while ((child = g_variant_iter_next_value(&iter))) {
 998                 g_variant_get(child, "{&s@a{sv}}", &interface_name, &inner_iter);
 999                 if (g_strcmp0(interface_name, BT_HAL_DEVICE_INTERFACE) == 0) {
1000                         DBG("Found a device: %s", path);
1001                         if (__bt_hal_parse_device_properties(inner_iter) == FALSE) {
1002                                 g_variant_unref(inner_iter);
1003                                 g_variant_unref(child);
1004                                 g_variant_unref(optional_param);
1005                                 ERR("Fail to parse the properies");
1006                                 return FALSE;
1007                         } else {
1008                                 g_variant_unref(inner_iter);
1009                                 g_variant_unref(child);
1010                                 g_variant_unref(optional_param);
1011                                 return TRUE;
1012                         }
1013                 }
1014                 g_variant_unref(inner_iter);
1015                 g_variant_unref(child);
1016         }
1017
1018         g_variant_unref(optional_param);
1019
1020         return FALSE;
1021 }
1022
1023 void __bt_hal_handle_gatt_char_event(GVariant *parameters, const char *signal_name)
1024 {
1025         DBG("+");
1026
1027         if (signal_name == NULL)
1028                 return;
1029
1030         if (strcasecmp(signal_name, "GattValueChanged") == 0) {
1031                 DBG("GattValueChanged event received");
1032
1033                 int result = 0;
1034                 const char *char_handle = NULL;
1035                 GVariant *char_value_var = NULL;
1036                 int len = 0;
1037                 char *char_value = NULL;
1038
1039                 g_variant_get(parameters, "(i&s@ay)", &result, &char_handle, &char_value_var);
1040                 DBG("char handle: %s", char_handle);
1041
1042                 len = g_variant_get_size(char_value_var);
1043                 if (len > 0)
1044                         char_value = (char *)g_variant_get_data(char_value_var);
1045
1046                 _bt_hal_handle_gattc_value_changed_event(result, char_handle, char_value, len);
1047
1048                 g_variant_unref(char_value_var);
1049         }
1050 }
1051
1052 static void __bt_hal_handle_gatt_service_event(GVariant *parameters, const char *signal_name)
1053 {
1054         if (signal_name == NULL)
1055                 return;
1056
1057         if (strcasecmp(signal_name, "GattServiceAdded") == 0) {
1058                 char *path = NULL;
1059                 g_variant_get(parameters, "(&s)", &path);
1060                 _bt_hal_handle_gattc_service_changed_event(TRUE, path);
1061         }
1062 }
1063
1064 static gboolean __bt_hal_event_manager(gpointer data)
1065 {
1066         bt_hal_event_type_t bt_event = 0x00;
1067         GVariant *value;
1068         char *obj_path = NULL;
1069
1070         bt_hal_main_event_data_t *param = (bt_hal_main_event_data_t*)data;
1071         if (strcasecmp(param->signal_name, "InterfacesAdded") == 0) {
1072
1073                 /*TODO: Handle Interfaces Added Signal from stack */
1074
1075                 g_variant_get(param->parameters, "(&o@a{sa{sv}})", &obj_path, &value);
1076
1077                 if (obj_path == NULL) {
1078                         ERR("obj_path is NULL");
1079                         return FALSE;
1080                 }
1081
1082                 if (strcasecmp(obj_path, BT_HAL_BLUEZ_HCI_PATH) == 0) {
1083                         /* TODO: Handle adapter added */
1084                         DBG("Manager Event: Signal Name: InterfiacesAdded: Adapter added in bluetoothd: path [hci0]");
1085                 } else {
1086                         bt_event = __bt_hal_parse_event(value);
1087                         if (bt_event == BT_HAL_DEVICE_EVENT) {
1088                                 __bt_hal_handle_device_event(value, param->parameters);
1089                         } else if (bt_event == BT_HAL_AVRCP_CONTROL_EVENT) {
1090                                 _bt_hal_set_control_device_path(obj_path);
1091                         }
1092                 }
1093                 g_variant_unref(value);
1094
1095         } else if (strcasecmp(param->signal_name, "InterfacesRemoved") == 0) {
1096                 char *str;
1097                 GVariantIter *iter;
1098
1099                 /*TODO: Handle Interfaces Removed Signal from stack */
1100
1101                 g_variant_get(param->parameters, "(&oas)", &obj_path, &iter);
1102
1103                 while (g_variant_iter_loop(iter, "s", &str)) {
1104                         if (g_strcmp0(str, BT_HAL_PLAYER_CONTROL_INTERFACE) == 0)
1105                                 _bt_hal_remove_control_device_path(obj_path);
1106                         else if (g_strcmp0(str, BT_HAL_GATT_SERVICE_INTERFACE) == 0)
1107                                 _bt_hal_handle_gattc_service_changed_event(FALSE, obj_path);
1108                 }
1109                 g_variant_iter_free(iter);
1110         } else if (strcasecmp(param->signal_name, "NameOwnerChanged") == 0) {
1111                 char *name = NULL;
1112                 char *previous = NULL;
1113                 char *current = NULL;
1114
1115                 if (g_strcmp0(g_variant_get_type_string(param->parameters), "(sss)") != 0) {
1116                         ERR("Invalid variant format");
1117                         return FALSE;
1118                 }
1119
1120                 /* TODO: Handle Name Owener changed Signal */
1121                 if (__bt_hal_get_owner_info(param->parameters, &name, &previous, &current)) {
1122                         ERR("Fail to get the owner info");
1123                         return FALSE;
1124                 }
1125
1126                 if (*current != '\0')
1127                         return FALSE;
1128
1129                 if (name == NULL)
1130                         return FALSE;
1131
1132                 if (strcasecmp(name, BT_HAL_BLUEZ_NAME) == 0) {
1133                         struct hal_ev_adapter_state_changed ev;
1134                         struct hal_ev_le_state_changed le_ev;
1135
1136                         INFO("Bluetoothd is terminated");
1137
1138                         /* Send the disable event in here */
1139
1140                         ev.state = HAL_POWER_OFF;
1141                         le_ev.state = HAL_POWER_OFF;
1142
1143                         event_cb(HAL_EV_ADAPTER_STATE_CHANGED, &ev, sizeof(ev));
1144                         event_cb(HAL_EV_LE_STATE_CHANGED, &le_ev, sizeof(le_ev));
1145
1146                         /* Destroy Agent */
1147                         _bt_hal_destroy_adapter_agent();
1148                         _bt_hal_le_deinit();
1149                 }
1150         } else if (g_strcmp0(param->interface_name, BT_HAL_PROPERTIES_INTERFACE) == 0) {
1151                 __bt_hal_handle_property_changed_event(param->parameters, param->object_path);
1152         } else if (g_strcmp0(param->interface_name, BT_HAL_ADAPTER_INTERFACE) == 0) {
1153                 _bt_hal_handle_adapter_event(param->parameters, param->signal_name);
1154         } else if (g_strcmp0(param->interface_name, BT_HAL_INPUT_INTERFACE) == 0) {
1155                 __bt_hal_handle_input_event(param->parameters, param->object_path);
1156         } else if (g_strcmp0(param->interface_name, BT_HAL_NETWORK_SERVER_INTERFACE) == 0) {
1157                 /* TODO: Handle Network Server events from stack */
1158                 DBG("Manager Event: Interface Name: BT_HAL_NETWORK_SERVER_INTERFACE");
1159         } else if (g_strcmp0(param->interface_name, BT_HAL_HEADSET_INTERFACE) == 0) {
1160                 __bt_hal_handle_headset_events(param->parameters, param->signal_name, param->object_path);
1161         } else if (g_strcmp0(param->interface_name, BT_HAL_SINK_INTERFACE) == 0) {
1162                 /* TODO: Handle Sink interface events from stack */
1163                 DBG("Manager Event: Interface Name:BT_HAL_SINK_INTERFACE");
1164         } else if (g_strcmp0(param->interface_name, BT_HAL_AGENT_INTERFACE) == 0) {
1165                 /* TODO: Handle Agent events from stack */
1166                 DBG("Manager Event: Interface Name:BT_HAL_AGENT_INTERFACE");
1167         } else if (g_strcmp0(param->interface_name, BT_HAL_DEVICE_INTERFACE) == 0) {
1168                 __bt_hal_handle_device_specific_events(param->parameters, param->signal_name, param->object_path);
1169         } else if (g_strcmp0(param->interface_name, BT_HAL_PLAYER_CONTROL_INTERFACE) == 0) {
1170                 __bt_hal_handle_avrcp_ctrl_events(param->parameters, param->signal_name, param->object_path);
1171         } else if (g_strcmp0(param->interface_name, BT_HAL_MEDIATRANSPORT_INTERFACE) == 0) {
1172                 __bt_hal_handle_avrcp_transport_events(param->parameters, param->signal_name, param->object_path);
1173         } else if (g_strcmp0(param->interface_name, BT_HAL_GATT_CHAR_INTERFACE) == 0) {
1174                 __bt_hal_handle_gatt_char_event(param->parameters, param->signal_name);
1175         } else if (g_strcmp0(param->interface_name, BT_HAL_GATT_SERVICE_INTERFACE) == 0) {
1176                 DBG("Manager Event: Interface Name: BT_HAL_GATT_SERVICE_INTERFACE");
1177                 __bt_hal_handle_gatt_service_event(param->parameters, param->signal_name);
1178         }
1179
1180         /* Free data */
1181         g_free(param->sender_name);
1182         g_free(param->object_path);
1183         g_free(param->interface_name);
1184         g_free(param->signal_name);
1185         g_variant_unref(param->parameters);
1186
1187         return FALSE;
1188 }
1189
1190 static  void __bt_hal_manager_event_filter(GDBusConnection *connection,
1191                 const gchar *sender_name,
1192                 const gchar *object_path,
1193                 const gchar *interface_name,
1194                 const gchar *signal_name,
1195                 GVariant *parameters,
1196                 gpointer user_data)
1197 {
1198         if (signal_name == NULL)
1199                 return;
1200
1201         bt_hal_main_event_data_t *param = g_new0(bt_hal_main_event_data_t, 1);
1202         param->sender_name = g_strdup(sender_name);
1203         param->object_path = g_strdup(object_path);
1204         param->interface_name = g_strdup(interface_name);
1205         param->signal_name = g_strdup(signal_name);
1206         param->parameters = g_variant_ref(parameters);
1207
1208         g_idle_add(__bt_hal_event_manager, (gpointer)param);
1209         return;
1210 }
1211
1212 static void __bt_hal_handle_headset_events(GVariant *msg, const char *member, const char *path)
1213 {
1214         gboolean property_flag = FALSE;
1215         char *property = NULL;
1216         GVariant *value = NULL;
1217         g_variant_get(msg, "(sv)", &property, &value);
1218
1219         if (property == NULL)
1220                 return;
1221
1222         DBG("Property = %s \n", property);
1223         /* We allow only 1 headset connection (HSP or HFP)*/
1224         if (strcasecmp(property, "Connected") == 0) {
1225                 char *address;
1226                 g_variant_get(value, "b", &property_flag);
1227
1228                 address = g_malloc0(BT_HAL_ADDRESS_STRING_SIZE);
1229
1230                 /* Fix : NULL_RETURNS */
1231                 if (address == NULL)
1232                         return;
1233
1234                 _bt_hal_convert_device_path_to_address(path, address);
1235                 __bt_hal_send_hf_audio_connection_state_event(property_flag, address);
1236                 g_free(address);
1237         } else if (strcasecmp(property, "State") == 0) {
1238                 char *state = NULL;
1239
1240                 g_variant_get(value, "s", &state);
1241
1242                 /* This code assumes we support only 1 headset connection */
1243                 /* Need to use the headset list, if we support multi-headsets */
1244                 if (strcasecmp(state, "Playing") == 0) {
1245                         DBG("Playing: Sco Connected");
1246                 } else if (strcasecmp(state, "connected") == 0 ||
1247                                 strcasecmp(state, "disconnected") == 0) {
1248                         if (strcasecmp(state, "connected") == 0)
1249                                 DBG("Sco Connected");
1250                         else
1251                                 DBG("Sco Disconnected");
1252                 } else {
1253                         ERR("Not handled state - %s", state);
1254                         g_free(state);
1255                         return;
1256                 }
1257                 g_free(state);
1258         } else if (strcasecmp(property, "SpeakerGain") == 0) {
1259                 char *address;
1260
1261                 address = g_malloc0(BT_HAL_ADDRESS_STRING_SIZE);
1262
1263                 _bt_hal_convert_device_path_to_address(path, address);
1264                 INFO("Speaker Gain for address [%s]", address);
1265                 /* TODO Handle event sending to HAL */
1266
1267                 g_free(address);
1268         } else if (strcasecmp(property, "MicrophoneGain") == 0) {
1269                 char *address;
1270
1271                 address = g_malloc0(BT_HAL_ADDRESS_STRING_SIZE);
1272
1273                 _bt_hal_convert_device_path_to_address(path, address);
1274                 INFO("Microphone Gain for address [%s]", address);
1275                 /* TODO Handle event sending to HAL */
1276
1277                 g_free(address);
1278         }
1279
1280         if (property)
1281                 g_free(property);
1282         g_variant_unref(value);
1283 }
1284
1285 static int __bt_hal_register_manager_subscribe_signal(GDBusConnection *conn,
1286                 int subscribe)
1287 {
1288         if (conn == NULL)
1289                 return -1;
1290
1291         static int subs_interface_added_id = -1;
1292         static int subs_interface_removed_id = -1;
1293         static int subs_name_owner_id = -1;
1294         static int subs_property_id = -1;
1295         static int subs_adapter_id = -1;
1296
1297         INFO_C("+");
1298
1299         if (subscribe) {
1300                 if (subs_interface_added_id == -1) {
1301                         subs_interface_added_id = g_dbus_connection_signal_subscribe(conn,
1302                                         NULL, BT_HAL_MANAGER_INTERFACE,
1303                                         BT_HAL_INTERFACES_ADDED, NULL, NULL, 0,
1304                                         __bt_hal_manager_event_filter,
1305                                         NULL, NULL);
1306                 }
1307                 if (subs_interface_removed_id == -1) {
1308                         subs_interface_removed_id = g_dbus_connection_signal_subscribe(conn,
1309                                         NULL, BT_HAL_MANAGER_INTERFACE,
1310                                         BT_HAL_INTERFACES_REMOVED, NULL, NULL, 0,
1311                                         __bt_hal_manager_event_filter,
1312                                         NULL, NULL);
1313                 }
1314                 if (subs_name_owner_id == -1) {
1315                         subs_name_owner_id = g_dbus_connection_signal_subscribe(conn,
1316                                         NULL, BT_HAL_FREEDESKTOP_INTERFACE,
1317                                         BT_HAL_NAME_OWNER_CHANGED, NULL, NULL, 0,
1318                                         __bt_hal_manager_event_filter,
1319                                         NULL, NULL);
1320                 }
1321                 if (subs_property_id == -1) {
1322                         subs_property_id = g_dbus_connection_signal_subscribe(conn,
1323                                         NULL, BT_HAL_PROPERTIES_INTERFACE,
1324                                         BT_HAL_PROPERTIES_CHANGED, NULL, NULL, 0,
1325                                         __bt_hal_manager_event_filter,
1326                                         NULL, NULL);
1327                 }
1328                 if (subs_adapter_id == -1) {
1329                         subs_adapter_id = g_dbus_connection_signal_subscribe(conn,
1330                                         NULL, BT_HAL_ADAPTER_INTERFACE,
1331                                         NULL, NULL, NULL, 0,
1332                                         __bt_hal_manager_event_filter,
1333                                         NULL, NULL);
1334                 }
1335         } else {
1336                 if (subs_interface_added_id != -1) {
1337                         g_dbus_connection_signal_unsubscribe(conn,
1338                                         subs_interface_added_id);
1339                         subs_interface_added_id = -1;
1340                 }
1341                 if (subs_interface_removed_id != -1) {
1342                         g_dbus_connection_signal_unsubscribe(conn,
1343                                         subs_interface_removed_id);
1344                         subs_interface_removed_id = -1;
1345                 }
1346                 if (subs_name_owner_id != -1) {
1347                         g_dbus_connection_signal_unsubscribe(conn,
1348                                         subs_name_owner_id);
1349                         subs_name_owner_id = -1;
1350                 }
1351                 if (subs_property_id != -1) {
1352                         g_dbus_connection_signal_unsubscribe(conn,
1353                                         subs_property_id);
1354                         subs_property_id = -1;
1355                 }
1356                 if (subs_adapter_id == -1) {
1357                         g_dbus_connection_signal_unsubscribe(conn, subs_adapter_id);
1358                         subs_adapter_id = -1;
1359                 }
1360         }
1361
1362         INFO_C("-");
1363         return 0;
1364 }
1365
1366 static int __bt_hal_register_device_subscribe_signal(GDBusConnection *conn,
1367                 int subscribe)
1368 {
1369         static int subs_device_id = -1;
1370
1371         DBG("+");
1372         if (conn == NULL)
1373                 return -1;
1374
1375         if (subscribe) {
1376                 if (subs_device_id == -1) {
1377                         subs_device_id = g_dbus_connection_signal_subscribe(conn,
1378                                         NULL, BT_HAL_DEVICE_INTERFACE,
1379                                         NULL, NULL, NULL, 0,
1380                                         __bt_hal_manager_event_filter,
1381                                         NULL, NULL);
1382                 }
1383         } else {
1384                 if (subs_device_id != -1) {
1385                         g_dbus_connection_signal_unsubscribe(conn,
1386                                         subs_device_id);
1387                         subs_device_id = -1;
1388                 }
1389         }
1390
1391         DBG("-");
1392         return 0;
1393 }
1394
1395 static int __bt_hal_register_input_subscribe_signal(GDBusConnection *conn, int subscribe)
1396 {
1397         static int subs_input_id = -1;
1398
1399         DBG("+");
1400
1401         if (conn == NULL)
1402                 return -1;
1403
1404         if (subscribe) {
1405                 if (subs_input_id == -1) {
1406                         subs_input_id = g_dbus_connection_signal_subscribe(conn,
1407                                         NULL, BT_HAL_INPUT_INTERFACE,
1408                                         NULL, NULL, NULL, 0,
1409                                         __bt_hal_manager_event_filter,
1410                                         NULL, NULL);
1411                 }
1412         } else {
1413                 if (subs_input_id != -1) {
1414                         g_dbus_connection_signal_unsubscribe(conn,
1415                                         subs_input_id);
1416                         subs_input_id = -1;
1417                 }
1418         }
1419
1420         DBG("-");
1421
1422         return 0;
1423 }
1424
1425 static int __bt_hal_register_gatt_subscribe_signal(GDBusConnection *conn,
1426                 int subscribe)
1427 {
1428         static int subs_gatt_char_id = -1;
1429         static int subs_gatt_service_id = -1;
1430
1431         if (subscribe) {
1432                 if (subs_gatt_char_id == -1) {
1433                         subs_gatt_char_id = g_dbus_connection_signal_subscribe(conn,
1434                                         NULL, BT_HAL_GATT_CHAR_INTERFACE,
1435                                         NULL, NULL, NULL, 0,
1436                                         __bt_hal_manager_event_filter,
1437                                         NULL, NULL);
1438                 }
1439                 if (subs_gatt_service_id == -1) {
1440                         subs_gatt_service_id = g_dbus_connection_signal_subscribe(conn,
1441                                         NULL, BT_HAL_GATT_SERVICE_INTERFACE,
1442                                         NULL, NULL, NULL, 0,
1443                                         __bt_hal_manager_event_filter,
1444                                         NULL, NULL);
1445                 }
1446         } else {
1447                 if (subs_gatt_char_id == -1) {
1448                         g_dbus_connection_signal_unsubscribe(conn,
1449                                         subs_gatt_char_id);
1450                         subs_gatt_char_id = -1;
1451                 }
1452                 if (subs_gatt_service_id == -1) {
1453                         g_dbus_connection_signal_unsubscribe(conn,
1454                                         subs_gatt_service_id);
1455                         subs_gatt_service_id = -1;
1456                 }
1457         }
1458
1459         return BT_HAL_ERROR_NONE;
1460 }
1461
1462
1463
1464 static int __bt_hal_register_service_event(GDBusConnection *g_conn, int event_type)
1465 {
1466         DBG("+");
1467
1468         if (g_conn == NULL)
1469                 return  BT_HAL_ERROR_INTERNAL;
1470
1471         /* TODO: Add more events in subsequent patches */
1472         switch (event_type) {
1473         case BT_HAL_MANAGER_EVENT:
1474                 __bt_hal_register_manager_subscribe_signal(g_conn, TRUE);
1475                 break;
1476         case BT_HAL_DEVICE_EVENT:
1477                 __bt_hal_register_device_subscribe_signal(g_conn, TRUE);
1478                 break;
1479         case BT_HAL_HID_EVENT:
1480                 __bt_hal_register_input_subscribe_signal(g_conn, TRUE);
1481                 break;
1482         case BT_HAL_HEADSET_EVENT:
1483                  __bt_hal_register_audio_subscribe_signal(g_conn, TRUE);
1484                 break;
1485         case BT_HAL_GATT_EVENT:
1486                 __bt_hal_register_gatt_subscribe_signal(g_conn, TRUE);
1487                 break;
1488         default:
1489                 INFO_C("Register Event: event_type [%d]", event_type);
1490                 return BT_HAL_ERROR_NOT_SUPPORT;
1491         }
1492
1493         return BT_HAL_ERROR_NONE;
1494 }
1495
1496 static int __bt_hal_register_audio_subscribe_signal(GDBusConnection *conn,
1497                 int subscribe)
1498 {
1499         if (conn == NULL)
1500                 return -1;
1501
1502         static int subs_headset_id = -1;
1503         static int subs_sink_id = -1;
1504
1505         if (subscribe) {
1506                 if (subs_headset_id == -1) {
1507                         subs_headset_id = g_dbus_connection_signal_subscribe(conn,
1508                                         NULL, BT_HAL_HEADSET_INTERFACE,
1509                                         NULL, NULL, NULL, 0,
1510                                         __bt_hal_manager_event_filter,
1511                                         NULL, NULL);
1512                 }
1513                 if (subs_sink_id == -1) {
1514                         subs_sink_id = g_dbus_connection_signal_subscribe(conn,
1515                                         NULL, BT_HAL_SINK_INTERFACE,
1516                                         NULL, NULL, NULL, 0,
1517                                         __bt_hal_manager_event_filter,
1518                                         NULL, NULL);
1519                 }
1520         } else {
1521                 if (subs_headset_id != -1) {
1522                         g_dbus_connection_signal_unsubscribe(conn,
1523                                         subs_headset_id);
1524                         subs_headset_id = -1;
1525                 }
1526                 if (subs_sink_id != -1) {
1527                         g_dbus_connection_signal_unsubscribe(conn,
1528                                         subs_sink_id);
1529                         subs_sink_id = -1;
1530                 }
1531         }
1532         return 0;
1533 }
1534
1535 static int __bt_hal_initialize_manager_receiver(void)
1536 {
1537         DBG("+");
1538
1539         GError *error = NULL;
1540
1541         if (manager_conn == NULL) {
1542                 manager_conn =  g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
1543                 if (error != NULL) {
1544                         ERR_C("ERROR: Can't get on system bus [%s]", error->message);
1545                         g_clear_error(&error);
1546                 }
1547                 if (manager_conn == NULL)
1548                         goto fail;
1549         }
1550
1551         if (__bt_hal_register_service_event(manager_conn,
1552                                 BT_HAL_MANAGER_EVENT) != BT_HAL_ERROR_NONE)
1553                 goto fail;
1554         if (__bt_hal_register_service_event(manager_conn,
1555                                 BT_HAL_DEVICE_EVENT) != BT_HAL_ERROR_NONE)
1556                 goto fail;
1557         if (__bt_hal_register_service_event(manager_conn,
1558                                 BT_HAL_HID_EVENT) != BT_HAL_ERROR_NONE)
1559                 goto fail;
1560         if (__bt_hal_register_service_event(manager_conn,
1561                                 BT_HAL_HEADSET_EVENT) != BT_HAL_ERROR_NONE)
1562                 goto fail;
1563         if (__bt_hal_register_service_event(manager_conn,
1564                                 BT_HAL_GATT_EVENT) != BT_HAL_ERROR_NONE)
1565                 goto fail;
1566         return BT_HAL_ERROR_NONE;
1567 fail:
1568         if (manager_conn) {
1569                 g_object_unref(manager_conn);
1570                 manager_conn = NULL;
1571         }
1572
1573         DBG("-");
1574
1575         return BT_HAL_ERROR_INTERNAL;
1576 }
1577
1578 /* To receive the event from bluez */
1579 int _bt_hal_initialize_event_receiver(handle_stack_msg cb)
1580 {
1581         int result;
1582         DBG("+");
1583
1584         if (!cb)
1585                 return BT_HAL_ERROR_INVALID_PARAM;
1586
1587         result = __bt_hal_initialize_manager_receiver();
1588
1589         DBG("Manager event receiver initialization result [%d]", result);
1590         if (result != BT_HAL_ERROR_NONE)
1591                 return result;
1592
1593         /*TODO: Initialize Obexd Event receiver */
1594
1595         /* Initialize event receiver for flight mode  */
1596         _bt_hal_register_vconf_handler();
1597
1598         event_cb = cb;
1599         DBG("-");
1600
1601         return BT_HAL_ERROR_NONE;
1602 }
1603
1604 static void __bt_hal_device_property_changed_event(GVariant *msg, const char *path)
1605 {
1606         GVariantIter value_iter;
1607         GVariant *value = NULL;
1608         char *key = NULL;
1609         g_variant_iter_init(&value_iter, msg);
1610         DBG("+");
1611
1612         while (g_variant_iter_loop(&value_iter, "{sv}", &key, &value)) {
1613                 if (!g_strcmp0(key, "Connected")) {
1614                         guint connected = 0;
1615                         g_variant_get(value, "i", &connected);
1616                         DBG("Device property changed : Connected [%d]", connected);
1617                 } else if (!g_strcmp0(key, "RSSI")) {
1618                         DBG("Device property changed : RSSI");
1619                         __bt_hal_dbus_device_found_properties(path);
1620                 } else if (!g_strcmp0(key, "GattConnected")) {
1621                         DBG("Device property changed : GattConnected");
1622                         gboolean gatt_connected = FALSE;
1623                         g_variant_get(value, "b", &gatt_connected);
1624                         char *address = g_malloc0(BT_HAL_ADDRESS_STRING_SIZE);
1625                         _bt_hal_convert_device_path_to_address(path, address);
1626                         DBG("@@gatt_connected: %d", gatt_connected);
1627                         DBG("@@address: %s", address);
1628                         _bt_hal_gatt_connected_state_event(gatt_connected, address);
1629                         _bt_hal_handle_gattc_connected_event(address, gatt_connected);
1630                         g_free(address);
1631                 } else if (!g_strcmp0(key, "Paired")) {
1632                         gboolean paired = FALSE;
1633                         struct hal_ev_bond_state_changed ev;
1634                         char address[BT_HAL_ADDRESS_STRING_SIZE];
1635
1636                         g_variant_get(value, "b", &paired);
1637                         DBG("Device property changed : Paired = %s", (paired ? "TRUE" : "FALSE"));
1638
1639                         _bt_hal_agent_set_canceled(FALSE);
1640                         _bt_hal_convert_device_path_to_address(path, address);
1641
1642                         /* Prepare to send event to HAL bluetooth */
1643                         ev.status = BT_STATUS_SUCCESS;
1644                         ev.state = paired ? BT_BOND_STATE_BONDED : BT_BOND_STATE_NONE;
1645                         _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
1646
1647                         if (!event_cb) {
1648                                 ERR("Bluetooth HAL event handler not registered");
1649                         } else {
1650                                 DBG("Sending HAL_EV_BOND_STATE_CHANGED event");
1651                                 event_cb(HAL_EV_BOND_STATE_CHANGED, (void*)&ev, sizeof(ev));
1652                         }
1653                 } else if (!g_strcmp0(key, "LegacyPaired")) {
1654                         DBG("Device property changed : LegacyPaired");
1655                 } else if (!g_strcmp0(key, "Trusted")) {
1656                         DBG("Device property changed : Trusted");
1657                         gboolean trusted = FALSE;
1658                         gchar *address = NULL;
1659                         g_variant_get(value, "b", &trusted);
1660                         address = g_malloc0(BT_HAL_ADDRESS_STRING_SIZE);
1661
1662                         _bt_hal_convert_device_path_to_address(path, address);
1663                         DBG("Device [%s] trusted: [%d]", address, trusted);
1664
1665                         __bt_hal_send_device_trust_state_event(trusted, address);
1666                         g_free(address);
1667                 } else if (!g_strcmp0(key, "IpspConnected")) {
1668                         DBG("Device property changed : IpspConnected");
1669                 } else if (!g_strcmp0(key, "IpspInitStateChanged")) {
1670                         DBG("Device property changed : IpspInitStateChanged");
1671                 } else if (!g_strcmp0(key, "TrustedProfiles")) {
1672                         int trust_val = 0;
1673                         char address[BT_HAL_ADDRESS_STRING_SIZE];
1674
1675                         g_variant_get(value, "u", &trust_val);
1676                         _bt_hal_convert_device_path_to_address(path, address);
1677                         DBG("Address: %s, TrustedProfiles: 0x%X", address, trust_val);
1678                         __bt_hal_send_device_trusted_profile_changed_event(trust_val, address);
1679                 } else {
1680                         ERR("Unhandled Property:[%s]", key);
1681                 }
1682         }
1683         DBG("-");
1684 }
1685
1686 static void __bt_hal_dbus_device_found_properties(const char *device_path)
1687 {
1688         char *address;
1689         GError *error = NULL;
1690         GDBusProxy *device_proxy;
1691         GDBusConnection *conn;
1692         GVariant *result;
1693         DBG("+");
1694
1695         if (!device_path) {
1696                 ERR("Invalid device path");
1697                 return;
1698         }
1699
1700         conn = _bt_hal_get_system_gconn();
1701         if (!conn) {
1702                 ERR("_bt_hal_get_system_gconn failed");
1703                 return;
1704         }
1705
1706         device_proxy = g_dbus_proxy_new_sync(conn, G_DBUS_PROXY_FLAGS_NONE,
1707                         NULL,
1708                         BT_HAL_BLUEZ_NAME,
1709                         device_path,
1710                         BT_HAL_PROPERTIES_INTERFACE,
1711                         NULL, NULL);
1712
1713         if (!device_proxy) {
1714                 ERR("Error creating device_proxy");
1715                 return;
1716         }
1717
1718         result = g_dbus_proxy_call_sync(device_proxy,
1719                         "GetAll",
1720                         g_variant_new("(s)", BT_HAL_DEVICE_INTERFACE),
1721                         G_DBUS_CALL_FLAGS_NONE,
1722                         -1,
1723                         NULL,
1724                         &error);
1725         if (!result) {
1726                 ERR("Error occured in Proxy call");
1727                 if (error != NULL) {
1728                         ERR("Error occured in Proxy call (Error: %s)", error->message);
1729                         g_clear_error(&error);
1730                 }
1731                 g_object_unref(device_proxy);
1732                 return;
1733         }
1734
1735         address = g_malloc0(BT_HAL_ADDRESS_STRING_SIZE);
1736         _bt_hal_convert_device_path_to_address(device_path, address);
1737
1738         __bt_hal_device_properties_lookup(result, address);
1739
1740         g_object_unref(device_proxy);
1741         g_free(address);
1742
1743         DBG("-");
1744 }
1745
1746 static void __bt_hal_device_properties_lookup(GVariant *result, char *address)
1747 {
1748         /* Buffer and propety count management */
1749         uint8_t buf[BT_HAL_MAX_PROPERTY_BUF_SIZE];
1750         struct hal_ev_device_found *ev = (void *) buf;
1751         size_t size = 0;
1752         memset(buf, 0, sizeof(buf));
1753         size = sizeof(*ev);
1754         ev->num_props = 0;
1755
1756         GVariant *tmp_value;
1757         GVariant *value;
1758         gchar *name;
1759         gchar *manufacturer_data = NULL;
1760         DBG("+");
1761
1762         if (result != NULL) {
1763                 g_variant_get(result , "(@a{sv})", &value);
1764                 g_variant_unref(result);
1765
1766                 /* Alias */
1767                 tmp_value = g_variant_lookup_value(value, "Alias", G_VARIANT_TYPE_STRING);
1768
1769                 g_variant_get(tmp_value, "s", &name);
1770
1771                 g_variant_unref(tmp_value);
1772                 if (name != NULL) {
1773                         DBG_SECURE("Alias Name [%s]", name);
1774                         size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_NAME,
1775                                         strlen(name) + 1, name);
1776                         ev->num_props++;
1777                         DBG("Device Name [%s] Property num [%d]", name, ev->num_props);
1778                 } else {
1779                         /* Name */
1780                         tmp_value = g_variant_lookup_value(value, "Name", G_VARIANT_TYPE_STRING);
1781                         g_variant_get(tmp_value, "s", &name);
1782                         g_variant_unref(tmp_value);
1783
1784                         size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_NAME,
1785                                         strlen(name) + 1, name);
1786                         ev->num_props++;
1787                         DBG("Device Name [%s] Property num [%d]", name, ev->num_props);
1788                         g_variant_get(tmp_value, "s", &name);
1789                 }
1790
1791                 /* Class */
1792                 tmp_value = g_variant_lookup_value(value, "Class", G_VARIANT_TYPE_UINT32);
1793                 unsigned int class = tmp_value ? g_variant_get_uint32(tmp_value) : 0;
1794                 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_CLASS,
1795                                 sizeof(unsigned int), &class);
1796                 ev->num_props++;
1797                 if (tmp_value)
1798                         g_variant_unref(tmp_value);
1799
1800
1801                 /* Connected */
1802                 tmp_value = g_variant_lookup_value(value, "Connected",  G_VARIANT_TYPE_BOOLEAN);
1803                 unsigned int connected = tmp_value ? g_variant_get_boolean(tmp_value) : 0;
1804                 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_CONNECTED,
1805                                 sizeof(unsigned int), &connected);
1806                 ev->num_props++;
1807                 DBG("Device connected [%u] Property num [%d]", connected,  ev->num_props);
1808                 if (tmp_value)
1809                         g_variant_unref(tmp_value);
1810
1811                 /* Trust */
1812                 tmp_value = g_variant_lookup_value(value, "Trusted",  G_VARIANT_TYPE_BOOLEAN);
1813                 uint8_t trust = tmp_value ? (g_variant_get_boolean(tmp_value) ? 1 : 0) : 0;
1814                 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_TRUSTED,
1815                                 sizeof(uint8_t), &trust);
1816                 ev->num_props++;
1817                 DBG("Device trusted [%d] Property num [%d]", trust, ev->num_props);
1818                 if (tmp_value)
1819                         g_variant_unref(tmp_value);
1820
1821                 /* Paired */
1822                 tmp_value = g_variant_lookup_value(value, "Paired",  G_VARIANT_TYPE_BOOLEAN);
1823                 uint8_t paired = tmp_value ? (g_variant_get_boolean(tmp_value) ? 1 : 0) : 0;
1824
1825                 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_PAIRED,
1826                                 sizeof(uint8_t), &paired);
1827                 ev->num_props++;
1828                 DBG("Device Paired [%d] Property num [%d]", paired, ev->num_props);
1829                 if (tmp_value)
1830                         g_variant_unref(tmp_value);
1831
1832                 /* RSSI*/
1833                 tmp_value = g_variant_lookup_value(value, "RSSI", G_VARIANT_TYPE_INT32);
1834                 int rssi = tmp_value ? g_variant_get_int32(tmp_value) : 0;
1835                 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_RSSI,
1836                                 sizeof(int), &rssi);
1837                 ev->num_props++;
1838                 DBG("Device RSSI [%d] Property num [%d]", rssi, ev->num_props);
1839                 if (tmp_value)
1840                         g_variant_unref(tmp_value);
1841
1842                 /* Last Addr Type */
1843                 tmp_value = g_variant_lookup_value(value, "LastAddrType", G_VARIANT_TYPE_UINT32);
1844                 unsigned int addr_type = tmp_value ? g_variant_get_uint32(tmp_value) : 0;
1845                 if (tmp_value)
1846                         g_variant_unref(tmp_value);
1847                 DBG("Device Last Address Type [0x%x]", addr_type);
1848
1849                 /* Is Alias Set */
1850                 tmp_value = g_variant_lookup_value(value, "IsAliasSet", G_VARIANT_TYPE_UINT32);
1851                 uint8_t is_alias_set = tmp_value ? (g_variant_get_boolean(tmp_value) ? 1 : 0) : 0;
1852                 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_IS_ALIAS_SET,
1853                                         sizeof(uint8_t), &is_alias_set);
1854                 ev->num_props++;
1855                 DBG("IsAliasSet: [%s], Property num [%d]", (is_alias_set ? "TRUE" : "FALSE"), ev->num_props);
1856                 if (tmp_value)
1857                         g_variant_unref(tmp_value);
1858
1859                 /* UUID's */
1860                 tmp_value = g_variant_lookup_value(value, "UUIDs", G_VARIANT_TYPE_STRING_ARRAY);
1861                 gsize uuid_count = g_variant_get_size(tmp_value);
1862                 char **uuid_value = g_variant_dup_strv(tmp_value, &uuid_count);
1863                 {
1864                         /* UUID collection */
1865                         int i;
1866 #ifdef __TEST_
1867                         int z;
1868 #endif
1869                         int num_props_tmp = ev->num_props;
1870
1871                         uint8_t uuids[BT_HAL_STACK_UUID_SIZE * uuid_count];
1872
1873                         for (i = 0; uuid_value[i] != NULL; i++) {
1874
1875                                 char *uuid_str = NULL;
1876                                 uint8_t uuid[BT_HAL_STACK_UUID_SIZE];
1877                                 memset(uuid, 0x00, BT_HAL_STACK_UUID_SIZE);
1878
1879                                 DBG("UUID string from Bluez [%s]\n", uuid_value[i]);
1880                                 uuid_str = g_strdup(uuid_value[i]);
1881                                 DBG("UUID string [%s]\n", uuid_str);
1882
1883                                 _bt_hal_convert_uuid_string_to_type(uuid, uuid_str);
1884 #ifdef __TEST_
1885                                 for (z = 0; z < 16; z++)
1886                                         DBG("[0x%x]", uuid[z]);
1887 #endif
1888
1889                                 memcpy(uuids+i*BT_HAL_STACK_UUID_SIZE, uuid, BT_HAL_STACK_UUID_SIZE);
1890                                 g_free(uuid_str);
1891                         }
1892
1893                         size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_UUIDS,
1894                                         (BT_HAL_STACK_UUID_SIZE * uuid_count),
1895                                         uuids);
1896                         ev->num_props = num_props_tmp + 1;
1897                         g_free(uuid_value);
1898                 }
1899                 g_variant_unref(tmp_value);
1900
1901                 /* LegacyManufacturerDataLen */
1902                 tmp_value = g_variant_lookup_value(value, "LegacyManufacturerDataLen", G_VARIANT_TYPE_UINT32);
1903                 unsigned int manufacturer_data_len = tmp_value ? g_variant_get_uint32(tmp_value) : 0;
1904                 if (manufacturer_data_len > BT_HAL_MANUFACTURER_DATA_LENGTH_MAX) {
1905                         ERR("manufacturer_data_len is too long(len = %d)", manufacturer_data_len);
1906                         manufacturer_data_len = BT_HAL_MANUFACTURER_DATA_LENGTH_MAX;
1907                 }
1908                 if (tmp_value)
1909                         g_variant_unref(tmp_value);
1910                 /*size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_MANUFACTURER_DATA_LEN,
1911                   sizeof(unsigned int), &manufacturer_data_len);
1912                   ev->num_props++;*/
1913                 DBG("Device Legacy Manufacturer data length [%u]", manufacturer_data_len);
1914
1915                 /* ManufacturerData */
1916                 tmp_value = g_variant_lookup_value(value, "LegacyManufacturerData", G_VARIANT_TYPE_BYTESTRING);
1917                 manufacturer_data = value ? (gchar *)g_variant_get_bytestring(tmp_value) : NULL;
1918                 if (manufacturer_data) {
1919                         if (manufacturer_data_len > 0) {
1920                                 //size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_MANUFACTURER_DATA,
1921                                 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_BLE_ADV_DATA,
1922                                                 manufacturer_data_len, manufacturer_data);
1923                                 ev->num_props++;
1924                         }
1925                 }
1926                 if (tmp_value)
1927                         g_variant_unref(tmp_value);
1928
1929                 /* Address */
1930                 uint8_t bdaddr[6];
1931                 _bt_hal_convert_addr_string_to_type(bdaddr, address);
1932                 size += __bt_insert_hal_properties(buf + size, HAL_PROP_DEVICE_ADDR,
1933                                 sizeof(bdaddr), bdaddr);
1934                 ev->num_props++;
1935                 DBG("Device address [%s] property Num [%d]", address, ev->num_props);
1936
1937                 g_free(name);
1938                 g_variant_unref(value);
1939         } else {
1940                 ERR("result  is NULL\n");
1941         }
1942         if (size > 1) {
1943                 DBG("Send Device found event to HAL user, Num Prop [%d] total size [%zd]", ev->num_props, size);
1944                 event_cb(HAL_EV_DEVICE_FOUND, (void*) buf, size);
1945         }
1946         DBG("-");
1947 }
1948
1949 static void __bt_hal_send_device_acl_connection_state_event(int status, gboolean connected, const char *address)
1950 {
1951         DBG("+");
1952         struct hal_ev_acl_state_changed ev;
1953
1954         ev.status = status;
1955         ev.state = (connected == TRUE) ?
1956                 HAL_ACL_STATE_CONNECTED :
1957                 HAL_ACL_STATE_DISCONNECTED;
1958
1959         _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
1960
1961         if (!event_cb)
1962                 ERR("Bluetooth HAL event handler not registered");
1963         else
1964                 event_cb(HAL_EV_ACL_STATE_CHANGED, &ev, sizeof(ev));
1965         DBG("-");
1966 }
1967
1968 static void __bt_hal_send_device_le_connection_state_event(int status, gboolean connected, const char *address)
1969 {
1970         DBG("+");
1971         struct hal_ev_le_conn_state_changed ev;
1972
1973         ev.status = status;
1974         ev.state = (connected == TRUE) ?
1975                 HAL_LE_STATE_CONNECTED :
1976                 HAL_LE_STATE_DISCONNECTED;
1977
1978         _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
1979
1980         if (!event_cb)
1981                 ERR("Bluetooth HAL event handler not registered");
1982         else
1983                 event_cb(HAL_EV_LE_CONN_STATE_CHANGED, &ev, sizeof(ev));
1984         DBG("-");
1985 }
1986
1987 static void __bt_hal_send_device_trust_state_event(gboolean is_trusted,
1988                                 const char *address)
1989 {
1990         struct hal_ev_device_trust_state_changed ev;
1991         DBG("+");
1992
1993         ev.trust = (is_trusted == TRUE) ?
1994                 HAL_DEVICE_TRUSTED :
1995                 HAL_DEVICE_UNTRUSTED;
1996
1997         _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
1998
1999         if (!event_cb)
2000                 ERR("Bluetooth HAL event handler not registered");
2001         else
2002                 event_cb(HAL_EV_DEVICE_TRUST_CHANGED, &ev, sizeof(ev));
2003         DBG("-");
2004 }
2005
2006 static void __bt_hal_send_device_trusted_profile_changed_event(
2007                 uint32_t trust_val, const char *address)
2008 {
2009         struct hal_ev_device_trusted_profiles_changed ev;
2010         DBG("+");
2011
2012         _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
2013         ev.trust_val = trust_val;
2014
2015         if (!event_cb)
2016                 ERR("Bluetooth HAL event handler not registered");
2017         else
2018                 event_cb(HAL_EV_DEVICE_TRUSTED_PROFILES_CHANGED, &ev, sizeof(ev));
2019         DBG("-");
2020 }
2021
2022 static void __bt_hal_handle_device_specific_events(GVariant *msg, const char *member,
2023                         const char *path)
2024 {
2025         char *address;
2026         const char *property = NULL;
2027         if (path == NULL)
2028                 return;
2029
2030         if (strcasecmp(member, "PropertyChanged") == 0) {
2031                 g_variant_get(msg, "(s)", &property);
2032                 if (property == NULL)
2033                         return;
2034                 if (strcasecmp(property, "GattConnected") == 0) {
2035                         INFO("GATT Connected");
2036                         gboolean connected = FALSE;
2037                         char *address;
2038                         address = g_malloc0(BT_HAL_ADDRESS_STRING_SIZE);
2039
2040                         _bt_hal_convert_device_path_to_address(path, address);
2041                         g_variant_get(msg, "(b)", &connected);
2042
2043                         INFO("Connected device address[%s] connnected[%d]", address, connected);
2044                         g_free(address);
2045                 } else if (strcasecmp(property, "Paired") == 0) {
2046                         gboolean paired = FALSE;
2047                         struct hal_ev_bond_state_changed ev;
2048                         char address[BT_HAL_ADDRESS_STRING_SIZE];
2049
2050                         g_variant_get(msg, "(b)", &paired);
2051                         DBG("Device property changed : Paired = %s", (paired ? "TRUE" : "FALSE"));
2052
2053                         _bt_hal_agent_set_canceled(FALSE);
2054                         _bt_hal_convert_device_path_to_address(path, address);
2055
2056                         /* Prepare to send event to HAL bluetooth */
2057                         ev.status = BT_STATUS_SUCCESS;
2058                         ev.state = paired ? BT_BOND_STATE_BONDED : BT_BOND_STATE_NONE;
2059                         _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
2060
2061                         if (!event_cb) {
2062                                 ERR("Bluetooth HAL event handler not registered");
2063                         } else {
2064                                 DBG("Sending HAL_EV_BOND_STATE_CHANGED event");
2065                                 event_cb(HAL_EV_BOND_STATE_CHANGED, (void*)&ev, sizeof(ev));
2066                         }
2067                 } else if (strcasecmp(property, "UUIDs") == 0) {
2068                         /* TODO */
2069                 }
2070         } else if (strcasecmp(member, "DeviceConnected") == 0) {
2071                 unsigned char addr_type = 0;
2072
2073                 g_variant_get(msg, "(y)", &addr_type);
2074
2075                 address = g_malloc0(BT_HAL_ADDRESS_STRING_SIZE);
2076                 _bt_hal_convert_device_path_to_address(path, address);
2077
2078                 DBG("Member: [%s]", member);
2079                 ERR_C("### Connected [%s] [%s]", !addr_type ? "BREDR" : "LE", address);
2080                 if (!addr_type)
2081                         __bt_hal_send_device_acl_connection_state_event(BT_STATUS_SUCCESS, TRUE, address);
2082                 else
2083                         __bt_hal_send_device_le_connection_state_event(BT_STATUS_SUCCESS, TRUE, address);
2084                 g_free(address);
2085         } else if (strcasecmp(member, "Disconnected") == 0) {
2086                 unsigned char disc_reason = 0;
2087                 unsigned char addr_type = 0;
2088                 char *name = NULL;
2089
2090                 g_variant_get(msg, "(yy&s)", &addr_type, &disc_reason, &name);
2091
2092                 address = g_malloc0(BT_HAL_ADDRESS_STRING_SIZE);
2093                 _bt_hal_convert_device_path_to_address(path, address);
2094
2095                 ERR_C("### Disconnected [%s] [%d : %s] [%s] [%s]", !addr_type ? "BREDR" : "LE",
2096                         disc_reason, _bt_hal_convert_disc_reason_to_string(disc_reason), address, name);
2097
2098                 if (!addr_type)
2099                         __bt_hal_send_device_acl_connection_state_event(_bt_hal_convert_disc_reason_to_status(disc_reason), FALSE, address);
2100                 else
2101                         __bt_hal_send_device_le_connection_state_event(_bt_hal_convert_disc_reason_to_status(disc_reason), FALSE, address);
2102                 g_free(address);
2103         } else if (strcasecmp(member, "ProfileStateChanged") == 0) {
2104                 int state = 0;
2105                 char *profile_uuid = NULL;
2106
2107                 g_variant_get(msg, "(si)", &profile_uuid, &state);
2108                 address = g_malloc0(BT_HAL_ADDRESS_STRING_SIZE);
2109                 _bt_hal_convert_device_path_to_address(path, address);
2110
2111                 DBG("[%s] %s, state %d", address, profile_uuid, state);
2112                 if (strncmp(profile_uuid, HID_UUID, strlen(HID_UUID)) == 0) {
2113                         DBG("HID Host Profile state: %d", state);
2114                         if (state == BT_HAL_PROFILE_STATE_CONNECTED)
2115                                 __bt_hal_send_hid_connection_state_event(TRUE, address);
2116                         else if (state == BT_HAL_PROFILE_STATE_DISCONNECTED)
2117                                 __bt_hal_send_hid_connection_state_event(FALSE, address);
2118                         else
2119                                 DBG("HID Host Profile state: Invalid");
2120                 } else if (strcmp(profile_uuid, HID_DEVICE_UUID) == 0) {
2121                         DBG("HID Device Profile state: %d", state);
2122                         if (state == BT_HAL_PROFILE_STATE_CONNECTED)
2123                                 __bt_hal_send_hid_device_connection_state_event(TRUE, address);
2124                         else if (state == BT_HAL_PROFILE_STATE_DISCONNECTED)
2125                                 __bt_hal_send_hid_device_connection_state_event(FALSE, address);
2126                         else
2127                                 DBG("HID Device Profile state: Invalid");
2128                 } else if ((strcmp(profile_uuid, A2DP_SINK_UUID) == 0)) {
2129                         if (state == BT_HAL_PROFILE_STATE_CONNECTED) {
2130                                 DBG("A2DP Profile state changed: BT_PROFILE_STATE_CONNECTED");
2131                                 __bt_hal_send_av_connection_state_event(TRUE, address);
2132                         } else if (state == BT_HAL_PROFILE_STATE_DISCONNECTED) {
2133                                 DBG("A2DP Profile state changed: BT_PROFILE_STATE_DISCONNECTED");
2134                                 __bt_hal_send_av_connection_state_event(FALSE, address);
2135                         } else if (state == BT_HAL_PROFILE_STATE_DISCONNECTING) {
2136                                 DBG("A2DP Profile state changed: BT_PROFILE_STATE_DISCONNECTING");
2137                         } else if (state == BT_HAL_PROFILE_STATE_CONNECTING) {
2138                                 DBG("A2DP Profile state changed: BT_PROFILE_STATE_CONNECTING");
2139                         } else {
2140                                 ERR("A2DP Profile state: Invalid");
2141                         }
2142                 } else if ((strcmp(profile_uuid, A2DP_SOURCE_UUID) == 0)) {
2143                         if (state == BT_HAL_PROFILE_STATE_CONNECTED) {
2144                                 DBG("A2DP Sink Profile state changed: BT_HAL_PROFILE_STATE_CONNECTED");
2145                                 __bt_hal_send_a2dp_sink_connection_state_event(TRUE, address);
2146                         } else if (state == BT_HAL_PROFILE_STATE_DISCONNECTED) {
2147                                 DBG("A2DP Sink Profile state changed: BT_HAL_PROFILE_STATE_DISCONNECTED");
2148                                 __bt_hal_send_a2dp_sink_connection_state_event(FALSE, address);
2149                         } else if (state == BT_HAL_PROFILE_STATE_DISCONNECTING) {
2150                                 DBG("A2DP Sink Profile state changed: BT_HAL_PROFILE_STATE_DISCONNECTING");
2151                         } else if (state == BT_HAL_PROFILE_STATE_CONNECTING) {
2152                                 DBG("A2DP Sink Profile state changed: BT_HAL_PROFILE_STATE_CONNECTING");
2153                         }
2154                 } else if (strcmp(profile_uuid, HFP_HF_UUID) == 0) {
2155                         if (state == BT_HAL_PROFILE_STATE_CONNECTING)
2156                                 DBG("HFP Profile state changed: BT_PROFILE_STATE_CONNECTING");
2157                         else if (state == BT_HAL_PROFILE_STATE_CONNECTED) {
2158                                 DBG("HFP Profile state changed: BT_PROFILE_STATE_CONNECTED");
2159                                 __bt_hal_send_hf_connection_state_event(TRUE, address);
2160                         } else if (state == BT_HAL_PROFILE_STATE_DISCONNECTED) {
2161                                 DBG("HFP Profile state changed: BT_PROFILE_STATE_DISCONNECTED");
2162                                 __bt_hal_send_hf_connection_state_event(FALSE, address);
2163                         } else if (state == BT_HAL_PROFILE_STATE_DISCONNECTING) {
2164                                 DBG("HFP Profile state changed: BT_PROFILE_STATE_DISCONNECTING");
2165                         } else {
2166                                 ERR("HFP Profile state: Invalid");
2167                         }
2168                 } else if (strcmp(profile_uuid, HFP_AG_UUID) == 0) {
2169                         if (state == BT_HAL_PROFILE_STATE_CONNECTING)
2170                                 DBG("HFP Client Profile state changed: BT_PROFILE_STATE_CONNECTING");
2171                         else if (state == BT_HAL_PROFILE_STATE_CONNECTED) {
2172                                 DBG("HFP Client Profile state changed: BT_PROFILE_STATE_CONNECTED");
2173                                 __bt_hal_send_hf_client_connection_state_event(TRUE, address);
2174                         } else if (state == BT_HAL_PROFILE_STATE_DISCONNECTED) {
2175                                 DBG("HFP Client Profile state changed: BT_PROFILE_STATE_DISCONNECTED");
2176                                 __bt_hal_send_hf_client_connection_state_event(FALSE, address);
2177                         } else if (state == BT_HAL_PROFILE_STATE_DISCONNECTING) {
2178                                 DBG("HFP Client Profile state changed: BT_PROFILE_STATE_DISCONNECTING");
2179                         } else {
2180                                 ERR("HFP Client Profile state: Invalid");
2181                         }
2182                 } else if ((strcmp(profile_uuid, AVRCP_TARGET_UUID) == 0)) {
2183                         if (state == BT_HAL_PROFILE_STATE_CONNECTED) {
2184                                 DBG("AVRCP Controller Profile state changed: BT_HAL_PROFILE_STATE_CONNECTED");
2185                                 __bt_hal_send_avrcp_ctrl_connection_state_event(TRUE, address);
2186                         } else if (state == BT_HAL_PROFILE_STATE_DISCONNECTED) {
2187                                 DBG("AVRCP Controller Profile state changed: BT_HAL_PROFILE_STATE_DISCONNECTED");
2188                                 __bt_hal_send_avrcp_ctrl_connection_state_event(FALSE, address);
2189                         } else if (state == BT_HAL_PROFILE_STATE_DISCONNECTING) {
2190                                 DBG("AVRCP Controller Profile state changed: BT_HAL_PROFILE_STATE_DISCONNECTING");
2191                         } else if (state == BT_HAL_PROFILE_STATE_CONNECTING) {
2192                                 DBG("AVRCP Controller Profile state changed: BT_HAL_PROFILE_STATE_CONNECTING");
2193                         }
2194                 } else {
2195                         DBG("Profile[%s] State changed status [%d] ", profile_uuid, state);
2196                 }
2197                 g_free(address);
2198                 g_free(profile_uuid);
2199         } else if (strcasecmp(member, "AttMtuChanged") == 0) {
2200                 char *address;
2201                 guint16 mtu = 0;
2202
2203                 address = g_malloc0(BT_HAL_ADDRESS_STRING_SIZE);
2204
2205                 DBG("Member: [%s]", member);
2206
2207                 _bt_hal_convert_device_path_to_address(path, address);
2208                 g_variant_get(msg, "(q)", &mtu);
2209
2210                 __bt_hal_handle_gatts_mtu_changed_event(address, mtu);
2211
2212                 g_free(address);
2213         } else if (strcasecmp(member, "AdvReport") == 0) {
2214                 __bt_hal_handle_adv_report(msg, path);
2215         }
2216 }
2217
2218 static void __bt_hal_handle_adv_report(GVariant *msg, const char *path)
2219 {
2220         uint8_t buf[BT_HAL_MAX_PROPERTY_BUF_SIZE];
2221         struct hal_ev_gatt_client_scan_result *ev = (void *)buf;
2222         size_t size = 0;
2223         char *address = NULL;
2224         GVariant *value = NULL;
2225         char *buffer = NULL;
2226         int data_len = 0;
2227         int buffer_len = 0;
2228         uint8_t addr_type = 0;
2229         uint8_t adv_type = 0;
2230         int rssi = 0;
2231
2232         if (!gatt_event_cb)
2233                 return;
2234
2235         memset(buf, 0, sizeof(buf));
2236         size = sizeof(*ev);
2237
2238         g_variant_get(msg, "(&syyii@ay)", &address, &addr_type,
2239                         &adv_type, &rssi, &data_len, &value);
2240
2241         buffer_len = g_variant_get_size(value);
2242         if (buffer_len > 0)
2243                 buffer = (char *)g_variant_get_data(value);
2244
2245         if (data_len != buffer_len) {
2246                 ERR("Unexpected: buffer_len: %d, data_len: %d",
2247                                 buffer_len, data_len);
2248                 data_len = buffer_len;
2249         }
2250
2251         DBG("Address: %s, len: %d, rssi: %d, addr_type: 0x%02X, adv_type: 0x%02X",
2252                         address, data_len, rssi, addr_type, adv_type);
2253
2254         _bt_hal_convert_addr_string_to_type(ev->bd_addr, address);
2255         ev->addr_type = addr_type;
2256         ev->adv_type = adv_type;
2257         ev->rssi = rssi;
2258         ev->len = data_len;
2259         memcpy(ev->adv_data, buffer, data_len);
2260         size += data_len;
2261
2262         gatt_event_cb(HAL_EV_GATT_CLIENT_SCAN_RESULT, buf, size);
2263         g_variant_unref(value);
2264 }
2265
2266 static void __bt_hal_handle_gatts_mtu_changed_event(char *address, int mtu)
2267 {
2268         uint8_t buf[BT_HAL_MAX_PROPERTY_BUF_SIZE];
2269         struct hal_ev_gatt_server_mtu_changed *ev = (void *)buf;
2270         size_t size = 0;
2271
2272         if (!gatt_event_cb)
2273                 return;
2274
2275         memset(buf, 0, sizeof(buf));
2276         size = sizeof(*ev);
2277
2278         DBG("Address: %s, mtu: %d", address, mtu);
2279
2280         ev->conn_id = _bt_get_remote_gatt_client_conn_id(address);
2281         ev->mtu = mtu;
2282
2283         DBG("Send GATT server mtu changed event to HAL, size: [%zd]", size);
2284         gatt_event_cb(HAL_EV_GATT_SERVER_MTU_CHANGED, buf, size);
2285 }
2286
2287 /* AVRCP Controller Role(Remote:AVRCP Target) Events */
2288 static void __bt_hal_send_avrcp_ctrl_connection_state_event(gboolean connected, const char *address)
2289 {
2290         DBG("+");
2291         struct hal_ev_avrcp_ctrl_conn_state ev;
2292
2293         if (connected == TRUE)
2294                 INFO("AVRCP(Controller) Profile Connected for address [%s]", address);
2295         else
2296                 INFO("AVRCP(Controller) Profile DisConnected for address [%s]", address);
2297
2298         if (connected == TRUE)
2299                 ev.state = HAL_AVRCP_CTRL_STATE_CONNECTED;
2300         else
2301                 ev.state = HAL_AVRCP_CTRL_STATE_DISCONNECTED;
2302         _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
2303
2304         if (!avrcp_ctrl_event_cb)
2305                 ERR("AVRCP controller handler not registered");
2306         else
2307                 avrcp_ctrl_event_cb(HAL_EV_AVRCP_CTRL_CONN_STATE, &ev, sizeof(ev));
2308 }
2309
2310 static int __bt_media_attr_to_type(const char *str)
2311 {
2312         if (!strcasecmp(str, "Equalizer"))
2313                 return HAL_PLAYER_ATTR_EQUALIZER;
2314         else if (!strcasecmp(str, "Repeat"))
2315                 return HAL_PLAYER_ATTR_REPEAT;
2316         else if (!strcasecmp(str, "Shuffle"))
2317                 return HAL_PLAYER_ATTR_SHUFFLE;
2318         else if (!strcasecmp(str, "Scan"))
2319                 return HAL_PLAYER_ATTR_SCAN;
2320         else
2321                 return 0;
2322 }
2323
2324
2325 static int __bt_hal_play_status_str_to_type(const char *value)
2326 {
2327         if (!strcmp(value, "stopped"))
2328                 return HAL_PLAYSTATE_STOPPED;
2329         else if (!strcmp(value, "playing"))
2330                 return HAL_PLAYSTATE_PLAYING;
2331         else if (!strcmp(value, "paused"))
2332                 return HAL_PLAYSTATE_PAUSED;
2333         else if (!strcmp(value, "forward-seek"))
2334                 return HAL_PLAYSTATE_FWD_SEEK;
2335         else if (!strcmp(value, "reverse-seek"))
2336                 return HAL_PLAYSTATE_REV_SEEK;
2337         else
2338                 return HAL_PLAYSTATE_ERROR;
2339 }
2340
2341 static void __bt_avrcp_control_parse_properties(struct hal_ev_track_changed *ev, GVariant *item)
2342 {
2343         GVariant *value = NULL;
2344         GVariantIter iter;
2345         char *value_string = NULL;
2346         const char *key = NULL;
2347         int i = 0;
2348
2349         if (ev == NULL)
2350                 return;
2351
2352         g_variant_iter_init(&iter, item);
2353         while (g_variant_iter_loop(&iter, "{sv}", &key, &value)) {
2354                 if (strcasecmp(key, "Title") == 0) {
2355                         value_string = (char *)g_variant_get_string(value, NULL);
2356                         DBG("Value : %s ", value_string);
2357                         ev->attr[i].attr_id = HAL_MEDIA_ATTR_ID_TITLE;
2358                         g_strlcpy((gchar *)ev->attr[i].text, value_string, HAL_MAX_ATTR_STR_LEN);
2359                         i++;
2360                 } else if (strcasecmp(key, "Artist") == 0) {
2361                         value_string = (char *)g_variant_get_string(value, NULL);
2362                         DBG("Value : %s ", value_string);
2363                         ev->attr[i].attr_id = HAL_MEDIA_ATTR_ID_ARTIST;
2364                         g_strlcpy((gchar *)ev->attr[i].text, value_string, HAL_MAX_ATTR_STR_LEN);
2365                         i++;
2366                 } else if (strcasecmp(key, "Album") == 0) {
2367                         value_string = (char *)g_variant_get_string(value, NULL);
2368                         DBG("Value : %s ", value_string);
2369                         ev->attr[i].attr_id = HAL_MEDIA_ATTR_ID_ALBUM;
2370                         g_strlcpy((gchar *)ev->attr[i].text, value_string, HAL_MAX_ATTR_STR_LEN);
2371                         i++;
2372                 } else if (strcasecmp(key, "Genre") == 0) {
2373                         value_string = (char *)g_variant_get_string(value, NULL);
2374                         DBG("Value : %s ", value_string);
2375                         ev->attr[i].attr_id = HAL_MEDIA_ATTR_ID_GENRE;
2376                         g_strlcpy((gchar *)ev->attr[i].text, value_string, HAL_MAX_ATTR_STR_LEN);
2377                         i++;
2378                 } else if (strcasecmp(key, "Duration") == 0) {
2379                         long int val;
2380
2381                         val = g_variant_get_uint32(value);
2382                         DBG("Value : %li", val);
2383                         ev->attr[i].attr_id = HAL_MEDIA_ATTR_ID_PLAYING_TIME;
2384                         snprintf((char*)ev->attr[i].text, HAL_MAX_ATTR_STR_LEN, "%ld", val);
2385                         i++;
2386                 } else if (strcasecmp(key, "NumberOfTracks") == 0) {
2387                         long int val;
2388
2389                         val = g_variant_get_uint32(value);
2390                         DBG("Value : %li", val);
2391                         ev->attr[i].attr_id = HAL_MEDIA_ATTR_ID_NUM_TRACKS;
2392                         snprintf((char*)ev->attr[i].text, HAL_MAX_ATTR_STR_LEN, "%ld", val);
2393                         i++;
2394                 } else if (strcasecmp(key, "TrackNumber") == 0) {
2395                         long int val;
2396
2397                         val = g_variant_get_uint32(value);
2398                         DBG("Value : %li", val);
2399                         ev->attr[i].attr_id = HAL_MEDIA_ATTR_ID_TRACK_NUM;
2400                         snprintf((char*)ev->attr[i].text, HAL_MAX_ATTR_STR_LEN, "%ld", val);
2401                         i++;
2402                 } else {
2403                         DBG("%s not supported, ignoring", key);
2404                 }
2405
2406                 if (i >= HAL_MAX_ATTR_NUM) {
2407                         ERR(" Received max attribute [%d]", i);
2408                         break;
2409                 }
2410         }
2411
2412         ev->num_attr = i;
2413         g_variant_iter_free(&iter);
2414         return;
2415 }
2416
2417 static int __bt_media_attrval_to_val(int type, const char *value)
2418 {
2419         int ret = -1;
2420
2421         switch (type) {
2422         case HAL_PLAYER_ATTR_EQUALIZER:
2423                 if (!strcmp(value, "off"))
2424                         ret = 0x01;
2425                 else
2426                         ret = 0x02;
2427                 break;
2428         case HAL_PLAYER_ATTR_REPEAT:
2429                 if (!strcmp(value, "off"))
2430                         ret = BTRC_PLAYER_VAL_OFF_REPEAT;
2431                 else if (!strcmp(value, "singletrack"))
2432                         ret = BTRC_PLAYER_VAL_SINGLE_REPEAT;
2433                 else if (!strcmp(value, "alltracks"))
2434                         ret = BTRC_PLAYER_VAL_ALL_REPEAT;
2435                 else
2436                         ret = BTRC_PLAYER_VAL_GROUP_REPEAT;
2437                 break;
2438         case HAL_PLAYER_ATTR_SHUFFLE:
2439                 if (!strcmp(value, "off"))
2440                         ret = BTRC_PLAYER_VAL_OFF_SHUFFLE;
2441                 else if (!strcmp(value, "alltracks"))
2442                         ret = BTRC_PLAYER_VAL_ALL_SHUFFLE;
2443                 else
2444                         ret = BTRC_PLAYER_VAL_GROUP_SHUFFLE;
2445                 break;
2446         case HAL_PLAYER_ATTR_SCAN:
2447                 if (!strcmp(value, "off"))
2448                         ret = 0x01;
2449                 else if (!strcmp(value, "alltracks"))
2450                         ret = 0x02;
2451                 else
2452                         ret = 0x03;
2453                 break;
2454         default:
2455                 ERR("Value not handled");
2456         }
2457
2458         return ret;
2459 }
2460
2461 static void __bt_hal_handle_avrcp_ctrl_events(GVariant *msg, const char *member,
2462                 const char *path)
2463 {
2464         const char *property = NULL;
2465         GVariant *value = NULL;
2466         GVariantIter iter;
2467         char address[BT_HAL_ADDRESS_STRING_SIZE];
2468
2469         if (!msg) {
2470                 ERR("Error returned in method call\n");
2471                 return;
2472         }
2473
2474         if (!avrcp_ctrl_event_cb) {
2475                 ERR("AVRCP controller DBUS handler callback not registered");
2476                 return;
2477         }
2478
2479         g_variant_iter_init(&iter, msg);
2480
2481         _bt_hal_convert_device_path_to_address(path, address);
2482
2483         while (g_variant_iter_loop(&iter, "{sv}", &property, &value)) {
2484                 DBG("Property = %s \n", property);
2485                 if ((strcasecmp(property, "Equalizer") == 0) ||
2486                                 (strcasecmp(property, "Repeat") == 0) ||
2487                                 (strcasecmp(property, "Shuffle") == 0) ||
2488                                 (strcasecmp(property, "Scan") == 0)) {
2489                         struct hal_ev_player_setting ev;
2490                         const char *valstr;
2491                         int val = 0;
2492
2493                         valstr = g_variant_get_string(value, NULL);
2494                         DBG("Value : %s ", valstr);
2495
2496                         if (valstr)
2497                                 val = __bt_media_attrval_to_val(__bt_media_attr_to_type(property), valstr);
2498
2499                         if (val >= 0) {
2500                                 memset(&ev, 0, sizeof(ev));
2501                                 _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
2502                                 ev.num_attr = 1;
2503                                 ev.attr_ids[0] = __bt_media_attr_to_type(property);
2504                                 ev.attr_values[0] = val;
2505
2506                                 /* Send event to application */
2507                                 avrcp_ctrl_event_cb(HAL_EV_AVRCP_CTRL_PLAYER_APP_SETTING_CHANGED, &ev, sizeof(ev));
2508                         }
2509                 } else if ((strcasecmp(property, "Status") == 0)) {
2510                         struct hal_ev_play_status_changed ev;
2511                         const char *valstr;
2512
2513                         valstr = g_variant_get_string(value, NULL);
2514                         DBG("Value : %s ", valstr);
2515
2516                         memset(&ev, 0, sizeof(ev));
2517                         _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
2518                         if (valstr)
2519                                 ev.status = __bt_hal_play_status_str_to_type(valstr);
2520
2521                         /* Send event to application */
2522                         avrcp_ctrl_event_cb(HAL_EV_AVRCP_CTRL_PLAY_STATUS_CHANGED, &ev, sizeof(ev));
2523
2524                 } else if (strcasecmp(property, "Position") == 0) {
2525                         struct hal_ev_play_position ev;
2526
2527                         memset(&ev, 0, sizeof(ev));
2528                         _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
2529                         ev.pos = g_variant_get_uint32(value);
2530                         DBG("Value : %d ", ev.pos);
2531
2532                         /* Send event to application */
2533                         avrcp_ctrl_event_cb(HAL_EV_AVRCP_CTRL_PLAY_POSITION_CHANGED, &ev, sizeof(ev));
2534                 } else if (strcasecmp(property, "Track") == 0) {
2535                         struct hal_ev_track_changed ev;
2536
2537                         memset(&ev, 0, sizeof(ev));
2538                         _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
2539                         __bt_avrcp_control_parse_properties(&ev, value);
2540
2541                         /* Send event to application */
2542                         avrcp_ctrl_event_cb(HAL_EV_AVRCP_CTRL_TRACK_CHANGED, &ev, sizeof(ev));
2543                 } else {
2544                         DBG("Property not handled");
2545                 }
2546         }
2547
2548         g_free((char *)property);
2549         g_variant_unref(value);
2550 }
2551
2552 static void __bt_hal_handle_avrcp_transport_events(GVariant *msg, const char *member,
2553                 const char *path)
2554 {
2555         const char *property = NULL;
2556         GVariant *value = NULL;
2557         GVariantIter iter;
2558         char address[BT_HAL_ADDRESS_STRING_SIZE];
2559         DBG("+");
2560
2561         if (!msg) {
2562                 ERR("Error returned in method call\n");
2563                 return;
2564         }
2565
2566         if (!avrcp_tg_event_cb) {
2567                 ERR("AVRCP target DBUS handler callback not registered");
2568                 return;
2569         }
2570
2571         g_variant_iter_init(&iter, msg);
2572
2573         _bt_hal_convert_device_path_to_address(path, address);
2574
2575         while (g_variant_iter_loop(&iter, "{sv}", &property, &value)) {
2576                 DBG("Property = %s \n", property);
2577                 if ((strcasecmp(property, "Delay") == 0)) {
2578                         struct hal_ev_avrcp_tg_delay_changed ev;
2579                         uint16_t val;
2580
2581                         memset(&ev, 0, sizeof(ev));
2582                         _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
2583
2584                         val = g_variant_get_uint16(value);
2585                         DBG("Value : %d", val);
2586                         ev.value = val;
2587
2588                         /* Send event to application */
2589                         avrcp_tg_event_cb(HAL_EV_AVRCP_TG_DELAY_CHANGE, &ev, sizeof(ev));
2590                 } else {
2591                         DBG("Property not handled");
2592                 }
2593         }
2594
2595         DBG("-");
2596         g_free((char *)property);
2597         g_variant_unref(value);
2598 }
2599
2600 /* A2DP Src Role(Remote:Sink) Events */
2601 static void __bt_hal_send_av_connection_state_event(gboolean connected, const char *address)
2602 {
2603         DBG("+");
2604         struct hal_ev_a2dp_conn_state ev;
2605
2606         if (connected == TRUE)
2607                 INFO("A2DP(Src) Profile Connected for address [%s]", address);
2608         else
2609                 INFO("A2DP(Src) Profile DisConnected for address [%s]", address);
2610
2611         ev.state = (connected == TRUE) ?
2612                 HAL_EV_A2DP_STATE_CONNECTED :
2613                 HAL_EV_A2DP_STATE_DISCONNECTED;
2614
2615         _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
2616
2617         if (!av_event_cb)
2618                 ERR("AV event handler not registered");
2619         else
2620                 av_event_cb(HAL_EV_A2DP_CONN_STATE, &ev, sizeof(ev));
2621 }
2622
2623 /* A2DP Sink Role(Remote:Source) Events */
2624 static void __bt_hal_send_a2dp_sink_connection_state_event(gboolean connected, const char *address)
2625 {
2626         DBG("+");
2627         struct hal_ev_a2dp_conn_state ev;
2628
2629         if (connected == TRUE)
2630                 INFO("A2DP(Sink) Profile Connected for address [%s]", address);
2631         else
2632                 INFO("A2DP(Sink) Profile DisConnected for address [%s]", address);
2633
2634         ev.state = (connected == TRUE) ?
2635                 HAL_EV_A2DP_STATE_CONNECTED :
2636                 HAL_EV_A2DP_STATE_DISCONNECTED;
2637
2638         _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
2639
2640         if (!a2dp_sink_event_cb)
2641                 ERR("AV event handler not registered");
2642         else
2643                 a2dp_sink_event_cb(HAL_EV_A2DP_SOURCE_CONN_STATE, &ev, sizeof(ev));
2644 }
2645
2646 /* HF(AG Role) Audio Events */
2647 static void __bt_hal_send_hf_audio_connection_state_event(gboolean connected,
2648                                                 const char *address)
2649 {
2650         DBG("+");
2651         struct hal_ev_handsfree_audio_state ev;
2652
2653         if (connected == TRUE)
2654                 INFO("AG Audio Connected for address [%s]", address);
2655         else
2656                 INFO("AG Audio DisConnected for address [%s]", address);
2657
2658         ev.state = (connected == TRUE) ?
2659                 HAL_EV_HANDSFREE_AUDIO_STATE_CONNECTED :
2660                 HAL_EV_HANDSFREE_AUDIO_STATE_DISCONNECTED;
2661
2662         _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
2663
2664         if (!hf_event_cb)
2665                 ERR("HF event handler not registered");
2666         else
2667                 hf_event_cb(HAL_EV_HANDSFREE_AUDIO_STATE, &ev, sizeof(ev));
2668 }
2669
2670 /* HF(AG Role) Profile Events */
2671 static void __bt_hal_send_hf_connection_state_event(gboolean connected,
2672                                                 const char *address)
2673 {
2674         DBG("+");
2675         struct hal_ev_handsfree_conn_state ev;
2676
2677         if (connected == TRUE)
2678                 INFO("AG Profile Connected for address [%s]", address);
2679         else
2680                 INFO("AG Profile DisConnected for address [%s]", address);
2681
2682         ev.state = (connected == TRUE) ?
2683                 HAL_EV_HANDSFREE_CONN_STATE_CONNECTED :
2684                 HAL_EV_HANDSFREE_CONN_STATE_DISCONNECTED;
2685
2686         _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
2687
2688         if (!hf_event_cb)
2689                 ERR("HF event handler not registered");
2690         else
2691                 hf_event_cb(HAL_EV_HANDSFREE_CONN_STATE, &ev, sizeof(ev));
2692 }
2693
2694 /* HF(Client Role) Profile Events */
2695 static void __bt_hal_send_hf_client_connection_state_event(gboolean connected,
2696                                                 const char *address)
2697 {
2698         struct hal_ev_hf_client_conn_state ev;
2699
2700         if (connected == TRUE)
2701                 INFO("HF Client Profile Connected for address [%s]", address);
2702         else
2703                 INFO("HF Client Profile DisConnected for address [%s]", address);
2704
2705         ev.state = (connected == TRUE) ?
2706                 HAL_EV_HF_CLIENT_CONN_STATE_CONNECTED :
2707                 HAL_EV_HF_CLIENT_CONN_STATE_DISCONNECTED;
2708
2709         _bt_hal_convert_addr_string_to_type(ev.bdaddr, address);
2710
2711         if (!hf_client_event_cb)
2712                 ERR("HF Client event handler not registered");
2713         else
2714                 hf_client_event_cb(HAL_EV_HF_CLIENT_CONN_STATE, &ev, sizeof(ev));
2715 }
2716
2717 void _bt_hal_register_event_handler_cb(bt_hal_module_e module, handle_stack_msg cb)
2718 {
2719         switch (module) {
2720         case HAL_HIDHOST:
2721                 hid_event_cb = cb;
2722                 break;
2723         case HAL_HIDDEVICE:
2724                 hid_device_event_cb = cb;
2725                 break;
2726         case HAL_A2DP_SRC:
2727                 av_event_cb = cb;
2728                 break;
2729         case HAL_A2DP_SNK:
2730                 a2dp_sink_event_cb = cb;
2731                 break;
2732         case HAL_HF_AG:
2733                 hf_event_cb = cb;
2734                 break;
2735         case HAL_HF_CLIENT:
2736                 hf_client_event_cb = cb;
2737                 break;
2738         case HAL_AVRCP_TG:
2739                 avrcp_tg_event_cb = cb;
2740                 break;
2741         case HAL_AVRCP_CTRL:
2742                 avrcp_ctrl_event_cb = cb;
2743                 break;
2744         case HAL_GATT:
2745                 gatt_event_cb = cb;
2746                 break;
2747         default:
2748                 ERR("Unknown module: %d", module);
2749         }
2750 }
2751
2752 void _bt_hal_unregister_event_handler_cb(bt_hal_module_e module)
2753 {
2754         switch (module) {
2755         case HAL_HIDHOST:
2756                 hid_event_cb = NULL;
2757                 break;
2758         case HAL_A2DP_SRC:
2759                 av_event_cb = NULL;
2760                 break;
2761         case HAL_A2DP_SNK:
2762                 a2dp_sink_event_cb = NULL;
2763                 break;
2764         case HAL_HF_AG:
2765                 hf_event_cb = NULL;
2766                 break;
2767         case HAL_HF_CLIENT:
2768                 hf_client_event_cb = NULL;
2769                 break;
2770         case HAL_AVRCP_TG:
2771                 avrcp_tg_event_cb = NULL;
2772                 break;
2773         case HAL_AVRCP_CTRL:
2774                 avrcp_ctrl_event_cb = NULL;
2775                 break;
2776         case HAL_GATT:
2777                 gatt_event_cb = NULL;
2778                 break;
2779         default:
2780                 ERR("Unknown module: %d", module);
2781         }
2782 }
2783
2784 bool _bt_hal_get_adapter_request_state(void)
2785 {
2786         return is_adapter_activating;
2787 }
2788
2789 bool _bt_hal_get_le_request_state(void)
2790 {
2791         return is_le_activating;
2792 }
2793
2794 void _bt_hal_set_adapter_request_state(bool enable)
2795 {
2796         DBG("set_adapter_request_state %d", enable);
2797         is_adapter_activating = enable;
2798 }
2799
2800 void _bt_hal_set_le_request_state(bool enable)
2801 {
2802         DBG("set_le_request_state %d", enable);
2803         is_le_activating = enable;
2804 }