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