plugins/dbus/dbussignaller.h

   1 #ifndef _DBUSSIGNALLER_H_
   2 #define _DBUSSIGNALLER_H_
   3
   4 #include <gio/gio.h>
   5 #include <map>
   6 #include <string>
   7
   8 #include "debugout.h"
   9 #include "abstractproperty.h"
  10
  11 class DBusSignaller
  12 {
  13 public:
  14
  15         static DBusSignaller* factory(int timeout)
  16         {
  17                 if(!singleton)
  18                         return singleton = new DBusSignaller(timeout);
  19                 return singleton;
  20         }
  21
  22         void fireSignal(GDBusConnection* conn, std::string objPath, std::string iface, std::string sigName, AbstractProperty* prop)
  23         {
  24                 DBusSignal signal(conn, objPath, iface, sigName, prop);
  25
  26                 queue[objPath] = signal;
  27         }
  28
  29         class DBusSignal
  30         {
  31         public:
  32                 DBusSignal():connection(nullptr), property(nullptr){}
  33                 DBusSignal(GDBusConnection* conn, std::string objPath, std::string iface, std::string sigName, AbstractProperty* var)
  34                         : connection(conn), objectPath(objPath), interface(iface), signalName(sigName), property(var)
  35                 {
  36
  37                 }
  38
  39                 GDBusConnection* connection;
  40                 std::string objectPath;
  41                 std::string interface;
  42                 std::string signalName;
  43                 AbstractProperty* property;
  44         };
  45
  46 private:
  47
  48         DBusSignaller() { }
  49
  50         DBusSignaller(int timeout)
  51         {
  52                 g_timeout_add(timeout,[](gpointer userData)
  53                 {
  54                         std::map<std::string, DBusSignal> *q = static_cast<std::map<std::string, DBusSignal>*>(userData);
  55                         std::map<std::string, DBusSignal> queue = *q;
  56
  57                         for(auto sig : queue)
  58                         {
  59                                 DBusSignal signal = sig.second;
  60
  61                                 GError* error = nullptr;
  62
  63                                 AbstractProperty* property = signal.property;
  64
  65                                 GVariant* val = g_variant_ref(property->toGVariant());
  66
  67                                 /// Send PropertiesChanged signal
  68
  69                                 GVariantBuilder builder;
  70                                 g_variant_builder_init(&builder, G_VARIANT_TYPE_DICTIONARY);
  71
  72                                 g_variant_builder_add(&builder, "{sv}", property->name().c_str(), val);
  73                                 g_variant_builder_add(&builder, "{sv}", std::string(property->name() + "Sequence").c_str(), g_variant_new("i", property->sequence()));
  74                                 g_variant_builder_add(&builder, "{sv}", "Time", g_variant_new("d", property->timestamp()) );
  75
  76                                 g_dbus_connection_emit_signal(signal.connection, NULL, signal.objectPath.c_str(), "org.freedesktop.DBus.Properties", signal.signalName.c_str(), g_variant_new("(sa{sv}as)",
  77                                                                                                                                                                                                                                                                                                                                          signal.interface.c_str(),
  78                                                                                                                                                                                                                                                                                                                                          &builder, NULL), &error);
  79
  80                                 if(error)
  81                                 {
  82                                         DebugOut(DebugOut::Error)<<error->message<<std::endl;
  83                                 }
  84
  85                                 queue.erase(signal.objectPath);
  86
  87                         }
  88
  89                         *q = queue;
  90
  91                         return 1;
  92
  93                 },&queue);
  94         }
  95
  96         std::map<std::string, DBusSignal> queue;
  97
  98         static DBusSignaller * singleton;
  99 };
 100
 101 #endif