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