[PATCH BlueZ 2/4] media: Add implementation of RegisterApplication

[Luiz Augusto von Dentz <luiz.dentz@gmail.com>]

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

This implements RegisterApplication registering any proxy which does
implement either MediaEndpoint or MediaPlayer.
---
 profiles/audio/media.c | 485 ++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 482 insertions(+), 3 deletions(-)

diff --git a/profiles/audio/media.c b/profiles/audio/media.c
index 28fa70668..993ecb3b3 100644
--- a/profiles/audio/media.c
+++ b/profiles/audio/media.c
@@ -48,6 +48,7 @@
 #include "src/uuid-helper.h"
 #include "src/log.h"
 #include "src/error.h"
+#include "src/shared/util.h"
 #include "src/shared/queue.h"
 
 #include "avdtp.h"
@@ -62,8 +63,21 @@
 
 #define REQUEST_TIMEOUT (3 * 1000)		/* 3 seconds */
 
+struct media_app {
+	struct media_adapter	*adapter;
+	GDBusClient		*client;
+	DBusMessage		*reg;
+	char			*sender;	/* Application bus id */
+	char			*path;		/* Application object path */
+	struct queue		*proxies;	/* Application proxies */
+	struct queue		*endpoints;	/* Application endpoints */
+	struct queue		*players;	/* Application players */
+	int			err;
+};
+
 struct media_adapter {
 	struct btd_adapter	*btd_adapter;
+	struct queue		*apps;		/* Application list */
 	GSList			*endpoints;	/* Endpoints list */
 	GSList			*players;	/* Players list */
 };
@@ -194,8 +208,9 @@ static struct media_endpoint *media_adapter_find_endpoint(
 	return NULL;
 }
 
-static void media_endpoint_remove(struct media_endpoint *endpoint)
+static void media_endpoint_remove(void *data)
 {
+	struct media_endpoint *endpoint = data;
 	struct media_adapter *adapter = endpoint->adapter;
 
 	if (endpoint->sep) {
@@ -996,8 +1011,10 @@ static void media_player_destroy(struct media_player *mp)
 	media_player_free(mp);
 }
 
-static void media_player_remove(struct media_player *mp)
+static void media_player_remove(void *data)
 {
+	struct media_player *mp = data;
+
 	info("Player unregistered: sender=%s path=%s", mp->sender, mp->path);
 
 	media_player_destroy(mp);
@@ -1341,7 +1358,7 @@ static gboolean set_position(struct media_player *mp, DBusMessageIter *iter)
 	const char *status;
 
 	if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_INT64)
-			return FALSE;
+		return FALSE;
 
 	dbus_message_iter_get_basic(iter, &value);
 
@@ -1870,6 +1887,461 @@ static DBusMessage *unregister_player(DBusConnection *conn, DBusMessage *msg,
 	return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
 }
 
+static void app_free(void *data)
+{
+	struct media_app *app = data;
+
+	queue_destroy(app->endpoints, media_endpoint_remove);
+	queue_destroy(app->players, media_player_remove);
+
+	if (app->client) {
+		g_dbus_client_set_disconnect_watch(app->client, NULL, NULL);
+		g_dbus_client_set_proxy_handlers(app->client, NULL, NULL,
+								NULL, NULL);
+		g_dbus_client_set_ready_watch(app->client, NULL, NULL);
+		g_dbus_client_unref(app->client);
+	}
+
+	if (app->reg)
+		dbus_message_unref(app->reg);
+
+	g_free(app->sender);
+	g_free(app->path);
+
+	free(app);
+}
+
+static void client_disconnect_cb(DBusConnection *conn, void *user_data)
+{
+	struct media_app *app = user_data;
+	struct media_adapter *adapter = app->adapter;
+
+	DBG("Client disconnected");
+
+	if (queue_remove(adapter->apps, app))
+		app_free(app);
+}
+
+static void app_register_endpoint(void *data, void *user_data)
+{
+	struct media_app *app = user_data;
+	GDBusProxy *proxy = data;
+	const char *iface = g_dbus_proxy_get_interface(proxy);
+	const char *path = g_dbus_proxy_get_path(proxy);
+	const char *uuid;
+	gboolean delay_reporting = FALSE;
+	uint8_t codec;
+	uint8_t *capabilities = NULL;
+	int size = 0;
+	DBusMessageIter iter, array;
+	struct media_endpoint *endpoint;
+
+	if (app->err)
+		return;
+
+	if (strcmp(iface, MEDIA_ENDPOINT_INTERFACE))
+		return;
+
+	/* Parse properties */
+	if (!g_dbus_proxy_get_property(proxy, "UUID", &iter))
+		goto fail;
+
+	if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
+		goto fail;
+
+	dbus_message_iter_get_basic(&iter, &uuid);
+
+	if (!g_dbus_proxy_get_property(proxy, "Codec", &iter))
+		goto fail;
+
+	if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_BYTE)
+		goto fail;
+
+	dbus_message_iter_get_basic(&iter, &codec);
+
+	/* DelayReporting and Capabilities are considered optional */
+	if (g_dbus_proxy_get_property(proxy, "DelayReporting", &iter))	{
+		if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_BOOLEAN)
+			goto fail;
+
+		dbus_message_iter_get_basic(&iter, &delay_reporting);
+	}
+
+	if (g_dbus_proxy_get_property(proxy, "Capabilities", &iter)) {
+		if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY)
+			goto fail;
+
+		dbus_message_iter_recurse(&iter, &array);
+		dbus_message_iter_get_fixed_array(&array, &capabilities, &size);
+	}
+
+	endpoint = media_endpoint_create(app->adapter, app->sender, path, uuid,
+					delay_reporting, codec, capabilities,
+					size, &app->err);
+	if (!endpoint) {
+		error("Unable to register endpoint %s:%s: %s", app->sender,
+						path, strerror(-app->err));
+		return;
+	}
+
+	queue_push_tail(app->endpoints, endpoint);
+
+	return;
+
+fail:
+	app->err = -EINVAL;
+}
+
+static void app_register_player(void *data, void *user_data)
+{
+	struct media_app *app = user_data;
+	GDBusProxy *proxy = data;
+	const char *iface = g_dbus_proxy_get_interface(proxy);
+	const char *path = g_dbus_proxy_get_path(proxy);
+	struct media_player *player;
+	DBusMessageIter iter;
+
+	if (app->err)
+		return;
+
+	if (strcmp(iface, MEDIA_PLAYER_INTERFACE))
+		return;
+
+	player = media_player_create(app->adapter, app->sender, path,
+							&app->err);
+	if (!player)
+		return;
+
+	if (g_dbus_proxy_get_property(proxy, "PlaybackStatus", &iter)) {
+		if (!set_status(player, &iter))
+			goto fail;
+	}
+
+	if (g_dbus_proxy_get_property(proxy, "Position", &iter)) {
+		if (!set_position(player, &iter))
+			goto fail;
+	}
+
+	if (g_dbus_proxy_get_property(proxy, "Metadata", &iter)) {
+		if (!parse_player_metadata(player, &iter))
+			goto fail;
+	}
+
+	if (g_dbus_proxy_get_property(proxy, "Shuffle", &iter)) {
+		if (!set_shuffle(player, &iter))
+			goto fail;
+	}
+
+	if (g_dbus_proxy_get_property(proxy, "LoopStatus", &iter)) {
+		if (!set_repeat(player, &iter))
+			goto fail;
+	}
+
+	if (g_dbus_proxy_get_property(proxy, "CanPlay", &iter)) {
+		if (!set_flag(player, &iter, &player->play))
+			goto fail;
+	}
+
+	if (g_dbus_proxy_get_property(proxy, "CanPause", &iter)) {
+		if (!set_flag(player, &iter, &player->pause))
+			goto fail;
+	}
+
+	if (g_dbus_proxy_get_property(proxy, "CanGoNext", &iter)) {
+		if (!set_flag(player, &iter, &player->next))
+			goto fail;
+	}
+
+	if (g_dbus_proxy_get_property(proxy, "CanGoPrevious", &iter)) {
+		if (!set_flag(player, &iter, &player->previous))
+			goto fail;
+	}
+
+	if (g_dbus_proxy_get_property(proxy, "CanControl", &iter)) {
+		if (!set_flag(player, &iter, &player->control))
+			goto fail;
+	}
+
+	if (g_dbus_proxy_get_property(proxy, "Identity", &iter)) {
+		if (!set_name(player, &iter))
+			goto fail;
+	}
+
+	queue_push_tail(app->players, player);
+
+	return;
+fail:
+	app->err = -EINVAL;
+	error("Unable to register player %s:%s: %s", app->sender, path,
+							strerror(-app->err));
+	media_player_destroy(player);
+}
+
+static void remove_app(void *data)
+{
+	struct media_app *app = data;
+
+	/*
+	 * Set callback to NULL to avoid potential race condition
+	 * when calling remove_app and GDBusClient unref.
+	 */
+	g_dbus_client_set_disconnect_watch(app->client, NULL, NULL);
+
+	/*
+	 * Set proxy handlers to NULL, so that this gets called only once when
+	 * the first proxy that belongs to this service gets removed.
+	 */
+	g_dbus_client_set_proxy_handlers(app->client, NULL, NULL, NULL, NULL);
+
+
+	queue_remove(app->adapter->apps, app);
+
+	app_free(app);
+}
+
+static void client_ready_cb(GDBusClient *client, void *user_data)
+{
+	struct media_app *app = user_data;
+	DBusMessage *reply;
+	bool fail = false;
+
+	/*
+	 * Process received objects
+	 */
+	if (queue_isempty(app->proxies)) {
+		error("No object received");
+		fail = true;
+		reply = btd_error_failed(app->reg, "No object received");
+		goto reply;
+	}
+
+	queue_foreach(app->proxies, app_register_endpoint, app);
+	queue_foreach(app->proxies, app_register_player, app);
+
+	if (app->err) {
+		if (app->err == -EPROTONOSUPPORT)
+			reply = btd_error_not_supported(app->reg);
+		else
+			reply = btd_error_invalid_args(app->reg);
+		goto reply;
+	}
+
+	if ((queue_isempty(app->endpoints) && queue_isempty(app->players))) {
+		error("No valid external Media objects found");
+		fail = true;
+		reply = btd_error_failed(app->reg,
+					"No valid media object found");
+		goto reply;
+	}
+
+	DBG("Media application registered: %s:%s", app->sender, app->path);
+
+	reply = dbus_message_new_method_return(app->reg);
+
+reply:
+	g_dbus_send_message(btd_get_dbus_connection(), reply);
+	dbus_message_unref(app->reg);
+	app->reg = NULL;
+
+	if (fail)
+		remove_app(app);
+}
+
+static void proxy_added_cb(GDBusProxy *proxy, void *user_data)
+{
+	struct media_app *app = user_data;
+	const char *iface, *path;
+
+	if (app->err)
+		return;
+
+	queue_push_tail(app->proxies, proxy);
+
+	iface = g_dbus_proxy_get_interface(proxy);
+	path = g_dbus_proxy_get_path(proxy);
+
+	DBG("Proxy added: %s, iface: %s", path, iface);
+}
+
+static bool match_endpoint_by_path(const void *a, const void *b)
+{
+	const struct media_endpoint *endpoint = a;
+	const char *path = b;
+
+	return !strcmp(endpoint->path, path);
+}
+
+static bool match_player_by_path(const void *a, const void *b)
+{
+	const struct media_player *player = a;
+	const char *path = b;
+
+	return !strcmp(player->path, path);
+}
+
+static void proxy_removed_cb(GDBusProxy *proxy, void *user_data)
+{
+	struct media_app *app = user_data;
+	struct media_endpoint *endpoint;
+	struct media_player *player;
+	const char *iface, *path;
+
+	iface = g_dbus_proxy_get_interface(proxy);
+	path = g_dbus_proxy_get_path(proxy);
+
+	if (!strcmp(iface, MEDIA_ENDPOINT_INTERFACE)) {
+		endpoint = queue_remove_if(app->endpoints,
+						match_endpoint_by_path,
+						(void *) path);
+		if (!endpoint)
+			return;
+
+		if (!g_slist_find(app->adapter->endpoints, endpoint))
+			return;
+
+		DBG("Proxy removed - removing endpoint: %s", endpoint->path);
+
+		media_endpoint_remove(endpoint);
+	} else if (!strcmp(iface, MEDIA_PLAYER_INTERFACE)) {
+		player = queue_remove_if(app->players, match_player_by_path,
+						(void *) path);
+		if (!player)
+			return;
+
+		if (!g_slist_find(app->adapter->players, player))
+			return;
+
+		DBG("Proxy removed - removing player: %s", player->path);
+
+		media_player_remove(player);
+	}
+}
+
+static struct media_app *create_app(DBusConnection *conn, DBusMessage *msg,
+							const char *path)
+{
+	struct media_app *app;
+	const char *sender = dbus_message_get_sender(msg);
+
+	if (!path || !g_str_has_prefix(path, "/"))
+		return NULL;
+
+	app = new0(struct media_app, 1);
+
+	app->client = g_dbus_client_new_full(conn, sender, path, path);
+	if (!app->client)
+		goto fail;
+
+	app->sender = g_strdup(sender);
+	if (!app->sender)
+		goto fail;
+
+	app->path = g_strdup(path);
+	if (!app->path)
+		goto fail;
+
+	app->proxies = queue_new();
+	app->endpoints = queue_new();
+	app->players = queue_new();
+	app->reg = dbus_message_ref(msg);
+
+	g_dbus_client_set_disconnect_watch(app->client, client_disconnect_cb,
+									app);
+	g_dbus_client_set_proxy_handlers(app->client, proxy_added_cb,
+					proxy_removed_cb, NULL, app);
+	g_dbus_client_set_ready_watch(app->client, client_ready_cb, app);
+
+	return app;
+
+fail:
+	app_free(app);
+	return NULL;
+}
+
+struct match_data {
+	const char *path;
+	const char *sender;
+};
+
+static bool match_app(const void *a, const void *b)
+{
+	const struct media_app *app = a;
+	const struct match_data *data = b;
+
+	return g_strcmp0(app->path, data->path) == 0 &&
+				g_strcmp0(app->sender, data->sender) == 0;
+}
+
+static DBusMessage *register_app(DBusConnection *conn, DBusMessage *msg,
+							void *user_data)
+{
+	struct media_adapter *adapter = user_data;
+	const char *sender = dbus_message_get_sender(msg);
+	DBusMessageIter args;
+	const char *path;
+	struct media_app *app;
+	struct match_data match_data;
+
+	if (!dbus_message_iter_init(msg, &args))
+		return btd_error_invalid_args(msg);
+
+	if (dbus_message_iter_get_arg_type(&args) != DBUS_TYPE_OBJECT_PATH)
+		return btd_error_invalid_args(msg);
+
+	dbus_message_iter_get_basic(&args, &path);
+
+	match_data.path = path;
+	match_data.sender = sender;
+
+	if (queue_find(adapter->apps, match_app, &match_data))
+		return btd_error_already_exists(msg);
+
+	dbus_message_iter_next(&args);
+	if (dbus_message_iter_get_arg_type(&args) != DBUS_TYPE_ARRAY)
+		return btd_error_invalid_args(msg);
+
+	app = create_app(conn, msg, path);
+	if (!app)
+		return btd_error_failed(msg, "Failed to register application");
+
+	DBG("Registering application: %s:%s", sender, path);
+
+	app->adapter = adapter;
+	queue_push_tail(adapter->apps, app);
+
+	return NULL;
+}
+
+static DBusMessage *unregister_app(DBusConnection *conn, DBusMessage *msg,
+							void *user_data)
+{
+	struct media_adapter *adapter = user_data;
+	const char *sender = dbus_message_get_sender(msg);
+	const char *path;
+	DBusMessageIter args;
+	struct media_app *app;
+	struct match_data match_data;
+
+	if (!dbus_message_iter_init(msg, &args))
+		return btd_error_invalid_args(msg);
+
+	if (dbus_message_iter_get_arg_type(&args) != DBUS_TYPE_OBJECT_PATH)
+		return btd_error_invalid_args(msg);
+
+	dbus_message_iter_get_basic(&args, &path);
+
+	match_data.path = path;
+	match_data.sender = sender;
+
+	app = queue_remove_if(adapter->apps, match_app, &match_data);
+	if (!app)
+		return btd_error_does_not_exist(msg);
+
+	app_free(app);
+
+	return dbus_message_new_method_return(msg);
+}
+
 static const GDBusMethodTable media_methods[] = {
 	{ GDBUS_METHOD("RegisterEndpoint",
 		GDBUS_ARGS({ "endpoint", "o" }, { "properties", "a{sv}" }),
@@ -1881,6 +2353,13 @@ static const GDBusMethodTable media_methods[] = {
 		NULL, register_player) },
 	{ GDBUS_METHOD("UnregisterPlayer",
 		GDBUS_ARGS({ "player", "o" }), NULL, unregister_player) },
+	{ GDBUS_ASYNC_METHOD("RegisterApplication",
+					GDBUS_ARGS({ "application", "o" },
+						{ "options", "a{sv}" }),
+					NULL, register_app) },
+	{ GDBUS_ASYNC_METHOD("UnregisterApplication",
+					GDBUS_ARGS({ "application", "o" }),
+					NULL, unregister_app) },
 	{ },
 };
 
-- 
2.21.0