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

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