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

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