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