myvtm/Module/mod_DeviceControl/mod_DeviceControl.h

#ifndef _MOD_DEVICECONTROL_H
#define _MOD_DEVICECONTROL_H

#pragma once

#include "modVer.h"

#include "DeviceControlFSM.h"
#include "DevEntityCommBase.hpp"

// to get mac address
#include <string>
#include <vector>

#ifdef RVC_OS_WIN

#include <Winsock2.h>
#include <WS2tcpip.h>
#include <Iphlpapi.h>
#include "IHttpFunc.h"
#include "json.h"
#pragma comment(lib,"Iphlpapi")

#else

#include "SpTest.h"

#endif // RVC_OS_WIN

#pragma warning( disable : 4996 )

#define MACSESION 6

using namespace DeviceControl;

class CDeviceControlEntity;

class CDeviceControlServerSession : public DeviceControlService_ServerSessionBase
{
public:
    CDeviceControlServerSession(CDeviceControlEntity* pEntity) :m_pEntity(pEntity) {}
    virtual ~CDeviceControlServerSession() {}
    virtual void Handle_USB(SpReqAnsContext<DeviceControlService_USB_Req, DeviceControlService_USB_Ans>::Pointer ctx);
    virtual void Handle_GetUkeyID(SpReqAnsContext<DeviceControlService_GetUkeyID_Req, DeviceControlService_GetUkeyID_Ans>::Pointer ctx);
    virtual void Handle_InitToken(SpReqAnsContext<DeviceControlService_InitToken_Req, DeviceControlService_InitToken_Ans>::Pointer ctx);
    virtual void Handle_QueryUSBStatus(SpReqAnsContext<DeviceControlService_QueryUSBStatus_Req, DeviceControlService_QueryUSBStatus_Ans>::Pointer ctx);
    virtual void Handle_QueryHardwareInfo(SpReqAnsContext<DeviceControlService_QueryHardwareInfo_Req, DeviceControlService_QueryHardwareInfo_Ans>::Pointer ctx);
    virtual void Handle_ReadCenterConfigStr(SpReqAnsContext<DeviceControlService_ReadCenterConfigStr_Req, DeviceControlService_ReadCenterConfigStr_Ans>::Pointer ctx);
    virtual void Handle_ReadConfigValue(SpReqAnsContext<DeviceControlService_ReadConfigValue_Req, DeviceControlService_ReadConfigValue_Ans>::Pointer ctx);
    virtual void Handle_GetDevInfo(SpReqAnsContext<DeviceControlService_GetDevInfo_Req, DeviceControlService_GetDevInfo_Ans>::Pointer ctx);
    virtual void Handle_TestConnectivity(SpReqAnsContext<DeviceControlService_TestConnectivity_Req, DeviceControlService_TestConnectivity_Ans>::Pointer ctx);
    virtual void Handle_GetVendorFileList(SpReqAnsContext<DeviceControlService_GetVendorFileList_Req, DeviceControlService_GetVendorFileList_Ans>::Pointer ctx);
    virtual void Handle_TestAdapterFileAvailable(SpReqAnsContext<DeviceControlService_TestAdapterFileAvailable_Req, DeviceControlService_TestAdapterFileAvailable_Ans>::Pointer ctx);

private:
    CDeviceControlEntity* m_pEntity;
};

class CDeviceControlEntity : public CDevAdptEntityBase
{
public:
    CDeviceControlEntity(){}
    virtual ~CDeviceControlEntity()
    {

    }
    virtual const char* GetEntityName() const { return "DeviceControl"; }

    const char* GetEntityVersion() const { return MODULE_VERSION_FULL; }

#if defined(RVC_OS_LINUX)
	ON_ENTITYT_TEST()
#endif //RVC_OS_LINUX

	virtual void OnPreStart(CAutoArray<CSimpleStringA> strArgs, CSmartPointer<ITransactionContext> pTransactionContext);

    virtual void OnPrePause(CSmartPointer<ITransactionContext> pTransactionContext)
    {
        pTransactionContext->SendAnswer(Error_Succeed);
    }
    virtual void OnPreContinue(CSmartPointer<ITransactionContext> pTransactionContext)
    {
        pTransactionContext->SendAnswer(Error_Succeed);
    }

    virtual void OnPreClose(EntityCloseCauseEnum eCloseCause, CSmartPointer<ITransactionContext> pTransactionContext)
    {
        m_fsm.OnExit();
        pTransactionContext->SendAnswer(Error_Succeed);
    }

    virtual CServerSessionBase* OnNewSession(const char*, const char*)
    {
        return new CDeviceControlServerSession(this);
    }

    void USB(SpReqAnsContext<DeviceControlService_USB_Req, DeviceControlService_USB_Ans>::Pointer ctx)
    {
        ctx->Answer(Error_NotSupport);
    }

    void GetUkeyID(SpReqAnsContext<DeviceControlService_GetUkeyID_Req, DeviceControlService_GetUkeyID_Ans>::Pointer ctx)
    {
        ctx->Answer(Error_NotSupport);
    }

    void InitToken(SpReqAnsContext<DeviceControlService_InitToken_Req, DeviceControlService_InitToken_Ans>::Pointer ctx)
    {
        ctx->Answer(Error_NotSupport);
    }

    void QueryUSBStatus(SpReqAnsContext<DeviceControlService_QueryUSBStatus_Req, DeviceControlService_QueryUSBStatus_Ans>::Pointer ctx)
    {
        ctx->Answer(Error_NotSupport);
    }

    void QueryHardwareInfo(SpReqAnsContext<DeviceControlService_QueryHardwareInfo_Req, DeviceControlService_QueryHardwareInfo_Ans>::Pointer ctx);
    void ReadCenterConfigStr(SpReqAnsContext<DeviceControlService_ReadCenterConfigStr_Req, DeviceControlService_ReadCenterConfigStr_Ans>::Pointer ctx);

    void ReadConfigValue(SpReqAnsContext<DeviceControlService_ReadConfigValue_Req, DeviceControlService_ReadConfigValue_Ans>::Pointer ctx);

    void GetDevInfo(SpReqAnsContext<DeviceControlService_GetDevInfo_Req, DeviceControlService_GetDevInfo_Ans>::Pointer ctx)
    {
        ctx->Answer(Error_NotImpl);
    }

    void TestConnectivity(SpReqAnsContext<DeviceControlService_TestConnectivity_Req, DeviceControlService_TestConnectivity_Ans>::Pointer ctx);

    void GetVendorFileList(SpReqAnsContext<DeviceControlService_GetVendorFileList_Req, DeviceControlService_GetVendorFileList_Ans>::Pointer ctx);
    void TestAdapterFileAvailable(SpReqAnsContext<DeviceControlService_TestAdapterFileAvailable_Req, DeviceControlService_TestAdapterFileAvailable_Ans>::Pointer ctx);

    void OnSelfTest(EntityTestEnum eTestType, CSmartPointer<ITransactionContext> pTransactionContext)
    {
        m_fsm.SelfTest(eTestType, pTransactionContext);
    }

    virtual bool IsService()const { return true; }

    virtual bool IsMultiThread()const { return true; }

private:
    std::pair<ErrorCodeEnum, CSimpleStringA> __ReadCenterConfigStr(CSimpleStringA key, CSimpleStringA entityName);
    void BroadcastAdapterTestResult(const CSimpleStringA& adapterName, ErrorCodeEnum result, const CSimpleStringA& strErrMsg);
private:
    CDeviceControlFSM m_fsm;
};

#endif //_MOD_DEVICECONTROL_H