bt-oal/bluez_hal/src/bt-hal-event-receiver.c

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