[PATCH BlueZ 01/14] tools: Add support for MPRIS TrackList interface to mpris-player

[PATCH BlueZ 01/14] tools: Add support for MPRIS TrackList interface to mpris-player

[Luiz Augusto von Dentz]

From: Luiz Augusto von Dentz <luiz.von.dentz@intel.com>

This adds support for TrackList interface as defined in MPRIS:
http://specifications.freedesktop.org/mpris-spec/latest/Track_List_Interface.html
---
 tools/mpris-player.c | 299 ++++++++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 286 insertions(+), 13 deletions(-)

diff --git a/tools/mpris-player.c b/tools/mpris-player.c
index a7a506c..3378227 100644
--- a/tools/mpris-player.c
+++ b/tools/mpris-player.c
@@ -43,10 +43,13 @@
 #define BLUEZ_ADAPTER_INTERFACE "org.bluez.Adapter1"
 #define BLUEZ_MEDIA_INTERFACE "org.bluez.Media1"
 #define BLUEZ_MEDIA_PLAYER_INTERFACE "org.bluez.MediaPlayer1"
+#define BLUEZ_MEDIA_FOLDER_INTERFACE "org.bluez.MediaFolder1"
+#define BLUEZ_MEDIA_ITEM_INTERFACE "org.bluez.MediaItem1"
 #define BLUEZ_MEDIA_TRANSPORT_INTERFACE "org.bluez.MediaTransport1"
 #define MPRIS_BUS_NAME "org.mpris.MediaPlayer2."
 #define MPRIS_INTERFACE "org.mpris.MediaPlayer2"
 #define MPRIS_PLAYER_INTERFACE "org.mpris.MediaPlayer2.Player"
+#define MPRIS_TRACKLIST_INTERFACE "org.mpris.MediaPlayer2.TrackList"
 #define MPRIS_PLAYER_PATH "/org/mpris/MediaPlayer2"
 #define ERROR_INTERFACE "org.mpris.MediaPlayer2.Error"
 
@@ -61,12 +64,20 @@ static GSList *transports = NULL;
 static gboolean option_version = FALSE;
 static gboolean option_export = FALSE;
 
+struct tracklist {
+	char *playlist;
+	GDBusProxy *proxy;
+	GSList *items;
+};
+
 struct player {
 	char *bus_name;
 	DBusConnection *conn;
 	GDBusProxy *proxy;
+	GDBusProxy *folder;
 	GDBusProxy *device;
 	GDBusProxy *transport;
+	struct tracklist *tracklist;
 };
 
 typedef int (* parse_metadata_func) (DBusMessageIter *iter, const char *key,
@@ -856,10 +867,23 @@ static void disconnect_handler(DBusConnection *connection, void *user_data)
 	printf("org.bluez disappeared\n");
 }
 
+static void unregister_tracklist(struct player *player)
+{
+	struct tracklist *tracklist = player->tracklist;
+
+	g_slist_free(tracklist->items);
+	g_free(tracklist->playlist);
+	g_free(tracklist);
+	player->tracklist = NULL;
+}
+
 static void player_free(void *data)
 {
 	struct player *player = data;
 
+	if (player->tracklist != NULL)
+		unregister_tracklist(player);
+
 	if (player->conn) {
 		dbus_connection_close(player->conn);
 		dbus_connection_unref(player->conn);
@@ -1464,16 +1488,106 @@ static const GDBusMethodTable mpris_methods[] = {
 	{ }
 };
 
+static gboolean get_tracklist(const GDBusPropertyTable *property,
+					DBusMessageIter *iter, void *data)
+{
+	struct player *player = data;
+	dbus_bool_t value;
+
+	value = player->tracklist != NULL ? TRUE : FALSE;
+
+	dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN, &value);
+
+	return TRUE;
+}
+
 static const GDBusPropertyTable mpris_properties[] = {
 	{ "CanQuit", "b", get_disable, NULL, NULL },
 	{ "Fullscreen", "b", get_disable, NULL, NULL },
 	{ "CanSetFullscreen", "b", get_disable, NULL, NULL },
 	{ "CanRaise", "b", get_disable, NULL, NULL },
-	{ "HasTrackList", "b", get_disable, NULL, NULL },
+	{ "HasTrackList", "b", get_tracklist, NULL, NULL },
 	{ "Identity", "s", get_name, NULL, NULL },
 	{ }
 };
 
+static DBusMessage *tracklist_get_metadata(DBusConnection *conn,
+						DBusMessage *msg, void *data)
+{
+	return g_dbus_create_error(msg, ERROR_INTERFACE ".NotImplemented",
+					"Not implemented");
+}
+
+static DBusMessage *tracklist_goto(DBusConnection *conn,
+						DBusMessage *msg, void *data)
+{
+	return g_dbus_create_error(msg, ERROR_INTERFACE ".NotImplemented",
+					"Not implemented");
+}
+
+static DBusMessage *tracklist_add_track(DBusConnection *conn,
+						DBusMessage *msg, void *data)
+{
+	return g_dbus_create_error(msg, ERROR_INTERFACE ".NotImplemented",
+					"Not implemented");
+}
+
+static DBusMessage *tracklist_remove_track(DBusConnection *conn,
+						DBusMessage *msg, void *data)
+{
+	return g_dbus_create_error(msg, ERROR_INTERFACE ".NotImplemented",
+					"Not implemented");
+}
+
+static const GDBusMethodTable tracklist_methods[] = {
+	{ GDBUS_METHOD("GetTracksMetadata",
+			GDBUS_ARGS({ "tracks", "ao" }),
+			GDBUS_ARGS({ "metadata", "aa{sv}" }),
+			tracklist_get_metadata) },
+	{ GDBUS_METHOD("AddTrack",
+			GDBUS_ARGS({ "uri", "s" }, { "after", "o" },
+						{ "current", "b" }),
+			NULL,
+			tracklist_add_track) },
+	{ GDBUS_METHOD("RemoveTrack",
+			GDBUS_ARGS({ "track", "o" }), NULL,
+			tracklist_remove_track) },
+	{ GDBUS_ASYNC_METHOD("GoTo",
+			GDBUS_ARGS({ "track", "o" }), NULL,
+			tracklist_goto) },
+	{ },
+};
+
+static void append_path(gpointer data, gpointer user_data)
+{
+	GDBusProxy *proxy = data;
+	DBusMessageIter *iter = user_data;
+	const char *path = g_dbus_proxy_get_path(proxy);
+
+	dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH, &path);
+}
+
+static gboolean get_tracks(const GDBusPropertyTable *property,
+					DBusMessageIter *iter, void *data)
+{
+	struct player *player = data;
+	DBusMessageIter value;
+
+	dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
+					DBUS_TYPE_OBJECT_PATH_AS_STRING,
+					&value);
+	g_slist_foreach(player->tracklist->items, append_path, &value);
+	dbus_message_iter_close_container(iter, &value);
+
+	return TRUE;
+}
+
+static const GDBusPropertyTable tracklist_properties[] = {
+	{ "Tracks", "ao", get_tracks, NULL, NULL },
+	{ "CanEditTracks", "b", get_disable, NULL, NULL },
+	{ }
+};
+
 #define a_z "abcdefghijklmnopqrstuvwxyz"
 #define A_Z "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 #define _0_9 "_0123456789"
@@ -1509,6 +1623,79 @@ static GDBusProxy *find_transport_by_path(const char *path)
 	return NULL;
 }
 
+static void list_items_setup(DBusMessageIter *iter, void *user_data)
+{
+	DBusMessageIter dict;
+
+	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);
+	dbus_message_iter_close_container(iter, &dict);
+}
+
+static void change_folder_reply(DBusMessage *message, void *user_data)
+{
+	struct player *player = user_data;
+	struct tracklist *tracklist = player->tracklist;
+	DBusError err;
+
+	dbus_error_init(&err);
+	if (dbus_set_error_from_message(&err, message)) {
+		fprintf(stderr, "error: %s", err.name);
+		return;
+	}
+
+	g_dbus_proxy_method_call(tracklist->proxy, "ListItems",
+					list_items_setup, NULL, NULL, NULL);
+}
+
+static void change_folder_setup(DBusMessageIter *iter, void *user_data)
+{
+	struct player *player = user_data;
+	struct tracklist *tracklist = player->tracklist;
+
+	dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH,
+							&tracklist->playlist);
+}
+
+static void register_tracklist(struct player *player, const char *playlist)
+{
+	struct tracklist *tracklist;
+	GDBusProxy *proxy;
+
+	if (player->tracklist != NULL)
+		return;
+
+	proxy = g_dbus_proxy_new(client, g_dbus_proxy_get_path(player->proxy),
+						BLUEZ_MEDIA_FOLDER_INTERFACE);
+	if (proxy == NULL)
+		return;
+
+	tracklist = g_new0(struct tracklist, 1);
+	tracklist->proxy = proxy;
+	tracklist->playlist = g_strdup(playlist);
+
+	if (!g_dbus_register_interface(player->conn, MPRIS_PLAYER_PATH,
+						MPRIS_TRACKLIST_INTERFACE,
+						tracklist_methods,
+						NULL,
+						tracklist_properties,
+						player, NULL)) {
+		fprintf(stderr, "Could not register interface %s",
+						MPRIS_TRACKLIST_INTERFACE);
+		g_free(tracklist);
+		return;
+	}
+
+	player->tracklist = tracklist;
+
+	g_dbus_proxy_method_call(proxy, "ChangeFolder", change_folder_setup,
+					change_folder_reply, player, NULL);
+}
+
 static void register_player(GDBusProxy *proxy)
 {
 	struct player *player;
@@ -1582,6 +1769,11 @@ static void register_player(GDBusProxy *proxy)
 	if (transport)
 		player->transport = g_dbus_proxy_ref(transport);
 
+	if (g_dbus_proxy_get_property(proxy, "Playlist", &iter)) {
+		dbus_message_iter_get_basic(&iter, &path);
+		register_tracklist(player, path);
+	}
+
 	return;
 
 fail:
@@ -1630,28 +1822,72 @@ static void register_transport(GDBusProxy *proxy)
 	player->transport = g_dbus_proxy_ref(proxy);
 }
 
+static struct player *find_player_by_item(const char *item)
+{
+	GSList *l;
+
+	for (l = players; l; l = l->next) {
+		struct player *player = l->data;
+		const char *path = g_dbus_proxy_get_path(player->proxy);
+
+		if (g_str_has_prefix(item, path))
+			return player;
+	}
+
+	return NULL;
+}
+
+static void register_item(struct player *player, GDBusProxy *proxy)
+{
+	struct tracklist *tracklist;
+	const char *path;
+
+	tracklist = player->tracklist;
+	if (tracklist == NULL)
+		return;
+
+	path = g_dbus_proxy_get_path(proxy);
+	if (g_str_equal(path, tracklist->playlist) ||
+				!g_str_has_prefix(path, tracklist->playlist))
+		return;
+
+	tracklist->items = g_slist_append(tracklist->items, proxy);
+
+	g_dbus_emit_property_changed(player->conn, MPRIS_PLAYER_PATH,
+						MPRIS_TRACKLIST_INTERFACE,
+						"Tracks");
+}
+
 static void proxy_added(GDBusProxy *proxy, void *user_data)
 {
 	const char *interface;
+	const char *path;
 
 	interface = g_dbus_proxy_get_interface(proxy);
+	path = g_dbus_proxy_get_path(proxy);
 
 	if (!strcmp(interface, BLUEZ_ADAPTER_INTERFACE)) {
 		if (adapter != NULL)
 			return;
 
-		printf("Bluetooth Adapter %s found\n",
-						g_dbus_proxy_get_path(proxy));
+		printf("Bluetooth Adapter %s found\n", path);
 		adapter = proxy;
 		list_names(session);
 	} else if (!strcmp(interface, BLUEZ_MEDIA_PLAYER_INTERFACE)) {
-		printf("Bluetooth Player %s found\n",
-						g_dbus_proxy_get_path(proxy));
+		printf("Bluetooth Player %s found\n", path);
 		register_player(proxy);
 	} else if (!strcmp(interface, BLUEZ_MEDIA_TRANSPORT_INTERFACE)) {
-		printf("Bluetooth Transport %s found\n",
-						g_dbus_proxy_get_path(proxy));
+		printf("Bluetooth Transport %s found\n", path);
 		register_transport(proxy);
+	} else if (!strcmp(interface, BLUEZ_MEDIA_ITEM_INTERFACE)) {
+		struct player *player;
+
+		player = find_player_by_item(path);
+		if (player == NULL)
+			return;
+
+		printf("Bluetooth Item %s found\n", path);
+		register_item(player, proxy);
 	}
 }
 
@@ -1660,6 +1896,9 @@ static void unregister_player(struct player *player)
 	players = g_slist_remove(players, player);
 
 	g_dbus_unregister_interface(player->conn, MPRIS_PLAYER_PATH,
+						MPRIS_TRACKLIST_INTERFACE);
+
+	g_dbus_unregister_interface(player->conn, MPRIS_PLAYER_PATH,
 						MPRIS_INTERFACE);
 
 	g_dbus_unregister_interface(player->conn, MPRIS_PLAYER_PATH,
@@ -1711,20 +1950,41 @@ static void unregister_transport(GDBusProxy *proxy)
 	player->transport = NULL;
 }
 
+static void unregister_item(struct player *player, GDBusProxy *proxy)
+{
+	struct tracklist *tracklist = player->tracklist;
+	const char *path;
+
+	if (tracklist == NULL)
+		return;
+
+	path = g_dbus_proxy_get_path(proxy);
+	if (g_str_equal(path, tracklist->playlist) ||
+				!g_str_has_prefix(path, tracklist->playlist))
+		return;
+
+	tracklist->items = g_slist_remove(tracklist->items, proxy);
+
+	g_dbus_emit_property_changed(player->conn, MPRIS_PLAYER_PATH,
+						MPRIS_TRACKLIST_INTERFACE,
+						"Tracks");
+}
+
 static void proxy_removed(GDBusProxy *proxy, void *user_data)
 {
 	const char *interface;
+	const char *path;
 
 	if (adapter == NULL)
 		return;
 
 	interface = g_dbus_proxy_get_interface(proxy);
+	path = g_dbus_proxy_get_path(proxy);
 
 	if (strcmp(interface, BLUEZ_ADAPTER_INTERFACE) == 0) {
 		if (adapter != proxy)
 			return;
-		printf("Bluetooth Adapter %s removed\n",
-						g_dbus_proxy_get_path(proxy));
+		printf("Bluetooth Adapter %s removed\n", path);
 		adapter = NULL;
 	} else if (strcmp(interface, BLUEZ_MEDIA_PLAYER_INTERFACE) == 0) {
 		struct player *player;
@@ -1733,13 +1993,20 @@ static void proxy_removed(GDBusProxy *proxy, void *user_data)
 		if (player == NULL)
 			return;
 
-		printf("Bluetooth Player %s removed\n",
-						g_dbus_proxy_get_path(proxy));
+		printf("Bluetooth Player %s removed\n", path);
 		unregister_player(player);
 	} else if (strcmp(interface, BLUEZ_MEDIA_TRANSPORT_INTERFACE) == 0) {
-		printf("Bluetooth Transport %s removed\n",
-						g_dbus_proxy_get_path(proxy));
+		printf("Bluetooth Transport %s removed\n", path);
 		unregister_transport(proxy);
+	} else if (strcmp(interface, BLUEZ_MEDIA_ITEM_INTERFACE) == 0) {
+		struct player *player;
+
+		player = find_player_by_item(path);
+		if (player == NULL)
+			return;
+
+		printf("Bluetooth Item %s removed\n", path);
+		unregister_item(player, proxy);
 	}
 }
 
@@ -1771,6 +2038,12 @@ static void player_property_changed(GDBusProxy *proxy, const char *name,
 	if (player == NULL)
 		return;
 
+	if (strcasecmp(name, "Playlist") == 0) {
+		const char *path;
+		dbus_message_iter_get_basic(iter, &path);
+		return register_tracklist(player, path);
+	}
+
 	property = property_to_mpris(name);
 	if (property == NULL)
 		return;
-- 
1.8.1.4

[PATCH BlueZ 02/14] tools: Add implementation of TrackList.GetTracksMetadata to mpris-player

[Luiz Augusto von Dentz]

From: Luiz Augusto von Dentz <luiz.von.dentz@intel.com>

---
 tools/mpris-player.c | 86 ++++++++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 84 insertions(+), 2 deletions(-)

diff --git a/tools/mpris-player.c b/tools/mpris-player.c
index 3378227..2e27ee2 100644
--- a/tools/mpris-player.c
+++ b/tools/mpris-player.c
@@ -1511,11 +1511,93 @@ static const GDBusPropertyTable mpris_properties[] = {
 	{ }
 };
 
+static GDBusProxy *find_item(struct player *player, const char *path)
+{
+	struct tracklist *tracklist = player->tracklist;
+	GSList *l;
+
+	for (l = tracklist->items; l; l = l->next) {
+		GDBusProxy *proxy = l->data;
+		const char *p = g_dbus_proxy_get_path(proxy);
+
+		if (g_str_equal(path, p))
+			return proxy;
+	}
+
+	return NULL;
+}
+
+static void append_item_metadata(void *data, void *user_data)
+{
+	GDBusProxy *item = data;
+	DBusMessageIter *iter = user_data;
+	DBusMessageIter var, metadata;
+
+	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, &metadata);
+
+	if (g_dbus_proxy_get_property(item, "Metadata", &var))
+		parse_metadata(&var, &metadata, parse_track_entry);
+
+	dbus_message_iter_close_container(iter, &metadata);
+
+	return;
+}
+
 static DBusMessage *tracklist_get_metadata(DBusConnection *conn,
 						DBusMessage *msg, void *data)
 {
-	return g_dbus_create_error(msg, ERROR_INTERFACE ".NotImplemented",
-					"Not implemented");
+	struct player *player = data;
+	DBusMessage *reply;
+	DBusMessageIter args, array;
+	GSList *l = NULL;
+
+	dbus_message_iter_init(msg, &args);
+
+	if (dbus_message_iter_get_arg_type(&args) != DBUS_TYPE_ARRAY)
+		return g_dbus_create_error(msg,
+					ERROR_INTERFACE ".InvalidArguments",
+					"Invalid Arguments");
+
+	dbus_message_iter_recurse(&args, &array);
+
+	while (dbus_message_iter_get_arg_type(&array) ==
+						DBUS_TYPE_OBJECT_PATH) {
+		const char *path;
+		GDBusProxy *item;
+
+		dbus_message_iter_get_basic(&array, &path);
+
+		item = find_item(player, path);
+		if (item == NULL)
+			return g_dbus_create_error(msg,
+					ERROR_INTERFACE ".InvalidArguments",
+					"Invalid Arguments");
+
+		l = g_slist_append(l, item);
+
+		dbus_message_iter_next(&array);
+	}
+
+	reply = dbus_message_new_method_return(msg);
+
+	dbus_message_iter_init_append(reply, &args);
+
+	dbus_message_iter_open_container(&args, DBUS_TYPE_ARRAY,
+					DBUS_TYPE_ARRAY_AS_STRING
+					DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+					DBUS_TYPE_STRING_AS_STRING
+					DBUS_TYPE_VARIANT_AS_STRING
+					DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
+					&array);
+
+	g_slist_foreach(l, append_item_metadata, &array);
+
+	dbus_message_iter_close_container(&args, &array);
+
+	return reply;
 }
 
 static DBusMessage *tracklist_goto(DBusConnection *conn,
-- 
1.8.1.4

[PATCH BlueZ 03/14] tools: Add implementation of TrackList.GoTo to mpris-player

[Luiz Augusto von Dentz]

From: Luiz Augusto von Dentz <luiz.von.dentz@intel.com>

---
 tools/mpris-player.c | 54 ++++++++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 52 insertions(+), 2 deletions(-)

diff --git a/tools/mpris-player.c b/tools/mpris-player.c
index 2e27ee2..3fa9cd6 100644
--- a/tools/mpris-player.c
+++ b/tools/mpris-player.c
@@ -1600,11 +1600,61 @@ static DBusMessage *tracklist_get_metadata(DBusConnection *conn,
 	return reply;
 }
 
+static void item_play_reply(DBusMessage *message, void *user_data)
+{
+	struct pending_call *p = user_data;
+	struct player *player = p->player;
+	DBusMessage *msg = p->msg;
+	DBusMessage *reply;
+	DBusError err;
+
+	dbus_error_init(&err);
+	if (dbus_set_error_from_message(&err, message)) {
+		fprintf(stderr, "error: %s", err.name);
+		reply = g_dbus_create_error(msg, err.name, "%s", err.message);
+		dbus_error_free(&err);
+	} else
+		reply = g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+
+	g_dbus_send_message(player->conn, reply);
+}
+
+static void item_play(struct player *player, DBusMessage *msg,
+							GDBusProxy *item)
+{
+	struct pending_call *p;
+
+	p = g_new0(struct pending_call, 1);
+	p->player = player;
+	p->msg = dbus_message_ref(msg);
+
+	g_dbus_proxy_method_call(item, "Play", NULL, item_play_reply,
+						p, pending_call_free);
+}
+
 static DBusMessage *tracklist_goto(DBusConnection *conn,
 						DBusMessage *msg, void *data)
 {
-	return g_dbus_create_error(msg, ERROR_INTERFACE ".NotImplemented",
-					"Not implemented");
+	struct player *player = data;
+	GDBusProxy *item;
+	const char *path;
+
+	if (!dbus_message_get_args(msg, NULL,
+					DBUS_TYPE_OBJECT_PATH, &path,
+					DBUS_TYPE_INVALID))
+		return g_dbus_create_error(msg,
+					ERROR_INTERFACE ".InvalidArguments",
+					"Invalid arguments");
+
+	item = find_item(player, path);
+	if (item == NULL)
+		return g_dbus_create_error(msg,
+					ERROR_INTERFACE ".InvalidArguments",
+					"Invalid arguments");
+
+	item_play(player, msg, item);
+
+	return NULL;
 }
 
 static DBusMessage *tracklist_add_track(DBusConnection *conn,
-- 
1.8.1.4

[PATCH BlueZ 04/14] tools: Add support for MPRIS TrackList.TrackAdded signal to mpris-player

[Luiz Augusto von Dentz]

From: Luiz Augusto von Dentz <luiz.von.dentz@intel.com>

---
 tools/mpris-player.c | 47 ++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 46 insertions(+), 1 deletion(-)

diff --git a/tools/mpris-player.c b/tools/mpris-player.c
index 3fa9cd6..d4e6d14 100644
--- a/tools/mpris-player.c
+++ b/tools/mpris-player.c
@@ -1690,6 +1690,12 @@ static const GDBusMethodTable tracklist_methods[] = {
 	{ },
 };
 
+static const GDBusSignalTable tracklist_signals[] = {
+	{ GDBUS_SIGNAL("TrackAdded", GDBUS_ARGS({"metadata", "a{sv}"},
+						{"after", "o"})) },
+	{ }
+};
+
 static void append_path(gpointer data, gpointer user_data)
 {
 	GDBusProxy *proxy = data;
@@ -1813,7 +1819,7 @@ static void register_tracklist(struct player *player, const char *playlist)
 	if (!g_dbus_register_interface(player->conn, MPRIS_PLAYER_PATH,
 						MPRIS_TRACKLIST_INTERFACE,
 						tracklist_methods,
-						NULL,
+						tracklist_signals,
 						tracklist_properties,
 						player, NULL)) {
 		fprintf(stderr, "Could not register interface %s",
@@ -1973,6 +1979,10 @@ static void register_item(struct player *player, GDBusProxy *proxy)
 {
 	struct tracklist *tracklist;
 	const char *path;
+	DBusMessage *signal;
+	DBusMessageIter iter, args, metadata;
+	GSList *l;
+	GDBusProxy *after;
 
 	tracklist = player->tracklist;
 	if (tracklist == NULL)
@@ -1983,11 +1993,46 @@ static void register_item(struct player *player, GDBusProxy *proxy)
 				!g_str_has_prefix(path, tracklist->playlist))
 		return;
 
+	l = g_slist_last(tracklist->items);
 	tracklist->items = g_slist_append(tracklist->items, proxy);
 
 	g_dbus_emit_property_changed(player->conn, MPRIS_PLAYER_PATH,
 						MPRIS_TRACKLIST_INTERFACE,
 						"Tracks");
+
+	if (l == NULL)
+		return;
+
+	signal = dbus_message_new_signal(MPRIS_PLAYER_PATH,
+					MPRIS_TRACKLIST_INTERFACE,
+					"TrackAdded");
+	if (!signal) {
+		fprintf(stderr, "Unable to allocate new %s.TrackAdded signal",
+						MPRIS_TRACKLIST_INTERFACE);
+		return;
+	}
+
+	dbus_message_iter_init_append(signal, &args);
+
+	if (!g_dbus_proxy_get_property(proxy, "Metadata", &iter)) {
+		dbus_message_unref(signal);
+		return;
+	}
+
+	dbus_message_iter_open_container(&args, 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, &metadata);
+
+	parse_metadata(&iter, &metadata, parse_track_entry);
+
+	dbus_message_iter_close_container(&args, &metadata);
+
+	after = l->data;
+	path = g_dbus_proxy_get_path(after);
+	dbus_message_iter_append_basic(&args, DBUS_TYPE_OBJECT_PATH, &path);
+
+	g_dbus_send_message(player->conn, signal);
 }
 
 static void proxy_added(GDBusProxy *proxy, void *user_data)
-- 
1.8.1.4

[PATCH BlueZ 05/14] tools: Add support for MPRIS TrackList.TrackRemoved signal to mpris-player

[Luiz Augusto von Dentz]

From: Luiz Augusto von Dentz <luiz.von.dentz@intel.com>

---
 tools/mpris-player.c | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/tools/mpris-player.c b/tools/mpris-player.c
index d4e6d14..79d815b 100644
--- a/tools/mpris-player.c
+++ b/tools/mpris-player.c
@@ -1693,6 +1693,7 @@ static const GDBusMethodTable tracklist_methods[] = {
 static const GDBusSignalTable tracklist_signals[] = {
 	{ GDBUS_SIGNAL("TrackAdded", GDBUS_ARGS({"metadata", "a{sv}"},
 						{"after", "o"})) },
+	{ GDBUS_SIGNAL("TrackRemoved", GDBUS_ARGS({"track", "o"})) },
 	{ }
 };
 
@@ -2135,16 +2136,21 @@ static void unregister_item(struct player *player, GDBusProxy *proxy)
 	if (tracklist == NULL)
 		return;
 
-	path = g_dbus_proxy_get_path(proxy);
-	if (g_str_equal(path, tracklist->playlist) ||
-				!g_str_has_prefix(path, tracklist->playlist))
+	if (g_slist_find(tracklist->items, proxy) == NULL)
 		return;
 
+	path = g_dbus_proxy_get_path(proxy);
+
 	tracklist->items = g_slist_remove(tracklist->items, proxy);
 
 	g_dbus_emit_property_changed(player->conn, MPRIS_PLAYER_PATH,
 						MPRIS_TRACKLIST_INTERFACE,
 						"Tracks");
+
+	g_dbus_emit_signal(player->conn, MPRIS_PLAYER_PATH,
+				MPRIS_TRACKLIST_INTERFACE, "TrackRemoved",
+				DBUS_TYPE_OBJECT_PATH, &path,
+				DBUS_TYPE_INVALID);
 }
 
 static void proxy_removed(GDBusProxy *proxy, void *user_data)
-- 
1.8.1.4

[PATCH BlueZ 06/14] tools: Add support for MPRIS TrackList.TrackMetadataChanged signal to mpris-player

[Luiz Augusto von Dentz]

From: Luiz Augusto von Dentz <luiz.von.dentz@intel.com>

---
 tools/mpris-player.c | 40 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)

diff --git a/tools/mpris-player.c b/tools/mpris-player.c
index 79d815b..681bb09 100644
--- a/tools/mpris-player.c
+++ b/tools/mpris-player.c
@@ -1694,6 +1694,8 @@ static const GDBusSignalTable tracklist_signals[] = {
 	{ GDBUS_SIGNAL("TrackAdded", GDBUS_ARGS({"metadata", "a{sv}"},
 						{"after", "o"})) },
 	{ GDBUS_SIGNAL("TrackRemoved", GDBUS_ARGS({"track", "o"})) },
+	{ GDBUS_SIGNAL("TrackMetadataChanged", GDBUS_ARGS({"track", "o"},
+						{"metadata", "a{sv}"})) },
 	{ }
 };
 
@@ -2281,6 +2283,41 @@ static void transport_property_changed(GDBusProxy *proxy, const char *name,
 						name);
 }
 
+static void item_property_changed(GDBusProxy *proxy, const char *name,
+					DBusMessageIter *iter, void *user_data)
+{
+	struct player *player;
+	DBusMessage *signal;
+	DBusMessageIter args;
+	const char *path;
+
+	path = g_dbus_proxy_get_path(proxy);
+
+	player = find_player_by_item(path);
+	if (player == NULL)
+		return;
+
+	if (strcasecmp(name, "Metadata") != 0)
+		return;
+
+	signal = dbus_message_new_signal(MPRIS_PLAYER_PATH,
+					MPRIS_TRACKLIST_INTERFACE,
+					"TrackMetadataChanged");
+	if (!signal) {
+		fprintf(stderr, "Unable to allocate new %s.TrackAdded signal",
+						MPRIS_TRACKLIST_INTERFACE);
+		return;
+	}
+
+	dbus_message_iter_init_append(signal, &args);
+
+	dbus_message_iter_append_basic(&args, DBUS_TYPE_OBJECT_PATH, &path);
+
+	append_iter(&args, iter);
+
+	g_dbus_send_message(player->conn, signal);
+}
+
 static void property_changed(GDBusProxy *proxy, const char *name,
 					DBusMessageIter *iter, void *user_data)
 {
@@ -2294,6 +2331,9 @@ static void property_changed(GDBusProxy *proxy, const char *name,
 	if (strcmp(interface, BLUEZ_MEDIA_TRANSPORT_INTERFACE) == 0)
 		return transport_property_changed(proxy, name, iter,
 								user_data);
+
+	if (strcmp(interface, BLUEZ_MEDIA_ITEM_INTERFACE) == 0)
+		return item_property_changed(proxy, name, iter, user_data);
 }
 
 int main(int argc, char *argv[])
-- 
1.8.1.4

[PATCH BlueZ 07/14] tools: Add support for MPRIS Playlists interface to mpris-player

[Luiz Augusto von Dentz]

From: Luiz Augusto von Dentz <luiz.von.dentz@intel.com>

This adds support for Playlists interface as defined in MPRIS:
http://specifications.freedesktop.org/mpris-spec/latest/Playlists_Interface.html
---
 tools/mpris-player.c | 100 ++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 99 insertions(+), 1 deletion(-)

diff --git a/tools/mpris-player.c b/tools/mpris-player.c
index 681bb09..9ac59b3 100644
--- a/tools/mpris-player.c
+++ b/tools/mpris-player.c
@@ -50,6 +50,7 @@
 #define MPRIS_INTERFACE "org.mpris.MediaPlayer2"
 #define MPRIS_PLAYER_INTERFACE "org.mpris.MediaPlayer2.Player"
 #define MPRIS_TRACKLIST_INTERFACE "org.mpris.MediaPlayer2.TrackList"
+#define MPRIS_PLAYLISTS_INTERFACE "org.mpris.MediaPlayer2.Playlists"
 #define MPRIS_PLAYER_PATH "/org/mpris/MediaPlayer2"
 #define ERROR_INTERFACE "org.mpris.MediaPlayer2.Error"
 
@@ -1729,6 +1730,89 @@ static const GDBusPropertyTable tracklist_properties[] = {
 	{ }
 };
 
+static DBusMessage *playlist_activate(DBusConnection *conn,
+						DBusMessage *msg, void *data)
+{
+	return g_dbus_create_error(msg, ERROR_INTERFACE ".NotImplemented",
+					"Not implemented");
+}
+
+static DBusMessage *playlist_get(DBusConnection *conn, DBusMessage *msg,
+								void *data)
+{
+	return g_dbus_create_error(msg, ERROR_INTERFACE ".NotImplemented",
+					"Not implemented");
+}
+
+static const GDBusMethodTable playlist_methods[] = {
+	{ GDBUS_METHOD("ActivatePlaylist",
+			GDBUS_ARGS({ "playlist", "o" }), NULL,
+			playlist_activate) },
+	{ GDBUS_METHOD("GetPlaylists",
+			GDBUS_ARGS({ "index", "u" }, { "maxcount", "u"},
+					{ "order", "s" }, { "reverse", "b" }),
+			GDBUS_ARGS({ "playlists", "a(oss)"}),
+			playlist_get) },
+	{ },
+};
+
+static gboolean get_playlist_count(const GDBusPropertyTable *property,
+					DBusMessageIter *iter, void *data)
+{
+	uint32_t count = 1;
+
+	dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT32, &count);
+
+	return TRUE;
+}
+
+static gboolean get_orderings(const GDBusPropertyTable *property,
+					DBusMessageIter *iter, void *data)
+{
+	DBusMessageIter value;
+	const char *order = "User";
+
+	dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
+					DBUS_TYPE_OBJECT_PATH_AS_STRING,
+					&value);
+	dbus_message_iter_append_basic(&value, DBUS_TYPE_STRING, &order);
+	dbus_message_iter_close_container(iter, &value);
+
+	return TRUE;
+}
+
+static gboolean get_active_playlist(const GDBusPropertyTable *property,
+					DBusMessageIter *iter, void *data)
+{
+	struct player *player = data;
+	struct tracklist *tracklist = player->tracklist;
+	DBusMessageIter value, entry;
+	dbus_bool_t enabled = TRUE;
+	const char *empty = "";
+
+	dbus_message_iter_open_container(iter, DBUS_TYPE_STRUCT,
+							NULL, &value);
+	dbus_message_iter_append_basic(&value, DBUS_TYPE_BOOLEAN, &enabled);
+	dbus_message_iter_open_container(&value, DBUS_TYPE_STRUCT, NULL,
+								&entry);
+	dbus_message_iter_append_basic(&entry, DBUS_TYPE_OBJECT_PATH,
+						&tracklist->playlist);
+	dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING,
+						&tracklist->playlist);
+	dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &empty);
+	dbus_message_iter_close_container(&value, &entry);
+	dbus_message_iter_close_container(iter, &value);
+
+	return TRUE;
+}
+
+static const GDBusPropertyTable playlist_properties[] = {
+	{ "PlaylistCount", "u", get_playlist_count, NULL, NULL },
+	{ "Orderings", "as", get_orderings, NULL, NULL },
+	{ "ActivePlaylist", "(b(oss))", get_active_playlist, NULL, NULL },
+	{ }
+};
+
 #define a_z "abcdefghijklmnopqrstuvwxyz"
 #define A_Z "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 #define _0_9 "_0123456789"
@@ -1831,6 +1915,16 @@ static void register_tracklist(struct player *player, const char *playlist)
 		return;
 	}
 
+	if (!g_dbus_register_interface(player->conn, MPRIS_PLAYER_PATH,
+						MPRIS_PLAYLISTS_INTERFACE,
+						playlist_methods,
+						NULL,
+						playlist_properties,
+						player, NULL)) {
+		fprintf(stderr, "Could not register interface %s",
+						MPRIS_PLAYLISTS_INTERFACE);
+	}
+
 	player->tracklist = tracklist;
 
 	g_dbus_proxy_method_call(proxy, "ChangeFolder", change_folder_setup,
@@ -2075,8 +2169,12 @@ static void unregister_player(struct player *player)
 {
 	players = g_slist_remove(players, player);
 
-	g_dbus_unregister_interface(player->conn, MPRIS_PLAYER_PATH,
+	if (player->tracklist != NULL) {
+		g_dbus_unregister_interface(player->conn, MPRIS_PLAYER_PATH,
+						MPRIS_PLAYLISTS_INTERFACE);
+		g_dbus_unregister_interface(player->conn, MPRIS_PLAYER_PATH,
 						MPRIS_TRACKLIST_INTERFACE);
+	}
 
 	g_dbus_unregister_interface(player->conn, MPRIS_PLAYER_PATH,
 						MPRIS_INTERFACE);
-- 
1.8.1.4

[PATCH BlueZ 08/14] tools: Add implementation of Playlists.ActivatePlaylist to mpris-player

[Luiz Augusto von Dentz]

From: Luiz Augusto von Dentz <luiz.von.dentz@intel.com>

---
 tools/mpris-player.c | 99 +++++++++++++++++++++++++++++++---------------------
 1 file changed, 59 insertions(+), 40 deletions(-)

diff --git a/tools/mpris-player.c b/tools/mpris-player.c
index 9ac59b3..47e98d7 100644
--- a/tools/mpris-player.c
+++ b/tools/mpris-player.c
@@ -1730,11 +1730,68 @@ static const GDBusPropertyTable tracklist_properties[] = {
 	{ }
 };
 
+static void list_items_setup(DBusMessageIter *iter, void *user_data)
+{
+	DBusMessageIter dict;
+
+	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);
+	dbus_message_iter_close_container(iter, &dict);
+}
+
+static void change_folder_reply(DBusMessage *message, void *user_data)
+{
+	struct player *player = user_data;
+	struct tracklist *tracklist = player->tracklist;
+	DBusError err;
+
+	dbus_error_init(&err);
+	if (dbus_set_error_from_message(&err, message)) {
+		fprintf(stderr, "error: %s", err.name);
+		return;
+	}
+
+	g_dbus_proxy_method_call(tracklist->proxy, "ListItems",
+					list_items_setup, NULL, NULL, NULL);
+}
+
+static void change_folder_setup(DBusMessageIter *iter, void *user_data)
+{
+	struct player *player = user_data;
+	struct tracklist *tracklist = player->tracklist;
+
+	dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH,
+							&tracklist->playlist);
+}
+
 static DBusMessage *playlist_activate(DBusConnection *conn,
 						DBusMessage *msg, void *data)
 {
-	return g_dbus_create_error(msg, ERROR_INTERFACE ".NotImplemented",
-					"Not implemented");
+	struct player *player = data;
+	struct tracklist *tracklist = player->tracklist;
+	const char *path;
+
+	if (!dbus_message_get_args(msg, NULL,
+					DBUS_TYPE_OBJECT_PATH, &path,
+					DBUS_TYPE_INVALID))
+		return g_dbus_create_error(msg,
+					ERROR_INTERFACE ".InvalidArguments",
+					"Invalid Arguments");
+
+	if (!g_str_equal(path, tracklist->playlist))
+		return g_dbus_create_error(msg,
+					ERROR_INTERFACE ".InvalidArguments",
+					"Invalid Arguments");
+
+	g_dbus_proxy_method_call(tracklist->proxy, "ChangeFolder",
+				change_folder_setup, change_folder_reply,
+				player, NULL);
+
+	return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 }
 
 static DBusMessage *playlist_get(DBusConnection *conn, DBusMessage *msg,
@@ -1848,44 +1905,6 @@ static GDBusProxy *find_transport_by_path(const char *path)
 	return NULL;
 }
 
-static void list_items_setup(DBusMessageIter *iter, void *user_data)
-{
-	DBusMessageIter dict;
-
-	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);
-	dbus_message_iter_close_container(iter, &dict);
-}
-
-static void change_folder_reply(DBusMessage *message, void *user_data)
-{
-	struct player *player = user_data;
-	struct tracklist *tracklist = player->tracklist;
-	DBusError err;
-
-	dbus_error_init(&err);
-	if (dbus_set_error_from_message(&err, message)) {
-		fprintf(stderr, "error: %s", err.name);
-		return;
-	}
-
-	g_dbus_proxy_method_call(tracklist->proxy, "ListItems",
-					list_items_setup, NULL, NULL, NULL);
-}
-
-static void change_folder_setup(DBusMessageIter *iter, void *user_data)
-{
-	struct player *player = user_data;
-	struct tracklist *tracklist = player->tracklist;
-
-	dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH,
-							&tracklist->playlist);
-}
-
 static void register_tracklist(struct player *player, const char *playlist)
 {
 	struct tracklist *tracklist;
-- 
1.8.1.4

[PATCH BlueZ 09/14] tools: Add implementation of Playlists.GetPlaylists to mpris-player

[Luiz Augusto von Dentz]

From: Luiz Augusto von Dentz <luiz.von.dentz@intel.com>

---
 tools/mpris-player.c | 45 +++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 43 insertions(+), 2 deletions(-)

diff --git a/tools/mpris-player.c b/tools/mpris-player.c
index 47e98d7..a067fe5 100644
--- a/tools/mpris-player.c
+++ b/tools/mpris-player.c
@@ -1797,8 +1797,49 @@ static DBusMessage *playlist_activate(DBusConnection *conn,
 static DBusMessage *playlist_get(DBusConnection *conn, DBusMessage *msg,
 								void *data)
 {
-	return g_dbus_create_error(msg, ERROR_INTERFACE ".NotImplemented",
-					"Not implemented");
+	struct player *player = data;
+	struct tracklist *tracklist = player->tracklist;
+	uint32_t index, count;
+	const char *order;
+	dbus_bool_t reverse;
+	DBusMessage *reply;
+	DBusMessageIter iter, entry, value, name;
+	const char *string;
+	const char *empty = "";
+
+	if (!dbus_message_get_args(msg, NULL,
+					DBUS_TYPE_UINT32, &index,
+					DBUS_TYPE_UINT32, &count,
+					DBUS_TYPE_STRING, &order,
+					DBUS_TYPE_BOOLEAN, &reverse,
+					DBUS_TYPE_INVALID))
+		return g_dbus_create_error(msg,
+					ERROR_INTERFACE ".InvalidArguments",
+					"Invalid Arguments");
+
+	reply = dbus_message_new_method_return(msg);
+
+	dbus_message_iter_init_append(reply, &iter);
+
+	dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "(oss)",
+								&entry);
+	dbus_message_iter_open_container(&entry, DBUS_TYPE_STRUCT, NULL,
+								&value);
+	dbus_message_iter_append_basic(&value, DBUS_TYPE_OBJECT_PATH,
+						&tracklist->playlist);
+	if (g_dbus_proxy_get_property(tracklist->proxy, "Name", &name)) {
+		dbus_message_iter_get_basic(&name, &string);
+		dbus_message_iter_append_basic(&value, DBUS_TYPE_STRING,
+								&string);
+	} else {
+		dbus_message_iter_append_basic(&value, DBUS_TYPE_STRING,
+							&tracklist->playlist);
+	}
+	dbus_message_iter_append_basic(&value, DBUS_TYPE_STRING, &empty);
+	dbus_message_iter_close_container(&entry, &value);
+	dbus_message_iter_close_container(&iter, &entry);
+
+	return reply;
 }
 
 static const GDBusMethodTable playlist_methods[] = {
-- 
1.8.1.4

[PATCH BlueZ 10/14] tools: Map mpris:trackid to Item in mpris-player

[Luiz Augusto von Dentz]

From: Luiz Augusto von Dentz <luiz.von.dentz@intel.com>

mpris:trackid is used as identifier of the current track.
---
 tools/mpris-player.c | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/tools/mpris-player.c b/tools/mpris-player.c
index a067fe5..cdda3ec 100644
--- a/tools/mpris-player.c
+++ b/tools/mpris-player.c
@@ -1326,6 +1326,21 @@ static gboolean parse_int32_metadata(DBusMessageIter *iter, const char *key,
 	return TRUE;
 }
 
+static gboolean parse_path_metadata(DBusMessageIter *iter, const char *key,
+						DBusMessageIter *metadata)
+{
+	const char *value;
+
+	if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_OBJECT_PATH)
+		return FALSE;
+
+	dbus_message_iter_get_basic(iter, &value);
+
+	dict_append_entry(metadata, key, DBUS_TYPE_OBJECT_PATH, &value);
+
+	return TRUE;
+}
+
 static int parse_track_entry(DBusMessageIter *entry, const char *key,
 						DBusMessageIter *metadata)
 {
@@ -1354,6 +1369,9 @@ static int parse_track_entry(DBusMessageIter *entry, const char *key,
 	} else if (strcasecmp(key, "TrackNumber") == 0) {
 		if (!parse_int32_metadata(&var, "xesam:trackNumber", metadata))
 			return -EINVAL;
+	} else if (strcasecmp(key, "Item") == 0) {
+		if (!parse_path_metadata(&var, "mpris:trackid", metadata))
+			return -EINVAL;
 	}
 
 	return 0;
@@ -1533,12 +1551,16 @@ static void append_item_metadata(void *data, void *user_data)
 	GDBusProxy *item = data;
 	DBusMessageIter *iter = user_data;
 	DBusMessageIter var, metadata;
+	const char *path = g_dbus_proxy_get_path(item);
 
 	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, &metadata);
 
+	dict_append_entry(&metadata, "mpris:trackid", DBUS_TYPE_OBJECT_PATH,
+									&path);
+
 	if (g_dbus_proxy_get_property(item, "Metadata", &var))
 		parse_metadata(&var, &metadata, parse_track_entry);
 
-- 
1.8.1.4

[PATCH BlueZ 11/14] tools: Always register Playlists and TrackList in mpris-player

[Luiz Augusto von Dentz]

From: Luiz Augusto von Dentz <luiz.von.dentz@intel.com>

MPRIS spec does not make use of ObjectManager so the interfaces need
to be registered all together otherwise clients may get errors and
assume the interfaces will never be registered.
---
 tools/mpris-player.c | 115 +++++++++++++++++++++++++++++----------------------
 1 file changed, 66 insertions(+), 49 deletions(-)

diff --git a/tools/mpris-player.c b/tools/mpris-player.c
index cdda3ec..0307861 100644
--- a/tools/mpris-player.c
+++ b/tools/mpris-player.c
@@ -1722,6 +1722,13 @@ static const GDBusSignalTable tracklist_signals[] = {
 	{ }
 };
 
+static gboolean tracklist_exists(const GDBusPropertyTable *property, void *data)
+{
+	struct player *player = data;
+
+	return player->tracklist != NULL;
+}
+
 static void append_path(gpointer data, gpointer user_data)
 {
 	GDBusProxy *proxy = data;
@@ -1735,8 +1742,12 @@ static gboolean get_tracks(const GDBusPropertyTable *property,
 					DBusMessageIter *iter, void *data)
 {
 	struct player *player = data;
+	struct tracklist *tracklist = player->tracklist;
 	DBusMessageIter value;
 
+	if (tracklist == NULL)
+		return FALSE;
+
 	dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
 					DBUS_TYPE_OBJECT_PATH_AS_STRING,
 					&value);
@@ -1747,7 +1758,7 @@ static gboolean get_tracks(const GDBusPropertyTable *property,
 }
 
 static const GDBusPropertyTable tracklist_properties[] = {
-	{ "Tracks", "ao", get_tracks, NULL, NULL },
+	{ "Tracks", "ao", get_tracks, NULL, tracklist_exists },
 	{ "CanEditTracks", "b", get_disable, NULL, NULL },
 	{ }
 };
@@ -1879,8 +1890,12 @@ static const GDBusMethodTable playlist_methods[] = {
 static gboolean get_playlist_count(const GDBusPropertyTable *property,
 					DBusMessageIter *iter, void *data)
 {
+	struct player *player = data;
 	uint32_t count = 1;
 
+	if (player->tracklist == NULL)
+		return FALSE;
+
 	dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT32, &count);
 
 	return TRUE;
@@ -1910,6 +1925,9 @@ static gboolean get_active_playlist(const GDBusPropertyTable *property,
 	dbus_bool_t enabled = TRUE;
 	const char *empty = "";
 
+	if (tracklist == NULL)
+		return FALSE;
+
 	dbus_message_iter_open_container(iter, DBUS_TYPE_STRUCT,
 							NULL, &value);
 	dbus_message_iter_append_basic(&value, DBUS_TYPE_BOOLEAN, &enabled);
@@ -1927,9 +1945,10 @@ static gboolean get_active_playlist(const GDBusPropertyTable *property,
 }
 
 static const GDBusPropertyTable playlist_properties[] = {
-	{ "PlaylistCount", "u", get_playlist_count, NULL, NULL },
+	{ "PlaylistCount", "u", get_playlist_count, NULL, tracklist_exists },
 	{ "Orderings", "as", get_orderings, NULL, NULL },
-	{ "ActivePlaylist", "(b(oss))", get_active_playlist, NULL, NULL },
+	{ "ActivePlaylist", "(b(oss))", get_active_playlist, NULL,
+							tracklist_exists },
 	{ }
 };
 
@@ -1968,7 +1987,27 @@ static GDBusProxy *find_transport_by_path(const char *path)
 	return NULL;
 }
 
-static void register_tracklist(struct player *player, const char *playlist)
+static struct player *find_player(GDBusProxy *proxy)
+{
+	GSList *l;
+
+	for (l = players; l; l = l->next) {
+		struct player *player = l->data;
+		const char *path, *p;
+
+		if (player->proxy == proxy)
+			return player;
+
+		path = g_dbus_proxy_get_path(proxy);
+		p = g_dbus_proxy_get_path(player->proxy);
+		if (g_str_equal(path, p))
+			return player;
+	}
+
+	return NULL;
+}
+
+static void register_tracklist(struct player *player, const char *path)
 {
 	struct tracklist *tracklist;
 	GDBusProxy *proxy;
@@ -1983,34 +2022,9 @@ static void register_tracklist(struct player *player, const char *playlist)
 
 	tracklist = g_new0(struct tracklist, 1);
 	tracklist->proxy = proxy;
-	tracklist->playlist = g_strdup(playlist);
-
-	if (!g_dbus_register_interface(player->conn, MPRIS_PLAYER_PATH,
-						MPRIS_TRACKLIST_INTERFACE,
-						tracklist_methods,
-						tracklist_signals,
-						tracklist_properties,
-						player, NULL)) {
-		fprintf(stderr, "Could not register interface %s",
-						MPRIS_TRACKLIST_INTERFACE);
-		g_free(tracklist);
-		return;
-	}
-
-	if (!g_dbus_register_interface(player->conn, MPRIS_PLAYER_PATH,
-						MPRIS_PLAYLISTS_INTERFACE,
-						playlist_methods,
-						NULL,
-						playlist_properties,
-						player, NULL)) {
-		fprintf(stderr, "Could not register interface %s",
-						MPRIS_PLAYLISTS_INTERFACE);
-	}
+	tracklist->playlist = g_strdup(path);
 
 	player->tracklist = tracklist;
-
-	g_dbus_proxy_method_call(proxy, "ChangeFolder", change_folder_setup,
-					change_folder_reply, player, NULL);
 }
 
 static void register_player(GDBusProxy *proxy)
@@ -2082,15 +2096,32 @@ static void register_player(GDBusProxy *proxy)
 		goto fail;
 	}
 
+	if (!g_dbus_register_interface(player->conn, MPRIS_PLAYER_PATH,
+						MPRIS_TRACKLIST_INTERFACE,
+						tracklist_methods,
+						tracklist_signals,
+						tracklist_properties,
+						player, NULL)) {
+		fprintf(stderr, "Could not register interface %s",
+						MPRIS_TRACKLIST_INTERFACE);
+		goto fail;
+	}
+
+	if (!g_dbus_register_interface(player->conn, MPRIS_PLAYER_PATH,
+						MPRIS_PLAYLISTS_INTERFACE,
+						playlist_methods,
+						NULL,
+						playlist_properties,
+						player, NULL)) {
+		fprintf(stderr, "Could not register interface %s",
+						MPRIS_PLAYLISTS_INTERFACE);
+		goto fail;
+	}
+
 	transport = find_transport_by_path(path);
 	if (transport)
 		player->transport = g_dbus_proxy_ref(transport);
 
-	if (g_dbus_proxy_get_property(proxy, "Playlist", &iter)) {
-		dbus_message_iter_get_basic(&iter, &path);
-		register_tracklist(player, path);
-	}
-
 	return;
 
 fail:
@@ -2265,20 +2296,6 @@ static void unregister_player(struct player *player)
 						MPRIS_PLAYER_INTERFACE);
 }
 
-static struct player *find_player(GDBusProxy *proxy)
-{
-	GSList *l;
-
-	for (l = players; l; l = l->next) {
-		struct player *player = l->data;
-
-		if (player->proxy == proxy)
-			return player;
-	}
-
-	return NULL;
-}
-
 static struct player *find_player_by_transport(GDBusProxy *proxy)
 {
 	GSList *l;
-- 
1.8.1.4

[PATCH BlueZ 12/14] tools: Wait MediaFolder interface appear to enable TrackList in mpris-player

[Luiz Augusto von Dentz]

From: Luiz Augusto von Dentz <luiz.von.dentz@intel.com>

This avoids having to use g_dbus_proxy_new which may create a new proxy
when the interface is no registered yet and might not be ready for use.
---
 tools/mpris-player.c | 90 ++++++++++++++++++++++++++++++++++++++++------------
 1 file changed, 70 insertions(+), 20 deletions(-)

diff --git a/tools/mpris-player.c b/tools/mpris-player.c
index 0307861..cdff267 100644
--- a/tools/mpris-player.c
+++ b/tools/mpris-player.c
@@ -66,7 +66,6 @@ static gboolean option_version = FALSE;
 static gboolean option_export = FALSE;
 
 struct tracklist {
-	char *playlist;
 	GDBusProxy *proxy;
 	GSList *items;
 };
@@ -78,6 +77,7 @@ struct player {
 	GDBusProxy *folder;
 	GDBusProxy *device;
 	GDBusProxy *transport;
+	char *playlist;
 	struct tracklist *tracklist;
 };
 
@@ -873,7 +873,7 @@ static void unregister_tracklist(struct player *player)
 	struct tracklist *tracklist = player->tracklist;
 
 	g_slist_free(tracklist->items);
-	g_free(tracklist->playlist);
+	g_dbus_proxy_unref(tracklist->proxy);
 	g_free(tracklist);
 	player->tracklist = NULL;
 }
@@ -896,6 +896,7 @@ static void player_free(void *data)
 	if (player->transport)
 		g_dbus_proxy_unref(player->transport);
 
+	g_free(player->playlist);
 	g_free(player->bus_name);
 	g_free(player);
 }
@@ -1788,6 +1789,10 @@ static void change_folder_reply(DBusMessage *message, void *user_data)
 		return;
 	}
 
+	g_dbus_emit_property_changed(player->conn, MPRIS_PLAYER_PATH,
+						MPRIS_PLAYLISTS_INTERFACE,
+						"ActivePlaylist");
+
 	g_dbus_proxy_method_call(tracklist->proxy, "ListItems",
 					list_items_setup, NULL, NULL, NULL);
 }
@@ -1795,10 +1800,9 @@ static void change_folder_reply(DBusMessage *message, void *user_data)
 static void change_folder_setup(DBusMessageIter *iter, void *user_data)
 {
 	struct player *player = user_data;
-	struct tracklist *tracklist = player->tracklist;
 
 	dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH,
-							&tracklist->playlist);
+							&player->playlist);
 }
 
 static DBusMessage *playlist_activate(DBusConnection *conn,
@@ -1808,6 +1812,11 @@ static DBusMessage *playlist_activate(DBusConnection *conn,
 	struct tracklist *tracklist = player->tracklist;
 	const char *path;
 
+	if (tracklist == NULL)
+		return g_dbus_create_error(msg,
+					ERROR_INTERFACE ".InvalidArguments",
+					"Invalid Arguments");
+
 	if (!dbus_message_get_args(msg, NULL,
 					DBUS_TYPE_OBJECT_PATH, &path,
 					DBUS_TYPE_INVALID))
@@ -1815,7 +1824,7 @@ static DBusMessage *playlist_activate(DBusConnection *conn,
 					ERROR_INTERFACE ".InvalidArguments",
 					"Invalid Arguments");
 
-	if (!g_str_equal(path, tracklist->playlist))
+	if (!g_str_equal(path, player->playlist))
 		return g_dbus_create_error(msg,
 					ERROR_INTERFACE ".InvalidArguments",
 					"Invalid Arguments");
@@ -1840,6 +1849,11 @@ static DBusMessage *playlist_get(DBusConnection *conn, DBusMessage *msg,
 	const char *string;
 	const char *empty = "";
 
+	if (tracklist == NULL)
+		return g_dbus_create_error(msg,
+					ERROR_INTERFACE ".InvalidArguments",
+					"Invalid Arguments");
+
 	if (!dbus_message_get_args(msg, NULL,
 					DBUS_TYPE_UINT32, &index,
 					DBUS_TYPE_UINT32, &count,
@@ -1859,14 +1873,14 @@ static DBusMessage *playlist_get(DBusConnection *conn, DBusMessage *msg,
 	dbus_message_iter_open_container(&entry, DBUS_TYPE_STRUCT, NULL,
 								&value);
 	dbus_message_iter_append_basic(&value, DBUS_TYPE_OBJECT_PATH,
-						&tracklist->playlist);
+						&player->playlist);
 	if (g_dbus_proxy_get_property(tracklist->proxy, "Name", &name)) {
 		dbus_message_iter_get_basic(&name, &string);
 		dbus_message_iter_append_basic(&value, DBUS_TYPE_STRING,
 								&string);
 	} else {
 		dbus_message_iter_append_basic(&value, DBUS_TYPE_STRING,
-							&tracklist->playlist);
+							&player->playlist);
 	}
 	dbus_message_iter_append_basic(&value, DBUS_TYPE_STRING, &empty);
 	dbus_message_iter_close_container(&entry, &value);
@@ -1934,9 +1948,9 @@ static gboolean get_active_playlist(const GDBusPropertyTable *property,
 	dbus_message_iter_open_container(&value, DBUS_TYPE_STRUCT, NULL,
 								&entry);
 	dbus_message_iter_append_basic(&entry, DBUS_TYPE_OBJECT_PATH,
-						&tracklist->playlist);
+						&player->playlist);
 	dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING,
-						&tracklist->playlist);
+						&player->playlist);
 	dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &empty);
 	dbus_message_iter_close_container(&value, &entry);
 	dbus_message_iter_close_container(iter, &value);
@@ -2007,24 +2021,52 @@ static struct player *find_player(GDBusProxy *proxy)
 	return NULL;
 }
 
-static void register_tracklist(struct player *player, const char *path)
+static void register_tracklist(GDBusProxy *proxy)
 {
+	struct player *player;
 	struct tracklist *tracklist;
-	GDBusProxy *proxy;
 
-	if (player->tracklist != NULL)
+	player = find_player(proxy);
+	if (player == NULL)
 		return;
 
-	proxy = g_dbus_proxy_new(client, g_dbus_proxy_get_path(player->proxy),
-						BLUEZ_MEDIA_FOLDER_INTERFACE);
-	if (proxy == NULL)
+	if (player->tracklist != NULL)
 		return;
 
 	tracklist = g_new0(struct tracklist, 1);
-	tracklist->proxy = proxy;
-	tracklist->playlist = g_strdup(path);
+	tracklist->proxy = g_dbus_proxy_ref(proxy);
 
 	player->tracklist = tracklist;
+
+	if (player->playlist == NULL)
+		return;
+
+	g_dbus_emit_property_changed(player->conn, MPRIS_PLAYER_PATH,
+						MPRIS_PLAYLISTS_INTERFACE,
+						"PlaylistCount");
+
+	g_dbus_proxy_method_call(tracklist->proxy, "ChangeFolder",
+				change_folder_setup, change_folder_reply,
+				player, NULL);
+}
+
+static void player_set_playlist(struct player *player, const char *path)
+{
+	struct tracklist *tracklist = player->tracklist;
+
+	g_free(player->playlist);
+	player->playlist = g_strdup(path);
+
+	if (player->tracklist == NULL)
+		return;
+
+	g_dbus_emit_property_changed(player->conn, MPRIS_PLAYER_PATH,
+						MPRIS_PLAYLISTS_INTERFACE,
+						"PlaylistCount");
+
+	g_dbus_proxy_method_call(tracklist->proxy, "ChangeFolder",
+				change_folder_setup, change_folder_reply,
+				player, NULL);
 }
 
 static void register_player(GDBusProxy *proxy)
@@ -2122,6 +2164,11 @@ static void register_player(GDBusProxy *proxy)
 	if (transport)
 		player->transport = g_dbus_proxy_ref(transport);
 
+	if (g_dbus_proxy_get_property(proxy, "Playlist", &iter)) {
+		dbus_message_iter_get_basic(&iter, &path);
+		player_set_playlist(player, path);
+	}
+
 	return;
 
 fail:
@@ -2199,8 +2246,8 @@ static void register_item(struct player *player, GDBusProxy *proxy)
 		return;
 
 	path = g_dbus_proxy_get_path(proxy);
-	if (g_str_equal(path, tracklist->playlist) ||
-				!g_str_has_prefix(path, tracklist->playlist))
+	if (g_str_equal(path, player->playlist) ||
+				!g_str_has_prefix(path, player->playlist))
 		return;
 
 	l = g_slist_last(tracklist->items);
@@ -2266,6 +2313,9 @@ static void proxy_added(GDBusProxy *proxy, void *user_data)
 	} else if (!strcmp(interface, BLUEZ_MEDIA_TRANSPORT_INTERFACE)) {
 		printf("Bluetooth Transport %s found\n", path);
 		register_transport(proxy);
+	} else if (!strcmp(interface, BLUEZ_MEDIA_FOLDER_INTERFACE)) {
+		printf("Bluetooth Folder %s found\n", path);
+		register_tracklist(proxy);
 	} else if (!strcmp(interface, BLUEZ_MEDIA_ITEM_INTERFACE)) {
 		struct player *player;
 
@@ -2423,7 +2473,7 @@ static void player_property_changed(GDBusProxy *proxy, const char *name,
 	if (strcasecmp(name, "Playlist") == 0) {
 		const char *path;
 		dbus_message_iter_get_basic(iter, &path);
-		return register_tracklist(player, path);
+		return player_set_playlist(player, path);
 	}
 
 	property = property_to_mpris(name);
-- 
1.8.1.4

[PATCH BlueZ 13/14] tools: Use playlist proxy instead of object path in mpris-player

[Luiz Augusto von Dentz]

From: Luiz Augusto von Dentz <luiz.von.dentz@intel.com>

This is more convenient as it gives access to all properties including
the Name of the playlist.
---
 tools/mpris-player.c | 130 +++++++++++++++++++++++++++------------------------
 1 file changed, 69 insertions(+), 61 deletions(-)

diff --git a/tools/mpris-player.c b/tools/mpris-player.c
index cdff267..df0ac7c 100644
--- a/tools/mpris-player.c
+++ b/tools/mpris-player.c
@@ -77,7 +77,7 @@ struct player {
 	GDBusProxy *folder;
 	GDBusProxy *device;
 	GDBusProxy *transport;
-	char *playlist;
+	GDBusProxy *playlist;
 	struct tracklist *tracklist;
 };
 
@@ -896,7 +896,9 @@ static void player_free(void *data)
 	if (player->transport)
 		g_dbus_proxy_unref(player->transport);
 
-	g_free(player->playlist);
+	if (player->playlist)
+		g_dbus_proxy_unref(player->playlist);
+
 	g_free(player->bus_name);
 	g_free(player);
 }
@@ -1800,9 +1802,11 @@ static void change_folder_reply(DBusMessage *message, void *user_data)
 static void change_folder_setup(DBusMessageIter *iter, void *user_data)
 {
 	struct player *player = user_data;
+	const char *path;
+
+	path = g_dbus_proxy_get_path(player->playlist);
 
-	dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH,
-							&player->playlist);
+	dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH, &path);
 }
 
 static DBusMessage *playlist_activate(DBusConnection *conn,
@@ -1812,7 +1816,7 @@ static DBusMessage *playlist_activate(DBusConnection *conn,
 	struct tracklist *tracklist = player->tracklist;
 	const char *path;
 
-	if (tracklist == NULL)
+	if (player->playlist == NULL || tracklist == NULL)
 		return g_dbus_create_error(msg,
 					ERROR_INTERFACE ".InvalidArguments",
 					"Invalid Arguments");
@@ -1824,7 +1828,7 @@ static DBusMessage *playlist_activate(DBusConnection *conn,
 					ERROR_INTERFACE ".InvalidArguments",
 					"Invalid Arguments");
 
-	if (!g_str_equal(path, player->playlist))
+	if (!g_str_equal(path, g_dbus_proxy_get_path(player->playlist)))
 		return g_dbus_create_error(msg,
 					ERROR_INTERFACE ".InvalidArguments",
 					"Invalid Arguments");
@@ -1840,16 +1844,15 @@ static DBusMessage *playlist_get(DBusConnection *conn, DBusMessage *msg,
 								void *data)
 {
 	struct player *player = data;
-	struct tracklist *tracklist = player->tracklist;
 	uint32_t index, count;
 	const char *order;
 	dbus_bool_t reverse;
 	DBusMessage *reply;
 	DBusMessageIter iter, entry, value, name;
-	const char *string;
+	const char *string, *path;
 	const char *empty = "";
 
-	if (tracklist == NULL)
+	if (player->playlist == NULL)
 		return g_dbus_create_error(msg,
 					ERROR_INTERFACE ".InvalidArguments",
 					"Invalid Arguments");
@@ -1864,6 +1867,8 @@ static DBusMessage *playlist_get(DBusConnection *conn, DBusMessage *msg,
 					ERROR_INTERFACE ".InvalidArguments",
 					"Invalid Arguments");
 
+	path = g_dbus_proxy_get_path(player->playlist);
+
 	reply = dbus_message_new_method_return(msg);
 
 	dbus_message_iter_init_append(reply, &iter);
@@ -1872,15 +1877,14 @@ static DBusMessage *playlist_get(DBusConnection *conn, DBusMessage *msg,
 								&entry);
 	dbus_message_iter_open_container(&entry, DBUS_TYPE_STRUCT, NULL,
 								&value);
-	dbus_message_iter_append_basic(&value, DBUS_TYPE_OBJECT_PATH,
-						&player->playlist);
-	if (g_dbus_proxy_get_property(tracklist->proxy, "Name", &name)) {
+	dbus_message_iter_append_basic(&value, DBUS_TYPE_OBJECT_PATH, &path);
+	if (g_dbus_proxy_get_property(player->playlist, "Name", &name)) {
 		dbus_message_iter_get_basic(&name, &string);
 		dbus_message_iter_append_basic(&value, DBUS_TYPE_STRING,
 								&string);
 	} else {
 		dbus_message_iter_append_basic(&value, DBUS_TYPE_STRING,
-							&player->playlist);
+								&path);
 	}
 	dbus_message_iter_append_basic(&value, DBUS_TYPE_STRING, &empty);
 	dbus_message_iter_close_container(&entry, &value);
@@ -1901,13 +1905,20 @@ static const GDBusMethodTable playlist_methods[] = {
 	{ },
 };
 
+static gboolean playlist_exists(const GDBusPropertyTable *property, void *data)
+{
+	struct player *player = data;
+
+	return player->playlist != NULL;
+}
+
 static gboolean get_playlist_count(const GDBusPropertyTable *property,
 					DBusMessageIter *iter, void *data)
 {
 	struct player *player = data;
 	uint32_t count = 1;
 
-	if (player->tracklist == NULL)
+	if (player->playlist == NULL)
 		return FALSE;
 
 	dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT32, &count);
@@ -1934,23 +1945,22 @@ static gboolean get_active_playlist(const GDBusPropertyTable *property,
 					DBusMessageIter *iter, void *data)
 {
 	struct player *player = data;
-	struct tracklist *tracklist = player->tracklist;
 	DBusMessageIter value, entry;
 	dbus_bool_t enabled = TRUE;
-	const char *empty = "";
+	const char *path, *empty = "";
 
-	if (tracklist == NULL)
+	if (player->playlist == NULL)
 		return FALSE;
 
+	path = g_dbus_proxy_get_path(player->playlist);
+
 	dbus_message_iter_open_container(iter, DBUS_TYPE_STRUCT,
 							NULL, &value);
 	dbus_message_iter_append_basic(&value, DBUS_TYPE_BOOLEAN, &enabled);
 	dbus_message_iter_open_container(&value, DBUS_TYPE_STRUCT, NULL,
 								&entry);
-	dbus_message_iter_append_basic(&entry, DBUS_TYPE_OBJECT_PATH,
-						&player->playlist);
-	dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING,
-						&player->playlist);
+	dbus_message_iter_append_basic(&entry, DBUS_TYPE_OBJECT_PATH, &path);
+	dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &path);
 	dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &empty);
 	dbus_message_iter_close_container(&value, &entry);
 	dbus_message_iter_close_container(iter, &value);
@@ -1959,10 +1969,10 @@ static gboolean get_active_playlist(const GDBusPropertyTable *property,
 }
 
 static const GDBusPropertyTable playlist_properties[] = {
-	{ "PlaylistCount", "u", get_playlist_count, NULL, tracklist_exists },
+	{ "PlaylistCount", "u", get_playlist_count, NULL, playlist_exists },
 	{ "Orderings", "as", get_orderings, NULL, NULL },
 	{ "ActivePlaylist", "(b(oss))", get_active_playlist, NULL,
-							tracklist_exists },
+							playlist_exists },
 	{ }
 };
 
@@ -2041,30 +2051,7 @@ static void register_tracklist(GDBusProxy *proxy)
 	if (player->playlist == NULL)
 		return;
 
-	g_dbus_emit_property_changed(player->conn, MPRIS_PLAYER_PATH,
-						MPRIS_PLAYLISTS_INTERFACE,
-						"PlaylistCount");
-
-	g_dbus_proxy_method_call(tracklist->proxy, "ChangeFolder",
-				change_folder_setup, change_folder_reply,
-				player, NULL);
-}
-
-static void player_set_playlist(struct player *player, const char *path)
-{
-	struct tracklist *tracklist = player->tracklist;
-
-	g_free(player->playlist);
-	player->playlist = g_strdup(path);
-
-	if (player->tracklist == NULL)
-		return;
-
-	g_dbus_emit_property_changed(player->conn, MPRIS_PLAYER_PATH,
-						MPRIS_PLAYLISTS_INTERFACE,
-						"PlaylistCount");
-
-	g_dbus_proxy_method_call(tracklist->proxy, "ChangeFolder",
+	g_dbus_proxy_method_call(player->tracklist->proxy, "ChangeFolder",
 				change_folder_setup, change_folder_reply,
 				player, NULL);
 }
@@ -2164,11 +2151,6 @@ static void register_player(GDBusProxy *proxy)
 	if (transport)
 		player->transport = g_dbus_proxy_ref(transport);
 
-	if (g_dbus_proxy_get_property(proxy, "Playlist", &iter)) {
-		dbus_message_iter_get_basic(&iter, &path);
-		player_set_playlist(player, path);
-	}
-
 	return;
 
 fail:
@@ -2232,22 +2214,54 @@ static struct player *find_player_by_item(const char *item)
 	return NULL;
 }
 
+static void register_playlist(struct player *player, GDBusProxy *proxy)
+{
+	const char *path;
+	DBusMessageIter iter;
+
+	if (!g_dbus_proxy_get_property(player->proxy, "Playlist", &iter))
+		return;
+
+	dbus_message_iter_get_basic(&iter, &path);
+
+	if (!g_str_equal(path, g_dbus_proxy_get_path(proxy)))
+		return;
+
+	player->playlist = g_dbus_proxy_ref(proxy);
+
+	g_dbus_emit_property_changed(player->conn, MPRIS_PLAYER_PATH,
+						MPRIS_PLAYLISTS_INTERFACE,
+						"PlaylistCount");
+
+	if (player->tracklist == NULL)
+		return;
+
+	g_dbus_proxy_method_call(player->tracklist->proxy, "ChangeFolder",
+				change_folder_setup, change_folder_reply,
+				player, NULL);
+}
+
 static void register_item(struct player *player, GDBusProxy *proxy)
 {
 	struct tracklist *tracklist;
-	const char *path;
+	const char *path, *playlist;
 	DBusMessage *signal;
 	DBusMessageIter iter, args, metadata;
 	GSList *l;
 	GDBusProxy *after;
 
+	if (player->playlist == NULL) {
+		register_playlist(player, proxy);
+		return;
+	}
+
 	tracklist = player->tracklist;
 	if (tracklist == NULL)
 		return;
 
 	path = g_dbus_proxy_get_path(proxy);
-	if (g_str_equal(path, player->playlist) ||
-				!g_str_has_prefix(path, player->playlist))
+	playlist = g_dbus_proxy_get_path(player->playlist);
+	if (!g_str_has_prefix(path, playlist))
 		return;
 
 	l = g_slist_last(tracklist->items);
@@ -2470,12 +2484,6 @@ static void player_property_changed(GDBusProxy *proxy, const char *name,
 	if (player == NULL)
 		return;
 
-	if (strcasecmp(name, "Playlist") == 0) {
-		const char *path;
-		dbus_message_iter_get_basic(iter, &path);
-		return player_set_playlist(player, path);
-	}
-
 	property = property_to_mpris(name);
 	if (property == NULL)
 		return;
-- 
1.8.1.4

[PATCH BlueZ 14/14] tools: Emit changes to HasTrackList in mpris-player

[Luiz Augusto von Dentz]

From: Luiz Augusto von Dentz <luiz.von.dentz@intel.com>

---
 tools/mpris-player.c | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/tools/mpris-player.c b/tools/mpris-player.c
index df0ac7c..d3a42a8 100644
--- a/tools/mpris-player.c
+++ b/tools/mpris-player.c
@@ -2048,6 +2048,10 @@ static void register_tracklist(GDBusProxy *proxy)
 
 	player->tracklist = tracklist;
 
+	g_dbus_emit_property_changed(player->conn, MPRIS_PLAYER_PATH,
+						MPRIS_INTERFACE,
+						"HasTrackList");
+
 	if (player->playlist == NULL)
 		return;
 
-- 
1.8.1.4

Re: [PATCH BlueZ 01/14] tools: Add support for MPRIS TrackList interface to mpris-player

[Luiz Augusto von Dentz]

Hi,

On Wed, May 15, 2013 at 6:31 PM, Luiz Augusto von Dentz
<luiz.dentz@gmail.com> wrote:
> From: Luiz Augusto von Dentz <luiz.von.dentz@intel.com>
>
> This adds support for TrackList interface as defined in MPRIS:
> http://specifications.freedesktop.org/mpris-spec/latest/Track_List_Interface.html
> ---
>  tools/mpris-player.c | 299 ++++++++++++++++++++++++++++++++++++++++++++++++---
>  1 file changed, 286 insertions(+), 13 deletions(-)

This patch-set is now upstream.

Luiz Augusto von Dentz