X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=bt-service%2Fbt-service-event-receiver.c;h=c8a073176c77d172f063b82a321ce6a6c4015d51;hb=1fa07edcd0e77a445700975773db3300f556caf5;hp=d6f8c3a54f8d6b7c0b1a75b16e8288b1ec0cd42b;hpb=15a8da0024995b8eef2d95dac6f278d03e879c1b;p=platform%2Fcore%2Fconnectivity%2Fbluetooth-frwk.git diff --git a/bt-service/bt-service-event-receiver.c b/bt-service/bt-service-event-receiver.c index d6f8c3a..c8a0731 100644 --- a/bt-service/bt-service-event-receiver.c +++ b/bt-service/bt-service-event-receiver.c @@ -1,11 +1,5 @@ /* - * Bluetooth-frwk - * - * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. - * - * Contact: Hocheol Seo - * Girishashok Joshi - * Chanyeol Park + * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -26,9 +20,6 @@ #include #include #include -#if ENABLE_TIZEN_2_4 -#include -#endif #include "bluetooth-api.h" #include "bt-internal-types.h" @@ -47,9 +38,15 @@ #include "bt-service-pbap.h" #include "bt-service-headset-connection.h" #include "bt-service-avrcp-controller.h" +#include "bt-service-hid.h" +#include "bt-service-proximity.h" #include "bt-service-opp-client.h" +#ifdef TIZEN_DPM_ENABLE +#include "bt-service-dpm.h" +#endif + #define DBUS_TIMEOUT 20 * 1000 /* 20 Sec */ static GDBusConnection *manager_conn; static GDBusConnection *obexd_conn; @@ -58,9 +55,10 @@ static GDBusConnection *opc_obexd_conn; static GList *p_cache_list = NULL; static guint event_id; +static guint session_reinit_timer; guint nap_connected_device_count = 0; static guint hid_connected_device_count = 0; -static GList *p_adv_ind_list; +static GList *p_adv_ind_list = NULL; typedef struct { bt_remote_dev_info_t *dev_info; @@ -76,7 +74,7 @@ typedef enum { OBEX_PBAP = (1 << 4), OBEX_IRMC = (1 << 5), OBEX_PCSUITE = (1 << 6), - OBEX_SYNCEVOLUTION = (1 << 7), + OBEX_SYNCEVOLUTION = (1 << 7), OBEX_MAS = (1 << 8), } bluetooth_obex_connection_type_t; @@ -90,8 +88,14 @@ void _bt_handle_network_client_event(GVariant *msg_iter, void __bt_gatt_char_property_changed_event(GVariant *msg_iter, const char *path); -static void __bt_free_bt_le_adv_info_t(bt_le_adv_info_t *adv_info) +static void __bt_free_bt_le_adv_info_t(gpointer data) { + bt_le_adv_info_t *adv_info = data; + + if (adv_info->timer_id) + g_source_remove(adv_info->timer_id); + adv_info->timer_id = 0; + g_free(adv_info->addr); g_free(adv_info->data); g_free(adv_info); @@ -102,23 +106,25 @@ static bt_le_adv_info_t *__bt_get_adv_ind_info(char *addr) retv_if(!addr, NULL); bt_le_adv_info_t *adv_info = NULL; GList *current = g_list_first((GList *)p_adv_ind_list); - while(current && current->data) { + while (current && current->data) { adv_info = (bt_le_adv_info_t *)current->data; - retv_if(adv_info && !g_strcmp0(adv_info->addr, addr), adv_info); + if (adv_info && !g_strcmp0(adv_info->addr, addr)) + return adv_info; current = g_list_next(current); } return NULL; } -static void __bt_add_adv_ind_info(bt_le_adv_info_t *adv_info) +static int __bt_add_adv_ind_info(bt_le_adv_info_t *adv_info) { - ret_if(!adv_info); + retv_if(!adv_info, -1); if (__bt_get_adv_ind_info(adv_info->addr) != NULL) { - BT_ERR("adv_info is already added"); __bt_free_bt_le_adv_info_t(adv_info); - return; + return -1; } p_adv_ind_list = g_list_append(p_adv_ind_list, adv_info); + + return 0; } static void __bt_del_adv_ind_info(char *addr) @@ -127,7 +133,7 @@ static void __bt_del_adv_ind_info(char *addr) ret_if(!p_adv_ind_list); bt_le_adv_info_t *adv_info = NULL; GList *current = g_list_first((GList *)p_adv_ind_list); - while(current && current->data) { + while (current && current->data) { adv_info = (bt_le_adv_info_t *)current->data; if (adv_info && !g_strcmp0(adv_info->addr, addr)) { p_adv_ind_list = g_list_remove(p_adv_ind_list, adv_info); @@ -138,6 +144,26 @@ static void __bt_del_adv_ind_info(char *addr) } } +static gboolean __bt_adv_scan_req_timeout_cb(gpointer user_data) +{ + bt_remote_le_dev_info_t le_dev_info; + bt_le_adv_info_t *adv_info = (bt_le_adv_info_t*)user_data; + + memset(&le_dev_info, 0x00, sizeof(bt_remote_le_dev_info_t)); + + le_dev_info.address = adv_info->addr; + le_dev_info.addr_type = adv_info->addr_type; + le_dev_info.rssi = adv_info->rssi; + le_dev_info.adv_data = adv_info->data; + le_dev_info.adv_data_len = 0; + adv_info->timer_id = 0; + + _bt_send_scan_result_event(&le_dev_info, adv_info); + __bt_del_adv_ind_info(adv_info->addr); + + return FALSE; +} + static void __bt_free_cache_info(bt_cache_info_t *cache_info) { ret_if(cache_info == NULL); @@ -165,7 +191,7 @@ static gboolean __bt_parse_device_properties(GVariant *item, if (dev_info->name == NULL) dev_info->name = g_variant_dup_string(val, &len); } else if (strcasecmp(key, "Connected") == 0) { - dev_info->connected = g_variant_get_uint32(val); + dev_info->connected = g_variant_get_byte(val); } else if (strcasecmp(key, "paired") == 0) { dev_info->paired = g_variant_get_boolean(val); } else if (strcasecmp(key, "Trusted") == 0) { @@ -177,7 +203,7 @@ static gboolean __bt_parse_device_properties(GVariant *item, } else if (strcasecmp(key, "UUIDs") == 0) { char **uuid_value; gsize size = 0; - int i =0; + int i = 0; size = g_variant_get_size(val); if (size > 0) { @@ -191,8 +217,8 @@ static gboolean __bt_parse_device_properties(GVariant *item, } g_free(uuid_value); } - } else if (strcasecmp(key, "ManufacturerDataLen") == 0) { - g_variant_get(val, "(i)", &dev_info->manufacturer_data_len); + } else if (strcasecmp(key, "LegacyManufacturerDataLen") == 0) { + g_variant_get(val, "q", &dev_info->manufacturer_data_len); if (dev_info->manufacturer_data_len > BLUETOOTH_MANUFACTURER_DATA_LENGTH_MAX) { BT_ERR("manufacturer_data_len is too long(len = %d)", dev_info->manufacturer_data_len); dev_info->manufacturer_data_len = BLUETOOTH_MANUFACTURER_DATA_LENGTH_MAX; @@ -200,18 +226,22 @@ static gboolean __bt_parse_device_properties(GVariant *item, if (dev_info->manufacturer_data_len == 0) dev_info->manufacturer_data = g_strdup(""); - } else if (strcasecmp(key, "ManufacturerData") == 0) { + } else if (strcasecmp(key, "LegacyManufacturerData") == 0) { + int i = 0; int len = 0; - GVariant *manufacturer_var; - g_variant_get(val, "@ay", &manufacturer_var); - len = g_variant_get_size(manufacturer_var); - if (len > 0) { - char *manufacturer_data = (char *)g_variant_get_data(manufacturer_var); - dev_info->manufacturer_data = g_malloc0(len); - memcpy(dev_info->manufacturer_data, manufacturer_data, - len); - } - g_variant_unref(manufacturer_var); + GVariantIter *value_iter; + guint8 m_value; + + len = g_variant_get_size(val); + if (len <= 0) + continue; + + dev_info->manufacturer_data = g_malloc0(len); + + g_variant_get(val, "ay", &value_iter); + while (g_variant_iter_loop(value_iter, "y", &m_value)) + dev_info->manufacturer_data[i++] = m_value; + g_variant_iter_free(value_iter); } } @@ -223,17 +253,19 @@ static gboolean __bt_parse_interface(GVariant *msg, bt_remote_dev_info_t *dev_info) { char *path = NULL; - GVariant *optional_param; + GVariant *optional_param = NULL; GVariantIter iter; GVariant *child; - char *interface_name= NULL; + char *interface_name = NULL; GVariant *inner_iter = NULL; g_variant_get(msg, "(&o@a{sa{sv}})", &path, &optional_param); g_variant_iter_init(&iter, optional_param); + retv_if(optional_param == NULL, FALSE); + while ((child = g_variant_iter_next_value(&iter))) { - g_variant_get(child,"{&s@a{sv}}", &interface_name, &inner_iter); + g_variant_get(child, "{&s@a{sv}}", &interface_name, &inner_iter); if (g_strcmp0(interface_name, BT_DEVICE_INTERFACE) == 0) { BT_DBG("Found a device: %s", path); if (__bt_parse_device_properties(inner_iter, @@ -251,10 +283,10 @@ static gboolean __bt_parse_interface(GVariant *msg, } } g_variant_unref(inner_iter); - g_variant_unref(child); + g_variant_unref(child); } - if (optional_param) - g_variant_unref(optional_param); + + g_variant_unref(optional_param); return FALSE; } @@ -262,7 +294,7 @@ static gboolean __bt_parse_interface(GVariant *msg, static int __bt_get_owner_info(GVariant *msg, char **name, char **previous, char **current) { - g_variant_get(msg, "(sss)", name, previous, current); + g_variant_get(msg, "(&s&s&s)", name, previous, current); return BLUETOOTH_ERROR_NONE; } @@ -277,18 +309,16 @@ void __bt_set_device_values(gboolean connected, int state) { int bt_device_state = VCONFKEY_BT_DEVICE_NONE; - if (vconf_get_int(VCONFKEY_BT_DEVICE, &bt_device_state) != 0) { + if (vconf_get_int(VCONFKEY_BT_DEVICE, &bt_device_state) != 0) BT_ERR("vconf_get_int failed"); - } if (connected == TRUE) bt_device_state |= state; else if (bt_device_state & state) bt_device_state ^= state; - if (vconf_set_int(VCONFKEY_BT_DEVICE, bt_device_state) != 0) { + if (vconf_set_int(VCONFKEY_BT_DEVICE, bt_device_state) != 0) BT_ERR("vconf_set_int failed"); - } } gboolean _bt_discovery_finished_cb(gpointer user_data) @@ -297,9 +327,8 @@ gboolean _bt_discovery_finished_cb(gpointer user_data) event_id = 0; GVariant *param = NULL; if (_bt_get_discovering_property(DISCOVERY_ROLE_BREDR) == FALSE) { - if (_bt_get_cancel_by_user() == TRUE) { + if (_bt_get_cancel_by_user() == TRUE) result = BLUETOOTH_ERROR_CANCEL_BY_USER; - } _bt_set_cancel_by_user(FALSE); _bt_set_discovery_status(FALSE); @@ -318,11 +347,14 @@ static gboolean __bt_le_discovery_finished_cb(gpointer user_data) event_id = 0; GVariant *param = NULL; if (_bt_get_discovering_property(DISCOVERY_ROLE_LE) == FALSE) { - if (_bt_get_cancel_by_user() == TRUE) { + if (_bt_get_cancel_by_user() == TRUE) result = BLUETOOTH_ERROR_CANCEL_BY_USER; - } + + g_list_free_full(p_adv_ind_list, __bt_free_bt_le_adv_info_t); + p_adv_ind_list = NULL; _bt_set_cancel_by_user(FALSE); + _bt_disable_all_scanner_status(); _bt_set_le_scan_status(FALSE); param = g_variant_new("(i)", result); _bt_send_event(BT_LE_ADAPTER_EVENT, @@ -345,7 +377,7 @@ void __bt_update_remote_cache_devinfo(const char *address, gboolean paired_statu node = g_list_first(p_cache_list); - while (node != NULL){ + while (node != NULL) { cache_info = (bt_cache_info_t *)node->data; if (cache_info == NULL) { @@ -377,10 +409,10 @@ static void __bt_device_remote_connected_properties( GVariant *param = NULL; BT_DBG("+"); - if (remote_dev_info->uuid_count > 0 ) { - for (i = 0; iuuid_count; i++) { + if (remote_dev_info->uuid_count > 0) { + for (i = 0; i < remote_dev_info->uuid_count; i++) { char *uuid = remote_dev_info->uuids[i]; - if (strcasecmp(uuid, HID_UUID) == 0){ + if (strcasecmp(uuid, HID_UUID) == 0) { int event = BLUETOOTH_EVENT_NONE; event = (connected == TRUE) ? @@ -419,7 +451,7 @@ void _bt_handle_adapter_event(GVariant *msg, const char *member) g_variant_get(msg, "(&o)", &object_path); _bt_convert_device_path_to_address((const char*)object_path, address); - remote_dev_info = _bt_get_remote_device_info(address); + remote_dev_info = _bt_get_remote_device_info_by_object_path(object_path); if (remote_dev_info == NULL) { g_free(address); return; @@ -436,17 +468,14 @@ void _bt_handle_adapter_event(GVariant *msg, const char *member) /* Bonding from remote device */ address = g_malloc0(BT_ADDRESS_STRING_SIZE); - g_variant_get(msg, "(&o)", &object_path); - /* Fix : NULL_RETURNS */ - if (address == NULL) - return; + g_variant_get(msg, "(&o)", &object_path); _bt_convert_device_path_to_address((const char *)object_path, address); node = g_list_first(p_cache_list); - while (node != NULL){ + while (node != NULL) { cache_info = (bt_cache_info_t *)node->data; if (cache_info == NULL) { @@ -468,7 +497,6 @@ void _bt_handle_adapter_event(GVariant *msg, const char *member) } else if (strcasecmp(member, "AdvertisingEnabled") == 0) { BT_DBG("Advertising Enabled"); int slot_id; - const char *sender; int event; int adv_handle; gboolean status = FALSE; @@ -480,7 +508,6 @@ void _bt_handle_adapter_event(GVariant *msg, const char *member) /* Send event to application */ _bt_set_advertising_status(slot_id, status); - sender = _bt_get_adv_slot_owner(slot_id); adv_handle = _bt_get_adv_slot_adv_handle(slot_id); if (status) @@ -489,18 +516,25 @@ void _bt_handle_adapter_event(GVariant *msg, const char *member) event = BLUETOOTH_EVENT_ADVERTISING_STOPPED; param = g_variant_new("(ii)", result, adv_handle); + +#if 0 + const char *sender; + sender = _bt_get_adv_slot_owner(slot_id); _bt_send_event_to_dest(sender, BT_ADAPTER_EVENT, event, param); +#else + _bt_send_event(BT_ADAPTER_EVENT, event, param); +#endif if (event == BLUETOOTH_EVENT_ADVERTISING_STOPPED) - __bt_unregister_adv_slot_owner(slot_id); + _bt_unregister_adv_slot_owner(slot_id); } else if (strcasecmp(member, "RssiEnabled") == 0) { BT_DBG("RSSI Enabled"); gboolean status = FALSE; char *address = NULL; int link_type; - g_variant_get(msg,"(sib)", &address, &link_type, &status); + g_variant_get(msg, "(sib)", &address, &link_type, &status); BT_DBG("RSSI Enabled [%s %d]", address, status); param = g_variant_new("(isib)", result, @@ -515,7 +549,7 @@ void _bt_handle_adapter_event(GVariant *msg, const char *member) int rssi_dbm; int link_type; char *address = NULL; - g_variant_get(msg,"(siii)", &address, &link_type, &alert_type, &rssi_dbm); + g_variant_get(msg, "(siii)", &address, &link_type, &alert_type, &rssi_dbm); BT_DBG("RSSI Alert: [Address %s LinkType %d] [Type %d DBM %d]", address, alert_type, rssi_dbm); @@ -530,7 +564,7 @@ void _bt_handle_adapter_event(GVariant *msg, const char *member) int rssi_dbm; int link_type; char *address = NULL; - g_variant_get(msg,"(sii)", &address, &link_type, &rssi_dbm); + g_variant_get(msg, "(sii)", &address, &link_type, &rssi_dbm); BT_DBG("Raw RSSI: [Address %s] [Link Type %d][RSSI DBM %d]", address, link_type, rssi_dbm); @@ -541,11 +575,17 @@ void _bt_handle_adapter_event(GVariant *msg, const char *member) param); g_free(address); } else if (strcasecmp(member, BT_HARDWARE_ERROR) == 0) { - BT_ERR_C("Hardware error received from BLUEZ"); + BT_ERR_C("### Hardware error received from BLUEZ"); +/* Don't add the recovery logic into platform */ +#if 0 _bt_recover_adapter(); +#endif } else if (strcasecmp(member, BT_TX_TIMEOUT_ERROR) == 0) { - BT_ERR_C("Tx timeout error received from BLUEZ"); + BT_ERR_C("### Tx timeout error received from BLUEZ"); +/* Don't add the recovery logic into platform */ +#if 0 _bt_recover_adapter(); +#endif } BT_DBG("-"); } @@ -557,18 +597,25 @@ static void __bt_adapter_property_changed_event(GVariant *msg, const char *path) int result = BLUETOOTH_ERROR_NONE; GVariantIter value_iter; GVariant *val = NULL; + GVariant *ret = NULL; GError *err = NULL; char *property = NULL; GVariant *param = NULL; - g_variant_iter_init (&value_iter, msg); - while ((g_variant_iter_loop (&value_iter,"{sv}", &property, &val))) { + + g_variant_iter_init(&value_iter, msg); + while ((g_variant_iter_loop(&value_iter, "{sv}", &property, &val))) { BT_INFO("Property %s", property); if (strcasecmp(property, "Discovering") == 0) { gboolean discovering = FALSE; + + if (_bt_adapter_get_status() != BT_ACTIVATED) + continue; + g_variant_get(val, "b", &discovering); - /* Send event to application */ BT_DBG("Discovering %d", discovering); + + /* Send event to application */ if (discovering == TRUE) { _bt_set_discovery_status(TRUE); param = g_variant_new("(i)", result); @@ -576,13 +623,15 @@ static void __bt_adapter_property_changed_event(GVariant *msg, const char *path) BLUETOOTH_EVENT_DISCOVERY_STARTED, param); } else { - ret_if(event_id > 0); + if (event_id > 0) + continue; adapter_proxy = _bt_get_adapter_proxy(); - ret_if(adapter_proxy == NULL); + if (adapter_proxy == NULL) + continue; /* Need to stop searching */ - g_dbus_proxy_call_sync(adapter_proxy, "StopDiscovery", + ret = g_dbus_proxy_call_sync(adapter_proxy, "StopDiscovery", NULL, G_DBUS_CALL_FLAGS_NONE, DBUS_TIMEOUT, NULL, @@ -591,6 +640,8 @@ static void __bt_adapter_property_changed_event(GVariant *msg, const char *path) BT_ERR("Dbus Error : %s", err->message); g_clear_error(&err); } + if (ret) + g_variant_unref(ret); event_id = g_timeout_add(BT_DISCOVERY_FINISHED_DELAY, (GSourceFunc)_bt_discovery_finished_cb, NULL); @@ -598,7 +649,13 @@ static void __bt_adapter_property_changed_event(GVariant *msg, const char *path) } else if (strcasecmp(property, "LEDiscovering") == 0) { gboolean le_discovering = FALSE; + if (_bt_adapter_get_status() != BT_ACTIVATED || + _bt_adapter_get_le_status() != BT_LE_ACTIVATED) + continue; + g_variant_get(val, "b", &le_discovering); + BT_DBG("LEDiscovering %d", le_discovering); + /* Send event to application */ if (le_discovering == TRUE) { _bt_set_le_scan_status(TRUE); @@ -607,13 +664,15 @@ static void __bt_adapter_property_changed_event(GVariant *msg, const char *path) BLUETOOTH_EVENT_LE_DISCOVERY_STARTED, param); } else { - ret_if(event_id > 0); + if (event_id > 0) + continue; adapter_proxy = _bt_get_adapter_proxy(); - ret_if(adapter_proxy == NULL); + if (adapter_proxy == NULL) + continue; /* Need to stop searching */ - g_dbus_proxy_call_sync(adapter_proxy, "StopLEDiscovery", + ret = g_dbus_proxy_call_sync(adapter_proxy, "StopLEDiscovery", NULL, G_DBUS_CALL_FLAGS_NONE, DBUS_TIMEOUT, NULL, @@ -622,28 +681,28 @@ static void __bt_adapter_property_changed_event(GVariant *msg, const char *path) BT_ERR("Dbus Error %s", err->message); g_clear_error(&err); } + if (ret) + g_variant_unref(ret); event_id = g_timeout_add(BT_DISCOVERY_FINISHED_DELAY, (GSourceFunc)__bt_le_discovery_finished_cb, NULL); } } else if (strcasecmp(property, "Name") == 0) { char *name = NULL; - g_variant_get(val, "s", &name); + g_variant_get(val, "&s", &name); param = g_variant_new("(is)", result, name); /* Send event to application */ _bt_send_event(BT_ADAPTER_EVENT, BLUETOOTH_EVENT_LOCAL_NAME_CHANGED, param); - g_free(name); } else if (strcasecmp(property, "Alias") == 0) { char *alias = NULL; - g_variant_get(val, "s", &alias); + g_variant_get(val, "&s", &alias); param = g_variant_new("(is)", result, alias); /* Send event to application */ _bt_send_event(BT_ADAPTER_EVENT, BLUETOOTH_EVENT_LOCAL_NAME_CHANGED, param); - g_free(alias); } else if (strcasecmp(property, "Discoverable") == 0) { gboolean discoverable = FALSE; @@ -652,27 +711,32 @@ static void __bt_adapter_property_changed_event(GVariant *msg, const char *path) if (discoverable == FALSE) { if (_bt_get_discoverable_timeout_property() > 0) { - int time = 0; + unsigned int time = 0; + adapter_proxy = _bt_get_adapter_properties_proxy(); - ret_if(adapter_proxy == NULL); - g_dbus_proxy_call_sync(adapter_proxy, "Set", - g_variant_new("(ssv)", BT_ADAPTER_INTERFACE, + if (adapter_proxy == NULL) + continue; + + ret = g_dbus_proxy_call_sync(adapter_proxy, "Set", + g_variant_new("(ssv)", BT_ADAPTER_INTERFACE, "DiscoverableTimeout", - g_variant_new("i", time)), - G_DBUS_CALL_FLAGS_NONE, - DBUS_TIMEOUT, NULL, - &err); + g_variant_new("u", time)), + G_DBUS_CALL_FLAGS_NONE, + DBUS_TIMEOUT, NULL, + &err); if (err != NULL) { - BT_ERR("StopLEDiscovery Failed: %s", err->message); - g_error_free(err); + BT_ERR("Set DiscoverableTimeout Failed: %s", err->message); + g_clear_error(&err); } + if (ret) + g_variant_unref(ret); } mode = BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE; /* Send event to application */ - BT_INFO("[Connectable]"); + BT_INFO("[Non Discoverable]"); param = g_variant_new("(in)", result, mode); _bt_send_event(BT_ADAPTER_EVENT, BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED, @@ -699,11 +763,8 @@ static void __bt_adapter_property_changed_event(GVariant *msg, const char *path) /* Event was already sent by "Discoverable" signal */ if (mode == BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE || - mode == BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE) { - g_free(property); - g_variant_unref(val); - return; - } + mode == BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE) + continue; /* Send event to application */ BT_INFO("[Limited Discoverable (Timeout %u secs)]", @@ -713,24 +774,36 @@ static void __bt_adapter_property_changed_event(GVariant *msg, const char *path) BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED, param); } else if (strcasecmp(property, "Powered") == 0) { - /* TODO: Need to check this operation!! */ gboolean powered = FALSE; - int bt_state; + int bt_state = VCONFKEY_BT_STATUS_OFF; + int le_state = VCONFKEY_BT_LE_STATUS_OFF; - g_variant_get(val, "b" ,&powered); + g_variant_get(val, "b", &powered); BT_DBG("Powered = %d", powered); - if (powered == FALSE) { - if (vconf_get_int(VCONFKEY_BT_STATUS, &bt_state) == 0 && - bt_state != VCONFKEY_BT_STATUS_OFF) { - _bt_disable_adapter(); - } -#ifdef ENABLE_TIZEN_2_4 - if (vconf_get_int(VCONFKEY_BT_LE_STATUS, &bt_state) == 0 && - bt_state != VCONFKEY_BT_LE_STATUS_OFF) { - _bt_set_le_disabled(BLUETOOTH_ERROR_NONE); - } -#endif + +#ifdef USB_BLUETOOTH + if (powered) { + _bt_handle_adapter_added(); + continue; } + + _bt_handle_adapter_removed(); + + vconf_get_int(VCONFKEY_BT_LE_STATUS, &le_state); + if (le_state != VCONFKEY_BT_LE_STATUS_OFF) + _bt_set_le_disabled(BLUETOOTH_ERROR_NONE); +#else + if (powered) + continue; + + vconf_get_int(VCONFKEY_BT_STATUS, &bt_state); + if (bt_state != VCONFKEY_BT_STATUS_OFF) + _bt_disable_adapter(); + + vconf_get_int(VCONFKEY_BT_LE_STATUS, &le_state); + if (le_state != VCONFKEY_BT_LE_STATUS_OFF) + _bt_set_le_disabled(BLUETOOTH_ERROR_NONE); +#endif } else if (strcasecmp(property, "Connectable") == 0) { gboolean connectable = FALSE; @@ -741,26 +814,41 @@ static void __bt_adapter_property_changed_event(GVariant *msg, const char *path) _bt_send_event(BT_ADAPTER_EVENT, BLUETOOTH_EVENT_CONNECTABLE_CHANGED, param); +#if 0 if (_bt_adapter_get_status() == BT_DEACTIVATING && _bt_adapter_get_le_status() == BT_LE_ACTIVATED && connectable == 0) _bt_set_disabled(BLUETOOTH_ERROR_NONE); +#endif } else if (strcasecmp(property, "SupportedLEFeatures") == 0) { char *name = NULL; char *value = NULL; GVariantIter *iter = NULL; + g_variant_get(val, "as", &iter); - while (g_variant_iter_loop(iter, "s", &name)) { - BT_DBG("name = %s", name); - g_variant_iter_loop(iter, "s", &value); - BT_DBG("Value = %s", value); - if (FALSE == _bt_update_le_feature_support(name, value)) - BT_INFO("Fail to update LE feature info"); + if (iter == NULL) + continue; + + while (g_variant_iter_next(iter, "&s", &name) && + g_variant_iter_next(iter, "&s", &value)) { + BT_DBG("name = %s, Value = %s", name, value); + if (!_bt_update_le_feature_support(name, value)) + BT_ERR("Failed to update LE feature (name = %s, value = %s)", name, value); } - if (iter) - g_variant_iter_free(iter); + g_variant_iter_free(iter); + } else if (strcasecmp(property, "IpspInitStateChanged") == 0) { + gboolean ipsp_initialized = FALSE; + + g_variant_get(val, "b", &ipsp_initialized); + BT_DBG("IPSP init state changed: %d", ipsp_initialized); + param = g_variant_new("(b)", ipsp_initialized); + + /* Send event to application */ + _bt_send_event(BT_ADAPTER_EVENT, + BLUETOOTH_EVENT_IPSP_INIT_STATE_CHANGED, + param); } else { - BT_DBG("property : [%s]", property); + BT_DBG("Unhandled property : [%s]", property); } } } @@ -772,8 +860,8 @@ static void __bt_obex_property_changed_event(GVariant *msg, const char *path) GVariantIter value_iter; GVariant *child = NULL, *val = NULL; char *property = NULL; - g_variant_iter_init (&value_iter, msg); - while ((child = g_variant_iter_next_value (&value_iter))) { + g_variant_iter_init(&value_iter, msg); + while ((child = g_variant_iter_next_value(&value_iter))) { g_variant_get(child, "{sv}", &property, &val); ret_if(property == NULL); @@ -784,21 +872,25 @@ static void __bt_obex_property_changed_event(GVariant *msg, const char *path) char *status; g_variant_get(val, "s", &status); - if (strcasecmp(status, "active") == 0){ + if (strcasecmp(status, "active") == 0) { _bt_obex_transfer_started(path); } else if (strcasecmp(status, "complete") == 0) { _bt_obex_transfer_completed(path, TRUE); _bt_pbap_obex_transfer_completed(path, TRUE); - } else if (strcasecmp(status, "error") == 0){ + } else if (strcasecmp(status, "error") == 0) { _bt_obex_transfer_completed(path, FALSE); _bt_pbap_obex_transfer_completed(path, FALSE); } g_free(status); } else if (strcasecmp(property, "Transferred") == 0) { - static int transferred = 0; + guint64 transferred = 0; + /* As Transferred is expected guint64 so change int to guint64 and + * eariler transferred is static because of it can overwrite data + * on present on opc_obex_conn or obexd_conn as these are + * static memory are in sequential */ g_variant_get(val, "t", &transferred); - _bt_obex_transfer_progress(path,transferred); + _bt_obex_transfer_progress(path, transferred); } g_free(property); g_variant_unref(val); @@ -819,7 +911,7 @@ static void __bt_device_property_changed_event(GVariant *msg, const char *path) char *address; GVariant *param = NULL; bt_remote_dev_info_t *remote_dev_info; - g_variant_iter_init (&value_iter, msg); + g_variant_iter_init(&value_iter, msg); while ((g_variant_iter_loop(&value_iter, "{sv}", &property, &val))) { BT_DBG("Property %s", property); if (strcasecmp(property, "Connected") == 0) { @@ -838,7 +930,7 @@ static void __bt_device_property_changed_event(GVariant *msg, const char *path) BT_DBG("connected: %d", connected); BT_DBG("address: %s", address); - remote_dev_info = _bt_get_remote_device_info(address); + remote_dev_info = _bt_get_remote_device_info_by_object_path(path); if (remote_dev_info != NULL) { __bt_device_remote_connected_properties( @@ -861,7 +953,7 @@ static void __bt_device_property_changed_event(GVariant *msg, const char *path) _bt_convert_device_path_to_address(path, address); BT_DBG("address: %s", address); - remote_dev_info = _bt_get_remote_device_info(address); + remote_dev_info = _bt_get_remote_device_info_by_object_path(path); if (remote_dev_info == NULL) { g_free(property); g_variant_unref(val); @@ -870,14 +962,31 @@ static void __bt_device_property_changed_event(GVariant *msg, const char *path) } BT_DBG("Address type %d", remote_dev_info->addr_type); - if (remote_dev_info && remote_dev_info->addr_type == 0) { + if (remote_dev_info->addr_type == 0) { BT_DBG("Name %s", remote_dev_info->name); +#ifdef TIZEN_DPM_ENABLE + if (_bt_dpm_get_bluetooth_desktop_connectivity_state() == + DPM_RESTRICTED) { + bluetooth_device_class_t device_class; + _bt_divide_device_class(&device_class, remote_dev_info->class); + + if (device_class.major_class == + BLUETOOTH_DEVICE_MAJOR_CLASS_COMPUTER) { + _bt_free_device_info(remote_dev_info); + g_free(property); + g_variant_unref(val); + g_free(address); + return; + } + } +#endif + GVariant *uuids = NULL; GVariantBuilder *builder = NULL; int i = 0; builder = g_variant_builder_new(G_VARIANT_TYPE("as")); - for (i=0; i < remote_dev_info->uuid_count; i++) { + for (i = 0; i < remote_dev_info->uuid_count; i++) { g_variant_builder_add(builder, "s", remote_dev_info->uuids[i]); } @@ -946,7 +1055,7 @@ static void __bt_device_property_changed_event(GVariant *msg, const char *path) _bt_convert_device_path_to_address(path, address); - remote_dev_info = _bt_get_remote_device_info(address); + remote_dev_info = _bt_get_remote_device_info_by_object_path(path); if (remote_dev_info == NULL) { g_free(property); g_variant_unref(val); @@ -954,30 +1063,35 @@ static void __bt_device_property_changed_event(GVariant *msg, const char *path) return; } - if(paired == FALSE) { + if (paired == FALSE) { BT_INFO("Unpaired: %s", address); __bt_update_remote_cache_devinfo(address, FALSE); param = g_variant_new("(is)", result, address); _bt_send_event(BT_ADAPTER_EVENT, BLUETOOTH_EVENT_BONDED_DEVICE_REMOVED, param); +#ifdef TIZEN_BT_A2DP_SINK_AUTO_CONNECT + { + char *last_connected = NULL; + last_connected = vconf_get_str(BT_LAST_CONNECTED_DEVICE); + if (!g_strcmp0(address, last_connected)) + _bt_audio_set_auto_connect_device_addr(""); + if (last_connected) + free(last_connected); + } +#endif } else { - BT_INFO("Paired: %s", address); + char secure_addr[BT_ADDRESS_STRING_SIZE] = { 0 }; + + _bt_convert_addr_string_to_secure_string(secure_addr, address); + BT_INFO(" ### Paired: %s", secure_addr); __bt_update_remote_cache_devinfo(address, TRUE); - if (_bt_is_device_creating() == TRUE) { - BT_DBG("Try to Pair by me"); - _bt_free_device_info(remote_dev_info); - g_free(address); - g_free(property); - g_variant_unref(val); - return; - } GVariant *uuids = NULL; GVariantBuilder *builder = NULL; int i = 0; builder = g_variant_builder_new(G_VARIANT_TYPE("as")); - for (i=0; i < remote_dev_info->uuid_count; i++) { + for (i = 0; i < remote_dev_info->uuid_count; i++) { g_variant_builder_add(builder, "s", remote_dev_info->uuids[i]); } @@ -1009,6 +1123,7 @@ static void __bt_device_property_changed_event(GVariant *msg, const char *path) } else if (strcasecmp(property, "LegacyPaired") == 0) { gboolean paired = FALSE; bt_remote_dev_info_t *remote_dev_info; + unsigned char auth_info[5] = {0, }; if (_bt_adapter_get_status() != BT_ACTIVATED) { BT_DBG("BT is not activated, so ignore this"); @@ -1022,18 +1137,30 @@ static void __bt_device_property_changed_event(GVariant *msg, const char *path) BT_DBG("LegacyPaired: %d", paired); _bt_convert_device_path_to_address(path, address); - remote_dev_info = _bt_get_remote_device_info(address); + remote_dev_info = _bt_get_remote_device_info_by_object_path(path); if (remote_dev_info == NULL) { g_free(address); g_free(property); g_variant_unref(val); return; } + if (remote_dev_info->is_alias_set == FALSE) { + /*minimum Size of the samsung specific manufacturer data is greater than 30 */ + if ((remote_dev_info->manufacturer_data_len > 30) && + (remote_dev_info->manufacturer_data[0] == 0x00) && + (remote_dev_info->manufacturer_data[1] == 0x75)) { + + /* 2 samsung (0x00 0x75) + 1 (control and version) + 1 (service ID) + + 1 (discovery version) + 1 (associated service ID) + 2 (Proxamity and locality) + 2 (Device type and icon) = 10 */ + + memcpy(auth_info, &(remote_dev_info->manufacturer_data[10]), 5); + } + } - BT_DBG("LegacyPairing Failed with %s. Show Error Popup", - remote_dev_info->name); + BT_DBG("LegacyPairing Failed with %s. Show Error Popup", remote_dev_info->name); _bt_launch_system_popup(BT_AGENT_EVENT_LEGACY_PAIR_FAILED_FROM_REMOTE, - remote_dev_info->name, NULL, NULL, NULL); + remote_dev_info->name, auth_info, NULL, NULL, NULL); _bt_free_device_info(remote_dev_info); g_free(address); @@ -1057,6 +1184,59 @@ static void __bt_device_property_changed_event(GVariant *msg, const char *path) event, param); g_free(address); + } else if (strcasecmp(property, "TrustedProfiles") == 0) { + int trusted = 0; + + g_variant_get(val, "u", &trusted); + + address = g_malloc0(BT_ADDRESS_STRING_SIZE); + _bt_convert_device_path_to_address(path, address); + + BT_DBG("Address: %s, TrustedProfiles: %d", address, trusted); + _bt_send_event(BT_DEVICE_EVENT, + BLUETOOTH_EVENT_SUPPORTED_PROFILE_TRUSTED, + g_variant_new("(isi)", result, address, trusted)); + g_free(address); + } else if (strcasecmp(property, "IpspConnected") == 0) { + gboolean connected = FALSE; + + g_variant_get(val, "b", &connected); + + + event = connected ? BLUETOOTH_EVENT_IPSP_CONNECTED : + BLUETOOTH_EVENT_IPSP_DISCONNECTED; + + address = g_malloc0(BT_ADDRESS_STRING_SIZE); + + _bt_convert_device_path_to_address(path, address); + + BT_DBG("Ipspconnected: %d", connected); + BT_DBG("address: %s", address); + param = g_variant_new("(is)", result, address); + + /* Send event to application */ + _bt_send_event(BT_DEVICE_EVENT, + event, + param); + g_free(address); + } else if (strcasecmp(property, "IpspBtInterfaceInfo") == 0) { + char *ifname = NULL; + + g_variant_get(val, "s", &ifname); + + address = g_malloc0(BT_ADDRESS_STRING_SIZE); + + _bt_convert_device_path_to_address(path, address); + + BT_DBG("Ipsp BT Interface Name: %s", ifname); + BT_DBG("address: %s", address); + param = g_variant_new("(iss)", result, address, ifname); + + /* Send event to application */ + _bt_send_event(BT_DEVICE_EVENT, + BLUETOOTH_EVENT_IPSP_INTERFACE_INFO, + param); + g_free(address); } } BT_DBG("-"); @@ -1073,8 +1253,8 @@ static void __bt_media_control_changed_event(GVariant *msg, const char *path) GVariant *child = NULL; bt_remote_dev_info_t *remote_dev_info; GVariant *param = NULL; - g_variant_iter_init (&value_iter, msg); - while ((child = g_variant_iter_next_value (&value_iter))) { + g_variant_iter_init(&value_iter, msg); + while ((child = g_variant_iter_next_value(&value_iter))) { g_variant_get(child, "{sv}", &property, &val); BT_INFO("Property %s", property); if (strcasecmp(property, "Connected") == 0) { @@ -1113,18 +1293,82 @@ static void __bt_media_control_changed_event(GVariant *msg, const char *path) BT_DBG("-"); } +int get_alert_level_enum(const char *alert) +{ + int lvl = -1; + + if (strcmp(alert, "none") == 0) + lvl = BT_PXP_ALERT_NONE; + else if (strcmp(alert, "mild") == 0) + lvl = BT_PXP_ALERT_MILD; + else if (strcmp(alert, "high") == 0) + lvl = BT_PXP_ALERT_HIGH; + + return lvl; +} + +static void _bt_handle_pxp_property_changed_event(GVariant *msg, const char *path, int role) +{ + int result = BLUETOOTH_ERROR_NONE; + int service_type; + int alert_lvl; + GVariantIter value_iter; + char *property = NULL; + char *address; + GVariant *val = NULL; + GVariant *child = NULL; + GVariant *param = NULL; + g_variant_iter_init(&value_iter, msg); + + BT_DBG("+"); + while ((child = g_variant_iter_next_value(&value_iter))) { + g_variant_get(child, "{sv}", &property, &val); + BT_INFO("Property %s", property); + + if ((strcasecmp(property, "LinkLossAlertLevel") == 0) || + (strcasecmp(property, "ImmediateAlertLevel") == 0)) { + char *alert_str = NULL; + + address = g_malloc0(BT_ADDRESS_STRING_SIZE); + _bt_convert_device_path_to_address(path, address); + + if (strcasecmp(property, "LinkLossAlertLevel") == 0) + service_type = BT_PXP_PROPERTY_LLS; + else + service_type = BT_PXP_PROPERTY_IAS; + + g_variant_get(val, "s", &alert_str); + alert_lvl = get_alert_level_enum(alert_str); + + param = g_variant_new("(isiii)", result, address, + role, service_type, alert_lvl); + + /* Send event to application */ + _bt_send_event(BT_DEVICE_EVENT, + BLUETOOTH_EVENT_PXP_PROPERTY_CHANGED, + param); + g_free(address); + g_free(alert_str); + } + g_free(property); + g_variant_unref(child); + g_variant_unref(val); + } + BT_DBG("-"); +} + void _bt_handle_property_changed_event(GVariant *msg, const char *object_path) { char *interface_name = NULL; GVariant *val = NULL; - g_variant_get(msg, "(&s@a{sv}@as)", &interface_name, &val,NULL); + g_variant_get(msg, "(&s@a{sv}@as)", &interface_name, &val, NULL); if (strcasecmp(interface_name, BT_ADAPTER_INTERFACE) == 0) { __bt_adapter_property_changed_event(val, object_path); } else if (strcasecmp(interface_name, BT_DEVICE_INTERFACE) == 0) { - __bt_device_property_changed_event(val,object_path); + __bt_device_property_changed_event(val, object_path); } else if (strcasecmp(interface_name, BT_OBEX_TRANSFER_INTERFACE) == 0) { BT_DBG("BT_OBEX_TRANSFER_INTERFACE"); __bt_obex_property_changed_event(val, @@ -1142,6 +1386,14 @@ void _bt_handle_property_changed_event(GVariant *msg, const char *object_path) } else if (strcasecmp(interface_name, BT_GATT_CHAR_INTERFACE) == 0) { __bt_gatt_char_property_changed_event(val, object_path); + } else if (strcasecmp(interface_name, BT_PROXIMITY_REPORTER_INTERFACE) == 0) { + BT_DBG("BT_PROXIMITY_REPORTER_INTERFACE"); + _bt_handle_pxp_property_changed_event(val, + object_path, BT_PXP_REPORTER_ROLE); + } else if (strcasecmp(interface_name, BT_PROXIMITY_MONITOR_INTERFACE) == 0) { + BT_DBG("BT_PROXIMITY_MONITOR_INTERFACE"); + _bt_handle_pxp_property_changed_event(val, + object_path, BT_PXP_MONITOR_ROLE); } g_variant_unref(val); } @@ -1154,8 +1406,8 @@ void __bt_opc_property_changed_event(GVariant *msg, GVariant *val = NULL; GVariant *child = NULL; - g_variant_iter_init (&value_iter, msg); - while ((child = g_variant_iter_next_value (&value_iter))) { + g_variant_iter_init(&value_iter, msg); + while ((child = g_variant_iter_next_value(&value_iter))) { g_variant_get(child, "{sv}", &property, &val); ret_if(property == NULL); @@ -1164,16 +1416,16 @@ void __bt_opc_property_changed_event(GVariant *msg, g_variant_get(val, "s", &status); BT_DBG("Status is %s", status); - if(strcasecmp(status, "active") == 0){ + if (strcasecmp(status, "active") == 0) _bt_obex_client_started(path); - }else if (strcasecmp(status, "complete") == 0) { + else if (strcasecmp(status, "complete") == 0) _bt_obex_client_completed(path, TRUE); - }else if (strcasecmp(status, "error") == 0){ + else if (strcasecmp(status, "error") == 0) _bt_obex_client_completed(path, FALSE); - } + g_free(status); } else if (strcasecmp(property, "Transferred") == 0) { - static int transferred = 0; + guint64 transferred = 0; g_variant_get(val, "t", &transferred); _bt_obex_client_progress(path, transferred); @@ -1211,8 +1463,8 @@ void _bt_handle_input_event(GVariant *msg, const char *path) GVariant *child = NULL, *val = NULL; bt_remote_dev_info_t *remote_dev_info; GVariant *param = NULL; - g_variant_iter_init (&value_iter, msg); - while ((child = g_variant_iter_next_value (&value_iter))) { + g_variant_iter_init(&value_iter, msg); + while ((child = g_variant_iter_next_value(&value_iter))) { g_variant_get(child, "{sv}", &property, &val); ret_if(property == NULL); @@ -1233,7 +1485,7 @@ void _bt_handle_input_event(GVariant *msg, const char *path) _bt_send_event(BT_HID_EVENT, event, param); /* Check HID connection type (Keyboard or Mouse) and update the status */ - remote_dev_info = _bt_get_remote_device_info(address); + remote_dev_info = _bt_get_remote_device_info_by_object_path(path); if (property_flag == TRUE) { hid_connected_device_count++; @@ -1250,19 +1502,15 @@ void _bt_handle_input_event(GVariant *msg, const char *path) BT_DBG("HID device class [%x]", remote_dev_info->class); if (remote_dev_info->class & BLUETOOTH_DEVICE_MINOR_CLASS_KEY_BOARD) { -#ifdef ENABLE_TIZEN_2_4 __bt_set_device_values(property_flag, VCONFKEY_BT_DEVICE_HID_KEYBOARD_CONNECTED); -#endif } if (remote_dev_info->class & BLUETOOTH_DEVICE_MINOR_CLASS_POINTING_DEVICE) { -#ifdef ENABLE_TIZEN_2_4 __bt_set_device_values(property_flag, VCONFKEY_BT_DEVICE_HID_MOUSE_CONNECTED); -#endif } _bt_free_device_info(remote_dev_info); } @@ -1317,7 +1565,7 @@ void _bt_handle_network_client_event(GVariant *msg, GVariant *val = NULL; GVariantIter value_iter; GVariant *param = NULL; - g_variant_iter_init (&value_iter, msg); + g_variant_iter_init(&value_iter, msg); while ((g_variant_iter_loop(&value_iter, "{sv}", &property, &val))) { if (strcasecmp(property, "Connected") == 0) { int event = BLUETOOTH_EVENT_NONE; @@ -1360,30 +1608,27 @@ void __bt_gatt_char_property_changed_event(GVariant *msg, GVariant *val = NULL; int result = BLUETOOTH_ERROR_NONE; GVariant *param = NULL; - g_variant_iter_init (&value_iter, msg); + g_variant_iter_init(&value_iter, msg); char_handle = g_strdup(path); while ((g_variant_iter_loop(&value_iter, "{sv}", &property, &val))) { - BT_INFO("Property %s", property); + BT_DBG("Property %s", property); ret_if(property == NULL); if (strcasecmp(property, "Notifying") == 0) { gboolean property_flag = FALSE; g_variant_get(val, "b", &property_flag); - if (property_flag == TRUE) - BT_DBG("notifying is enabled"); - else - BT_DBG("notifying is disabled"); + BT_INFO("Notifying is %s", property_flag ? "enabled" : "disabled"); } else if (strcasecmp(property, "ChangedValue") == 0) { int len = 0; GByteArray *gp_byte_array = NULL; - BT_INFO("Type '%s'\n", g_variant_get_type_string (val)); + BT_INFO("Type '%s'\n", g_variant_get_type_string(val)); if (val) { gp_byte_array = g_byte_array_new(); len = g_variant_get_size(val); BT_DBG("Len = %d", len); - g_byte_array_append (gp_byte_array, + g_byte_array_append(gp_byte_array, (const guint8 *) g_variant_get_data(val), len); if (gp_byte_array->len != 0) { GVariant *byte_array = NULL; @@ -1394,9 +1639,9 @@ void __bt_gatt_char_property_changed_event(GVariant *msg, TRUE, NULL, NULL); param = g_variant_new("(is@ay)", result, char_handle, byte_array); - _bt_send_event(BT_DEVICE_EVENT, - BLUETOOTH_EVENT_GATT_CHAR_VAL_CHANGED, - param); + + /* Send event only registered client */ + _bt_send_char_value_changed_event(param); } g_byte_array_free(gp_byte_array, TRUE); } @@ -1404,14 +1649,52 @@ void __bt_gatt_char_property_changed_event(GVariant *msg, } g_free(char_handle); } -void _bt_handle_device_event(GVariant *msg, const char *member,const char *path) + +void _bt_handle_gatt_event(GVariant *msg, const char *member, const char *path) { - int event; + ret_if(path == NULL); + + if (strcasecmp(member, "GattValueChanged") == 0) { + +#if 0 // Debug Only + /*** Debug only ***/ + GVariant *value = NULL; + int value_len = 0; + char *buffer = NULL; + + g_variant_get(msg, "(is@ay)", NULL, NULL, &value); + value_len = g_variant_get_size(value); + if (value_len > 0) { + char buf[8 * 5 + 1] = { 0 }; + int i; + int to; + buffer = (char *)g_variant_get_data(value); + to = value_len > (sizeof(buf) / 5) ? sizeof(buf) / 5 : value_len; + + for (i = 0; i < to; i++) + snprintf(&buf[i * 5], 6, "0x%02x ", buffer[i]); + buf[i * 5] = '\0'; + BT_DBG("GATT Val[%d] %s", value_len, buf); + } + g_variant_unref(value); + /******/ +#endif + + /* Send event only registered client */ + _bt_send_char_value_changed_event(msg); + } +} + + +void _bt_handle_device_event(GVariant *msg, const char *member, const char *path) +{ + int event = 0; int result = BLUETOOTH_ERROR_NONE; char *address; - char *dev_name; + char *dev_name = NULL; const char *property = NULL; GVariant *param = NULL; + char secure_address[BT_ADDRESS_STRING_SIZE] = { 0 }; ret_if(path == NULL); if (strcasecmp(member, "PropertyChanged") == 0) { @@ -1424,6 +1707,7 @@ void _bt_handle_device_event(GVariant *msg, const char *member,const char *path) gboolean connected = FALSE; char *address; address = g_malloc0(BT_ADDRESS_STRING_SIZE); + _bt_convert_device_path_to_address(path, address); g_variant_get(msg, "(b)", &connected); @@ -1458,7 +1742,7 @@ void _bt_handle_device_event(GVariant *msg, const char *member,const char *path) _bt_convert_device_path_to_address(path, address); - remote_dev_info = _bt_get_remote_device_info(address); + remote_dev_info = _bt_get_remote_device_info_by_object_path(path); if (remote_dev_info == NULL) { g_free(address); return; @@ -1467,7 +1751,7 @@ void _bt_handle_device_event(GVariant *msg, const char *member,const char *path) GVariantBuilder *builder = NULL; int i = 0; builder = g_variant_builder_new(G_VARIANT_TYPE("as")); - for (i=0; i < remote_dev_info->uuid_count; i++) { + for (i = 0; i < remote_dev_info->uuid_count; i++) { g_variant_builder_add(builder, "s", remote_dev_info->uuids[i]); } @@ -1508,7 +1792,7 @@ void _bt_handle_device_event(GVariant *msg, const char *member,const char *path) _bt_convert_device_path_to_address(path, address); - remote_dev_info = _bt_get_remote_device_info(address); + remote_dev_info = _bt_get_remote_device_info_by_object_path(path); if (remote_dev_info == NULL) { g_free(address); return; @@ -1520,7 +1804,7 @@ void _bt_handle_device_event(GVariant *msg, const char *member,const char *path) GVariantBuilder *builder = NULL; int i = 0; builder = g_variant_builder_new(G_VARIANT_TYPE("as")); - for (i=0; i < remote_dev_info->uuid_count; i++) { + for (i = 0; i < remote_dev_info->uuid_count; i++) { g_variant_builder_add(builder, "s", remote_dev_info->uuids[i]); } @@ -1556,17 +1840,18 @@ void _bt_handle_device_event(GVariant *msg, const char *member,const char *path) address = g_malloc0(BT_ADDRESS_STRING_SIZE); _bt_convert_device_path_to_address(path, address); - dev_name = _bt_get_bonded_device_name(address); + dev_name = _bt_get_device_name(address); - BT_INFO("Address : %s Type : %d", address, addr_type); - BT_ERR_C("Connected [%s] [%s]", !addr_type ? "BREDR" : "LE", - !addr_type ? dev_name : address); + _bt_convert_addr_string_to_secure_string(secure_address, address); + BT_INFO("Address : %s Type : %d", secure_address, addr_type); + BT_ERR_C("### Connected [%s] [%s]", !addr_type ? "BREDR" : "LE", + !addr_type ? dev_name : secure_address); g_free(dev_name); + if (addr_type) + _bt_add_le_connected_dev_info(address); + _bt_logging_connection(TRUE, addr_type); -#ifdef ENABLE_TIZEN_2_4 - journal_bt_connected(); -#endif param = g_variant_new("(isy)", result, address, addr_type); /*Send event to application*/ _bt_send_event(BT_DEVICE_EVENT, @@ -1576,39 +1861,67 @@ void _bt_handle_device_event(GVariant *msg, const char *member,const char *path) } else if (strcasecmp(member, "Disconnected") == 0) { unsigned char disc_reason = 0; unsigned char addr_type = 0; + char *dev_name = NULL; gboolean sending = FALSE; - g_variant_get(msg, "(yy)", &addr_type, &disc_reason); + g_variant_get(msg, "(yys)", &addr_type, &disc_reason, &dev_name); result = disc_reason; address = g_malloc0(BT_ADDRESS_STRING_SIZE); _bt_convert_device_path_to_address(path, address); - dev_name = _bt_get_bonded_device_name(address); -#ifdef ENABLE_TIZEN_2_4 - journal_bt_disconnected(); -#endif /* 0x00 BDADDR_BRDER 0x01 BDADDR_LE_PUBLIC 0x02 BDADDR_LE_RANDOM */ - BT_INFO("Address : %s Type : %d", address, addr_type); - BT_ERR_C("Disconnected [%s] [%d : %s] [%s]", !addr_type ? "BREDR" : "LE", - disc_reason, _bt_convert_disc_reason_to_string(disc_reason), - !addr_type ? dev_name : address); + _bt_convert_addr_string_to_secure_string(secure_address, address); + BT_INFO("Address : %s Type : %d", secure_address, addr_type); + BT_ERR_C("### Disconnected [%s] [%s] [%d : %s]", !addr_type ? "BREDR" : "LE", + !addr_type ? dev_name : secure_address, + disc_reason, _bt_convert_disc_reason_to_string(disc_reason)); g_free(dev_name); _bt_headset_set_local_connection(FALSE); _bt_logging_connection(FALSE, addr_type); - /*Check for any OPP transfer on the device and cancel - * the transfer - */ - _bt_obex_check_pending_transfer(address); - _bt_opp_client_is_sending(&sending); - if(sending == TRUE) - _bt_opp_client_check_pending_transfer(address); + if (addr_type) + _bt_remove_le_connected_dev_info(address); + else { +#ifdef TIZEN_BT_A2DP_SINK_AUTO_CONNECT + { + int bt_device_state = VCONFKEY_BT_DEVICE_NONE; + + if (vconf_get_int(VCONFKEY_BT_DEVICE, &bt_device_state) != 0) + BT_ERR("vconf_get_int failed"); + + BT_INFO("conn_state[0x%x], adapter_state [%d]", + bt_device_state, _bt_adapter_get_status()); + + if (disc_reason == BLUETOOTH_ERROR_CONNECTION_TIMEOUT) { + _bt_audio_start_auto_connect(TRUE); + } else if (bt_device_state & + VCONFKEY_BT_DEVICE_A2DP_SOURCE_CONNECTED) { + BT_INFO("Disconnected due to turning BT off. Skip a address"); + } else { + char *last_connected = NULL; + last_connected = vconf_get_str(BT_LAST_CONNECTED_DEVICE); + if (!g_strcmp0(address, last_connected)) + _bt_audio_set_auto_connect_device_addr(""); + if (last_connected) + free(last_connected); + } + } + +#endif + /*Check for any OPP transfer on the device and cancel + * the transfer + */ + _bt_obex_check_pending_transfer(address); + _bt_opp_client_is_sending(&sending); + if (sending == TRUE) + _bt_opp_client_check_pending_transfer(address); + } param = g_variant_new("(isy)", result, address, addr_type); _bt_send_event(BT_DEVICE_EVENT, BLUETOOTH_EVENT_DEVICE_DISCONNECTED, @@ -1618,102 +1931,109 @@ void _bt_handle_device_event(GVariant *msg, const char *member,const char *path) int state = 0; char *profile_uuid = NULL; bt_headset_wait_t *wait_list; + bluetooth_device_address_t bd_addr; g_variant_get(msg, "(si)", &profile_uuid, &state); address = g_malloc0(BT_ADDRESS_STRING_SIZE); _bt_convert_device_path_to_address(path, address); + _bt_convert_addr_string_to_type(bd_addr.addr, address); - BT_DBG("Address: %s", address); - BT_DBG("Profile UUID: %s", profile_uuid); - BT_DBG("State: %d", state); + _bt_convert_addr_string_to_secure_string(secure_address, address); + BT_INFO_C("[%s] state: %s, addr: %s", + _bt_convert_uuid_to_string(profile_uuid), + _bt_convert_profile_state_to_string(state), secure_address); - if ((strcmp(profile_uuid, A2DP_SINK_UUID) == 0) && - (state == BT_PROFILE_STATE_CONNECTED)) { + if (strcmp(profile_uuid, A2DP_SINK_UUID) == 0) { + if (state == BT_PROFILE_STATE_CONNECTED) { - int event = BLUETOOTH_EVENT_AV_CONNECTED; - char connected_address[BT_ADDRESS_STRING_SIZE + 1]; - bluetooth_device_address_t device_address; - gboolean connected; - bt_headset_wait_t *wait_list; + int event = BLUETOOTH_EVENT_AV_CONNECTED; + char connected_address[BT_ADDRESS_STRING_SIZE + 1]; + bluetooth_device_address_t device_address; + gboolean connected; + bt_headset_wait_t *wait_list; + guint restricted = 0x0; - __bt_set_device_values(TRUE, - VCONFKEY_BT_DEVICE_A2DP_HEADSET_CONNECTED); + __bt_set_device_values(TRUE, + VCONFKEY_BT_DEVICE_A2DP_HEADSET_CONNECTED); - __bt_connection_manager_set_state(address, event); + __bt_connection_manager_set_state(address, event); - if (_bt_headset_get_local_connection() == FALSE) - _bt_start_timer_for_connection(address, BT_AUDIO_HSP); - else { - /* Connection Started from local device therefore no need to - * intiate connection for pending profile */ - _bt_headset_set_local_connection(FALSE); - } - param = g_variant_new("(is)", result, address); - _bt_send_event(BT_HEADSET_EVENT, event, - param); - connected = _bt_is_headset_type_connected(BT_AUDIO_A2DP, - connected_address); - if (connected) { - if (g_strcmp0(connected_address, address) != 0) { - _bt_convert_addr_string_to_type( - device_address.addr, - connected_address); - _bt_audio_disconnect(0, BT_AUDIO_A2DP, - &device_address, NULL); + _bt_get_restrict_profile(&bd_addr, RESTRICTED_PROFILE_HFP_HS, &restricted); + + if (_bt_headset_get_local_connection() == FALSE) { + if (restricted == 0x0) /* not restricted*/ + _bt_start_timer_for_connection(address, BT_AUDIO_HSP); + } else { + /* Connection Started from local device therefore no need to + * intiate connection for pending profile */ + _bt_headset_set_local_connection(FALSE); + } + param = g_variant_new("(is)", result, address); + _bt_send_event(BT_HEADSET_EVENT, event, + param); + connected = _bt_is_headset_type_connected(BT_AUDIO_A2DP, + connected_address); + if (connected) { + if (g_strcmp0(connected_address, address) != 0) { + _bt_convert_addr_string_to_type( + device_address.addr, + connected_address); + _bt_audio_disconnect(0, BT_AUDIO_A2DP, + &device_address, NULL); + } } - } - _bt_add_headset_to_list(BT_AUDIO_A2DP, - BT_STATE_CONNECTED, address); + _bt_add_headset_to_list(BT_AUDIO_A2DP, + BT_STATE_CONNECTED, address); - wait_list = _bt_get_audio_wait_data(); - if (wait_list != NULL && - (g_strcmp0(wait_list->address, address) == 0)) - _bt_rel_wait_data(); + wait_list = _bt_get_audio_wait_data(); + if (wait_list != NULL && + (g_strcmp0(wait_list->address, address) == 0)) + _bt_rel_wait_data(); - } else if ((strcmp(profile_uuid, A2DP_SINK_UUID) == 0) && - (state == BT_PROFILE_STATE_DISCONNECTED)) { + } else if (state == BT_PROFILE_STATE_DISCONNECTED) { - int event = BLUETOOTH_EVENT_AV_DISCONNECTED; + int event = BLUETOOTH_EVENT_AV_DISCONNECTED; - if (!_bt_is_service_connected(address, BT_AUDIO_A2DP)) { - g_free(address); - g_free(profile_uuid); - return; - } + if (!_bt_is_service_connected(address, BT_AUDIO_A2DP)) { + g_free(address); + g_free(profile_uuid); + return; + } - __bt_set_device_values(FALSE, - VCONFKEY_BT_DEVICE_A2DP_HEADSET_CONNECTED); + __bt_set_device_values(FALSE, + VCONFKEY_BT_DEVICE_A2DP_HEADSET_CONNECTED); - __bt_connection_manager_set_state(address, event); - param = g_variant_new("(is)", result, address); - _bt_send_event(BT_HEADSET_EVENT, event, - param); - /* Remove data from the connected list */ - _bt_remove_headset_from_list(BT_AUDIO_A2DP, address); - wait_list = _bt_get_audio_wait_data(); + __bt_connection_manager_set_state(address, event); + param = g_variant_new("(is)", result, address); + _bt_send_event(BT_HEADSET_EVENT, event, + param); + /* Remove data from the connected list */ + _bt_remove_headset_from_list(BT_AUDIO_A2DP, address); + wait_list = _bt_get_audio_wait_data(); - if (wait_list == NULL) { - g_free(address); - g_free(profile_uuid); - return; - } + if (wait_list == NULL) { + g_free(address); + g_free(profile_uuid); + return; + } - if (((wait_list->type == BT_AUDIO_ALL) && - (wait_list->ag_flag == TRUE)) || - (wait_list->type == BT_AUDIO_A2DP) || - (wait_list->disconnection_type == BT_AUDIO_A2DP)) { - bluetooth_device_address_t device_address; - _bt_convert_addr_string_to_type( - device_address.addr, - wait_list->address); + if (((wait_list->type == BT_AUDIO_ALL) && + (wait_list->ag_flag == TRUE)) || + (wait_list->type == BT_AUDIO_A2DP) || + (wait_list->disconnection_type == BT_AUDIO_A2DP)) { + bluetooth_device_address_t device_address; + _bt_convert_addr_string_to_type( + device_address.addr, + wait_list->address); - _bt_audio_connect(wait_list->req_id, - wait_list->type, - &device_address, - wait_list->out_param1); + _bt_audio_connect(wait_list->req_id, + wait_list->type, + &device_address, + NULL); + } } } else if (strcmp(profile_uuid, AVRCP_TARGET_UUID) == 0) { @@ -1754,13 +2074,44 @@ void _bt_handle_device_event(GVariant *msg, const char *member,const char *path) if (state == BT_PROFILE_STATE_CONNECTED) { int event = BLUETOOTH_EVENT_AV_SOURCE_CONNECTED; BT_INFO("A2DP Source is connected"); +#ifdef TIZEN_BT_A2DP_SINK_ENABLE + __bt_set_device_values(TRUE, + VCONFKEY_BT_DEVICE_A2DP_SOURCE_CONNECTED); +#endif + +#ifdef TIZEN_BT_A2DP_SINK_AUTO_CONNECT + _bt_audio_set_auto_connect_device_addr(address); + _bt_audio_stop_auto_connect(); +#endif + _bt_add_headset_to_list(BT_AUDIO_A2DP_SOURCE, + BT_STATE_CONNECTED, address); _bt_send_event(BT_A2DP_SOURCE_EVENT, event, g_variant_new("(is)", result, address)); } else if (state == BT_PROFILE_STATE_DISCONNECTED) { int event = BLUETOOTH_EVENT_AV_SOURCE_DISCONNECTED; BT_INFO("A2DP Source Disconnected"); +#ifdef TIZEN_BT_A2DP_SINK_ENABLE + __bt_set_device_values(FALSE, + VCONFKEY_BT_DEVICE_A2DP_SOURCE_CONNECTED); +#endif + _bt_remove_headset_from_list(BT_AUDIO_A2DP_SOURCE, address); _bt_send_event(BT_A2DP_SOURCE_EVENT, event, g_variant_new("(is)", result, address)); + + wait_list = _bt_get_audio_wait_data(); + if (wait_list && wait_list->type == BT_AUDIO_A2DP_SOURCE) { + bluetooth_device_address_t device_address; + _bt_convert_addr_string_to_type( + device_address.addr, + wait_list->address); + + _bt_audio_connect(wait_list->req_id, + wait_list->type, + &device_address, + NULL); + /* Now free the wait list */ + _bt_rel_wait_data(); + } } } else if ((strcmp(profile_uuid, HID_UUID) == 0) && ((state == BT_PROFILE_STATE_CONNECTED) || @@ -1773,13 +2124,19 @@ void _bt_handle_device_event(GVariant *msg, const char *member,const char *path) param = g_variant_new("(is)", result, address); _bt_send_event(BT_HID_EVENT, event, param); - - if (state == BT_PROFILE_STATE_CONNECTED) - __bt_set_device_values(TRUE, - VCONFKEY_BT_DEVICE_HID_CONNECTED); - else - __bt_set_device_values(FALSE, - VCONFKEY_BT_DEVICE_HID_CONNECTED); + } else if (strcmp(profile_uuid, HID_DEVICE_UUID) == 0) { + if (state == BT_PROFILE_STATE_CONNECTED) { + int event; + event = BLUETOOTH_HID_DEVICE_CONNECTED; + param = g_variant_new("(is)", result, address); + _bt_send_event(BT_HID_DEVICE_EVENT, event, + param); + } else if (state == BT_PROFILE_STATE_DISCONNECTED) { + event = BLUETOOTH_HID_DEVICE_DISCONNECTED; + param = g_variant_new("(is)", result, address); + _bt_send_event(BT_HID_DEVICE_EVENT, event, + param); + } } g_free(address); g_free(profile_uuid); @@ -1794,17 +2151,30 @@ void _bt_handle_device_event(GVariant *msg, const char *member,const char *path) le_dev_info = g_malloc0(sizeof(bt_remote_le_dev_info_t)); - g_variant_get(msg, "(syyii@ay)", &le_dev_info->address, + g_variant_get(msg, "(&syyii@ay)", &le_dev_info->address, &le_dev_info->addr_type, &le_dev_info->adv_type, &le_dev_info->rssi, &le_dev_info->adv_data_len, &value); + if (value == NULL) { + _bt_free_le_device_info(le_dev_info); + return; + } + + _bt_convert_device_path_to_address(path, le_dev_info->address); + buffer_len = g_variant_get_size(value); if (buffer_len > 0) buffer = (char *)g_variant_get_data(value); le_dev_info->adv_data = g_memdup(buffer, buffer_len); + if (le_dev_info->adv_data == NULL && + le_dev_info->adv_type != BT_LE_ADV_SCAN_RSP) { + _bt_free_le_device_info(le_dev_info); + g_variant_unref(value); + return; + } if (_bt_get_le_scan_type() == BT_LE_PASSIVE_SCAN) { _bt_send_scan_result_event(le_dev_info, NULL); @@ -1816,13 +2186,17 @@ void _bt_handle_device_event(GVariant *msg, const char *member,const char *path) if (le_dev_info->adv_type != BT_LE_ADV_SCAN_RSP) { /* ADV_IND */ adv_info = g_malloc0(sizeof(bt_le_adv_info_t)); adv_info->addr = g_strdup(le_dev_info->address); + adv_info->addr_type = le_dev_info->addr_type; + adv_info->rssi = le_dev_info->rssi; adv_info->data_len = le_dev_info->adv_data_len; adv_info->data = g_malloc0(le_dev_info->adv_data_len); memcpy(adv_info->data, le_dev_info->adv_data, le_dev_info->adv_data_len); - __bt_add_adv_ind_info(adv_info); - + if (__bt_add_adv_ind_info(adv_info) == 0) { + adv_info->timer_id = g_timeout_add(1000, + (GSourceFunc)__bt_adv_scan_req_timeout_cb, (void*)adv_info); + } } else { /* SCAN_RSP */ adv_info = __bt_get_adv_ind_info(le_dev_info->address); if (adv_info) { @@ -1832,8 +2206,63 @@ void _bt_handle_device_event(GVariant *msg, const char *member,const char *path) } _bt_free_le_device_info(le_dev_info); g_variant_unref(value); - } + } else if (strcasecmp(member, "LEDataLengthChanged") == 0) { + guint16 tx_octets = 0; + guint16 tx_time = 0; + guint16 rx_octets = 0; + guint16 rx_time = 0; + + g_variant_get(msg, "(qqqq)", + &tx_octets, &tx_time, &rx_octets, &rx_time); + + address = g_malloc0(BT_ADDRESS_STRING_SIZE); + _bt_convert_device_path_to_address(path, address); + + param = g_variant_new("(isqqqq)", result, address, tx_octets, tx_time, + rx_octets, rx_time); + /* Send event to application */ + _bt_send_event(BT_DEVICE_EVENT, + BLUETOOTH_EVENT_LE_DATA_LENGTH_CHANGED, param); + g_free(address); + } else if (strcasecmp(member, "IpspStateChanged") == 0) { + gboolean connected = FALSE; + char *ifname = NULL; + g_variant_get(msg, "(bs)", &connected, &ifname); + + event = connected ? BLUETOOTH_EVENT_IPSP_CONNECTED : + BLUETOOTH_EVENT_IPSP_DISCONNECTED; + + address = g_malloc0(BT_ADDRESS_STRING_SIZE); + _bt_convert_device_path_to_address(path, address); + + BT_DBG("Ipsp BT Interface Name: %s", ifname); + BT_DBG("address: %s", address); + param = g_variant_new("(iss)", result, address, ifname); + + /* Send event to application */ + _bt_send_event(BT_DEVICE_EVENT, + event, + param); + g_free(address); + } else if (strcasecmp(member, "iBeaconReport") == 0) { + bt_remote_ibeacon_dev_info_t *ibeacon_dev_info = NULL; + + ret_if(_bt_is_le_scanning() == FALSE); + + ibeacon_dev_info = g_malloc0(sizeof(bt_remote_ibeacon_dev_info_t)); + + g_variant_get(msg, "(syuusuuy)", &ibeacon_dev_info->address, + &ibeacon_dev_info->addr_type, + &ibeacon_dev_info->company_id, + &ibeacon_dev_info->ibeacon_type, + &ibeacon_dev_info->uuid, + &ibeacon_dev_info->major_id, + &ibeacon_dev_info->minor_id, + &ibeacon_dev_info->measured_power); + _bt_send_ibeacon_scan_result_event(ibeacon_dev_info); + g_free(ibeacon_dev_info); + } } void __bt_set_audio_values(gboolean connected, char *address) @@ -1842,24 +2271,19 @@ void __bt_set_audio_values(gboolean connected, char *address) int bt_device_state = VCONFKEY_BT_DEVICE_NONE; /* Set the headset name */ - if (connected == TRUE) { - name = _bt_get_bonded_device_name(address); - } else { + if (connected == TRUE) + name = _bt_get_device_name(address); + else name = g_strdup(""); - } - if (vconf_set_str(VCONFKEY_BT_HEADSET_NAME, - name) != 0) { + if (vconf_set_str(VCONFKEY_BT_HEADSET_NAME, name) != 0) BT_ERR("vconf_set_str failed"); - } g_free(name); /* Set the headset state */ - if (vconf_get_int(VCONFKEY_BT_DEVICE, - &bt_device_state) != 0) { - BT_ERR("vconf_get_str failed"); - } + if (vconf_get_int(VCONFKEY_BT_DEVICE, &bt_device_state) != 0) + BT_ERR("vconf_get_int failed"); #ifdef TIZEN_SUPPORT_DUAL_HF if ((connected == TRUE) && @@ -1870,11 +2294,10 @@ void __bt_set_audio_values(gboolean connected, char *address) bt_device_state ^= VCONFKEY_BT_DEVICE_HEADSET_CONNECTED; } #else - if (connected == TRUE) { + if (connected == TRUE) bt_device_state |= VCONFKEY_BT_DEVICE_HEADSET_CONNECTED; - } else if (bt_device_state & VCONFKEY_BT_DEVICE_HEADSET_CONNECTED) { + else if (bt_device_state & VCONFKEY_BT_DEVICE_HEADSET_CONNECTED) bt_device_state ^= VCONFKEY_BT_DEVICE_HEADSET_CONNECTED; - } #endif if (vconf_set_int(VCONFKEY_BT_DEVICE, @@ -1891,6 +2314,7 @@ void _bt_handle_headset_event(GVariant *msg, const char *path) GVariant *value = NULL; GVariant *param = NULL; g_variant_get(msg, "(sv)", &property, &value); + bluetooth_device_address_t bd_addr; ret_if(property == NULL); @@ -1900,21 +2324,22 @@ void _bt_handle_headset_event(GVariant *msg, const char *path) int event = BLUETOOTH_EVENT_NONE; bt_headset_wait_t *wait_list; char *address; + guint restricted = 0x0; g_variant_get(value, "b", &property_flag); address = g_malloc0(BT_ADDRESS_STRING_SIZE); - /* Fix : NULL_RETURNS */ - if (address == NULL) - return; - _bt_convert_device_path_to_address(path, address); + _bt_convert_addr_string_to_type(bd_addr.addr, address); if (property_flag == TRUE) { event = BLUETOOTH_EVENT_AG_CONNECTED; - if (_bt_headset_get_local_connection() == FALSE) - _bt_start_timer_for_connection(address, BT_AUDIO_A2DP); - else + _bt_get_restrict_profile(&bd_addr, RESTRICTED_PROFILE_A2DP, &restricted); + + if (_bt_headset_get_local_connection() == FALSE) { + if (restricted == 0x0) /* not restricted*/ + _bt_start_timer_for_connection(address, BT_AUDIO_A2DP); + } else _bt_headset_set_local_connection(FALSE); } else { int previous_state; @@ -1949,7 +2374,7 @@ void _bt_handle_headset_event(GVariant *msg, const char *path) _bt_convert_addr_string_to_type(device_address.addr, wait_list->address); _bt_audio_connect(wait_list->req_id, wait_list->type, - &device_address, wait_list->out_param1); + &device_address, NULL); _bt_rel_wait_data(); } else if (event == BLUETOOTH_EVENT_AG_CONNECTED) { /* Add data to the connected list */ @@ -1991,8 +2416,11 @@ void _bt_handle_headset_event(GVariant *msg, const char *path) _bt_convert_device_path_to_address(path, address); - g_variant_get(value, "i", &spkr_gain); - param = g_variant_new("(isq)", result, address, spkr_gain); + spkr_gain = g_variant_get_uint16(value); + + BT_DBG("spkr_gain: %d", spkr_gain); + + param = g_variant_new("(i&sq)", result, address, spkr_gain); _bt_send_event(BT_HEADSET_EVENT, BLUETOOTH_EVENT_AG_SPEAKER_GAIN, param); @@ -2005,8 +2433,9 @@ void _bt_handle_headset_event(GVariant *msg, const char *path) _bt_convert_device_path_to_address(path, address); - g_variant_get(value, "i", &mic_gain); - param = g_variant_new("(isq)", result, address, mic_gain); + mic_gain = g_variant_get_uint16(value); + + param = g_variant_new("(i&sq)", result, address, mic_gain); _bt_send_event(BT_HEADSET_EVENT, BLUETOOTH_EVENT_AG_MIC_GAIN, param); g_free(address); @@ -2015,7 +2444,7 @@ void _bt_handle_headset_event(GVariant *msg, const char *path) if (property) g_free(property); g_variant_unref(value); - } +} void _bt_handle_sink_event(GVariant *msg, const char *path) { @@ -2027,8 +2456,8 @@ void _bt_handle_sink_event(GVariant *msg, const char *path) GVariant *child = NULL; GVariant *val = NULL; GVariant *param = NULL; - g_variant_iter_init (&value_iter, msg); - while ((child = g_variant_iter_next_value (&value_iter))) { + g_variant_iter_init(&value_iter, msg); + while ((child = g_variant_iter_next_value(&value_iter))) { g_variant_get(child, "{sv}", &property, &val); @@ -2082,10 +2511,10 @@ void _bt_handle_sink_event(GVariant *msg, const char *path) _bt_audio_connect(wait_list->req_id, wait_list->type, &device_address, - wait_list->out_param1); + NULL); } g_free(address); - }else if (strcasecmp(value, "Connected") == 0) { + } else if (strcasecmp(value, "Connected") == 0) { char *address; char connected_address[BT_ADDRESS_STRING_SIZE + 1]; bluetooth_device_address_t device_address; @@ -2107,7 +2536,7 @@ void _bt_handle_sink_event(GVariant *msg, const char *path) if (connected) { /* Match connected device address */ if (g_strcmp0(connected_address, address) != 0) { - /* Convert BD adress from string type */ + /* Convert BD address from string type */ _bt_convert_addr_string_to_type( device_address.addr, connected_address); @@ -2141,12 +2570,10 @@ void _bt_handle_agent_event(GVariant *msg, const char *member) if (strcasecmp(member, "ObexAuthorize") == 0) { __bt_get_agent_signal_info(msg, &address, &name, &uuid); - param = g_variant_new("(iss)", result, address, name); + param = g_variant_new("(i&s&s)", result, address, name); _bt_send_event(BT_OPP_SERVER_EVENT, BLUETOOTH_EVENT_OBEX_SERVER_CONNECTION_AUTHORIZE, param); - g_free(address); - g_free(name); } else if (strcasecmp(member, "RfcommAuthorize") == 0) { bt_rfcomm_server_info_t *server_info; @@ -2155,14 +2582,11 @@ void _bt_handle_agent_event(GVariant *msg, const char *member) server_info = _bt_rfcomm_get_server_info_using_uuid(uuid); ret_if(server_info == NULL); ret_if(server_info->server_type != BT_CUSTOM_SERVER); - param = g_variant_new("(isssn)", result, address, uuid, name, + param = g_variant_new("(i&s&s&sn)", result, address, uuid, name, server_info->control_fd); _bt_send_event(BT_RFCOMM_SERVER_EVENT, BLUETOOTH_EVENT_RFCOMM_AUTHORIZE, param); - g_free(address); - g_free(uuid); - g_free(name); } } @@ -2182,7 +2606,7 @@ static void __bt_devices_list_free(void) node = g_list_first(p_cache_list); - while (node != NULL){ + while (node != NULL) { cache_info = (bt_cache_info_t *)node->data; p_cache_list = g_list_remove(p_cache_list, cache_info); __bt_free_cache_info(cache_info); @@ -2195,13 +2619,13 @@ static int __bt_parse_event(GVariant *msg) { GVariantIter iter; GVariant *child; - char *interface_name= NULL; + char *interface_name = NULL; GVariant *inner_iter = NULL; g_variant_iter_init(&iter, msg); while ((child = g_variant_iter_next_value(&iter))) { - g_variant_get(child,"{&s@a{sv}}", &interface_name, &inner_iter); + g_variant_get(child, "{&s@a{sv}}", &interface_name, &inner_iter); if (g_strcmp0(interface_name, BT_DEVICE_INTERFACE) == 0) { g_variant_unref(inner_iter); @@ -2243,19 +2667,29 @@ static void __bt_manager_event_filter(GDBusConnection *connection, if (strcasecmp(signal_name, "InterfacesAdded") == 0) { g_variant_get(parameters, "(&o@a{sa{sv}})", &obj_path, &value); - if (strcasecmp(obj_path, BT_BLUEZ_HCI_PATH) == 0) + if (strcasecmp(obj_path, BT_BLUEZ_HCI_PATH) == 0) { +#ifdef USB_BLUETOOTH + BT_DBG("Enable Adapter"); + _bt_enable_adapter(); +#else _bt_handle_adapter_added(); - else { +#endif + } else { bt_event = __bt_parse_event(value); if (bt_event == BT_DEVICE_EVENT) { bt_cache_info_t *cache_info; bt_remote_dev_info_t *dev_info; - ret_if(_bt_is_discovering() == FALSE && - _bt_is_le_scanning() == FALSE); + if (_bt_is_discovering() == FALSE && + _bt_is_le_scanning() == FALSE) { + g_variant_unref(value); + return; + } cache_info = g_malloc0(sizeof(bt_cache_info_t)); + dev_info = g_malloc0(sizeof(bt_remote_dev_info_t)); + cache_info->dev_info = dev_info; if (__bt_parse_interface(parameters, dev_info) == FALSE) { @@ -2280,11 +2714,27 @@ static void __bt_manager_event_filter(GDBusConnection *connection, */ dev_info->name = g_strdup(dev_info->address); +#ifdef TIZEN_DPM_ENABLE + if (_bt_dpm_get_bluetooth_desktop_connectivity_state() == + DPM_RESTRICTED) { + bluetooth_device_class_t device_class; + _bt_divide_device_class(&device_class, dev_info->class); + BT_DBG("[%s]device_class.major_class : %d", dev_info->name, device_class.major_class); + + if (device_class.major_class == + BLUETOOTH_DEVICE_MAJOR_CLASS_COMPUTER) { + __bt_free_cache_info(cache_info); + g_variant_unref(value); + return; + } + } +#endif + GVariant *uuids = NULL; GVariantBuilder *builder = NULL; int i = 0; builder = g_variant_builder_new(G_VARIANT_TYPE("as")); - for (i=0; i < dev_info->uuid_count; i++) { + for (i = 0; i < dev_info->uuid_count; i++) { g_variant_builder_add(builder, "s", dev_info->uuids[i]); } @@ -2318,13 +2768,17 @@ static void __bt_manager_event_filter(GDBusConnection *connection, } g_variant_unref(value); } else if (strcasecmp(signal_name, "InterfacesRemoved") == 0) { - if (g_strcmp0(interface_name, BT_MEDIATRANSPORT_INTERFACE) == 0) { +#ifdef USB_BLUETOOTH + BT_DBG("InterfacesRemoved"); + _bt_handle_adapter_removed(); +#endif + if (g_strcmp0(interface_name, BT_MEDIATRANSPORT_INTERFACE) == 0) bt_event = BT_MEDIA_TRANSFER_EVENT; - } else if (g_strcmp0(interface_name, BT_DEVICE_INTERFACE) == 0) { + else if (g_strcmp0(interface_name, BT_DEVICE_INTERFACE) == 0) bt_event = BT_DEVICE_EVENT; - } else if (g_strcmp0(interface_name, BT_PLAYER_CONTROL_INTERFACE) == 0) { + else if (g_strcmp0(interface_name, BT_PLAYER_CONTROL_INTERFACE) == 0) bt_event = BT_AVRCP_CONTROL_EVENT; - } + if ((bt_event != 0) && (bt_event != BT_MEDIA_TRANSFER_EVENT)) { _bt_handle_adapter_event(parameters, signal_name); if (bt_event == BT_AVRCP_CONTROL_EVENT) { @@ -2338,28 +2792,30 @@ static void __bt_manager_event_filter(GDBusConnection *connection, char *previous = NULL; char *current = NULL; + if (g_strcmp0(g_variant_get_type_string(parameters), "(sss)") != 0) { + BT_ERR("Invalid variant format"); + return; + } + if (__bt_get_owner_info(parameters, &name, &previous, ¤t)) { BT_ERR("Fail to get the owner info"); return; } - if (*current != '\0') { - if (name) - g_free(name); - if (previous) - g_free(previous); - if (current) - g_free(current); + if (*current != '\0') + return; + + if (name == NULL) return; - } if (strcasecmp(name, BT_BLUEZ_NAME) == 0) { - BT_DBG("Bluetoothd is terminated"); - if (_bt_adapter_get_status() != BT_DEACTIVATING) { - __bt_disable_cb(); - } + BT_INFO_C("### Bluetoothd is terminated"); + if (_bt_adapter_get_status() == BT_ACTIVATED) + _bt_disable_cb(); + _bt_handle_adapter_removed(); __bt_devices_list_free(); + _bt_service_adapter_le_deinit(); } _bt_obex_server_check_allocation(&value); @@ -2376,13 +2832,14 @@ static void __bt_manager_event_filter(GDBusConnection *connection, _bt_rfcomm_server_check_termination(name); } + /* Reset connection interval */ + _bt_remove_all_le_conn_param_info(name); + /* Stop advertising started by terminated process */ _bt_stop_advertising_by_terminated_process(name); + /* Stop LE Scan */ _bt_stop_le_scan(name); - g_free(name); - g_free(previous); - g_free(current); } else if (g_strcmp0(interface_name, BT_PROPERTIES_INTERFACE) == 0) { const char *path = object_path; @@ -2398,13 +2855,17 @@ static void __bt_manager_event_filter(GDBusConnection *connection, } else if (g_strcmp0(interface_name, BT_NETWORK_SERVER_INTERFACE) == 0) { _bt_handle_network_server_event(parameters, signal_name); } else if (g_strcmp0(interface_name, BT_HEADSET_INTERFACE) == 0) { - _bt_handle_headset_event(parameters, object_path); + if (g_strcmp0(signal_name, "PropertyChanged") == 0) { + _bt_handle_headset_event(parameters, object_path); + } } else if (g_strcmp0(interface_name, BT_SINK_INTERFACE) == 0) { _bt_handle_sink_event(parameters, object_path); } else if (g_strcmp0(interface_name, BT_AGENT_INTERFACE) == 0) { _bt_handle_agent_event(parameters, signal_name); } else if (g_strcmp0(interface_name, BT_DEVICE_INTERFACE) == 0) { _bt_handle_device_event(parameters, signal_name, object_path); + } else if (g_strcmp0(interface_name, BT_GATT_CHAR_INTERFACE) == 0) { + _bt_handle_gatt_event(parameters, signal_name, object_path); } return; @@ -2416,7 +2877,7 @@ static gboolean __bt_is_obexd_event(GVariant *msg, const char *interface) if (g_strcmp0(interface, BT_PROPERTIES_INTERFACE) == 0) { char *interface_name = NULL; - g_variant_get(msg,"(&s@a{sv}@as)", &interface_name, NULL, NULL); + g_variant_get(msg, "(&s@a{sv}@as)", &interface_name, NULL, NULL); retv_if(interface_name == NULL, FALSE); if (strcasecmp(interface_name, BT_OBEX_TRANSFER_INTERFACE) == 0) { @@ -2445,7 +2906,7 @@ static void __bt_obexd_event_filter(GDBusConnection *connection, BT_ERR("Fail to get the path"); return; } - BT_INFO("object_path = [%s]", object_path); + BT_INFO("object_path = [%s]", obj_path); /*Handle OPP_SERVER_CONNECTED_EVENT here */ if (strncmp(obj_path, BT_SESSION_BASEPATH_SERVER, @@ -2456,7 +2917,7 @@ static void __bt_obexd_event_filter(GDBusConnection *connection, if (g_strrstr(obj_path, "session") && g_strrstr(obj_path, "transfer")) { BT_DBG("Obex_Server_Session_Transfer connected"); - _bt_obex_transfer_connected(); + _bt_obex_transfer_connected(obj_path); } g_free(obj_path); } else if (strcasecmp(member, "InterfacesRemoved") == 0) { @@ -2465,7 +2926,7 @@ static void __bt_obexd_event_filter(GDBusConnection *connection, BT_ERR("Fail to get the path"); return; } - BT_INFO("object_path = [%s]", object_path); + BT_INFO("object_path = [%s]", obj_path); if (strncmp(obj_path, BT_SESSION_BASEPATH_CLIENT, strlen(BT_SESSION_BASEPATH_CLIENT)) == 0) { @@ -2480,8 +2941,10 @@ static void __bt_obexd_event_filter(GDBusConnection *connection, } if (g_strrstr(obj_path, "session") && g_strrstr(obj_path, "transfer")) { - BT_DBG("Obex_Server_Session_Transfer disconnected"); - _bt_obex_transfer_disconnected(); + BT_DBG("Obex_Server_Session_Transfer disconnected %s", + obj_path); + + _bt_obex_transfer_disconnected(obj_path); } g_free(obj_path); } else if (__bt_is_obexd_event(parameters, interface_name) == TRUE) { @@ -2508,7 +2971,7 @@ static gboolean __bt_is_obexd_client_event(GVariant *msg, const char *interface) if (g_strcmp0(interface, BT_PROPERTIES_INTERFACE) == 0) { char *interface_name = NULL; - g_variant_get(msg,"(&s@a{sv}@as)", &interface_name, NULL, NULL); + g_variant_get(msg, "(&s@a{sv}@as)", &interface_name, NULL, NULL); retv_if(interface_name == NULL, FALSE); @@ -2536,22 +2999,21 @@ static void __bt_opc_event_filter(GDBusConnection *connection, char *obj_path = NULL; if (strcasecmp(member, "InterfacesAdded") == 0) { BT_DBG("InterfacesAdded"); - }else if (strcasecmp(member, "InterfacesRemoved") == 0) { + } else if (strcasecmp(member, "InterfacesRemoved") == 0) { if (__bt_get_object_path(parameters, &obj_path)) { BT_ERR("Fail to get the path"); return; } - BT_DBG("object_path =%s",obj_path); + BT_DBG("object_path = %s", obj_path); if (strncmp(obj_path, BT_SESSION_BASEPATH_CLIENT, strlen(BT_SESSION_BASEPATH_CLIENT)) != 0 || strstr(obj_path, "transfer") == NULL) { g_free(obj_path); return; - } - else if (strncmp(obj_path, BT_SESSION_BASEPATH_CLIENT, + } else if (strncmp(obj_path, BT_SESSION_BASEPATH_CLIENT, strlen(BT_SESSION_BASEPATH_CLIENT)) == 0) { BT_DBG("Going to call opc disconnected"); _bt_opc_disconnected(obj_path); @@ -2559,7 +3021,7 @@ static void __bt_opc_event_filter(GDBusConnection *connection, _bt_sending_files(); g_free(obj_path); - }else if (__bt_is_obexd_client_event(parameters, interface_name) == TRUE){ + } else if (__bt_is_obexd_client_event(parameters, interface_name) == TRUE) { char *path = (char *)object_path; BT_INFO("object_path %s", path); if (strncmp(path, BT_SESSION_BASEPATH_CLIENT, @@ -2621,6 +3083,7 @@ int _bt_register_manager_subscribe_signal(GDBusConnection *conn, static int subs_name_owner_id = -1; static int subs_property_id = -1; static int subs_adapter_id = -1; + static int subs_gatt_id = -1; if (subscribe) { if (subs_interface_added_id == -1) { @@ -2658,6 +3121,13 @@ int _bt_register_manager_subscribe_signal(GDBusConnection *conn, __bt_manager_event_filter, NULL, NULL); } + if (subs_gatt_id == -1) { + subs_gatt_id = g_dbus_connection_signal_subscribe(conn, + NULL, BT_GATT_CHAR_INTERFACE, + NULL, NULL, NULL, 0, + __bt_manager_event_filter, + NULL, NULL); + } } else { if (subs_interface_added_id != -1) { g_dbus_connection_signal_unsubscribe(conn, @@ -2679,10 +3149,14 @@ int _bt_register_manager_subscribe_signal(GDBusConnection *conn, subs_property_id); subs_property_id = -1; } - if (subs_adapter_id == -1) { + if (subs_adapter_id != -1) { g_dbus_connection_signal_unsubscribe(conn, subs_adapter_id); subs_adapter_id = -1; } + if (subs_gatt_id != -1) { + g_dbus_connection_signal_unsubscribe(conn, subs_gatt_id); + subs_gatt_id = -1; + } } return 0; } @@ -2791,7 +3265,7 @@ int _bt_register_audio_subscribe_signal(GDBusConnection *conn, if (subs_headset_id == -1) { subs_headset_id = g_dbus_connection_signal_subscribe(conn, NULL, BT_HEADSET_INTERFACE, - NULL, NULL, NULL, 0, + "PropertyChanged", NULL, NULL, 0, __bt_manager_event_filter, NULL, NULL); } @@ -2962,6 +3436,43 @@ int _bt_register_a2dp_subscribe_signal(GDBusConnection *conn, return 0; } +static void __bt_dump_event_filter(GDBusConnection *connection, + const gchar *sender_name, + const gchar *object_path, + const gchar *interface_name, + const gchar *signal_name, + GVariant *parameters, + gpointer user_data) +{ + return; +} + +int __bt_register_dump_subscribe_signal(GDBusConnection *conn, + gboolean subscribe) +{ + if (conn == NULL) + return -1; + + static int subs_source_id = -1; + + if (subscribe) { + if (subs_source_id == -1) { + subs_source_id = g_dbus_connection_signal_subscribe(conn, + NULL, BT_DUMP_SERVICE_INTERFACE, + BT_DUMP_SERVICE_SIGNAL, BT_DUMP_SERVICE_PATH, NULL, 0, + __bt_dump_event_filter, + NULL, NULL); + } + } else { + if (subs_source_id != -1) { + g_dbus_connection_signal_unsubscribe(conn, + subs_source_id); + subs_source_id = -1; + } + } + return 0; +} + int _bt_register_service_event(GDBusConnection *g_conn, int event_type) { BT_DBG("+"); @@ -3066,6 +3577,8 @@ static int __bt_init_manager_receiver(void) if (_bt_register_service_event(manager_conn, BT_NETWORK_EVENT) != BLUETOOTH_ERROR_NONE) goto fail; + + __bt_register_dump_subscribe_signal(manager_conn, TRUE); return BLUETOOTH_ERROR_NONE; fail: if (manager_conn) { @@ -3081,6 +3594,7 @@ fail: static int __bt_init_obexd_receiver(void) { BT_DBG("+"); +#ifndef TIZEN_TV /* TODO: obexd doesn't work in TV profile. It should be resolved later. */ GError *error = NULL; if (obexd_conn == NULL) { @@ -3099,12 +3613,42 @@ static int __bt_init_obexd_receiver(void) obexd_conn = NULL; return BLUETOOTH_ERROR_INTERNAL; } - +#endif BT_DBG("-"); return BLUETOOTH_ERROR_NONE; } +gboolean __bt_reinit_obexd_receiver(gpointer user_data) +{ + static int retry_cnt = 0; + int result = BLUETOOTH_ERROR_NONE; + + BT_DBG("+"); + + result = __bt_init_obexd_receiver(); + if (result != BLUETOOTH_ERROR_NONE) { + /* 20 ms * 50 = 10 seconds. During 10 seconds fail to initialize, + then it is not the timing issue. Just can't use the session bus connection */ + if (retry_cnt > 100) { + BT_ERR("Fail to init obexd receiver by 50 times."); + retry_cnt = 0; + session_reinit_timer = 0; + return FALSE; + } + retry_cnt++; + BT_DBG("Retry to initialize the obexd receiver"); + return TRUE; + } + + retry_cnt = 0; + session_reinit_timer = 0; + + BT_DBG("-"); + + return FALSE; +} + /* To receive the event from bluez */ int _bt_init_service_event_receiver(void) { @@ -3116,9 +3660,17 @@ int _bt_init_service_event_receiver(void) retv_if(result != BLUETOOTH_ERROR_NONE, result); result = __bt_init_obexd_receiver(); - if (result != BLUETOOTH_ERROR_NONE) + if (result != BLUETOOTH_ERROR_NONE) { BT_ERR("Fail to init obexd receiver"); + /* Try to re-initialize obexd receiver in the timer */ + if (session_reinit_timer > 0) + g_source_remove(session_reinit_timer); + + session_reinit_timer = g_timeout_add(BT_SESSION_BUS_GET_TIMEOUT, + (GSourceFunc)__bt_reinit_obexd_receiver, NULL); + } + BT_DBG("-"); return BLUETOOTH_ERROR_NONE; @@ -3132,6 +3684,8 @@ void _bt_deinit_service_event_receiver(void) _bt_unregister_service_event(obexd_conn, BT_OPP_SERVER_EVENT); + __bt_register_dump_subscribe_signal(manager_conn, FALSE); + if (manager_conn) { g_object_unref(manager_conn); manager_conn = NULL; @@ -3144,6 +3698,7 @@ void _bt_deinit_service_event_receiver(void) if (event_id > 0) g_source_remove(event_id); + event_id = 0; BT_DBG("-"); }