src/mpdpp.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2008-2014 by Andrzej Rybczak                            *
   3  *   electricityispower@gmail.com                                          *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.              *
  19  ***************************************************************************/
  20
  21 #include <cassert>
  22 #include <cstdlib>
  23 #include <algorithm>
  24 #include <map>
  25
  26 #include "charset.h"
  27 #include "error.h"
  28 #include "mpdpp.h"
  29
  30 MPD::Connection Mpd;
  31
  32 namespace MPD {//
  33
  34 Connection::Connection() : m_connection(nullptr),
  35                                 m_command_list_active(false),
  36                                 m_idle(false),
  37                                 m_host("localhost"),
  38                                 m_port(6600),
  39                                 m_timeout(15)
  40 {
  41 }
  42
  43 Connection::~Connection()
  44 {
  45         if (m_connection)
  46                 mpd_connection_free(m_connection);
  47 }
  48
  49 void Connection::Connect()
  50 {
  51         assert(!m_connection);
  52         try
  53         {
  54                 m_connection = mpd_connection_new(m_host.c_str(), m_port, m_timeout * 1000);
  55                 checkErrors();
  56                 if (!m_password.empty())
  57                         SendPassword();
  58                 m_fd = mpd_connection_get_fd(m_connection);
  59                 checkErrors();
  60         }
  61         catch (MPD::ClientError &e)
  62         {
  63                 Disconnect();
  64                 throw e;
  65         }
  66 }
  67
  68 bool Connection::Connected() const
  69 {
  70         return m_connection;
  71 }
  72
  73 void Connection::Disconnect()
  74 {
  75         if (m_connection)
  76                 mpd_connection_free(m_connection);
  77         m_connection = nullptr;
  78         m_command_list_active = false;
  79         m_idle = false;
  80 }
  81
  82 unsigned Connection::Version() const
  83 {
  84         return m_connection ? mpd_connection_get_server_version(m_connection)[1] : 0;
  85 }
  86
  87 void Connection::SetHostname(const std::string &host)
  88 {
  89         size_t at = host.find("@");
  90         if (at != std::string::npos)
  91         {
  92                 m_password = host.substr(0, at);
  93                 m_host = host.substr(at+1);
  94         }
  95         else
  96                 m_host = host;
  97 }
  98
  99 void Connection::SendPassword()
 100 {
 101         assert(m_connection);
 102         noidle();
 103         assert(!m_command_list_active);
 104         mpd_run_password(m_connection, m_password.c_str());
 105         checkErrors();
 106 }
 107
 108 void Connection::idle()
 109 {
 110         checkConnection();
 111         if (!m_idle)
 112         {
 113                 mpd_send_idle(m_connection);
 114                 checkErrors();
 115         }
 116         m_idle = true;
 117 }
 118
 119 int Connection::noidle()
 120 {
 121         checkConnection();
 122         int flags = 0;
 123         if (m_idle && mpd_send_noidle(m_connection))
 124         {
 125                 m_idle = false;
 126                 flags = mpd_recv_idle(m_connection, true);
 127                 mpd_response_finish(m_connection);
 128                 checkErrors();
 129         }
 130         return flags;
 131 }
 132
 133 Statistics Connection::getStatistics()
 134 {
 135         prechecks();
 136         mpd_stats *stats = mpd_run_stats(m_connection);
 137         checkErrors();
 138         return Statistics(stats);
 139 }
 140
 141 Status Connection::getStatus()
 142 {
 143         prechecks();
 144         mpd_status *status = mpd_run_status(m_connection);
 145         checkErrors();
 146         return Status(status);
 147 }
 148
 149 void Connection::UpdateDirectory(const std::string &path)
 150 {
 151         prechecksNoCommandsList();
 152         mpd_run_update(m_connection, path.c_str());
 153         checkErrors();
 154 }
 155
 156 void Connection::Play()
 157 {
 158         prechecksNoCommandsList();
 159         mpd_run_play(m_connection);
 160         checkErrors();
 161 }
 162
 163 void Connection::Play(int pos)
 164 {
 165         prechecksNoCommandsList();
 166         mpd_run_play_pos(m_connection, pos);
 167         checkErrors();
 168 }
 169
 170 void Connection::PlayID(int id)
 171 {
 172         prechecksNoCommandsList();
 173         mpd_run_play_id(m_connection, id);
 174         checkErrors();
 175 }
 176
 177 void Connection::Pause(bool state)
 178 {
 179         prechecksNoCommandsList();
 180         mpd_run_pause(m_connection, state);
 181         checkErrors();
 182 }
 183
 184 void Connection::Toggle()
 185 {
 186         prechecksNoCommandsList();
 187         mpd_run_toggle_pause(m_connection);
 188         checkErrors();
 189 }
 190
 191 void Connection::Stop()
 192 {
 193         prechecksNoCommandsList();
 194         mpd_run_stop(m_connection);
 195         checkErrors();
 196 }
 197
 198 void Connection::Next()
 199 {
 200         prechecksNoCommandsList();
 201         mpd_run_next(m_connection);
 202         checkErrors();
 203 }
 204
 205 void Connection::Prev()
 206 {
 207         prechecksNoCommandsList();
 208         mpd_run_previous(m_connection);
 209         checkErrors();
 210 }
 211
 212 void Connection::Move(unsigned from, unsigned to)
 213 {
 214         prechecks();
 215         if (m_command_list_active)
 216                 mpd_send_move(m_connection, from, to);
 217         else
 218         {
 219                 mpd_run_move(m_connection, from, to);
 220                 checkErrors();
 221         }
 222 }
 223
 224 void Connection::Swap(unsigned from, unsigned to)
 225 {
 226         prechecks();
 227         if (m_command_list_active)
 228                 mpd_send_swap(m_connection, from, to);
 229         else
 230         {
 231                 mpd_run_swap(m_connection, from, to);
 232                 checkErrors();
 233         }
 234 }
 235
 236 void Connection::Seek(unsigned pos, unsigned where)
 237 {
 238         prechecksNoCommandsList();
 239         mpd_run_seek_pos(m_connection, pos, where);
 240         checkErrors();
 241 }
 242
 243 void Connection::Shuffle()
 244 {
 245         prechecksNoCommandsList();
 246         mpd_run_shuffle(m_connection);
 247         checkErrors();
 248 }
 249
 250 void Connection::ClearMainPlaylist()
 251 {
 252         prechecksNoCommandsList();
 253         mpd_run_clear(m_connection);
 254         checkErrors();
 255 }
 256
 257 void Connection::ClearPlaylist(const std::string &playlist)
 258 {
 259         prechecksNoCommandsList();
 260         mpd_run_playlist_clear(m_connection, playlist.c_str());
 261         checkErrors();
 262 }
 263
 264 void Connection::AddToPlaylist(const std::string &path, const Song &s)
 265 {
 266         AddToPlaylist(path, s.getURI());
 267 }
 268
 269 void Connection::AddToPlaylist(const std::string &path, const std::string &file)
 270 {
 271         prechecks();
 272         if (m_command_list_active)
 273                 mpd_send_playlist_add(m_connection, path.c_str(), file.c_str());
 274         else
 275         {
 276                 mpd_run_playlist_add(m_connection, path.c_str(), file.c_str());
 277                 checkErrors();
 278         }
 279 }
 280
 281 void Connection::PlaylistMove(const std::string &path, int from, int to)
 282 {
 283         prechecks();
 284         if (m_command_list_active)
 285                 mpd_send_playlist_move(m_connection, path.c_str(), from, to);
 286         else
 287         {
 288                 mpd_send_playlist_move(m_connection, path.c_str(), from, to);
 289                 mpd_response_finish(m_connection);
 290                 checkErrors();
 291         }
 292 }
 293
 294 void Connection::Rename(const std::string &from, const std::string &to)
 295 {
 296         prechecksNoCommandsList();
 297         mpd_run_rename(m_connection, from.c_str(), to.c_str());
 298         checkErrors();
 299 }
 300
 301 void Connection::GetPlaylistChanges(unsigned version, SongConsumer f)
 302 {
 303         prechecksNoCommandsList();
 304         mpd_send_queue_changes_meta(m_connection, version);
 305         while (mpd_song *s = mpd_recv_song(m_connection))
 306                 f(Song(s));
 307         mpd_response_finish(m_connection);
 308         checkErrors();
 309 }
 310
 311 Song Connection::GetSong(const std::string &path)
 312 {
 313         prechecksNoCommandsList();
 314         mpd_send_list_all_meta(m_connection, path.c_str());
 315         mpd_song *s = mpd_recv_song(m_connection);
 316         mpd_response_finish(m_connection);
 317         checkErrors();
 318         return Song(s);
 319 }
 320
 321 void Connection::GetPlaylistContent(const std::string &path, SongConsumer f)
 322 {
 323         prechecksNoCommandsList();
 324         mpd_send_list_playlist_meta(m_connection, path.c_str());
 325         while (mpd_song *s = mpd_recv_song(m_connection))
 326                 f(Song(s));
 327         mpd_response_finish(m_connection);
 328         checkErrors();
 329 }
 330
 331 void Connection::GetPlaylistContentNoInfo(const std::string &path, SongConsumer f)
 332 {
 333         prechecksNoCommandsList();
 334         mpd_send_list_playlist(m_connection, path.c_str());
 335         while (mpd_song *s = mpd_recv_song(m_connection))
 336                 f(Song(s));
 337         mpd_response_finish(m_connection);
 338         checkErrors();
 339 }
 340
 341 void Connection::GetSupportedExtensions(std::set<std::string> &acc)
 342 {
 343         prechecksNoCommandsList();
 344         mpd_send_command(m_connection, "decoders", NULL);
 345         while (mpd_pair *pair = mpd_recv_pair_named(m_connection, "suffix"))
 346         {
 347                 acc.insert(pair->value);
 348                 mpd_return_pair(m_connection, pair);
 349         }
 350         mpd_response_finish(m_connection);
 351         checkErrors();
 352 }
 353
 354 void Connection::SetRepeat(bool mode)
 355 {
 356         prechecksNoCommandsList();
 357         mpd_run_repeat(m_connection, mode);
 358         checkErrors();
 359 }
 360
 361 void Connection::SetRandom(bool mode)
 362 {
 363         prechecksNoCommandsList();
 364         mpd_run_random(m_connection, mode);
 365         checkErrors();
 366 }
 367
 368 void Connection::SetSingle(bool mode)
 369 {
 370         prechecksNoCommandsList();
 371         mpd_run_single(m_connection, mode);
 372         checkErrors();
 373 }
 374
 375 void Connection::SetConsume(bool mode)
 376 {
 377         prechecksNoCommandsList();
 378         mpd_run_consume(m_connection, mode);
 379         checkErrors();
 380 }
 381
 382 void Connection::SetVolume(unsigned vol)
 383 {
 384         prechecksNoCommandsList();
 385         mpd_run_set_volume(m_connection, vol);
 386         checkErrors();
 387 }
 388
 389 std::string Connection::GetReplayGainMode()
 390 {
 391         prechecksNoCommandsList();
 392         mpd_send_command(m_connection, "replay_gain_status", NULL);
 393         std::string result;
 394         if (mpd_pair *pair = mpd_recv_pair_named(m_connection, "replay_gain_mode"))
 395         {
 396                 result = pair->value;
 397                 mpd_return_pair(m_connection, pair);
 398         }
 399         mpd_response_finish(m_connection);
 400         checkErrors();
 401         return result;
 402 }
 403
 404 void Connection::SetReplayGainMode(ReplayGainMode mode)
 405 {
 406         prechecksNoCommandsList();
 407         const char *rg_mode;
 408         switch (mode)
 409         {
 410                 case rgmOff:
 411                         rg_mode = "off";
 412                         break;
 413                 case rgmTrack:
 414                         rg_mode = "track";
 415                         break;
 416                 case rgmAlbum:
 417                         rg_mode = "album";
 418                         break;
 419                 default:
 420                         rg_mode = "";
 421                         break;
 422         }
 423         mpd_send_command(m_connection, "replay_gain_mode", rg_mode, NULL);
 424         mpd_response_finish(m_connection);
 425         checkErrors();
 426 }
 427
 428 void Connection::SetCrossfade(unsigned crossfade)
 429 {
 430         prechecksNoCommandsList();
 431         mpd_run_crossfade(m_connection, crossfade);
 432         checkErrors();
 433 }
 434
 435 void Connection::SetPriority(const Song &s, int prio)
 436 {
 437         prechecks();
 438         if (m_command_list_active)
 439                 mpd_send_prio_id(m_connection, prio, s.getID());
 440         else
 441         {
 442                 mpd_run_prio_id(m_connection, prio, s.getID());
 443                 checkErrors();
 444         }
 445 }
 446
 447 int Connection::AddSong(const std::string &path, int pos)
 448 {
 449         prechecks();
 450         int id;
 451         if (pos < 0)
 452                 mpd_send_add_id(m_connection, path.c_str());
 453         else
 454                 mpd_send_add_id_to(m_connection, path.c_str(), pos);
 455         if (!m_command_list_active)
 456         {
 457                 id = mpd_recv_song_id(m_connection);
 458                 mpd_response_finish(m_connection);
 459                 checkErrors();
 460         }
 461         else
 462                 id = 0;
 463         return id;
 464 }
 465
 466 int Connection::AddSong(const Song &s, int pos)
 467 {
 468         return AddSong((!s.isFromDatabase() ? "file://" : "") + s.getURI(), pos);
 469 }
 470
 471 void Connection::Add(const std::string &path)
 472 {
 473         prechecks();
 474         if (m_command_list_active)
 475                 mpd_send_add(m_connection, path.c_str());
 476         else
 477         {
 478                 mpd_run_add(m_connection, path.c_str());
 479                 checkErrors();
 480         }
 481 }
 482
 483 bool Connection::AddRandomTag(mpd_tag_type tag, size_t number)
 484 {
 485         StringList tags;
 486         GetList(tag, [&tags](std::string tag_name) {
 487                 tags.push_back(tag_name);
 488         });
 489         if (number > tags.size())
 490         {
 491                 //if (itsErrorHandler)
 492                 //      itsErrorHandler(this, 0, "Requested number is out of range", itsErrorHandlerUserdata);
 493                 return false;
 494         }
 495         else
 496         {
 497                 std::random_shuffle(tags.begin(), tags.end());
 498                 auto it = tags.begin()+rand()%(tags.size()-number);
 499                 for (size_t i = 0; i < number && it != tags.end(); ++i)
 500                 {
 501                         StartSearch(1);
 502                         AddSearch(tag, *it++);
 503                         SongList songs;
 504                         CommitSearchSongs([&songs](MPD::Song s) {
 505                                 songs.push_back(s);
 506                         });
 507                         StartCommandsList();
 508                         for (auto s = songs.begin(); s != songs.end(); ++s)
 509                                 AddSong(*s);
 510                         CommitCommandsList();
 511                 }
 512         }
 513         return true;
 514 }
 515
 516 bool Connection::AddRandomSongs(size_t number)
 517 {
 518         prechecksNoCommandsList();
 519         StringList files;
 520         mpd_send_list_all(m_connection, "/");
 521         while (mpd_pair *item = mpd_recv_pair_named(m_connection, "file"))
 522         {
 523                 files.push_back(item->value);
 524                 mpd_return_pair(m_connection, item);
 525         }
 526         mpd_response_finish(m_connection);
 527         checkErrors();
 528
 529         if (number > files.size())
 530         {
 531                 //if (itsErrorHandler)
 532                 //      itsErrorHandler(this, 0, "Requested number of random songs is bigger than size of your library", itsErrorHandlerUserdata);
 533                 return false;
 534         }
 535         else
 536         {
 537                 std::random_shuffle(files.begin(), files.end());
 538                 StartCommandsList();
 539                 auto it = files.begin()+rand()%(std::max(size_t(1), files.size()-number));
 540                 for (size_t i = 0; i < number && it != files.end(); ++i, ++it)
 541                         AddSong(*it);
 542                 CommitCommandsList();
 543         }
 544         return true;
 545 }
 546
 547 void Connection::Delete(unsigned pos)
 548 {
 549         prechecks();
 550         mpd_send_delete(m_connection, pos);
 551         if (!m_command_list_active)
 552         {
 553                 mpd_response_finish(m_connection);
 554                 checkErrors();
 555         }
 556 }
 557
 558 void Connection::PlaylistDelete(const std::string &playlist, unsigned pos)
 559 {
 560         prechecks();
 561         mpd_send_playlist_delete(m_connection, playlist.c_str(), pos);
 562         if (!m_command_list_active)
 563         {
 564                 mpd_response_finish(m_connection);
 565                 checkErrors();
 566         }
 567 }
 568
 569 void Connection::StartCommandsList()
 570 {
 571         prechecksNoCommandsList();
 572         mpd_command_list_begin(m_connection, true);
 573         m_command_list_active = true;
 574         checkErrors();
 575 }
 576
 577 void Connection::CommitCommandsList()
 578 {
 579         prechecks();
 580         assert(m_command_list_active);
 581         mpd_command_list_end(m_connection);
 582         mpd_response_finish(m_connection);
 583         m_command_list_active = false;
 584         checkErrors();
 585 }
 586
 587 void Connection::DeletePlaylist(const std::string &name)
 588 {
 589         prechecksNoCommandsList();
 590         mpd_run_rm(m_connection, name.c_str());
 591         checkErrors();
 592 }
 593
 594 void Connection::LoadPlaylist(const std::string &name)
 595 {
 596         prechecksNoCommandsList();
 597         mpd_run_load(m_connection, name.c_str());
 598         checkErrors();
 599 }
 600
 601 void Connection::SavePlaylist(const std::string &name)
 602 {
 603         prechecksNoCommandsList();
 604         mpd_send_save(m_connection, name.c_str());
 605         mpd_response_finish(m_connection);
 606         checkErrors();
 607 }
 608
 609 void Connection::GetPlaylists(StringConsumer f)
 610 {
 611         GetDirectory("/", [&f](Item &&item) {
 612                 if (item.type == itPlaylist)
 613                         f(std::move(item.name));
 614         });
 615 }
 616
 617 void Connection::GetList(mpd_tag_type type, StringConsumer f)
 618 {
 619         prechecksNoCommandsList();
 620         mpd_search_db_tags(m_connection, type);
 621         mpd_search_commit(m_connection);
 622         while (mpd_pair *item = mpd_recv_pair_tag(m_connection, type))
 623         {
 624                 f(std::string(item->value));
 625                 mpd_return_pair(m_connection, item);
 626         }
 627         mpd_response_finish(m_connection);
 628         checkErrors();
 629 }
 630
 631 void Connection::StartSearch(bool exact_match)
 632 {
 633         prechecksNoCommandsList();
 634         mpd_search_db_songs(m_connection, exact_match);
 635 }
 636
 637 void Connection::StartFieldSearch(mpd_tag_type item)
 638 {
 639         prechecksNoCommandsList();
 640         mpd_search_db_tags(m_connection, item);
 641 }
 642
 643 void Connection::AddSearch(mpd_tag_type item, const std::string &str) const
 644 {
 645         checkConnection();
 646         mpd_search_add_tag_constraint(m_connection, MPD_OPERATOR_DEFAULT, item, str.c_str());
 647 }
 648
 649 void Connection::AddSearchAny(const std::string &str) const
 650 {
 651         checkConnection();
 652         mpd_search_add_any_tag_constraint(m_connection, MPD_OPERATOR_DEFAULT, str.c_str());
 653 }
 654
 655 void Connection::AddSearchURI(const std::string &str) const
 656 {
 657         checkConnection();
 658         mpd_search_add_uri_constraint(m_connection, MPD_OPERATOR_DEFAULT, str.c_str());
 659 }
 660
 661 void Connection::CommitSearchSongs(SongConsumer f)
 662 {
 663         prechecksNoCommandsList();
 664         mpd_search_commit(m_connection);
 665         while (mpd_song *s = mpd_recv_song(m_connection))
 666                 f(Song(s));
 667         mpd_response_finish(m_connection);
 668         checkErrors();
 669 }
 670
 671 void Connection::CommitSearchTags(StringConsumer f)
 672 {
 673         prechecksNoCommandsList();
 674         mpd_search_commit(m_connection);
 675         while (mpd_pair *tag = mpd_recv_pair_tag(m_connection, m_searched_field))
 676         {
 677                 f(std::string(tag->value));
 678                 mpd_return_pair(m_connection, tag);
 679         }
 680         mpd_response_finish(m_connection);
 681         checkErrors();
 682 }
 683
 684 void Connection::GetDirectory(const std::string &directory, ItemConsumer f)
 685 {
 686         prechecksNoCommandsList();
 687         mpd_send_list_meta(m_connection, directory.c_str());
 688         while (mpd_entity *item = mpd_recv_entity(m_connection))
 689         {
 690                 Item it;
 691                 switch (mpd_entity_get_type(item))
 692                 {
 693                         case MPD_ENTITY_TYPE_DIRECTORY:
 694                                 it.name = mpd_directory_get_path(mpd_entity_get_directory(item));
 695                                 it.type = itDirectory;
 696                                 break;
 697                         case MPD_ENTITY_TYPE_SONG:
 698                                 it.song = std::make_shared<Song>(Song(mpd_song_dup(mpd_entity_get_song(item))));
 699                                 it.type = itSong;
 700                                 break;
 701                         case MPD_ENTITY_TYPE_PLAYLIST:
 702                                 it.name = mpd_playlist_get_path(mpd_entity_get_playlist(item));
 703                                 it.type = itPlaylist;
 704                                 break;
 705                         default:
 706                                 assert(false);
 707                 }
 708                 mpd_entity_free(item);
 709                 f(std::move(it));
 710         }
 711         mpd_response_finish(m_connection);
 712         checkErrors();
 713 }
 714
 715 void Connection::GetDirectoryRecursive(const std::string &directory, SongConsumer f)
 716 {
 717         prechecksNoCommandsList();
 718         mpd_send_list_all_meta(m_connection, directory.c_str());
 719         while (mpd_entity *e = mpd_recv_entity(m_connection)) {
 720                 if (mpd_entity_get_type(e) == MPD_ENTITY_TYPE_SONG)
 721                         f(Song(mpd_song_dup(mpd_entity_get_song(e))));
 722                 mpd_entity_free(e);
 723         }
 724         mpd_response_finish(m_connection);
 725         checkErrors();
 726 }
 727
 728 void Connection::GetDirectories(const std::string &directory, StringConsumer f)
 729 {
 730         prechecksNoCommandsList();
 731         mpd_send_list_meta(m_connection, directory.c_str());
 732         while (mpd_directory *dir = mpd_recv_directory(m_connection))
 733         {
 734                 f(std::string(mpd_directory_get_path(dir)));
 735                 mpd_directory_free(dir);
 736         }
 737         mpd_response_finish(m_connection);
 738         checkErrors();
 739 }
 740
 741 void Connection::GetSongs(const std::string &directory, SongConsumer f)
 742 {
 743         prechecksNoCommandsList();
 744         mpd_send_list_meta(m_connection, directory.c_str());
 745         while (mpd_song *s = mpd_recv_song(m_connection))
 746                 f(Song(s));
 747         mpd_response_finish(m_connection);
 748         checkErrors();
 749 }
 750
 751 void Connection::GetOutputs(OutputConsumer f)
 752 {
 753         prechecksNoCommandsList();
 754         mpd_send_outputs(m_connection);
 755         while (mpd_output *output = mpd_recv_output(m_connection))
 756         {
 757                 f(Output(mpd_output_get_name(output), mpd_output_get_enabled(output)));
 758                 mpd_output_free(output);
 759         }
 760         mpd_response_finish(m_connection);
 761         checkErrors();
 762 }
 763
 764 void Connection::EnableOutput(int id)
 765 {
 766         prechecksNoCommandsList();
 767         mpd_run_enable_output(m_connection, id);
 768         checkErrors();
 769 }
 770
 771 void Connection::DisableOutput(int id)
 772 {
 773         prechecksNoCommandsList();
 774         mpd_run_disable_output(m_connection, id);
 775         checkErrors();
 776 }
 777
 778 void Connection::GetURLHandlers(StringConsumer f)
 779 {
 780         prechecksNoCommandsList();
 781         mpd_send_list_url_schemes(m_connection);
 782         while (mpd_pair *handler = mpd_recv_pair_named(m_connection, "handler"))
 783         {
 784                 f(std::string(handler->value));
 785                 mpd_return_pair(m_connection, handler);
 786         }
 787         mpd_response_finish(m_connection);
 788         checkErrors();
 789 }
 790
 791 void Connection::GetTagTypes(StringConsumer f)
 792 {
 793
 794         prechecksNoCommandsList();
 795         mpd_send_list_tag_types(m_connection);
 796         while (mpd_pair *tag_type = mpd_recv_pair_named(m_connection, "tagtype"))
 797         {
 798                 f(std::string(tag_type->value));
 799                 mpd_return_pair(m_connection, tag_type);
 800         }
 801         mpd_response_finish(m_connection);
 802         checkErrors();
 803 }
 804
 805 void Connection::checkConnection() const
 806 {
 807         if (!m_connection)
 808                 throw ClientError(MPD_ERROR_STATE, "No active MPD connection", false);
 809 }
 810
 811 void Connection::prechecks()
 812 {
 813         checkConnection();
 814         noidle();
 815 }
 816
 817 void Connection::prechecksNoCommandsList()
 818 {
 819         assert(!m_command_list_active);
 820         prechecks();
 821 }
 822
 823 void Connection::checkErrors() const
 824 {
 825         mpd_error code = mpd_connection_get_error(m_connection);
 826         if (code != MPD_ERROR_SUCCESS)
 827         {
 828                 std::string msg = mpd_connection_get_error_message(m_connection);
 829                 if (code == MPD_ERROR_SERVER)
 830                 {
 831                         mpd_server_error server_code = mpd_connection_get_server_error(m_connection);
 832                         bool clearable = mpd_connection_clear_error(m_connection);
 833                         throw ServerError(server_code, msg, clearable);
 834                 }
 835                 else
 836                 {
 837                         bool clearable = mpd_connection_clear_error(m_connection);
 838                         throw ClientError(code, msg, clearable);
 839                 }
 840         }
 841 }
 842
 843 }