Merge pull request #4504 from ErikReider/geoclue-privacy

Add GeoClue2 location privacy item

include/modules/privacy/privacy.hpp

@@ -1,13 +1,16 @@
 #pragma once
 
+#include <atomic>
 #include <string>
 
 #include "gtkmm/box.h"
 #include "modules/privacy/privacy_item.hpp"
+#include "util/geoclue_backend.hpp"
 #include "util/pipewire/pipewire_backend.hpp"
 #include "util/pipewire/privacy_node_info.hpp"
 
-using waybar::util::PipewireBackend::PrivacyNodeInfo;
+using waybar::util::PipewireBackend::PrivacyNodeType;
+using waybar::util::PipewireBackend::PWPrivacyNodeInfo;
 
 namespace waybar::modules::privacy {
 
@@ -16,15 +19,15 @@ class Privacy : public AModule {
   Privacy(const std::string&, const Json::Value&, Gtk::Orientation, const std::string& pos);
   auto update() -> void override;
 
-  void onPrivacyNodesChanged();
-
  private:
-  std::list<PrivacyNodeInfo*> nodes_screenshare;  // Screen is being shared
-  std::list<PrivacyNodeInfo*> nodes_audio_in;     // Application is using the microphone
-  std::list<PrivacyNodeInfo*> nodes_audio_out;    // Application is outputting audio
+  std::list<PWPrivacyNodeInfo*> nodes_screenshare;  // Screen is being shared
+  std::list<PWPrivacyNodeInfo*> nodes_audio_in;     // Application is using the microphone
+  std::list<PWPrivacyNodeInfo*> nodes_audio_out;    // Application is outputting audio
+  std::atomic<bool> location_in_use;                // GeoClue is being used
 
   std::mutex mutex_;
   sigc::connection visibility_conn;
+  sigc::connection geoclue_timeout_conn;
 
   // Config
   Gtk::Box box_;
@@ -35,7 +38,12 @@ class Privacy : public AModule {
   std::set<std::pair<PrivacyNodeType, std::string>> ignore;
   bool ignore_monitor = true;
 
-  std::shared_ptr<util::PipewireBackend::PipewireBackend> backend = nullptr;
+  std::shared_ptr<util::PipewireBackend::PipewireBackend> pw_backend = nullptr;
+  std::shared_ptr<util::GeoClueBackend::GeoClueBackend> geoclue_backend = nullptr;
+
+  void onPWPrivacyNodesChanged();
+  bool locationTimeout(bool in_use);
+  void onGeoCluePrivacyNodesChanged();
 };
 
 }  // namespace waybar::modules::privacy

include/modules/privacy/privacy_item.hpp

@@ -9,35 +9,36 @@
 #include "gtkmm/revealer.h"
 #include "util/pipewire/privacy_node_info.hpp"
 
-using waybar::util::PipewireBackend::PrivacyNodeInfo;
 using waybar::util::PipewireBackend::PrivacyNodeType;
+using waybar::util::PipewireBackend::PWPrivacyNodeInfo;
 
 namespace waybar::modules::privacy {
 
 class PrivacyItem : public Gtk::Revealer {
- public:
+ protected:
   PrivacyItem(const Json::Value& config_, enum PrivacyNodeType privacy_type_,
-              std::list<PrivacyNodeInfo*>* nodes, Gtk::Orientation orientation,
-              const std::string& pos, const uint icon_size, const uint transition_duration);
+              Gtk::Orientation orientation, const std::string& pos, const uint icon_size,
+              const uint transition_duration);
+
+ public:
+  virtual void set_tooltip() = 0;
 
   enum PrivacyNodeType privacy_type;
 
   void set_in_use(bool in_use);
 
- private:
-  std::list<PrivacyNodeInfo*>* nodes;
-
-  sigc::connection signal_conn;
-
+  uint tooltipIconSize = 24;
   Gtk::Box tooltip_window;
 
+ private:
+  sigc::connection signal_conn;
+
   bool init = false;
   bool in_use = false;
 
   // Config
   std::string iconName = "image-missing-symbolic";
   bool tooltip = true;
-  uint tooltipIconSize = 24;
 
   Gtk::Box box_;
   Gtk::Image icon_;
@@ -45,4 +46,28 @@ class PrivacyItem : public Gtk::Revealer {
   void update_tooltip();
 };
 
+class GeoCluePrivacyItem : public PrivacyItem {
+ public:
+  GeoCluePrivacyItem(const Json::Value& config_, Gtk::Orientation orientation,
+                     const std::string& pos, const uint icon_size, const uint transition_duration)
+      : PrivacyItem(config_, util::PipewireBackend::PRIVACY_NODE_TYPE_LOCATION, orientation, pos,
+                    icon_size, transition_duration) {}
+
+  void set_tooltip() override;
+};
+
+class PWPrivacyItem : public PrivacyItem {
+ public:
+  PWPrivacyItem(const Json::Value& config_, enum PrivacyNodeType privacy_type_,
+                std::list<PWPrivacyNodeInfo*>* nodes_, Gtk::Orientation orientation,
+                const std::string& pos, const uint icon_size, const uint transition_duration)
+      : PrivacyItem(config_, privacy_type_, orientation, pos, icon_size, transition_duration),
+        nodes(nodes_) {}
+
+  void set_tooltip() override;
+
+ private:
+  std::list<PWPrivacyNodeInfo*>* nodes;
+};
+
 }  // namespace waybar::modules::privacy

include/util/geoclue_backend.hpp

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <giomm/dbusconnection.h>
+
+#include <atomic>
+
+#include "giomm/dbusproxy.h"
+
+namespace waybar::util::GeoClueBackend {
+
+class GeoClueBackend {
+ private:
+  guint watcherID_;
+  sigc::connection signal_conn;
+  Glib::RefPtr<Gio::DBus::Proxy> proxy;
+  bool connected;
+
+  /* Hack to keep constructor inaccessible but still public.
+   * This is required to be able to use std::make_shared.
+   * It is important to keep this class only accessible via a reference-counted
+   * pointer because the destructor will manually free memory, and this could be
+   * a problem with C++20's copy and move semantics.
+   */
+  struct PrivateConstructorTag {};
+
+ public:
+  sigc::signal<void> in_use_changed_signal_event;
+
+  std::atomic<bool> location_in_use;  // GeoClue is being used
+
+  static std::shared_ptr<GeoClueBackend> getInstance();
+
+  // DBus callbacks
+  void onAppear(const Glib::RefPtr<Gio::DBus::Connection>&, const Glib::ustring&,
+                const Glib::ustring&);
+  void onVanished(const Glib::RefPtr<Gio::DBus::Connection>&, const Glib::ustring&);
+  void propertyChanged(const Gio::DBus::Proxy::MapChangedProperties& changedProperties,
+                       const std::vector<Glib::ustring>& invalidatedProperties);
+
+  GeoClueBackend(PrivateConstructorTag tag);
+  ~GeoClueBackend();
+};
+}  // namespace waybar::util::GeoClueBackend

include/util/pipewire/pipewire_backend.hpp

@@ -29,7 +29,7 @@ class PipewireBackend {
  public:
   sigc::signal<void> privacy_nodes_changed_signal_event;
 
-  std::unordered_map<uint32_t, PrivacyNodeInfo*> privacy_nodes;
+  std::unordered_map<uint32_t, PWPrivacyNodeInfo*> privacy_nodes;
   std::mutex mutex_;
 
   static std::shared_ptr<PipewireBackend> getInstance();

include/util/pipewire/privacy_node_info.hpp

@@ -12,10 +12,11 @@ enum PrivacyNodeType {
   PRIVACY_NODE_TYPE_NONE,
   PRIVACY_NODE_TYPE_VIDEO_INPUT,
   PRIVACY_NODE_TYPE_AUDIO_INPUT,
-  PRIVACY_NODE_TYPE_AUDIO_OUTPUT
+  PRIVACY_NODE_TYPE_AUDIO_OUTPUT,
+  PRIVACY_NODE_TYPE_LOCATION
 };
 
-class PrivacyNodeInfo {
+class PWPrivacyNodeInfo {
  public:
   PrivacyNodeType type = PRIVACY_NODE_TYPE_NONE;
   uint32_t id;