AutoUpdaterClient.h

#pragma once

#ifdef WIN32
#   ifndef _CRT_SECURE_NO_WARNINGS
#       define _CRT_SECURE_NO_WARNINGS
#   endif
#endif

#include <tchar.h>
#include <string>
#include <queue>

// ParaEngine includes
#include "PluginAPI.h"
#include "PluginLoader.hpp"

// ParaEngine interfaces that we use
#include "INPL.h"
#include "INPLRuntime.h"
#include "IParaEngineCore.h"
#include "IParaEngineApp.h"

#include "NPLInterface.hpp"

#include "util/Mutex.hpp"
#include "util/Semaphore.hpp"

namespace NPL
{
    class IAutoUpdaterClient
    {
    public:
        enum AutoUpdaterProgress
        {
            AUP_NOT_STARTED,
            AUP_STARTED,
            AUP_NOCHANGE,
            AUP_UNKNOWN,
            AUP_BROKENFILE,
            AUP_ERROR,
            AUP_PROGRESS,
            // apply patch completed
            AUP_COMPLETED,
            // info host to apply patch. 
            AUP_DO_APPLY_PATCH,
        };
        struct ProgressMessage
        {
            ProgressMessage():m_eventType(AUP_NOT_STARTED),m_finishcount(0), m_allcount(0) {};
            ProgressMessage(AutoUpdaterProgress eventType, const char* msg=NULL, int finishcount=0, int allcount=0)
                :m_eventType(eventType),m_finishcount(finishcount), m_allcount(allcount) 
            {
                if(msg)
                    m_msg = msg;
            };
            AutoUpdaterProgress m_eventType;
            std::string m_msg;
            int m_finishcount;
            int m_allcount;
        };

        class IAutoUpdaterCallback
        {
        public:
            virtual void OnProgress(const ProgressMessage& msg) = 0;
        };

        virtual void SetUpdaterDllPath(const char* sDllPath = NULL) = 0;

        virtual void OnProgress(AutoUpdaterProgress eventType, const char* msg=NULL, int finishcount=0, int allcount=0) = 0;

        virtual int BeginUpdate(const std::string& curVersion, const char* sUpdaterName = NULL) = 0;

        virtual void ActivateAutoUpdater(const std::string& sMsg) = 0;

        virtual void OnMessageCallback(NPLInterface::NPLObjectProxy& msg) = 0;

        virtual AutoUpdaterProgress WaitForCompletion(IAutoUpdaterCallback* pCallback = 0) = 0;

        virtual bool GetUpdaterMessage(ProgressMessage& msg) = 0;

        virtual bool PeekUpdaterMessage(ProgressMessage& msg) = 0;

        virtual void ExitUpdater() = 0;

        virtual void ApplyPatch() = 0;
    };

    class CAutoUpdaterClient : public INPLRuntimeState, public IAutoUpdaterClient
    {
    public:
        CAutoUpdaterClient();
        ~CAutoUpdaterClient();

    public:
        virtual void SetUpdaterDllPath(const char* sDllPath = NULL);

        virtual void ActivateAutoUpdater(const std::string& sMsg);

        virtual int BeginUpdate(const std::string& curVersion, const char* sUpdaterName = NULL);

        virtual void OnProgress(AutoUpdaterProgress eventType, const char* msg=NULL, int finishcount=0, int allcount=0);

        virtual void OnMessageCallback(NPLInterface::NPLObjectProxy& msg);

        virtual AutoUpdaterProgress WaitForCompletion(IAutoUpdaterCallback* pCallback = 0);

        virtual bool GetUpdaterMessage(ProgressMessage& msg);

        virtual bool PeekUpdaterMessage(ProgressMessage& msg);

        virtual void ExitUpdater();

        virtual void ApplyPatch();
    public:
        virtual const std::string& GetName() const;

        virtual int activate(const char * sNPLFilename, const char* sCode, int nCodeLength=0, int priority=2, int reliability=4);

        virtual NPLReturnCode Activate_async(const std::string & filepath, const char * code = NULL,int nLength=0, int priority=0);

        virtual NPLReturnCode ActivateLocal(const char* filepath, const char * code = NULL,int nLength=0, int priority=0);

        virtual NPLReturnCode Activate_async(NPLMessage_ptr& msg, int priority=0);

        virtual NPLReturnCode SendMessage(NPLMessage_ptr& msg, int priority=0);

        virtual const char* GetCurrentMsg();

        virtual int GetCurrentMsgLength();

        virtual INPLRuntime* GetNPLRuntime();

        virtual void WriteLog(const char* text, int nTextLen=0, int nLogType = 0);

        //
        // Timer functions
        //

        virtual bool SetTimer(int nIDEvent, float fElapse, const char* sNeuronFile) {return false;};

        virtual bool KillTimer(int nIDEvent) { return false;};

        virtual bool ChangeTimer(int nIDEvent, int dueTime, int period) { return false;};

        virtual void SetUpdateUrl(const std::string& updateurl);
        virtual void RegisterFile(const char* sFilename, INPLActivationFile* pFileHandler = NULL);

        virtual void call(const char * sNPLFilename, const char* sCode, int nCodeLength = 0);
    protected:
        const char* m_current_msg;

        int m_current_msg_length;

        std::string m_name;

        std::string m_updateurl;

        ParaEngine::CPluginLoader m_auto_updater_plugin;


        AutoUpdaterProgress m_progress_status;
        ParaEngine::Mutex m_mutex;
        ParaEngine::Semaphore m_semaphore;

        std::queue<ProgressMessage> m_msgs;

        std::string m_session_dir;
        std::string m_sApplyPatchMsg;
        std::string m_updater_plugin_path;

        IAutoUpdaterCallback* m_pUpdaterCallback;
    };
}