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

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