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