abstractsensor_i.h

Go to the documentation of this file.

 
#ifndef ABSTRACTSENSOR_I_H
#define ABSTRACTSENSOR_I_H
 
#include <QtDBus/QtDBus>
#include <QList>
#include <QVector>
#include <QString>
 
#include "sfwerror.h"
#include "serviceinfo.h"
#include "socketreader.h"
#include "datatypes/datarange.h"
 
class AbstractSensorChannelInterface : public QObject
{
    Q_OBJECT
    Q_DISABLE_COPY(AbstractSensorChannelInterface)
    Q_PROPERTY(int sessionId READ sessionId)
    Q_PROPERTY(SensorError errorCode READ errorCode)
    Q_PROPERTY(QString errorString READ errorString)
    Q_PROPERTY(QString description READ description)
    Q_PROPERTY(QString id READ id)
    Q_PROPERTY(int interval READ interval WRITE setInterval)
    Q_PROPERTY(bool standbyOverride READ standbyOverride WRITE setStandbyOverride)
    Q_PROPERTY(QString type READ type)
    Q_PROPERTY(unsigned int bufferInterval READ bufferInterval WRITE setBufferInterval)
    Q_PROPERTY(unsigned int bufferSize READ bufferSize WRITE setBufferSize)
    Q_PROPERTY(bool hwBuffering READ hwBuffering)
    Q_PROPERTY(bool downsampling READ downsampling WRITE setDownsampling)
 
public:
 
    virtual ~AbstractSensorChannelInterface();
 
    bool release();
 
    int sessionId() const;
 
    SensorError errorCode();
 
    QString errorString();
 
    QString description();
 
    QString id();
 
    int interval();
 
    void setInterval(int value);
 
    bool standbyOverride();
 
    bool setStandbyOverride(bool override);
 
    unsigned int bufferInterval();
 
    void setBufferInterval(unsigned int value);
 
    bool downsampling();
 
    bool setDownsampling(bool value);
 
    IntegerRangeList getAvailableBufferIntervals();
 
    unsigned int bufferSize();
 
    void setBufferSize(unsigned int value);
 
    IntegerRangeList getAvailableBufferSizes();
 
    QString type();
 
    virtual QDBusReply<void> start();
 
    virtual QDBusReply<void> stop();
 
    DataRangeList getAvailableIntervals();
 
    DataRangeList getAvailableDataRanges();
 
    DataRange getCurrentDataRange();
 
    void requestDataRange(DataRange range);
 
    void removeDataRangeRequest();
 
    bool setDataRangeIndex(int dataRangeIndex);
 
    bool hwBuffering();
 
    bool isValid() const;
 
private:
    void setError(SensorError errorCode, const QString& errorString);
 
    void clearError();
 
    SocketReader& getSocketReader() const;
 
private Q_SLOTS: // METHODS
 
    void displayStateChanged(bool displayState);
 
    QDBusReply<void> setInterval(int sessionId, int value);
 
    QDBusReply<bool> setStandbyOverride(int sessionId, bool value);
 
    QDBusReply<void> setBufferInterval(int sessionId, unsigned int value);
 
    QDBusReply<void> setBufferSize(int sessionId, unsigned int value);
 
    QDBusReply<void> setDownsampling(int sessionId, bool value);
 
    QDBusReply<void> start(int sessionId);
 
    QDBusReply<void> stop(int sessionId);
 
    void dataReceived();
 
protected:
    AbstractSensorChannelInterface(const QString& path, const char* interfaceName, int sessionId);
 
    bool read(void* buffer, int size);
 
    template<typename T>
    bool read(QVector<T>& values);
 
    virtual bool dataReceivedImpl() = 0;
 
    template<typename T>
    T getAccessor(const char* name);
 
    template<typename T>
    void setAccessor(const char* name, const T& value);
 
    QDBusMessage call(QDBus::CallMode mode,
                      const QString& method,
                      const QVariant& arg1 = QVariant(),
                      const QVariant& arg2 = QVariant(),
                      const QVariant& arg3 = QVariant(),
                      const QVariant& arg4 = QVariant(),
                      const QVariant& arg5 = QVariant(),
                      const QVariant& arg6 = QVariant(),
                      const QVariant& arg7 = QVariant(),
                      const QVariant& arg8 = QVariant());
 
    QDBusMessage callWithArgumentList(QDBus::CallMode mode, const QString& method, const QList<QVariant>& args);
 
    void dbusConnectNotify(const QMetaMethod& signal);
protected slots:
    void startFinished(QDBusPendingCallWatcher *watch);
    void stopFinished(QDBusPendingCallWatcher *watch);
 
    void setIntervalFinished(QDBusPendingCallWatcher *watch);
    void setBufferIntervalFinished(QDBusPendingCallWatcher *watch);
    void setBufferSizeFinished(QDBusPendingCallWatcher *watch);
    void setStandbyOverrideFinished(QDBusPendingCallWatcher *watch);
    void setDownsamplingFinished(QDBusPendingCallWatcher *watch);
    void setDataRangeIndexFinished(QDBusPendingCallWatcher *watch);
 
 
private:
    struct AbstractSensorChannelInterfaceImpl;
 
    AbstractSensorChannelInterfaceImpl* pimpl_; 
};
 
template<typename T>
bool AbstractSensorChannelInterface::read(QVector<T>& values)
{
    return getSocketReader().read(values);
}
 
template<typename T>
T AbstractSensorChannelInterface::getAccessor(const char* name)
{
    QDBusReply<T> reply(call(QDBus::Block, QLatin1String(name)));
    if(!reply.isValid())
    {
        qDebug() << "Failed to get '" << name << "' from sensord: " << reply.error().message();
        return T();
    }
    return reply.value();
}
 
template<typename T>
void AbstractSensorChannelInterface::setAccessor(const char* name, const T& value)
{
    QDBusReply<void> reply(call(QDBus::NoBlock, QLatin1String(name), qVariantFromValue(value)));
    if(!reply.isValid())
    {
        qDebug() << "Failed to set '" << name << " = " << value << "' to sensord: " << reply.error().message();
    }
}
 
namespace local {
    typedef ::AbstractSensorChannelInterface AbstractSensor;
}
 
#endif