waybar/src/modules/battery.cpp

191 lines
6.3 KiB
C++
Raw Normal View History

2018-08-08 23:54:58 +02:00
#include "modules/battery.hpp"
2019-05-19 01:44:45 +02:00
#include <spdlog/spdlog.h>
2018-08-08 23:54:58 +02:00
2018-12-18 17:30:54 +01:00
waybar::modules::Battery::Battery(const std::string& id, const Json::Value& config)
2019-04-18 17:52:00 +02:00
: ALabel(config, "{capacity}%", 60) {
2018-12-18 17:30:54 +01:00
label_.set_name("battery");
if (!id.empty()) {
label_.get_style_context()->add_class(id);
}
getBatteries();
2018-08-19 13:39:57 +02:00
fd_ = inotify_init1(IN_CLOEXEC);
if (fd_ == -1) {
2018-08-13 14:05:13 +02:00
throw std::runtime_error("Unable to listen batteries.");
2018-08-16 14:29:41 +02:00
}
2018-09-04 23:50:08 +02:00
for (auto const& bat : batteries_) {
auto wd = inotify_add_watch(fd_, (bat / "uevent").c_str(), IN_ACCESS);
if (wd != -1) {
wds_.push_back(wd);
}
2018-08-16 14:29:41 +02:00
}
2018-08-20 14:50:45 +02:00
worker();
}
2019-04-18 17:52:00 +02:00
waybar::modules::Battery::~Battery() {
for (auto wd : wds_) {
inotify_rm_watch(fd_, wd);
}
2018-08-20 14:50:45 +02:00
close(fd_);
}
2019-04-18 17:52:00 +02:00
void waybar::modules::Battery::worker() {
2018-11-23 11:57:37 +01:00
thread_timer_ = [this] {
dp.emit();
2018-12-24 08:50:58 +01:00
thread_timer_.sleep_for(interval_);
};
2018-08-19 13:39:57 +02:00
thread_ = [this] {
2018-08-17 14:24:00 +02:00
struct inotify_event event = {0};
2019-04-18 17:52:00 +02:00
int nbytes = read(fd_, &event, sizeof(event));
if (nbytes != sizeof(event) || event.mask & IN_IGNORED) {
thread_.stop();
2018-08-13 14:05:13 +02:00
return;
2018-08-16 14:29:41 +02:00
}
// TODO: don't stop timer for now since there is some bugs :?
2018-11-16 10:02:12 +01:00
// thread_timer_.stop();
2018-08-20 14:50:45 +02:00
dp.emit();
2018-08-08 23:54:58 +02:00
};
}
2019-04-18 17:52:00 +02:00
void waybar::modules::Battery::getBatteries() {
try {
for (auto& node : fs::directory_iterator(data_dir_)) {
if (!fs::is_directory(node)) {
continue;
}
auto dir_name = node.path().filename();
auto bat_defined = config_["bat"].isString();
2019-04-18 17:52:00 +02:00
if (((bat_defined && dir_name == config_["bat"].asString()) || !bat_defined) &&
fs::exists(node.path() / "capacity") && fs::exists(node.path() / "uevent") &&
fs::exists(node.path() / "status")) {
batteries_.push_back(node.path());
}
auto adap_defined = config_["adapter"].isString();
2019-04-18 17:52:00 +02:00
if (((adap_defined && dir_name == config_["adapter"].asString()) || !adap_defined) &&
fs::exists(node.path() / "online")) {
adapter_ = node.path();
}
}
2019-04-18 17:52:00 +02:00
} catch (fs::filesystem_error& e) {
throw std::runtime_error(e.what());
}
if (batteries_.empty()) {
if (config_["bat"].isString()) {
throw std::runtime_error("No battery named " + config_["bat"].asString());
}
throw std::runtime_error("No batteries.");
}
}
const std::tuple<uint8_t, float, std::string> waybar::modules::Battery::getInfos() const {
2018-08-08 23:54:58 +02:00
try {
2019-04-18 17:52:00 +02:00
uint16_t total = 0;
2019-05-22 10:09:05 +02:00
uint32_t total_power = 0; // μW
uint32_t total_energy = 0; // μWh
uint32_t total_energy_full = 0;
2018-11-02 22:50:01 +01:00
std::string status = "Unknown";
2018-09-04 23:50:08 +02:00
for (auto const& bat : batteries_) {
2019-04-18 17:52:00 +02:00
uint16_t capacity;
uint32_t power_now;
uint32_t energy_full;
uint32_t energy_now;
std::string _status;
2018-08-09 11:21:08 +02:00
std::ifstream(bat / "capacity") >> capacity;
std::ifstream(bat / "status") >> _status;
2019-05-22 10:06:54 +02:00
auto rate_path = fs::exists(bat / "current_now") ? "current_now" : "power_now";
std::ifstream(bat / rate_path) >> power_now;
auto now_path = fs::exists(bat / "charge_now") ? "charge_now" : "energy_now";
std::ifstream(bat / now_path) >> energy_now;
auto full_path = fs::exists(bat / "charge_full") ? "charge_full" : "energy_full";
std::ifstream(bat / full_path) >> energy_full;
2018-08-16 14:29:41 +02:00
if (_status != "Unknown") {
status = _status;
2018-08-16 14:29:41 +02:00
}
2018-08-13 14:05:13 +02:00
total += capacity;
total_power += power_now;
total_energy += energy_now;
total_energy_full += energy_full;
2018-08-08 23:54:58 +02:00
}
2019-05-17 10:59:54 +02:00
if (!adapter_.empty() && status == "Discharging") {
bool online;
std::ifstream(adapter_ / "online") >> online;
if (online) {
status = "Plugged";
}
2019-05-14 15:43:57 +02:00
}
float time_remaining = 0;
if (status == "Discharging" && total_power != 0) {
2019-05-22 10:09:05 +02:00
time_remaining = (float)total_energy / total_power;
} else if (status == "Charging" && total_power != 0) {
2019-05-22 10:09:05 +02:00
time_remaining = -(float)(total_energy_full - total_energy) / total_power;
}
2019-05-17 10:59:54 +02:00
uint16_t capacity = total / batteries_.size();
return {capacity, time_remaining, status};
} catch (const std::exception& e) {
2019-05-22 10:09:05 +02:00
spdlog::error("Battery: {}", e.what());
return {0, 0, "Unknown"};
}
}
2019-05-22 10:09:05 +02:00
const std::string waybar::modules::Battery::getAdapterStatus(uint8_t capacity) const {
if (!adapter_.empty()) {
bool online;
std::ifstream(adapter_ / "online") >> online;
if (capacity == 100) {
return "Full";
}
2019-05-14 15:43:57 +02:00
if (online) {
2019-05-17 10:59:54 +02:00
return "Charging";
2019-05-14 15:43:57 +02:00
}
return "Discharging";
}
return "Unknown";
}
const std::string waybar::modules::Battery::formatTimeRemaining(float hoursRemaining) {
2019-05-22 10:09:05 +02:00
hoursRemaining = std::fabs(hoursRemaining);
uint16_t full_hours = static_cast<uint16_t>(hoursRemaining);
uint16_t minutes = static_cast<uint16_t>(60 * (hoursRemaining - full_hours));
return std::to_string(full_hours) + " h " + std::to_string(minutes) + " min";
}
2019-04-18 17:52:00 +02:00
auto waybar::modules::Battery::update() -> void {
auto [capacity, time_remaining, status] = getInfos();
2018-12-24 12:17:07 +01:00
if (status == "Unknown") {
status = getAdapterStatus(capacity);
2018-12-24 12:17:07 +01:00
}
2019-02-22 11:35:26 +01:00
if (tooltipEnabled()) {
std::string tooltip_text;
if (time_remaining != 0) {
2019-05-22 10:09:05 +02:00
std::string time_to = std::string("Time to ") + ((time_remaining > 0) ? "empty" : "full");
tooltip_text = time_to + ": " + formatTimeRemaining(time_remaining);
} else {
2019-05-22 10:09:05 +02:00
tooltip_text = status;
}
label_.set_tooltip_text(tooltip_text);
2019-02-22 11:35:26 +01:00
}
std::transform(status.begin(), status.end(), status.begin(), ::tolower);
auto format = format_;
auto state = getState(capacity, true);
2019-05-14 15:43:57 +02:00
if (!old_status_.empty()) {
label_.get_style_context()->remove_class(old_status_);
}
label_.get_style_context()->add_class(status);
old_status_ = status;
if (!state.empty() && config_["format-" + status + "-" + state].isString()) {
format = config_["format-" + status + "-" + state].asString();
2018-11-02 22:50:01 +01:00
} else if (config_["format-" + status].isString()) {
format = config_["format-" + status].asString();
2018-11-02 22:50:01 +01:00
} else if (!state.empty() && config_["format-" + state].isString()) {
format = config_["format-" + state].asString();
}
if (format.empty()) {
event_box_.hide();
} else {
event_box_.show();
2019-05-22 10:09:05 +02:00
label_.set_markup(fmt::format(format,
fmt::arg("capacity", capacity),
fmt::arg("icon", getIcon(capacity, state)),
fmt::arg("time", formatTimeRemaining(time_remaining))));
2018-08-08 23:54:58 +02:00
}
}