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

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