Merge pull request #2971 from picnoir/pic/power-profiles-daemon

Introduce a power-profiles-daemon module

README.md

@@ -13,6 +13,7 @@
 - Local time
 - Battery
 - UPower
+- Power profiles daemon
 - Network
 - Bluetooth
 - Pulseaudio

include/modules/power_profiles_daemon.hpp

@@ -0,0 +1,46 @@
+#pragma once
+
+#include <fmt/format.h>
+
+#include "ALabel.hpp"
+#include "giomm/dbusproxy.h"
+
+namespace waybar::modules {
+
+struct Profile {
+  std::string name;
+  std::string driver;
+};
+
+class PowerProfilesDaemon : public ALabel {
+ public:
+  PowerProfilesDaemon(const std::string &, const Json::Value &);
+  auto update() -> void override;
+  void profileChangedCb(const Gio::DBus::Proxy::MapChangedProperties &,
+                        const std::vector<Glib::ustring> &);
+  void busConnectedCb(Glib::RefPtr<Gio::AsyncResult> &r);
+  void getAllPropsCb(Glib::RefPtr<Gio::AsyncResult> &r);
+  void setPropCb(Glib::RefPtr<Gio::AsyncResult> &r);
+  void populateInitState();
+  bool handleToggle(GdkEventButton *const &e) override;
+
+ private:
+  // True if we're connected to the dbug interface. False if we're
+  // not.
+  bool connected_;
+  // Look for a profile name in the list of available profiles and
+  // switch activeProfile_ to it.
+  void switchToProfile(std::string const &);
+  // Used to toggle/display the profiles
+  std::vector<Profile> availableProfiles_;
+  // Points to the active profile in the profiles list
+  std::vector<Profile>::iterator activeProfile_;
+  // Current CSS class applied to the label
+  std::string currentStyle_;
+  // Format string
+  std::string tooltipFormat_;
+  // DBus Proxy used to track the current active profile
+  Glib::RefPtr<Gio::DBus::Proxy> powerProfilesProxy_;
+};
+
+}  // namespace waybar::modules

man/waybar-power-profiles-daemon.5.scd

@@ -0,0 +1,72 @@
+waybar-power-profiles-daemon(5)
+
+# NAME
+
+waybar - power-profiles-daemon module
+
+# DESCRIPTION
+
+The *power-profiles-daemon* module displays the active power-profiles-daemon profile and cycle through the available profiles on click.
+
+# FILES
+
+$XDG_CONFIG_HOME/waybar/config
+
+# CONFIGURATION
+
+
+[- *Option*
+:- *Typeof*
+:- *Default*
+:= *Description*
+|[ *format*
+:[ string
+:[ "{icon}"
+:[ Message displayed on the bar. {icon} and {profile} are respectively substituted with the icon representing the active profile and its full name.
+|[ *tooltip-format*
+:[ string
+:[ "Power profile: {profile}\\nDriver: {driver}"
+:[ Messaged displayed in the module tooltip. {icon} and {profile} are respectively substituted with the icon representing the active profile and its full name.
+|[ *tooltip*
+:[ bool
+:[ true
+:[ Display the tooltip.
+|[ *format-icons*
+:[ object
+:[ See default value in the example below.
+:[ Icons used to represent the various power-profile. *Note*: the default configuration uses the font-awesome icons. You may want to override it if you don't have this font installed on your system.
+
+
+# CONFIGURATION EXAMPLES
+
+Compact display (default config):
+
+```
+"power-profiles-daemon": {
+  "format": "{icon}",
+  "tooltip-format": "Power profile: {profile}\nDriver: {driver}",
+  "tooltip": true,
+  "format-icons": {
+    "default": "",
+    "performance": "",
+    "balanced": "",
+    "power-saver": ""
+  }
+}
+```
+
+Display the full profile name:
+
+```
+"power-profiles-daemon": {
+  "format": "{icon}   {profile}",
+  "tooltip-format": "Power profile: {profile}\nDriver: {driver}",
+  "tooltip": true,
+  "format-icons": {
+    "default": "",
+    "performance": "",
+    "balanced": "",
+    "power-saver": ""
+  }
+}
+```

meson.build

@@ -212,6 +212,7 @@ if is_linux
         'src/modules/cpu_usage/linux.cpp',
         'src/modules/memory/common.cpp',
         'src/modules/memory/linux.cpp',
+        'src/modules/power_profiles_daemon.cpp',
         'src/modules/systemd_failed_units.cpp',
     )
     man_files += files(
@@ -221,6 +222,7 @@ if is_linux
         'man/waybar-cpu.5.scd',
         'man/waybar-memory.5.scd',
         'man/waybar-systemd-failed-units.5.scd',
+        'man/waybar-power-profiles-daemon.5.scd',
     )
 elif is_dragonfly or is_freebsd or is_netbsd or is_openbsd
     add_project_arguments('-DHAVE_CPU_BSD', language: 'cpp')
@@ -577,4 +579,3 @@ if clangtidy.found()
             '-p', meson.project_build_root()
         ] + src_files)
 endif
-

resources/config.jsonc

@@ -20,6 +20,7 @@
         "idle_inhibitor",
         "pulseaudio",
         "network",
+        "power-profiles-daemon",
         "cpu",
         "memory",
         "temperature",
@@ -147,6 +148,17 @@
     "battery#bat2": {
         "bat": "BAT2"
     },
+    "power-profiles-daemon": {
+      "format": "{icon}",
+      "tooltip-format": "Power profile: {profile}\nDriver: {driver}",
+      "tooltip": true,
+      "format-icons": {
+        "default": "",
+        "performance": "",
+        "balanced": "",
+        "power-saver": ""
+      }
+    },
     "network": {
         // "interface": "wlp2*", // (Optional) To force the use of this interface
         "format-wifi": "{essid} ({signalStrength}%) ",
@@ -188,4 +200,3 @@
         // "exec": "$HOME/.config/waybar/mediaplayer.py --player spotify 2> /dev/null" // Filter player based on name
     }
 }
-

resources/style.css

@@ -87,6 +87,7 @@ button:hover {
 #mode,
 #idle_inhibitor,
 #scratchpad,
+#power-profiles-daemon,
 #mpd {
     padding: 0 10px;
     color: #ffffff;
@@ -139,6 +140,25 @@ button:hover {
     animation-direction: alternate;
 }
 
+#power-profiles-daemon {
+    padding-right: 15px;
+}
+
+#power-profiles-daemon.performance {
+    background-color: #f53c3c;
+    color: #ffffff;
+}
+
+#power-profiles-daemon.balanced {
+    background-color: #2980b9;
+    color: #ffffff;
+}
+
+#power-profiles-daemon.power-saver {
+    background-color: #2ecc71;
+    color: #000000;
+}
+
 label:focus {
     background-color: #000000;
 }

src/factory.cpp

@@ -86,6 +86,7 @@
 #endif
 #if defined(__linux__)
 #include "modules/bluetooth.hpp"
+#include "modules/power_profiles_daemon.hpp"
 #endif
 #ifdef HAVE_LOGIND_INHIBITOR
 #include "modules/inhibitor.hpp"
@@ -282,6 +283,9 @@ waybar::AModule* waybar::Factory::makeModule(const std::string& name,
     if (ref == "bluetooth") {
       return new waybar::modules::Bluetooth(id, config_[name]);
     }
+    if (ref == "power-profiles-daemon") {
+      return new waybar::modules::PowerProfilesDaemon(id, config_[name]);
+    }
 #endif
 #ifdef HAVE_LOGIND_INHIBITOR
     if (ref == "inhibitor") {

src/modules/power_profiles_daemon.cpp

@@ -0,0 +1,206 @@
+#include "modules/power_profiles_daemon.hpp"
+
+#include <fmt/args.h>
+#include <glibmm.h>
+#include <glibmm/variant.h>
+#include <spdlog/spdlog.h>
+
+namespace waybar::modules {
+
+PowerProfilesDaemon::PowerProfilesDaemon(const std::string& id, const Json::Value& config)
+    : ALabel(config, "power-profiles-daemon", id, "{icon}", 0, false, true), connected_(false) {
+  if (config_["tooltip-format"].isString()) {
+    tooltipFormat_ = config_["tooltip-format"].asString();
+  } else {
+    tooltipFormat_ = "Power profile: {profile}\nDriver: {driver}";
+  }
+  // Fasten your seatbelt, we're up for quite a ride. The rest of the
+  // init is performed asynchronously. There's 2 callbacks involved.
+  // Here's the overall idea:
+  // 1. Async connect to the system bus.
+  // 2. In the system bus connect callback, try to call
+  //    org.freedesktop.DBus.Properties.GetAll to see if
+  //    power-profiles-daemon is able to respond.
+  // 3. In the GetAll callback, connect the activeProfile monitoring
+  //    callback, consider the init to be successful. Meaning start
+  //    drawing the module.
+  //
+  // There's sadly no other way around that, we have to try to call a
+  // method on the proxy to see whether or not something's responding
+  // on the other side.
+
+  // NOTE: the DBus adresses are under migration. They should be
+  // changed to org.freedesktop.UPower.PowerProfiles at some point.
+  //
+  // See
+  // https://gitlab.freedesktop.org/upower/power-profiles-daemon/-/releases/0.20
+  //
+  // The old name is still announced for now. Let's rather use the old
+  // adresses for compatibility sake.
+  //
+  // Revisit this in 2026, systems should be updated by then.
+  Gio::DBus::Proxy::create_for_bus(Gio::DBus::BusType::BUS_TYPE_SYSTEM, "net.hadess.PowerProfiles",
+                                   "/net/hadess/PowerProfiles", "net.hadess.PowerProfiles",
+                                   sigc::mem_fun(*this, &PowerProfilesDaemon::busConnectedCb));
+}
+
+void PowerProfilesDaemon::busConnectedCb(Glib::RefPtr<Gio::AsyncResult>& r) {
+  try {
+    powerProfilesProxy_ = Gio::DBus::Proxy::create_for_bus_finish(r);
+    using GetAllProfilesVar = Glib::Variant<std::tuple<Glib::ustring>>;
+    auto callArgs = GetAllProfilesVar::create(std::make_tuple("net.hadess.PowerProfiles"));
+    powerProfilesProxy_->call("org.freedesktop.DBus.Properties.GetAll",
+                              sigc::mem_fun(*this, &PowerProfilesDaemon::getAllPropsCb), callArgs);
+    // Connect active profile callback
+  } catch (const std::exception& e) {
+    spdlog::error("Failed to create the power profiles daemon DBus proxy: {}", e.what());
+  } catch (const Glib::Error& e) {
+    spdlog::error("Failed to create the power profiles daemon DBus proxy: {}",
+                  std::string(e.what()));
+  }
+}
+
+// Callback for the GetAll call.
+//
+// We're abusing this call to make sure power-profiles-daemon is
+// available on the host. We're not really using
+void PowerProfilesDaemon::getAllPropsCb(Glib::RefPtr<Gio::AsyncResult>& r) {
+  try {
+    auto _ = powerProfilesProxy_->call_finish(r);
+    // Power-profiles-daemon responded something, we can assume it's
+    // available, we can safely attach the activeProfile monitoring
+    // now.
+    connected_ = true;
+    powerProfilesProxy_->signal_properties_changed().connect(
+        sigc::mem_fun(*this, &PowerProfilesDaemon::profileChangedCb));
+    populateInitState();
+    dp.emit();
+  } catch (const std::exception& err) {
+    spdlog::error("Failed to query power-profiles-daemon via dbus: {}", err.what());
+  } catch (const Glib::Error& err) {
+    spdlog::error("Failed to query power-profiles-daemon via dbus: {}", std::string(err.what()));
+  }
+}
+
+void PowerProfilesDaemon::populateInitState() {
+  // Retrieve current active profile
+  Glib::Variant<std::string> profileStr;
+  powerProfilesProxy_->get_cached_property(profileStr, "ActiveProfile");
+
+  // Retrieve profiles list, it's aa{sv}.
+  using ProfilesType = std::vector<std::map<Glib::ustring, Glib::Variant<std::string>>>;
+  Glib::Variant<ProfilesType> profilesVariant;
+  powerProfilesProxy_->get_cached_property(profilesVariant, "Profiles");
+  for (auto& variantDict : profilesVariant.get()) {
+    Glib::ustring name;
+    Glib::ustring driver;
+    if (auto p = variantDict.find("Profile"); p != variantDict.end()) {
+      name = p->second.get();
+    }
+    if (auto d = variantDict.find("Driver"); d != variantDict.end()) {
+      driver = d->second.get();
+    }
+    if (!name.empty()) {
+      availableProfiles_.emplace_back(std::move(name), std::move(driver));
+    } else {
+      spdlog::error(
+          "Power profiles daemon: power-profiles-daemon sent us an empty power profile name. "
+          "Something is wrong.");
+    }
+  }
+
+  // Find the index of the current activated mode (to toggle)
+  std::string str = profileStr.get();
+  switchToProfile(str);
+
+  update();
+}
+
+void PowerProfilesDaemon::profileChangedCb(
+    const Gio::DBus::Proxy::MapChangedProperties& changedProperties,
+    const std::vector<Glib::ustring>& invalidatedProperties) {
+  // We're likely connected if this callback gets triggered.
+  // But better be safe than sorry.
+  if (connected_) {
+    if (auto activeProfileVariant = changedProperties.find("ActiveProfile");
+        activeProfileVariant != changedProperties.end()) {
+      std::string activeProfile =
+          Glib::VariantBase::cast_dynamic<Glib::Variant<std::string>>(activeProfileVariant->second)
+              .get();
+      switchToProfile(activeProfile);
+      update();
+    }
+  }
+}
+
+// Look for the profile str in our internal profiles list. Using a
+// vector to store the profiles ain't the smartest move
+// complexity-wise, but it makes toggling between the mode easy. This
+// vector is 3 elements max, we'll be fine :P
+void PowerProfilesDaemon::switchToProfile(std::string const& str) {
+  auto pred = [str](Profile const& p) { return p.name == str; };
+  this->activeProfile_ = std::find_if(availableProfiles_.begin(), availableProfiles_.end(), pred);
+  if (activeProfile_ == availableProfiles_.end()) {
+    spdlog::error(
+        "Power profile daemon: can't find the active profile {} in the available profiles list",
+        str);
+  }
+}
+
+auto PowerProfilesDaemon::update() -> void {
+  if (connected_ && activeProfile_ != availableProfiles_.end()) {
+    auto profile = (*activeProfile_);
+    // Set label
+    fmt::dynamic_format_arg_store<fmt::format_context> store;
+    store.push_back(fmt::arg("profile", profile.name));
+    store.push_back(fmt::arg("driver", profile.driver));
+    store.push_back(fmt::arg("icon", getIcon(0, profile.name)));
+    label_.set_markup(fmt::vformat(format_, store));
+    if (tooltipEnabled()) {
+      label_.set_tooltip_text(fmt::vformat(tooltipFormat_, store));
+    }
+
+    // Set CSS class
+    if (!currentStyle_.empty()) {
+      label_.get_style_context()->remove_class(currentStyle_);
+    }
+    label_.get_style_context()->add_class(profile.name);
+    currentStyle_ = profile.name;
+    event_box_.set_visible(true);
+  } else {
+    event_box_.set_visible(false);
+  }
+
+  ALabel::update();
+}
+
+bool PowerProfilesDaemon::handleToggle(GdkEventButton* const& e) {
+  if (e->type == GdkEventType::GDK_BUTTON_PRESS && connected_) {
+    activeProfile_++;
+    if (activeProfile_ == availableProfiles_.end()) {
+      activeProfile_ = availableProfiles_.begin();
+    }
+
+    using VarStr = Glib::Variant<Glib::ustring>;
+    using SetPowerProfileVar = Glib::Variant<std::tuple<Glib::ustring, Glib::ustring, VarStr>>;
+    VarStr activeProfileVariant = VarStr::create(activeProfile_->name);
+    auto callArgs = SetPowerProfileVar::create(
+        std::make_tuple("net.hadess.PowerProfiles", "ActiveProfile", activeProfileVariant));
+    powerProfilesProxy_->call("org.freedesktop.DBus.Properties.Set",
+                              sigc::mem_fun(*this, &PowerProfilesDaemon::setPropCb), callArgs);
+  }
+  return true;
+}
+
+void PowerProfilesDaemon::setPropCb(Glib::RefPtr<Gio::AsyncResult>& r) {
+  try {
+    auto _ = powerProfilesProxy_->call_finish(r);
+    update();
+  } catch (const std::exception& e) {
+    spdlog::error("Failed to set the the active power profile: {}", e.what());
+  } catch (const Glib::Error& e) {
+    spdlog::error("Failed to set the active power profile: {}", std::string(e.what()));
+  }
+}
+
+}  // namespace waybar::modules