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