#endif
#include "bt-service-device-internal.h"
+#ifdef TIZEN_GATT_CLIENT
+#include "bt-service-gatt.h"
+#endif
+
/* OAL headers */
#include <oal-event.h>
#include <oal-manager.h>
#include <oal-adapter-mgr.h>
#include <oal-device-mgr.h>
+#if !defined(TIZEN_PROFILE_WEARABLE) && !defined(TIZEN_PROFILE_IOT)
#define MAX_BOND_RETRY_COUNT 3
+#endif
#define BT_PASSKEY_MAX_LENGTH 4
+#define BT_LE_CONN_PARAM_DEFAULT_SUPERVISION_TIMEOUT 6000 /* msec */
+
+#define BT_LE_CONN_PARAM_BALANCED_MIN_INTERVAL 30 /* msec */
+#define BT_LE_CONN_PARAM_BALANCED_MAX_INTERVAL 50 /* msec */
+#define BT_LE_CONN_PARAM_BALANCED_SLAVE_LATENCY 0 /* event */
+
+#define BT_LE_CONN_PARAM_LOW_LATENCY_MIN_INTERVAL 10 /* msec */
+#define BT_LE_CONN_PARAM_LOW_LATENCY_MAX_INTERVAL 30 /* msec */
+#define BT_LE_CONN_PARAM_LOW_LATENCY_SLAVE_LATENCY 0 /* event */
+
+#define BT_LE_CONN_PARAM_LOW_POWER_MIN_INTERVAL 80 /* msec */
+#define BT_LE_CONN_PARAM_LOW_POWER_MAX_INTERVAL 100 /* msec */
+#define BT_LE_CONN_PARAM_LOW_POWER_SLAVE_LATENCY 2 /* event */
+
/* Bonding Info structure */
typedef struct {
int result;
/* BT device bond state variable */
static bt_bond_state_e bt_device_bond_state;
+#if !defined(TIZEN_PROFILE_WEARABLE) && !defined(TIZEN_PROFILE_IOT)
static int bond_retry_count;
+#endif
static char *passkey_watcher;
static GSList *pin_info_list = NULL;
+/** DBFW+ Event Code */
+typedef enum {
+ BT_DBFW_PLUS_EVENT_CODE_LINK_LOSS_INFO = 0x10,
+ BT_DBFW_PLUS_EVENT_CODE_LINK_LOSS_CLOCK_INFO = 0x11,
+ BT_DBFW_PLUS_EVENT_CODE_LINK_LOSS_PAGE_SLOTS = 0x12,
+ BT_DBFW_PLUS_EVENT_CODE_LINK_LOSS_LMP_TRACE = 0x13,
+ BT_DBFW_PLUS_EVENT_CODE_A2DP_INFO = 0x20,
+ BT_DBFW_PLUS_EVENT_CODE_HFP_INFO = 0x31,
+ BT_DBFW_PLUS_EVENT_CODE_HFP_SCO_PACKET_TYPE_INFO = 0x32,
+} bt_dbfw_plus_event_code_t;
+
+static int dbfw_rssi;
+
+#ifdef TIZEN_GATT_CLIENT
+typedef struct {
+ char *address;
+ float interval_min;
+ float interval_max;
+ GSList *senders;
+} bt_connected_le_dev_t;
+
+typedef struct {
+ char *sender;
+ float interval_min;
+ float interval_max;
+ guint16 latency;
+ guint16 time_out;
+ float key;
+} bt_le_conn_param_t;
+
+static GSList *le_connected_dev_list = NULL;
+
+#define BT_LE_CONN_INTERVAL_MIN 7.5 /* msec */
+#define BT_LE_CONN_INTERVAL_MAX 4000 /* msec */
+#define BT_LE_CONN_SUPER_TO_MIN 100 /* msec */
+#define BT_LE_CONN_SUPER_TO_MAX 32000 /* msec */
+#define BT_LE_CONN_SLAVE_LATENCY_MAX 499
+#define BT_LE_CONN_TO_SPLIT 10 /* msec */
+#define BT_LE_CONN_INTERVAL_SPLIT 1.25 /* msec */
+
+static void _bt_handle_le_connected_dev_info(const char *address, gboolean connected);
+#endif
+
/* Forward declaration */
static void __bt_device_event_handler(int event_type, gpointer event_data);
static void __bt_device_remote_device_found_callback(gpointer event_data, gboolean is_ble);
static void __bt_device_handle_bond_removal_event(bt_address_t *bd_addr);
static void __bt_device_handle_bond_failed_event(event_dev_bond_failed_t* bond_fail_event);
static void __bt_handle_ongoing_bond(bt_remote_dev_info_t *remote_dev_info, gboolean incoming_bond);
-static void __bt_device_conn_state_changed_callback(event_dev_conn_status_t *acl_event,
+static void __bt_device_acl_state_changed_callback(event_dev_conn_status_t *acl_event,
gboolean connected, unsigned char type);
static void __bt_free_pairing_info(bt_pairing_data_t **p_info);
static void __bt_device_trusted_callback(gboolean trusted, event_dev_trust_t* info);
static int __bt_get_device_pin_code(const char *address, char *pin_code);
+static gboolean __bt_ignore_auto_pairing_request(const char *address);
gboolean _bt_is_device_creating(void)
{
BT_DBG("+");
/* Get method invocation context */
- for (l = _bt_get_invocation_list(); l != NULL; l = g_slist_next(l)) {
+ for (l = _bt_get_invocation_list(); l != NULL; ) {
req_info = l->data;
+ l = g_slist_next(l);
if (req_info == NULL || req_info->service_function != service_function)
continue;
BT_ERR("Unexpected: Info request pending for a different address!!");
return;
} else {
- BT_INFO("Found info request addr [%s]", (char*)req_info->user_data);
+ BT_DBG("Found info request addr [%s]", (char*)req_info->user_data);
bt_sdp_info_t sdp_info;
memset(&sdp_info, 0x00, sizeof(bt_sdp_info_t));
g_array_append_vals(out_param, &sdp_info, sizeof(bt_sdp_info_t));
_bt_service_method_return(req_info->context, out_param, result);
- g_free(req_info->user_data);
_bt_free_info_from_invocation_list(req_info);
g_array_free(out_param, TRUE);
}
BT_ERR("Unexpected: Info request pending for a different address!!");
return;
} else {
- BT_INFO("Found info request addr [%s]", (char*)req_info->user_data);
+ BT_DBG("Found info request addr [%s]", (char*)req_info->user_data);
bluetooth_device_info_t dev_info;
memset(&dev_info, 0x00, sizeof(bluetooth_device_info_t));
_bt_convert_addr_string_to_type(dev_info.device_address.addr,
sizeof(bluetooth_device_info_t));
_bt_service_method_return(req_info->context, out_param, result);
- g_free(req_info->user_data);
_bt_free_info_from_invocation_list(req_info);
g_array_free(out_param, TRUE);
}
BT_ERR("Unexpected: Info request pending for a different address!!");
return;
} else {
- BT_INFO("Found info request addr [%s]", (char*)req_info->user_data);
+ BT_DBG("Found info request addr [%s]", (char*)req_info->user_data);
bluetooth_device_address_t dev_addr;
_bt_convert_addr_string_to_type(dev_addr.addr, address);
out_param = g_array_new(FALSE, FALSE, sizeof(gchar));
sizeof(bluetooth_device_address_t));
_bt_service_method_return(req_info->context, out_param, result);
- g_free(req_info->user_data);
_bt_free_info_from_invocation_list(req_info);
g_array_free(out_param, TRUE);
}
break;
}
}
- BT_INFO("-");
+ BT_DBG("-");
}
/*
{
bt_remote_dev_info_t *rem_info = NULL;
- BT_DBG("+");
rem_info = g_malloc0(sizeof(bt_remote_dev_info_t));
_bt_copy_remote_dev(rem_info, &(oal_dev_props->device_info));
/* a. Check if bonding is on-going, if yes, we MUST update the bonding device properties */
if (trigger_bond_info && !strcmp(trigger_bond_info->addr, rem_info->address)) {
- BT_INFO("Bonding is ongoing, try update properties");
+ BT_DBG("Bonding is ongoing, try update properties");
if (!trigger_bond_info->dev_info ||
(!trigger_bond_info->dev_info->name &&
- !incoming_bond_info->dev_info->alias) ||
+ !trigger_bond_info->dev_info->alias) ||
!trigger_bond_info->dev_info->address ||
trigger_bond_info->dev_info->uuid_count == 0) {
- BT_INFO("Complete data is not present, Assigning rem_info");
+ BT_DBG("Complete data is not present, Assigning rem_info");
if (!trigger_bond_info->dev_info)
trigger_bond_info->dev_info = g_malloc0(sizeof(bt_remote_dev_info_t));
_bt_copy_remote_dev_info(trigger_bond_info->dev_info, rem_info);
BT_DBG("Bonding dev addr has matched with remote dev properties address [%s]", rem_info->address);
__bt_handle_ongoing_bond(trigger_bond_info->dev_info, FALSE);
} else if (incoming_bond_info && !g_strcmp0(incoming_bond_info->addr, rem_info->address)) {
- BT_INFO("Incoming Bond is ongoing, try update properties");
+ BT_DBG("Incoming Bond is ongoing, try update properties");
if (!incoming_bond_info->dev_info ||
(!incoming_bond_info->dev_info->name &&
!incoming_bond_info->dev_info->alias) ||
!incoming_bond_info->dev_info->address ||
incoming_bond_info->dev_info->uuid_count == 0) {
- BT_INFO("Complete data is not present, Assigning rem_info");
+ BT_DBG("Complete data is not present, Assigning rem_info");
if (!incoming_bond_info->dev_info)
incoming_bond_info->dev_info = g_malloc0(sizeof(bt_remote_dev_info_t));
_bt_copy_remote_dev_info(incoming_bond_info->dev_info, rem_info);
}
_bt_free_remote_dev(rem_info);
- BT_DBG("-");
}
static int __get_oal_trusted_profile(bluetooth_trusted_profile_t profile)
result = device_set_trust_profile(&bd_addr, oal_profile, trust);
if (result != OAL_STATUS_SUCCESS) {
BT_ERR("device_set_trust_profile error: [%d]", result);
- return BLUETOOTH_ERROR_INTERNAL;
+ return _bt_convert_oal_status_to_bt_error(result);
}
BT_DBG("-");
result = device_get_trust_profile(&bd_addr, oal_profile, trust);
if (result != OAL_STATUS_SUCCESS) {
BT_ERR("device_set_trust_profile error: [%d]", result);
- return BLUETOOTH_ERROR_INTERNAL;
+ return _bt_convert_oal_status_to_bt_error(result);
}
BT_DBG("-");
_bt_convert_addr_type_to_string(address, auth_event->address.addr);
- BT_INFO("service_d: %d", service_d);
+ BT_DBG("service_d: %d", service_d);
switch (service_d) {
case HID_SERVICE_ID:
- BT_INFO("Incoming HID Profile conn Req from device addr [%s]", address);
+ BT_DBG("Incoming HID Profile conn Req from device addr [%s]", address);
break;
case A2DP_SERVICE_ID:
- BT_INFO("Incoming A2DP(Remote Sink) profile conn Req from device addr [%s]", address);
+ BT_DBG("Incoming A2DP(Remote Sink) profile conn Req from device addr [%s]", address);
_bt_a2dp_src_handle_incoming_authorization(address, service_d);
return;
case A2DP_SRC_SERVICE_ID:
- BT_INFO("Incoming A2DP(Remote Source) Profile conn Req from device addr [%s]", address);
+ BT_DBG("Incoming A2DP(Remote Source) Profile conn Req from device addr [%s]", address);
_bt_a2dp_sink_handle_incoming_authorization(address, service_d);
break;
case AVRCP_SERVICE_ID:
- BT_INFO("Incoming AVRCP (Remote) Profile conn Req from device addr [%s]", address);
+ BT_DBG("Incoming AVRCP (Remote) Profile conn Req from device addr [%s]", address);
break;
case AVRCP_CT_SERVICE_ID:
- BT_INFO("Incoming AVRCP (Controller) Profile conn Req from device addr [%s]", address);
+ BT_DBG("Incoming AVRCP (Controller) Profile conn Req from device addr [%s]", address);
break;
#ifdef TIZEN_FEATURE_BT_OBEX
case OPP_SERVICE_ID: {
GVariant *param = NULL;
- char *name = g_strdup(address); /* TODO: Retrieve and send correct name in OBEX conn auth req event */
+ char *name = NULL;
+
+ if (_bt_obex_server_is_custom() == false) {
+ /* Allow the connection for native OPP server */
+ break;
+ }
+
+ name = g_strdup(address);
- BT_INFO("Incoming OPP conn Req from device addr [%s]", address);
+ BT_DBG("Incoming OPP conn Req from device addr [%s]", address);
_bt_obex_server_set_pending_conn_auth_device_addr(address);
param = g_variant_new("(iss)", BLUETOOTH_ERROR_NONE, address, name);
_bt_send_event(BT_OPP_SERVER_EVENT,
}
#endif
case HSP_SERVICE_ID:
- BT_INFO("Incoming HSP_SERVICE_ID conn Req from device addr [%s]", address);
+ BT_DBG("Incoming HSP_SERVICE_ID conn Req from device addr [%s]", address);
break;
case HFP_SERVICE_ID:
- BT_INFO("Incoming HFP_SERVICE_ID conn Req from device addr [%s]", address);
+ BT_DBG("Incoming HFP_SERVICE_ID conn Req from device addr [%s]", address);
break;
case SAP_SERVICE_ID:
- BT_INFO("Incoming SAP_SERVICE_ID conn Req from device addr [%s]", address);
+ BT_DBG("Incoming SAP_SERVICE_ID conn Req from device addr [%s]", address);
break;
case HSP_HS_SERVICE_ID:
- BT_INFO("Incoming HSP_HS_SERVICE_ID conn Req from device addr [%s]", address);
+ BT_DBG("Incoming HSP_HS_SERVICE_ID conn Req from device addr [%s]", address);
break;
case HFP_HS_SERVICE_ID:
- BT_INFO("Incoming HFP_HS_SERVICE_ID conn Req from device addr [%s]", address);
+ BT_DBG("Incoming HFP_HS_SERVICE_ID conn Req from device addr [%s]", address);
break;
#ifdef TIZEN_BT_HAL
case IOTIVITY_SERVICE_ID:
- BT_INFO("Incoming IOTIVITY_SERVICE_ID conn Req from device addr [%s]", address);
+ BT_DBG("Incoming IOTIVITY_SERVICE_ID conn Req from device addr [%s]", address);
break;
#endif
default:
/* For now, reject authorization for any service apart from above switch cases */
- BT_INFO("Incoming Profile conn req with service ID [%d] from device addr [%s]", service_d, address);
+ BT_DBG("Incoming Profile conn req with service ID [%d] from device addr [%s]", service_d, address);
res = device_reply_auth_request((bt_address_t*)&auth_event->address, service_d, FALSE, FALSE);
if (res != OAL_STATUS_SUCCESS)
BT_ERR("authorize_response: %d", res);
res = device_reply_auth_request((bt_address_t*)&auth_event->address, service_d, TRUE, FALSE);
if (res != OAL_STATUS_SUCCESS)
BT_ERR("authorize_response: %d", res);
- BT_INFO("-");
}
static void __bt_handle_ongoing_bond(bt_remote_dev_info_t *remote_dev_info, gboolean incoming_bond)
{
GVariant *param = NULL;
- BT_DBG("+");
if ((remote_dev_info->name || remote_dev_info->alias)
&& remote_dev_info->address
&& remote_dev_info->uuids) {
- BT_INFO("All properties updated, time to send bonding finished event");
GVariant *uuids = NULL;
GVariantBuilder *builder = NULL;
GVariant *manufacturer_data;
_bt_send_event(BT_ADAPTER_EVENT,
BLUETOOTH_EVENT_BONDING_FINISHED,
param);
+ BT_PERMANENT_LOG("Paired %s", remote_dev_info->address + 12);
+ BT_INFO_C("### Paired %s", remote_dev_info->address + 12);
if (incoming_bond) {
__bt_free_bond_info(BT_DEVICE_INCOMING_BOND_INFO);
} else {
char address[BT_ADDRESS_STRING_SIZE];
bluetooth_device_address_t dev_addr;
- BT_INFO("+");
-
/*
* BlueZ sends paired signal for each paired device, during activation,
* We should ignore this, otherwise application thinks that a new device
__bt_free_bond_info(BT_DEVICE_INCOMING_BOND_INFO);
}
- BT_INFO("-");
}
static void __bt_device_handle_bond_completion_event(bt_address_t *bd_addr)
gchar address[BT_ADDRESS_STR_LEN];
bluetooth_device_address_t dev_addr;
- BT_INFO("+");
-
if (trigger_bond_info == NULL) {
/* Send reply */
BT_DBG("trigger_bond_info == NULL, Handle incomming bond event");
return;
}
- BT_INFO("Bonding successfully completed");
/* Bonding state will be cleaned up & BONDING FINISHED EVENT
will be sent only when Properties are fetched from stack
Till that time lets not free trigger_bond_info.
trigger_bond_info->addr);
if (_bt_device_get_bonded_device_info(&dev_addr) == BLUETOOTH_ERROR_NONE) {
- BT_DBG("BOnded device info query posted to stack successfully");
+ BT_DBG("Bonded device info query posted to stack successfully");
__bt_device_handle_pending_requests(BLUETOOTH_ERROR_NONE, BT_BOND_DEVICE,
trigger_bond_info->addr, BT_ADDRESS_STRING_SIZE);
} else {
__bt_free_bond_info(BT_DEVICE_BOND_INFO);
__bt_free_pairing_info(&trigger_pairing_info);
}
-
- BT_INFO("-");
}
/**********************************************************************************************
{
char address[BT_ADDRESS_STRING_SIZE];
- BT_INFO("+");
-
_bt_convert_addr_type_to_string(address, bd_addr->addr);
_bt_service_remove_device_from_bonded_list(address);
if (trigger_unbond_info) {
- BT_INFO("Bond removal request successfully handled, return DBUS and send event");
+ BT_DBG("Bond removal request successfully handled, return DBUS and send event");
GVariant *param = NULL;
__bt_device_handle_pending_requests(BLUETOOTH_ERROR_NONE, BT_UNBOND_DEVICE,
trigger_unbond_info->addr, BT_ADDRESS_STRING_SIZE);
_bt_send_event(BT_ADAPTER_EVENT,
BLUETOOTH_EVENT_BONDED_DEVICE_REMOVED,
param);
+ BT_PERMANENT_LOG("Unpaired %s", trigger_unbond_info->addr + 12);
__bt_free_bond_info(BT_DEVICE_UNBOND_INFO);
__bt_free_pairing_info(&trigger_pairing_info);
} else if (trigger_bond_info) {
BT_ERR("Bonding was removed");
__bt_device_handle_bond_state();
}
- BT_INFO("-");
}
static void __bt_device_handle_bond_failed_event(event_dev_bond_failed_t* bond_fail_event)
case OAL_STATUS_RMT_DEVICE_DOWN:
{
if (trigger_bond_info) {
+#if !defined(TIZEN_PROFILE_WEARABLE) && !defined(TIZEN_PROFILE_IOT)
BT_INFO("OAL_STATUS_RMT_DEVICE_DOWN:Lets retry bonding!! retry count [%d]",
bond_retry_count);
int ret = OAL_STATUS_SUCCESS;
} else
bond_retry_count++;
} else {
+#endif
BT_ERR("Create Bond failed MAX_BOND_RETRY_COUNT TIMES!!");
__bt_device_handle_pending_requests(BLUETOOTH_ERROR_INTERNAL, BT_BOND_DEVICE,
trigger_bond_info->addr, BT_ADDRESS_STRING_SIZE);
__bt_free_bond_info(BT_DEVICE_BOND_INFO);
__bt_free_pairing_info(&trigger_pairing_info);
+#if !defined(TIZEN_PROFILE_WEARABLE) && !defined(TIZEN_PROFILE_IOT)
bond_retry_count = 0;
}
+#endif
}
break;
}
To be considered later*/
int result = BLUETOOTH_ERROR_INTERNAL;
BT_INFO("BT_OPERATION_STATUS_AUTH_FAILED");
+
+ BT_INFO("add device in pairing black list");
+ _bt_set_autopair_status_in_bonding_info(FALSE);
+
if (trigger_bond_info) {
+ __bt_ignore_auto_pairing_request(trigger_bond_info->addr);
BT_ERR("Create Bond procedure could not suceed, check if cancelled by User");
if (trigger_bond_info->is_cancelled_by_user) {
BT_ERR("Bonding is cancelled by user");
__bt_free_pairing_info(&trigger_pairing_info);
break;
}
+ case OAL_STATUS_ALREADY_CONNECT:
+ {
+ int result = BLUETOOTH_ERROR_ALREADY_CONNECT;
+ BT_INFO("OAL_STATUS_ALREADY_CONNECT");
+
+ if (trigger_bond_info) {
+ __bt_device_handle_pending_requests(result, BT_BOND_DEVICE,
+ trigger_bond_info->addr, BT_ADDRESS_STRING_SIZE);
+ __bt_free_bond_info(BT_DEVICE_BOND_INFO);
+ }
+ break;
+ }
case OAL_STATUS_INTERNAL_ERROR:
{
BT_INFO("OAL_STATUS_INTERNAL_ERROR");
BT_INFO("-");
}
+static gboolean __bt_device_init_dbfw_rssi_cb(gpointer user_data)
+{
+ dbfw_rssi = 0;
+ return FALSE;
+}
+
+static void __bt_device_parse_dbfw_set_rssi(unsigned char *data, uint32_t length)
+{
+ ret_if(length < 5);
+ dbfw_rssi = 0xFFFFFF00 | data[4];
+ BT_INFO("dbfw_rssi = %d", dbfw_rssi);
+ g_timeout_add(1000, __bt_device_init_dbfw_rssi_cb, NULL);
+}
+
+static void __bt_device_dbfw_plus_info_callback(event_dev_dbfw_plus_info_t *dbfw_info)
+{
+ char evt_str[18];
+ char *data_str = NULL;
+ int i;
+
+ data_str = g_malloc0(dbfw_info->length * 2 + 1);
+ for (i = 0; i < dbfw_info->length; i++)
+ snprintf(&data_str[i * 2], 3, "%02X", dbfw_info->data[i]);
+ data_str[i * 2] = '\0';
+
+ switch(dbfw_info->event_code) {
+ case BT_DBFW_PLUS_EVENT_CODE_LINK_LOSS_INFO:
+ BT_DBG("## Event Code: Linkloss Debug Info");
+ snprintf(evt_str, 18, "[DBFW]Linkloss(D)");
+ __bt_device_parse_dbfw_set_rssi(dbfw_info->data, dbfw_info->length);
+ break;
+ case BT_DBFW_PLUS_EVENT_CODE_LINK_LOSS_CLOCK_INFO:
+ BT_DBG("## Event Code: Linkloss Clock Info");
+ snprintf(evt_str, 18, "[DBFW]Linkloss(C)");
+ break;
+ case BT_DBFW_PLUS_EVENT_CODE_LINK_LOSS_PAGE_SLOTS:
+ BT_DBG("## Event Code: Linkloss Page slots");
+ snprintf(evt_str, 18, "[DBFW]Linkloss(P)");
+ break;
+ case BT_DBFW_PLUS_EVENT_CODE_LINK_LOSS_LMP_TRACE:
+ BT_DBG("## Event Code: Linkloss LMP trace");
+ snprintf(evt_str, 18, "[DBFW]Linkloss(L)");
+ break;
+ case BT_DBFW_PLUS_EVENT_CODE_A2DP_INFO:
+ BT_DBG("## Event Code: A2DP Info");
+ snprintf(evt_str, 18, "[DBFW]A2DP");
+ break;
+ case BT_DBFW_PLUS_EVENT_CODE_HFP_INFO:
+ BT_DBG("## Event Code: HFP Info");
+ snprintf(evt_str, 18, "[DBFW]HFP");
+ break;
+ case BT_DBFW_PLUS_EVENT_CODE_HFP_SCO_PACKET_TYPE_INFO:
+ BT_DBG("## Event Code: HFP SCO Packet Type");
+ snprintf(evt_str, 18, "[DBFW]SCO");
+ break;
+ default:
+ BT_DBG("## Unknown event code (0x%02x)", dbfw_info->event_code);
+ snprintf(evt_str, 18, "[DBFW]0x%02X", dbfw_info->event_code);
+ break;
+ }
+
+ BT_PERMANENT_LOG("%s 0x%s", evt_str, data_str);
+ g_free(data_str);
+}
+
static void __bt_device_event_handler(int event_type, gpointer event_data)
{
int eventcheck = OAL_EVENT_DEVICE_PROPERTIES;
- BT_INFO("event [%d] Event check = [%d]", event_type, eventcheck);
+ BT_DBG("event [%d] Event check = [%d]", event_type, eventcheck);
switch (event_type) {
case OAL_EVENT_ADAPTER_INQUIRY_RESULT_BREDR_ONLY: {
break;
}
case OAL_EVENT_DEVICE_ACL_CONNECTED: {
- BT_INFO("ACL Connected event Received");
- event_dev_conn_status_t* param = event_data;
- __bt_device_conn_state_changed_callback(param, TRUE, 0);
+ BT_DBG("ACL Connected event Received");
+ __bt_device_acl_state_changed_callback((event_dev_conn_status_t *)event_data, TRUE, 0);
break;
}
case OAL_EVENT_DEVICE_ACL_DISCONNECTED: {
- BT_INFO("ACL Disconnected event Received");
- __bt_device_conn_state_changed_callback((event_dev_conn_status_t *)event_data, FALSE, 0);
+ BT_DBG("ACL Disconnected event Received");
+ __bt_device_acl_state_changed_callback((event_dev_conn_status_t *)event_data, FALSE, 0);
break;
}
case OAL_EVENT_DEVICE_LE_CONNECTED: {
- BT_INFO("LE Connected event Received");
- event_dev_conn_status_t* param = event_data;
- __bt_device_conn_state_changed_callback(param, TRUE, 1);
+ BT_DBG("LE Connected event Received");
+ __bt_device_acl_state_changed_callback((event_dev_conn_status_t *)event_data, TRUE, 1);
break;
}
case OAL_EVENT_DEVICE_LE_DISCONNECTED: {
- BT_INFO("LE Disconnected event Received");
- __bt_device_conn_state_changed_callback((event_dev_conn_status_t *)event_data, FALSE, 1);
+ BT_DBG("LE Disconnected event Received");
+ __bt_device_acl_state_changed_callback((event_dev_conn_status_t *)event_data, FALSE, 1);
break;
}
case OAL_EVENT_DEVICE_PIN_REQUEST: {
BLUETOOTH_EVENT_SUPPORTED_PROFILE_TRUSTED,
g_variant_new("(isi)", BLUETOOTH_ERROR_NONE,
address, ev->trust_val));
+ break;
}
case OAL_EVENT_RSSI_MONITORING_ENABLED: {
event_dev_rssi_info_t *ev = event_data;
_bt_send_event(BT_DEVICE_EVENT, BLUETOOTH_EVENT_RAW_RSSI, param);
break;
}
+ case OAL_EVENT_DEVICE_DBFW_PLUS_INFO: {
+ __bt_device_dbfw_plus_info_callback((event_dev_dbfw_plus_info_t*)event_data);
+ break;
+ }
default:
BT_INFO("Unhandled event..");
}
GVariant *param;
char address[BT_ADDRESS_STRING_SIZE];
char pin_code[BLUETOOTH_PIN_CODE_MAX_LENGTH + 1];
+ bool incoming = false;
BT_DBG("+");
_bt_convert_addr_type_to_string(address, pin_req_event->address.addr);
device_accept_pin_request(&pin_req_event->address, str_passkey);
BT_DBG("Send BLUETOOTH_EVENT_KEYBOARD_PASSKEY_DISPLAY");
- param = g_variant_new("(isss)", BLUETOOTH_ERROR_NONE, address, pin_req_event->name, str_passkey);
+
+ if(trigger_bond_info == NULL)
+ incoming = true;
+
+ param = g_variant_new("(bsss)", incoming, address, pin_req_event->name, str_passkey);
_bt_send_event(BT_ADAPTER_EVENT,
BLUETOOTH_EVENT_KEYBOARD_PASSKEY_DISPLAY, param);
BT_DBG("Key board pairing in process");
trigger_pairing_info->is_ssp = FALSE;
BT_DBG("Send BLUETOOTH_EVENT_PIN_REQUEST");
- param = g_variant_new("(iss)", BLUETOOTH_ERROR_NONE, address, pin_req_event->name);
+
+ if(trigger_bond_info == NULL)
+ incoming = true;
+
+ param = g_variant_new("(bss)", incoming, address, pin_req_event->name);
_bt_send_event(BT_ADAPTER_EVENT,
BLUETOOTH_EVENT_PIN_REQUEST, param);
}
gchar address[BT_ADDRESS_STR_LEN];
char *p_addr;
gchar *name;
- int result = BLUETOOTH_ERROR_NONE;
+ bool incoming = false;
+
BT_DBG("+");
_bt_convert_addr_type_to_string(address, dev_info->address.addr);
trigger_pairing_info->addr = g_strdup(address);
trigger_pairing_info->is_ssp = TRUE;
- param = g_variant_new("(iss)", result, p_addr, name);
+ if(trigger_bond_info == NULL)
+ incoming = true;
+
+ param = g_variant_new("(bss)", incoming, p_addr, name);
_bt_send_event(BT_ADAPTER_EVENT,
BLUETOOTH_EVENT_PASSKEY_REQUEST, param);
BT_DBG("-");
char *p_addr;
gchar *name;
char str_passkey[7];
- int result = BLUETOOTH_ERROR_NONE;
+ bool incoming = false; /*Stores if bonding request is incoming(true) or outgoing(false) */
BT_DBG("+");
_bt_convert_addr_type_to_string(address, dev_info->device_info.address.addr);
BT_DBG("Send BLUETOOTH_EVENT_PASSKEY_CONFIRMATION");
snprintf(str_passkey, sizeof(str_passkey), "%.6d", dev_info->pass_key);
- param = g_variant_new("(isss)", result, p_addr, name, str_passkey);
+ /*Storing if bond is incoming or outgoing*/
+ if(trigger_bond_info == NULL)
+ incoming = true;
+
+ param = g_variant_new("(bsss)", incoming, p_addr, name, str_passkey);
_bt_send_event(BT_ADAPTER_EVENT,
BLUETOOTH_EVENT_PASSKEY_CONFIRM_REQUEST, param);
BT_DBG("-");
char *p_addr;
gchar *name;
char str_passkey[7];
- int result = BLUETOOTH_ERROR_NONE;
+ bool incoming = false;
BT_DBG("+");
_bt_convert_addr_type_to_string(address, dev_info->device_info.address.addr);
BT_DBG("Send BLUETOOTH_EVENT_KEYBOARD_PASSKEY_DISPLAY");
snprintf(str_passkey, sizeof(str_passkey), "%06d", dev_info->pass_key);
- param = g_variant_new("(isss)", result, p_addr, name, str_passkey);
+ if(trigger_bond_info == NULL)
+ incoming = true;
+
+ param = g_variant_new("(bsss)", incoming, p_addr, name, str_passkey);
+
if (passkey_watcher) {
BT_INFO("Send passkey to %s", passkey_watcher);
_bt_send_event_to_dest(passkey_watcher, BT_ADAPTER_EVENT,
BT_DBG("-");
}
-static void __bt_device_conn_state_changed_callback(event_dev_conn_status_t *acl_event,
+static void __bt_device_acl_state_changed_callback(event_dev_conn_status_t *acl_event,
gboolean connected, unsigned char type)
{
gchar address[BT_ADDRESS_STR_LEN];
- int result = BLUETOOTH_ERROR_NONE;
+ int disc_reason = 0;
GVariant *param = NULL;
bt_device_conn_info_t conn_info;
- BT_DBG("+");
_bt_convert_addr_type_to_string(address, acl_event->address.addr);
+ _bt_logging_connection(connected, type);
+
+ disc_reason = acl_event->status;
+
if (connected) {
- param = g_variant_new("(isy)", result, address, type);
+ BT_PERMANENT_LOG("Connected %s %s", !type ? "EDR" : "LE", address + 12);
+ param = g_variant_new("(isy)", BLUETOOTH_ERROR_NONE, address, type);
_bt_send_event(BT_DEVICE_EVENT,
BLUETOOTH_EVENT_DEVICE_CONNECTED,
param);
} else {
- param = g_variant_new("(isy)", result, address, type);
+ BT_PERMANENT_LOG("Disconnected %s(%d) %s", !type ? "EDR" : "LE", disc_reason, address + 12);
+ param = g_variant_new("(isyi)", disc_reason, address, type, dbfw_rssi);
_bt_send_event(BT_DEVICE_EVENT,
BLUETOOTH_EVENT_DEVICE_DISCONNECTED,
param);
/* Update local cache */
_bt_update_remote_dev_property(address, DEV_PROP_CONNECTED, (void *)&conn_info);
- BT_DBG("-");
+#ifdef TIZEN_GATT_CLIENT
+ /*handle LE connected device info*/
+ if (type)
+ _bt_handle_le_connected_dev_info(address, connected);
+#endif
+
}
static void __bt_device_remote_device_found_callback(gpointer event_data, gboolean is_ble)
GVariantBuilder *builder = NULL;
unsigned int i;
- BT_INFO("+");
ret_if(_bt_is_discovering() == FALSE);
ret_if(event_data == NULL);
param);
_bt_free_remote_dev(dev_info);
- BT_DBG("-");
}
static void __bt_device_trusted_callback(gboolean trusted, event_dev_trust_t* info)
int result = BLUETOOTH_ERROR_NONE;
GVariant *param = NULL;
int event;
- BT_DBG("+");
_bt_convert_addr_type_to_string(address, info->address.addr);
event,
param);
- BT_DBG("-");
}
static void __bt_free_pairing_info(bt_pairing_data_t **p_info)
{
- BT_DBG("+");
bt_pairing_data_t * info = *p_info;
if (info) {
if (info->addr)
g_free(info);
}
*p_info = NULL;
- BT_DBG("-");
}
static void __bt_free_bond_info(uint8_t type)
{
- BT_INFO("+");
-
switch (type) {
case BT_DEVICE_BOND_INFO:
if (!trigger_bond_info)
trigger_unbond_info = NULL;
break;
}
- BT_INFO("-");
}
static void __bt_free_service_search_info(bt_service_search_info_data_t **p_info)
static int __bt_device_handle_bond_state(void)
{
- BT_INFO("Current Bond state: %d", bt_device_bond_state);
+ BT_DBG("Current Bond state: %d", bt_device_bond_state);
int ret = OAL_STATUS_INTERNAL_ERROR;
switch (bt_device_bond_state) {
}
if (ret != OAL_STATUS_SUCCESS)
- return BLUETOOTH_ERROR_INTERNAL;
+ return _bt_convert_oal_status_to_bt_error(ret);
else
return BLUETOOTH_ERROR_NONE;
}
int result;
bt_address_t bd_addr;
- BT_DBG("+");
-
retv_if(!addr, BLUETOOTH_ERROR_INVALID_PARAM);
memcpy(bd_addr.addr, addr, BLUETOOTH_ADDRESS_LENGTH);
result = device_query_attributes(&bd_addr);
if (result != OAL_STATUS_SUCCESS) {
BT_ERR("device_query_attributes error: [%d]", result);
- return BLUETOOTH_ERROR_INTERNAL;
+ return _bt_convert_oal_status_to_bt_error(result);
}
- BT_DBG("-");
return BLUETOOTH_ERROR_NONE;
}
int ret;
char address[BT_ADDRESS_STRING_SIZE];
- BT_DBG("+");
BT_CHECK_PARAMETER(alias, return);
ret = device_set_alias((bt_address_t *)device_address, (char *)alias);
if (ret != OAL_STATUS_SUCCESS) {
BT_ERR("device_set_alias: %d", ret);
- return BLUETOOTH_ERROR_INTERNAL;
+ return _bt_convert_oal_status_to_bt_error(ret);
}
/* Update local cache */
_bt_convert_addr_type_to_string(address, device_address->addr);
_bt_update_remote_dev_property(address, DEV_PROP_ALIAS, (void *)alias);
- BT_DBG("-");
return BLUETOOTH_ERROR_NONE;
}
int result = BLUETOOTH_ERROR_NONE;
char address[BT_ADDRESS_STRING_SIZE] = { 0 };
bluetooth_device_info_t dev_info;
- BT_DBG("+");
+ const char *stack_name = NULL;
retv_if(device_address == NULL, BLUETOOTH_ERROR_INVALID_PARAM);
/* Ready to initiate bonding */
- /* In Tizen, we will first remove bond and then attempt to create bond to keep
- consistency with bluedroid. Even if remove bond fails due to device not already
- bonded, then straight away create bond is triggered. This is because, remove bond
- is handled differently in bluedroid and bluez. In Bluez, if device is
- already removed, remove bond call fails.
- However in bluedroid, remove bond on already removed device returns success. So we will
- handle the cases transparently*/
- bt_device_bond_state = BT_DEVICE_BOND_STATE_REMOVE_BONDING;
+ stack_name = oal_get_stack_name();
+ if (stack_name && !g_strcmp0(stack_name, "bluez")) {
+ BT_DBG("[bluez] Create bond by type %d", conn_type);
+ bt_device_bond_state = BT_DEVICE_BOND_STATE_REMOVED_BONDING;
+ } else {
+ /* In Tizen, we will first remove bond and then attempt to create bond to keep
+ consistency with bluedroid. Even if remove bond fails due to device not already
+ bonded, then straight away create bond is triggered. This is because, remove bond
+ is handled differently in bluedroid and bluez. In Bluez, if device is
+ already removed, remove bond call fails.
+ However in bluedroid, remove bond on already removed device returns success. So we will
+ handle the cases transparently */
+ bt_device_bond_state = BT_DEVICE_BOND_STATE_REMOVE_BONDING;
+ }
+
+#if !defined(TIZEN_PROFILE_WEARABLE) && !defined(TIZEN_PROFILE_IOT)
bond_retry_count = 0;
+#endif
result = __bt_device_handle_bond_state();
if (result != BLUETOOTH_ERROR_NONE)
goto fail;
- BT_DBG("-");
return result;
fail:
sizeof(bluetooth_device_info_t));
__bt_free_bond_info(BT_DEVICE_BOND_INFO);
- BT_DBG("-");
return result;
}
int result = OAL_STATUS_SUCCESS;
char address[BT_ADDRESS_STRING_SIZE] = { 0 };
bluetooth_device_info_t dev_info;
- BT_INFO("+");
retv_if(device_address == NULL, BLUETOOTH_ERROR_INVALID_PARAM);
if (result != OAL_STATUS_SUCCESS)
goto fail;
- return result;
+ return BLUETOOTH_ERROR_NONE;
fail:
memset(&dev_info, 0x00, sizeof(bluetooth_device_info_t));
sizeof(bluetooth_device_info_t));
__bt_free_bond_info(BT_DEVICE_UNBOND_INFO);
- return result;
+ return _bt_convert_oal_status_to_bt_error(result);
}
int _bt_cancel_bonding(void)
if (ret != OAL_STATUS_SUCCESS) {
BT_ERR("_bt_device_handle_passkey_reply: err [%d]", ret);
- return BLUETOOTH_ERROR_INTERNAL;
+ return _bt_convert_oal_status_to_bt_error(ret);
}
BT_INFO("-");
if (result != OAL_STATUS_SUCCESS) {
BT_ERR("Device Service Search Failed..: %d", result);
__bt_free_service_search_info(&service_search_info);
- return BLUETOOTH_ERROR_INTERNAL;
+ return _bt_convert_oal_status_to_bt_error(result);
}
return BLUETOOTH_ERROR_NONE;
}
if (ret != OAL_STATUS_SUCCESS) {
BT_ERR("SDP Cancel request failed [%d]", ret);
- return BLUETOOTH_ERROR_INTERNAL;
+ return _bt_convert_oal_status_to_bt_error(ret);
}
__bt_device_handle_pending_requests(BLUETOOTH_ERROR_CANCEL_BY_USER, BT_SEARCH_SERVICE,
ret = device_set_authorized((bt_address_t*)device_address, authorize);
if (ret != OAL_STATUS_SUCCESS) {
BT_ERR("device_set_authorized: %d", ret);
- return BLUETOOTH_ERROR_INTERNAL;
+ return _bt_convert_oal_status_to_bt_error(ret);
}
return BLUETOOTH_ERROR_NONE;
case BT_PROFILE_CONN_HSP:
svc_id = HFP_HS_SERVICE_ID; /* Remote is HFP HF Unit */
break;
+ case BT_PROFILE_CONN_HFG:
+ svc_id = HFP_SERVICE_ID; /* Remote is HFP AG Unit */
+ break;
+#ifdef TIZEN_GATT_CLIENT
+ case BT_PROFILE_CONN_GATT:
+ return _bt_is_remote_gatt_device_connected(device_address); /* Remote is GATT client or Server */
+#endif
default:
BT_DBG("Unknown svc_type: %d", svc_type);
return FALSE;
res = device_reply_auth_request(&bd_addr, 0, reply, FALSE);
if (res != OAL_STATUS_SUCCESS) {
BT_ERR("authorize_response: %d", res);
- return BLUETOOTH_ERROR_INTERNAL;
+ return _bt_convert_oal_status_to_bt_error(res);
}
BT_DBG("-");
low_threshold, in_range_threshold, high_threshold);
if (result != OAL_STATUS_SUCCESS) {
BT_ERR("device_get_connected_link_rssi_strength error: [%d]", result);
- return BLUETOOTH_ERROR_INTERNAL;
+ return _bt_convert_oal_status_to_bt_error(result);
}
BT_DBG("-");
result = device_get_connected_link_rssi_strength(&bd_addr, link_type);
if (result != OAL_STATUS_SUCCESS) {
BT_ERR("device_get_connected_link_rssi_strength error: [%d]", result);
- return BLUETOOTH_ERROR_INTERNAL;
+ return _bt_convert_oal_status_to_bt_error(result);
}
BT_DBG("-");
BT_INFO("Set passkey notification(sender:%s, %s)",
sender, enable ? "Enable" : "Disable");
- result = device_enable_gap_auth_notifications(OAL_PASSKEY_DISPLAY,enable);
+ result = device_enable_gap_auth_notifications(OAL_PASSKEY_DISPLAY, enable);
if (OAL_STATUS_SUCCESS != result) {
BT_ERR("device_enable_gap_auth_notifications error: [%d]", result);
- return BLUETOOTH_ERROR_INTERNAL;
+ return _bt_convert_oal_status_to_bt_error(result);
}
g_free(passkey_watcher);
if (g_strcmp0(pin_info->address, address) == 0) {
pin_info_list = g_slist_remove(pin_info_list, pin_info);
- g_free(pin_info->pin_code);
+ g_free(pin_info->address);
g_free(pin_info->pin_code);
g_free(pin_info);
break;
BT_DBG("-");
return BLUETOOTH_ERROR_NONE;
}
+
+int _bt_device_get_ida(bluetooth_device_address_t *device_address, bluetooth_device_address_t *id_address)
+{
+ int result = BLUETOOTH_ERROR_NONE;
+ char address[BT_ADDRESS_STRING_SIZE] = { 0 };
+
+ _bt_convert_addr_type_to_string(address, device_address->addr);
+
+ BT_DBG("getting IDA for remote device: [%s]", address);
+
+ result = device_get_ida((bt_address_t*)device_address, (bt_address_t*)id_address);
+
+ if (result != OAL_STATUS_SUCCESS) {
+ BT_ERR("device_get_ida Failed %d", result);
+ return _bt_convert_oal_status_to_bt_error(result);
+ }
+
+ return result;
+}
+
+#ifdef TIZEN_GATT_CLIENT
+static bt_connected_le_dev_t *__bt_get_le_connected_dev_info(const char *address)
+{
+ GSList *l = NULL;
+ bt_connected_le_dev_t *dev;
+
+ if (!address)
+ return NULL;
+
+ for (l = le_connected_dev_list; l; l = g_slist_next(l)) {
+ dev = l->data;
+
+ if (g_strcmp0(dev->address, address) == 0)
+ return dev;
+ }
+ return NULL;
+}
+
+static void __bt_le_conn_param_free(void *data)
+{
+ bt_le_conn_param_t *param = (bt_le_conn_param_t *)data;
+
+ BT_DBG("%s", param->sender);
+ g_free(param->sender);
+ g_free(param);
+}
+
+static void _bt_add_le_connected_dev_info(const char *address)
+{
+ bt_connected_le_dev_t *dev = NULL;
+
+ if (!address)
+ return;
+
+ dev = g_malloc0(sizeof(bt_connected_le_dev_t));
+ dev->address = g_strdup(address);
+
+ le_connected_dev_list = g_slist_append(le_connected_dev_list, dev);
+
+ return;
+}
+
+static void _bt_remove_le_connected_dev_info(const char *address)
+{
+ bt_connected_le_dev_t *dev = NULL;
+
+ if (!address)
+ return;
+
+ dev = __bt_get_le_connected_dev_info(address);
+ if (!dev)
+ return;
+
+ g_slist_free_full(dev->senders, __bt_le_conn_param_free);
+ le_connected_dev_list = g_slist_remove(le_connected_dev_list, dev);
+ g_free(dev->address);
+ g_free(dev);
+
+ return;
+}
+
+static void _bt_handle_le_connected_dev_info(const char *address, gboolean connected)
+{
+ BT_DBG("update le_connected_dev_list");
+
+ if (connected)
+ _bt_add_le_connected_dev_info(address);
+ else
+ _bt_remove_le_connected_dev_info(address);
+}
+
+static bt_le_conn_param_t *__bt_get_le_conn_param_info(bt_connected_le_dev_t *dev, const char *sender)
+{
+ GSList *l = NULL;
+ bt_le_conn_param_t *param = NULL;
+
+ if (!dev || !sender)
+ return NULL;
+
+ for (l = dev->senders; l; l = g_slist_next(l)) {
+ param = l->data;
+ if (g_strcmp0(param->sender, sender) == 0)
+ return param;
+ }
+
+ return NULL;
+}
+
+static gint __bt_compare_le_conn_param_key(gpointer *a, gpointer *b)
+{
+ bt_le_conn_param_t *parama = (bt_le_conn_param_t *)a;
+ bt_le_conn_param_t *paramb = (bt_le_conn_param_t *)b;
+
+ return parama->key > paramb->key;
+}
+
+
+int _bt_add_le_conn_param_info(const char *address, const char *sender,
+ float interval_min, float interval_max, guint16 latency, guint16 time_out)
+{
+ bt_connected_le_dev_t *dev = NULL;
+ bt_le_conn_param_t *param = NULL;
+ bt_le_conn_param_t *data = NULL;
+
+ if (!address || !sender)
+ return BLUETOOTH_ERROR_INVALID_PARAM;
+
+ dev = __bt_get_le_connected_dev_info(address);
+ if (!dev)
+ return BLUETOOTH_ERROR_INTERNAL;
+
+ param = __bt_get_le_conn_param_info(dev, sender);
+
+ data = g_malloc0(sizeof(bt_le_conn_param_t));
+ data->sender = g_strdup(sender);
+ data->interval_min = interval_min;
+ data->interval_max = interval_max;
+ data->latency = latency;
+ data->time_out = time_out;
+ data->key = interval_min + (interval_max - interval_min)/2;
+
+ if (param == NULL) {
+ BT_DBG("Add param %s %s %f %f", address, sender, interval_min, interval_max);
+ dev->senders = g_slist_append(dev->senders, data);
+ } else {
+ BT_DBG("Update param %s %s %f %f", address, sender, interval_min, interval_max);
+ dev->senders = g_slist_remove(dev->senders, param);
+ g_free(param->sender);
+ g_free(param);
+ dev->senders = g_slist_append(dev->senders, data);
+ }
+
+ /* Sorting. First element have the minimum interval */
+ dev->senders = g_slist_sort(dev->senders,
+ (GCompareFunc)__bt_compare_le_conn_param_key);
+
+ return BLUETOOTH_ERROR_NONE;
+}
+
+
+static int __bt_le_set_conn_parameter(const char *address,
+ float interval_min, float interval_max,
+ guint16 latency, guint16 time_out)
+{
+ bt_address_t dev_addr = { {0} };
+ guint32 min, max, to;
+
+ BT_INFO("Min interval: %f, Max interval: %f, Latency: %u, Supervision timeout: %u",
+ interval_min, interval_max, latency, time_out);
+
+ min = interval_min / BT_LE_CONN_INTERVAL_SPLIT;
+ max = interval_max / BT_LE_CONN_INTERVAL_SPLIT;
+ to = time_out / BT_LE_CONN_TO_SPLIT;
+
+ BT_DBG("updating: Min interval: %d, Max interval: %d, Latency: %d, Supervision timeout: %d",
+ min, max, latency, to);
+
+ _bt_convert_addr_string_to_type(dev_addr.addr, address);
+
+ return gattc_conn_param_update(&dev_addr, min, max, latency, to);
+}
+
+int _bt_remove_le_conn_param_info(const char *address, const char *sender)
+{
+ bt_connected_le_dev_t *dev = NULL;
+ bt_le_conn_param_t *param = NULL;
+
+ if (!address || !sender)
+ return BLUETOOTH_ERROR_INVALID_PARAM;
+
+ dev = __bt_get_le_connected_dev_info(address);
+ if (!dev)
+ return BLUETOOTH_ERROR_INTERNAL;
+
+ param = __bt_get_le_conn_param_info(dev, sender);
+ if (param) {
+ BT_DBG("Remove param %s %s ", address, sender);
+ dev->senders = g_slist_remove(dev->senders, param);
+ g_free(param->sender);
+ g_free(param);
+ }
+
+ return BLUETOOTH_ERROR_NONE;
+}
+
+int _bt_get_le_connection_parameter(bluetooth_le_connection_mode_t mode,
+ bluetooth_le_connection_param_t *param)
+{
+ if (param == NULL)
+ return BLUETOOTH_ERROR_INVALID_PARAM;
+
+ memset(param, 0x00, sizeof(bluetooth_le_connection_param_t));
+
+ switch (mode) {
+ case BLUETOOTH_LE_CONNECTION_MODE_BALANCED:
+ param->interval_min = BT_LE_CONN_PARAM_BALANCED_MIN_INTERVAL;
+ param->interval_max = BT_LE_CONN_PARAM_BALANCED_MAX_INTERVAL;
+ param->latency = BT_LE_CONN_PARAM_BALANCED_SLAVE_LATENCY;
+ param->timeout = BT_LE_CONN_PARAM_DEFAULT_SUPERVISION_TIMEOUT;
+ break;
+
+ case BLUETOOTH_LE_CONNECTION_MODE_LOW_LATENCY:
+ param->interval_min = BT_LE_CONN_PARAM_LOW_LATENCY_MIN_INTERVAL;
+ param->interval_max = BT_LE_CONN_PARAM_LOW_LATENCY_MAX_INTERVAL;
+ param->latency = BT_LE_CONN_PARAM_LOW_LATENCY_SLAVE_LATENCY;
+ param->timeout = BT_LE_CONN_PARAM_DEFAULT_SUPERVISION_TIMEOUT;
+ break;
+
+ case BLUETOOTH_LE_CONNECTION_MODE_LOW_POWER:
+ param->interval_min = BT_LE_CONN_PARAM_LOW_POWER_MIN_INTERVAL;
+ param->interval_max = BT_LE_CONN_PARAM_LOW_POWER_MAX_INTERVAL;
+ param->latency = BT_LE_CONN_PARAM_LOW_POWER_SLAVE_LATENCY;
+ param->timeout = BT_LE_CONN_PARAM_DEFAULT_SUPERVISION_TIMEOUT;
+ break;
+
+ default:
+ BT_ERR("Unhandled mode : %d", mode);
+ break;
+ }
+
+ return BLUETOOTH_ERROR_NONE;
+}
+
+int _bt_le_connection_update(const char *sender,
+ unsigned char *device_address,
+ float interval_min, float interval_max,
+ guint16 latency, guint16 time_out)
+{
+ char address[BT_ADDRESS_STRING_SIZE] = { 0 };
+ guint32 min_supervision_to;
+ bt_connected_le_dev_t *dev = NULL;
+ bt_le_conn_param_t *param = NULL;
+ int ret = BLUETOOTH_ERROR_NONE;
+
+ BT_CHECK_PARAMETER(device_address, return);
+
+ BT_DBG("Sender %s, Min interval: %f, Max interval: %f, Latency: %u, Supervision timeout: %u",
+ sender, interval_min, interval_max, latency, time_out);
+
+ if (interval_min > interval_max ||
+ interval_min < BT_LE_CONN_INTERVAL_MIN ||
+ interval_max > BT_LE_CONN_INTERVAL_MAX) {
+ ret = BLUETOOTH_ERROR_INVALID_PARAM;
+ goto fail;
+ }
+
+ if (time_out < BT_LE_CONN_SUPER_TO_MIN ||
+ time_out > BT_LE_CONN_SUPER_TO_MAX) {
+ ret = BLUETOOTH_ERROR_INVALID_PARAM;
+ goto fail;
+ }
+
+ if (latency > BT_LE_CONN_SLAVE_LATENCY_MAX) {
+ ret = BLUETOOTH_ERROR_INVALID_PARAM;
+ goto fail;
+ }
+
+ /*
+ * The Supervision_Timeout in milliseconds shall be larger than
+ * (1 + Conn_Latency) * Conn_Interval_Max * 2,
+ * where Conn_Interval_Max is given in milliseconds.
+ */
+
+ min_supervision_to = (1 + latency) * interval_max * 2;
+ if (time_out <= min_supervision_to) {
+ ret = BLUETOOTH_ERROR_INVALID_PARAM;
+ goto fail;
+ }
+
+ _bt_convert_addr_type_to_string(address, device_address);
+ BT_DBG("Remote device address: %s", address);
+
+ _bt_add_le_conn_param_info(address, sender, interval_min, interval_max, 0, 2000);
+
+ dev = __bt_get_le_connected_dev_info(address);
+ if (dev == NULL) {
+ BT_ERR("device not found in the list");
+ ret = BLUETOOTH_ERROR_NOT_CONNECTED;
+ goto fail;
+ }
+
+ if (g_slist_length(dev->senders) == 1)
+ goto update;
+ else {
+ param = dev->senders->data;
+
+ BT_DBG("dev %f, param %f, input %f", dev->interval_min, param->interval_min, interval_min);
+
+ if (dev->interval_min == param->interval_min && dev->interval_max == param->interval_max) {
+ BT_DBG("Skip due to same interval");
+ return ret;
+ }
+
+ interval_min = param->interval_min;
+ interval_max = param->interval_max;
+ }
+
+update:
+ ret = __bt_le_set_conn_parameter(address, interval_min, interval_max, latency, time_out);
+
+ if (ret != OAL_STATUS_SUCCESS) {
+ _bt_remove_le_conn_param_info(address, sender);
+ BT_DBG("fail to update the LE connection parameter");
+ ret = _bt_convert_oal_status_to_bt_error(ret);
+ goto fail;
+ }
+
+ dev->interval_min = interval_min;
+ dev->interval_max = interval_max;
+
+ return BLUETOOTH_ERROR_NONE;
+fail:
+ return ret;
+}
+
+int _bt_disconnect_device(bluetooth_device_address_t *device_address)
+{
+ int result = OAL_STATUS_SUCCESS;
+
+ BT_DBG("+");
+
+ retv_if(!device_address, BLUETOOTH_ERROR_INVALID_PARAM);
+
+ result = device_disconnect((bt_address_t *)device_address);
+ if (result != OAL_STATUS_SUCCESS) {
+ BT_DBG("Failed to disconnect device");
+ return _bt_convert_oal_status_to_bt_error(result);
+ }
+
+ BT_DBG("-");
+ return BLUETOOTH_ERROR_NONE;
+}
+
+static gboolean __bt_ignore_auto_pairing_request(const char *address)
+{
+ gchar *buffer;
+ char **lines;
+ int i;
+ char lap_address[BT_LOWER_ADDRESS_LENGTH + 1] = {0,};
+ char *temp_buffer;
+ FILE *fp;
+ long size;
+ size_t result;
+
+ BT_DBG("+\n");
+
+ if (address == NULL)
+ return FALSE;
+
+ /* Get the LAP(Lower Address part) */
+ /* User BT_LOWER_ADDRESS_LENGTH+1 for lap_address to accomodate
+ a "," */
+ snprintf(lap_address, sizeof(lap_address), ",%s", address);
+
+ fp = fopen(BT_AGENT_AUTO_PAIR_BLACKLIST_FILE, "r");
+
+ if (fp == NULL) {
+ BT_ERR("fopen failed \n");
+ return FALSE;
+ }
+
+ fseek(fp, 0, SEEK_END);
+ size = ftell(fp);
+ rewind(fp);
+
+ if (size < 0) {
+ BT_ERR("Get file size failed \n");
+ fclose(fp);
+ return FALSE;
+ }
+
+ buffer = g_malloc0(sizeof(char) * size);
+ result = fread((char *)buffer, 1, size, fp);
+ fclose(fp);
+ if (result != size) {
+ BT_ERR("Read Error\n");
+ g_free(buffer);
+ return FALSE;
+ }
+
+ lines = g_strsplit_set(buffer, BT_AGENT_NEW_LINE, 0);
+ g_free(buffer);
+
+ if (lines == NULL)
+ return FALSE;
+
+ /* Write the data and insert new device data */
+ for (i = 0; lines[i] != NULL; i++) {
+ if (g_str_has_prefix(lines[i], "AddressBlacklist")) {
+ temp_buffer = g_strconcat(lines[i], lap_address, NULL);
+ g_free(lines[i]);
+ lines[i] = temp_buffer;
+ }
+ }
+ buffer = g_strjoinv(BT_AGENT_NEW_LINE, lines);
+ g_strfreev(lines);
+ /* Fix : NULL_RETURNS */
+ retv_if(buffer == NULL, FALSE);
+
+ fp = fopen(BT_AGENT_AUTO_PAIR_BLACKLIST_FILE, "w");
+
+ if (fp == NULL) {
+ BT_ERR("fopen failed \n");
+ g_free(buffer);
+ return FALSE;
+ }
+
+ BT_DBG("Buffer = %s\n", buffer);
+ fwrite(buffer, 1, strlen(buffer), fp);
+ fclose(fp);
+
+ g_free(buffer);
+
+ BT_DBG("-\n");
+
+ return FALSE;
+}
+#endif
projects / platform / core / connectivity / bluetooth-frwk.git / blobdiff