scmApi.h

Go to the documentation of this file.

#pragma once

#include <boost/function.hpp>
#include <boost/system/error_code.hpp>
#include <boost/shared_ptr.hpp>
#include "scmTypes.h"
#include <list>
#include <map>

class SCMClientService;

//To avoid redefinition in client and app
#ifndef SCM_TYPES
#define SCM_TYPES

namespace dpySCM {

typedef boost::function<void(const bool &available)> service_availability_handler;

typedef boost::function<void(boost::system::error_code& ec, const dpySCM::Device& rDevice)> get_devices_handler_function; 
typedef boost::function<void(boost::system::error_code& ec, const dpySCM::DeviceReaderList& rReader)> get_readers_handler_function; 
typedef boost::function<void(boost::system::error_code& ec, const std::string& deviceId, dpySCM::CardEvent cardEvent)> handler_cardEvent_function; 
typedef boost::function<void(boost::system::error_code& ec, dpySCM::DeviceChargeResult deviceChargeResult)> handler_device_charge_result_function; 
typedef boost::function<void(boost::system::error_code& ec, const std::string& deviceId, dpySCM::Event deviceEvent)> handler_deviceListEvent_function; 
typedef boost::function<void(boost::system::error_code& ec)> confirmation_handler_function; 
typedef boost::function<void(boost::system::error_code& ec, dpySCM::DeviceKeys deviceKeys)> get_keys_handler_function; 
typedef boost::function<void(boost::system::error_code& ec, dpySCM::TransactionDevice TransactionDevice)> card_operation_handler_function; 
typedef boost::function<void(boost::system::error_code& ec, dpySCM::DevicePassThrough devicePassThrough)> pass_through_operation_handler_function; 
typedef boost::function<void(boost::system::error_code& ec, dpySCM::DeviceVersion& deviceVersion)> device_version_handler_function; 
typedef boost::function<void(boost::system::error_code& ec, dpySCM::DevicePaymentAppInfo& devicePaymentAppInfo)> device_payment_app_info_function; 
typedef boost::function<void(boost::system::error_code& ec, dpySCM::DeviceMediaProfiles& deviceMediaProfiles)> device_media_profiles_function; 
typedef boost::function<void(boost::system::error_code& ec, dpySCM::DeviceUpgradeStatus& deviceUpgradeStatus)> upgrade_status_events_function; 
typedef boost::function<void(boost::system::error_code& ec, const std::string& deviceId)> force_device_upgrade_function; 
typedef boost::function<void(boost::system::error_code& ec, dpySCM::DevicePciRebootTime& devicePciRebootTime)> reboot_time_handler_function; 
typedef boost::function<void(boost::system::error_code& ec, dpySCM::UltraLightCounter& ulCounter)> ultralight_counter_handler_function;
typedef boost::function<void(boost::system::error_code& ec, dpySCM::DeviceNetworkConfiguration& deviceNetworkConfiguration)> device_network_configuration_handler_function; 
typedef boost::function<void(boost::system::error_code& ec, dpySCM::DevicePaymentAppConfiguration& devicePaymentAppConf)> device_payment_app_conf_function; 
typedef boost::function<void(boost::system::error_code& ec, dpySCM::DeviceDateTime& dateTime)> device_date_time_handler_function; 
typedef boost::function<void(boost::system::error_code& ec, dpySCM::DeviceNetworkStatus& deviceNetworkStatus)> network_status_handler_function; 
typedef boost::function<void(boost::system::error_code& ec, const std::string& deviceId, dpySCM::LoggingConfiguration& loggingConfiguration)> get_logging_configuration_handler_function; 
typedef boost::function<void(boost::system::error_code& ec, dpySCM::DeviceArtifacts& deviceArtifacts)> get_artifacts_handler_function; 
typedef boost::function<void(boost::system::error_code& ec, dpySCM::DevicePluginData& devicePluginData)> execute_plugin_handler_function; 
typedef boost::function<void(boost::system::error_code& ec, const dpySCM::DevicePluginData& devicePluginData)> plugin_event_handler_function; 

} //dpySCM

#endif

class IsmartCardReaderObserver
{
public:
    virtual void newSmartCard(boost::system::error_code& ec, const std::string& deviceId, dpySCM::CardEvent cardEvent) = 0;
    virtual void chargeResult(boost::system::error_code& ec, dpySCM::DeviceChargeResult deviceChargeResult) = 0;
    virtual ~IsmartCardReaderObserver() = default;
};

class IsmartCardDeviceObserver
{
public:

    virtual void notifyPciReboot(boost::system::error_code& ec, dpySCM::DevicePciRebootTime& devicePciRebootTime) = 0;

    virtual void newUpgradeStatus(boost::system::error_code& ec, dpySCM::DeviceUpgradeStatus& deviceUpgradeStatus) = 0;

    virtual ~IsmartCardDeviceObserver() = default;

};

class IsmartCardDeviceListObserver
{
public:
    virtual void deviceListEvent(boost::system::error_code& ec, const std::string& deviceId, dpySCM::Event deviceEvent) = 0;
    virtual ~IsmartCardDeviceListObserver() = default;
};

class IPluginObserver
{
public:
    virtual void pluginEvent(boost::system::error_code& ec, const dpySCM::DevicePluginData& devicePluginData) = 0;

    virtual ~IPluginObserver() = default;
};


class SCM
{
private:

    boost::shared_ptr<SCMClientService> mClient;
    std::map<std::string, std::string> mDevices;

    template<typename Func>
    void sendToDeviceOrService(const std::string& deviceId, Func func);

    std::vector<IsmartCardDeviceListObserver*> observersDeviceListObserver;
    std::vector<IsmartCardDeviceObserver*> observersDeviceObserver;
    std::vector<IsmartCardReaderObserver*> observersReaderObserver;
    std::vector<IPluginObserver*> pluginObservers; 
    boost::system::error_code operateData(dpySCM::OperationType opType, std::string deviceId, std::string uid, std::list<dpySCM::Data> &contents);
    boost::system::error_code operateDataBlock(dpySCM::OperationType opType, std::string deviceId, std::string uid, std::list<dpySCM::DataBlock> contents);
    void asyncAddArtifact(std::string deviceId, dpySCM::ArtifactInfo artifactInfo, dpySCM::confirmation_handler_function handler);

public:

    explicit SCM(std::string ip = "127.0.0.1");
    ~SCM();
    bool isAlive();
    void monitorServiceAvailability_S(dpySCM::service_availability_handler handler);
    void monitorServiceAvailability_U();

    void asyncGetDevices(dpySCM::get_devices_handler_function handler);
    boost::system::error_code getDevices(dpySCM::Device& rDevice);
    void deviceListEvent_S(dpySCM::handler_deviceListEvent_function handler);
    void deviceListEvent_U();
    void asyncGetReaders(std::string deviceId,dpySCM::get_readers_handler_function handler);
    void asyncGetVersion(std::string deviceId, dpySCM::device_version_handler_function handler);
    void newCardEvent_S(dpySCM::handler_cardEvent_function handler);
    void newCardEvent_U();
    void asyncAddKeys(dpySCM::DeviceKeys keyGroup, dpySCM::confirmation_handler_function handler);
    void asyncAddKeys(std::string deviceId, std::string json, dpySCM::confirmation_handler_function handler);
    void asyncGetKeys(std::string deviceId, dpySCM::get_keys_handler_function handler);
    void asyncRemoveKeys(std::string deviceId, dpySCM::confirmation_handler_function handler);
    void upgradeStatus_S(dpySCM::upgrade_status_events_function handler);
    void upgradeStatus_U();
    void asyncForceDeviceUpgrade(std::string deviceId,dpySCM::force_device_upgrade_function handler);

    // Device list observer
    boost::system::error_code subscribeDeviceListEvent(IsmartCardDeviceListObserver *observer);
    boost::system::error_code unsubscribeDeviceListEvent(IsmartCardDeviceListObserver *observer);
    // Device observer
    boost::system::error_code subscribeDeviceEvent(IsmartCardDeviceObserver *observer);
    boost::system::error_code unsubscribeDeviceEvent(IsmartCardDeviceObserver *observer);
    // Reader observer
    boost::system::error_code subscribeReaderEvent(IsmartCardReaderObserver *observer);
    boost::system::error_code unsubscribeReaderEvent(IsmartCardReaderObserver *observer);
    // Plugin observer
    boost::system::error_code subscribePluginEvent(IPluginObserver *observer);
    boost::system::error_code unsubscribePluginEvent(IPluginObserver *observer);

    void asyncCardOperation(dpySCM::TransactionDevice operationDevice, dpySCM::card_operation_handler_function handler);
    void asyncPassThrough(dpySCM::DevicePassThrough devicePassThrough, dpySCM::pass_through_operation_handler_function handler);
    void asyncGetULCounter(std::string deviceId, dpySCM::UltraLightCounter& ulCounter, dpySCM::ultralight_counter_handler_function handler);
    void asyncIncrementULCounter(std::string deviceId, dpySCM::UltraLightCounter& ulCounter, dpySCM::confirmation_handler_function handler);
    void asyncResetSamSlot(std::string deviceId, dpySCM::SamSlot slotNumber, dpySCM::confirmation_handler_function handler);


    boost::system::error_code auth(std::string deviceId, std::string uid, std::list<dpySCM::Data>& contents);
    boost::system::error_code read(std::string deviceId, std::string uid, std::list<dpySCM::Data>& contents);
    boost::system::error_code write(std::string deviceId, std::string uid, std::list<dpySCM::Data>& contents);
    boost::system::error_code apduExchange(std::string deviceId, std::string uid, std::list<dpySCM::ApduTxData>& apduTx, std::list<dpySCM::ApduRxData>& apduRx);
    boost::system::error_code passThrough(std::string deviceId, dpySCM::PassThrough& passThrough);
    boost::system::error_code getULCounter(std::string deviceId, dpySCM::UltraLightCounter& ulCounter);
    boost::system::error_code incrementULCounter(std::string deviceId, dpySCM::UltraLightCounter& ulCounter);
    boost::system::error_code transferBlock(std::string deviceId, std::string uid, std::list<dpySCM::DataBlock> contents);
    boost::system::error_code restoreBlock(std::string deviceId, std::string uid, std::list<dpySCM::DataBlock> contents);
    boost::system::error_code incrementOnlyBlock(std::string deviceId, std::string uid, std::list<dpySCM::DataBlock> contents);
    boost::system::error_code decrementOnlyBlock(std::string deviceId, std::string uid, std::list<dpySCM::DataBlock> contents);
    boost::system::error_code incrementBlock(std::string deviceId, std::string uid, std::list<dpySCM::DataBlock> contents);
    boost::system::error_code decrementBlock(std::string deviceId, std::string uid, std::list<dpySCM::DataBlock> contents);

    void chargeResultEMV_S(dpySCM::handler_device_charge_result_function handler);
    void chargeResultEMV_U();
    void asyncRequestChargeEMV(dpySCM::DeviceRequestCharge requestChargeDevice, dpySCM::confirmation_handler_function handler);
    void asyncChargeConfirmationEMV(dpySCM::DeviceChargeConfirmation requestChargeConfirmation, dpySCM::confirmation_handler_function handler);
    void asyncSetPaymentAppStatus(dpySCM::DevicePaymentAppStatus devicePaymentAppStatus, dpySCM::confirmation_handler_function handler);
    void asyncGetPaymentAppInfo(std::string deviceId, dpySCM::device_payment_app_info_function handler);
    void asyncGetPaymentAppConf(dpySCM::DevicePaymentAppConfiguration devicePaymentAppConf, dpySCM::device_payment_app_conf_function handler);
    void asyncSetPaymentAppConf(dpySCM::DevicePaymentAppConfiguration devicePaymentAppConf, dpySCM::confirmation_handler_function handler);
    void asyncForcePaymentAppComm(std::string deviceId, dpySCM::confirmation_handler_function handler);


    void asyncPlayProfile(std::string deviceId, std::string profileId, dpySCM::confirmation_handler_function handler);
    void asyncAddMediaProfiles(std::string deviceId,std::string json, dpySCM::confirmation_handler_function handler);
    void asyncAddMediaProfiles(dpySCM::DeviceMediaProfiles deviceMediaProfiles, dpySCM::confirmation_handler_function handler);
    void asyncGetMediaProfiles(std::string deviceId, dpySCM::device_media_profiles_function handler);
    void asyncRemoveMediaProfiles(std::string deviceId, dpySCM::confirmation_handler_function handler);

    void pciRebootEvent_S(dpySCM::reboot_time_handler_function handler);
    void pciRebootEvent_U();
    void asyncGetPciRebootTime(std::string deviceId, dpySCM::reboot_time_handler_function handler);
    void asyncSetPciRebootTime(dpySCM::DevicePciRebootTime deviceRebootTime, dpySCM::confirmation_handler_function handler);
    boost::system::error_code getPciRebootTime(std::string deviceId,  dpySCM::DevicePciRebootTime& rebootTime);
    boost::system::error_code setPciRebootTime(dpySCM::DevicePciRebootTime deviceRebootTime);

    void asyncGetNetworkConfiguration(std::string deviceId, dpySCM::device_network_configuration_handler_function handler);
    void asyncSetNetworkConfiguration(dpySCM::DeviceNetworkConfiguration deviceNetworkConfiguration, dpySCM::confirmation_handler_function handler);
    void asyncGetDateTime(std::string deviceId, dpySCM::device_date_time_handler_function handler);
    void asyncRebootDevice(std::string deviceId, dpySCM::RebootType rebootType, dpySCM::confirmation_handler_function handler);
    void asyncTestNetworkConnectivity(dpySCM::DeviceNetworkConnectivity deviceNetworkConnectivity, dpySCM::network_status_handler_function handler);
    void asyncSetLoggingConfiguration(std::string deviceId, dpySCM::LoggingConfiguration loggingConfiguration, dpySCM::confirmation_handler_function handler);
    void asyncGetLoggingConfiguration(std::string deviceId, dpySCM::get_logging_configuration_handler_function handler);

    boost::system::error_code asyncAddArtifact(std::string deviceId, std::string name, std::string fileName, dpySCM::ArtifactType type, dpySCM::ArtifactInstallationType installType, dpySCM::confirmation_handler_function handler);
    boost::system::error_code asyncAddArtifact(std::string deviceId, std::string name, std::string fileName, dpySCM::ArtifactType type, dpySCM::ArtifactInstallationType installType, std::string version, dpySCM::confirmation_handler_function handler);
    void asyncGetArtifacts(std::string deviceId, dpySCM::get_artifacts_handler_function handler);
    void asyncRemoveArtifact(std::string deviceId, std::string name, dpySCM::confirmation_handler_function handler);
    void asyncExecutePlugin(std::string deviceId, std::string name, std::map<std::string,std::string> inputData, dpySCM::execute_plugin_handler_function handler);
    void pluginEvent_S(dpySCM::plugin_event_handler_function handler);
    void pluginEvent_U();
};