modemApi.h

Go to the documentation of this file.

#pragma once

#include <boost/function.hpp>
#include <boost/system/error_code.hpp>
#include <map>
#include <vector>

#include "iModemList.h"
#include "networking.h"

class ModemClient;

#ifndef MODEM_TYPES_H_
#define MODEM_TYPES_H_

namespace dpyModem {

enum MODEM_INFO
{
    MANUFACTURER, 
    MODEL, 
    FW_VERSION, 
    IMEI, 
    SIM_IMSI, 
    SIM_ICCID, 
    SIM_OPERATOR, 
    SIM_APN 
};


enum ModemOperation
{
    DISABLE, 
    ENABLE, 
    SLEEP, 
    SW_RESTART, 
    HW_RESTART, 
    DISABLE_DATA_CONNECTION, 
    ENABLE_DATA_CONNECTION, 
};

typedef boost::function<void(boost::system::error_code, std::list<std::string> modems)> modem_list_handler_function;

typedef boost::function<void(boost::system::error_code, std::list<std::string> sims)> sim_list_handler_function;

typedef boost::function<void(boost::system::error_code error_code,std::string modemid, struct ModemStatus& status)> modem_status_handler_function;


typedef boost::function<void(boost::system::error_code, std::string modemid, ListEvent event)> modem_list_event_handler_function;

typedef boost::function<void(boost::system::error_code, std::string modemid, dpyModem::ModemWarning warning)> modem_warning_event_handler_function;

typedef boost::function<void(boost::system::error_code error_code,std::string modemid, const bool &enabled)> modem_data_connection_status_handler_function;

typedef boost::function<void(boost::system::error_code, ModemInfo modeminfo)> modem_info_handler_function;

typedef boost::function<void(boost::system::error_code, SimInfo siminfo)> sim_info_handler_function;

typedef boost::function<void(boost::system::error_code, std::string modemid, std::string simid, ListEvent event)> sim_list_event_handler_function;

typedef boost::function<void(boost::system::error_code, std::string simid, dpyModem::SimStatus status)> simStatus_handler_function;


typedef boost::function<void(const bool &available)> service_availability_handler_function;
typedef boost::function<void(boost::system::error_code& ec, ModemWarning warning_notif)> warning_handler_function; 
typedef boost::function<
        void(boost::system::error_code error_code, MODEM_INFO type, const std::string& value)> get_info_handler_function; 
typedef boost::function<
        void(boost::system::error_code error_code, const AccessPointNetwork& apn_info, const bool& forced_apn)> get_apn_handler_function; 
typedef boost::function<
        void(boost::system::error_code error_code, const AccessPointNetwork& apn_info)> get_apn_by_imsi_handler_function; 
typedef boost::function<void(boost::system::error_code error_code)> result_handler_function; 
typedef boost::function<void(boost::system::error_code error_code, const bool &enabled)> data_connection_status_handler_function; 
typedef boost::function<void(boost::system::error_code error_code, const std::string& modemId, const std::string& interfaceName, std::map<dpyNetworking::Statistics, uint32_t>statisticsValues, const std::string& interfaceIpAddress )> interface_statistics_function_handler; 

typedef boost::function<void(boost::system::error_code error_code, std::string modemid, int simSlot)> sim_slot_handler_function;

typedef boost::function<void(boost::system::error_code error_code, dpyModem::AccessPointNetwork found_apn)> forced_apn_handler_function;

} //dpyModem


#endif /* MODEM_TYPES_H_ */


class ModemManager
{
protected:
    boost::shared_ptr <ModemClient> mClient;
public:
    explicit ModemManager(std::string ip = "127.0.0.1");
    ~ModemManager();

    bool isAlive();

    void monitorServiceAvailability_S(dpyModem::service_availability_handler_function handler);

    void monitorServiceAvailability_U();

    void asyncGetModems(dpyModem::modem_list_handler_function handler);

    void asyncGetModemInfo(const std::string& modemid, dpyModem::modem_info_handler_function handler);

    void asyncGetModemStatus(const std::string& modemid, dpyModem::modem_status_handler_function handler);

    void getModemStatusEvents_S(dpyModem::modem_status_handler_function handler);

    void getModemListEvents_S(dpyModem::modem_list_event_handler_function handler);

    void getModemWarningEvents_S(dpyModem::modem_warning_event_handler_function handler);

    void asyncRequestModemOperation(const std::string& modemid, const dpyModem::ModemOperation& operation, dpyModem::result_handler_function handler);

    void asyncIsDataConnectionEnabled(const std::string& modemid,dpyModem::modem_data_connection_status_handler_function handler);


    void asyncGetModemSims(const std::string& modemid, dpyModem::sim_list_handler_function handler);

    void asyncGetActiveSims(const std::string& modemid, dpyModem::sim_list_handler_function handler);

    void asyncSwitchCurrentSimCard(const std::string& modemid, dpyModem::result_handler_function handler);

    void getCurrentSimSlot(const std::string& modemid, dpyModem::sim_slot_handler_function handler);

    void getSimListEvents_S (dpyModem::sim_list_event_handler_function handler);

    void getSimStatusEvents_S(dpyModem::simStatus_handler_function handler);
    void getSimStatusEvents_U();

    void asyncGetSimInfo(const std::string& simid, dpyModem::sim_info_handler_function handler);

    void asyncGetSimStatus(const std::string& simid, dpyModem::simStatus_handler_function handler);


    void asyncGetApnByImsi(const std::string& imsi, dpyModem::get_apn_by_imsi_handler_function handler);

    void asyncAddNewApn(const std::string& imsi, const dpyModem::AccessPointNetwork& apn, dpyModem::result_handler_function handler);

    void asyncDeleteApnByImsi(const std::string& imsi, dpyModem::result_handler_function handler);

    void asyncModifyApnByImsi(const std::string& current_imsi, const dpyModem::AccessPointNetwork& new_apn, dpyModem::result_handler_function handler);

    [[deprecated("Do not use the IMSI parameter to configure a forced APN. Forced APN is used for all inserted SIMs")]]
    void asyncForceCustomApn(const std::string& imsi, dpyModem::result_handler_function handler, const bool& force = false, const dpyModem::AccessPointNetwork& custom_apn = {});

    void asyncForceCustomApn(dpyModem::result_handler_function handler, const bool& force = false, const dpyModem::AccessPointNetwork& custom_apn = {});

    void asyncGetInterfaceStatistics(const std::string& modemid, dpyModem::interface_statistics_function_handler);

    void asyncForceNetworkMode(const std::string& modemid, dpyModem::NetworkMode mode,dpyModem::result_handler_function handler);

    void asyncGetForcedAPN(dpyModem::forced_apn_handler_function handler);

};