otaupdaterApi.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 <vector>
#include <map>

class OtaUpdaterClient;

#ifndef OTAUPDATER_TYPES
#define OTAUPDATER_TYPES

namespace dpyOtaupdater {
struct Channel
{
    std::string type = ""; 
    std::string baseurl = ""; 
};

enum ServiceStatus
{
    INIT = 0, 
    SYNCHRONIZING = 1, 
    IDLE = 2, 
    RECOVERING = 3, 
    OPERATING = 4, 
    COMPLETE_RFS = 5, 
    END = 6 
};

enum AltRFSStatus
{
    OK = 0, 
    ERROR = 1, 
    IN_PROCESS = 2, 
    UPGRADED = 3, 
    BACKUP = 4, 
};


enum OperationType
{
    NO_OPERATING = 0, 
    INSTALLING = 1, 
    UPGRADING = 2, 
    REMOVING = 3, 
    DOWNLOADING = 4, 
};

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

typedef boost::function<void(boost::system::error_code error_code, int status, int rfsstatus)> status_handler_function;

typedef boost::function<void(boost::system::error_code error_code, std::vector<std::pair<std::string, std::string>> &updatesList)> updateslist_handler_function;

typedef boost::function<void(boost::system::error_code error_code, std::map<std::string, std::pair<std::string, std::string>> &versionList)> versionlist_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, std::vector<std::pair<std::string, Channel>> &channelList)> channels_handler_function;

typedef boost::function<void(boost::system::error_code error_code, std::vector<std::pair<std::string, std::string>> &updatesList)> remoteversionlist_handler_function;

typedef boost::function<void(boost::system::error_code error_code, int operation, int percentage)> operation_percentage_handler_function;
}
#endif //OTAUPDATER_TYPES

class OtaUpdater
{
private:
    boost::shared_ptr<OtaUpdaterClient> mClient;
public:

    explicit OtaUpdater(std::string ip = "127.0.0.1");
#ifndef TESTING
    ~OtaUpdater();
#else
    virtual ~OtaUpdater();
#endif

#ifndef TESTING
    bool isAlive();
    void monitorServiceAvailability_S(dpyOtaupdater::service_availability_handler handler);
    void monitorServiceAvailability_U();
    void asyncGetUpdates(dpyOtaupdater::updateslist_handler_function handler);
    void asyncGetStatus(dpyOtaupdater::status_handler_function handler);
    void getStatus_S(dpyOtaupdater::status_handler_function handler);
    void getStatus_U();

    void asyncRepoSync(dpyOtaupdater::result_handler_function handler);
    void asyncUpgrade(dpyOtaupdater::result_handler_function handler, std::vector<std::string> packages = {""});
    void asyncInstall(dpyOtaupdater::result_handler_function handler, std::vector<std::string> packages = {""});
    void asyncUninstall(dpyOtaupdater::result_handler_function handler, std::vector<std::string> packages = {""});
    void asyncGetVersions(dpyOtaupdater::versionlist_handler_function handler, std::vector<std::string> packages = {""});
    void asyncGetRemoteVersions(dpyOtaupdater::remoteversionlist_handler_function handler, std::vector<std::string> packages = {});
    void asyncRollback(dpyOtaupdater::result_handler_function handler);
    void asyncDiscard(dpyOtaupdater::result_handler_function handler);
    void asyncAck(dpyOtaupdater::result_handler_function);

    void asyncAddChannel(dpyOtaupdater::result_handler_function handler, std::string name, dpyOtaupdater::Channel channel);
    void asyncDelChannel(dpyOtaupdater::result_handler_function handler, std::string name);
    void asyncGetChannels(dpyOtaupdater::channels_handler_function handler);

    void asyncGetOperationPercentage(dpyOtaupdater::operation_percentage_handler_function handler);
    void getOperationPercentage_S(dpyOtaupdater::operation_percentage_handler_function handler);
    void getOperationPercentage_U();

#else
    virtual bool isAlive();
    virtual void monitorServiceAvailability_S(dpyOtaupdater::service_availability_handler handler);
    virtual void monitorServiceAvailability_U();
    virtual void asyncGetUpdates(dpyOtaupdater::updateslist_handler_function handler);
    virtual void asyncGetStatus(dpyOtaupdater::status_handler_function handler);
    virtual void getStatus_S(dpyOtaupdater::status_handler_function handler);
    virtual void getStatus_U();
    virtual void asyncRepoSync(dpyOtaupdater::result_handler_function handler);
    virtual void asyncUpgrade(dpyOtaupdater::result_handler_function handler, std::vector<std::string> packages = {""});
    virtual void asyncInstall(dpyOtaupdater::result_handler_function handler, std::vector<std::string> packages = {""});
    virtual void asyncUninstall(dpyOtaupdater::result_handler_function handler, std::vector<std::string> packages = {""});
    virtual void asyncGetVersions(dpyOtaupdater::versionlist_handler_function handler, std::vector<std::string> packages = {""});
    virtual void asyncGetRemoteVersions(dpyOtaupdater::remoteversionlist_handler_function handler, std::vector<std::string> packages = {""});
    virtual void asyncRollback(dpyOtaupdater::result_handler_function handler);
    virtual void asyncDiscard(dpyOtaupdater::result_handler_function handler);
    virtual void asyncAck(dpyOtaupdater::result_handler_function);

    virtual void asyncAddChannel(dpyOtaupdater::result_handler_function handler, std::string name, dpyOtaupdater::Channel channel);
    virtual void asyncDelChannel(dpyOtaupdater::result_handler_function handler, std::string name);
    virtual void asyncGetChannels(dpyOtaupdater::channels_handler_function handler);


    virtual void asyncGetOperationPercentage(dpyOtaupdater::operation_percentage_handler_function handler);
    virtual void getOperationPercentage_S(dpyOtaupdater::operation_percentage_handler_function handler);
    virtual void getOperationPercentage_U();
#endif
};