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