waybar/src/modules/battery.cpp

481 lines
16 KiB
C++
Raw Normal View History

2018-08-08 23:54:58 +02:00
#include "modules/battery.hpp"
2020-05-22 21:23:04 +02:00
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)
: ALabel(config, "battery", id, "{capacity}%", 60) {
battery_watch_fd_ = inotify_init1(IN_CLOEXEC);
if (battery_watch_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
}
global_watch_fd_ = inotify_init1(IN_CLOEXEC);
if (global_watch_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
}
// Watch the directory for any added or removed batteries
global_watch = inotify_add_watch(global_watch_fd_, data_dir_.c_str(), IN_CREATE | IN_DELETE);
if (global_watch < 0) {
throw std::runtime_error("Could not watch for battery plug/unplug");
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() {
std::lock_guard<std::mutex> guard(battery_list_mutex_);
if (global_watch >= 0) {
inotify_rm_watch(global_watch_fd_, global_watch);
}
close(global_watch_fd_);
for (auto it = batteries_.cbegin(); it != batteries_.cend(); it++) {
auto watch_id = (*it).second;
if (watch_id >= 0) {
inotify_rm_watch(battery_watch_fd_, watch_id);
}
batteries_.erase(it);
}
close(battery_watch_fd_);
2018-08-20 14:50:45 +02:00
}
2019-04-18 17:52:00 +02:00
void waybar::modules::Battery::worker() {
2018-11-23 11:57:37 +01:00
thread_timer_ = [this] {
// Make sure we eventually update the list of batteries even if we miss an
// inotify event for some reason
refreshBatteries();
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};
2022-04-06 08:37:19 +02:00
int nbytes = read(battery_watch_fd_, &event, sizeof(event));
if (nbytes != sizeof(event) || event.mask & IN_IGNORED) {
thread_.stop();
return;
}
dp.emit();
};
thread_battery_update_ = [this] {
struct inotify_event event = {0};
2022-04-06 08:37:19 +02:00
int nbytes = read(global_watch_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
}
refreshBatteries();
2018-08-20 14:50:45 +02:00
dp.emit();
2018-08-08 23:54:58 +02:00
};
}
void waybar::modules::Battery::refreshBatteries() {
std::lock_guard<std::mutex> guard(battery_list_mutex_);
// Mark existing list of batteries as not necessarily found
std::map<fs::path, bool> check_map;
for (auto const& bat : batteries_) {
check_map[bat.first] = false;
}
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() / "charge_now")) &&
fs::exists(node.path() / "uevent") && fs::exists(node.path() / "status") &&
fs::exists(node.path() / "type")) {
std::string type;
std::ifstream(node.path() / "type") >> type;
2022-04-06 08:37:19 +02:00
if (!type.compare("Battery")) {
check_map[node.path()] = true;
auto search = batteries_.find(node.path());
if (search == batteries_.end()) {
// We've found a new battery save it and start listening for events
auto event_path = (node.path() / "uevent");
auto wd = inotify_add_watch(battery_watch_fd_, event_path.c_str(), IN_ACCESS);
if (wd < 0) {
throw std::runtime_error("Could not watch events for " + node.path().string());
}
batteries_[node.path()] = wd;
}
}
}
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 (warnFirstTime_ && batteries_.empty()) {
if (config_["bat"].isString()) {
spdlog::warn("No battery named {0}", config_["bat"].asString());
} else {
spdlog::warn("No batteries.");
}
warnFirstTime_ = false;
}
// Remove any batteries that are no longer present and unwatch them
for (auto const& check : check_map) {
if (!check.second) {
auto watch_id = batteries_[check.first];
if (watch_id >= 0) {
inotify_rm_watch(battery_watch_fd_, watch_id);
}
batteries_.erase(check.first);
}
}
}
// Unknown > Full > Not charging > Discharging > Charging
static bool status_gt(const std::string& a, const std::string& b) {
2022-04-06 08:37:19 +02:00
if (a == b)
return false;
else if (a == "Unknown")
return true;
else if (a == "Full" && b != "Unknown")
return true;
else if (a == "Not charging" && b != "Unknown" && b != "Full")
return true;
else if (a == "Discharging" && b != "Unknown" && b != "Full" && b != "Not charging")
return true;
return false;
}
2021-01-24 21:39:14 +01:00
const std::tuple<uint8_t, float, std::string, float> waybar::modules::Battery::getInfos() {
std::lock_guard<std::mutex> guard(battery_list_mutex_);
2018-08-08 23:54:58 +02:00
try {
2022-04-06 08:37:19 +02:00
uint32_t total_power = 0; // μW
2022-09-02 11:42:46 +02:00
bool total_power_exists = false;
2022-04-06 08:37:19 +02:00
uint32_t total_energy = 0; // μWh
2022-09-02 11:42:46 +02:00
bool total_energy_exists = false;
2022-04-06 08:37:19 +02:00
uint32_t total_energy_full = 0;
2022-09-02 11:42:46 +02:00
bool total_energy_full_exists = false;
2022-04-06 08:37:19 +02:00
uint32_t total_energy_full_design = 0;
2022-09-02 11:42:46 +02:00
bool total_energy_full_design_exists = false;
2022-04-06 08:37:19 +02:00
uint32_t total_capacity{0};
2022-09-02 11:42:46 +02:00
bool total_capacity_exists = false;
2018-11-02 22:50:01 +01:00
std::string status = "Unknown";
for (auto const& item : batteries_) {
auto bat = item.first;
std::string _status;
std::getline(std::ifstream(bat / "status"), _status);
// Some battery will report current and charge in μA/μAh.
// Scale these by the voltage to get μW/μWh.
2022-09-02 11:42:46 +02:00
uint32_t capacity;
bool capacity_exists;
if (fs::exists(bat / "capacity")) {
capacity_exists = true;
std::ifstream(bat / "capacity") >> capacity;
} else {
capacity_exists = false;
capacity = 0;
}
uint32_t current_now;
bool current_now_exists;
if (fs::exists(bat / "current_now")) {
current_now_exists = true;
std::ifstream(bat / "current_now") >> current_now;
} else if (fs::exists(bat / "current_avg")) {
current_now_exists = true;
std::ifstream(bat / "current_avg") >> current_now;
} else {
current_now_exists = false;
current_now = 0;
}
uint32_t voltage_now;
bool voltage_now_exists;
if (fs::exists(bat / "voltage_now")) {
voltage_now_exists = true;
std::ifstream(bat / "voltage_now") >> voltage_now;
} else if (fs::exists(bat / "voltage_avg")) {
voltage_now_exists = true;
std::ifstream(bat / "voltage_avg") >> voltage_now;
} else {
voltage_now_exists = false;
voltage_now = 0;
}
uint32_t charge_full;
bool charge_full_exists;
if (fs::exists(bat / "charge_full")) {
charge_full_exists = true;
std::ifstream(bat / "charge_full") >> charge_full;
2022-09-02 11:42:46 +02:00
} else {
charge_full_exists = false;
charge_full = 0;
}
uint32_t charge_full_design;
bool charge_full_design_exists;
if (fs::exists(bat / "charge_full_design")) {
charge_full_design_exists = true;
std::ifstream(bat / "charge_full_design") >> charge_full_design;
2022-09-02 11:42:46 +02:00
} else {
charge_full_design_exists = false;
charge_full_design = 0;
}
uint32_t charge_now;
bool charge_now_exists;
if (fs::exists(bat / "charge_now")) {
charge_now_exists = true;
std::ifstream(bat / "charge_now") >> charge_now;
} else if (capacity_exists && charge_full_exists) {
// charge_now is missing on some systems, estimate using capacity and charge_full.
charge_now_exists = true; // this could be debatably set to false (same for all properties below)
charge_now = (capacity * charge_full) / 100;
} else {
charge_now_exists = false;
charge_now = 0;
}
uint32_t power_now;
bool power_now_exists;
if (fs::exists(bat / "power_now")) {
power_now_exists = true;
2022-04-06 08:37:19 +02:00
std::ifstream(bat / "power_now") >> power_now;
2022-09-02 11:42:46 +02:00
} else if (current_now_exists && voltage_now_exists) {
power_now_exists = true;
power_now = ((uint64_t)current_now * (uint64_t)voltage_now) / 1000000;
} else {
2022-09-02 11:42:46 +02:00
power_now_exists = false;
2022-04-06 08:37:19 +02:00
power_now = 0;
2022-09-02 11:42:46 +02:00
}
uint32_t energy_now;
bool energy_now_exists;
if (fs::exists(bat / "energy_now")) {
energy_now_exists = true;
std::ifstream(bat / "energy_now") >> energy_now;
} else if (charge_now_exists && voltage_now_exists) {
energy_now_exists = true;
energy_now = ((uint64_t)charge_now * (uint64_t)voltage_now) / 1000000;
} else {
energy_now_exists = false;
2022-04-06 08:37:19 +02:00
energy_now = 0;
2022-09-02 11:42:46 +02:00
}
uint32_t energy_full;
bool energy_full_exists;
if (fs::exists(bat / "energy_full")) {
energy_full_exists = true;
std::ifstream(bat / "energy_full") >> energy_full;
} else if (charge_full_exists && voltage_now_exists) {
energy_full_exists = true;
energy_full = ((uint64_t)charge_full * (uint64_t)voltage_now) / 1000000;
} else {
energy_full_exists = false;
2022-04-06 08:37:19 +02:00
energy_full = 0;
2022-09-02 11:42:46 +02:00
}
uint32_t energy_full_design;
bool energy_full_design_exists;
if (fs::exists(bat / "energy_full_design")) {
energy_full_design_exists = true;
std::ifstream(bat / "energy_full_design") >> energy_full_design;
} else if (charge_full_design_exists && voltage_now_exists) {
energy_full_design_exists = true;
energy_full_design = ((uint64_t)charge_full_design * (uint64_t)voltage_now) / 1000000;
} else {
energy_full_design_exists = false;
energy_full_design = 0;
}
// Show the "smallest" status among all batteries
2022-09-02 11:42:46 +02:00
if (status_gt(status, _status))
status = _status;
2022-09-02 11:42:46 +02:00
if (power_now_exists) {
total_power_exists = true;
total_power += power_now;
}
if (energy_now_exists) {
total_energy_exists = true;
total_energy += energy_now;
}
if (energy_full_exists) {
total_energy_full_exists = true;
total_energy_full += energy_full;
}
if (energy_full_design_exists) {
total_energy_full_design_exists = true;
total_energy_full_design += energy_full_design;
}
if (capacity_exists) {
total_capacity_exists = true;
total_capacity += capacity;
2018-08-16 14:29:41 +02:00
}
2018-08-08 23:54:58 +02:00
}
2022-09-02 11:42:46 +02:00
2019-05-17 10:59:54 +02:00
if (!adapter_.empty() && status == "Discharging") {
bool online;
2022-09-02 11:42:46 +02:00
if (fs::exists(adapter_ / "online"))
std::ifstream(adapter_ / "online") >> online;
else
online = false;
if (online)
2019-05-17 10:59:54 +02:00
status = "Plugged";
2019-05-14 15:43:57 +02:00
}
2022-09-02 11:42:46 +02:00
float time_remaining{0.0f};
if (status == "Discharging" && total_power_exists && total_energy_exists) {
if (total_power != 0)
time_remaining = (float)total_energy / total_power;
} else if (status == "Charging" && total_energy_exists && total_energy_full_exists && total_power_exists) {
if (total_power != 0)
time_remaining = -(float)(total_energy_full - total_energy) / total_power;
// If we've turned positive it means the battery is past 100% and so just report that as no time remaining
if (time_remaining > 0.0f)
time_remaining = 0.0f;
}
2022-09-02 11:42:46 +02:00
float calculated_capacity{0.0f};
if (total_capacity_exists) {
if (total_capacity > 0.0f)
calculated_capacity = (float)total_capacity;
else if (total_energy_full_exists && total_energy_exists) {
if (total_energy_full > 0.0f)
calculated_capacity = ((float)total_energy * 100.0f / (float)total_energy_full);
}
}
2022-09-02 11:42:46 +02:00
// Handle design-capacity
2022-09-02 11:42:46 +02:00
if ((config_["design-capacity"].isBool() ? config_["design-capacity"].asBool() : false) && total_energy_exists && total_energy_full_design_exists) {
if (total_energy_full_design > 0.0f)
calculated_capacity = ((float)total_energy * 100.0f / (float)total_energy_full_design);
}
2022-09-02 11:42:46 +02:00
// Handle full-at
if (config_["full-at"].isUInt()) {
auto full_at = config_["full-at"].asUInt();
2022-09-02 11:42:46 +02:00
if (full_at < 100)
calculated_capacity = 100.f * calculated_capacity / full_at;
}
2022-09-02 11:42:46 +02:00
// Handle it gracefully by clamping at 100%
// This can happen when the battery is calibrating and goes above 100%
if (calculated_capacity > 100.f)
calculated_capacity = 100.f;
uint8_t cap = round(calculated_capacity);
// If we've reached 100% just mark as full as some batteries can stay stuck reporting they're still charging but not yet done
if (cap == 100 && status == "Charging")
status = "Full";
2021-01-24 21:39:14 +01:00
return {cap, time_remaining, status, total_power / 1e6};
} catch (const std::exception& e) {
2019-05-22 10:09:05 +02:00
spdlog::error("Battery: {}", e.what());
2021-01-24 21:39:14 +01:00
return {0, 0, "Unknown", 0};
}
}
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) {
return "Plugged";
2019-05-14 15:43:57 +02:00
}
return "Discharging";
}
return "Unknown";
}
const std::string waybar::modules::Battery::formatTimeRemaining(float hoursRemaining) {
hoursRemaining = std::fabs(hoursRemaining);
2019-05-22 10:09:05 +02:00
uint16_t full_hours = static_cast<uint16_t>(hoursRemaining);
uint16_t minutes = static_cast<uint16_t>(60 * (hoursRemaining - full_hours));
2022-04-06 08:37:19 +02:00
auto format = std::string("{H} h {M} min");
if (full_hours == 0 && minutes == 0) {
// Migh as well not show "0h 0min"
return "";
}
if (config_["format-time"].isString()) {
format = config_["format-time"].asString();
}
return fmt::format(format, fmt::arg("H", full_hours), fmt::arg("M", minutes));
}
2019-04-18 17:52:00 +02:00
auto waybar::modules::Battery::update() -> void {
if (batteries_.empty()) {
event_box_.hide();
return;
}
2021-01-24 21:39:14 +01:00
auto [capacity, time_remaining, status, power] = getInfos();
2018-12-24 12:17:07 +01:00
if (status == "Unknown") {
status = getAdapterStatus(capacity);
2018-12-24 12:17:07 +01:00
}
2020-08-19 23:11:16 +02:00
auto status_pretty = status;
2020-05-22 21:23:04 +02:00
// Transform to lowercase and replace space with dash
2022-04-06 08:37:19 +02:00
std::transform(status.begin(), status.end(), status.begin(),
[](char ch) { return ch == ' ' ? '-' : std::tolower(ch); });
auto format = format_;
auto state = getState(capacity, true);
2020-08-19 23:11:16 +02:00
auto time_remaining_formatted = formatTimeRemaining(time_remaining);
if (tooltipEnabled()) {
std::string tooltip_text_default;
std::string tooltip_format = "{timeTo}";
2020-08-19 23:11:16 +02:00
if (time_remaining != 0) {
std::string time_to = std::string("Time to ") + ((time_remaining > 0) ? "empty" : "full");
tooltip_text_default = time_to + ": " + time_remaining_formatted;
} else {
tooltip_text_default = status_pretty;
}
if (!state.empty() && config_["tooltip-format-" + status + "-" + state].isString()) {
tooltip_format = config_["tooltip-format-" + status + "-" + state].asString();
} else if (config_["tooltip-format-" + status].isString()) {
tooltip_format = config_["tooltip-format-" + status].asString();
} else if (!state.empty() && config_["tooltip-format-" + state].isString()) {
tooltip_format = config_["tooltip-format-" + state].asString();
} else if (config_["tooltip-format"].isString()) {
tooltip_format = config_["tooltip-format"].asString();
}
2022-04-06 08:37:19 +02:00
label_.set_tooltip_text(fmt::format(tooltip_format, fmt::arg("timeTo", tooltip_text_default),
2020-08-19 23:11:16 +02:00
fmt::arg("capacity", capacity),
fmt::arg("time", time_remaining_formatted)));
}
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();
2020-05-22 21:23:04 +02:00
auto icons = std::vector<std::string>{status + "-" + state, status, state};
2022-04-06 08:37:19 +02:00
label_.set_markup(fmt::format(format, fmt::arg("capacity", capacity), fmt::arg("power", power),
2020-05-22 21:23:04 +02:00
fmt::arg("icon", getIcon(capacity, icons)),
2020-08-19 23:11:16 +02:00
fmt::arg("time", time_remaining_formatted)));
2018-08-08 23:54:58 +02:00
}
2020-04-12 18:30:21 +02:00
// Call parent update
ALabel::update();
2018-08-08 23:54:58 +02:00
}