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

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