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

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