#define BT_ADV_FILTER_POLICY_DEFAULT 0x00
#define BT_ADV_TYPE_DEFAULT 0x00
#define BT_ADV_FILTER_POLICY_ALLOW_SCAN_CONN_WL_ONLY 0x03
+#define BT_SCAN_INTERVAL_SPLIT 0.625
+
typedef struct {
int adv_inst_max;
static gboolean is_le_set_scan_parameter = FALSE;
static gboolean is_le_scanning = FALSE;
static gboolean scan_filter_enabled = FALSE;
-static bt_le_scan_type_t le_scan_type = BT_LE_PASSIVE_SCAN;
+static bt_le_scan_type_t le_scan_type = BT_LE_ACTIVE_SCAN;
+static bluetooth_le_scan_params_t le_scan_params = { BT_LE_ACTIVE_SCAN, 0, 0 };
static GSList *gatt_client_senders = NULL;
le_adv_slot = NULL;
}
-int _bt_service_adapter_le_init(void)
+static void __bt_free_le_scanner(bt_adapter_le_scanner_t *scanner)
{
- le_adv_slot = g_malloc0(sizeof(bt_adapter_le_adv_slot_t) * le_feature_info.adv_inst_max);
+ g_free(scanner->sender);
+ g_slist_free_full(scanner->filter_list, g_free);
+ g_free(scanner);
+}
- return BLUETOOTH_ERROR_NONE;
+static void __bt_free_le_scanner_all(void)
+{
+ g_slist_free_full(scanner_list, (GDestroyNotify)__bt_free_le_scanner);
+ scanner_list = NULL;
+
+ scan_filter_enabled = FALSE;
+ is_le_scanning = FALSE;
+ is_le_set_scan_parameter = FALSE;
+ le_scan_params.type = BT_LE_ACTIVE_SCAN;
+ le_scan_params.interval = 0;
+ le_scan_params.window = 0;
}
-void _bt_service_adapter_le_deinit(void)
+int _bt_le_set_max_packet_len(void)
{
- __bt_free_le_adv_slot();
+ int result = BLUETOOTH_ERROR_NONE;
+ int tx_octets, tx_time;
+ bluetooth_le_read_maximum_data_length_t max_len = {0};
+
+ if (BLUETOOTH_ERROR_NONE != _bt_le_read_maximum_data_length(&max_len))
+ return BLUETOOTH_ERROR_INTERNAL;
+
+ if (max_len.max_tx_octets > BT_LE_TX_LEN_DEFAULT) {
+ tx_octets = max_len.max_tx_octets > BT_LE_TX_LEN_MAX ?
+ BT_LE_TX_LEN_MAX : max_len.max_tx_octets;
+ tx_time = BT_LE_TX_TIME_MAX;
+
+ result = _bt_le_write_host_suggested_default_data_length(tx_octets, tx_time);
+
+ BT_DBG("Wrote max packet size : result[%d], MAX[%d], set[%d]",
+ result, max_len.max_tx_octets, tx_octets);
+ }
+
+ return result;
}
gboolean _bt_update_le_feature_support(const char *item, const char *value)
if (item == NULL || value == NULL)
return FALSE;
+ if (!le_adv_slot)
+ _bt_service_adapter_le_init();
+
if (g_strcmp0(item, "adv_inst_max") == 0) {
int slot_num;
return i;
}
- if (le_feature_info.adv_inst_max <= 2)
- i = 0;
- else if (le_feature_info.adv_inst_max > 2 && use_reserved_slot == TRUE)
+ if (le_feature_info.adv_inst_max <= 1)
i = 0;
+ else if (use_reserved_slot == TRUE)
+ i = 1;
else
i = 2;
gboolean status = FALSE;
int i;
+ if (le_adv_slot == NULL)
+ return FALSE;
+
for (i = 0; i < le_feature_info.adv_inst_max; i++) {
if (le_adv_slot[i].is_advertising == TRUE)
status = TRUE;
&error);
if (error) {
+ BT_INFO("SetAdvertising %d, slot_id %d", enable, slot_id);
BT_ERR("SetAdvertising Fail: %s", error->message);
g_clear_error(&error);
return BLUETOOTH_ERROR_INTERNAL;
params->type == BLUETOOTH_ADV_NON_CONNECTABLE)
return BLUETOOTH_ERROR_NOT_SUPPORT;
+ if (params->tx_power_level > 1 ||
+ params->tx_power_level < -127)
+ return BLUETOOTH_ERROR_INVALID_PARAM;
+
min = params->interval_min / BT_ADV_INTERVAL_SPLIT;
max = params->interval_max / BT_ADV_INTERVAL_SPLIT;
ret = g_dbus_proxy_call_sync(proxy, "SetAdvertisingParameters",
- g_variant_new("(uuuui)", min, max,
+ g_variant_new("(uuuuii)", min, max,
params->filter_policy, params->type,
- slot_id), G_DBUS_CALL_FLAGS_NONE,
- -1, NULL, &error);
+ params->tx_power_level, slot_id),
+ G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
if (error) {
BT_ERR("SetAdvertisingParameters Fail: %s", error->message);
adv_params.interval_max = params->interval_max;
adv_params.filter_policy = params->filter_policy;
adv_params.type = params->type;
+ adv_params.tx_power_level = params->tx_power_level;
if (ret)
g_variant_unref(ret);
proxy = _bt_get_adapter_proxy();
retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
+ BT_DBG("inteval %f, win %f, type %d", params->interval, params->window, params->type);
+
if (params->interval < BT_LE_SCAN_INTERVAL_MIN || params->interval > BT_LE_SCAN_INTERVAL_MAX)
return BLUETOOTH_ERROR_INVALID_PARAM;
if (params->window > params->interval)
return BLUETOOTH_ERROR_INVALID_PARAM;
- itv = params->interval / BT_ADV_INTERVAL_SPLIT;
- win = params->window / BT_ADV_INTERVAL_SPLIT;
+ itv = params->interval / BT_SCAN_INTERVAL_SPLIT;
+ win = params->window / BT_SCAN_INTERVAL_SPLIT;
ret = g_dbus_proxy_call_sync(proxy, "SetScanParameters",
g_variant_new("(uuu)", params->type, itv, win),
if (ret)
g_variant_unref(ret);
- BT_INFO("Set scan parameters");
+ BT_INFO("Set scan parameters inteval %f, win %f, type %d",
+ itv * BT_SCAN_INTERVAL_SPLIT, win * BT_SCAN_INTERVAL_SPLIT, params->type);
+ return BLUETOOTH_ERROR_NONE;
+}
+
+int _bt_prepare_scan_parameters(bluetooth_le_scan_params_t *params, int scan_type)
+{
+ if (_bt_adapter_get_status() != BT_ACTIVATED &&
+ _bt_adapter_get_le_status() != BT_LE_ACTIVATED) {
+ return BLUETOOTH_ERROR_DEVICE_NOT_ENABLED;
+ }
+
+ if (params)
+ BT_DBG("inteval %f, win %f", params->interval, params->window);
+ else
+ BT_DBG("type %d", scan_type);
+
+ if (params) {
+ if (params->interval < BT_LE_SCAN_INTERVAL_MIN || params->interval > BT_LE_SCAN_INTERVAL_MAX)
+ return BLUETOOTH_ERROR_INVALID_PARAM;
+
+ if (params->window < BT_LE_SCAN_WINDOW_MIN || params->window > BT_LE_SCAN_WINDOW_MAX)
+ return BLUETOOTH_ERROR_INVALID_PARAM;
+
+ if (params->window > params->interval)
+ return BLUETOOTH_ERROR_INVALID_PARAM;
+
+ le_scan_params.interval = params->interval;
+ le_scan_params.window = params->window;
+ } else {
+ le_scan_params.type = scan_type;
+ if (le_scan_params.interval == 0) {
+ /* Set default scan interval same with BT_ADAPTER_LE_SCAN_MODE_LOW_ENERGY */
+ le_scan_params.interval = 5120;
+ le_scan_params.window = 512;
+ }
+ }
+
+ is_le_set_scan_parameter = TRUE;
+
return BLUETOOTH_ERROR_NONE;
}
return NULL;
}
-int __bt_get_available_scan_filter_slot_id(void)
+static int __bt_get_available_scan_filter_slot_id(void)
{
GSList *l;
bt_adapter_le_scanner_t *scanner;
return FALSE;
}
-int _bt_register_scan_filter(const char *sender, bluetooth_le_scan_filter_t *filter, int *slot_id)
+int _bt_register_scan_filter(const char *sender, bluetooth_le_scan_filter_t *filter)
{
GDBusProxy *proxy;
GError *error = NULL;
bt_adapter_le_scanner_t *scanner = NULL;
bluetooth_le_scan_filter_t *filter_data = NULL;
int feature_selection = 0;
+ int slot_id;
- *slot_id = __bt_get_available_scan_filter_slot_id();
- if (*slot_id == -1)
+ slot_id = __bt_get_available_scan_filter_slot_id();
+ if (slot_id == -1)
return BLUETOOTH_ERROR_NO_RESOURCES;
proxy = _bt_get_adapter_proxy();
0, // client_if
0, // action (Add - 0x00, Delete - 0x01, Clear - 0x02)
BLUETOOTH_LE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS, // filter_type
- *slot_id, // filter_index
+ slot_id, // filter_index
0, // company_id
0, // company_id_mask
arr_uuid_param, // p_uuid
0, // client_if
0, // action (Add - 0x00, Delete - 0x01, Clear - 0x02)
BLUETOOTH_LE_SCAN_FILTER_FEATURE_DEVICE_NAME, // filter_type
- *slot_id, // filter_index
+ slot_id, // filter_index
0, // company_id
0, // company_id_mask
arr_uuid_param, // p_uuid
0, // client_if
0, // action (Add - 0x00, Delete - 0x01, Clear - 0x02)
BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_UUID, // filter_type
- *slot_id, // filter_index
+ slot_id, // filter_index
0, // company_id
0, // company_id_mask
arr_uuid_param, // p_uuid
arr_uuid_mask_param, // p_uuid_mask
- NULL, // string
+ "", // string
0, // address_type
arr_data_param, // p_data
arr_data_mask_param);
0, // client_if
0, // action (Add - 0x00, Delete - 0x01, Clear - 0x02)
BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID, // filter_type
- *slot_id, // filter_index
+ slot_id, // filter_index
0, // company_id
0, // company_id_mask
arr_uuid_param, // p_uuid
arr_uuid_mask_param, // p_uuid_mask
- NULL, // string
+ "", // string
0, // address_type
arr_data_param, // p_data
arr_data_mask_param);
0, // client_if
0, // action (Add - 0x00, Delete - 0x01, Clear - 0x02)
BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_DATA, // filter_type
- *slot_id, // filter_index
+ slot_id, // filter_index
0, // company_id
0, // company_id_mask
arr_uuid_param, // p_uuid
arr_uuid_mask_param, // p_uuid_mask
- NULL, // string
+ "", // string
0, // address_type
arr_data_param, // p_data
arr_data_mask_param);
0, // client_if
0, // action (Add - 0x00, Delete - 0x01, Clear - 0x02)
BLUETOOTH_LE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA, // filter_type
- *slot_id, // filter_index
+ slot_id, // filter_index
filter->manufacturer_id, // company_id
0xFFFF, // company_id_mask
arr_uuid_param, // p_uuid
arr_uuid_mask_param, // p_uuid_mask
- NULL, // string
+ "", // string
0, // address_type
arr_data_param, // p_data
arr_data_mask_param);
param = g_variant_new("(iiiiiiiiiiii)",
0, // client_if
0, // action (Add - 0x00, Delete - 0x01, Clear - 0x02)
- *slot_id, // filter_index
+ slot_id, // filter_index
feature_selection, // feat_seln
0, // list_logic_type (OR - 0x00, AND - 0x01)
1, // filt_logic_type (OR - 0x00, AND - 0x01)
if (scanner) {
filter_data = g_malloc0(sizeof(bluetooth_le_scan_filter_t));
memcpy(filter_data, filter, sizeof(bluetooth_le_scan_filter_t));
- filter_data->slot_id = *slot_id;
+ filter_data->slot_id = slot_id;
scanner->filter_list = g_slist_append(scanner->filter_list, filter_data);
}
return BLUETOOTH_ERROR_NONE;
}
-int _bt_unregister_scan_filter(const char *sender, int slot_id)
-{
- GDBusProxy *proxy;
- GError *error = NULL;
- GVariant *ret;
- bt_adapter_le_scanner_t *scanner = NULL;
- bluetooth_le_scan_filter_t *filter_data = NULL;
- GSList *l;
- gboolean is_slot_id_found = FALSE;
-
- scanner = __bt_find_scanner_from_list(sender);
- if (scanner == NULL) {
- BT_ERR("There is NO available scanner.");
- return BLUETOOTH_ERROR_NOT_FOUND;
- }
-
- for (l = scanner->filter_list; l != NULL; l = g_slist_next(l)) {
- filter_data = l->data;
- if (filter_data->slot_id == slot_id) {
- is_slot_id_found = TRUE;
- break;
- }
- }
- if (is_slot_id_found == FALSE) {
- BT_ERR("There is NO registered slot.");
- return BLUETOOTH_ERROR_NOT_FOUND;
- }
-
- proxy = _bt_get_adapter_proxy();
- retv_if(proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
-
- ret = g_dbus_proxy_call_sync(proxy, "scan_filter_clear",
- g_variant_new("(ii)", 0, slot_id),
- G_DBUS_CALL_FLAGS_NONE,
- -1, NULL, &error);
-
- if (error) {
- BT_ERR("scan_filter_clear Fail: %s", error->message);
- g_clear_error(&error);
- }
-
- scanner->filter_list = g_slist_remove(scanner->filter_list, filter_data);
- g_free(filter_data);
-
- if (ret)
- g_variant_unref(ret);
- return BLUETOOTH_ERROR_NONE;
-}
-
int _bt_unregister_all_scan_filters(const char *sender)
{
GDBusProxy *proxy;
G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
if (error) {
- BT_ERR("scan_filter_clear Fail: %s", error->message);
+ BT_ERR("scan_filter_enable Fail: %s", error->message);
g_clear_error(&error);
}
/* Set default scan parameter same with BT_ADAPTER_LE_SCAN_MODE_LOW_ENERGY */
bluetooth_le_scan_params_t scan_params;
scan_params.type = BT_LE_ACTIVE_SCAN;
- scan_params.interval = 5000;
- scan_params.window = 500;
+ scan_params.interval = 5120;
+ scan_params.window = 512;
_bt_set_scan_parameters(&scan_params);
- }
+ } else
+ _bt_set_scan_parameters(&le_scan_params);
if (scanner->filter_list == NULL) {
BT_INFO("Start LE Full Scan");
G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
if (error) {
- BT_ERR("scan_filter_clear Fail: %s", error->message);
+ BT_ERR("scan_filter_enable Fail: %s", error->message);
g_clear_error(&error);
}
if (scanner == NULL || scanner->is_scanning == FALSE)
return BLUETOOTH_ERROR_NOT_IN_OPERATION;
- scanner->is_scanning = FALSE;
+ _bt_unregister_all_scan_filters(sender);
+
+ scanner_list = g_slist_remove(scanner_list, scanner);
+ __bt_free_le_scanner(scanner);
for (l = scanner_list; l != NULL; l = g_slist_next(l)) {
scanner = l->data;
-1, NULL, &error);
if (error) {
- BT_ERR("scan_filter_clear Fail: %s", error->message);
+ BT_ERR("scan_filter_enable Fail: %s", error->message);
g_clear_error(&error);
}
BT_INFO("Enable LE Scan Filter");
scan_filter_enabled = TRUE;
}
+ BT_INFO("next_scanning exists. Keep the LE scanning");
return BLUETOOTH_ERROR_NONE;
} else {
if (scan_filter_enabled == TRUE) {
-1, NULL, &error);
if (error) {
- BT_ERR("scan_filter_clear Fail: %s", error->message);
+ BT_ERR("scan_filter_enable Fail: %s", error->message);
g_clear_error(&error);
}
ret = g_dbus_proxy_call_sync(proxy, "StopLEDiscovery",
NULL, G_DBUS_CALL_FLAGS_NONE,
-1, NULL, &error);
+ if (error) {
+ BT_ERR("StopLEDiscovery Fail: %s", error->message);
+ g_clear_error(&error);
+ }
+
if (ret == NULL) {
BT_ERR("LE Scan stop failed");
return BLUETOOTH_ERROR_INTERNAL;
scan_filter_enabled = FALSE;
is_le_set_scan_parameter = FALSE;
+ le_scan_params.type = BT_LE_ACTIVE_SCAN;
+ le_scan_params.interval = 0;
+ le_scan_params.window = 0;
if (ret)
g_variant_unref(ret);
return BLUETOOTH_ERROR_NONE;
void _bt_set_le_scan_status(gboolean mode)
{
+ BT_DBG("set is_le_scanning : %d -> %d", is_le_scanning, mode);
is_le_scanning = mode;
}
int scan_data_len = 0;
ret_if(le_dev_info == NULL);
- if (_bt_get_le_scan_type() == BT_LE_ACTIVE_SCAN)
- ret_if(adv_info == NULL);
- if (_bt_get_le_scan_type() == BT_LE_PASSIVE_SCAN) {
+ if (adv_info == NULL) { /* Not received scan response data within 1 sec */
adv_data = le_dev_info->adv_data;
adv_data_len = le_dev_info->adv_data_len;
scan_data = le_dev_info->adv_data;
reply = g_dbus_proxy_call_sync(proxy, "LEReadMaximumDataLength",
NULL, G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
- g_object_unref(proxy);
-
if (reply == NULL) {
BT_ERR("LEReadMaximumDataLength dBUS-RPC failed");
if (error != NULL) {
NULL,
&error);
- g_object_unref(proxy);
-
if (reply == NULL) {
BT_ERR("_bt_le_write_host_suggested_default_data_length dBUS-RPC failed");
if (error != NULL) {
gchar *device_path = NULL;
GDBusConnection *conn;
GDBusProxy *device_proxy;
+ GVariant *result;
_bt_convert_addr_type_to_string(address, device_address->addr);
g_free(device_path);
retv_if(device_proxy == NULL, BLUETOOTH_ERROR_INTERNAL);
- g_dbus_proxy_call_sync(device_proxy,
+ result = g_dbus_proxy_call_sync(device_proxy,
"LESetDataLength",
g_variant_new("(qq)", txOctets, txTime),
G_DBUS_CALL_FLAGS_NONE,
return BLUETOOTH_ERROR_INTERNAL;
}
+ if (result)
+ g_variant_unref(result);
+
return BLUETOOTH_ERROR_NONE;
}
+
+int _bt_service_adapter_le_init(void)
+{
+ le_adv_slot = g_malloc0(sizeof(bt_adapter_le_adv_slot_t) * le_feature_info.adv_inst_max);
+
+ return BLUETOOTH_ERROR_NONE;
+}
+
+void _bt_service_adapter_le_deinit(void)
+{
+ __bt_free_le_adv_slot();
+ __bt_free_le_scanner_all();
+}
projects / platform / core / connectivity / bluetooth-frwk.git / blobdiff