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