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_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_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_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;
}
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;
}
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;
}
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;
}
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;
}
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_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;
}
/**
* @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_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;
}
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;
}
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);
}
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);
}
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);
}
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;
}
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);
}
int mpd_server_get_allowed_commands(MpdObj *mi)
{
char *temp = NULL;
int num_commands = 0;
if(!mi){
debug_printf(DEBUG_ERROR, "mi != NULL failed\n");
return MPD_ARGS_ERROR;
}
if(!mpd_check_connected(mi)) {
debug_printf(DEBUG_WARNING, "Not Connected");
return MPD_NOT_CONNECTED;
}
if(!mpd_server_check_version(mi,0,12,0)){
debug_printf(DEBUG_INFO, "Not supported by mpd");
return MPD_SERVER_NOT_SUPPORTED;
}
mpd_server_free_commands(mi);
if(mpd_lock_conn(mi))
{
debug_printf(DEBUG_ERROR, "lock failed");
return MPD_LOCK_FAILED;
}
mpd_sendCommandsCommand(mi->connection);
while((temp = mpd_getNextCommand(mi->connection)))
{
num_commands++;
mi->commands = realloc(mi->commands, (num_commands+1)*sizeof(MpdCommand));
mi->commands[num_commands-1].command_name = temp;
mi->commands[num_commands-1].enabled = TRUE;
mi->commands[num_commands].command_name = NULL;
mi->commands[num_commands].enabled = FALSE;
}
mpd_finishCommand(mi->connection);
mpd_sendNotCommandsCommand(mi->connection);
while((temp = mpd_getNextCommand(mi->connection)))
{
num_commands++;
mi->commands = realloc(mi->commands, (num_commands+1)*sizeof(MpdCommand));
mi->commands[num_commands-1].command_name = temp;
mi->commands[num_commands-1].enabled = FALSE;
mi->commands[num_commands].command_name = NULL;
mi->commands[num_commands].enabled = FALSE;
}
mpd_finishCommand(mi->connection);
if(mpd_unlock_conn(mi))
{
return MPD_LOCK_FAILED;
}
return MPD_OK;
}
MpdData * mpd_playlist_get_changes_posid(MpdObj *mi,int old_playlist_id)
{
MpdData *data = NULL;
mpd_InfoEntity *ent = NULL;
debug_printf(DEBUG_INFO, "Fetching using new plchangesposid command");
if(!mpd_check_connected(mi))
{
debug_printf(DEBUG_WARNING,"not connected\n");
return NULL;
}
if(mpd_lock_conn(mi))
{
debug_printf(DEBUG_WARNING,"lock failed\n");
return NULL;
}
if(old_playlist_id == -1)
{
debug_printf(DEBUG_INFO,"get fresh playlist\n");
mpd_sendPlChangesPosIdCommand (mi->connection, 0);
/* mpd_sendPlaylistIdCommand(mi->connection, -1); */
}
else
{
mpd_sendPlChangesPosIdCommand (mi->connection, old_playlist_id);
}
while (( ent = mpd_getNextInfoEntity(mi->connection)) != NULL)
{
if(ent->type == MPD_INFO_ENTITY_TYPE_SONG)
{
data = mpd_new_data_struct_append(data);
data->type = MPD_DATA_TYPE_SONG;
data->song = ent->info.song;
ent->info.song = NULL;
}
mpd_freeInfoEntity(ent);
}
mpd_finishCommand(mi->connection);
/* unlock */
if(mpd_unlock_conn(mi))
{
debug_printf(DEBUG_WARNING,"mpd_playlist_get_changes: unlock failed.\n");
mpd_data_free(data);
return NULL;
}
if(data == NULL)
{
return NULL;
}
return mpd_data_get_first(data);
}
int mpd_stats_update_real(MpdObj *mi, ChangedStatusType* what_changed)
{
ChangedStatusType what_changed_here = 0;
if ( what_changed == NULL ) {
/* we need to save the current state, because we're called standalone */
memcpy(&(mi->OldState), &(mi->CurrentState), sizeof(MpdServerState));
}
if(!mpd_check_connected(mi))
{
debug_printf(DEBUG_INFO,"not connected\n");
return MPD_NOT_CONNECTED;
}
if(mpd_lock_conn(mi))
{
debug_printf(DEBUG_ERROR,"lock failed\n");
return MPD_LOCK_FAILED;
}
if(mi->stats != NULL)
{
mpd_freeStats(mi->stats);
}
mpd_sendStatsCommand(mi->connection);
mi->stats = mpd_getStats(mi->connection);
if(mi->stats == NULL)
{
debug_printf(DEBUG_ERROR,"Failed to grab stats from mpd\n");
}
else if(mi->stats->dbUpdateTime != mi->OldState.dbUpdateTime)
{
debug_printf(DEBUG_INFO, "database updated\n");
what_changed_here |= MPD_CST_DATABASE;
mi->CurrentState.dbUpdateTime = mi->stats->dbUpdateTime;
}
if (what_changed) {
(*what_changed) |= what_changed_here;
} else {
if((mi->the_status_changed_callback != NULL) & what_changed_here)
{
mi->the_status_changed_callback(mi, what_changed_here, mi->the_status_changed_signal_userdata);
}
}
if(mpd_unlock_conn(mi))
{
debug_printf(DEBUG_ERROR, "unlock failed");
return MPD_LOCK_FAILED;
}
return MPD_OK;
}
MpdData * mpd_playlist_search_commit(MpdObj *mi)
{
mpd_InfoEntity *ent = NULL;
MpdData *data = NULL;
if(!mpd_check_connected(mi))
{
debug_printf(DEBUG_WARNING,"not connected\n");
return NULL;
}
if(mi->search_type < MPD_SEARCH_TYPE_PLAYLIST_FIND )
{
debug_printf(DEBUG_ERROR, "no or 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);
while (( ent = mpd_getNextInfoEntity(mi->connection)) != NULL)
{
if(ent->type == MPD_INFO_ENTITY_TYPE_SONG)
{
data = mpd_new_data_struct_append(data);
data->type = MPD_DATA_TYPE_SONG;
data->song = ent->info.song;
ent->info.song = NULL;
}
mpd_freeInfoEntity(ent);
}
mpd_finishCommand(mi->connection);
/*
* reset search type
*/
mi->search_type = MPD_SEARCH_TYPE_NONE;
mi->search_field = MPD_TAG_ITEM_ARTIST;
/* unlock */
if(mpd_unlock_conn(mi))
{
debug_printf(DEBUG_ERROR, "Failed to unlock connection");
if(data)mpd_data_free(data);
return NULL;
}
if(data == NULL)
{
return NULL;
}
return mpd_data_get_first(data);
}
MpdData * mpd_playlist_get_song_from_pos_range(MpdObj *mi, int start, int stop)
{
MpdData *data = NULL;
int i;
mpd_InfoEntity *ent = NULL;
if(!mpd_check_connected(mi))
{
debug_printf(DEBUG_ERROR, "Not Connected\n");
return NULL;
}
if(mpd_status_check(mi) != MPD_OK)
{
debug_printf(DEBUG_ERROR,"Failed grabbing status\n");
return NULL;
}
if(mpd_lock_conn(mi))
{
return NULL;
}
/* Don't check outside playlist length */
if(!(stop < mi->status->playlistLength)) {
stop = mi->status->playlistLength -1;
}
mpd_sendCommandListBegin(mi->connection);
for(i=start; i <= stop; i++){
mpd_sendPlaylistInfoCommand(mi->connection, i);
}
mpd_sendCommandListEnd(mi->connection);
while (( ent = mpd_getNextInfoEntity(mi->connection)) != NULL)
{
if(ent->type == MPD_INFO_ENTITY_TYPE_SONG)
{
data = mpd_new_data_struct_append(data);
data->type = MPD_DATA_TYPE_SONG;
data->song = ent->info.song;
ent->info.song = NULL;
}
mpd_freeInfoEntity(ent);
}
mpd_finishCommand(mi->connection);
if(mpd_unlock_conn(mi))
{
/*TODO free entity. for now this can never happen */
return NULL;
}
return data;
}
/*******************************************************************************
* PLAYLIST
*/
mpd_Song * mpd_playlist_get_song(MpdObj *mi, int songid)
{
mpd_Song *song = NULL;
mpd_InfoEntity *ent = NULL;
if(songid < 0){
debug_printf(DEBUG_ERROR, "songid < 0 Failed");
return NULL;
}
if(!mpd_check_connected(mi))
{
debug_printf(DEBUG_ERROR, "Not Connected\n");
return NULL;
}
if(mpd_lock_conn(mi))
{
return NULL;
}
debug_printf(DEBUG_INFO, "Trying to grab song with id: %i\n", songid);
mpd_sendPlaylistIdCommand(mi->connection, songid);
ent = mpd_getNextInfoEntity(mi->connection);
mpd_finishCommand(mi->connection);
if(mpd_unlock_conn(mi))
{
if(ent) mpd_freeInfoEntity(ent);
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\n");
return NULL;
}
song = ent->info.song;
ent->info.song = NULL;
mpd_freeInfoEntity(ent);
return song;
}
int mpd_player_set_random(MpdObj * mi, int random)
{
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_sendRandomCommand(mi->connection, random);
mpd_finishCommand(mi->connection);
mpd_unlock_conn(mi);
mpd_status_queue_update(mi);
return MPD_OK;
}
int mpd_playlist_swap_id (MpdObj *mi, int old_id, int new_id) {
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_sendSwapIdCommand(mi->connection,old_id, new_id);
mpd_finishCommand(mi->connection);
/* unlock */
mpd_unlock_conn(mi);
return MPD_OK;
}
int mpd_status_set_crossfade(MpdObj *mi,int crossfade_time)
{
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_sendCrossfadeCommand(mi->connection, crossfade_time);
mpd_finishCommand(mi->connection);
mpd_unlock_conn(mi);
mpd_status_queue_update(mi);
return MPD_OK;
}
