ReaderManager.h

gehe zur Dokumentation dieser Datei

 
#pragma once
 
#include "command/CreateCardConnectionCommand.h"
#include "Env.h"
#include "Reader.h"
#include "ReaderFilter.h"
#include "ReaderManagerWorker.h"
 
#include <QMutex>
#include <QPointer>
#include <QThread>
 
 
namespace governikus
{
class ReaderManager
    : public QObject
    , private Env::ThreadSafe
{
    Q_OBJECT
    friend class Env;
 
    private:
        mutable QMutex mMutex;
        QThread mThread;
        QPointer<ReaderManagerWorker> mWorker;
        QMap<QString, ReaderInfo> mReaderInfoCache;
        QMap<ReaderManagerPlugInType, ReaderManagerPlugInInfo> mPlugInInfoCache;
 
    protected:
        ReaderManager();
        ~ReaderManager() override;
 
    public:
        void init();
 
        void reset(ReaderManagerPlugInType pType);
 
        void startScanAll(bool pAutoConnect = true);
 
        void startScan(ReaderManagerPlugInType pType, bool pAutoConnect = true);
 
        void stopScanAll(const QString& pError = QString());
 
        bool isScanRunning() const;
 
        bool isScanRunning(ReaderManagerPlugInType pType) const;
 
        void stopScan(ReaderManagerPlugInType pType, const QString& pError = QString());
 
        QVector<ReaderManagerPlugInInfo> getPlugInInfos() const;
        virtual QVector<ReaderInfo> getReaderInfos(const ReaderFilter& pFilter = ReaderFilter()) const;
        ReaderInfo getReaderInfo(const QString& pReaderName) const;
        void updateReaderInfo(const QString& pReaderName);
 
        template<typename T>
        QMetaObject::Connection callCreateCardConnectionCommand(const QString& pReaderName, const typename QtPrivate::FunctionPointer<T>::Object* pReceiver, T pSlot)
        {
            auto* command = new CreateCardConnectionCommand(pReaderName, mWorker);
            QMetaObject::Connection connection = connect(command, &CreateCardConnectionCommand::fireCommandDone, pReceiver, pSlot, Qt::UniqueConnection);
            if (connection)
            {
                command->run();
            }
            else
            {
                qCCritical(card) << "Cannot invoke CreateCardConnectionCommand command";
                command->deleteLater();
            }
 
            return connection;
        }
 
 
        void updateRetryCounters();
 
    Q_SIGNALS:
        void firePluginAdded(const ReaderManagerPlugInInfo& pInfo);
        void fireStatusChanged(const ReaderManagerPlugInInfo& pInfo);
        void fireReaderAdded(const ReaderInfo& pInfo);
        void fireReaderRemoved(const ReaderInfo& pInfo);
        void fireReaderPropertiesUpdated(const ReaderInfo& pInfo);
        void fireCardInserted(const ReaderInfo& pInfo);
        void fireCardRemoved(const ReaderInfo& pInfo);
        void fireCardRetryCounterChanged(const ReaderInfo& pInfo);
        void fireReaderEvent();
        void fireInitialized();
 
    private Q_SLOTS:
        void doUpdateCacheEntry(const ReaderInfo& pInfo);
        void doRemoveCacheEntry(const ReaderInfo& pInfo);
        void doFullUpdateCache(const ReaderManagerPlugInInfo& pInfo);
 
    public Q_SLOTS:
        void shutdown();
};
 
} // namespace governikus