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