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