librarymanager.hpp

Go to the documentation of this file.

#ifndef LIBRARYMANAGER_HPP__
#define LIBRARYMANAGER_HPP__
 
#include <string>
#include <list>
#include <mutex>
 
#include <logicalaccess/dynlibrary/idynlibrary.hpp>
#include <logicalaccess/iks/IslogKeyServer.hpp>
 
namespace logicalaccess
{
class AccessControlCardService;
 
class LLA_CORE_API LibraryManager
{
  public:
    enum LibraryType
    {
        READERS_TYPE = 0,
        CARDS_TYPE   = 1,
        UNIFIED_TYPE = 2
    };
 
  private:
    LibraryManager() = default;
 
    ~LibraryManager() = default;
 
    static bool hasEnding(std::string const &fullString, std::string ending);
 
  public:
    static LibraryManager *getInstance();
 
    void *getFctFromName(const std::string &fctname, LibraryType libraryType);
 
    std::shared_ptr<ReaderProvider> getReaderProvider(const std::string &readertype);
 
    std::shared_ptr<ReaderUnit> getReader(const std::string &readerName);
 
    std::shared_ptr<Chip> getCard(const std::string &cardtype);
 
    std::shared_ptr<Commands> getCommands(const std::string &extendedtype);
 
    std::shared_ptr<RemoteCrypto>
    getRemoteCrypto(const iks::IslogKeyServer::IKSConfig &cfg);
 
    std::shared_ptr<RemoteCrypto> getRemoteCrypto();
 
    std::shared_ptr<IAESCryptoService>
    getPKCSAESCrypto(const std::string &env_PROTECCIO_CONF_DIR,
                     const std::string &pkcs_library_shared_object_path);
 
    static std::shared_ptr<DataTransport>
    getDataTransport(const std::string &transporttype);
    std::shared_ptr<KeyDiversification>
    getKeyDiversification(const std::string &keydivtype);
 
    std::shared_ptr<CardService> getCardService(std::shared_ptr<Chip> chip,
                                                CardServiceType type);
 
    ReaderServicePtr getReaderService(ReaderUnitPtr reader, ReaderServiceType type);
 
    std::vector<std::string> getAvailableCards();
 
    std::vector<std::string> getAvailableReaders();
 
    static std::vector<std::string> getAvailableDataTransports();
 
    void scanPlugins();
 
  protected:
    std::vector<std::string> getAvailablePlugins(LibraryType libraryType);
    static void getAvailablePlugins(std::vector<std::string> &plugins,
                                    getobjectinfoat objectinfoptr);
 
  private:
    mutable std::recursive_mutex mutex_;
    std::map<std::string, IDynLibrary *> libLoaded;
    static const std::string enumType[3];
};
}
 
#endif