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

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