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