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