942 lines
22 KiB
C++
942 lines
22 KiB
C++
/***************************************************************************
|
|
* Copyright (C) 2008-2009 by Andrzej Rybczak *
|
|
* electricityispower@gmail.com *
|
|
* *
|
|
* 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 St, Fifth Floor, Boston, MA 02110-1301, USA. *
|
|
***************************************************************************/
|
|
|
|
#include <cstdlib>
|
|
#include <algorithm>
|
|
|
|
#include "charset.h"
|
|
#include "mpdpp.h"
|
|
|
|
using namespace MPD;
|
|
|
|
MPD::Connection Mpd;
|
|
|
|
const char *MPD::Message::PartOfSongsAdded = "Only part of requested songs' list added to playlist!";
|
|
const char *MPD::Message::FullPlaylist = "Playlist is full!";
|
|
const char *MPD::Message::FunctionDisabledFilteringEnabled = "Function disabled due to enabled filtering in playlist";
|
|
|
|
Connection::Connection() : itsConnection(0),
|
|
isConnected(0),
|
|
isCommandsListEnabled(0),
|
|
itsErrorCode(0),
|
|
itsMaxPlaylistLength(-1),
|
|
itsHost("localhost"),
|
|
itsPort(6600),
|
|
itsTimeout(15),
|
|
itsCurrentStatus(0),
|
|
itsOldStatus(0),
|
|
itsUpdater(0),
|
|
itsErrorHandler(0)
|
|
{
|
|
}
|
|
|
|
Connection::~Connection()
|
|
{
|
|
if (itsConnection)
|
|
mpd_closeConnection(itsConnection);
|
|
if (itsOldStatus)
|
|
mpd_freeStatus(itsOldStatus);
|
|
if (itsCurrentStatus)
|
|
mpd_freeStatus(itsCurrentStatus);
|
|
}
|
|
|
|
bool Connection::Connect()
|
|
{
|
|
if (!isConnected && !itsConnection)
|
|
{
|
|
itsConnection = mpd_newConnection(itsHost.c_str(), itsPort, itsTimeout);
|
|
isConnected = 1;
|
|
if (CheckForErrors())
|
|
return false;
|
|
if (!itsPassword.empty())
|
|
SendPassword();
|
|
return !CheckForErrors();
|
|
}
|
|
else
|
|
return true;
|
|
}
|
|
|
|
bool Connection::Connected() const
|
|
{
|
|
return isConnected;
|
|
}
|
|
|
|
void Connection::Disconnect()
|
|
{
|
|
if (itsConnection)
|
|
mpd_closeConnection(itsConnection);
|
|
if (itsOldStatus)
|
|
mpd_freeStatus(itsOldStatus);
|
|
if (itsCurrentStatus)
|
|
mpd_freeStatus(itsCurrentStatus);
|
|
itsConnection = 0;
|
|
itsCurrentStatus = 0;
|
|
itsOldStatus = 0;
|
|
isConnected = 0;
|
|
isCommandsListEnabled = 0;
|
|
itsMaxPlaylistLength = -1;
|
|
}
|
|
|
|
float Connection::Version() const
|
|
{
|
|
return itsConnection ? itsConnection->version[1] + itsConnection->version[2]*0.1 : 0;
|
|
}
|
|
|
|
void Connection::SetHostname(const std::string &host)
|
|
{
|
|
size_t at = host.find("@");
|
|
if (at != std::string::npos)
|
|
{
|
|
itsPassword = host.substr(0, at);
|
|
itsHost = host.substr(at+1);
|
|
}
|
|
else
|
|
itsHost = host;
|
|
}
|
|
|
|
void Connection::SendPassword() const
|
|
{
|
|
mpd_sendPasswordCommand(itsConnection, itsPassword.c_str());
|
|
mpd_finishCommand(itsConnection);
|
|
}
|
|
|
|
void Connection::SetStatusUpdater(StatusUpdater updater, void *data)
|
|
{
|
|
itsUpdater = updater;
|
|
itsStatusUpdaterUserdata = data;
|
|
}
|
|
|
|
void Connection::SetErrorHandler(ErrorHandler handler, void *data)
|
|
{
|
|
itsErrorHandler = handler;
|
|
itsErrorHandlerUserdata = data;
|
|
}
|
|
|
|
void Connection::UpdateStatus()
|
|
{
|
|
if (!itsConnection)
|
|
return;
|
|
|
|
CheckForErrors();
|
|
|
|
if (!itsConnection)
|
|
return;
|
|
|
|
if (itsOldStatus)
|
|
mpd_freeStatus(itsOldStatus);
|
|
|
|
itsOldStatus = itsCurrentStatus;
|
|
itsCurrentStatus = 0;
|
|
|
|
mpd_sendStatusCommand(itsConnection);
|
|
itsCurrentStatus = mpd_getStatus(itsConnection);
|
|
|
|
if (!itsMaxPlaylistLength)
|
|
itsMaxPlaylistLength = GetPlaylistLength();
|
|
|
|
if (CheckForErrors())
|
|
return;
|
|
|
|
if (itsCurrentStatus && itsUpdater)
|
|
{
|
|
if (!itsOldStatus)
|
|
{
|
|
itsChanges.Playlist = 1;
|
|
itsChanges.SongID = 1;
|
|
itsChanges.Database = 1;
|
|
itsChanges.DBUpdating = 1;
|
|
itsChanges.Volume = 1;
|
|
itsChanges.ElapsedTime = 1;
|
|
itsChanges.Crossfade = 1;
|
|
itsChanges.Random = 1;
|
|
itsChanges.Repeat = 1;
|
|
itsChanges.Single = 1;
|
|
itsChanges.Consume = 1;
|
|
itsChanges.PlayerState = 1;
|
|
itsChanges.StatusFlags = 1;
|
|
}
|
|
else
|
|
{
|
|
itsChanges.Playlist = itsOldStatus->playlist != itsCurrentStatus->playlist;
|
|
itsChanges.SongID = itsOldStatus->songid != itsCurrentStatus->songid;
|
|
itsChanges.Database = itsOldStatus->updatingDb && !itsCurrentStatus->updatingDb;
|
|
itsChanges.DBUpdating = itsOldStatus->updatingDb != itsCurrentStatus->updatingDb;
|
|
itsChanges.Volume = itsOldStatus->volume != itsCurrentStatus->volume;
|
|
itsChanges.ElapsedTime = itsOldStatus->elapsedTime != itsCurrentStatus->elapsedTime;
|
|
itsChanges.Crossfade = itsOldStatus->crossfade != itsCurrentStatus->crossfade;
|
|
itsChanges.Random = itsOldStatus->random != itsCurrentStatus->random;
|
|
itsChanges.Repeat = itsOldStatus->repeat != itsCurrentStatus->repeat;
|
|
itsChanges.Single = itsOldStatus->single != itsCurrentStatus->single;
|
|
itsChanges.Consume = itsOldStatus->consume != itsCurrentStatus->consume;
|
|
itsChanges.PlayerState = itsOldStatus->state != itsCurrentStatus->state;
|
|
itsChanges.StatusFlags = itsChanges.Repeat || itsChanges.Random || itsChanges.Single || itsChanges.Consume || itsChanges.Crossfade || itsChanges.DBUpdating;
|
|
}
|
|
itsUpdater(this, itsChanges, itsErrorHandlerUserdata);
|
|
}
|
|
}
|
|
|
|
void Connection::UpdateDirectory(const std::string &path)
|
|
{
|
|
if (isConnected)
|
|
{
|
|
mpd_sendUpdateCommand(itsConnection, path.c_str());
|
|
mpd_finishCommand(itsConnection);
|
|
if (!itsConnection->error && itsUpdater)
|
|
{
|
|
itsCurrentStatus->updatingDb = 1;
|
|
StatusChanges ch;
|
|
ch.DBUpdating = 1;
|
|
ch.StatusFlags = 1;
|
|
itsUpdater(this, ch, itsErrorHandlerUserdata);
|
|
}
|
|
}
|
|
}
|
|
|
|
void Connection::Execute(const std::string &command) const
|
|
{
|
|
if (isConnected)
|
|
{
|
|
mpd_executeCommand(itsConnection, command.c_str());
|
|
if (!isCommandsListEnabled)
|
|
mpd_finishCommand(itsConnection);
|
|
}
|
|
}
|
|
|
|
void Connection::Play() const
|
|
{
|
|
if (isConnected)
|
|
PlayID(-1);
|
|
}
|
|
|
|
void Connection::Play(int pos) const
|
|
{
|
|
if (isConnected)
|
|
{
|
|
mpd_sendPlayCommand(itsConnection, pos);
|
|
if (!isCommandsListEnabled)
|
|
mpd_finishCommand(itsConnection);
|
|
}
|
|
}
|
|
|
|
void Connection::PlayID(int id) const
|
|
{
|
|
if (isConnected)
|
|
{
|
|
mpd_sendPlayIdCommand(itsConnection, id);
|
|
if (!isCommandsListEnabled)
|
|
mpd_finishCommand(itsConnection);
|
|
}
|
|
}
|
|
|
|
void Connection::Pause() const
|
|
{
|
|
if (isConnected)
|
|
{
|
|
mpd_sendPauseCommand(itsConnection, itsCurrentStatus->state != psPause);
|
|
if (!isCommandsListEnabled)
|
|
mpd_finishCommand(itsConnection);
|
|
}
|
|
}
|
|
|
|
void Connection::Stop() const
|
|
{
|
|
if (isConnected)
|
|
{
|
|
mpd_sendStopCommand(itsConnection);
|
|
if (!isCommandsListEnabled)
|
|
mpd_finishCommand(itsConnection);
|
|
}
|
|
}
|
|
|
|
void Connection::Next() const
|
|
{
|
|
if (isConnected)
|
|
{
|
|
mpd_sendNextCommand(itsConnection);
|
|
if (!isCommandsListEnabled)
|
|
mpd_finishCommand(itsConnection);
|
|
}
|
|
}
|
|
|
|
void Connection::Prev() const
|
|
{
|
|
if (isConnected)
|
|
{
|
|
mpd_sendPrevCommand(itsConnection);
|
|
if (!isCommandsListEnabled)
|
|
mpd_finishCommand(itsConnection);
|
|
}
|
|
}
|
|
|
|
void Connection::Move(int from, int to) const
|
|
{
|
|
if (isConnected)
|
|
{
|
|
mpd_sendMoveCommand(itsConnection, from, to);
|
|
if (!isCommandsListEnabled)
|
|
mpd_finishCommand(itsConnection);
|
|
}
|
|
}
|
|
|
|
void Connection::Swap(int from, int to) const
|
|
{
|
|
if (isConnected)
|
|
{
|
|
mpd_sendSwapCommand(itsConnection, from, to);
|
|
if (!isCommandsListEnabled)
|
|
mpd_finishCommand(itsConnection);
|
|
}
|
|
}
|
|
|
|
void Connection::Seek(int where) const
|
|
{
|
|
if (isConnected)
|
|
{
|
|
mpd_sendSeekCommand(itsConnection, itsCurrentStatus->song, where);
|
|
if (!isCommandsListEnabled)
|
|
mpd_finishCommand(itsConnection);
|
|
}
|
|
}
|
|
|
|
void Connection::Shuffle() const
|
|
{
|
|
if (isConnected)
|
|
{
|
|
mpd_sendShuffleCommand(itsConnection);
|
|
if (!isCommandsListEnabled)
|
|
mpd_finishCommand(itsConnection);
|
|
}
|
|
}
|
|
|
|
void Connection::ClearPlaylist() const
|
|
{
|
|
if (isConnected)
|
|
{
|
|
mpd_sendClearCommand(itsConnection);
|
|
if (!isCommandsListEnabled)
|
|
mpd_finishCommand(itsConnection);
|
|
}
|
|
}
|
|
|
|
void Connection::ClearPlaylist(const std::string &playlist) const
|
|
{
|
|
if (isConnected)
|
|
{
|
|
mpd_sendPlaylistClearCommand(itsConnection, playlist.c_str());
|
|
if (!isCommandsListEnabled)
|
|
mpd_finishCommand(itsConnection);
|
|
}
|
|
}
|
|
|
|
void Connection::AddToPlaylist(const std::string &path, const Song &s) const
|
|
{
|
|
if (!s.Empty())
|
|
AddToPlaylist(path, s.GetFile());
|
|
}
|
|
|
|
void Connection::AddToPlaylist(const std::string &path, const std::string &file) const
|
|
{
|
|
if (isConnected)
|
|
{
|
|
mpd_sendPlaylistAddCommand(itsConnection, path.c_str(), file.c_str());
|
|
if (!isCommandsListEnabled)
|
|
mpd_finishCommand(itsConnection);
|
|
}
|
|
}
|
|
|
|
void Connection::Move(const std::string &path, int from, int to) const
|
|
{
|
|
if (isConnected)
|
|
{
|
|
mpd_sendPlaylistMoveCommand(itsConnection, path.c_str(), from, to);
|
|
if (!isCommandsListEnabled)
|
|
mpd_finishCommand(itsConnection);
|
|
}
|
|
}
|
|
|
|
void Connection::Rename(const std::string &from, const std::string &to) const
|
|
{
|
|
if (isConnected)
|
|
{
|
|
mpd_sendRenameCommand(itsConnection, from.c_str(), to.c_str());
|
|
if (!isCommandsListEnabled)
|
|
mpd_finishCommand(itsConnection);
|
|
}
|
|
}
|
|
|
|
void Connection::GetPlaylistChanges(long long id, SongList &v) const
|
|
{
|
|
if (isConnected)
|
|
{
|
|
if (id < 0)
|
|
{
|
|
id = 0;
|
|
v.reserve(GetPlaylistLength());
|
|
}
|
|
mpd_sendPlChangesCommand(itsConnection, id);
|
|
while (mpd_InfoEntity *item = mpd_getNextInfoEntity(itsConnection))
|
|
{
|
|
if (item->type == MPD_INFO_ENTITY_TYPE_SONG)
|
|
{
|
|
Song *s = new Song(item->info.song, 1);
|
|
item->info.song = 0;
|
|
v.push_back(s);
|
|
}
|
|
mpd_freeInfoEntity(item);
|
|
}
|
|
mpd_finishCommand(itsConnection);
|
|
}
|
|
}
|
|
|
|
Song Connection::GetSong(const std::string &path) const
|
|
{
|
|
if (isConnected)
|
|
{
|
|
mpd_sendListallInfoCommand(itsConnection, path.c_str());
|
|
mpd_InfoEntity *item = mpd_getNextInfoEntity(itsConnection);
|
|
Song result = item->info.song;
|
|
item->info.song = 0;
|
|
mpd_freeInfoEntity(item);
|
|
mpd_finishCommand(itsConnection);
|
|
return result;
|
|
}
|
|
else
|
|
return Song();
|
|
}
|
|
|
|
int Connection::GetCurrentSongPos() const
|
|
{
|
|
return isConnected && itsCurrentStatus ? (itsCurrentStatus->state == psPlay || itsCurrentStatus->state == psPause ? itsCurrentStatus->song : -1) : -1;
|
|
}
|
|
|
|
Song Connection::GetCurrentSong() const
|
|
{
|
|
if (isConnected && (GetState() == psPlay || GetState() == psPause))
|
|
{
|
|
mpd_sendCurrentSongCommand(itsConnection);
|
|
if (mpd_InfoEntity *item = mpd_getNextInfoEntity(itsConnection))
|
|
{
|
|
Song result = item->info.song;
|
|
item->info.song = 0;
|
|
mpd_freeInfoEntity(item);
|
|
return result;
|
|
}
|
|
else
|
|
return Song();
|
|
mpd_finishCommand(itsConnection);
|
|
}
|
|
else
|
|
return Song();
|
|
}
|
|
|
|
void Connection::GetPlaylistContent(const std::string &path, SongList &v) const
|
|
{
|
|
if (isConnected)
|
|
{
|
|
mpd_sendListPlaylistInfoCommand(itsConnection, path.c_str());
|
|
while (mpd_InfoEntity *item = mpd_getNextInfoEntity(itsConnection))
|
|
{
|
|
if (item->type == MPD_INFO_ENTITY_TYPE_SONG)
|
|
{
|
|
Song *s = new Song(item->info.song);
|
|
item->info.song = 0;
|
|
v.push_back(s);
|
|
}
|
|
mpd_freeInfoEntity(item);
|
|
}
|
|
mpd_finishCommand(itsConnection);
|
|
}
|
|
}
|
|
|
|
void Connection::SetRepeat(bool mode) const
|
|
{
|
|
if (isConnected)
|
|
{
|
|
mpd_sendRepeatCommand(itsConnection, mode);
|
|
if (!isCommandsListEnabled)
|
|
mpd_finishCommand(itsConnection);
|
|
}
|
|
}
|
|
|
|
void Connection::SetRandom(bool mode) const
|
|
{
|
|
if (isConnected)
|
|
{
|
|
mpd_sendRandomCommand(itsConnection, mode);
|
|
if (!isCommandsListEnabled)
|
|
mpd_finishCommand(itsConnection);
|
|
}
|
|
}
|
|
|
|
void Connection::SetSingle(bool mode) const
|
|
{
|
|
if (isConnected)
|
|
{
|
|
mpd_sendSingleCommand(itsConnection, mode);
|
|
if (!isCommandsListEnabled)
|
|
mpd_finishCommand(itsConnection);
|
|
}
|
|
}
|
|
|
|
void Connection::SetConsume(bool mode) const
|
|
{
|
|
if (isConnected)
|
|
{
|
|
mpd_sendConsumeCommand(itsConnection, mode);
|
|
if (!isCommandsListEnabled)
|
|
mpd_finishCommand(itsConnection);
|
|
}
|
|
}
|
|
|
|
void Connection::SetVolume(int vol)
|
|
{
|
|
if (isConnected && vol >= 0 && vol <= 100)
|
|
{
|
|
mpd_sendSetvolCommand(itsConnection, vol);
|
|
mpd_finishCommand(itsConnection);
|
|
if (!itsConnection->error && itsUpdater)
|
|
{
|
|
itsCurrentStatus->volume = vol;
|
|
StatusChanges ch;
|
|
ch.Volume = 1;
|
|
itsUpdater(this, ch, itsStatusUpdaterUserdata);
|
|
}
|
|
}
|
|
}
|
|
|
|
void Connection::SetCrossfade(int crossfade) const
|
|
{
|
|
if (isConnected)
|
|
{
|
|
mpd_sendCrossfadeCommand(itsConnection, crossfade);
|
|
if (!isCommandsListEnabled)
|
|
mpd_finishCommand(itsConnection);
|
|
}
|
|
}
|
|
|
|
int Connection::AddSong(const std::string &path)
|
|
{
|
|
int id = -1;
|
|
if (isConnected)
|
|
{
|
|
if (GetPlaylistLength() < itsMaxPlaylistLength)
|
|
{
|
|
id = mpd_sendAddIdCommand(itsConnection, path.c_str());
|
|
if (!isCommandsListEnabled)
|
|
{
|
|
mpd_finishCommand(itsConnection);
|
|
UpdateStatus();
|
|
}
|
|
else
|
|
id = 0;
|
|
}
|
|
else if (itsErrorHandler)
|
|
itsErrorHandler(this, MPD_ACK_ERROR_PLAYLIST_MAX, Message::FullPlaylist, itsErrorHandlerUserdata);
|
|
}
|
|
return id;
|
|
}
|
|
|
|
int Connection::AddSong(const Song &s)
|
|
{
|
|
return !s.Empty() ? (AddSong((!s.isFromDB() ? "file://" : "") + (s.Localized() ? locale_to_utf_cpy(s.GetFile()) : s.GetFile()))) : -1;
|
|
}
|
|
|
|
void Connection::Add(const std::string &path) const
|
|
{
|
|
if (!isConnected)
|
|
return;
|
|
mpd_sendAddCommand(itsConnection, path.c_str());
|
|
mpd_finishCommand(itsConnection);
|
|
}
|
|
|
|
bool Connection::AddRandomSongs(size_t number)
|
|
{
|
|
if (!isConnected && !number)
|
|
return false;
|
|
|
|
TagList files;
|
|
|
|
mpd_sendListallCommand(itsConnection, "/");
|
|
while (char *file = mpd_getNextTag(itsConnection, MPD_TAG_ITEM_FILENAME))
|
|
{
|
|
files.push_back(file);
|
|
delete [] file;
|
|
}
|
|
mpd_finishCommand(itsConnection);
|
|
|
|
if (number > files.size())
|
|
{
|
|
if (itsErrorHandler)
|
|
itsErrorHandler(this, 0, "Requested number of random songs is bigger than size of your library!", itsErrorHandlerUserdata);
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
srand(time(0));
|
|
std::random_shuffle(files.begin(), files.end());
|
|
StartCommandsList();
|
|
TagList::const_iterator it = files.begin()+rand()%(files.size()-number);
|
|
for (size_t i = 0; i < number && it != files.end(); ++i)
|
|
AddSong(*it++);
|
|
CommitCommandsList();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void Connection::Delete(int pos) const
|
|
{
|
|
if (isConnected)
|
|
{
|
|
mpd_sendDeleteCommand(itsConnection, pos);
|
|
if (!isCommandsListEnabled)
|
|
mpd_finishCommand(itsConnection);
|
|
}
|
|
}
|
|
|
|
void Connection::DeleteID(int id) const
|
|
{
|
|
if (isConnected)
|
|
{
|
|
mpd_sendDeleteIdCommand(itsConnection, id);
|
|
if (!isCommandsListEnabled)
|
|
mpd_finishCommand(itsConnection);
|
|
}
|
|
}
|
|
|
|
void Connection::Delete(const std::string &playlist, int pos) const
|
|
{
|
|
if (isConnected)
|
|
{
|
|
mpd_sendPlaylistDeleteCommand(itsConnection, playlist.c_str(), pos);
|
|
if (!isCommandsListEnabled)
|
|
mpd_finishCommand(itsConnection);
|
|
}
|
|
}
|
|
|
|
void Connection::StartCommandsList()
|
|
{
|
|
if (isConnected)
|
|
{
|
|
mpd_sendCommandListBegin(itsConnection);
|
|
isCommandsListEnabled = 1;
|
|
}
|
|
|
|
}
|
|
|
|
bool Connection::CommitCommandsList()
|
|
{
|
|
if (isConnected)
|
|
{
|
|
mpd_sendCommandListEnd(itsConnection);
|
|
mpd_finishCommand(itsConnection);
|
|
UpdateStatus();
|
|
if (GetPlaylistLength() == itsMaxPlaylistLength && itsErrorHandler)
|
|
itsErrorHandler(this, MPD_ACK_ERROR_PLAYLIST_MAX, Message::FullPlaylist, itsErrorHandlerUserdata);
|
|
isCommandsListEnabled = 0;
|
|
}
|
|
return !CheckForErrors();
|
|
}
|
|
|
|
void Connection::DeletePlaylist(const std::string &name) const
|
|
{
|
|
if (isConnected)
|
|
{
|
|
mpd_sendRmCommand(itsConnection, name.c_str());
|
|
if (!isCommandsListEnabled)
|
|
mpd_finishCommand(itsConnection);
|
|
}
|
|
}
|
|
|
|
bool Connection::SavePlaylist(const std::string &name) const
|
|
{
|
|
if (isConnected)
|
|
{
|
|
mpd_sendSaveCommand(itsConnection, name.c_str());
|
|
mpd_finishCommand(itsConnection);
|
|
return !(itsConnection->error == MPD_ERROR_ACK && itsConnection->errorCode == MPD_ACK_ERROR_EXIST);
|
|
}
|
|
else
|
|
return false;
|
|
}
|
|
|
|
void Connection::GetPlaylists(TagList &v) const
|
|
{
|
|
if (isConnected)
|
|
{
|
|
ItemList list;
|
|
GetDirectory("/", list);
|
|
for (ItemList::const_iterator it = list.begin(); it != list.end(); ++it)
|
|
{
|
|
if (it->type == itPlaylist)
|
|
v.push_back(it->name);
|
|
}
|
|
FreeItemList(list);
|
|
}
|
|
}
|
|
|
|
void Connection::GetList(TagList &v, mpd_TagItems type) const
|
|
{
|
|
if (isConnected)
|
|
{
|
|
mpd_sendListCommand(itsConnection, type, 0);
|
|
while (char *item = mpd_getNextTag(itsConnection, type))
|
|
{
|
|
if (item[0] != 0) // do not push empty item
|
|
v.push_back(item);
|
|
delete [] item;
|
|
}
|
|
mpd_finishCommand(itsConnection);
|
|
}
|
|
}
|
|
|
|
void Connection::GetAlbums(const std::string &artist, TagList &v) const
|
|
{
|
|
if (isConnected)
|
|
{
|
|
mpd_sendListCommand(itsConnection, MPD_TABLE_ALBUM, artist.empty() ? 0 : artist.c_str());
|
|
|
|
while (char *item = mpd_getNextAlbum(itsConnection))
|
|
{
|
|
if (item[0] != 0) // do not push empty item
|
|
v.push_back(item);
|
|
delete [] item;
|
|
}
|
|
mpd_finishCommand(itsConnection);
|
|
}
|
|
}
|
|
|
|
void Connection::StartSearch(bool exact_match) const
|
|
{
|
|
if (isConnected)
|
|
mpd_startSearch(itsConnection, exact_match);
|
|
}
|
|
|
|
void Connection::StartFieldSearch(mpd_TagItems item)
|
|
{
|
|
if (isConnected)
|
|
{
|
|
itsSearchedField = item;
|
|
mpd_startFieldSearch(itsConnection, item);
|
|
}
|
|
}
|
|
|
|
void Connection::AddSearch(mpd_TagItems item, const std::string &str) const
|
|
{
|
|
// mpd version < 0.14.* doesn't support empty search constraints
|
|
if (Version() < 14 && str.empty())
|
|
return;
|
|
if (isConnected)
|
|
mpd_addConstraintSearch(itsConnection, item, str.c_str());
|
|
}
|
|
|
|
void Connection::CommitSearch(SongList &v) const
|
|
{
|
|
if (isConnected)
|
|
{
|
|
mpd_commitSearch(itsConnection);
|
|
while (mpd_InfoEntity *item = mpd_getNextInfoEntity(itsConnection))
|
|
{
|
|
if (item->type == MPD_INFO_ENTITY_TYPE_SONG)
|
|
{
|
|
Song *s = new Song(item->info.song);
|
|
item->info.song = 0;
|
|
v.push_back(s);
|
|
}
|
|
mpd_freeInfoEntity(item);
|
|
}
|
|
mpd_finishCommand(itsConnection);
|
|
}
|
|
}
|
|
|
|
void Connection::CommitSearch(TagList &v) const
|
|
{
|
|
if (isConnected)
|
|
{
|
|
mpd_commitSearch(itsConnection);
|
|
while (char *tag = mpd_getNextTag(itsConnection, itsSearchedField))
|
|
{
|
|
if (tag[0] != 0) // do not push empty item
|
|
v.push_back(tag);
|
|
delete [] tag;
|
|
}
|
|
mpd_finishCommand(itsConnection);
|
|
}
|
|
}
|
|
|
|
void Connection::GetDirectory(const std::string &path, ItemList &v) const
|
|
{
|
|
if (isConnected)
|
|
{
|
|
mpd_sendLsInfoCommand(itsConnection, path.c_str());
|
|
while (mpd_InfoEntity *item = mpd_getNextInfoEntity(itsConnection))
|
|
{
|
|
Item i;
|
|
switch (item->type)
|
|
{
|
|
case MPD_INFO_ENTITY_TYPE_DIRECTORY:
|
|
i.name = item->info.directory->path;
|
|
i.type = itDirectory;
|
|
break;
|
|
case MPD_INFO_ENTITY_TYPE_SONG:
|
|
i.song = new Song(item->info.song);
|
|
item->info.song = 0;
|
|
i.type = itSong;
|
|
break;
|
|
case MPD_INFO_ENTITY_TYPE_PLAYLISTFILE:
|
|
i.name = item->info.playlistFile->path;
|
|
i.type = itPlaylist;
|
|
break;
|
|
}
|
|
v.push_back(i);
|
|
mpd_freeInfoEntity(item);
|
|
}
|
|
mpd_finishCommand(itsConnection);
|
|
}
|
|
}
|
|
|
|
void Connection::GetDirectoryRecursive(const std::string &path, SongList &v) const
|
|
{
|
|
if (isConnected)
|
|
{
|
|
mpd_sendListallInfoCommand(itsConnection, path.c_str());
|
|
while (mpd_InfoEntity *item = mpd_getNextInfoEntity(itsConnection))
|
|
{
|
|
if (item->type == MPD_INFO_ENTITY_TYPE_SONG)
|
|
{
|
|
Song *s = new Song(item->info.song);
|
|
item->info.song = 0;
|
|
v.push_back(s);
|
|
}
|
|
mpd_freeInfoEntity(item);
|
|
}
|
|
mpd_finishCommand(itsConnection);
|
|
}
|
|
}
|
|
|
|
void Connection::GetSongs(const std::string &path, SongList &v) const
|
|
{
|
|
if (isConnected)
|
|
{
|
|
mpd_sendLsInfoCommand(itsConnection, path.c_str());
|
|
while (mpd_InfoEntity *item = mpd_getNextInfoEntity(itsConnection))
|
|
{
|
|
if (item->type == MPD_INFO_ENTITY_TYPE_SONG)
|
|
{
|
|
Song *s = new Song(item->info.song);
|
|
item->info.song = 0;
|
|
v.push_back(s);
|
|
}
|
|
mpd_freeInfoEntity(item);
|
|
}
|
|
mpd_finishCommand(itsConnection);
|
|
}
|
|
}
|
|
|
|
void Connection::GetDirectories(const std::string &path, TagList &v) const
|
|
{
|
|
if (isConnected)
|
|
{
|
|
mpd_sendLsInfoCommand(itsConnection, path.c_str());
|
|
while (mpd_InfoEntity *item = mpd_getNextInfoEntity(itsConnection))
|
|
{
|
|
if (item->type == MPD_INFO_ENTITY_TYPE_DIRECTORY)
|
|
v.push_back(item->info.directory->path);
|
|
mpd_freeInfoEntity(item);
|
|
}
|
|
mpd_finishCommand(itsConnection);
|
|
}
|
|
}
|
|
|
|
void Connection::GetOutputs(OutputList &v) const
|
|
{
|
|
if (!isConnected)
|
|
return;
|
|
mpd_sendOutputsCommand(itsConnection);
|
|
while (mpd_OutputEntity *output = mpd_getNextOutput(itsConnection))
|
|
{
|
|
v.push_back(std::make_pair(output->name, output->enabled));
|
|
mpd_freeOutputElement(output);
|
|
}
|
|
mpd_finishCommand(itsConnection);
|
|
}
|
|
|
|
bool Connection::EnableOutput(int id)
|
|
{
|
|
if (!isConnected)
|
|
return false;
|
|
mpd_sendEnableOutputCommand(itsConnection, id);
|
|
mpd_finishCommand(itsConnection);
|
|
return !CheckForErrors();
|
|
}
|
|
|
|
bool Connection::DisableOutput(int id)
|
|
{
|
|
if (!isConnected)
|
|
return false;
|
|
mpd_sendDisableOutputCommand(itsConnection, id);
|
|
mpd_finishCommand(itsConnection);
|
|
return !CheckForErrors();
|
|
}
|
|
|
|
int Connection::CheckForErrors()
|
|
{
|
|
itsErrorCode = 0;
|
|
if (itsConnection->error)
|
|
{
|
|
itsErrorMessage = itsConnection->errorStr;
|
|
if (itsConnection->error == MPD_ERROR_ACK)
|
|
{
|
|
// this is to avoid setting too small max size as we check it before fetching current status
|
|
// setting real max playlist length is in UpdateStatus()
|
|
if (itsConnection->errorCode == MPD_ACK_ERROR_PLAYLIST_MAX && itsMaxPlaylistLength == size_t(-1))
|
|
itsMaxPlaylistLength = 0;
|
|
|
|
if (itsErrorHandler)
|
|
itsErrorHandler(this, itsConnection->errorCode, itsConnection->errorStr, itsErrorHandlerUserdata);
|
|
itsErrorCode = itsConnection->errorCode;
|
|
}
|
|
else
|
|
{
|
|
if (itsErrorHandler)
|
|
itsErrorHandler(this, itsConnection->error, itsConnection->errorStr, itsErrorHandlerUserdata);
|
|
itsErrorCode = itsConnection->error;
|
|
Disconnect(); // the rest of errors are fatal to connection
|
|
}
|
|
if (itsConnection)
|
|
mpd_clearError(itsConnection);
|
|
}
|
|
return itsErrorCode;
|
|
}
|
|
|
|
void MPD::FreeSongList(SongList &l)
|
|
{
|
|
for (SongList::iterator i = l.begin(); i != l.end(); ++i)
|
|
delete *i;
|
|
l.clear();
|
|
}
|
|
|
|
void MPD::FreeItemList(ItemList &l)
|
|
{
|
|
for (ItemList::iterator i = l.begin(); i != l.end(); ++i)
|
|
delete i->song;
|
|
l.clear();
|
|
}
|
|
|