Zander671/Waybar
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'master' into smooth-power

Browse Source
This commit is contained in:
Alexis Rouillard
2026-07-03 22:11:06 +02:00
committed by GitHub
parent 7f63a905a1 fbb9a7eccd
commit da91ca2457
206 changed files with 4685 additions and 2526 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/modules/battery.cpp
+98 -72
View File
@@ -125,17 +125,16 @@ void waybar::modules::Battery::refreshBatteries() {
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") || bat_compatibility) &&
fs::exists(node.path() / "type")) {
(fs::exists(node.path() / "status") || bat_compatibility)) {
std::string type;
std::ifstream(node.path() / "type") >> type;
if (!type.compare("Battery")) {
if (std::ifstream{node.path() / "type"} >> type && !type.compare("Battery")) {
// Ignore non-system power supplies unless explicitly requested
if (!bat_defined && fs::exists(node.path() / "scope")) {
if (!bat_defined) {
std::string scope;
std::ifstream(node.path() / "scope") >> scope;
if (g_ascii_strcasecmp(scope.data(), "device") == 0) {
// for hotplug-in device, access it is always unstable because you may remove the
// device anytime so just allow failure happen and do nothing
if (std::ifstream{node.path() / "scope"} >> scope &&
g_ascii_strcasecmp(scope.data(), "device") == 0) {
continue;
}
}
@@ -147,7 +146,9 @@ void waybar::modules::Battery::refreshBatteries() {
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());
spdlog::warn("Could not watch events for {} (device may have been removed)",
node.path().string());
continue;
}
batteries_[node.path()] = wd;
}
@@ -160,7 +161,7 @@ void waybar::modules::Battery::refreshBatteries() {
}
}
} catch (fs::filesystem_error& e) {
throw std::runtime_error(e.what());
spdlog::warn("Battery directory tracking failed: {}", e.what());
}
if (warnFirstTime_ && batteries_.empty()) {
if (config_["bat"].isString()) {
@@ -281,11 +282,11 @@ waybar::modules::Battery::getInfos() {
auto bat = item.first;
std::string _status;
/* Check for adapter status if battery is not available */
if (!std::ifstream(bat / "status")) {
std::getline(std::ifstream(adapter_ / "status"), _status);
} else {
std::getline(std::ifstream(bat / "status"), _status);
{
std::ifstream f{bat / "status"};
if (!std::getline(f, _status)) {
std::getline(std::ifstream(adapter_ / "status"), _status);
}
}
// Some battery will report current and charge in μA/μAh.
@@ -294,64 +295,74 @@ waybar::modules::Battery::getInfos() {
uint32_t current_now = 0;
int32_t _current_now_int = 0;
bool current_now_exists = false;
if (fs::exists(bat / "current_now")) {
current_now_exists = true;
std::ifstream(bat / "current_now") >> _current_now_int;
} else if (fs::exists(bat / "current_avg")) {
current_now_exists = true;
std::ifstream(bat / "current_avg") >> _current_now_int;
if (std::ifstream current_now_f{bat / "current_now"}) {
if (current_now_f >> _current_now_int) {
current_now_exists = true;
}
} else if (std::ifstream current_avg_f{bat / "current_avg"}) {
if (current_avg_f >> _current_now_int) {
current_now_exists = true;
}
}
// Documentation ABI allows a negative value when discharging, positive
// value when charging.
current_now = std::abs(_current_now_int);
if (fs::exists(bat / "time_to_empty_now")) {
time_to_empty_now_exists = true;
std::ifstream(bat / "time_to_empty_now") >> time_to_empty_now;
if (std::ifstream f{bat / "time_to_empty_now"}) {
if (f >> time_to_empty_now) {
time_to_empty_now_exists = true;
}
}
if (fs::exists(bat / "time_to_full_now")) {
time_to_full_now_exists = true;
std::ifstream(bat / "time_to_full_now") >> time_to_full_now;
if (std::ifstream f{bat / "time_to_full_now"}) {
if (f >> time_to_full_now) {
time_to_full_now_exists = true;
}
}
uint32_t voltage_now = 0;
bool voltage_now_exists = false;
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;
if (std::ifstream voltage_now_f{bat / "voltage_now"}) {
if (voltage_now_f >> voltage_now) {
voltage_now_exists = true;
}
} else if (std::ifstream voltage_avg_f{bat / "voltage_avg"}) {
if (voltage_avg_f >> voltage_now) {
voltage_now_exists = true;
}
}
uint32_t charge_full = 0;
bool charge_full_exists = false;
if (fs::exists(bat / "charge_full")) {
charge_full_exists = true;
std::ifstream(bat / "charge_full") >> charge_full;
if (std::ifstream f{bat / "charge_full"}) {
if (f >> charge_full) {
charge_full_exists = true;
}
}
uint32_t charge_full_design = 0;
bool charge_full_design_exists = false;
if (fs::exists(bat / "charge_full_design")) {
charge_full_design_exists = true;
std::ifstream(bat / "charge_full_design") >> charge_full_design;
if (std::ifstream f{bat / "charge_full_design"}) {
if (f >> charge_full_design) {
charge_full_design_exists = true;
}
}
uint32_t charge_now = 0;
bool charge_now_exists = false;
if (fs::exists(bat / "charge_now")) {
charge_now_exists = true;
std::ifstream(bat / "charge_now") >> charge_now;
if (std::ifstream f{bat / "charge_now"}) {
if (f >> charge_now) {
charge_now_exists = true;
}
}
uint32_t power_now = 0;
int32_t _power_now_int = 0;
bool power_now_exists = false;
if (fs::exists(bat / "power_now")) {
power_now_exists = true;
std::ifstream(bat / "power_now") >> _power_now_int;
if (std::ifstream f{bat / "power_now"}) {
if (f >> _power_now_int) {
power_now_exists = true;
}
}
// Some drivers (example: Qualcomm) exposes use a negative value when
// discharging, positive value when charging.
@@ -359,28 +370,31 @@ waybar::modules::Battery::getInfos() {
uint32_t energy_now = 0;
bool energy_now_exists = false;
if (fs::exists(bat / "energy_now")) {
energy_now_exists = true;
std::ifstream(bat / "energy_now") >> energy_now;
if (std::ifstream f{bat / "energy_now"}) {
if (f >> energy_now) {
energy_now_exists = true;
}
}
uint32_t energy_full = 0;
bool energy_full_exists = false;
if (fs::exists(bat / "energy_full")) {
energy_full_exists = true;
std::ifstream(bat / "energy_full") >> energy_full;
if (std::ifstream f{bat / "energy_full"}) {
if (f >> energy_full) {
energy_full_exists = true;
}
}
uint32_t energy_full_design = 0;
bool energy_full_design_exists = false;
if (fs::exists(bat / "energy_full_design")) {
energy_full_design_exists = true;
std::ifstream(bat / "energy_full_design") >> energy_full_design;
if (std::ifstream f{bat / "energy_full_design"}) {
if (f >> energy_full_design) {
energy_full_design_exists = true;
}
}
uint16_t cycleCount = 0;
if (fs::exists(bat / "cycle_count")) {
std::ifstream(bat / "cycle_count") >> cycleCount;
if (std::ifstream f{bat / "cycle_count"}) {
f >> cycleCount;
}
if (charge_full_design >= largestDesignCapacity) {
largestDesignCapacity = charge_full_design;
@@ -410,9 +424,10 @@ waybar::modules::Battery::getInfos() {
} else if (energy_now_exists && energy_full_exists && energy_full != 0) {
capacity_exists = true;
capacity = 100 * (uint64_t)energy_now / (uint64_t)energy_full;
} else if (fs::exists(bat / "capacity")) {
capacity_exists = true;
std::ifstream(bat / "capacity") >> capacity;
} else if (std::ifstream f{bat / "capacity"}) {
if (f >> capacity) {
capacity_exists = true;
}
}
if (!voltage_now_exists) {
@@ -612,11 +627,12 @@ waybar::modules::Battery::getInfos() {
float calculated_capacity{0.0f};
if (total_capacity_exists) {
if (total_capacity > 0.0f)
if (total_capacity > 0.0f) {
calculated_capacity = (float)total_capacity / batteries_.size();
else if (total_energy_full_exists && total_energy_exists) {
if (total_energy_full > 0.0f)
} 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);
}
}
}
@@ -713,13 +729,20 @@ auto waybar::modules::Battery::update() -> void {
if (status == "Unknown") {
status = getAdapterStatus(capacity);
}
auto state = getState(capacity, true);
bool adapter_online = false;
if (!adapter_.empty()) {
std::ifstream(adapter_ / "online") >> adapter_online;
}
if (config_["full-at-plugged"].asBool() && status == "Full" && adapter_online) {
status = "Plugged";
}
auto status_pretty = status;
puts(status.c_str());
// Transform to lowercase and replace space with dash
std::ranges::transform(status.begin(), status.end(), status.begin(),
[](char ch) { return ch == ' ' ? '-' : std::tolower(ch); });
auto format = format_;
auto state = getState(capacity, true);
processEvents(state, status, capacity);
setBarClass(state);
auto time_remaining_formatted = formatTimeRemaining(time_remaining);
@@ -818,16 +841,19 @@ void waybar::modules::Battery::processEvents(std::string& state, std::string& st
if (!events.isObject() || events.empty()) {
return;
}
std::string event_name = fmt::format("on-{}-{}", status == "discharging" ? status : "charging",
state.empty() ? std::to_string(capacity) : state);
auto exec = [](Json::Value const& event) {
if (!event.isString()) return;
if (auto command = event.asString(); !command.empty()) {
util::command::exec(command, "");
}
};
std::string status_name = status == "discharging" ? "on-discharging" : "on-charging";
std::string event_name = status_name + '-' + (state.empty() ? std::to_string(capacity) : state);
if (last_event_ != event_name) {
spdlog::debug("battery: triggering event {}", event_name);
if (events[event_name].isString()) {
std::string exec = events[event_name].asString();
// Execute the command if it is not empty
if (!exec.empty()) {
util::command::exec(exec, "");
}
exec(events[event_name]);
if (!last_event_.empty() && last_event_[3] != event_name[3]) {
exec(events[status_name]);
}
last_event_ = event_name;
}