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

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