#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"
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 */
};
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) {
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);
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}" }),
{ 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) },
{ },
};
projects / platform / upstream / bluez.git / commitdiff