From 7ee92f15781ecec0b728a6580624d87cb6f15878 Mon Sep 17 00:00:00 2001 From: Luiz Augusto von Dentz Date: Thu, 11 Jul 2019 16:38:58 +0300 Subject: [PATCH] media: Add implementation of RegisterApplication This implements RegisterApplication registering any proxy which does implement either MediaEndpoint or MediaPlayer. Change-Id: Ib6bab82176f9941662511f47facc4f8d1f3d31e4 Signed-off-by: himanshu --- profiles/audio/media.c | 483 ++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 481 insertions(+), 2 deletions(-) diff --git a/profiles/audio/media.c b/profiles/audio/media.c index d178138..a50dd5b 100755 --- a/profiles/audio/media.c +++ b/profiles/audio/media.c @@ -51,6 +51,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" @@ -81,8 +82,21 @@ static gboolean a2dp_sink_support = false; static gboolean a2dp_source_support = true; #endif +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 */ }; @@ -236,8 +250,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) { @@ -1320,8 +1335,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); @@ -2280,6 +2297,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}" }), @@ -2295,6 +2767,13 @@ static const GDBusMethodTable media_methods[] = { { GDBUS_METHOD("SelectRole", GDBUS_ARGS({ "role", "s" }), NULL, a2dp_select_role) }, #endif + { 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.7.4