annotate src/audacious/dbus.c @ 2694:c2b82432c1b6 trunk

[svn] Added basic DBus support, disabled by default with a configuration option to enable it. The general and playback information/manipulation methods are currently the only ones implemented. That is version, play, pause, stop, playing, paused, stopped, status, and seek. There are stubs for many unimplemented methods.

/*
*
* Author: Ben Tucker <[e-mail]>, (C) 2007
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at your
* option) any later version.
*
* This program 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
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
*
*/

#ifdef HAVE_CONFIG_H
#  include "config.h"
#endif

#include <glib.h>
#include <dbus/dbus-glib-bindings.h>
#include "dbus.h"
#include "dbus-bindings.h"

#include "main.h"
#include "ui_equalizer.h"
#include "ui_main.h"
#include "input.h"
#include "playback.h"
#include "playlist.h"
#include "ui_playlist.h"
#include "ui_preferences.h"
#include "libaudacious/beepctrl.h"
#include "memorypool.h"
#include "titlestring.h"
#include "ui_jumptotrack.h"

G_DEFINE_TYPE(RemoteObject, audacious_remote, G_TYPE_OBJECT);

void audacious_remote_class_init(RemoteObjectClass *class) {}

void audacious_remote_init(RemoteObject *object) {
	GError *error = NULL;
	DBusGProxy *driver_proxy;
	unsigned int request_ret;

	// Initialize the DBus connection
	object->connection = dbus_g_bus_get(DBUS_BUS_SESSION, &error);
	if (object->connection == NULL) {
		g_warning("Unable to connect to dbus: %s", error->message);
		g_error_free(error);
		return;
	}
	
	dbus_g_object_type_install_info(audacious_remote_get_type(),
																	&dbus_glib_audacious_remote_object_info);
	
	// Register DBUS path
	dbus_g_connection_register_g_object(object->connection, DBUS_OBJECT_PATH,
																			G_OBJECT(object));

	// Register the service name, the constants here are defined in
	// dbus-glib-bindings.h
	driver_proxy = dbus_g_proxy_new_for_name(object->connection,
																					 DBUS_SERVICE_DBUS, DBUS_PATH_DBUS,
																					 DBUS_INTERFACE_DBUS);

	if (!org_freedesktop_DBus_request_name(driver_proxy, DBUS_SERVICE, 0,
			&request_ret, &error)) {
		g_warning("Unable to register service: %s", error->message);
		g_error_free(error);
	}
	
	g_object_unref(driver_proxy);
}

RemoteObject *init_dbus() {
	RemoteObject *object;
	g_type_init();
	object = g_object_new(audacious_remote_get_type(), NULL);
	return object;
}

// Audacious General Information
gboolean audacious_remote_version(RemoteObject *obj, gchar **version,
																	GError **error) {
	*version = g_strdup(VERSION);
	return TRUE;
}

// Playback Information/Manipulation
gboolean audacious_remote_play(RemoteObject *obj, GError **error) {
	if (playback_get_paused())
		playback_pause();
	else if (playlist_get_length(playlist_get_active()))
		playback_initiate();
	else
		mainwin_eject_pushed();
	return TRUE;
}

gboolean audacious_remote_pause(RemoteObject *obj, GError **error) {
	playback_pause();
	return TRUE;
}

gboolean audacious_remote_stop(RemoteObject *obj, GError **error) {
	ip_data.stop = TRUE;
	playback_stop();
	ip_data.stop = FALSE;
	mainwin_clear_song_info();
	return TRUE;
}

gboolean audacious_remote_playing(RemoteObject *obj, gboolean *is_playing,
																	GError **error) {
	*is_playing = playback_get_playing();
	return TRUE;
}

gboolean audacious_remote_paused(RemoteObject *obj, gboolean *is_paused,
																 GError **error) {
	*is_paused = playback_get_paused();
	return TRUE;
}

gboolean audacious_remote_stopped(RemoteObject *obj, gboolean *is_stopped,
																	GError **error) {
	*is_stopped = !playback_get_playing();
	return TRUE;
}

gboolean audacious_remote_status(RemoteObject *obj, gchar **status,
																 GError **error) {
	if (playback_get_paused())
		*status = g_strdup("paused");
	else if (playback_get_playing())
		*status = g_strdup("playing");
	else
		*status = g_strdup("stopped");
	return TRUE;
}

gboolean audacious_remote_seek(RemoteObject *obj, guint pos, GError **error) {
	if (playlist_get_current_length(playlist_get_active()) > 0 &&
			pos < (guint)playlist_get_current_length(playlist_get_active()))
			playback_seek(pos / 1000);

	return TRUE;
}

// Playlist Information/Manipulation
gboolean audacious_remote_position(RemoteObject *obj, int *pos, GError **error)
{
	return TRUE;
}

gboolean audacious_remote_advance(RemoteObject *obj, GError **error) {
	return TRUE;
}

gboolean audacious_remote_reverse(RemoteObject *obj, GError **error) {
	return TRUE;
}

gboolean audacious_remote_length(RemoteObject *obj, int *length,
																 GError **error) {
	return TRUE;
}

gboolean audacious_remote_song_title(RemoteObject *obj, int pos,
																		 gchar **title, GError **error) {
	return TRUE;
}

gboolean audacious_remote_song_filename(RemoteObject *obj, int pos,
																				gchar **filename, GError **error) {
	return TRUE;
}

gboolean audacious_remote_song_length(RemoteObject *obj, int pos, int *length,
																			GError **error) {
	return TRUE;
}

gboolean audacious_remote_song_frames(RemoteObject *obj, int pos, int *length,
																			GError **error) {
	return TRUE;
}

gboolean audacious_remote_jump(RemoteObject *obj, int pos, GError **error) {
	return TRUE;
}

gboolean audacious_remote_add_url(RemoteObject *obj, gchar *url,
																	GError **error) {
	return TRUE;
}

gboolean audacious_remote_delete(RemoteObject *obj, int pos, GError **error) {
	return TRUE;
}

gboolean audacious_remote_clear(RemoteObject *obj, GError **error) {
	return TRUE;
}

gboolean audacious_remote_repeating(RemoteObject *obj, gboolean *is_repeating,
																		GError **error) {
	return TRUE;
}

gboolean audacious_remote_repeat(RemoteObject *obj, GError **error) {
	return TRUE;
}

gboolean audacious_remote_shuffling(RemoteObject *obj, gboolean *is_shuffling,
																		GError **error) {
	return TRUE;
}

gboolean audacious_remote_shuffle(RemoteObject *obj, GError **error) {
	return TRUE;
}