mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-09-09 13:48:55 +00:00
333 lines
8.6 KiB
C
333 lines
8.6 KiB
C
/*
|
|
* 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);
|
|
}
|