iModem.h

#ifndef IMODEM_H_
#define IMODEM_H_

#include <boost/system/error_code.hpp>
#include <boost/asio.hpp>
#include <boost/chrono.hpp>

#include <list>
#include <string>

#include "iSim.h"

namespace dpyModem {

typedef enum
{
    ADDED = 0, 
    REMOVED = 1, 
} ListEvent;

typedef enum
{
    MODEMMANAGERGENERIC_USB = 0,
    MODEMMANAGER_EM7455 = 1,
    BGS2W_PREINSTALLED = 2,
    MODEMMANAGER_RC7620 = 3,
    MODEMMANAGER_EC25 = 4,
    MODEMMANAGER_WP7607 = 5,
    MODEMMANAGER_RC7611 = 6,
    MODEMMANAGER_EG25 = 7,
    MODEMMANAGER_RG255C = 8
} ModemType;

enum ModemState
{
    DISABLED, 
    RESTARTING, 
    SLEEPING, 
    ENABLING_MODEM, 
    ENABLED_SIM_READY, 
    SERVICE_AVAILABLE_GOOD_SIGNAL, 
    CELLULAR_NETWORK_REG_HOME, 
    CELLULAR_NETWORK_REG_ROAMING, 
    DATA_CONNECTION_NOT_AVAILABLE, 
    DATA_CONNECTION_ENABLED, 
    DATA_CONNECTION_CONNECTING, 
    DATA_CONNECTION_ACTIVE, 
    DATA_CONNECTION_BACKOFF 
};

enum ModemPowerStatus
{
    MODEM_DISABLED, 
    MODEM_RESTART, 
    MODEM_SLEEP, 
    MODEM_ON 
};

enum SignalQuality
{
    ANTENNA_NOT_DETECTED, 
    POOR_SIGNAL_STRENGTH, 
    FAIR_SIGNAL_STRENGTH, 
    GOOD_SIGNAL_STRENGTH, 
    EXCELLENT_SIGNAL_STRENGTH 
};

enum NetworkStatus
{
    NOT_REGISTERED, 
    SEARCHING_OPERATOR, 
    REGISTERED_HOME_NET, 
    REGISTERED_ROAMING, 
    REGISTRATION_DENIED 
};

enum GPRS_NETWORK_STATUS
{
    GPRS_NOT_REGISTERED, 
    GPRS_SEARCHING_OPERATOR, 
    GPRS_REGISTERED_HOME_NET, 
    GPRS_REGISTERED_ROAMING, 
    GPRS_REGISTRATION_DENIED 
};

enum NetworkMode
{
    MODE_NONE = 0,   
    MODE_CS   = 1,  
    MODE_2G   = 2,  
    MODE_3G   = 4,  
    MODE_4G   = 8,  
    MODE_5G   = 16, 
    MODE_ANY  = 32, 
};


enum AccessTechnology
{
    NONE,     
    POTS,    
    GSM,     
    GPRS,     
    EDGE,     
    UMTS,     
    HSPA,     
    HSDPA,    
    HSUPA,    
    CDMA,     
    LTE,     
    NR5G     
};

struct ModemStatus
{
    ModemState currentState; 
    ModemPowerStatus powerStatus; 
    SimStatus simStatus; 
    SignalQuality signalQuality; 
    NetworkStatus cellularNetworkStatus; 
    AccessTechnology accessTech; 
};

struct ModemInfo
{
    std::string manufacturer; 
    std::string model; 
    std::string imei; 
    std::string fw_version; 
};


enum ModemWarning
{
    NOTIFY_UNDERVOLTAGE, 
    NOTIFY_OVERVOLTAGE, 
    NOTIFY_CLOSE_TO_UNDERTEMPERATURE, 
    NOTIFY_CLOSE_TO_OVERTEMPERATURE, 
    NOTIFY_UNDERTEMPERATURE, 
    NOTIFY_OVERTEMPERATURE, 
    NOTIFY_BACK_TO_NORMAL_TEMPERATURE, 
    NOTIFY_JAMMING, 
    NOTIFY_SHUTDOWN, 
    NOTIFY_RESTARTED 
};

struct CallConfig
{
    int audio_mode;
    int ringtone;
    int volume_ringtone;
    int volume_percent;
    int micro_gain;
    int micro_mult_factor;
};

} //dpyModem

class IModem;

class ModemObserver
{
public:
    virtual void updateModemState(const std::string& modemid,const dpyModem::ModemState& state) = 0;

    virtual void processModemWarningEvent(const std::string& modemid,const dpyModem::ModemWarning& warning) = 0;

    virtual void updateSimList(const std::string& modemid, const std::string& simid,const dpyModem::ListEvent& event) = 0;

    virtual ~ModemObserver()
    {
    }
};

class IModem
{
private:
    std::string mId; 
    std::vector<ModemObserver*> mObserversList; 

protected:
    std::map<std::string, boost::shared_ptr<ISim>> mIdToSimMap; 
    void setId(const std::string& id);
    void notifyModemStateUpdate(const std::string& modemid, const dpyModem::ModemState& status);
    void notifyModemWarningEvent(const std::string& modemid, const dpyModem::ModemWarning& warning);
    void notifySimListEvent(const std::string& modemid, const std::string& simid, const dpyModem::ListEvent& event);
    void notifySimStatusUpdate(const std::string& simid, const dpyModem::SimStatus& status);

public:

    virtual ~IModem();

    std::string getId() const;

    virtual boost::system::error_code getModemInfo(dpyModem::ModemInfo& info) const = 0;

    virtual boost::system::error_code getCurrentSim(boost::shared_ptr<ISim>& sim) const = 0;

    virtual boost::system::error_code getSims(std::list<boost::shared_ptr<ISim>>& list ) const = 0;

    virtual bool isSimActive(const std::string& simId) const = 0;

    virtual boost::system::error_code getActiveSims(std::list<boost::shared_ptr<ISim>>& list ) const = 0;

    virtual boost::system::error_code getSimById(const std::string& simid, boost::shared_ptr<ISim>& sim) const = 0;

    virtual boost::system::error_code getStatus(dpyModem::ModemStatus& status) = 0;

    virtual bool enableModem(boost::system::error_code& ec) = 0;

    virtual bool disableModem(boost::system::error_code& ec) = 0;

    virtual bool sleepModem(boost::system::error_code& ec) = 0;

    virtual bool softwareRestartModem(boost::system::error_code& ec) = 0;

    virtual bool hardwareRestartModem(boost::system::error_code& ec) = 0;

    virtual boost::system::error_code enableDataConnection() = 0;

    virtual boost::system::error_code disableDataConnection() = 0;

    virtual bool isDataConnectionEnabled() = 0;

    virtual boost::system::error_code forceNetworkMode(const dpyModem::NetworkMode& mode) = 0;

    boost::system::error_code subscribe(ModemObserver* observer);

    boost::system::error_code unsubscribe(ModemObserver* observer);

};

#endif /* IMODEM_H_ */