[PATCH BlueZ 1/8] adapter: Add DBus.Properties getters

[PATCH BlueZ 1/8] adapter: Add DBus.Properties getters

[Lucas De Marchi]

From: Lucas De Marchi <lucas.de.marchi@gmail.com>

---
 src/adapter.c | 221 +++++++++++++++++++++++++++++++++++++++-------------------
 1 file changed, 149 insertions(+), 72 deletions(-)

diff --git a/src/adapter.c b/src/adapter.c
index 2f8c8a3..eb5fc83 100644
--- a/src/adapter.c
+++ b/src/adapter.c
@@ -1113,106 +1113,169 @@ static DBusMessage *adapter_stop_discovery(DBusConnection *conn,
 	return dbus_message_new_method_return(msg);
 }
 
-static DBusMessage *get_properties(DBusConnection *conn,
-					DBusMessage *msg, void *data)
+static gboolean adapter_property_get_address(
+					const GDBusPropertyTable *property,
+					DBusMessageIter *iter, void *data)
 {
 	struct btd_adapter *adapter = data;
-	const char *property;
-	DBusMessage *reply;
-	DBusMessageIter iter;
-	DBusMessageIter dict;
 	char srcaddr[18];
-	gboolean value;
-	char **devices, **uuids;
-	int i;
-	GSList *l;
-	sdp_list_t *list;
+	const char *ptr;
 
 	ba2str(&adapter->bdaddr, srcaddr);
+	ptr = srcaddr;
 
-	if (check_address(srcaddr) < 0)
-		return btd_error_invalid_args(msg);
+	dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &ptr);
 
-	reply = dbus_message_new_method_return(msg);
-	if (!reply)
-		return NULL;
+	return TRUE;
+}
 
-	dbus_message_iter_init_append(reply, &iter);
+static gboolean adapter_property_get_name(const GDBusPropertyTable *property,
+					DBusMessageIter *iter, void *data)
+{
+	struct btd_adapter *adapter = data;
+	const char *ptr;
 
-	dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
-			DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
-			DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
-			DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
+	ptr = adapter->name ?: "";
 
-	/* Address */
-	property = srcaddr;
-	dict_append_entry(&dict, "Address", DBUS_TYPE_STRING, &property);
+	dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &ptr);
 
-	/* Name */
-	property = adapter->name ? : "";
+	return TRUE;
+}
 
-	dict_append_entry(&dict, "Name", DBUS_TYPE_STRING, &property);
+static gboolean adapter_property_get_class(const GDBusPropertyTable *property,
+					DBusMessageIter *iter, void *data)
+{
+	struct btd_adapter *adapter = data;
 
-	/* Class */
-	dict_append_entry(&dict, "Class",
-				DBUS_TYPE_UINT32, &adapter->dev_class);
+	dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT32,
+							&adapter->dev_class);
+
+	return TRUE;
+}
+
+static gboolean adapter_property_get_powered(
+					const GDBusPropertyTable *property,
+					DBusMessageIter *iter, void *data)
+{
+	struct btd_adapter *adapter = data;
+	dbus_bool_t value;
 
-	/* Powered */
 	value = (adapter->up && !adapter->off_requested) ? TRUE : FALSE;
-	dict_append_entry(&dict, "Powered", DBUS_TYPE_BOOLEAN, &value);
+	dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN, &value);
+
+	return TRUE;
+}
+
+static gboolean adapter_property_get_discoverable(
+					const GDBusPropertyTable *property,
+					DBusMessageIter *iter, void *data)
+{
+	struct btd_adapter *adapter = data;
+	dbus_bool_t value;
 
-	/* Discoverable */
 	value = adapter->scan_mode & SCAN_INQUIRY ? TRUE : FALSE;
-	dict_append_entry(&dict, "Discoverable", DBUS_TYPE_BOOLEAN, &value);
+	dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN, &value);
 
-	/* Pairable */
-	dict_append_entry(&dict, "Pairable", DBUS_TYPE_BOOLEAN,
-				&adapter->pairable);
+	return TRUE;
+}
 
-	/* DiscoverableTimeout */
-	dict_append_entry(&dict, "DiscoverableTimeout",
-				DBUS_TYPE_UINT32, &adapter->discov_timeout);
+static gboolean adapter_property_get_pairable(
+					const GDBusPropertyTable *property,
+					DBusMessageIter *iter, void *data)
+{
+	struct btd_adapter *adapter = data;
 
-	/* PairableTimeout */
-	dict_append_entry(&dict, "PairableTimeout",
-				DBUS_TYPE_UINT32, &adapter->pairable_timeout);
+	dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN,
+							&adapter->pairable);
+	return TRUE;
+}
 
+static gboolean adapter_property_get_discoverable_timeout(
+					const GDBusPropertyTable *property,
+					DBusMessageIter *iter, void *data)
+{
+	struct btd_adapter *adapter = data;
 
-	/* Discovering */
-	dict_append_entry(&dict, "Discovering", DBUS_TYPE_BOOLEAN,
-							&adapter->discovering);
+	dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT32,
+						&adapter->discov_timeout);
 
-	/* Devices */
-	devices = g_new0(char *, g_slist_length(adapter->devices) + 1);
-	for (i = 0, l = adapter->devices; l; l = l->next, i++) {
-		struct btd_device *dev = l->data;
-		devices[i] = (char *) device_get_path(dev);
+	return TRUE;
+}
+
+static gboolean adapter_property_get_pairable_timeout(
+					const GDBusPropertyTable *property,
+					DBusMessageIter *iter, void *data)
+{
+	struct btd_adapter *adapter = data;
+
+	dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT32,
+						&adapter->pairable_timeout);
+
+	return TRUE;
+}
+
+static gboolean adapter_property_get_discovering(
+					const GDBusPropertyTable *property,
+					DBusMessageIter *iter, void *data)
+{
+	struct btd_adapter *adapter = data;
+
+	dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN,
+						&adapter->discovering);
+
+	return TRUE;
+}
+
+static gboolean adapter_property_get_devices(
+					const GDBusPropertyTable *property,
+					DBusMessageIter *iter, void *data)
+{
+	struct btd_adapter *adapter = data;
+	DBusMessageIter entry;
+	GSList *l;
+
+	dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
+				DBUS_TYPE_OBJECT_PATH_AS_STRING, &entry);
+
+	for (l = adapter->devices; l != NULL; l = l->next) {
+		const char *path = device_get_path(l->data);
+
+		dbus_message_iter_append_basic(&entry, DBUS_TYPE_OBJECT_PATH,
+								&path);
 	}
-	dict_append_array(&dict, "Devices", DBUS_TYPE_OBJECT_PATH,
-								&devices, i);
-	g_free(devices);
 
-	/* UUIDs */
-	uuids = g_new0(char *, sdp_list_len(adapter->services) + 1);
+	dbus_message_iter_close_container(iter, &entry);
 
-	for (i = 0, list = adapter->services; list; list = list->next) {
-		sdp_record_t *rec = list->data;
+	return TRUE;
+}
+
+static gboolean adapter_property_get_uuids(const GDBusPropertyTable *property,
+					DBusMessageIter *iter, void *data)
+{
+	struct btd_adapter *adapter = data;
+	DBusMessageIter entry;
+	sdp_list_t *l;
+
+	dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
+					DBUS_TYPE_STRING_AS_STRING, &entry);
+
+	for (l = adapter->services; l != NULL; l = l->next) {
+		sdp_record_t *rec = l->data;
 		char *uuid;
 
 		uuid = bt_uuid2string(&rec->svclass);
-		if (uuid)
-			uuids[i++] = uuid;
-	}
-
-	dict_append_array(&dict, "UUIDs", DBUS_TYPE_STRING, &uuids, i);
+		if (uuid == NULL)
+			continue;
 
-	g_strfreev(uuids);
+		dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING,
+								&uuid);
+		g_free(uuid);
+	}
 
-	dbus_message_iter_close_container(&iter, &dict);
+	dbus_message_iter_close_container(iter, &entry);
 
-	return reply;
+	return TRUE;
 }
-
 static DBusMessage *set_property(DBusConnection *conn,
 					DBusMessage *msg, void *data)
 {
@@ -1656,9 +1719,6 @@ static DBusMessage *unregister_agent(DBusConnection *conn, DBusMessage *msg,
 }
 
 static const GDBusMethodTable adapter_methods[] = {
-	{ GDBUS_METHOD("GetProperties",
-			NULL, GDBUS_ARGS({ "properties", "a{sv}" }),
-			get_properties) },
 	{ GDBUS_ASYNC_METHOD("SetProperty",
 			GDBUS_ARGS({ "name", "s" }, { "value", "v" }), NULL,
 			set_property) },
@@ -1714,6 +1774,22 @@ static const GDBusSignalTable adapter_signals[] = {
 	{ }
 };
 
+static const GDBusPropertyTable adapter_properties[] = {
+	{ "Address", "s", adapter_property_get_address },
+	{ "Name", "s", adapter_property_get_name },
+	{ "Class", "u", adapter_property_get_class },
+	{ "Powered", "b", adapter_property_get_powered },
+	{ "Discoverable", "b", adapter_property_get_discoverable },
+	{ "Pairable", "b", adapter_property_get_pairable },
+	{ "DiscoverableTimeout", "u",
+			adapter_property_get_discoverable_timeout },
+	{ "PairableTimeout", "u", adapter_property_get_pairable_timeout },
+	{ "Discovering", "b", adapter_property_get_discovering },
+	{ "Devices", "ao", adapter_property_get_devices },
+	{ "UUIDs", "as", adapter_property_get_uuids },
+	{ }
+};
+
 static void create_stored_device_from_profiles(char *key, char *value,
 						void *user_data)
 {
@@ -2624,8 +2700,9 @@ struct btd_adapter *adapter_create(int id)
 
 	if (!g_dbus_register_interface(btd_get_dbus_connection(),
 					path, ADAPTER_INTERFACE,
-					adapter_methods, adapter_signals, NULL,
-					adapter, adapter_free)) {
+					adapter_methods, adapter_signals,
+					adapter_properties, adapter,
+					adapter_free)) {
 		error("Adapter interface init failed on path %s", path);
 		adapter_free(adapter);
 		return NULL;
-- 
1.7.12.2

[PATCH BlueZ 2/8] adapter: Set Name through DBus.Properties

[Lucas De Marchi]

---
 src/adapter.c | 59 +++++++++++++++++++++++++++++++++++++++--------------------
 1 file changed, 39 insertions(+), 20 deletions(-)

diff --git a/src/adapter.c b/src/adapter.c
index eb5fc83..512e2df 100644
--- a/src/adapter.c
+++ b/src/adapter.c
@@ -730,9 +730,8 @@ void adapter_name_changed(struct btd_adapter *adapter, const char *name)
 	g_free(adapter->name);
 	adapter->name = g_strdup(name);
 
-	emit_property_changed(adapter->path,
-				ADAPTER_INTERFACE, "Name",
-				DBUS_TYPE_STRING, &name);
+	g_dbus_emit_property_changed(btd_get_dbus_connection(), adapter->path,
+						ADAPTER_INTERFACE, "Name");
 
 	if (main_opts.gatt_enabled)
 		attrib_gap_set(adapter, GATT_CHARAC_DEVICE_NAME,
@@ -767,21 +766,30 @@ int adapter_set_name(struct btd_adapter *adapter, const char *name)
 	return 0;
 }
 
-static DBusMessage *set_name(DBusMessage *msg, const char *name, void *data)
+static void set_name(struct btd_adapter *adapter, const char *name,
+						GDBusPendingPropertySet id)
 {
-	struct btd_adapter *adapter = data;
 	int ret;
 
 	if (adapter->allow_name_changes == FALSE)
-		return btd_error_failed(msg, strerror(EPERM));
+		return g_dbus_pending_property_error(btd_get_dbus_connection(),
+						id, ERROR_INTERFACE ".Failed",
+						strerror(EPERM));
 
 	ret = adapter_set_name(adapter, name);
-	if (ret == -EINVAL)
-		return btd_error_invalid_args(msg);
-	else if (ret < 0)
-		return btd_error_failed(msg, strerror(-ret));
+	if (ret >= 0) {
+		g_dbus_pending_property_success(btd_get_dbus_connection(), id);
+		return;
+	}
 
-	return dbus_message_new_method_return(msg);
+	if (ret == -EINVAL)
+		g_dbus_pending_property_error(btd_get_dbus_connection(),
+				id, ERROR_INTERFACE ".InvalidArguments",
+				"Invalid arguments in method call");
+	else
+		g_dbus_pending_property_error(btd_get_dbus_connection(),
+						id, ERROR_INTERFACE ".Failed",
+						strerror(-ret));
 }
 
 struct btd_device *adapter_find_device(struct btd_adapter *adapter,
@@ -1142,6 +1150,24 @@ static gboolean adapter_property_get_name(const GDBusPropertyTable *property,
 	return TRUE;
 }
 
+static void adapter_property_set_name(const GDBusPropertyTable *property,
+					DBusMessageIter *value,
+					GDBusPendingPropertySet id, void *data)
+{
+	const char *name;
+
+	if (dbus_message_iter_get_arg_type(value) != DBUS_TYPE_STRING) {
+		g_dbus_pending_property_error(btd_get_dbus_connection(),
+				id, ERROR_INTERFACE ".InvalidArguments",
+				"Invalid arguments in method call");
+		return;
+	}
+
+	dbus_message_iter_get_basic(value, &name);
+
+	set_name(data, name, id);
+}
+
 static gboolean adapter_property_get_class(const GDBusPropertyTable *property,
 					DBusMessageIter *iter, void *data)
 {
@@ -1296,15 +1322,8 @@ static DBusMessage *set_property(DBusConnection *conn,
 		return btd_error_invalid_args(msg);
 	dbus_message_iter_recurse(&iter, &sub);
 
-	if (g_str_equal("Name", property)) {
-		const char *name;
-
-		if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRING)
-			return btd_error_invalid_args(msg);
-		dbus_message_iter_get_basic(&sub, &name);
 
-		return set_name(msg, name, data);
-	} else if (g_str_equal("Powered", property)) {
+	if (g_str_equal("Powered", property)) {
 		gboolean powered;
 
 		if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_BOOLEAN)
@@ -1776,7 +1795,7 @@ static const GDBusSignalTable adapter_signals[] = {
 
 static const GDBusPropertyTable adapter_properties[] = {
 	{ "Address", "s", adapter_property_get_address },
-	{ "Name", "s", adapter_property_get_name },
+	{ "Name", "s", adapter_property_get_name, adapter_property_set_name },
 	{ "Class", "u", adapter_property_get_class },
 	{ "Powered", "b", adapter_property_get_powered },
 	{ "Discoverable", "b", adapter_property_get_discoverable },
-- 
1.7.12.2

[PATCH BlueZ 3/8] adapter: Set *Timeout through DBus.Properties

[Lucas De Marchi]

---
 src/adapter.c | 93 +++++++++++++++++++++++++++++++----------------------------
 1 file changed, 49 insertions(+), 44 deletions(-)

diff --git a/src/adapter.c b/src/adapter.c
index 512e2df..cc0ec3b 100644
--- a/src/adapter.c
+++ b/src/adapter.c
@@ -644,14 +644,13 @@ static void confirm_mode_cb(struct agent *agent, DBusError *derr, void *data)
 		session_unref(req);
 }
 
-static DBusMessage *set_discoverable_timeout(DBusMessage *msg,
-						uint32_t timeout, void *data)
+static void set_discoverable_timeout(struct btd_adapter *adapter,
+				uint32_t timeout, GDBusPendingPropertySet id)
 {
-	struct btd_adapter *adapter = data;
-	const char *path;
+	DBusConnection *conn = btd_get_dbus_connection();
 
 	if (adapter->discov_timeout == timeout && timeout == 0)
-		return dbus_message_new_method_return(msg);
+		return g_dbus_pending_property_success(conn, id);
 
 	if (adapter->scan_mode & SCAN_INQUIRY)
 		mgmt_set_discoverable(adapter->dev_id, TRUE, timeout);
@@ -660,23 +659,18 @@ static DBusMessage *set_discoverable_timeout(DBusMessage *msg,
 
 	write_discoverable_timeout(&adapter->bdaddr, timeout);
 
-	path = dbus_message_get_path(msg);
-
-	emit_property_changed(path,
-				ADAPTER_INTERFACE, "DiscoverableTimeout",
-				DBUS_TYPE_UINT32, &timeout);
-
-	return dbus_message_new_method_return(msg);
+	g_dbus_emit_property_changed(conn, adapter->path, ADAPTER_INTERFACE,
+						"DiscoverableTimeout");
+	g_dbus_pending_property_success(conn, id);
 }
 
-static DBusMessage *set_pairable_timeout(DBusMessage *msg,
-						uint32_t timeout, void *data)
+static void set_pairable_timeout(struct btd_adapter *adapter,
+				uint32_t timeout, GDBusPendingPropertySet id)
 {
-	struct btd_adapter *adapter = data;
-	const char *path;
+	DBusConnection *conn = btd_get_dbus_connection();
 
 	if (adapter->pairable_timeout == timeout && timeout == 0)
-		return dbus_message_new_method_return(msg);
+		return g_dbus_pending_property_success(conn, id);
 
 	if (adapter->pairable)
 		adapter_set_pairable_timeout(adapter, timeout);
@@ -685,13 +679,9 @@ static DBusMessage *set_pairable_timeout(DBusMessage *msg,
 
 	write_pairable_timeout(&adapter->bdaddr, timeout);
 
-	path = dbus_message_get_path(msg);
-
-	emit_property_changed(path,
-				ADAPTER_INTERFACE, "PairableTimeout",
-				DBUS_TYPE_UINT32, &timeout);
-
-	return dbus_message_new_method_return(msg);
+	g_dbus_emit_property_changed(conn, adapter->path, ADAPTER_INTERFACE,
+							"PairableTimeout");
+	g_dbus_pending_property_success(conn, id);
 }
 
 void btd_adapter_class_changed(struct btd_adapter *adapter, uint8_t *new_class)
@@ -1228,6 +1218,22 @@ static gboolean adapter_property_get_discoverable_timeout(
 	return TRUE;
 }
 
+
+static void adapter_property_set_discoverable_timeout(
+		const GDBusPropertyTable *property, DBusMessageIter *value,
+		GDBusPendingPropertySet id, void *data)
+{
+	uint32_t timeout;
+
+	if (dbus_message_iter_get_arg_type(value) != DBUS_TYPE_UINT32)
+		return g_dbus_pending_property_error(btd_get_dbus_connection(),
+				id, ERROR_INTERFACE ".InvalidArguments",
+				"Invalid arguments in method call");
+
+	dbus_message_iter_get_basic(value, &timeout);
+	set_discoverable_timeout(data, timeout, id);
+}
+
 static gboolean adapter_property_get_pairable_timeout(
 					const GDBusPropertyTable *property,
 					DBusMessageIter *iter, void *data)
@@ -1240,6 +1246,21 @@ static gboolean adapter_property_get_pairable_timeout(
 	return TRUE;
 }
 
+static void adapter_property_set_pairable_timeout(
+		const GDBusPropertyTable *property, DBusMessageIter *value,
+		GDBusPendingPropertySet id, void *data)
+{
+	uint32_t timeout;
+
+	if (dbus_message_iter_get_arg_type(value) != DBUS_TYPE_UINT32)
+		return g_dbus_pending_property_error(btd_get_dbus_connection(),
+				id, ERROR_INTERFACE ".InvalidArguments",
+				"Invalid arguments in method call");
+
+	dbus_message_iter_get_basic(value, &timeout);
+	set_pairable_timeout(data, timeout, id);
+}
+
 static gboolean adapter_property_get_discovering(
 					const GDBusPropertyTable *property,
 					DBusMessageIter *iter, void *data)
@@ -1341,15 +1362,6 @@ static DBusMessage *set_property(DBusConnection *conn,
 		dbus_message_iter_get_basic(&sub, &discoverable);
 
 		return set_discoverable(msg, discoverable, data);
-	} else if (g_str_equal("DiscoverableTimeout", property)) {
-		uint32_t timeout;
-
-		if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_UINT32)
-			return btd_error_invalid_args(msg);
-
-		dbus_message_iter_get_basic(&sub, &timeout);
-
-		return set_discoverable_timeout(msg, timeout, data);
 	} else if (g_str_equal("Pairable", property)) {
 		gboolean pairable;
 
@@ -1359,15 +1371,6 @@ static DBusMessage *set_property(DBusConnection *conn,
 		dbus_message_iter_get_basic(&sub, &pairable);
 
 		return set_pairable(msg, pairable, data);
-	} else if (g_str_equal("PairableTimeout", property)) {
-		uint32_t timeout;
-
-		if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_UINT32)
-			return btd_error_invalid_args(msg);
-
-		dbus_message_iter_get_basic(&sub, &timeout);
-
-		return set_pairable_timeout(msg, timeout, data);
 	}
 
 	return btd_error_invalid_args(msg);
@@ -1801,8 +1804,10 @@ static const GDBusPropertyTable adapter_properties[] = {
 	{ "Discoverable", "b", adapter_property_get_discoverable },
 	{ "Pairable", "b", adapter_property_get_pairable },
 	{ "DiscoverableTimeout", "u",
-			adapter_property_get_discoverable_timeout },
-	{ "PairableTimeout", "u", adapter_property_get_pairable_timeout },
+			adapter_property_get_discoverable_timeout,
+			adapter_property_set_discoverable_timeout },
+	{ "PairableTimeout", "u", adapter_property_get_pairable_timeout,
+				adapter_property_set_pairable_timeout },
 	{ "Discovering", "b", adapter_property_get_discovering },
 	{ "Devices", "ao", adapter_property_get_devices },
 	{ "UUIDs", "as", adapter_property_get_uuids },
-- 
1.7.12.2

[PATCH BlueZ 4/8] adapter: Refactor set_mode() in 2 functions

[Lucas De Marchi]

From: Lucas De Marchi <lucas.de.marchi@gmail.com>

Separate the handling of pending_mode from setting mode. This way it's
simpler to set the pending_mode only when needed. Half of callers were
passing NULL to this parameter.
---
 src/adapter.c | 78 +++++++++++++++++++++++++++++++----------------------------
 1 file changed, 41 insertions(+), 37 deletions(-)

diff --git a/src/adapter.c b/src/adapter.c
index cc0ec3b..c9ae8ca 100644
--- a/src/adapter.c
+++ b/src/adapter.c
@@ -278,8 +278,7 @@ static struct session_req *find_session_by_msg(GSList *list, const DBusMessage *
 	return NULL;
 }
 
-static int set_mode(struct btd_adapter *adapter, uint8_t new_mode,
-			DBusMessage *msg)
+static int set_mode(struct btd_adapter *adapter, uint8_t new_mode)
 {
 	int err;
 	const char *modestr;
@@ -319,22 +318,25 @@ done:
 
 	DBG("%s", modestr);
 
-	if (msg != NULL) {
-		struct session_req *req;
+	return 0;
+}
 
-		req = find_session_by_msg(adapter->mode_sessions, msg);
-		if (req) {
-			adapter->pending_mode = req;
-			session_ref(req);
-		} else
-			/* Wait for mode change to reply */
-			adapter->pending_mode = create_session(adapter, msg,
-								new_mode, NULL);
-	} else
-		/* Nothing to reply just write the new mode */
-		adapter->mode = new_mode;
+static void set_pending_mode(struct btd_adapter *adapter, uint8_t new_mode,
+							DBusMessage *msg)
+{
+	struct session_req *req;
 
-	return 0;
+	/*
+	 * Schedule the reply to be sent when a mode-change notification
+	 * arrives. The reply will be sent by set_mode_complete().
+	 */
+	req = find_session_by_msg(adapter->mode_sessions, msg);
+	if (req) {
+		adapter->pending_mode = req;
+		session_ref(req);
+	} else
+		adapter->pending_mode = create_session(adapter, msg, new_mode,
+									NULL);
 }
 
 static DBusMessage *set_discoverable(DBusMessage *msg,
@@ -351,10 +353,12 @@ static DBusMessage *set_discoverable(DBusMessage *msg,
 		return dbus_message_new_method_return(msg);
 	}
 
-	err = set_mode(adapter, mode, msg);
+	err = set_mode(adapter, mode);
 	if (err < 0)
 		return btd_error_failed(msg, strerror(-err));
 
+	set_pending_mode(adapter, mode, msg);
+
 	return NULL;
 }
 
@@ -376,10 +380,12 @@ static DBusMessage *set_powered(DBusMessage *msg, gboolean powered, void *data)
 		return dbus_message_new_method_return(msg);
 	}
 
-	err = set_mode(adapter, mode, msg);
+	err = set_mode(adapter, mode);
 	if (err < 0)
 		return btd_error_failed(msg, strerror(-err));
 
+	set_pending_mode(adapter, mode, msg);
+
 	return NULL;
 }
 
@@ -398,7 +404,7 @@ static DBusMessage *set_pairable(DBusMessage *msg,
 	if (!(adapter->scan_mode & SCAN_INQUIRY))
 		goto store;
 
-	err = set_mode(adapter, MODE_DISCOVERABLE, NULL);
+	err = set_mode(adapter, MODE_DISCOVERABLE);
 	if (err < 0 && msg)
 		return btd_error_failed(msg, strerror(-err));
 
@@ -549,7 +555,7 @@ static void session_remove(struct session_req *req)
 
 		DBG("Switching to '%s' mode", mode2str(mode));
 
-		set_mode(adapter, mode, NULL);
+		set_mode(adapter, mode);
 	} else {
 		adapter->disc_sessions = g_slist_remove(adapter->disc_sessions,
 							req);
@@ -620,28 +626,26 @@ static void confirm_mode_cb(struct agent *agent, DBusError *derr, void *data)
 		return;
 	}
 
-	err = set_mode(req->adapter, req->mode, req->msg);
+	err = set_mode(req->adapter, req->mode);
+	if (err >= 0 && req->adapter->mode != req->mode) {
+		set_pending_mode(req->adapter, req->mode, req->msg);
+		goto done;
+	}
+
 	if (err < 0)
 		reply = btd_error_failed(req->msg, strerror(-err));
-	else if (!req->adapter->pending_mode)
-		reply = dbus_message_new_method_return(req->msg);
 	else
-		reply = NULL;
-
-	if (reply) {
-		/*
-		 * Send reply immediately only if there was an error changing
-		 * mode, or change is not needed. Otherwise, reply is sent in
-		 * set_mode_complete.
-		 */
-		g_dbus_send_message(conn, reply);
+		reply = dbus_message_new_method_return(req->msg);
 
-		dbus_message_unref(req->msg);
-		req->msg = NULL;
-	}
+	/*
+	 * Send reply immediately only if there was an error changing mode, or
+	 * change is not needed. Otherwise, reply is sent in
+	 * set_mode_complete.
+	 */
+	g_dbus_send_message(conn, reply);
 
-	if (!find_session(req->adapter->mode_sessions, req->owner))
-		session_unref(req);
+done:
+	session_unref(req);
 }
 
 static void set_discoverable_timeout(struct btd_adapter *adapter,
-- 
1.7.12.2

[PATCH BlueZ 5/8] adapter: Add session type to session_req

[Lucas De Marchi]

From: Lucas De Marchi <lucas.de.marchi@gmail.com>

With this field we can differentiate requests that should have global
actions from the ones created with RequestSession(). The intention with
this is to allow to separate how we detect a global request on
set_mode_complete(), not tying to the name of the D-Bus method it came
from.
---
 src/adapter.c | 38 ++++++++++++++++++++++++--------------
 1 file changed, 24 insertions(+), 14 deletions(-)

diff --git a/src/adapter.c b/src/adapter.c
index c9ae8ca..26016f6 100644
--- a/src/adapter.c
+++ b/src/adapter.c
@@ -86,8 +86,14 @@
 
 static GSList *adapter_drivers = NULL;
 
+enum session_req_type {
+	SESSION_REQ_TYPE_GLOBAL = 0,
+	SESSION_REQ_TYPE_SESSION,
+};
+
 struct session_req {
 	struct btd_adapter	*adapter;
+	enum session_req_type	type;
 	DBusMessage		*msg;		/* Unreplied message ref */
 	char			*owner;		/* Bus name of the owner */
 	guint			id;		/* Listener id */
@@ -225,6 +231,7 @@ static struct session_req *session_ref(struct session_req *req)
 
 static struct session_req *create_session(struct btd_adapter *adapter,
 					DBusMessage *msg, uint8_t mode,
+					enum session_req_type type,
 					GDBusWatchFunction cb)
 {
 	const char *sender;
@@ -233,6 +240,7 @@ static struct session_req *create_session(struct btd_adapter *adapter,
 	req = g_new0(struct session_req, 1);
 	req->adapter = adapter;
 	req->mode = mode;
+	req->type = type;
 
 	if (msg == NULL)
 		return session_ref(req);
@@ -321,8 +329,8 @@ done:
 	return 0;
 }
 
-static void set_pending_mode(struct btd_adapter *adapter, uint8_t new_mode,
-							DBusMessage *msg)
+static void set_session_pending_mode(struct btd_adapter *adapter,
+					uint8_t new_mode, DBusMessage *msg)
 {
 	struct session_req *req;
 
@@ -336,7 +344,7 @@ static void set_pending_mode(struct btd_adapter *adapter, uint8_t new_mode,
 		session_ref(req);
 	} else
 		adapter->pending_mode = create_session(adapter, msg, new_mode,
-									NULL);
+					SESSION_REQ_TYPE_SESSION, NULL);
 }
 
 static DBusMessage *set_discoverable(DBusMessage *msg,
@@ -357,7 +365,8 @@ static DBusMessage *set_discoverable(DBusMessage *msg,
 	if (err < 0)
 		return btd_error_failed(msg, strerror(-err));
 
-	set_pending_mode(adapter, mode, msg);
+	adapter->pending_mode = create_session(adapter, msg, mode,
+						SESSION_REQ_TYPE_GLOBAL, NULL);
 
 	return NULL;
 }
@@ -384,7 +393,8 @@ static DBusMessage *set_powered(DBusMessage *msg, gboolean powered, void *data)
 	if (err < 0)
 		return btd_error_failed(msg, strerror(-err));
 
-	set_pending_mode(adapter, mode, msg);
+	adapter->pending_mode = create_session(adapter, msg, mode,
+						SESSION_REQ_TYPE_GLOBAL, NULL);
 
 	return NULL;
 }
@@ -535,8 +545,8 @@ static void session_remove(struct session_req *req)
 {
 	struct btd_adapter *adapter = req->adapter;
 
-	/* Ignore set_mode session */
-	if (req->owner == NULL && adapter->pending_mode)
+	/* Ignore global requests */
+	if (req->type == SESSION_REQ_TYPE_GLOBAL)
 		return;
 
 	DBG("%s session %p with %s deactivated",
@@ -628,7 +638,7 @@ static void confirm_mode_cb(struct agent *agent, DBusError *derr, void *data)
 
 	err = set_mode(req->adapter, req->mode);
 	if (err >= 0 && req->adapter->mode != req->mode) {
-		set_pending_mode(req->adapter, req->mode, req->msg);
+		set_session_pending_mode(req->adapter, req->mode, req->msg);
 		goto done;
 	}
 
@@ -1089,7 +1099,8 @@ static DBusMessage *adapter_start_discovery(DBusConnection *conn,
 		return btd_error_failed(msg, strerror(-err));
 
 done:
-	req = create_session(adapter, msg, 0, session_owner_exit);
+	req = create_session(adapter, msg, 0, SESSION_REQ_TYPE_GLOBAL,
+							session_owner_exit);
 
 	adapter->disc_sessions = g_slist_append(adapter->disc_sessions, req);
 
@@ -1403,7 +1414,7 @@ static DBusMessage *request_session(DBusConnection *conn,
 		return dbus_message_new_method_return(msg);
 	} else {
 		req = create_session(adapter, msg, new_mode,
-							session_owner_exit);
+				SESSION_REQ_TYPE_SESSION, session_owner_exit);
 		adapter->mode_sessions = g_slist_append(adapter->mode_sessions,
 							req);
 	}
@@ -2401,7 +2412,7 @@ void adapter_connect_list_add(struct btd_adapter *adapter,
 	if (adapter->disc_sessions == NULL)
 		adapter->discov_id = g_idle_add(discovery_cb, adapter);
 
-	req = create_session(adapter, NULL, 0, NULL);
+	req = create_session(adapter, NULL, 0, SESSION_REQ_TYPE_GLOBAL, NULL);
 	adapter->disc_sessions = g_slist_append(adapter->disc_sessions, req);
 	adapter->scanning_session = req;
 }
@@ -2454,7 +2465,7 @@ void btd_adapter_start(struct btd_adapter *adapter)
 					adapter->disc_sessions != NULL)
 		return;
 
-	req = create_session(adapter, NULL, 0, NULL);
+	req = create_session(adapter, NULL, 0, SESSION_REQ_TYPE_GLOBAL, NULL);
 	adapter->disc_sessions = g_slist_append(adapter->disc_sessions, req);
 	adapter->scanning_session = req;
 
@@ -2538,8 +2549,7 @@ static void set_mode_complete(struct btd_adapter *adapter)
 		if (err < 0)
 			reply = btd_error_failed(msg, strerror(-err));
 		else {
-			if (strcmp(dbus_message_get_member(msg),
-						"SetProperty") == 0)
+			if (pending->type == SESSION_REQ_TYPE_GLOBAL)
 				adapter->global_mode = adapter->mode;
 			reply = g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 		}
-- 
1.7.12.2

[PATCH BlueZ 6/8] adapter: Fix calling mgmt_set_pairable() with error set

[Lucas De Marchi]

From: Lucas De Marchi <lucas.de.marchi@gmail.com>

---
 src/adapter.c | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/adapter.c b/src/adapter.c
index 26016f6..a6593b2 100644
--- a/src/adapter.c
+++ b/src/adapter.c
@@ -415,8 +415,12 @@ static DBusMessage *set_pairable(DBusMessage *msg,
 		goto store;
 
 	err = set_mode(adapter, MODE_DISCOVERABLE);
-	if (err < 0 && msg)
-		return btd_error_failed(msg, strerror(-err));
+	if (err < 0) {
+		if (msg != NULL)
+			return btd_error_failed(msg, strerror(-err));
+
+		return NULL;
+	}
 
 store:
 	mgmt_set_pairable(adapter->dev_id, pairable);
-- 
1.7.12.2

[PATCH BlueZ 7/8] adapter: Port remaining properties to DBus.Properties

[Lucas De Marchi]

From: Lucas De Marchi <lucas.de.marchi@gmail.com>

Remaining properties ported to DBus.Properties:
	- Pairable
	- Discoverable
	- Powered
---
 src/adapter.c | 197 +++++++++++++++++++++++++++++++---------------------------
 1 file changed, 107 insertions(+), 90 deletions(-)

diff --git a/src/adapter.c b/src/adapter.c
index a6593b2..18689c6 100644
--- a/src/adapter.c
+++ b/src/adapter.c
@@ -95,6 +95,7 @@ struct session_req {
 	struct btd_adapter	*adapter;
 	enum session_req_type	type;
 	DBusMessage		*msg;		/* Unreplied message ref */
+	GDBusPendingPropertySet prop_id;	/* Pending Properties.Set() */
 	char			*owner;		/* Bus name of the owner */
 	guint			id;		/* Listener id */
 	uint8_t			mode;		/* Requested mode */
@@ -347,10 +348,10 @@ static void set_session_pending_mode(struct btd_adapter *adapter,
 					SESSION_REQ_TYPE_SESSION, NULL);
 }
 
-static DBusMessage *set_discoverable(DBusMessage *msg,
-					gboolean discoverable, void *data)
+static void set_discoverable(struct btd_adapter *adapter,
+			gboolean discoverable, GDBusPendingPropertySet id)
 {
-	struct btd_adapter *adapter = data;
+	DBusConnection *conn = btd_get_dbus_connection();
 	uint8_t mode;
 	int err;
 
@@ -358,55 +359,61 @@ static DBusMessage *set_discoverable(DBusMessage *msg,
 
 	if (mode == adapter->mode) {
 		adapter->global_mode = mode;
-		return dbus_message_new_method_return(msg);
+		return g_dbus_pending_property_success(conn, id);
 	}
 
 	err = set_mode(adapter, mode);
 	if (err < 0)
-		return btd_error_failed(msg, strerror(-err));
+		return g_dbus_pending_property_error(conn, id,
+						ERROR_INTERFACE ".Failed",
+						strerror(-err));
 
-	adapter->pending_mode = create_session(adapter, msg, mode,
+	adapter->pending_mode = create_session(adapter, NULL, mode,
 						SESSION_REQ_TYPE_GLOBAL, NULL);
-
-	return NULL;
+	adapter->pending_mode->prop_id = id;
 }
 
-static DBusMessage *set_powered(DBusMessage *msg, gboolean powered, void *data)
+static void set_powered(struct btd_adapter *adapter, gboolean powered,
+						GDBusPendingPropertySet id)
 {
-	struct btd_adapter *adapter = data;
+	DBusConnection *conn = btd_get_dbus_connection();
 	uint8_t mode;
 	int err;
 
 	if (powered) {
 		mode = get_mode(&adapter->bdaddr, "on");
-		return set_discoverable(msg, mode == MODE_DISCOVERABLE, data);
+		return set_discoverable(adapter, mode == MODE_DISCOVERABLE,
+									id);
 	}
 
 	mode = MODE_OFF;
 
 	if (mode == adapter->mode) {
 		adapter->global_mode = mode;
-		return dbus_message_new_method_return(msg);
+		return g_dbus_pending_property_success(conn, id);
 	}
 
 	err = set_mode(adapter, mode);
 	if (err < 0)
-		return btd_error_failed(msg, strerror(-err));
+		return g_dbus_pending_property_error(conn, id,
+						ERROR_INTERFACE ".Failed",
+						strerror(-err));
 
-	adapter->pending_mode = create_session(adapter, msg, mode,
+	adapter->pending_mode = create_session(adapter, NULL, mode,
 						SESSION_REQ_TYPE_GLOBAL, NULL);
-
-	return NULL;
+	adapter->pending_mode->prop_id = id;
 }
 
-static DBusMessage *set_pairable(DBusMessage *msg,
-						gboolean pairable, void *data)
+static void set_pairable(struct btd_adapter *adapter, gboolean pairable,
+				bool reply, GDBusPendingPropertySet id)
 {
-	struct btd_adapter *adapter = data;
+	DBusConnection *conn = btd_get_dbus_connection();
 	int err;
 
 	if (adapter->scan_mode == SCAN_DISABLED)
-		return btd_error_not_ready(msg);
+		return g_dbus_pending_property_error(conn, id,
+						ERROR_INTERFACE ".NotReady",
+						"Resource Not Ready");
 
 	if (pairable == adapter->pairable)
 		goto done;
@@ -416,22 +423,26 @@ static DBusMessage *set_pairable(DBusMessage *msg,
 
 	err = set_mode(adapter, MODE_DISCOVERABLE);
 	if (err < 0) {
-		if (msg != NULL)
-			return btd_error_failed(msg, strerror(-err));
-
-		return NULL;
+		if (reply)
+			g_dbus_pending_property_error(conn, id,
+						ERROR_INTERFACE ".Failed",
+						strerror(-err));
+		return;
 	}
 
 store:
 	mgmt_set_pairable(adapter->dev_id, pairable);
 
 done:
-	return msg ? dbus_message_new_method_return(msg) : NULL;
+	if (reply)
+		g_dbus_pending_property_success(conn, id);
 }
 
+
+
 static gboolean pairable_timeout_handler(void *data)
 {
-	set_pairable(NULL, FALSE, data);
+	set_pairable(data, FALSE, false, 0);
 
 	return FALSE;
 }
@@ -1201,6 +1212,23 @@ static gboolean adapter_property_get_powered(
 	return TRUE;
 }
 
+static void adapter_property_set_powered(
+				const GDBusPropertyTable *property,
+				DBusMessageIter *value,
+				GDBusPendingPropertySet id, void *data)
+{
+	dbus_bool_t powered;
+
+	if (dbus_message_iter_get_arg_type(value) != DBUS_TYPE_BOOLEAN)
+		return g_dbus_pending_property_error(btd_get_dbus_connection(),
+				id, ERROR_INTERFACE ".InvalidArguments",
+				"Invalid arguments in method call");
+
+	dbus_message_iter_get_basic(value, &powered);
+
+	set_powered(data, powered, id);
+}
+
 static gboolean adapter_property_get_discoverable(
 					const GDBusPropertyTable *property,
 					DBusMessageIter *iter, void *data)
@@ -1214,6 +1242,23 @@ static gboolean adapter_property_get_discoverable(
 	return TRUE;
 }
 
+static void adapter_property_set_discoverable(
+				const GDBusPropertyTable *property,
+				DBusMessageIter *value,
+				GDBusPendingPropertySet id, void *data)
+{
+	dbus_bool_t discoverable;
+
+	if (dbus_message_iter_get_arg_type(value) != DBUS_TYPE_BOOLEAN)
+		return g_dbus_pending_property_error(btd_get_dbus_connection(),
+				id, ERROR_INTERFACE ".InvalidArguments",
+				"Invalid arguments in method call");
+
+	dbus_message_iter_get_basic(value, &discoverable);
+
+	set_discoverable(data, discoverable, id);
+}
+
 static gboolean adapter_property_get_pairable(
 					const GDBusPropertyTable *property,
 					DBusMessageIter *iter, void *data)
@@ -1225,6 +1270,22 @@ static gboolean adapter_property_get_pairable(
 	return TRUE;
 }
 
+static void adapter_property_set_pairable(const GDBusPropertyTable *property,
+		DBusMessageIter *value,
+		GDBusPendingPropertySet id, void *data)
+{
+	dbus_bool_t pairable;
+
+	if (dbus_message_iter_get_arg_type(value) != DBUS_TYPE_BOOLEAN)
+		return g_dbus_pending_property_error(btd_get_dbus_connection(),
+				id, ERROR_INTERFACE ".InvalidArguments",
+				"Invalid arguments in method call");
+
+	dbus_message_iter_get_basic(value, &pairable);
+
+	set_pairable(data, pairable, true, id);
+}
+
 static gboolean adapter_property_get_discoverable_timeout(
 					const GDBusPropertyTable *property,
 					DBusMessageIter *iter, void *data)
@@ -1342,58 +1403,6 @@ static gboolean adapter_property_get_uuids(const GDBusPropertyTable *property,
 
 	return TRUE;
 }
-static DBusMessage *set_property(DBusConnection *conn,
-					DBusMessage *msg, void *data)
-{
-	DBusMessageIter iter;
-	DBusMessageIter sub;
-	const char *property;
-
-	if (!dbus_message_iter_init(msg, &iter))
-		return btd_error_invalid_args(msg);
-
-	if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
-		return btd_error_invalid_args(msg);
-
-	dbus_message_iter_get_basic(&iter, &property);
-	dbus_message_iter_next(&iter);
-
-	if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
-		return btd_error_invalid_args(msg);
-	dbus_message_iter_recurse(&iter, &sub);
-
-
-	if (g_str_equal("Powered", property)) {
-		gboolean powered;
-
-		if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_BOOLEAN)
-			return btd_error_invalid_args(msg);
-
-		dbus_message_iter_get_basic(&sub, &powered);
-
-		return set_powered(msg, powered, data);
-	} else if (g_str_equal("Discoverable", property)) {
-		gboolean discoverable;
-
-		if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_BOOLEAN)
-			return btd_error_invalid_args(msg);
-
-		dbus_message_iter_get_basic(&sub, &discoverable);
-
-		return set_discoverable(msg, discoverable, data);
-	} else if (g_str_equal("Pairable", property)) {
-		gboolean pairable;
-
-		if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_BOOLEAN)
-			return btd_error_invalid_args(msg);
-
-		dbus_message_iter_get_basic(&sub, &pairable);
-
-		return set_pairable(msg, pairable, data);
-	}
-
-	return btd_error_invalid_args(msg);
-}
 
 static DBusMessage *request_session(DBusConnection *conn,
 					DBusMessage *msg, void *data)
@@ -1760,9 +1769,6 @@ static DBusMessage *unregister_agent(DBusConnection *conn, DBusMessage *msg,
 }
 
 static const GDBusMethodTable adapter_methods[] = {
-	{ GDBUS_ASYNC_METHOD("SetProperty",
-			GDBUS_ARGS({ "name", "s" }, { "value", "v" }), NULL,
-			set_property) },
 	{ GDBUS_ASYNC_METHOD("RequestSession", NULL, NULL,
 			request_session) },
 	{ GDBUS_METHOD("ReleaseSession", NULL, NULL,
@@ -1819,9 +1825,12 @@ static const GDBusPropertyTable adapter_properties[] = {
 	{ "Address", "s", adapter_property_get_address },
 	{ "Name", "s", adapter_property_get_name, adapter_property_set_name },
 	{ "Class", "u", adapter_property_get_class },
-	{ "Powered", "b", adapter_property_get_powered },
-	{ "Discoverable", "b", adapter_property_get_discoverable },
-	{ "Pairable", "b", adapter_property_get_pairable },
+	{ "Powered", "b", adapter_property_get_powered,
+					adapter_property_set_powered },
+	{ "Discoverable", "b", adapter_property_get_discoverable,
+					adapter_property_set_discoverable },
+	{ "Pairable", "b", adapter_property_get_pairable,
+					adapter_property_set_pairable },
 	{ "DiscoverableTimeout", "u",
 			adapter_property_get_discoverable_timeout,
 			adapter_property_set_discoverable_timeout },
@@ -2524,6 +2533,7 @@ static void unload_drivers(struct btd_adapter *adapter)
 
 static void set_mode_complete(struct btd_adapter *adapter)
 {
+	DBusConnection *conn = btd_get_dbus_connection();
 	struct session_req *pending;
 	const char *modestr;
 	int err;
@@ -2546,19 +2556,26 @@ static void set_mode_complete(struct btd_adapter *adapter)
 
 	err = (pending->mode != adapter->mode) ? -EINVAL : 0;
 
-	if (pending->msg != NULL) {
+	if (pending->type == SESSION_REQ_TYPE_GLOBAL) {
+		if (err < 0)
+			g_dbus_pending_property_error(conn, pending->prop_id,
+						ERROR_INTERFACE ".Failed",
+						strerror(-err));
+		else {
+			adapter->global_mode = adapter->mode;
+			g_dbus_pending_property_success(conn,
+							pending->prop_id);
+		}
+	} else if (pending->msg != NULL) {
 		DBusMessage *msg = pending->msg;
 		DBusMessage *reply;
 
 		if (err < 0)
 			reply = btd_error_failed(msg, strerror(-err));
-		else {
-			if (pending->type == SESSION_REQ_TYPE_GLOBAL)
-				adapter->global_mode = adapter->mode;
+		else
 			reply = g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
-		}
 
-		g_dbus_send_message(btd_get_dbus_connection(), reply);
+		g_dbus_send_message(conn, reply);
 	}
 
 	if (err != 0)
-- 
1.7.12.2

[PATCH BlueZ 8/8] adapter: Emit signals through DBus.Properties

[Lucas De Marchi]

From: Lucas De Marchi <lucas.de.marchi@gmail.com>

---
 src/adapter.c | 142 +++++++++++++++++++---------------------------------------
 1 file changed, 47 insertions(+), 95 deletions(-)

diff --git a/src/adapter.c b/src/adapter.c
index 18689c6..6b28651 100644
--- a/src/adapter.c
+++ b/src/adapter.c
@@ -470,9 +470,8 @@ void btd_adapter_pairable_changed(struct btd_adapter *adapter,
 
 	write_device_pairable(&adapter->bdaddr, pairable);
 
-	emit_property_changed(adapter->path,
-				ADAPTER_INTERFACE, "Pairable",
-				DBUS_TYPE_BOOLEAN, &pairable);
+	g_dbus_emit_property_changed(btd_get_dbus_connection(), adapter->path,
+					ADAPTER_INTERFACE, "Pairable");
 
 	if (pairable && adapter->pairable_timeout)
 		adapter_set_pairable_timeout(adapter,
@@ -736,9 +735,8 @@ void btd_adapter_class_changed(struct btd_adapter *adapter, uint8_t *new_class)
 		attrib_gap_set(adapter, GATT_CHARAC_APPEARANCE, cls, 2);
 	}
 
-	emit_property_changed(adapter->path,
-				ADAPTER_INTERFACE, "Class",
-				DBUS_TYPE_UINT32, &class);
+	g_dbus_emit_property_changed(btd_get_dbus_connection(), adapter->path,
+						ADAPTER_INTERFACE, "Class");
 }
 
 void adapter_name_changed(struct btd_adapter *adapter, const char *name)
@@ -830,52 +828,6 @@ struct btd_device *adapter_find_device(struct btd_adapter *adapter,
 	return device;
 }
 
-static void adapter_update_devices(struct btd_adapter *adapter)
-{
-	char **devices;
-	int i;
-	GSList *l;
-
-	/* Devices */
-	devices = g_new0(char *, g_slist_length(adapter->devices) + 1);
-	for (i = 0, l = adapter->devices; l; l = l->next, i++) {
-		struct btd_device *dev = l->data;
-		devices[i] = (char *) device_get_path(dev);
-	}
-
-	emit_array_property_changed(adapter->path,
-					ADAPTER_INTERFACE, "Devices",
-					DBUS_TYPE_OBJECT_PATH, &devices, i);
-	g_free(devices);
-}
-
-static void adapter_emit_uuids_updated(struct btd_adapter *adapter)
-{
-	char **uuids;
-	int i;
-	sdp_list_t *list;
-
-	if (!adapter->initialized)
-		return;
-
-	uuids = g_new0(char *, sdp_list_len(adapter->services) + 1);
-
-	for (i = 0, list = adapter->services; list; list = list->next) {
-		char *uuid;
-		sdp_record_t *rec = list->data;
-
-		uuid = bt_uuid2string(&rec->svclass);
-		if (uuid)
-			uuids[i++] = uuid;
-	}
-
-	emit_array_property_changed(adapter->path,
-					ADAPTER_INTERFACE, "UUIDs",
-					DBUS_TYPE_STRING, &uuids, i);
-
-	g_strfreev(uuids);
-}
-
 static uint8_t get_uuid_mask(uuid_t *uuid)
 {
 	if (uuid->type != SDP_UUID16)
@@ -947,7 +899,9 @@ void adapter_service_insert(struct btd_adapter *adapter, void *r)
 		mgmt_add_uuid(adapter->dev_id, &rec->svclass, svc_hint);
 	}
 
-	adapter_emit_uuids_updated(adapter);
+	if (adapter->initialized)
+		g_dbus_emit_property_changed(btd_get_dbus_connection(),
+				adapter->path, ADAPTER_INTERFACE, "UUIDs");
 }
 
 void adapter_service_remove(struct btd_adapter *adapter, void *r)
@@ -959,7 +913,9 @@ void adapter_service_remove(struct btd_adapter *adapter, void *r)
 	if (sdp_list_find(adapter->services, &rec->svclass, uuid_cmp) == NULL)
 		mgmt_remove_uuid(adapter->dev_id, &rec->svclass);
 
-	adapter_emit_uuids_updated(adapter);
+	if (adapter->initialized)
+		g_dbus_emit_property_changed(btd_get_dbus_connection(),
+				adapter->path, ADAPTER_INTERFACE, "UUIDs");
 }
 
 static struct btd_device *adapter_create_device(struct btd_adapter *adapter,
@@ -985,7 +941,8 @@ static struct btd_device *adapter_create_device(struct btd_adapter *adapter,
 			DBUS_TYPE_OBJECT_PATH, &path,
 			DBUS_TYPE_INVALID);
 
-	adapter_update_devices(adapter);
+	g_dbus_emit_property_changed(btd_get_dbus_connection(),
+				adapter->path, ADAPTER_INTERFACE, "Devices");
 
 	return device;
 }
@@ -1033,7 +990,8 @@ void adapter_remove_device(struct btd_adapter *adapter,
 		service_auth_cancel(auth);
 	}
 
-	adapter_update_devices(adapter);
+	g_dbus_emit_property_changed(btd_get_dbus_connection(),
+				adapter->path, ADAPTER_INTERFACE, "Devices");
 
 	g_dbus_emit_signal(btd_get_dbus_connection(), adapter->path,
 			ADAPTER_INTERFACE, "DeviceRemoved",
@@ -1807,8 +1765,6 @@ static const GDBusMethodTable adapter_methods[] = {
 };
 
 static const GDBusSignalTable adapter_signals[] = {
-	{ GDBUS_SIGNAL("PropertyChanged",
-			GDBUS_ARGS({ "name", "s" }, { "value", "v" })) },
 	{ GDBUS_SIGNAL("DeviceCreated",
 			GDBUS_ARGS({ "device", "o" })) },
 	{ GDBUS_SIGNAL("DeviceRemoved",
@@ -2449,7 +2405,6 @@ void btd_adapter_start(struct btd_adapter *adapter)
 {
 	struct session_req *req;
 	char address[18];
-	gboolean powered;
 
 	ba2str(&adapter->bdaddr, address);
 
@@ -2465,10 +2420,8 @@ void btd_adapter_start(struct btd_adapter *adapter)
 	else
 		adapter->mode = MODE_CONNECTABLE;
 
-	powered = TRUE;
-	emit_property_changed(adapter->path,
-				ADAPTER_INTERFACE, "Powered",
-				DBUS_TYPE_BOOLEAN, &powered);
+	g_dbus_emit_property_changed(btd_get_dbus_connection(), adapter->path,
+						ADAPTER_INTERFACE, "Powered");
 
 	call_adapter_powered_callbacks(adapter, TRUE);
 
@@ -2586,7 +2539,9 @@ static void set_mode_complete(struct btd_adapter *adapter)
 
 int btd_adapter_stop(struct btd_adapter *adapter)
 {
-	gboolean prop_false = FALSE;
+	DBusConnection *conn = btd_get_dbus_connection();
+	bool emit_discoverable = false, emit_pairable = false;
+	bool emit_discovering = false;
 
 	/* check pending requests */
 	reply_pending_requests(adapter);
@@ -2606,29 +2561,33 @@ int btd_adapter_stop(struct btd_adapter *adapter)
 	}
 
 	if (adapter->scan_mode == (SCAN_PAGE | SCAN_INQUIRY))
-		emit_property_changed(adapter->path,
-					ADAPTER_INTERFACE, "Discoverable",
-					DBUS_TYPE_BOOLEAN, &prop_false);
+		emit_discoverable = true;
 
 	if ((adapter->scan_mode & SCAN_PAGE) && adapter->pairable == TRUE)
-		emit_property_changed(adapter->path,
-					ADAPTER_INTERFACE, "Pairable",
-					DBUS_TYPE_BOOLEAN, &prop_false);
+		emit_pairable = true;
 
 	if (adapter->discovering)
-		emit_property_changed(adapter->path,
-					ADAPTER_INTERFACE, "Discovering",
-					DBUS_TYPE_BOOLEAN, &prop_false);
-
-	emit_property_changed(adapter->path,
-				ADAPTER_INTERFACE, "Powered",
-				DBUS_TYPE_BOOLEAN, &prop_false);
+		emit_discovering = true;
 
 	adapter->discovering = FALSE;
 	adapter->scan_mode = SCAN_DISABLED;
 	adapter->mode = MODE_OFF;
 	adapter->off_requested = FALSE;
 
+	if (emit_discoverable)
+		g_dbus_emit_property_changed(conn, adapter->path,
+					ADAPTER_INTERFACE, "Discoverable");
+	if (emit_pairable)
+		g_dbus_emit_property_changed(conn, adapter->path,
+					ADAPTER_INTERFACE, "Pairable");
+
+	if (emit_discovering)
+		g_dbus_emit_property_changed(conn, adapter->path,
+					ADAPTER_INTERFACE, "Discovering");
+
+	g_dbus_emit_property_changed(conn, adapter->path, ADAPTER_INTERFACE,
+								"Powered");
+
 	call_adapter_powered_callbacks(adapter, FALSE);
 
 	info("Adapter %s has been disabled", adapter->path);
@@ -2818,14 +2777,12 @@ void adapter_set_allow_name_changes(struct btd_adapter *adapter,
 void adapter_set_discovering(struct btd_adapter *adapter,
 						gboolean discovering)
 {
-	const char *path = adapter->path;
 	guint connect_list_len;
 
 	adapter->discovering = discovering;
 
-	emit_property_changed(path,
-				ADAPTER_INTERFACE, "Discovering",
-				DBUS_TYPE_BOOLEAN, &discovering);
+	g_dbus_emit_property_changed(btd_get_dbus_connection(), adapter->path,
+					ADAPTER_INTERFACE, "Discovering");
 
 	if (discovering)
 		return;
@@ -3319,7 +3276,7 @@ done:
 
 void adapter_mode_changed(struct btd_adapter *adapter, uint8_t scan_mode)
 {
-	gboolean discoverable, pairable;
+	bool emit_pairable = false;
 
 	DBG("old 0x%02x new 0x%02x", adapter->scan_mode, scan_mode);
 
@@ -3329,18 +3286,12 @@ void adapter_mode_changed(struct btd_adapter *adapter, uint8_t scan_mode)
 	switch (scan_mode) {
 	case SCAN_DISABLED:
 		adapter->mode = MODE_OFF;
-		discoverable = FALSE;
-		pairable = FALSE;
 		break;
 	case SCAN_PAGE:
 		adapter->mode = MODE_CONNECTABLE;
-		discoverable = FALSE;
-		pairable = adapter->pairable;
 		break;
 	case (SCAN_PAGE | SCAN_INQUIRY):
 		adapter->mode = MODE_DISCOVERABLE;
-		discoverable = TRUE;
-		pairable = adapter->pairable;
 		break;
 	default:
 		/* ignore, reserved */
@@ -3349,16 +3300,17 @@ void adapter_mode_changed(struct btd_adapter *adapter, uint8_t scan_mode)
 
 	/* If page scanning gets toggled emit the Pairable property */
 	if ((adapter->scan_mode & SCAN_PAGE) != (scan_mode & SCAN_PAGE))
-		emit_property_changed(adapter->path,
-					ADAPTER_INTERFACE, "Pairable",
-					DBUS_TYPE_BOOLEAN, &pairable);
-
-	emit_property_changed(adapter->path,
-				ADAPTER_INTERFACE, "Discoverable",
-				DBUS_TYPE_BOOLEAN, &discoverable);
+		emit_pairable = true;
 
 	adapter->scan_mode = scan_mode;
 
+	if (emit_pairable)
+		g_dbus_emit_property_changed(btd_get_dbus_connection(),
+				adapter->path, ADAPTER_INTERFACE, "Pairable");
+
+	g_dbus_emit_property_changed(btd_get_dbus_connection(), adapter->path,
+					ADAPTER_INTERFACE, "Discoverable");
+
 	set_mode_complete(adapter);
 }
 
-- 
1.7.12.2

Re: [PATCH BlueZ 1/8] adapter: Add DBus.Properties getters

[Johan Hedberg]

Hi Lucas,

On Tue, Oct 09, 2012, Lucas De Marchi wrote:
> ---
>  src/adapter.c | 221 +++++++++++++++++++++++++++++++++++++++-------------------
>  1 file changed, 149 insertions(+), 72 deletions(-)

All of these patches have been applied. I also pushed three other
patches to convert list-devices, test-adapter and test-device to support
the new interfaces.

Johan