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

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