int
main (int argc, char **argv)
{
GMainLoop *ml;
xmmsv_t *operands;
xmmsc_result_t *result;
xmmsc_connection_t *connection;
if (argc != 4) {
fprintf (stderr, "Usage: %s service-id op1 op2\n", argv[0]);
return EXIT_FAILURE;
}
/* Connect as usual. */
connection = xmmsc_init ("sumclient");
if (!connection) {
fprintf (stderr, "OOM!\n");
exit (EXIT_FAILURE);
}
if (!xmmsc_connect (connection, getenv ("XMMS_PATH"))) {
fprintf (stderr, "Connection failed: %s\n",
xmmsc_get_last_error (connection));
exit (EXIT_FAILURE);
}
ml = g_main_loop_new (NULL, FALSE);
/* Build a list of two operands for sumservice (tut9). */
operands = xmmsv_build_list (xmmsv_new_int (atoi(argv[2])),
xmmsv_new_int (atoi(argv[3])),
XMMSV_LIST_END);
/* And send the list to the sumservice.
* We use the reply policy of only expecting a single reply,
* which means the receiving client will get an error from
* the server if it attempts to reply to this message more
* than once.
*/
result = xmmsc_c2c_send (connection,
atoi(argv[1]),
XMMS_C2C_REPLY_POLICY_SINGLE_REPLY,
operands);
xmmsv_unref (operands);
xmmsc_result_notifier_set (result, print_sum, ml);
xmmsc_result_unref (result);
xmmsc_mainloop_gmain_init (connection);
g_main_loop_run (ml);
xmmsc_unref (connection);
return EXIT_SUCCESS;
}
static updater_t *
updater_new (void)
{
updater_t *updater = g_new0 (updater_t, 1);
updater->conn = xmmsc_init ("XMMS2-Medialib-Updater");
updater->watchers = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free, unregister_monitor);
return updater;
}
int
main (int argc, char **argv)
{
GIOChannel *gio;
GMainLoop *ml;
gchar *path;
gchar *tmp;
xmmsc_connection_t *conn;
xmmsc_result_t *res;
xmonitor_t *mon;
gint fd;
conn = xmmsc_init ("xmms-medialib-updater");
path = getenv ("XMMS_PATH");
if (!xmmsc_connect (conn, path)) {
ERR ("Could not connect to xmms2d %s", xmmsc_get_last_error (conn));
return EXIT_FAILURE;
}
ml = g_main_loop_new (NULL, FALSE);
xmmsc_mainloop_gmain_init (conn);
xmmsc_disconnect_callback_set (conn, quit, ml);
mon = g_new0 (xmonitor_t, 1);
fd = monitor_init (mon);
mon->conn = conn;
if (fd == -1) {
ERR ("Couldn't initalize monitor");
return EXIT_FAILURE;
}
tmp = getenv("XMMS_DEBUG");
if (!tmp) {
g_log_set_handler (NULL, G_LOG_LEVEL_MESSAGE | G_LOG_FLAG_RECURSION,
message_handler, NULL);
}
gio = g_io_channel_unix_new (fd);
g_io_add_watch (gio, G_IO_IN, s_callback, mon);
res = xmmsc_configval_register (conn, "mlibupdater.watch_dirs", "");
xmmsc_result_notifier_set (res, handle_configval, mon);
xmmsc_result_unref (res);
res = xmmsc_broadcast_configval_changed (conn);
xmmsc_result_notifier_set (res, handle_config_changed, mon);
xmmsc_result_unref (res);
g_main_loop_run (ml);
return EXIT_SUCCESS;
}
Client::Client( const std::string& name )
: bindata( conn_, connected_, mainloop_ ),
playback( conn_, connected_, mainloop_ ),
playlist( conn_, connected_, mainloop_ ),
medialib( conn_, connected_, mainloop_ ),
config( conn_, connected_, mainloop_ ),
stats( conn_, connected_, mainloop_ ),
xform( conn_, connected_, mainloop_ ),
collection( conn_, connected_, mainloop_ ),
name_( name ), conn_(0), connected_( false ),
mainloop_( 0 ), listener_( 0 ), quitSignal_( 0 ), dc_( 0 )
{
conn_ = xmmsc_init( name.c_str() );
}
static gboolean
ol_player_xmms2_init ()
{
ol_log_func ();
ol_debug ("init XMMS2");
if (connection == NULL)
{
connection = xmmsc_init ("osd-lyrics");
if (!connection)
{
ol_error ("Initialize XMMS2 connection failed.");
return FALSE;
}
}
ol_debug ("Now connect");
return ol_player_xmms2_connect ();
}
/*
* call-seq:
* Xmms::Client.new(name) -> xc
*
* Creates an Xmms::Client object.
*/
static VALUE
c_init (VALUE self, VALUE name)
{
RbXmmsClient *xmms = NULL;
Data_Get_Struct (self, RbXmmsClient, xmms);
if (!(xmms->real = xmmsc_init (StringValuePtr (name)))) {
rb_raise (rb_eNoMemError, "failed to allocate memory");
return Qnil;
}
xmms->deleted = false;
xmms->result_callbacks = rb_ary_new ();
xmms->disconnect_cb = Qnil;
xmms->io_need_out_cb = Qnil;
return self;
}
void Client::connect( const char* ipcpath )
{
if( !connected_ ) {
if( !conn_ ) {
conn_ = xmmsc_init( name_.c_str() );
}
if( !xmmsc_connect( conn_, ipcpath ) ) {
throw connection_error( xmmsc_get_last_error( conn_ ) );
}
connected_ = true;
}
if( mainloop_ && !listener_ && typeid(mainloop_) == typeid(MainLoop) ) {
listener_ = new Listener( conn_ );
dynamic_cast<MainLoop*>(mainloop_)->addListener( listener_ );
}
}
int
main (int argc, char **argv)
{
xmmsc_result_t *res;
xmmsv_t *configval;
xmmsv_t *val;
const char *errmsg;
gchar *path = getenv ("XMMS_PATH");
connection = xmmsc_init ("xmms2-vistest");
if (!connection || !xmmsc_connect (connection, path)){
printf ("Couldn't connect to xmms2d: %s\n",
xmmsc_get_last_error (connection));
exit (EXIT_FAILURE);
}
res = xmmsc_visualization_version (connection);
xmmsc_result_wait (res);
val = xmmsc_result_get_value (res);
if (xmmsv_get_error (val, &errmsg)) {
puts (errmsg);
exit (EXIT_FAILURE);
} else {
int32_t version;
xmmsv_get_int (val, &version);
/* insert the version you need here or instead of complaining,
reduce your feature set to fit the version */
if (version < 1) {
printf ("The server only supports formats up to version %d (needed is %d)!", version, 1);
exit (EXIT_FAILURE);
}
}
xmmsc_result_unref (res);
res = xmmsc_visualization_init (connection);
xmmsc_result_wait (res);
val = xmmsc_result_get_value (res);
if (xmmsv_get_error (val, &errmsg)) {
puts (errmsg);
exit (EXIT_FAILURE);
}
vis = xmmsc_visualization_init_handle (res);
configval = xmmsv_build_dict (XMMSV_DICT_ENTRY_STR ("type", "peak"),
XMMSV_DICT_ENTRY_STR ("stereo", "1"),
XMMSV_DICT_END);
res = xmmsc_visualization_properties_set (connection, vis, configval);
xmmsc_result_wait (res);
val = xmmsc_result_get_value (res);
if (xmmsv_get_error (val, &errmsg)) {
puts (errmsg);
exit (EXIT_FAILURE);
}
xmmsc_result_unref (res);
xmmsv_unref (configval);
while (!xmmsc_visualization_started (connection, vis)) {
res = xmmsc_visualization_start (connection, vis);
if (xmmsc_visualization_errored (connection, vis)) {
printf ("Couldn't start visualization transfer: %s\n",
xmmsc_get_last_error (connection));
exit (EXIT_FAILURE);
}
if (res) {
xmmsc_result_wait (res);
xmmsc_visualization_start_handle (connection, res);
xmmsc_result_unref (res);
}
}
/* using GTK mainloop */
mainloop = g_main_loop_new (NULL, FALSE);
xmmsc_mainloop_gmain_init (connection);
g_timeout_add_full (G_PRIORITY_DEFAULT, 20, draw_gtk, NULL, shutdown_gtk);
g_main_loop_run (mainloop);
/* not using GTK mainloop */
while (xmmsc_visualization_chunk_get (connection, vis, data, 0, 1000) != -1) {
draw ();
}
putchar ('\n');
xmmsc_visualization_shutdown (connection, vis);
if (connection) {
xmmsc_unref (connection);
}
return 0;
}
int
main (int argc, char **argv)
{
xmmsc_connection_t *conn;
GMainLoop *ml;
gchar *path;
printf ("Starting XMMS2 phone home agent...\n");
path = getenv ("XMMS_PATH");
conn = xmmsc_init ("xmms2-et");
if (!conn) {
printf ("Could not init xmmsc_connection!\n");
exit (1);
}
if (!xmmsc_connect (conn, path)) {
printf ("Could not connect to xmms2d: %s\n", xmmsc_get_last_error (conn));
exit (1);
}
output_plugin = g_strdup ("unknown");
get_systemname ();
send_socket = socket (PF_INET, SOCK_DGRAM, 0);
ml = g_main_loop_new (NULL, FALSE);
memset (&dest_addr, 0, sizeof (dest_addr));
dest_addr.sin_family = AF_INET;
dest_addr.sin_port = htons (DEST_PORT);
inet_aton (DEST_IP, &dest_addr.sin_addr);
start_time = time (NULL);
XMMS_CALLBACK_SET (conn, xmmsc_broadcast_playback_current_id, handle_current_id, conn);
XMMS_CALLBACK_SET (conn, xmmsc_main_stats, handle_stats, NULL);
XMMS_CALLBACK_SET (conn, xmmsc_broadcast_config_value_changed, handle_config, NULL);
XMMS_CALLBACK_SET (conn, xmmsc_broadcast_quit, handle_quit, ml);
XMMS_CALLBACK_SET (conn, xmmsc_signal_mediainfo_reader_unindexed, handle_mediainfo_reader, NULL);
{
xmmsc_result_t *res;
res = xmmsc_config_get_value (conn, "output.plugin");
xmmsc_result_notifier_set (res, handle_config_val, NULL);
xmmsc_result_unref (res);
}
xmmsc_disconnect_callback_set (conn, disconnected, NULL);
xmmsc_mainloop_gmain_init (conn);
g_main_loop_run (ml);
xmmsc_unref (conn);
printf ("XMMS2-ET shutting down...\n");
send_msg ("Clean shutdown", NULL);
return 0;
}
int
main (int argc, char **argv)
{
/*
* To connect to xmms2d you need to first have a
* connection.
*/
xmmsc_connection_t *connection;
/*
* xmmsc_result_t is the struct returned from all
* commands that are given to the xmms2d server
* we just declare a variable of this type here,
* we'll need it later.
*/
xmmsc_result_t *result;
/*
* xmmsv_t is the wrapper struct used to communicate
* values to/from the server. Typically, when a client
* issues commands, the server answers by sending back
* the return value for the command. Here, we will only
* use it to check if the server returned an error.
*/
xmmsv_t *return_value;
/*
* We need a string pointer to retrieve the error (if any)
* from the xmmsv_t. Note that the string will still be
* owned by the xmmsv_t structure.
*/
const char *err_buf;
/*
* First we need to initialize the connection;
* as argument you need to pass "name" of your
* client. The name has to be in the range [a-zA-Z0-9]
* because xmms is deriving configuration values
* from this name.
*/
connection = xmmsc_init ("tutorial1");
/*
* xmmsc_init will return NULL if memory is
* not available
*/
if (!connection) {
fprintf (stderr, "OOM!\n");
exit (EXIT_FAILURE);
}
/*
* Now we need to connect to xmms2d. We need to
* pass the XMMS ipc-path to the connect call.
* If passed NULL, it will default to
* unix:///tmp/xmms-ipc-<user>, but all xmms2 clients
* should handle the XMMS_PATH enviroment in
* order to configure connection path.
*
* xmmsc_connect will return NULL if an error occured
* and it will set the xmmsc_get_last_error() to a
* string describing the error
*/
if (!xmmsc_connect (connection, getenv ("XMMS_PATH"))) {
fprintf (stderr, "Connection failed: %s\n",
xmmsc_get_last_error (connection));
exit (EXIT_FAILURE);
}
/*
* This is all you have to do to connect to xmms2d.
* Now we can send commands. Let's do something easy
* like getting xmms2d to start playback.
*/
result = xmmsc_playback_start (connection);
/*
* The command will be sent, and since this is a
* synchronous connection we can block for its
* return here. The async / sync issue will be
* commented on later.
*/
xmmsc_result_wait (result);
/*
* When xmmsc_result_wait() returns, we have the
* answer from the server. We now extract that value
* from the result. Note that the value is still owned
* by the result, and will be freed along with it.
*/
return_value = xmmsc_result_get_value (result);
/*
* Let's check if the value returned by the server
* is an error, and print it out if it is.
*/
if (xmmsv_is_error (return_value) &&
xmmsv_get_error (return_value, &err_buf)) {
fprintf (stderr, "playback start returned error, %s",
err_buf);
}
/*
* This is very important - when we are done with the
* result we need to tell that to the clientlib,
* we do that by unrefing it. this will free resources,
* including the return_value, and make sure that we don't
* leak memory. It is not possible to touch the result or
* the return_value after we have done this.
*/
xmmsc_result_unref (result);
/*
* Now we are done, let's disconnect and free up all
* used resources.
*/
xmmsc_unref (connection);
return (EXIT_SUCCESS);
}
int show_xmmsinfo_c(lua_State *L)
{
xmmsc_connection_t *connection;
xmmsc_result_t *state;
xmmsv_t *state_value;
const char *err_buf;
int32_t status;
// string containing the current xmms2 state
char *state_str;
// initialize the Info struct
struct Info i;
// initialize the connection
connection = xmmsc_init("xmmsinfo");
if (!connection) {
fprintf(stderr, "No connection!\n");
return(EXIT_FAILURE);
}
// try to connect
if (!xmmsc_connect(connection, getenv("XMMS_PATH"))) {
fprintf(stderr, "Connection failed, %s\n",
xmmsc_get_last_error(connection));
return(EXIT_FAILURE);
}
// get current xmms2 status
state = xmmsc_playback_status(connection);
xmmsc_result_wait(state);
state_value = xmmsc_result_get_value(state);
if(xmmsv_get_error(state_value, &err_buf)) {
fprintf(stderr, "Error while asking for the connection status, %s\n",
err_buf);
}
if(!xmmsv_get_int(state_value, &status)) {
fprintf(stderr, "Couldn't get connection status, %d\n", status);
}
// 0 == stopped; 1 == playing; 2 == paused
if(status == XMMS_PLAYBACK_STATUS_PLAY) {
state_str = "playing";
} else if (status == XMMS_PLAYBACK_STATUS_PAUSE) {
state_str = "paused";
} else {
state_str = "stopped";
}
i.state = state_str;
// get current position in the playlist
xmmsc_result_t *current_id;
xmmsv_t *current_id_value;
int32_t cur_id;
current_id = xmmsc_playback_current_id(connection);
xmmsc_result_wait(current_id);
current_id_value = xmmsc_result_get_value(current_id);
xmmsv_get_int(current_id_value, &cur_id);
// initialize variables for the song info
xmmsc_result_t *result;
xmmsv_t *return_value;
xmmsv_t *dict_entry;
xmmsv_t *infos;
const char *val;
result = xmmsc_medialib_get_info(connection, cur_id);
xmmsc_result_wait(result);
return_value = xmmsc_result_get_value(result);
if(xmmsv_get_error(return_value, &err_buf)) {
fprintf(stderr, "Medialib returns error, %s\n",
err_buf);
return(EXIT_FAILURE);
}
infos = xmmsv_propdict_to_dict(return_value, NULL);
if(!xmmsv_dict_get(infos, "artist", &dict_entry) ||
!xmmsv_get_string(dict_entry, &val)) {
val = "No Artist";
}
i.artist = val;
if(!xmmsv_dict_get(infos, "album", &dict_entry) ||
!xmmsv_get_string(dict_entry, &val)) {
val = "No Album";
}
i.album = val;
if(!xmmsv_dict_get(infos, "title", &dict_entry) ||
!xmmsv_get_string(dict_entry, &val)) {
val = "No Title";
}
i.song = val;
i.id = cur_id;
if(!xmmsv_dict_get(infos, "url", &dict_entry) ||
!xmmsv_get_string(dict_entry, &val)) {
val = NULL;
}
i.uri = val;
// push everything to lua
lua_pushstring(L, i.state);
lua_pushstring(L, i.artist);
lua_pushstring(L, i.album);
lua_pushstring(L, i.song);
lua_pushinteger(L, i.id);
lua_pushstring(L, i.uri);
// clean up
xmmsv_unref(infos);
xmmsc_result_unref(result);
xmmsc_result_unref(state);
xmmsc_result_unref(current_id);
xmmsc_unref(connection);
return 6;
}
gboolean
cli_infos_connect (cli_infos_t *infos, gboolean autostart)
{
gchar *path;
xmmsc_result_t *res;
/* Open Async connection first */
infos->conn = xmmsc_init (CLI_CLIENTNAME);
if (!infos->conn) {
g_printf (_("Could not init connection!\n"));
return FALSE;
}
path = getenv ("XMMS_PATH");
if (!xmmsc_connect (infos->conn, path)) {
if (!autostart) {
/* Failed to connect, but don't autostart */
xmmsc_unref (infos->conn);
infos->conn = NULL;
return FALSE;
} else if (!cli_infos_autostart (infos, path)) {
/* Autostart failed, abort now */
if (path) {
g_printf (_("Could not connect to server at '%s'!\n"), path);
} else {
g_printf (_("Could not connect to server at default path!\n"));
}
xmmsc_unref (infos->conn);
infos->conn = NULL;
return FALSE;
}
}
/* Sync connection */
infos->sync = xmmsc_init (CLI_CLIENTNAME "-sync");
if (!infos->sync) {
g_printf (_("Could not init sync connection!\n"));
return FALSE;
}
if (!xmmsc_connect (infos->sync, path)) {
if (path) {
g_printf (_("Could not connect to server at '%s'!\n"), path);
} else {
g_printf (_("Could not connect to server at default path!\n"));
}
xmmsc_unref (infos->conn);
xmmsc_unref (infos->sync);
infos->conn = NULL;
infos->sync = NULL;
return FALSE;
}
/* Reset the connection state on server quit */
res = xmmsc_broadcast_quit (infos->conn);
xmmsc_result_notifier_set (res, &cli_infos_disconnect_callback, infos);
xmmsc_result_unref (res);
cli_cache_start (infos);
return TRUE;
}
int
main (int argc, char **argv)
{
/* The mainloop we should use later */
GMainLoop *ml;
/*
* The first part of this program is
* commented on in tut1.c
*/
xmmsc_connection_t *connection;
xmmsc_result_t *result;
/*
* In an async client we still connect as
* normal. Read up on this in earlier
* tutorials if you need.
*/
connection = xmmsc_init ("tutorial6");
if (!connection) {
fprintf (stderr, "OOM!\n");
exit (EXIT_FAILURE);
}
if (!xmmsc_connect (connection, getenv ("XMMS_PATH"))) {
fprintf (stderr, "Connection failed: %s\n",
xmmsc_get_last_error (connection));
exit (EXIT_FAILURE);
}
/*
* Initialize the mainloop, for more information about GLib mainloop
* see the GTK docs.
*/
ml = g_main_loop_new (NULL, FALSE);
/*
* We issue two async commands to restart playback.
* Since we don't want to set a notifier for those,
* we can free the result immediately.
*/
xmmsc_result_unref (xmmsc_playback_stop (connection));
xmmsc_result_unref (xmmsc_playback_start (connection));
printf ("Playtime: \n");
result = xmmsc_signal_playback_playtime (connection);
xmmsc_result_notifier_set (result, my_playtime, ml);
xmmsc_result_unref (result);
/*
* As you see we do it pretty much the same way that we did in tut2, but
* instead of being able to access the current id directly (as we would
* have if we where blocking) we need to wait until xmms calls our
* my_current_id function. This will keep your GUI from hanging while
* waiting for xmms2 to answer your command.
*
* In order to make xmmsclient call your callback functions we need to put
* the fd of the connection into the mainloop of our program. For your
* convenience the xmmsclient lib ships with automatic integration with
* GMainLoop. We just need to link with xmmsclient-glib and do the following
* call to make it work.
*/
xmmsc_mainloop_gmain_init (connection);
/*
* We are now all set to go. Just run the main loop and watch the magic.
*/
g_main_loop_run (ml);
return EXIT_SUCCESS;
}
int
main (int argc, char **argv)
{
/*
* The first part of this program is
* commented on in tut1.c and tut2.c
*/
xmmsc_connection_t *connection;
xmmsc_result_t *result;
xmmsv_t *return_value;
const char *err_buf;
/*
* Variables that we'll need later
*/
const char *val;
int intval;
int id;
xmmsv_t *dict_entry;
xmmsv_t *infos;
connection = xmmsc_init ("tutorial3");
if (!connection) {
fprintf (stderr, "OOM!\n");
exit (EXIT_FAILURE);
}
if (!xmmsc_connect (connection, getenv ("XMMS_PATH"))) {
fprintf (stderr, "Connection failed: %s\n",
xmmsc_get_last_error (connection));
exit (EXIT_FAILURE);
}
/*
* Ok, let' do the same thing as we did in
* tut2.c and retrieve the current playing
* entry. We need that to get information
* about the song.
*/
result = xmmsc_playback_current_id (connection);
xmmsc_result_wait (result);
return_value = xmmsc_result_get_value (result);
if (xmmsv_is_error (return_value) &&
xmmsv_get_error (return_value, &err_buf)) {
fprintf (stderr, "playback current id returns error, %s\n",
err_buf);
}
if (!xmmsv_get_int (return_value, &id)) {
fprintf (stderr, "xmmsc_playback_current_id didn't "
"return int as expected\n");
/* Fake id (ids are >= 1) used as an error flag. */
id = 0;
}
/* Print the value */
printf ("Currently playing id is %d\n", id);
/*
* Same drill as before. Release memory
* so that we can reuse it in the next
* clientlib call.
* */
xmmsc_result_unref (result);
/*
* Something about the medialib and xmms2. All
* entries that are played, put into playlists
* have to be in the medialib. A song's metadata
* will be added to the medialib the first time
* you do "xmms2 add" or equivalent.
*
* When we request information for an entry, it will
* be requested from the medialib, not the playlist
* or the playback. The playlist and playback only
* know the unique id of the entry. All other
* information must be retrieved in subsequent calls.
*
* Entry 0 is non valid. Only 1-inf is valid.
* So let's check for 0 and don't ask medialib for it.
*/
if (id == 0) {
fprintf (stderr, "Nothing is playing.\n");
exit (EXIT_FAILURE);
}
/*
* And now for something about return types from
* clientlib. The clientlib will always return
* an xmmsc_result_t that will eventually contain the
* return value as a xmmsv_t struct.
* The value can contain an int and string as
* base type. It can also contain more complex
* types like lists and dicts.
* A list is a sequence of values, each of them
* wrapped in its own xmmsv_t struct (of any type).
* A dict is a key<->value representation where key
* is always a string but the value is again wrapped
* in its own xmmsv_t struct (of any type).
*
* When retrieving an entry from the medialib, you
* get a dict as return. Let's print out some
* entries from it and then traverse the dict.
*/
result = xmmsc_medialib_get_info (connection, id);
/* And waaait for it .. */
xmmsc_result_wait (result);
/* Let's reuse the previous return_value pointer, it
* was invalidated as soon as we freed the result that
* contained it anyway.
*/
return_value = xmmsc_result_get_value (result);
if (xmmsv_is_error (return_value) &&
xmmsv_get_error (return_value, &err_buf)) {
/*
* This can return error if the id
* is not in the medialib
*/
fprintf (stderr, "medialib get info returns error, %s\n",
err_buf);
exit (EXIT_FAILURE);
}
/*
* Because of the nature of the dict returned by
* xmmsc_medialib_get_info, we need to convert it to
* a simpler dict using xmmsv_propdict_to_dict.
* Let's not worry about that for now and accept it
* as a fact of life.
*
* See tut5 for a discussion about dicts and propdicts.
*
* Note that xmmsv_propdict_to_dict creates a new
* xmmsv_t struct, which we will need to free manually
* when we're done with it.
*/
infos = xmmsv_propdict_to_dict (return_value, NULL);
/*
* We must first retrieve the xmmsv_t struct
* corresponding to the "artist" key in the dict,
* and then extract the string from that struct.
*/
if (!xmmsv_dict_get (infos, "artist", &dict_entry) ||
!xmmsv_get_string (dict_entry, &val)) {
/*
* if we end up here it means that the key "artist" wasn't
* in the dict or that the value for "artist" wasn't a
* string.
*
* You can check the type of the entry (if there is one) with
* xmmsv_get_type (dict_entry). It will return an
* xmmsv_type_t enum describing the type.
*
* Actually this is no disaster, it might just mean that
* we don't have an artist tag on this entry. Let's
* call it "No Artist" for now.
*/
val = "No Artist";
}
/* print the value */
printf ("artist = %s\n", val);
if (!xmmsv_dict_get (infos, "title", &dict_entry) ||
!xmmsv_get_string (dict_entry, &val)) {
val = "No Title";
}
printf ("title = %s\n", val);
/*
* Let's extract an integer as well
*/
if (!xmmsv_dict_get (infos, "bitrate", &dict_entry) ||
!xmmsv_get_int (dict_entry, &intval)) {
intval = 0;
}
printf ("bitrate = %i\n", intval);
/*
* We need to free infos manually here, else we will leak.
*/
xmmsv_unref (infos);
/*
* !!Important!!
*
* When unreffing the result here we will free
* the memory that we have extracted from the dict,
* and that includes all the string pointers of the
* dict entries! So if you want to keep strings
* somewhere you need to copy that memory! Very
* important otherwise you will get undefined behaviour.
*/
xmmsc_result_unref (result);
xmmsc_unref (connection);
return (EXIT_SUCCESS);
}
gboolean
cli_context_connect (cli_context_t *ctx, gboolean autostart)
{
gchar *path;
xmmsc_result_t *res;
/* Open Async connection first */
ctx->conn = xmmsc_init (CLI_CLIENTNAME);
if (!ctx->conn) {
g_printf (_("Could not init connection!\n"));
return FALSE;
}
path = configuration_get_string (ctx->config, "ipcpath");
if (!xmmsc_connect (ctx->conn, path)) {
if (!autostart) {
/* Failed to connect, but don't autostart */
xmmsc_unref (ctx->conn);
ctx->conn = NULL;
return FALSE;
} else if (!cli_context_autostart (ctx, path)) {
/* Autostart failed, abort now */
if (path) {
g_printf (_("Could not connect to server at '%s'!\n"), path);
} else {
g_printf (_("Could not connect to server at default path!\n"));
}
xmmsc_unref (ctx->conn);
ctx->conn = NULL;
return FALSE;
}
}
/* Sync connection */
ctx->sync = xmmsc_init (CLI_CLIENTNAME "-sync");
if (!ctx->sync) {
g_printf (_("Could not init sync connection!\n"));
return FALSE;
}
if (!xmmsc_connect (ctx->sync, path)) {
if (path) {
g_printf (_("Could not connect to server at '%s'!\n"), path);
} else {
g_printf (_("Could not connect to server at default path!\n"));
}
xmmsc_unref (ctx->conn);
xmmsc_unref (ctx->sync);
ctx->conn = NULL;
ctx->sync = NULL;
return FALSE;
}
/* Reset the connection state on server quit */
res = xmmsc_broadcast_quit (ctx->conn);
xmmsc_disconnect_callback_set (ctx->conn, disconnect_callback, ctx);
xmmsc_result_notifier_set (res, &cli_context_disconnect_callback, ctx);
xmmsc_result_unref (res);
cli_cache_start (ctx->cache, ctx->conn);
return TRUE;
}
int
main (int argc, char **argv)
{
xmmsc_connection_t *conn;
gchar *path;
gchar *gp = NULL;
gchar **s;
gchar **ipcsplit;
guint port;
int i;
printf ("Starting XMMS2 mDNS Agent...\n");
path = getenv ("XMMS_PATH_FULL");
if (!path) {
printf ("Sorry you need XMMS_PATH_FULL set\n");
exit (1);
}
ipcsplit = g_strsplit (path, ";", 0);
for (i = 0; ipcsplit[i]; i++) {
if (g_ascii_strncasecmp (ipcsplit[i], "tcp://", 6) == 0) {
gp = ipcsplit[i];
}
}
if (!gp) {
printf ("Need to have a socket listening to TCP before we can do that!");
exit (1);
}
s = g_strsplit (gp, ":", 0);
if (s && s[2]) {
port = strtol (s[2], NULL, 10);
} else {
port = XMMS_DEFAULT_TCP_PORT;
}
conn = xmmsc_init ("xmms2-mdns");
if (!conn) {
printf ("Could not init xmmsc_connection!\n");
exit (1);
}
if (!xmmsc_connect (conn, gp)) {
printf ("Could not connect to xmms2d: %s\n", xmmsc_get_last_error (conn));
exit (1);
}
ml = g_main_loop_new (NULL, FALSE);
XMMS_CALLBACK_SET (conn, xmmsc_broadcast_quit, handle_quit, ml);
xmmsc_disconnect_callback_set (conn, disconnected, NULL);
register_service (port);
xmmsc_mainloop_gmain_init (conn);
g_main_loop_run (ml);
DNSServiceRefDeallocate (g_sdref);
xmmsc_unref (conn);
printf ("XMMS2-mDNS shutting down...\n");
return 0;
}
int
main (int argc, char **argv)
{
/* The mainloop we should use later */
GMainLoop *ml;
/*
* The first part of this program is
* commented on in tut1.c
*/
xmmsc_connection_t *connection;
xmmsc_result_t *result;
/*
* In an async client we still connect as
* normal. Read up on this in earlier
* tutorials if you need.
*/
connection = xmmsc_init ("tutorial6");
if (!connection) {
fprintf (stderr, "OOM!\n");
exit (EXIT_FAILURE);
}
if (!xmmsc_connect (connection, getenv ("XMMS_PATH"))) {
fprintf (stderr, "Connection failed: %s\n",
xmmsc_get_last_error (connection));
exit (EXIT_FAILURE);
}
/*
* Initialize the mainloop, for more information about GLib mainloop
* see the GTK docs.
*/
ml = g_main_loop_new (NULL, FALSE);
/*
* The big difference between a sync client and an async client is that the
* async client works with callbacks. When you send a command and get an
* xmmsc_result_t back you should set up a callback for it and directly
* unref it. This means we can't do syncronous operations on this connection.
*
* In simple cases you can use the XMMS_CALLBACK_SET macro, but in order to
* be verbose here I do it all manually. Let's ask for the current id
* in an async way instead of the sync way as we did in tut2.
*/
result = xmmsc_playback_current_id (connection);
xmmsc_result_notifier_set (result, my_current_id, ml);
xmmsc_result_unref (result);
/*
* As you see we do it pretty much the same way that we did in tut2, but
* instead of being able to access the current id directly (as we would
* have if we where blocking) we need to wait until xmms calls our
* my_current_id function. This will keep your GUI from hanging while
* waiting for xmms2 to answer your command.
*
* In order to make xmmsclient call your callback functions we need to put
* the fd of the connection into the mainloop of our program. For your
* convenience the xmmsclient lib ships with automatic integration with
* GMainLoop. We just need to link with xmmsclient-glib and do the following
* call to make it work.
*/
xmmsc_mainloop_gmain_init (connection);
/*
* We are now all set to go. Just run the main loop and watch the magic.
*/
g_main_loop_run (ml);
return EXIT_SUCCESS;
}
