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