int mpd_database_delete_playlist(MpdObj *mi,char *path)
{
if(path == NULL)
{
debug_printf(DEBUG_WARNING, "path == NULL");
return MPD_ARGS_ERROR;
}
if(!mpd_check_connected(mi))
{
debug_printf(DEBUG_WARNING,"not connected\n");
return MPD_NOT_CONNECTED;
}
if(mpd_lock_conn(mi))
{
debug_printf(DEBUG_ERROR,"lock failed\n");
return MPD_LOCK_FAILED;
}
mpd_sendRmCommand(mi->connection,path);
mpd_finishCommand(mi->connection);
/* unlock */
mpd_unlock_conn(mi);
return MPD_OK;
}
int mpd_database_save_playlist(MpdObj *mi, char *name)
{
if(name == NULL || !strlen(name))
{
debug_printf(DEBUG_WARNING, "mpd_playlist_save: name != NULL and strlen(name) > 0 failed");
return MPD_ARGS_ERROR;
}
if(!mpd_check_connected(mi))
{
debug_printf(DEBUG_WARNING,"mpd_playlist_save: not connected\n");
return MPD_NOT_CONNECTED;
}
if(mpd_lock_conn(mi))
{
debug_printf(DEBUG_ERROR,"mpd_playlist_save: lock failed\n");
return MPD_LOCK_FAILED;
}
mpd_sendSaveCommand(mi->connection,name);
mpd_finishCommand(mi->connection);
if(mi->connection->error == MPD_ERROR_ACK && mi->connection->errorCode == MPD_ACK_ERROR_EXIST)
{
mpd_clearError(mi->connection);
mpd_unlock_conn(mi);
return MPD_DATABASE_PLAYLIST_EXIST;
}
/* unlock */
mpd_unlock_conn(mi);
return MPD_OK;
}
int mpd_playlist_queue_commit(MpdObj *mi)
{
if(mi->queue == NULL)
{
debug_printf(DEBUG_WARNING,"mi->queue is empty");
return MPD_PLAYLIST_QUEUE_EMPTY;
}
if(!mpd_check_connected(mi))
{
debug_printf(DEBUG_WARNING,"not connected\n");
return MPD_NOT_CONNECTED;
}
if(mpd_lock_conn(mi))
{
debug_printf(DEBUG_WARNING,"lock failed\n");
return MPD_LOCK_FAILED;
}
mpd_sendCommandListBegin(mi->connection);
/* get first item */
mi->queue = mi->queue->first;
while(mi->queue != NULL)
{
if(mi->queue->type == MPD_QUEUE_ADD)
{
if(mi->queue->path != NULL)
{
mpd_sendAddCommand(mi->connection, mi->queue->path);
}
}
else if(mi->queue->type == MPD_QUEUE_LOAD)
{
if(mi->queue->path != NULL)
{
mpd_sendLoadCommand(mi->connection, mi->queue->path);
}
}
else if (mi->queue->type == MPD_QUEUE_DELETE_ID)
{
if(mi->queue->id >= 0)
{
mpd_sendDeleteIdCommand(mi->connection, mi->queue->id);
}
}
else if (mi->queue->type == MPD_QUEUE_DELETE_POS)
{
if(mi->queue->id >= 0)
{
mpd_sendDeleteCommand(mi->connection, mi->queue->id);
}
}
mpd_queue_get_next(mi);
}
mpd_sendCommandListEnd(mi->connection);
mpd_finishCommand(mi->connection);
mpd_unlock_conn(mi);
mpd_status_update(mi);
return MPD_OK;
}
static void seek_command(gpointer user_data, const char *param)
{
int i = 0, j = 0;
gchar **fields;
if (!param)
return;
if (!mpd_check_connected(connection))
return;
printf("seek: '%s'\n", param);
fields = g_strsplit(param, ":", -1);
/* Calculate time */
for (j = 0; fields && fields[j]; j++)
{
i = atoi(fields[j]) + i * 60;
}
if (param[0] == '+' || param[0] == '-')
{
/* seek relative */
mpd_player_seek(connection, mpd_status_get_elapsed_song_time(connection) + i);
} else
{
/* seek absolute */
mpd_player_seek(connection, i);
}
g_strfreev(fields);
}
int mpd_playlist_load(MpdObj *mi, const char *path)
{
int retv = MPD_OK;
if(!mpd_check_connected(mi))
{
debug_printf(DEBUG_WARNING,"mpd_playlist_load: not connected\n");
return MPD_NOT_CONNECTED;
}
if(mpd_lock_conn(mi))
{
debug_printf(DEBUG_ERROR,"lock failed\n");
return MPD_LOCK_FAILED;
}
mpd_sendLoadCommand(mi->connection,path);
mpd_finishCommand(mi->connection);
if(mi->connection->errorCode == MPD_ACK_ERROR_NO_EXIST)
{
debug_printf(DEBUG_WARNING, "mpd_playlist_load: failed to load playlist\n");
mpd_clearError(mi->connection);
retv = MPD_PLAYLIST_LOAD_FAILED;
}
if(mpd_unlock_conn(mi))
{
debug_printf(DEBUG_ERROR, "Failed to unlock connection");
return MPD_LOCK_FAILED;
}
return retv;
}
int mpd_database_update_dir(MpdObj *mi, char *path)
{
/* if(path == NULL || !strlen(path))
{
debug_printf(DEBUG_ERROR, "path != NULL and strlen(path) > 0 failed");
return MPD_ARGS_ERROR;
}
*/
if(!mpd_check_connected(mi))
{
debug_printf(DEBUG_WARNING,"not connected\n");
return MPD_NOT_CONNECTED;
}
if(mpd_lock_conn(mi))
{
debug_printf(DEBUG_ERROR,"lock failed\n");
return MPD_LOCK_FAILED;
}
mpd_sendUpdateCommand(mi->connection,path);
mpd_finishCommand(mi->connection);
/* I have no idea why do this ?? it even makes gmpc very very unhappy.
* Because it doesnt trigger an signal anymore when updating starts
* mi->CurrentState.updatingDb = mpd_getUpdateId(mi->connection);
*/
/* unlock */
mpd_unlock_conn(mi);
/* What I think you should do is to force a direct status updated
*/
mpd_status_update(mi);
return MPD_OK;
}
MpdDBStats * mpd_database_search_stats_commit(MpdObj *mi)
{
MpdDBStats *data = NULL;
if(!mpd_check_connected(mi))
{
debug_printf(DEBUG_WARNING,"not connected\n");
return NULL;
}
if(mi->search_type != MPD_SEARCH_TYPE_STATS)
{
debug_printf(DEBUG_ERROR, "no/wrong search in progress to commit");
return NULL;
}
if(mpd_lock_conn(mi))
{
debug_printf(DEBUG_ERROR,"lock failed\n");
return NULL;
}
mpd_commitSearch(mi->connection);
data = (MpdDBStats *) mpd_getSearchStats(mi->connection);
/* unlock */
if(mpd_unlock_conn(mi))
{
debug_printf(DEBUG_ERROR, "Failed to unlock connection");
if(data)mpd_freeSearchStats((mpd_SearchStats *)data);
return NULL;
}
if(data == NULL)
{
return NULL;
}
return data;
}
int mpd_sticker_song_set(MpdObj *mi, const char *path, const char *tag, const char *value)
{
if(!mpd_check_connected(mi))
{
debug_printf(DEBUG_INFO,"not connected\n");
return MPD_NOT_CONNECTED;
}
if(mpd_server_check_command_allowed(mi, "sticker") != MPD_SERVER_COMMAND_ALLOWED) {
debug_printf(DEBUG_WARNING, "Command not allowed\n");
return MPD_SERVER_NOT_SUPPORTED;
}
if(mpd_lock_conn(mi))
{
debug_printf(DEBUG_ERROR,"lock failed\n");
return MPD_LOCK_FAILED;
}
mpd_sendSetSongSticker(mi->connection,path, tag,value);
mpd_finishCommand(mi->connection);
if(mpd_unlock_conn(mi))
{
debug_printf(DEBUG_ERROR, "Failed to unlock");
return MPD_LOCK_FAILED;
}
return MPD_OK;
}
int mpd_send_password(MpdObj *mi)
{
if(!mi) return MPD_ARGS_ERROR;
if(mi->password && mpd_check_connected(mi) && strlen(mi->password))
{
if(mpd_lock_conn(mi))
{
debug_printf(DEBUG_WARNING, "failed to lock connection");
return MPD_LOCK_FAILED;
}
mpd_sendPasswordCommand(mi->connection, mi->password);
mpd_finishCommand(mi->connection);
if(mpd_unlock_conn(mi))
{
debug_printf(DEBUG_ERROR, "Failed to unlock connection\n");
return MPD_LOCK_FAILED;
}
mpd_server_get_allowed_commands(mi);
/*TODO: should I do it here, or in the
* mpd_server_get_allowed_command, so it also get's executed on
* connect
*/
if((mi->the_status_changed_callback != NULL))
{
mi->the_status_changed_callback( mi,
MPD_CST_PERMISSION, mi->the_status_changed_signal_userdata );
}
}
return MPD_OK;
}
int mpd_playlist_queue_delete_pos(MpdObj *mi,int songpos)
{
if(!mpd_check_connected(mi))
{
debug_printf(DEBUG_WARNING,"mpd_playlist_add: not connected\n");
return MPD_NOT_CONNECTED;
}
if(mi->queue == NULL)
{
mi->queue = mpd_new_queue_struct();
mi->queue->first = mi->queue;
mi->queue->next = NULL;
mi->queue->prev = NULL;
}
else
{
mi->queue->next = mpd_new_queue_struct();
mi->queue->next->first = mi->queue->first;
mi->queue->next->prev = mi->queue;
mi->queue = mi->queue->next;
mi->queue->next = NULL;
}
mi->queue->type = MPD_QUEUE_DELETE_POS;
mi->queue->id = songpos;
mi->queue->path = NULL;
return MPD_OK;
}
mpd_Song * mpd_playlist_get_current_song(MpdObj *mi)
{
if(!mpd_check_connected(mi))
{
debug_printf(DEBUG_WARNING, "Not Connected\n");
return NULL;
}
if(mpd_status_check(mi) != MPD_OK)
{
debug_printf(DEBUG_ERROR, "Failed to check status\n");
return NULL;
}
if(mi->CurrentSong != NULL && mi->CurrentSong->id != mi->status->songid)
{
debug_printf(DEBUG_WARNING, "Current song not up2date, updating\n");
mpd_freeSong(mi->CurrentSong);
mi->CurrentSong = NULL;
}
/* only update song when playing/pasing */
if(mi->CurrentSong == NULL &&
(mpd_player_get_state(mi) != MPD_PLAYER_STOP && mpd_player_get_state(mi) != MPD_PLAYER_UNKNOWN))
{
/* TODO: this to use the geT_current_song_id function */
mi->CurrentSong = mpd_playlist_get_song(mi, mpd_player_get_current_song_id(mi));
if(mi->CurrentSong == NULL)
{
debug_printf(DEBUG_ERROR, "Failed to grab song\n");
return NULL;
}
}
return mi->CurrentSong;
}
/* callback if a row of the playlist is double-clicked */
static void pl_row_activated(GtkTreeView *tv, GtkTreePath *path, GtkTreeViewColumn *column, gpointer data) {
GtkTreeIter iter;
GtkTreeModel *model;
gint pl_id;
pl_id = -32;
model = gtk_tree_view_get_model(tv);
gtk_tree_model_get_iter(model, &iter, path);
gtk_tree_model_get(model, &iter, COLUMN_PL_ID, &pl_id, -1);
if(pl_id > -32) {
// if auto connect is set, try to reconnect
if(mpd_info.msi.connected) {
if(!mpd_check_connected(mpd_info.obj)) {
if(mpd_connect(mpd_info.obj) != MPD_OK) {
msi_clear(&mpd_info);
mpd_info.msi.connected = FALSE;
return;
}
msi_fill(&mpd_info);
mpd_info.msi.connected = TRUE;
}
mpd_player_play_id(mpd_info.obj, pl_id);
}
}
fprintf(log_file, "[%s:%3i] %s(): pl_id = %i\n", __FILE__, __LINE__, __FUNCTION__, pl_id);
fflush(log_file);
return;
}
MpdData * mpd_database_get_artists(MpdObj *mi)
{
char *string = NULL;
MpdData *data = NULL;
if(!mpd_check_connected(mi))
{
debug_printf(DEBUG_WARNING,"not connected\n");
return NULL;
}
if(mpd_lock_conn(mi))
{
debug_printf(DEBUG_ERROR,"lock failed\n");
return NULL;
}
mpd_sendListCommand(mi->connection,MPD_TABLE_ARTIST,NULL);
while (( string = mpd_getNextArtist(mi->connection)) != NULL)
{
data = mpd_new_data_struct_append(data);
data->type = MPD_DATA_TYPE_TAG;
data->tag_type = MPD_TAG_ITEM_ARTIST;
data->tag = string;
}
mpd_finishCommand(mi->connection);
/* unlock */
mpd_unlock_conn(mi);
if(data == NULL)
{
return NULL;
}
data = mpd_misc_sort_tag_list(data);
return mpd_data_get_first(data);
}
MpdData * mpd_server_get_output_devices(MpdObj *mi)
{
mpd_OutputEntity *output = NULL;
MpdData *data = NULL;
if(!mpd_check_connected(mi))
{
debug_printf(DEBUG_WARNING,"not connected\n");
return NULL;
}
/* TODO: Check version */
if(mpd_lock_conn(mi))
{
debug_printf(DEBUG_ERROR,"lock failed\n");
return NULL;
}
mpd_sendOutputsCommand(mi->connection);
while (( output = mpd_getNextOutput(mi->connection)) != NULL)
{
data = mpd_new_data_struct_append(data);
data->type = MPD_DATA_TYPE_OUTPUT_DEV;
data->output_dev = output;
}
mpd_finishCommand(mi->connection);
/* unlock */
mpd_unlock_conn(mi);
if(data == NULL)
{
return NULL;
}
return mpd_data_get_first(data);
}
int mpd_server_set_output_device(MpdObj *mi,int device_id,int state)
{
if(!mpd_check_connected(mi))
{
debug_printf(DEBUG_WARNING,"not connected\n");
return MPD_NOT_CONNECTED;
}
if(mpd_lock_conn(mi))
{
debug_printf(DEBUG_ERROR,"lock failed\n");
return MPD_LOCK_FAILED;
}
if(state)
{
mpd_sendEnableOutputCommand(mi->connection, device_id);
}
else
{
mpd_sendDisableOutputCommand(mi->connection, device_id);
}
mpd_finishCommand(mi->connection);
mpd_unlock_conn(mi);
mpd_status_queue_update(mi);
return FALSE;
}
void mpd_playlist_search_start(MpdObj *mi, int exact)
{
/*
* Check argument
*/
if(mi == NULL || exact > 1 || exact < 0)
{
debug_printf(DEBUG_ERROR, "Argument error");
return ;
}
if(!mpd_check_connected(mi))
{
debug_printf(DEBUG_ERROR, "Not Connected\n");
return ;
}
if(!mpd_server_check_version(mi, 0,12,1))
{
debug_printf(DEBUG_ERROR, "Advanced search requires mpd 0.12.2 or higher");
return ;
}
/* lock, so we can work on mi->connection */
if(mpd_lock_conn(mi) != MPD_OK)
{
debug_printf(DEBUG_ERROR, "Failed to lock connection");
return ;
}
mpd_startPlaylistSearch(mi->connection, exact);
/* Set search type */
mi->search_type = (exact)? MPD_SEARCH_TYPE_PLAYLIST_FIND:MPD_SEARCH_TYPE_PLAYLIST_SEARCH;
/* unlock, let the error handler handle any possible error.
*/
mpd_unlock_conn(mi);
return;
}
int mpd_player_seek(MpdObj * mi, int sec)
{
int cur_song = mpd_player_get_current_song_pos(mi);
if (cur_song < 0) {
debug_printf(DEBUG_ERROR, "mpd_player_get_current_song_pos returned error\n");
return cur_song;
}
if (!mpd_check_connected(mi)) {
debug_printf(DEBUG_WARNING, "not connected\n");
return MPD_NOT_CONNECTED;
}
if (mpd_lock_conn(mi)) {
debug_printf(DEBUG_WARNING, "lock failed\n");
return MPD_LOCK_FAILED;
}
debug_printf(DEBUG_INFO, "seeking in song %i to %i sec\n", cur_song, sec);
mpd_sendSeekCommand(mi->connection, cur_song, sec);
mpd_finishCommand(mi->connection);
mpd_unlock_conn(mi);
if (mpd_status_update(mi)) {
return MPD_STATUS_FAILED;
}
return MPD_OK;
}
int mpd_playlist_queue_load(MpdObj *mi,const char *path)
{
if(!mpd_check_connected(mi))
{
debug_printf(DEBUG_WARNING,"not connected\n");
return MPD_NOT_CONNECTED;
}
if(path == NULL)
{
debug_printf(DEBUG_ERROR, "path != NULL Failed");
return MPD_ARGS_ERROR;
}
if(mi->queue == NULL)
{
mi->queue = mpd_new_queue_struct();
mi->queue->first = mi->queue;
mi->queue->next = NULL;
mi->queue->prev = NULL;
}
else
{
mi->queue->next = mpd_new_queue_struct();
mi->queue->next->first = mi->queue->first;
mi->queue->next->prev = mi->queue;
mi->queue = mi->queue->next;
mi->queue->next = NULL;
}
mi->queue->type = MPD_QUEUE_LOAD;
mi->queue->path = strdup(path);
return MPD_OK;
}
void mpd_database_search_stats_start(MpdObj *mi)
{
/*
* Check argument
*/
if(mi == NULL)
{
debug_printf(DEBUG_ERROR, "Argument error");
return ;
}
if(!mpd_check_connected(mi))
{
debug_printf(DEBUG_ERROR, "Not Connected\n");
return ;
}
if(!mpd_server_check_version(mi, 0,12,0))
{
debug_printf(DEBUG_ERROR, "Advanced search requires mpd 0.12.0 or higher");
return ;
}
/* lock, so we can work on mi->connection */
if(mpd_lock_conn(mi) != MPD_OK)
{
debug_printf(DEBUG_ERROR, "Failed to lock connection");
return ;
}
mpd_startStatsSearch(mi->connection);
/* Set search type */
mi->search_type = MPD_SEARCH_TYPE_STATS;
/* unlock, let the error handler handle any possible error.
*/
mpd_unlock_conn(mi);
return;
}
/**
* @param mi A #MpdObj
* @param field A #mpd_TagItems
*
* Adds a constraint to the search
*/
void mpd_database_search_add_constraint(MpdObj *mi, mpd_TagItems field, const char *value)
{
if(mi == NULL || value == NULL || value[0] == '\0')
{
debug_printf(DEBUG_ERROR,"Failed to parse arguments");
return;
}
if(mi->search_type == MPD_SEARCH_TYPE_NONE)
{
debug_printf(DEBUG_ERROR, "No search to constraint");
return;
}
if(!mpd_check_connected(mi))
{
debug_printf(DEBUG_ERROR, "Not Connected\n");
return ;
}
if(!mpd_server_check_version(mi, 0,12,0))
{
debug_printf(DEBUG_ERROR, "Advanced search requires mpd 0.12.0 or higher");
return ;
}
/* lock, so we can work on mi->connection */
if(mpd_lock_conn(mi) != MPD_OK)
{
debug_printf(DEBUG_ERROR, "Failed to lock connection");
return ;
}
mpd_addConstraintSearch(mi->connection, field, value);
/* unlock, let the error handler handle any possible error.
*/
mpd_unlock_conn(mi);
return;
}
void mpd_database_search_field_start(MpdObj *mi, mpd_TagItems field)
{
/*
* Check argument
*/
if(mi == NULL || field >= MPD_TAG_NUM_OF_ITEM_TYPES || field < 0)
{
debug_printf(DEBUG_ERROR, "Argument error");
return ;
}
if(!mpd_check_connected(mi))
{
debug_printf(DEBUG_ERROR, "Not Connected\n");
return ;
}
if(!mpd_server_check_version(mi, 0,12,0))
{
debug_printf(DEBUG_ERROR, "Advanced field list requires mpd 0.12.0 or higher");
return ;
}
/* lock, so we can work on mi->connection */
if(mpd_lock_conn(mi) != MPD_OK)
{
debug_printf(DEBUG_ERROR, "Failed to lock connection");
return ;
}
mpd_startFieldSearch(mi->connection, field);
/* Set search type */
mi->search_type = MPD_SEARCH_TYPE_LIST;
mi->search_field = field;
/* unlock, let the error handler handle any possible error.
*/
mpd_unlock_conn(mi);
return;
}
int mpd_status_set_volume(MpdObj *mi,int volume)
{
if(!mpd_check_connected(mi))
{
debug_printf(DEBUG_WARNING,"not connected\n");
return MPD_NOT_CONNECTED;
}
/* making sure volume is between 0 and 100 */
volume = (volume < 0)? 0:(volume>100)? 100:volume;
if(mpd_lock_conn(mi))
{
debug_printf(DEBUG_ERROR,"lock failed\n");
return MPD_LOCK_FAILED;
}
/* send the command */
mpd_sendSetvolCommand(mi->connection , volume);
mpd_finishCommand(mi->connection);
/* check for errors */
mpd_unlock_conn(mi);
/* update status, because we changed it */
mpd_status_queue_update(mi);
/* return current volume */
return mpd_status_get_volume(mi);
}
int mpd_player_pause(MpdObj * mi)
{
if (!mpd_check_connected(mi)) {
debug_printf(DEBUG_WARNING, "not connected\n");
return MPD_NOT_CONNECTED;
}
if (mpd_lock_conn(mi)) {
debug_printf(DEBUG_WARNING, "lock failed\n");
return MPD_LOCK_FAILED;
}
if (mpd_player_get_state(mi) == MPD_PLAYER_PAUSE) {
mpd_sendPauseCommand(mi->connection, 0);
mpd_finishCommand(mi->connection);
} else if (mpd_player_get_state(mi) == MPD_PLAYER_PLAY) {
mpd_sendPauseCommand(mi->connection, 1);
mpd_finishCommand(mi->connection);
}
mpd_unlock_conn(mi);
if (mpd_status_update(mi)) {
return MPD_STATUS_FAILED;
}
return MPD_OK;
}
MpdData *mpd_database_get_playlist_content(MpdObj *mi,char *playlist)
{
MpdData *data = NULL;
mpd_InfoEntity *ent = NULL;
if(!mpd_check_connected(mi))
{
debug_printf(DEBUG_WARNING,"not connected\n");
return NULL;
}
if(!mpd_server_check_version(mi, 0,12,0))
{
debug_printf(DEBUG_WARNING, "only works with mpd higher then 0.12.0");
return NULL;
}
if(mpd_server_check_command_allowed(mi, "listplaylistinfo") != MPD_SERVER_COMMAND_ALLOWED)
{
debug_printf(DEBUG_WARNING, "Listing playlist content not supported or allowed");
return NULL;
}
if(mpd_lock_conn(mi))
{
debug_printf(DEBUG_WARNING,"lock failed\n");
return NULL;
}
mpd_sendListPlaylistInfoCommand(mi->connection, playlist);
while (( ent = mpd_getNextInfoEntity(mi->connection)) != NULL)
{
data = mpd_new_data_struct_append( data );
if(ent->type == MPD_INFO_ENTITY_TYPE_DIRECTORY)
{
data->type = MPD_DATA_TYPE_DIRECTORY;
data->directory = ent->info.directory->path;
ent->info.directory->path = NULL;
}
else if (ent->type == MPD_INFO_ENTITY_TYPE_SONG)
{
data->type = MPD_DATA_TYPE_SONG;
data->song = ent->info.song;
ent->info.song = NULL;
}
else if (ent->type == MPD_INFO_ENTITY_TYPE_PLAYLISTFILE)
{
data->type = MPD_DATA_TYPE_PLAYLIST;
data->playlist = ent->info.playlistFile->path;
ent->info.playlistFile->path = NULL;
}
mpd_freeInfoEntity(ent);
}
mpd_finishCommand(mi->connection);
/* unlock */
mpd_unlock_conn(mi);
if(data == NULL)
{
return NULL;
}
return mpd_data_get_first(data);
}
/**
* @param mi A #MpdObj
* @param path an Path to a file
*
* Grabs the song info for a single file. Make sure you pass an url to a song
* and not a directory, that might result in strange behauviour.
*
* @returns a #mpd_Song
*/
mpd_Song * mpd_database_get_fileinfo(MpdObj *mi,const char *path)
{
mpd_Song *song = NULL;
mpd_InfoEntity *ent = NULL;
/*
* Check path for availibility and length
*/
if(path == NULL || path[0] == '\0')
{
debug_printf(DEBUG_ERROR, "path == NULL || strlen(path) == 0");
return NULL;
}
if(!mpd_check_connected(mi))
{
debug_printf(DEBUG_ERROR, "Not Connected\n");
return NULL;
}
/* lock, so we can work on mi->connection */
if(mpd_lock_conn(mi) != MPD_OK)
{
debug_printf(DEBUG_ERROR, "Failed to lock connection");
return NULL;
}
/* send the request */
mpd_sendListallInfoCommand(mi->connection, path);
/* get the first (and only) result */
ent = mpd_getNextInfoEntity(mi->connection);
/* finish and clean up libmpdclient */
mpd_finishCommand(mi->connection);
/* unlock again */
if(mpd_unlock_conn(mi))
{
if(ent) mpd_freeInfoEntity(ent);
debug_printf(DEBUG_ERROR, "Failed to unlock");
return NULL;
}
if(ent == NULL)
{
debug_printf(DEBUG_ERROR, "Failed to grab song from mpd\n");
return NULL;
}
if(ent->type != MPD_INFO_ENTITY_TYPE_SONG)
{
mpd_freeInfoEntity(ent);
debug_printf(DEBUG_ERROR, "Failed to grab correct song type from mpd, path might not be a file\n");
return NULL;
}
/* get the song */
song = ent->info.song;
/* remove reference to song from the entity */
ent->info.song = NULL;
/* free the entity */
mpd_freeInfoEntity(ent);
return song;
}
int mpd_status_db_is_updating(MpdObj *mi)
{
if(!mpd_check_connected(mi))
{
debug_printf(DEBUG_WARNING, "mpd_check_connected failed.\n");
return FALSE;
}
return mi->CurrentState.updatingDb;
}
static gboolean serverstats_idle_handler(ss_str * s)
{
GtkTreeIter iter;
MpdDBStats *stats = NULL;
if (s->data == NULL || !mpd_check_connected(connection) || cancel_query)
{
if (gtk_tree_model_get_iter_first(s->model, &iter))
{
do
{
guint d;
gulong i;
gchar *value = NULL;
gtk_tree_model_get(s->model, &iter, 0, &i, -1);
d = (guint) 100 *(i / (double)s->max_i);
value = format_time_real(i, "");
gtk_list_store_set(GTK_LIST_STORE(s->model), &iter, 2, d, 3, value, -1);
g_free(value);
} while (gtk_tree_model_iter_next(s->model, &iter));
}
if (s->data)
mpd_data_free(s->data);
gtk_tree_view_set_model(GTK_TREE_VIEW(serverstats_tree), s->model);
gtk_tree_view_set_search_column(GTK_TREE_VIEW(serverstats_tree), 1);
gtk_widget_set_sensitive(GTK_WIDGET(s->box), TRUE);
gtk_widget_hide(gtk_widget_get_parent(s->pb));
if (cancel_query)
gtk_list_store_clear(GTK_LIST_STORE(s->model));
g_free(s);
cancel_query = FALSE;
return FALSE;
}
mpd_database_search_stats_start(connection);
mpd_database_search_add_constraint(connection, s->tag, s->data->tag);
stats = mpd_database_search_stats_commit(connection);
if (stats)
{
gtk_list_store_prepend(GTK_LIST_STORE(s->model), &iter);
gtk_list_store_set(GTK_LIST_STORE(s->model), &iter, 0, (unsigned long)(stats->playTime), 1, s->data->tag, -1);
s->max_i = MAX(s->max_i, stats->playTime);
mpd_database_search_free_stats(stats);
}
/* limit the amount of updating to 0.2 % */
if ((int)((1000 * s->hits) / s->total) % 5 == 0)
{
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(s->pb), s->hits / (double)s->total);
}
s->hits++;
s->data = mpd_data_get_next(s->data);
return TRUE;
}
void
gimmix_disconnect (MpdObj *mo)
{
if (mo != NULL || mpd_check_connected(mo))
{
mpd_free (mo);
}
return;
}
char *mpd_server_get_version(MpdObj *mi)
{
char *retval = NULL;
if(!mi || !mpd_check_connected(mi))
return NULL;
retval = malloc(10*sizeof(char));
snprintf(retval,10,"%i.%i.%i", mi->connection->version[0], mi->connection->version[1], mi->connection->version[2]);
/* always make sure the string is terminated */
retval[9] = '\0';
return retval;
}
MpdData * mpd_database_get_directory(MpdObj *mi,char *path)
{
MpdData *data = NULL;
mpd_InfoEntity *ent = NULL;
if(!mpd_check_connected(mi))
{
debug_printf(DEBUG_WARNING,"not connected\n");
return NULL;
}
if(path == NULL)
{
path = "/";
}
if(mpd_lock_conn(mi))
{
debug_printf(DEBUG_WARNING,"lock failed\n");
return NULL;
}
mpd_sendLsInfoCommand(mi->connection,path);
while (( ent = mpd_getNextInfoEntity(mi->connection)) != NULL)
{
data = mpd_new_data_struct_append(data);
if(ent->type == MPD_INFO_ENTITY_TYPE_DIRECTORY)
{
data->type = MPD_DATA_TYPE_DIRECTORY;
data->directory = ent->info.directory->path;
ent->info.directory->path = NULL;
}
else if (ent->type == MPD_INFO_ENTITY_TYPE_SONG)
{
data->type = MPD_DATA_TYPE_SONG;
data->song = ent->info.song;
ent->info.song = NULL;
}
else if (ent->type == MPD_INFO_ENTITY_TYPE_PLAYLISTFILE)
{
data->type = MPD_DATA_TYPE_PLAYLIST;
data->playlist = ent->info.playlistFile->path;
ent->info.playlistFile->path = NULL;
}
mpd_freeInfoEntity(ent);
}
mpd_finishCommand(mi->connection);
/* unlock */
mpd_unlock_conn(mi);
if(data == NULL)
{
return NULL;
}
return mpd_data_get_first(data);
}
