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