2019-04-16 16:34:37 +02:00
|
|
|
#include "modules/mpd.hpp"
|
|
|
|
|
|
|
|
#include <iostream>
|
|
|
|
|
|
|
|
waybar::modules::MPD::MPD(const std::string& id, const Json::Value &config)
|
2019-04-17 11:01:35 +02:00
|
|
|
: ALabel(config, "{album} - {artist} - {title}", 5),
|
|
|
|
server_(nullptr),
|
|
|
|
port_(config["port"].asUInt()),
|
2019-04-16 16:34:37 +02:00
|
|
|
connection_(nullptr, &mpd_connection_free),
|
2019-04-17 16:16:39 +02:00
|
|
|
alternate_connection_(nullptr, &mpd_connection_free),
|
2019-04-16 16:34:37 +02:00
|
|
|
status_(nullptr, &mpd_status_free),
|
|
|
|
song_(nullptr, &mpd_song_free) {
|
|
|
|
label_.set_name("mpd");
|
|
|
|
if (!id.empty()) {
|
|
|
|
label_.get_style_context()->add_class(id);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!config["server"].isNull()) {
|
2019-04-17 11:01:35 +02:00
|
|
|
server_ = config["server"].asCString();
|
2019-04-16 16:34:37 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
worker_ = worker();
|
2019-04-17 16:16:39 +02:00
|
|
|
|
|
|
|
event_box_.add_events(Gdk::BUTTON_PRESS_MASK);
|
|
|
|
event_box_.signal_button_press_event().connect(
|
|
|
|
sigc::mem_fun(*this, &MPD::handlePlayPause));
|
2019-04-16 16:34:37 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
auto waybar::modules::MPD::update() -> void {
|
|
|
|
tryConnect();
|
|
|
|
|
|
|
|
if (connection_ != nullptr) {
|
|
|
|
try {
|
|
|
|
fetchState();
|
|
|
|
} catch (std::exception e) {
|
|
|
|
stopped_ = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
setLabel();
|
|
|
|
}
|
|
|
|
|
|
|
|
std::thread waybar::modules::MPD::worker() {
|
|
|
|
return std::thread([this] () {
|
|
|
|
while (true) {
|
|
|
|
if (connection_ == nullptr) {
|
|
|
|
// Retry periodically if no connection
|
|
|
|
update();
|
2019-04-17 11:01:35 +02:00
|
|
|
std::this_thread::sleep_for(interval_);
|
2019-04-16 16:34:37 +02:00
|
|
|
} else {
|
|
|
|
// Else, update on any event
|
|
|
|
waitForEvent();
|
|
|
|
update();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
void waybar::modules::MPD::setLabel() {
|
|
|
|
if (connection_ == nullptr) {
|
|
|
|
label_.get_style_context()->add_class("disconnected");
|
|
|
|
// In the case connection closed while MPD is stopped
|
|
|
|
label_.get_style_context()->remove_class("stopped");
|
|
|
|
|
|
|
|
auto format = config_["format-disconnected"].isString() ?
|
|
|
|
config_["format-disconnected"].asString() : "disconnected";
|
|
|
|
label_.set_markup(format);
|
2019-04-17 10:46:08 +02:00
|
|
|
|
|
|
|
if (tooltipEnabled()) {
|
|
|
|
std::string tooltip_format;
|
|
|
|
tooltip_format = config_["tooltip-format-disconnected"].isString() ?
|
|
|
|
config_["tooltip-format-disconnected"].asString() : "MPD (disconnected)";
|
|
|
|
// Nothing to format
|
|
|
|
label_.set_tooltip_text(tooltip_format);
|
|
|
|
}
|
2019-04-16 16:34:37 +02:00
|
|
|
return;
|
|
|
|
} else {
|
|
|
|
label_.get_style_context()->remove_class("disconnected");
|
|
|
|
}
|
|
|
|
|
|
|
|
auto format = format_;
|
|
|
|
|
|
|
|
std::string artist, album_artist, album, title, date;
|
|
|
|
|
2019-04-17 13:55:08 +02:00
|
|
|
std::string stateIcon = "";
|
2019-04-16 16:34:37 +02:00
|
|
|
if (stopped_) {
|
|
|
|
format = config_["format-stopped"].isString() ?
|
|
|
|
config_["format-stopped"].asString() : "stopped";
|
|
|
|
label_.get_style_context()->add_class("stopped");
|
|
|
|
} else {
|
|
|
|
label_.get_style_context()->remove_class("stopped");
|
|
|
|
|
2019-04-17 13:55:08 +02:00
|
|
|
stateIcon = getStateIcon();
|
|
|
|
|
2019-04-16 16:34:37 +02:00
|
|
|
artist = mpd_song_get_tag(song_.get(), MPD_TAG_ARTIST, 0);
|
|
|
|
album_artist = mpd_song_get_tag(song_.get(), MPD_TAG_ALBUM_ARTIST, 0);
|
|
|
|
album = mpd_song_get_tag(song_.get(), MPD_TAG_ALBUM, 0);
|
|
|
|
title = mpd_song_get_tag(song_.get(), MPD_TAG_TITLE, 0);
|
|
|
|
date = mpd_song_get_tag(song_.get(), MPD_TAG_DATE, 0);
|
|
|
|
}
|
|
|
|
|
2019-04-17 15:09:06 +02:00
|
|
|
bool consumeActivated = mpd_status_get_consume(status_.get());
|
|
|
|
std::string consumeIcon = getOptionIcon("consume", consumeActivated);
|
|
|
|
bool randomActivated = mpd_status_get_random(status_.get());
|
|
|
|
std::string randomIcon = getOptionIcon("random", randomActivated);
|
|
|
|
bool repeatActivated = mpd_status_get_repeat(status_.get());
|
|
|
|
std::string repeatIcon = getOptionIcon("repeat", repeatActivated);
|
|
|
|
bool singleActivated = mpd_status_get_single(status_.get());
|
|
|
|
std::string singleIcon = getOptionIcon("single", singleActivated);
|
|
|
|
|
2019-04-17 13:55:08 +02:00
|
|
|
// TODO: format can fail
|
2019-04-16 16:34:37 +02:00
|
|
|
label_.set_markup(fmt::format(format,
|
|
|
|
fmt::arg("artist", artist),
|
2019-04-17 13:55:08 +02:00
|
|
|
fmt::arg("albumArtist", album_artist),
|
2019-04-16 16:34:37 +02:00
|
|
|
fmt::arg("album", album),
|
|
|
|
fmt::arg("title", title),
|
2019-04-17 13:55:08 +02:00
|
|
|
fmt::arg("date", date),
|
2019-04-17 15:09:06 +02:00
|
|
|
fmt::arg("stateIcon", stateIcon),
|
|
|
|
fmt::arg("consumeIcon", consumeIcon),
|
|
|
|
fmt::arg("randomIcon", randomIcon),
|
|
|
|
fmt::arg("repeatIcon", repeatIcon),
|
|
|
|
fmt::arg("singleIcon", singleIcon)));
|
2019-04-16 16:34:37 +02:00
|
|
|
|
|
|
|
if (tooltipEnabled()) {
|
|
|
|
std::string tooltip_format;
|
|
|
|
tooltip_format = config_["tooltip-format"].isString() ?
|
2019-04-17 10:46:08 +02:00
|
|
|
config_["tooltip-format"].asString() : "MPD (connected)";
|
2019-04-16 16:34:37 +02:00
|
|
|
auto tooltip_text = fmt::format(tooltip_format,
|
|
|
|
fmt::arg("artist", artist),
|
2019-04-17 13:55:08 +02:00
|
|
|
fmt::arg("albumArtist", album_artist),
|
2019-04-16 16:34:37 +02:00
|
|
|
fmt::arg("album", album),
|
|
|
|
fmt::arg("title", title),
|
2019-04-17 13:55:08 +02:00
|
|
|
fmt::arg("date", date),
|
2019-04-17 15:09:06 +02:00
|
|
|
fmt::arg("stateIcon", stateIcon),
|
|
|
|
fmt::arg("consumeIcon", consumeIcon),
|
|
|
|
fmt::arg("randomIcon", randomIcon),
|
|
|
|
fmt::arg("repeatIcon", repeatIcon),
|
|
|
|
fmt::arg("singleIcon", singleIcon));
|
2019-04-16 16:34:37 +02:00
|
|
|
label_.set_tooltip_text(tooltip_text);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-04-17 13:55:08 +02:00
|
|
|
std::string waybar::modules::MPD::getStateIcon() {
|
|
|
|
if (!config_["state-icons"].isObject()) {
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
|
|
|
if (connection_ == nullptr) {
|
|
|
|
std::cerr << "MPD: Trying to fetch state icon while disconnected" << std::endl;
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
|
|
|
if (stopped_) {
|
|
|
|
std::cerr << "MPD: Trying to fetch state icon while stopped" << std::endl;
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
|
|
|
if (state_ == MPD_STATE_PLAY) {
|
|
|
|
return config_["state-icons"]["playing"].asString();
|
|
|
|
} else {
|
|
|
|
// MPD_STATE_PAUSE
|
|
|
|
return config_["state-icons"]["paused"].asString();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-04-17 15:09:06 +02:00
|
|
|
std::string waybar::modules::MPD::getOptionIcon(std::string optionName, bool activated) {
|
|
|
|
if (!config_[optionName + "-icons"].isObject()) {
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
|
|
|
if (connection_ == nullptr) {
|
|
|
|
std::cerr << "MPD: Trying to fetch option icon while disconnected" << std::endl;
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
|
|
|
if (activated) {
|
|
|
|
return config_[optionName + "-icons"]["on"].asString();
|
|
|
|
} else {
|
|
|
|
return config_[optionName + "-icons"]["off"].asString();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-04-16 16:34:37 +02:00
|
|
|
void waybar::modules::MPD::tryConnect() {
|
|
|
|
if (connection_ != nullptr) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
connection_ = unique_connection(
|
2019-04-17 11:01:35 +02:00
|
|
|
mpd_connection_new(server_, port_, 5'000),
|
2019-04-16 16:34:37 +02:00
|
|
|
&mpd_connection_free);
|
|
|
|
|
2019-04-17 16:16:39 +02:00
|
|
|
alternate_connection_ = unique_connection(
|
|
|
|
mpd_connection_new(server_, port_, 5'000),
|
|
|
|
&mpd_connection_free);
|
|
|
|
|
|
|
|
if (connection_ == nullptr || alternate_connection_ == nullptr) {
|
2019-04-16 16:34:37 +02:00
|
|
|
std::cerr << "Failed to connect to MPD" << std::endl;
|
2019-04-17 16:16:39 +02:00
|
|
|
connection_.reset();
|
|
|
|
alternate_connection_.reset();
|
2019-04-16 16:34:37 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
try {
|
|
|
|
checkErrors();
|
|
|
|
} catch (std::runtime_error e) {
|
|
|
|
std::cerr << "Failed to connect to MPD: " << e.what() << std::endl;
|
|
|
|
connection_.reset();
|
2019-04-17 16:16:39 +02:00
|
|
|
alternate_connection_.reset();
|
2019-04-16 16:34:37 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
void waybar::modules::MPD::checkErrors() {
|
|
|
|
auto conn = connection_.get();
|
|
|
|
|
|
|
|
switch (mpd_connection_get_error(conn)) {
|
|
|
|
case MPD_ERROR_SUCCESS:
|
|
|
|
return;
|
|
|
|
case MPD_ERROR_CLOSED:
|
|
|
|
std::cerr << "Connection to MPD closed" << std::endl;
|
|
|
|
mpd_connection_clear_error(conn);
|
|
|
|
connection_.reset();
|
2019-04-17 16:16:39 +02:00
|
|
|
alternate_connection_.reset();
|
2019-04-16 16:34:37 +02:00
|
|
|
return;
|
|
|
|
default:
|
|
|
|
auto error_message = mpd_connection_get_error_message(conn);
|
|
|
|
mpd_connection_clear_error(conn);
|
|
|
|
throw std::runtime_error(std::string(error_message));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void waybar::modules::MPD::fetchState() {
|
|
|
|
status_ = unique_status(mpd_run_status(connection_.get()), &mpd_status_free);
|
|
|
|
checkErrors();
|
2019-04-17 13:55:08 +02:00
|
|
|
state_ = mpd_status_get_state(status_.get());
|
2019-04-16 16:34:37 +02:00
|
|
|
checkErrors();
|
2019-04-17 13:55:08 +02:00
|
|
|
stopped_ = state_ == MPD_STATE_UNKNOWN || state_ == MPD_STATE_STOP;
|
2019-04-16 16:34:37 +02:00
|
|
|
|
2019-04-17 15:09:06 +02:00
|
|
|
song_ = unique_song(mpd_run_current_song(connection_.get()), &mpd_song_free);
|
2019-04-16 16:34:37 +02:00
|
|
|
checkErrors();
|
|
|
|
}
|
|
|
|
|
|
|
|
void waybar::modules::MPD::waitForEvent() {
|
|
|
|
auto conn = connection_.get();
|
2019-04-17 15:09:06 +02:00
|
|
|
// Wait for a player (play/pause), option (random, shuffle, etc.), or playlist change
|
|
|
|
mpd_run_idle_mask(conn, static_cast<mpd_idle>(MPD_IDLE_PLAYER | MPD_IDLE_OPTIONS | MPD_IDLE_PLAYLIST));
|
2019-04-16 16:34:37 +02:00
|
|
|
checkErrors();
|
|
|
|
}
|
2019-04-17 16:16:39 +02:00
|
|
|
|
|
|
|
bool waybar::modules::MPD::handlePlayPause(GdkEventButton* const& e) {
|
|
|
|
if (e->type == GDK_2BUTTON_PRESS || e->type == GDK_3BUTTON_PRESS || alternate_connection_ == nullptr) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (e->button == 1) {
|
|
|
|
if (stopped_) {
|
|
|
|
mpd_run_play(alternate_connection_.get());
|
|
|
|
} else {
|
|
|
|
mpd_run_toggle_pause(alternate_connection_.get());
|
|
|
|
}
|
|
|
|
} else if (e->button == 3) {
|
|
|
|
mpd_run_stop(alternate_connection_.get());
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|