gstreamer/subprojects/gst-plugins-bad/sys/bluez/gstavrcputil.c

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

334 lines
8.6 KiB
C
Raw Normal View History

/*
* Copyright (C) 2015 Arun Raghavan <git@arunraghavan.net>
*
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "gstavrcputil.h"
#include "bluez.h"
#include <gio/gio.h>
#define BLUEZ_NAME "org.bluez"
#define BLUEZ_PATH "/"
#define BLUEZ_MEDIA_PLAYER_IFACE BLUEZ_NAME ".MediaPlayer1"
struct _GstAvrcpConnection
{
GMainContext *context;
GMainLoop *mainloop;
GThread *thread;
gchar *dev_path;
GDBusObjectManager *manager;
BluezMediaPlayer1 *player;
GstAvrcpMetadataCb cb;
gpointer user_data;
GDestroyNotify user_data_free_cb;
};
static const char *
tag_from_property (const char *name)
{
if (g_str_equal (name, "Title"))
return GST_TAG_TITLE;
else if (g_str_equal (name, "Artist"))
return GST_TAG_ARTIST;
else if (g_str_equal (name, "Album"))
return GST_TAG_ALBUM;
else if (g_str_equal (name, "Genre"))
return GST_TAG_GENRE;
else if (g_str_equal (name, "NumberOfTracks"))
return GST_TAG_TRACK_COUNT;
else if (g_str_equal (name, "TrackNumber"))
return GST_TAG_TRACK_NUMBER;
else if (g_str_equal (name, "Duration"))
return GST_TAG_DURATION;
else
return NULL;
}
static GstTagList *
tag_list_from_variant (GVariant * properties, gboolean track)
{
const gchar *name, *s;
GVariant *value;
GVariantIter *iter;
GstTagList *taglist = NULL;
iter = g_variant_iter_new (properties);
if (track)
taglist = gst_tag_list_new_empty ();
/* The properties are in two levels -- at the top level we have the position
* and the 'track'. The 'track' is another level of {sv} so we recurse one
* level to pick up the actual track data. We get the taglist from the
* recursive call, and ignore the position for now. */
while (g_variant_iter_next (iter, "{&sv}", &name, &value)) {
if (!track && g_str_equal (name, "Track")) {
/* Top level property */
taglist = tag_list_from_variant (value, TRUE);
} else if (track) {
/* If we get here, we are in the recursive call and we're dealing with
* properties under "Track" */
GType type;
const gchar *tag;
guint i;
guint64 i64;
tag = tag_from_property (name);
if (!tag)
goto next;
type = gst_tag_get_type (tag);
switch (type) {
case G_TYPE_STRING:
s = g_variant_get_string (value, NULL);
if (s && s[0] != '\0')
gst_tag_list_add (taglist, GST_TAG_MERGE_REPLACE, tag, s, NULL);
break;
case G_TYPE_UINT:
i = g_variant_get_uint32 (value);
if (i > 0)
gst_tag_list_add (taglist, GST_TAG_MERGE_REPLACE, tag, i, NULL);
break;
case G_TYPE_UINT64:
/* If we're here, the tag is 'duration' */
i64 = g_variant_get_uint32 (value);
if (i64 > 0 && i64 != (guint32) (-1)) {
gst_tag_list_add (taglist, GST_TAG_MERGE_REPLACE, tag,
i64 * GST_MSECOND, NULL);
}
break;
default:
GST_WARNING ("Unknown property: %s", name);
break;
}
}
next:
g_variant_unref (value);
}
g_variant_iter_free (iter);
if (taglist && gst_tag_list_is_empty (taglist)) {
gst_tag_list_unref (taglist);
taglist = NULL;
}
return taglist;
}
static void
player_property_changed_cb (GDBusProxy * proxy, GVariant * properties,
GStrv invalid, gpointer user_data)
{
GstAvrcpConnection *avrcp = (GstAvrcpConnection *) user_data;
GstTagList *taglist;
taglist = tag_list_from_variant (properties, FALSE);
if (taglist)
avrcp->cb (avrcp, taglist, avrcp->user_data);
}
static GstTagList *
player_get_taglist (BluezMediaPlayer1 * player)
{
GstTagList *taglist = NULL;
GVariant *track;
track = bluez_media_player1_get_track (player);
if (track)
taglist = tag_list_from_variant (track, TRUE);
return taglist;
}
static void
gst_avrcp_connection_set_player (GstAvrcpConnection * avrcp,
BluezMediaPlayer1 * player)
{
GstTagList *taglist;
if (avrcp->player)
g_object_unref (avrcp->player);
if (!player) {
avrcp->player = NULL;
return;
}
avrcp->player = g_object_ref (player);
g_signal_connect (player, "g-properties-changed",
G_CALLBACK (player_property_changed_cb), avrcp);
taglist = player_get_taglist (avrcp->player);
if (taglist)
avrcp->cb (avrcp, taglist, avrcp->user_data);
}
static BluezMediaPlayer1 *
media_player_from_dbus_object (GDBusObject * object)
{
return (BluezMediaPlayer1 *) g_dbus_object_get_interface (object,
BLUEZ_MEDIA_PLAYER_IFACE);
}
static GType
manager_proxy_type_func (GDBusObjectManagerClient * manager,
const gchar * object_path, const gchar * interface_name, gpointer user_data)
{
if (!interface_name)
return G_TYPE_DBUS_OBJECT_PROXY;
if (g_str_equal (interface_name, BLUEZ_MEDIA_PLAYER_IFACE))
return BLUEZ_TYPE_MEDIA_PLAYER1_PROXY;
return G_TYPE_DBUS_PROXY;
}
static void
manager_object_added_cb (GDBusObjectManager * manager,
GDBusObject * object, gpointer user_data)
{
GstAvrcpConnection *avrcp = (GstAvrcpConnection *) user_data;
BluezMediaPlayer1 *player;
if (!(player = media_player_from_dbus_object (object)))
return;
gst_avrcp_connection_set_player (avrcp, player);
}
static void
manager_object_removed_cb (GDBusObjectManager * manager,
GDBusObject * object, gpointer user_data)
{
GstAvrcpConnection *avrcp = (GstAvrcpConnection *) user_data;
BluezMediaPlayer1 *player;
if (!(player = media_player_from_dbus_object (object)))
return;
if (player == avrcp->player)
gst_avrcp_connection_set_player (avrcp, NULL);
}
static void
manager_ready_cb (GObject * object, GAsyncResult * res, gpointer user_data)
{
GstAvrcpConnection *avrcp = (GstAvrcpConnection *) user_data;
GList *objects, *i;
GError *err = NULL;
avrcp->manager = g_dbus_object_manager_client_new_for_bus_finish (res, &err);
if (!avrcp->manager) {
GST_WARNING ("Could not create ObjectManager proxy: %s", err->message);
g_error_free (err);
return;
}
g_signal_connect (avrcp->manager, "object-added",
G_CALLBACK (manager_object_added_cb), avrcp);
g_signal_connect (avrcp->manager, "object-removed",
G_CALLBACK (manager_object_removed_cb), avrcp);
objects = g_dbus_object_manager_get_objects (avrcp->manager);
for (i = objects; i; i = i->next) {
BluezMediaPlayer1 *player =
media_player_from_dbus_object (G_DBUS_OBJECT (i->data));
if (player && g_str_equal (avrcp->dev_path,
bluez_media_player1_get_device (player))) {
gst_avrcp_connection_set_player (avrcp, player);
break;
}
}
g_list_free_full (objects, g_object_unref);
}
GstAvrcpConnection *
gst_avrcp_connection_new (const gchar * dev_path, GstAvrcpMetadataCb cb,
gpointer user_data, GDestroyNotify user_data_free_cb)
{
GstAvrcpConnection *avrcp;
avrcp = g_new0 (GstAvrcpConnection, 1);
avrcp->cb = cb;
avrcp->user_data = user_data;
avrcp->user_data_free_cb = user_data_free_cb;
avrcp->context = g_main_context_new ();
avrcp->mainloop = g_main_loop_new (avrcp->context, FALSE);
avrcp->dev_path = g_strdup (dev_path);
g_main_context_push_thread_default (avrcp->context);
g_dbus_object_manager_client_new_for_bus (G_BUS_TYPE_SYSTEM,
G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_NONE, BLUEZ_NAME, BLUEZ_PATH,
manager_proxy_type_func, NULL, NULL, NULL, manager_ready_cb, avrcp);
g_main_context_pop_thread_default (avrcp->context);
avrcp->thread = g_thread_new ("gstavrcp", (GThreadFunc) g_main_loop_run,
avrcp->mainloop);
return avrcp;
}
void
gst_avrcp_connection_free (GstAvrcpConnection * avrcp)
{
g_main_loop_quit (avrcp->mainloop);
g_main_loop_unref (avrcp->mainloop);
g_main_context_unref (avrcp->context);
g_thread_join (avrcp->thread);
if (avrcp->player)
g_object_unref (avrcp->player);
if (avrcp->manager)
g_object_unref (avrcp->manager);
if (avrcp->user_data_free_cb)
avrcp->user_data_free_cb (avrcp->user_data);
g_free (avrcp->dev_path);
g_free (avrcp);
}