readerunit.hpp

Go to the documentation of this file.

 
#ifndef LOGICALACCESS_READERUNIT_HPP
#define LOGICALACCESS_READERUNIT_HPP
 
#include <stdint.h>
#include <boost/property_tree/ptree_fwd.hpp>
#include <memory>
#include <string>
#include <vector>
#include <logicalaccess/xmlserializable.hpp>
#include <logicalaccess/lla_fwd.hpp>
#include <logicalaccess/techno.hpp>
#include <logicalaccess/cardprobe.hpp>
#include <logicalaccess/services/reader_service.hpp>
#define PLUGINOBJECT_MAXLEN 64
 
namespace logicalaccess
{
class Chip;
class Profile;
class ReaderCardAdapter;
class DataTransport;
class CardsFormatComposite;
class ReaderFormatComposite;
class ReaderProvider;
 
class LLA_CORE_API ReaderUnit : public XmlSerializable,
                                        public std::enable_shared_from_this<ReaderUnit>
{
  public:
    using XmlSerializable::serialize;
    using XmlSerializable::unSerialize;
 
    explicit ReaderUnit(std::string rpt);
 
    virtual ~ReaderUnit();
 
    std::string getRPType() const;
 
    virtual ByteVector getPingCommand() const;
 
    virtual bool waitInsertion(unsigned int maxwait) = 0;
 
    virtual bool waitInsertion(const ByteVector &identifier, unsigned int maxwait);
 
    virtual bool waitRemoval(unsigned int maxwait) = 0;
 
    virtual bool isConnected() = 0;
 
    std::string getCardType() const
    {
        return d_card_type;
    }
 
    virtual void setCardType(std::string cardType) = 0;
 
    virtual std::shared_ptr<Chip> createChip(std::string type);
 
    virtual std::shared_ptr<Chip> createChip(std::string type,
                                             const ByteVector &identifier);
 
    virtual ByteVector getNumber(std::shared_ptr<Chip> chip);
 
    virtual std::shared_ptr<Chip> getSingleChip() = 0;
 
    virtual std::vector<std::shared_ptr<Chip>> getChipList() = 0;
 
    virtual ByteVector getNumber(std::shared_ptr<Chip> chip,
                                 std::shared_ptr<CardsFormatComposite> composite);
 
    static uint64_t getFormatedNumber(const ByteVector &number, int padding);
 
    static std::string getFormatedNumber(const ByteVector &number);
 
    virtual bool connect() = 0;
 
    virtual bool reconnect(int action = 0)
    {
        (void)action;
        return true;
    }
 
    virtual void disconnect() = 0;
 
    virtual bool connectToReader() = 0;
 
    virtual void disconnectFromReader() = 0;
 
    virtual std::string getName() const = 0;
 
    virtual std::string getConnectedName()
    {
        return getName();
    }
 
    virtual std::shared_ptr<ReaderUnitConfiguration> getConfiguration();
 
    virtual void setConfiguration(std::shared_ptr<ReaderUnitConfiguration> config);
 
    virtual std::shared_ptr<ReaderCardAdapter> getDefaultReaderCardAdapter();
 
    virtual void
    setDefaultReaderCardAdapter(std::shared_ptr<ReaderCardAdapter> defaultRca);
 
    virtual std::shared_ptr<DataTransport> getDataTransport() const;
 
    virtual void setDataTransport(std::shared_ptr<DataTransport> dataTransport);
 
    virtual std::string getReaderSerialNumber() = 0;
 
    std::string getDefaultXmlNodeName() const override;
 
    void serialize(boost::property_tree::ptree &node) override;
 
    void unSerialize(boost::property_tree::ptree &node) override;
 
    void unSerialize(boost::property_tree::ptree &node,
                     const std::string &rootNode) override;
 
    std::shared_ptr<ReaderProvider> getReaderProvider() const
    {
        return d_readerProvider.lock();
    }
 
    void setReaderProvider(std::weak_ptr<ReaderProvider> provider)
    {
        d_readerProvider = provider;
    }
 
    virtual std::shared_ptr<LCDDisplay> getLCDDisplay();
 
    virtual void setLCDDisplay(std::shared_ptr<LCDDisplay> d);
 
    virtual std::shared_ptr<LEDBuzzerDisplay> getLEDBuzzerDisplay();
 
    virtual void setLEDBuzzerDisplay(std::shared_ptr<LEDBuzzerDisplay> lbd);
 
    virtual void setCardTechnologies(const TechnoBitset &bitset);
 
    virtual TechnoBitset getCardTechnologies();
 
    virtual TechnoBitset getPossibleCardTechnologies();
 
    virtual ReaderServicePtr getService(const ReaderServiceType &type);
 
  protected:
    std::string d_readerProviderType;
 
    std::string d_card_type;
 
    std::weak_ptr<ReaderProvider> d_readerProvider;
 
    std::shared_ptr<ReaderUnitConfiguration> d_readerUnitConfig;
 
    std::shared_ptr<Chip> d_insertedChip;
 
    std::shared_ptr<LCDDisplay> d_lcdDisplay;
 
    std::shared_ptr<LEDBuzzerDisplay> d_ledBuzzerDisplay;
 
    virtual std::shared_ptr<ResultChecker> createDefaultResultChecker() const;
 
    virtual std::shared_ptr<CardProbe> createCardProbe();
 
  private:
    std::shared_ptr<ReaderCardAdapter> d_defaultReaderCardAdapter;
 
    std::shared_ptr<DataTransport> d_dataTransport;
};
}
 
#endif