From: Luiz Augusto von Dentz <[email protected]>
This enables the client to set its discoverable setting while
discovering which is very typical situation as usually the setings
application would allow incoming pairing request while scanning, so
this would reduce the number of calls setting Discoverable and
DiscoverableTimeout and restoring after done with discovery.
---
doc/adapter-api.txt | 6 ++++++
1 file changed, 6 insertions(+)
diff --git a/doc/adapter-api.txt b/doc/adapter-api.txt
index d14d0ca50..4791af2c7 100644
--- a/doc/adapter-api.txt
+++ b/doc/adapter-api.txt
@@ -113,6 +113,12 @@ Methods void StartDiscovery()
generated for either ManufacturerData and
ServiceData everytime they are discovered.
+ bool Discoverable (Default: false)
+
+ Make adapter discoverable while discovering,
+ if the adapter is already discoverable this
+ setting this filter won't do anything.
+
When discovery filter is set, Device objects will be
created as new devices with matching criteria are
discovered regardless of they are connectable or
--
2.17.1
On Thu, 2018-07-26 at 17:17 +0300, Luiz Augusto von Dentz wrote:
> From: Luiz Augusto von Dentz <[email protected]>
>
> This implements the discovery filter discoverable and tracks which
> clients had enabled it and restores the settings when the last client
> enabling it exits.
As mentioned on IRC, this does not work if the Discoverable filter is
set after the discovery has started. So:
discoverable off
scan on
scan.discoverable on
show <- this will show "Discoverable" still off.
Once this works, I'll re-test and push this patch to gnome-bluetooth
which uses the new functionality when available:
https://gitlab.gnome.org/GNOME/gnome-bluetooth/merge_requests/1
From: Luiz Augusto von Dentz <[email protected]>
If the discovery has been stopped and the client has set filters those
should be put back into filter list since the client may still be
interested in using them the next time it start a scanning.
---
src/adapter.c | 25 ++++++++++++++++---------
1 file changed, 16 insertions(+), 9 deletions(-)
diff --git a/src/adapter.c b/src/adapter.c
index bd9edddc6..822bd3472 100644
--- a/src/adapter.c
+++ b/src/adapter.c
@@ -1854,7 +1854,7 @@ static bool set_filtered_discoverable(struct btd_adapter *adapter, bool enable)
return set_discoverable(adapter, enable, 0);
}
-static void discovery_remove(struct watch_client *client)
+static void discovery_remove(struct watch_client *client, bool exit)
{
struct btd_adapter *adapter = client->adapter;
@@ -1882,7 +1882,11 @@ static void discovery_remove(struct watch_client *client)
set_filtered_discoverable(adapter, false);
}
- discovery_free(client);
+ if (!exit && client->discovery_filter)
+ adapter->set_filter_list = g_slist_prepend(
+ adapter->set_filter_list, client);
+ else
+ discovery_free(client);
/*
* If there are other client discoveries in progress, then leave
@@ -1911,8 +1915,11 @@ static void stop_discovery_complete(uint8_t status, uint16_t length,
goto done;
}
- if (client->msg)
+ if (client->msg) {
g_dbus_send_reply(dbus_conn, client->msg, DBUS_TYPE_INVALID);
+ dbus_message_unref(client->msg);
+ client->msg = NULL;
+ }
adapter->discovery_type = 0x00;
adapter->discovery_enable = 0x00;
@@ -1925,7 +1932,7 @@ static void stop_discovery_complete(uint8_t status, uint16_t length,
trigger_passive_scanning(adapter);
done:
- discovery_remove(client);
+ discovery_remove(client, false);
}
static int compare_sender(gconstpointer a, gconstpointer b)
@@ -2146,14 +2153,14 @@ static int update_discovery_filter(struct btd_adapter *adapter)
return -EINPROGRESS;
}
-static int discovery_stop(struct watch_client *client)
+static int discovery_stop(struct watch_client *client, bool exit)
{
struct btd_adapter *adapter = client->adapter;
struct mgmt_cp_stop_discovery cp;
/* Check if there are more client discovering */
if (g_slist_next(adapter->discovery_list)) {
- discovery_remove(client);
+ discovery_remove(client, exit);
update_discovery_filter(adapter);
return 0;
}
@@ -2163,7 +2170,7 @@ static int discovery_stop(struct watch_client *client)
* and so it is enough to send out the signal and just return.
*/
if (adapter->discovery_enable == 0x00) {
- discovery_remove(client);
+ discovery_remove(client, exit);
adapter->discovering = false;
g_dbus_emit_property_changed(dbus_conn, adapter->path,
ADAPTER_INTERFACE, "Discovering");
@@ -2188,7 +2195,7 @@ static void discovery_disconnect(DBusConnection *conn, void *user_data)
DBG("owner %s", client->owner);
- discovery_stop(client);
+ discovery_stop(client, true);
}
/*
@@ -2586,7 +2593,7 @@ static DBusMessage *stop_discovery(DBusConnection *conn,
if (client->msg)
return btd_error_busy(msg);
- err = discovery_stop(client);
+ err = discovery_stop(client, false);
switch (err) {
case 0:
return dbus_message_new_method_return(msg);
--
2.17.1
From: Luiz Augusto von Dentz <[email protected]>
This implements scan.clear for discoverable filter.
---
client/main.c | 9 ++++++++-
1 file changed, 8 insertions(+), 1 deletion(-)
diff --git a/client/main.c b/client/main.c
index 6e6f6d2fb..1a66a3ab4 100644
--- a/client/main.c
+++ b/client/main.c
@@ -1416,6 +1416,11 @@ static void filter_clear_duplicate(void)
filter.duplicate = false;
}
+static void filter_clear_discoverable(void)
+{
+ filter.discoverable = false;
+}
+
struct clear_entry {
const char *name;
void (*clear) (void);
@@ -1427,6 +1432,7 @@ static const struct clear_entry filter_clear[] = {
{ "pathloss", filter_clear_pathloss },
{ "transport", filter_clear_transport },
{ "duplicate-data", filter_clear_duplicate },
+ { "discoverable", filter_clear_discoverable },
{}
};
@@ -2539,7 +2545,8 @@ static const struct bt_shell_menu scan_menu = {
{ "discoverable", "[on/off]", cmd_scan_filter_discoverable,
"Set/Get discoverable filter",
NULL },
- { "clear", "[uuids/rssi/pathloss/transport/duplicate-data]",
+ { "clear",
+ "[uuids/rssi/pathloss/transport/duplicate-data/discoverable]",
cmd_scan_filter_clear,
"Clears discovery filter.",
filter_clear_generator },
--
2.17.1
From: Luiz Augusto von Dentz <[email protected]>
This adds discoverable command to scan menu which can be used to set
if adapter should become discoverable while scanning:
[bluetooth]# scan.discoverable on
[bluetooth]# scan on
SetDiscoveryFilter success
[CHG] Controller XX:XX:XX:XX:XX:XX Discoverable: yes
Discovery started
[CHG] Controller XX:XX:XX:XX:XX:XX Discovering: yes
[bluetooth]# scan off
Discovery stopped
[CHG] Controller XX:XX:XX:XX:XX:XX Discoverable: no
---
client/main.c | 29 +++++++++++++++++++++++++++++
1 file changed, 29 insertions(+)
diff --git a/client/main.c b/client/main.c
index 6f472d050..6e6f6d2fb 100644
--- a/client/main.c
+++ b/client/main.c
@@ -1166,6 +1166,7 @@ static struct set_discovery_filter_args {
char **uuids;
size_t uuids_len;
dbus_bool_t duplicate;
+ dbus_bool_t discoverable;
bool set;
} filter = {
.rssi = DISTANCE_VAL_INVALID,
@@ -1205,6 +1206,11 @@ static void set_discovery_filter_setup(DBusMessageIter *iter, void *user_data)
DBUS_TYPE_BOOLEAN,
&args->duplicate);
+ if (args->discoverable)
+ g_dbus_dict_append_entry(&dict, "Discoverable",
+ DBUS_TYPE_BOOLEAN,
+ &args->discoverable);
+
dbus_message_iter_close_container(iter, &dict);
}
@@ -1362,6 +1368,26 @@ static void cmd_scan_filter_duplicate_data(int argc, char *argv[])
filter.set = false;
}
+static void cmd_scan_filter_discoverable(int argc, char *argv[])
+{
+ if (argc < 2 || !strlen(argv[1])) {
+ bt_shell_printf("Discoverable: %s\n",
+ filter.discoverable ? "on" : "off");
+ return bt_shell_noninteractive_quit(EXIT_SUCCESS);
+ }
+
+ if (!strcmp(argv[1], "on"))
+ filter.discoverable = true;
+ else if (!strcmp(argv[1], "off"))
+ filter.discoverable = false;
+ else {
+ bt_shell_printf("Invalid option: %s\n", argv[1]);
+ return bt_shell_noninteractive_quit(EXIT_FAILURE);
+ }
+
+ filter.set = false;
+}
+
static void filter_clear_uuids(void)
{
g_strfreev(filter.uuids);
@@ -2510,6 +2536,9 @@ static const struct bt_shell_menu scan_menu = {
{ "duplicate-data", "[on/off]", cmd_scan_filter_duplicate_data,
"Set/Get duplicate data filter",
NULL },
+ { "discoverable", "[on/off]", cmd_scan_filter_discoverable,
+ "Set/Get discoverable filter",
+ NULL },
{ "clear", "[uuids/rssi/pathloss/transport/duplicate-data]",
cmd_scan_filter_clear,
"Clears discovery filter.",
--
2.17.1
From: Luiz Augusto von Dentz <[email protected]>
This implements the discovery filter discoverable and tracks which
clients had enabled it and restores the settings when the last client
enabling it exits.
---
src/adapter.c | 56 +++++++++++++++++++++++++++++++++++++++++++++++++--
1 file changed, 54 insertions(+), 2 deletions(-)
diff --git a/src/adapter.c b/src/adapter.c
index f92c897c7..bd9edddc6 100644
--- a/src/adapter.c
+++ b/src/adapter.c
@@ -157,6 +157,7 @@ struct discovery_filter {
int16_t rssi;
GSList *uuids;
bool duplicate;
+ bool discoverable;
};
struct watch_client {
@@ -214,6 +215,7 @@ struct btd_adapter {
bool discovering; /* discovering property state */
bool filtered_discovery; /* we are doing filtered discovery */
+ bool filtered_discoverable; /* we are doing filtered discovery */
bool no_scan_restart_delay; /* when this flag is set, restart scan
* without delay */
uint8_t discovery_type; /* current active discovery type */
@@ -1842,6 +1844,16 @@ static void discovery_free(void *user_data)
g_free(client);
}
+static bool set_filtered_discoverable(struct btd_adapter *adapter, bool enable)
+{
+ if (adapter->filtered_discoverable == enable)
+ return true;
+
+ adapter->filtered_discoverable = enable;
+
+ return set_discoverable(adapter, enable, 0);
+}
+
static void discovery_remove(struct watch_client *client)
{
struct btd_adapter *adapter = client->adapter;
@@ -1854,6 +1866,22 @@ static void discovery_remove(struct watch_client *client)
adapter->discovery_list = g_slist_remove(adapter->discovery_list,
client);
+ if (adapter->filtered_discoverable &&
+ client->discovery_filter->discoverable) {
+ GSList *l;
+
+ for (l = adapter->discovery_list; l; l = g_slist_next(l)) {
+ struct watch_client *client = l->data;
+
+ if (client->discovery_filter->discoverable)
+ break;
+ }
+
+ /* Disable filtered discoverable if there are no clients */
+ if (!l)
+ set_filtered_discoverable(adapter, false);
+ }
+
discovery_free(client);
/*
@@ -2224,6 +2252,15 @@ static DBusMessage *start_discovery(DBusConnection *conn,
adapter->set_filter_list, client);
adapter->discovery_list = g_slist_prepend(
adapter->discovery_list, client);
+
+ /* Reset discoverable filter if already set */
+ if (adapter->current_settings & MGMT_OP_SET_DISCOVERABLE)
+ goto done;
+
+ /* Set discoverable if filter requires and it*/
+ if (client->discovery_filter->discoverable)
+ set_filtered_discoverable(adapter, true);
+
goto done;
}
@@ -2348,6 +2385,17 @@ static bool parse_duplicate_data(DBusMessageIter *value,
return true;
}
+static bool parse_discoverable(DBusMessageIter *value,
+ struct discovery_filter *filter)
+{
+ if (dbus_message_iter_get_arg_type(value) != DBUS_TYPE_BOOLEAN)
+ return false;
+
+ dbus_message_iter_get_basic(value, &filter->discoverable);
+
+ return true;
+}
+
struct filter_parser {
const char *name;
bool (*func)(DBusMessageIter *iter, struct discovery_filter *filter);
@@ -2357,6 +2405,7 @@ struct filter_parser {
{ "Pathloss", parse_pathloss },
{ "Transport", parse_transport },
{ "DuplicateData", parse_duplicate_data },
+ { "Discoverable", parse_discoverable },
{ }
};
@@ -2396,6 +2445,7 @@ static bool parse_discovery_filter_dict(struct btd_adapter *adapter,
(*filter)->rssi = DISTANCE_VAL_INVALID;
(*filter)->type = get_scan_type(adapter);
(*filter)->duplicate = false;
+ (*filter)->discoverable = false;
dbus_message_iter_init(msg, &iter);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
@@ -2441,8 +2491,10 @@ static bool parse_discovery_filter_dict(struct btd_adapter *adapter,
goto invalid_args;
DBG("filtered discovery params: transport: %d rssi: %d pathloss: %d "
- " duplicate data: %s ", (*filter)->type, (*filter)->rssi,
- (*filter)->pathloss, (*filter)->duplicate ? "true" : "false");
+ " duplicate data: %s discoverable %s", (*filter)->type,
+ (*filter)->rssi, (*filter)->pathloss,
+ (*filter)->duplicate ? "true" : "false",
+ (*filter)->discoverable ? "true" : "false");
return true;
--
2.17.1
On Wed, 2018-08-01 at 14:59 +0300, Luiz Augusto von Dentz wrote:
>
<snip>
> Applied.
The gnome-bluetooth change to use this feature has also been merged,
and will be available in gnome-bluetooth-3.28.2.
Thanks for working on this!
Hi,
On Thu, Jul 26, 2018 at 5:17 PM, Luiz Augusto von Dentz
<[email protected]> wrote:
> From: Luiz Augusto von Dentz <[email protected]>
>
> This enables the client to set its discoverable setting while
> discovering which is very typical situation as usually the setings
> application would allow incoming pairing request while scanning, so
> this would reduce the number of calls setting Discoverable and
> DiscoverableTimeout and restoring after done with discovery.
> ---
> doc/adapter-api.txt | 6 ++++++
> 1 file changed, 6 insertions(+)
>
> diff --git a/doc/adapter-api.txt b/doc/adapter-api.txt
> index d14d0ca50..4791af2c7 100644
> --- a/doc/adapter-api.txt
> +++ b/doc/adapter-api.txt
> @@ -113,6 +113,12 @@ Methods void StartDiscovery()
> generated for either ManufacturerData and
> ServiceData everytime they are discovered.
>
> + bool Discoverable (Default: false)
> +
> + Make adapter discoverable while discovering,
> + if the adapter is already discoverable this
> + setting this filter won't do anything.
> +
> When discovery filter is set, Device objects will be
> created as new devices with matching criteria are
> discovered regardless of they are connectable or
> --
> 2.17.1
Applied.
--
Luiz Augusto von Dentz