src/FMDbusConn.cpp

   1 #include <KApplication>
   2 #include <QDBusConnectionInterface>
   3 #include <QComboBox>
   4 #include <QtCore>
   5 #include <QObject>
   6
   7 #include <unistd.h>
   8
   9 #include "FMDbusConn.h"
  10 #include "FingerManagerDevicesModel.h"
  11
  12 /**
  13  * FMDbusConn constructor
  14  */
  15 FMDbusConn::FMDbusConn() : managerIface(0) {
  16         if (!QDBusConnection::systemBus().isConnected()) {
  17                 qDebug("Cannot connect to D-Bus system bus.");
  18         }
  19         deviceResultsWatcher = new QFutureWatcher<FingerManagerDevicesModel*>(this);
  20         fingersResultsWatcher = new QFutureWatcher<QStringList>(this);
  21         connect(deviceResultsWatcher, SIGNAL(resultReadyAt(int)), SLOT(emitDiscovered(int)));
  22         connect(fingersResultsWatcher, SIGNAL(resultReadyAt(int)), SLOT(fingersDiscovered(int)));
  23 };
  24
  25 /**
  26  * FMDbusConn destructor
  27  */
  28 FMDbusConn::~FMDbusConn() {
  29         delete managerIface;
  30         delete deviceResultsWatcher;
  31         delete fingersResultsWatcher;
  32 }
  33
  34 /**
  35  * Start D-Bus daemon (requires some retries)
  36  */
  37 QDBusInterface* FMDbusConn::getManagerIface(int retr = INTERFACE_ACQUIRE_RETRY) {
  38         if (!retr) {
  39                 qDebug("Manager interface doesn't found!");
  40                 return(0);
  41         }
  42
  43         if (managerIface && managerIface->isValid()) {
  44                 qDebug("Returning existing manager interface");
  45                 return managerIface;
  46         }
  47
  48         qDebug("getManagerConnection try: %d", retr);
  49
  50         // Connect to Fprint manager on system bus
  51         QDBusConnection bus = QDBusConnection::systemBus();
  52         QDBusInterface *iface = new QDBusInterface("net.reactivated.Fprint",
  53                                 "/net/reactivated/Fprint/Manager",
  54                                 "net.reactivated.Fprint.Manager",
  55                                 bus, this);
  56
  57         // Wait while D-Bus Fprintd daemon starts
  58         if (iface->isValid()) {
  59                 managerIface = iface;
  60         } else {
  61                 managerIface = getManagerIface(--retr);
  62         }
  63         return(managerIface);
  64 }
  65
  66 /**
  67  * QFutureWatcher signal handler
  68  */
  69 void FMDbusConn::emitDiscovered(int idx) {
  70         emit devicesDiscovered(idx);
  71 }
  72
  73 void FMDbusConn::fingersDiscovered(int idx) {
  74         emit enrolledFingersDiscovered(idx);
  75 }
  76
  77 /**
  78  * Returns FingerManagerDevicesModel created by getDevices
  79  */
  80 FingerManagerDevicesModel* FMDbusConn::getModel(int idx) {
  81         return(deviceResultsWatcher->resultAt(idx));
  82 }
  83
  84 /**
  85  * Get device communication interface
  86  */
  87 QDBusInterface* getDeviceInterface(QString device) {
  88         QDBusInterface* i = new QDBusInterface("net.reactivated.Fprint",
  89                 device,
  90                 "net.reactivated.Fprint.Device",
  91                 QDBusConnection::systemBus());
  92         return(i);
  93 }
  94
  95 /**
  96  * Returns name associated with device
  97  */
  98 QString getDeviceName(QString device) {
  99         QString name;
 100         QDBusInterface *i = getDeviceInterface(device);
 101         if (i->isValid()) {
 102                 name = i->property("name").toString();
 103         } else {
 104                 name = device;
 105         }
 106         delete(i);
 107         return(name);
 108 }
 109
 110 /**
 111  * Real function which do all the work
 112  */
 113 FingerManagerDevicesModel* getDevicesReal(QDBusInterface *iface) {
 114         FingerManagerDevicesModel *model = new FingerManagerDevicesModel();
 115
 116         if (iface && iface->isValid()) {
 117
 118                 qDebug("D-Bus interface acquired! :-)");
 119                 QDBusReply<QList<QDBusObjectPath> > devices = iface->call("GetDevices");
 120                 if (devices.isValid()) {
 121                         foreach (QDBusObjectPath device, devices.value()) {
 122                                 model->addDevice(device.path(), getDeviceName(device.path()));
 123                         }
 124                 }
 125
 126                 QDBusReply<QDBusObjectPath> defaultDevice = iface->call("GetDefaultDevice");
 127                 if (defaultDevice.isValid()) {
 128                         model->setDefault(defaultDevice.value().path());
 129                 }
 130         } else {
 131                 qDebug("D-Bus interface cannot be acquired! :-(");
 132         }
 133         return(model);
 134 }
 135
 136 /**
 137  * Starts thread
 138  */
 139 void FMDbusConn::getDevices() {
 140         QDBusInterface *iface = getManagerIface();
 141         deviceResultsWatcher->setFuture(QtConcurrent::run(getDevicesReal, iface));
 142 }
 143
 144 /**
 145  * Returns QStringList returned by D-Bus daemon
 146  */
 147 QStringList FMDbusConn::getFingers(int idx) {
 148         return(fingersResultsWatcher->resultAt(idx));
 149 }
 150
 151 /**
 152  * Real function which do all the work
 153  */
 154 QStringList getEnrolledFingersReal(QDBusInterface *iface) {
 155         QStringList result;
 156         if (iface && iface->isValid()) {
 157                 QDBusReply<QStringList> r = iface->call("ListEnrolledFingers", getlogin());
 158                 if (r.isValid()) {
 159                         result = r.value();
 160                 } else {
 161                         QDBusError e = iface->lastError();
 162                         qDebug() << e.message();
 163                 }
 164         }
 165         return(result);
 166 }
 167
 168 /**
 169  * Starts thread
 170  */
 171 void FMDbusConn::getEnrolledFingers(QString device) {
 172         QDBusInterface *iface = getDeviceInterface(device);
 173         fingersResultsWatcher->setFuture(QtConcurrent::run(getEnrolledFingersReal, iface));
 174 }