myvtm/Module/mod_healthmanager/HealthManagerFSM.cpp

#include "stdafx.h"
#include <fstream>
#include <string>
#include <algorithm>
#ifdef RVC_OS_WIN
#include <io.h>
#else
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#endif

#include "CommEntityUtil.hpp"
#include "CommEntitySettings.hpp"
#include "mod_healthmanager.h"
#include "publicFunExport.h"
#include "iniutil.h"

using namespace std;
const int MAX_AYSNC_TIMEOUT = 60000;
const int MAX_IGNORE_TIMEOUT = 100;

unsigned long long GetTickCountRVC() {
#ifdef RVC_OS_WIN
	return GetTickCount64();
#else
	struct timespec ts;
	clock_gettime(CLOCK_MONOTONIC, &ts);
	return (ts.tv_sec * 1000 + ts.tv_nsec / 1000000);
#endif //RVC_OS_WIN
}
unsigned long long GetLastErrorRVC() {
#ifdef RVC_OS_WIN
	return GetLastError();
#else
	return errno;
#endif //RVC_OS_WIN
}

enum EntityOP
{
	OP_STOP_ENTITY,
	OP_START_ENTITY,
	OP_PAUSE_ENTITY,
	OP_TERMINATE_ENTITY,
	OP_CONTINUE_ENTITY,
};

bool StrEqualNoCase(const char *s1, const char *s2,int len)
{
	if (strlen(s1) != strlen(s2))
		return false;
	for (int i = 0; i < len; ++i)
	{
		if (toupper(s1[i]) != toupper(s2[i]))
			return false;
	}
	return true;
}

void CHealthManagerFSM::WaitALittleIfNecessary()
{
    if (IsCoolBootThisTime()) {
        GetEntityBase()->GetFunction()->ShowStartupInfo("正在初始化，请稍等片刻......");
        int millsec = 0;
        SP::Module::Comm::Settings::ReadConfigFromCenterAfterCfg(m_pEntity, "CoolBootDefaultWaitMillsecs", NULL, &millsec);
        if (millsec <= 0) {
			millsec = 30000;
        }

        Dbg("Sleep a little time %d", millsec);
        Sleep(millsec);
    }
}

ErrorCodeEnum CHealthManagerFSM::Initial()
{
    CSmartPointer<IEntityFunction> pFunc = GetEntityBase()->GetFunction();
    CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = pFunc.ConvertCase<IEntityFunctionPrivilege>();
    CSmartPointer<IAsynWaitSp> spWait;

    ErrorCodeEnum err;

	CSimpleStringA cfgPath = "";
	CSimpleStringA strCoreBoot("CoreBoot"), strSafeLoad("SafeLoad"), strOp("Operating"), strIEBrower("IEBrowser");
    
    GetEntityBase()->GetFunction()->GetSystemStaticInfo(m_sysInfo);
    Dbg("machinetype[%s],terminalID[%s]", (LPCTSTR)m_sysInfo.strMachineType, (LPCTSTR)m_sysInfo.strTerminalID);

    strCoreBoot = strCoreBoot + "." + m_sysInfo.strMachineType;
    strSafeLoad = strSafeLoad + "." + m_sysInfo.strMachineType;
    strOp = strOp + "." + m_sysInfo.strMachineType;
    m_strURL = strIEBrower + "." + m_sysInfo.strMachineType + ".Url";

    m_AccessAuthTries = 4;
    m_InitTries = 4;
    m_AccessAuthTimeout = 180000;
    m_InitializationTimeout = 180000;
    int tmpAATries, tmpInitTries, tmpAATimeout, tmpInitTimout;

    CSmartPointer<IConfigInfo> spConfig;
    err = GetEntityBase()->GetFunction()->OpenConfig(Config_Software, spConfig);
    if (err != Error_Succeed) {
        Dbg("open cfg file failed!");
        return Error_IO;
    }
    if (spConfig->ReadConfigValueInt("init", "AccessAuthTries", tmpAATries) == Error_Succeed)
        m_AccessAuthTries = tmpAATries;
    if (spConfig->ReadConfigValueInt("init", "InitTries", tmpInitTries) == Error_Succeed)
        m_InitTries = tmpInitTries;
    if (spConfig->ReadConfigValueInt("init", "AccessAuthTimeout", tmpAATimeout) == Error_Succeed)
        m_AccessAuthTimeout = tmpAATimeout;
    if (spConfig->ReadConfigValueInt("init", "InitializationTimeout", tmpInitTimout) == Error_Succeed)
        m_InitializationTimeout = tmpInitTimout;

    CSmartPointer<IConfigInfo> spConfigRoot;
    GetEntityBase()->GetFunction()->OpenConfig(Config_Root, spConfigRoot);
    CSimpleStringA csGpioVendor("");
    spConfigRoot->ReadConfigValue("Device.Gpio", "Vendor", csGpioVendor);
	if (csGpioVendor.GetLength() > 1) {
		m_hasCfgGpioInRootIni = true;
	}

    int count, cbNum, slNum, opNum;
    count = cbNum = slNum = opNum = 0;

    err = GetEntityBase()->GetFunction()->GetPath("cfg", cfgPath);
    cfgPath = cfgPath + "/HealthManager.ini";
    Dbg("cfgpath[%s]", (const char*)cfgPath);

    ifstream is;
    is.open(cfgPath, ios::binary);
    if (!is.is_open()) {
        DWORD dwErr = GetLastErrorRVC();
        Dbg("open cfg file failed. [%d]", dwErr);
        return Error_IO;
    }
    string line;
    long curr, end;
    is.seekg(0, ios_base::end);
    end = is.tellg();
    is.seekg(0, ios_base::beg);
    LoadStage eSection = LOADSTAGE_UNKNOWN;

    do {
        getline(is, line);
        if (line[0] == '[') {
            size_t secEnd = line.find(']', 1);
            if (secEnd != string::npos) {
                string strSec = line.substr(1, secEnd - 1);
                if (StrEqualNoCase(strSec.c_str(), strCoreBoot, strSec.length()))
                    eSection = LOADSTAGE_COREBOOT;
                else if (StrEqualNoCase(strSec.c_str(), strSafeLoad, strSec.length()))
                    eSection = LOADSTAGE_SAFELOAD;
                else if (StrEqualNoCase(strSec.c_str(), strOp, strSec.length()))
                    eSection = LOADSTAGE_OPERATING;
                else
                    eSection = LOADSTAGE_UNKNOWN;
            }
        } else if (((unsigned)(line[0] + 1) > 256) || line[0] == ';') {//Chinese and other...
            curr = is.tellg();
            continue;
        } else if (isalpha(line[0])) {
            if (eSection == LOADSTAGE_UNKNOWN) {
                curr = is.tellg();
                continue;
            }
            size_t keyPos = line.find('=', 0);
            if (keyPos != string::npos) {
                string keyName = line.substr(0, keyPos);
                count++;
                switch (eSection) {
                case LOADSTAGE_COREBOOT:
                    spConfig->ReadConfigValueInt(strCoreBoot, keyName.c_str(), m_coreBootOpt[keyName.c_str()].loadOpt);
                    m_vCoreBoot.push_back(keyName.c_str());
                    m_vAllCfgEntity.push_back(keyName.c_str());
                    m_coreBootOpt[keyName.c_str()].eResult = LOADING_INIT;
                    m_coreBootOpt[keyName.c_str()].initSn = cbNum;
                    cbNum++;
                    break;
                case LOADSTAGE_SAFELOAD:
                    spConfig->ReadConfigValueInt(strSafeLoad, keyName.c_str(), m_safeLoadOpt[keyName.c_str()].loadOpt);
                    m_vSafeLoad.push_back(keyName.c_str());
                    m_vAllCfgEntity.push_back(keyName.c_str());
                    m_safeLoadOpt[keyName.c_str()].eResult = LOADING_INIT;
                    m_safeLoadOpt[keyName.c_str()].initSn = slNum;
                    slNum++;
                    break;
                case LOADSTAGE_OPERATING:
                    spConfig->ReadConfigValueInt(strOp, keyName.c_str(), m_operatingOpt[keyName.c_str()].loadOpt);
                    if (keyName.compare("Gpio") == 0 && !m_hasCfgGpioInRootIni)
                        Dbg("have configure gpio in HealthManager.ini,but can't find gpio in root.ini,ignore start gpio.");
                    else {
                        m_vOperating.push_back(keyName.c_str());
                        m_vAllCfgEntity.push_back(keyName.c_str());
                        m_operatingOpt[keyName.c_str()].eResult = LOADING_INIT;
                        m_operatingOpt[keyName.c_str()].initSn = opNum;
                        opNum++;
                    }
                    break;
                default:
                    break;
                }
            }
        }
        curr = is.tellg();
    } while (curr < end);

    is.close();
    Dbg("opt num:[%d]c[%d]s[%d]o[%d]", count, m_coreBootOpt.size(), m_safeLoadOpt.size(), m_operatingOpt.size());

    //read entity loading history record
    CSimpleStringA sysinfoPath = "";

#if defined(RVC_OS_LINUX)
    if (!m_sysInfo.strMachineType.IsNullOrEmpty() && m_sysInfo.strMachineType.Compare("RVC.Stand2S") != 0) {
        CSimpleStringA strErrMsg = CSimpleStringA::Format("当前版本不支持此机型：%s", (LPCTSTR)m_sysInfo.strMachineType);
        SP::Module::Comm::LogErrorNotiyStruct notifyItem(Error_NotSupport, 0);
        SP::Module::Comm::LogNotiyMessageStruct notifyMsg(strErrMsg);
        notifyItem.Notify(notifyMsg);
        return Error_Succeed;
    }
#endif //RVC_OS_LINUX

	GetEntityBase()->GetFunction()->SetSysVar("TerminalStage", "X");
    WaitDeamonFinishTask* task = new WaitDeamonFinishTask(this);
    GetEntityBase()->GetFunction()->PostThreadPoolTask(task);

    return Error_Succeed;
}

ErrorCodeEnum CHealthManagerFSM::OnInit(void)
{
	m_hMD5OKEvt = CreateEventA(NULL, FALSE, FALSE, NULL);
	if (m_hMD5OKEvt == NULL)
	{
		Dbg("CreateEvent failed(%d).", GetLastErrorRVC());
	}
	return Initial();
}
ErrorCodeEnum CHealthManagerFSM::OnExit(void)
{
	return Error_Succeed;
}

void CHealthManagerFSM::s0_on_entry(void)
{
	LOG_FUNCTION();
	m_fsmState = HM_FSM_INIT;
}

void CHealthManagerFSM::s0_on_exit(void)
{
}

unsigned int CHealthManagerFSM::s0_on_event(FSMEvent* pEvt)
{
	LOG_FUNCTION();
	int ret = 0;
	switch(pEvt->iEvt)
	{
	case USER_EVT_WAIT_DEAMON_FINISHED:
		ret = pEvt->param1;
		pEvt->SetHandled();
		break;
	default:
		break;
	}
	return ret;
}

bool CHealthManagerFSM::IsCoolBootThisTime()
{
    //oilyang@20190924
//修改为判断冷热启动，热重启不再等待10s
//系统启动小于1.5分钟，认为是冷启动
    const ULONGLONG dwElapse = GetTickCountRVC();

	int millsec = 0;
	SP::Module::Comm::Settings::ReadConfigFromCenterAfterCfg(m_pEntity, "BootMaxMillsecsSeeAsAutoRun", NULL, &millsec);
	if (millsec <= 0) {
		millsec = 90000;
	}

    Dbg("have elapsed %d seconds from system start vs %d", dwElapse / 1000, millsec / 1000);
    if (dwElapse < millsec) {
        return true;
    }
    return false;
}

//CoreBoot
void CHealthManagerFSM::s1_on_entry()
{
	ErrorCodeEnum eErrCode;
	CSmartPointer<IEntityFunction> spEntityFunction = GetEntityBase()->GetFunction();
	CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = spEntityFunction.ConvertCase<IEntityFunctionPrivilege>();
	CEntityRunInfo browserInfo;
	if (IsCutIEBrowser())
		eErrCode = spEntityFunction->GetEntityRunInfo("Chromium", browserInfo);
	else
		eErrCode = spEntityFunction->GetEntityRunInfo("IEBrowser", browserInfo);
	if (browserInfo.eState == EntityState_Idle)
	{
		Dbg("IE idle before healthmanager, maybe healthmanager have been losted.");
		m_bIEBeforeHealth = true;
	}

	m_fsmState = HM_FSM_STATE_COREBOOT;

	WaitALittleIfNecessary();

	eErrCode = GetEntityBase()->GetFunction()->SetSysVar("RunState","B");
	if (eErrCode != Error_Succeed)
	{
		Dbg("set RunState B failed %s.", SpStrError(eErrCode));
	}

	bool bWatchDog = false,bAsync = false;
	m_eStage = LOADSTAGE_COREBOOT;
	int ret = 0;
	map<CSimpleStringA,EntityLoadInfo>::iterator it;
	//start entity
	
	vector<CSimpleStringA>::iterator vIt;
	if (m_coreBootOpt.size() == 0)
		goto COREBOOT_FINISH;

	char startMsg[128];
	for (vIt = m_vCoreBoot.begin(); vIt != m_vCoreBoot.end(); ++ vIt)
	{
		CSmartPointer<IAsynWaitSp> spWait;//oilyang 20160325 see the following comment
		it = m_coreBootOpt.find(*vIt);
		if (it == m_coreBootOpt.end())
		{
			Dbg("cannot find %s",(LPCSTR)*vIt);
			continue;
		}
		Dbg("start,%s,%d",(LPCSTR)it->first,it->second.loadOpt);
		CEntityRunInfo entRunInfo;
		ErrorCodeEnum errCode = spEntityFunction->GetEntityRunInfo(it->first,entRunInfo);
		if (errCode == Error_Succeed && entRunInfo.eState == EntityState_Idle)
		{
			it->second.eResult = LOADING_SUCCEED;
			ret = CheckLoadResult(LOADSTAGE_COREBOOT);
			if (ret == 0 || ret == 2)
				goto COREBOOT_FINISH;
			else
				continue;
		}
		ZeroMemory(startMsg, 128);
		//sprintf(startMsg, "正在启动实体%s...", it->first.GetData());
		//GetEntityBase()->GetFunction()->ShowStartupInfo(startMsg);
		switch(it->second.loadOpt)
		{
			case LOADOPT_IGNORE:
			{
				pFuncPrivilege->StartEntity(it->first,NULL,spWait);
				if (spWait != NULL)
					spWait->WaitAnswer(MAX_IGNORE_TIMEOUT);//oilyang 20160325 the null pointer
				it->second.eResult = LOADING_SUCCEED;
				ret = CheckLoadResult(LOADSTAGE_COREBOOT);
				if (ret == 0 || ret == 2)
					goto COREBOOT_FINISH;
			}
			break;
		case LOADOPT_ASYNC_VERIFY:
			errCode = AsyncStartEntity(it->first,NULL,NULL);
			Dbg("%d",errCode);
			bAsync = true;
			break;
		case LOADOPT_SYNC_VERIFY:
			{
				pFuncPrivilege->StartEntity(it->first,NULL,spWait);
				if (spWait != NULL)
					errCode = spWait->WaitAnswer(MAX_AYSNC_TIMEOUT);
				Dbg("(coreboot)sync...%d",errCode);
				if (errCode == Error_Succeed)
					it->second.eResult = LOADING_SUCCEED;
				else if (errCode == Error_TimeOut)
					it->second.eResult = LOADING_TIMEOUT;
				else
					it->second.eResult = LOADING_FAILED;

				if (_strnicmp(it->first,"WatchDog",strlen("WatchDog")) == 0 
					&& it->second.eResult == LOADING_SUCCEED)
					bWatchDog = true;

				if (errCode != Error_Succeed) {
					ShowEntityBootFailedAtFront(it->first, errCode);
					return;
				}
				else
					ret = CheckLoadResult(LOADSTAGE_COREBOOT);
				Dbg("s1 check ret %d",ret);
				if (ret == 0 || ret == 2)
					goto COREBOOT_FINISH;
			}
			break;
		default:
			break;
		}
	}

COREBOOT_FINISH:

	//start watchdog if have load it sucessfully
	if (bWatchDog)
	{
		/**TODO(Gifur@5/21/2021): 国产化容易出现卡死现象，找个时间点把看门狗的逻辑加上去 */
	}

	if (!bAsync)
	{
		FSMEvent *e = new FSMEvent(USER_EVT_COREBOOT_FINISHED);
		e->param1 = ret;
		PostEventFIFO(e);
	}
	else
	{
		ret = CheckLoadResult(LOADSTAGE_COREBOOT);
		if (ret == 0 || ret == 2)
		{
			FSMEvent *e = new FSMEvent(USER_EVT_COREBOOT_FINISHED);
			e->param1 = ret;
			PostEventFIFO(e);
		}
	}
	return;
}
void CHealthManagerFSM::s1_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CHealthManagerFSM::s1_on_event(FSMEvent* pEvt)
{
	LOG_FUNCTION();
	Dbg("s1 evt %d",pEvt->iEvt);
	switch(pEvt->iEvt)
	{
	case USER_EVT_COREBOOT_FINISHED:
		pEvt->SetHandled();
		if (pEvt->param1 == 2) {
			ShowEntityBootFailedAtFront(m_csErrEntity, Error_InvalidState);
		}
		return pEvt->param1;
		break;
	case USER_EVT_ENTER_CUSTOMER_MANAGER:
		pEvt->SetHandled();
		break;
	default:
		break;
	}
	return 0;
}

//SafeLoad
void CHealthManagerFSM::s2_on_entry()
{
	LOG_FUNCTION();

	m_fsmState = HM_FSM_STATE_SAFELOAD;
	Sleep(1000);

#if defined(RVC_OS_WIN)
	USBControl();
#endif //RVC_OS_WIN

	CSimpleStringA xMsg = CSimpleStringA::Format("\"Decripstion\":\"Enter safeload state.\",\"version:\"%s\"}"
												 , m_sysInfo.InstallVersion.ToString().GetData());
	LogWarn(Severity_Low, Error_Unexpect, HealthManager_UserErrorCode_Enter_SafeLoad_State, xMsg);	
	
	ErrorCodeEnum eErrCode;
	eErrCode = GetEntityBase()->GetFunction()->SetSysVar("RunState","S");
	if (eErrCode != Error_Succeed)
	{
		Dbg("set RunState S failed (%d).",eErrCode);
	}

	bool bAsync = false;
	m_eStage = LOADSTAGE_SAFELOAD;
	int ret = 0;
	map<CSimpleStringA,EntityLoadInfo>::iterator it;
	CSmartPointer<IEntityFunction> pFunc = GetEntityBase()->GetFunction();
	CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = pFunc.ConvertCase<IEntityFunctionPrivilege>();
	
	ErrorCodeEnum errCode;
	vector<CSimpleStringA>::iterator vIt;
	if (m_safeLoadOpt.size() == 0)
		goto SAFELOAD_FINISH;
	char startMsg[128];
	for (vIt = m_vSafeLoad.begin(); vIt != m_vSafeLoad.end(); ++vIt)
	{
		CSmartPointer<IAsynWaitSp> spWait;
		it = m_safeLoadOpt.find(*vIt);
		if (it == m_safeLoadOpt.end())
		{
			Dbg("cannot find %s",(LPCSTR)*vIt);
			continue;
		}
		CEntityRunInfo entRunInfo;
		errCode = pFunc->GetEntityRunInfo(it->first,entRunInfo);
		if (errCode == Error_Succeed && entRunInfo.eState == EntityState_Idle)
		{
			it->second.eResult = LOADING_SUCCEED;
			ret = CheckLoadResult(LOADSTAGE_SAFELOAD);
			if (ret == 0 || ret == 2)
				goto SAFELOAD_FINISH;
			else
				continue;
		}
		Dbg("start %s,%d",(LPCTSTR)it->first,it->second.loadOpt);
		switch(it->second.loadOpt)
		{
		case LOADOPT_IGNORE:
			{
				pFuncPrivilege->StartEntity(it->first,NULL,spWait);
				if (spWait != NULL)
					spWait->WaitAnswer(MAX_IGNORE_TIMEOUT);
				it->second.eResult = LOADING_SUCCEED;
				ret = CheckLoadResult(LOADSTAGE_SAFELOAD);
				if (ret == 0 || ret == 2)
					goto SAFELOAD_FINISH;
			}
			break;
		case LOADOPT_ASYNC_VERIFY:
			AsyncStartEntity(it->first,NULL,NULL);
			bAsync = true;
			break;
		case LOADOPT_SYNC_VERIFY:
			{
			ZeroMemory(startMsg, 128);
			sprintf(startMsg, "正在启动实体%s...", it->first.GetData());
			GetEntityBase()->GetFunction()->ShowStartupInfo(startMsg);
				pFuncPrivilege->StartEntity(it->first,NULL,spWait);
				if (spWait != NULL)
					errCode = spWait->WaitAnswer(MAX_AYSNC_TIMEOUT);
				Dbg("sync...%d",eErrCode);
				if (errCode == Error_Succeed) {
					it->second.eResult = LOADING_SUCCEED;

#if defined(RVC_OS_WIN)
                    if (StrEqualNoCase("MaintainWatcher", it->first, strlen("MaintainWatcher"))) {
                        Sleep(10000);
                        if (m_custMngerState == CM_ENTER) {
                            Dbg("enter CMS...");
                            FSMEvent* pEvt = new FSMEvent(USER_EVT_ENTER_CUSTOMER_MANAGER);
                            PostEventFIFO(pEvt);
                            goto SAFELOAD_END;
                        }
                    }
#endif //RVC_OS_WIN

				}
				else if (errCode == Error_TimeOut)
					it->second.eResult = LOADING_TIMEOUT;
				else
					it->second.eResult = LOADING_FAILED;
				if (it->second.eResult != Error_Succeed)
				{
					char tmp[64] = {0};
				sprintf(tmp, "实体 %s 启动失败 %d", it->first.GetData(), it->second.eResult);
					Dbg("%s",tmp);
				}
                if (errCode != Error_Succeed) {
                    ShowEntityBootFailedAtFront(it->first, errCode);
					m_csErrEntity = m_csErrEntity + "|" + it->first;
					FSMEvent* e = new FSMEvent(USER_EVT_SAFELOAD_FINISHED);
					e->param1 = 2;//"SYNC START" enity started failed.
					PostEventFIFO(e);
                    return;
                }
			//if (errCode != Error_Succeed)
			//	return;
			//else
					ret = CheckLoadResult(LOADSTAGE_SAFELOAD);
				if (ret == 0 || ret == 2)
					goto SAFELOAD_FINISH;
			}
			break;
		default:
			break;
		}
	}

SAFELOAD_FINISH:

	if (!bAsync)
	{
		FSMEvent *e = new FSMEvent(USER_EVT_SAFELOAD_FINISHED);
		e->param1 = ret;
		PostEventFIFO(e);
	}
	else
	{
		ret = CheckLoadResult(LOADSTAGE_SAFELOAD);
		Dbg("s2 %d",ret);
		if (ret == 0 || ret == 2)
		{
			FSMEvent *e = new FSMEvent(USER_EVT_SAFELOAD_FINISHED);
			e->param1 = ret;
			PostEventFIFO(e);
		}
	}

SAFELOAD_END:

	return ;
}

void CHealthManagerFSM::s2_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CHealthManagerFSM::s2_on_event(FSMEvent* pEvt)
{
	LOG_FUNCTION();
	int ret = 0;
	Dbg("s2 event %d,%d",pEvt->iEvt,pEvt->param1);
	switch(pEvt->iEvt)
	{
	case USER_EVT_SAFELOAD_FINISHED:
		{
			pEvt->SetHandled();
			//ToCheckUPS();
			//oiltmp
			//according to the system varible TerminalState to do sth.
			//Configed
			//Breakdown
			//Blocking
			//Authentication
			{
				if(pEvt->param1 == 0)
				{
					//initializer if configured
					CSimpleStringA csTermStage("");
					ErrorCodeEnum eErrCode;
					eErrCode = GetEntityBase()->GetFunction()->GetSysVar("TerminalStage",csTermStage);
					Dbg("after safeload to get termstage %s",(LPCTSTR)csTermStage);
					if (csTermStage == "B" || csTermStage == "N")
						return 1;
				}
				else if (pEvt->param1 == 2)
				{
					ShowEntityBootFailedAtFront(m_csErrEntity, Error_InvalidState);
					ret = 2;
				}

			}
			//Unsubscrible
		}
		break;
	case USER_EVT_SAFELOAD_EXMINE_FINISHED:
		if (pEvt->param1 == 0)
			ret = 0;
		//do something else oiltmp
		pEvt->SetHandled();
		break;
	case USER_EVT_ACCESSAUTH_FINISHED:
		pEvt->SetHandled();
		ret = pEvt->param1;
		break;
	case USER_EVT_ENTER_CUSTOMER_MANAGER:
		pEvt->SetHandled();
		break;
	default:
		break;
	}
	return ret;
}

//Operating
void CHealthManagerFSM::s3_on_entry()
{
	LOG_FUNCTION();

	m_fsmState = HM_FSM_STATE_OP;

#if defined(RVC_OS_WIN)
	Sleep(5000);//oilyang for nantian pinpad 20150703
#endif //RVC_OS_WIN

	if (m_custMngerState == CM_ENTER)
	{
		Dbg("in CMS,no need to start hardware.");
		return;
	}
	ErrorCodeEnum eErrCode;
	eErrCode = GetEntityBase()->GetFunction()->SetSysVar("RunState","O");
	if (eErrCode != Error_Succeed)
	{
		Dbg("set RunState O failed (%d).",eErrCode);
	}
	
	bool bAsync = false;
	m_eStage = LOADSTAGE_OPERATING;
	int ret = 0;
	map<CSimpleStringA,EntityLoadInfo>::iterator it;
	CSmartPointer<IEntityFunction> pFunc = GetEntityBase()->GetFunction();
	CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = pFunc.ConvertCase<IEntityFunctionPrivilege>();
	//start entity	
	
	ErrorCodeEnum errCode;
	vector<CSimpleStringA>::iterator vIt;
	if (m_operatingOpt.size() == 0)
		goto OPERATING_FINISH;
	char startMsg[128];
	for (vIt = m_vOperating.begin(); vIt != m_vOperating.end(); ++vIt)
	{
		CSmartPointer<IAsynWaitSp> spWait;
		it = m_operatingOpt.find(*vIt);
		if (it == m_operatingOpt.end())
		{
			Dbg("cannot find %s",(LPCSTR)*vIt);
			continue;
		}

		CEntityRunInfo entRunInfo;
		errCode = pFunc->GetEntityRunInfo(it->first,entRunInfo);
		if (errCode == Error_Succeed && entRunInfo.eState == EntityState_Idle)
		{
			it->second.eResult = LOADING_SUCCEED;
			ret = CheckLoadResult(LOADSTAGE_OPERATING);
			if (ret == 0 || ret == 2)
				goto OPERATING_FINISH;
			else
				continue;
		}
		Dbg("op start %s,%d",(LPCTSTR)it->first,it->second.loadOpt);
		switch(it->second.loadOpt)
		{
		case LOADOPT_IGNORE:
			{
				pFuncPrivilege->StartEntity(it->first,NULL,spWait);
				if (spWait != NULL)
					spWait->WaitAnswer(MAX_IGNORE_TIMEOUT);
				it->second.eResult = LOADING_SUCCEED;
				ret = CheckLoadResult(LOADSTAGE_OPERATING);
				if (ret == 0 || ret == 2)
					goto OPERATING_FINISH;
			}
			break;
		case LOADOPT_ASYNC_VERIFY:
			errCode = AsyncStartEntity(it->first,NULL,NULL);
			bAsync = true;
			break;
		case LOADOPT_SYNC_VERIFY:
			{
			ZeroMemory(startMsg, 128);
			sprintf(startMsg, "正在启动实体%s...", it->first.GetData());
			GetEntityBase()->GetFunction()->ShowStartupInfo(startMsg);
				errCode = pFuncPrivilege->StartEntity(it->first,NULL,spWait);
				if (errCode == Error_Succeed)
				{
					if (spWait != NULL)
						errCode = spWait->WaitAnswer(MAX_AYSNC_TIMEOUT);
				}
				else
				{
					Dbg("StartEntity %s failed(%d).",(LPCSTR)it->first,errCode);
					break;
				}
				if (errCode == Error_Succeed)
					it->second.eResult = LOADING_SUCCEED;
				else if (errCode == Error_TimeOut)
					it->second.eResult = LOADING_TIMEOUT;
				else
					it->second.eResult = LOADING_FAILED;
				if (it->second.eResult != Error_Succeed)
				{
					char tmp[64] = {0};
					sprintf(tmp, "实体 %s 启动失败", it->first.GetData());
					Dbg("%s", tmp);
				}
                if (errCode != Error_Succeed) {
                    ShowEntityBootFailedAtFront(it->first, errCode);
									m_csErrEntity = m_csErrEntity + "|" + it->first;
				FSMEvent* e = new FSMEvent(USER_EVT_OPERATING_FINISHED);
				e->param1 = 2;//"SYNC START" enity started failed.
				PostEventFIFO(e);
				return;
                    return;
                }
				else
					ret = CheckLoadResult(LOADSTAGE_OPERATING);
				if (ret == 0 || ret == 2)
					goto OPERATING_FINISH;
			}
			break;
		default:
			break;
		}
	}

OPERATING_FINISH:

	Dbg("s3 ret %d",ret);
	if (!bAsync)
	{
		FSMEvent *e = new FSMEvent(USER_EVT_OPERATING_FINISHED);
		e->param1 = ret;
		PostEventFIFO(e);
	}
	else
	{
		ret = CheckLoadResult(LOADSTAGE_OPERATING);
		if (ret == 0 || ret == 2)
		{
			FSMEvent *e = new FSMEvent(USER_EVT_OPERATING_FINISHED);
			e->param1 = ret;
			PostEventFIFO(e);
		}
	}

	return ;
}
void CHealthManagerFSM::s3_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CHealthManagerFSM::s3_on_event(FSMEvent* pEvt)
{
	LOG_FUNCTION();
	Dbg("s3(Operating) event %d,%d",pEvt->iEvt,pEvt->param1);
	int ret = 0;
	switch(pEvt->iEvt)
	{
	case USER_EVT_OPERATING_FINISHED:
		ret = pEvt->param1;
        if (ret == 2) {
            ShowEntityBootFailedAtFront(m_csErrEntity, Error_InvalidState);
        }
		pEvt->SetHandled();
		break;
	case USER_EVT_ENTER_CUSTOMER_MANAGER:
		pEvt->SetHandled();
		break;
	default:
		break;
	}
	return ret;
}

//Idle(Operating finished)
void CHealthManagerFSM::s4_on_entry()
{
	LOG_FUNCTION();
	m_fsmState = HM_FSM_STATE_IDLE;
	m_accessAuthCheckMD5 = 0;
	CSmartPointer<IEntityFunction> spEntityFunction = GetEntityBase()->GetFunction();
	CSmartPointer<IConfigInfo> spConfig, spCerConfig;
	ErrorCodeEnum eErrCer = spEntityFunction->OpenConfig(Config_CenterSetting, spCerConfig);
	if (eErrCer != Error_Succeed) {
		Dbg("open central cfg file failed!");
	}
	else
		spCerConfig->ReadConfigValueInt("AccessAuthorization", "CheckMD5", m_accessAuthCheckMD5);
	Dbg("before access auth,read MD5 flag:%d",m_accessAuthCheckMD5);
	if (!m_bIdleToMaintain)
	{	
		if (!m_bAccessAuth)
		{
			AccessAuthTask* pTask = new AccessAuthTask(this);
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
		}
	}
	else
		m_bIdleToMaintain = false;
}

void CHealthManagerFSM::s4_on_exit()
{
	LOG_FUNCTION();
}

unsigned int CHealthManagerFSM::s4_on_event(FSMEvent* pEvt)
{
	LOG_FUNCTION();
	Dbg("s4 event %d,%d",pEvt->iEvt,pEvt->param1);
	switch(pEvt->iEvt)
	{
	case USER_EVT_ACCESSAUTH_FINISHED:
		{
			pEvt->SetHandled();
			if (pEvt->param1 == 1)
			{
				SetAccessAuth(false);
				//why to do this???
				//LogEvent(Severity_Middle,EVENT_CONSOLE_REQ_RESTART_SHELL,"AccessAuth failed,to restart spshell.");
				//return 1;
			}
			
			CSimpleStringA csTermStage;
			ErrorCodeEnum eErrCode;
			eErrCode = GetEntityBase()->GetFunction()->GetSysVar("TerminalStage",csTermStage);
			Dbg("after accessauth to get termstage %s",(LPCTSTR)csTermStage);
			//oilyang@20170316@comment
			//for user desktop,start iebrowser no matter what TerminalStage is.
			//if (csTermStage[0] != 'A')
			//	break;
			eErrCode = GetEntityBase()->GetFunction()->SetSysVar("RunState","O");
			if (eErrCode != Error_Succeed)
			{
				Dbg("set RunState O failed (%d).",eErrCode);
			}
			CSmartPointer<IEntityFunction> spEntityFunction = GetEntityBase()->GetFunction();
			CSmartPointer<IConfigInfo> spConfigRun,spCerConfig;
			ErrorCodeEnum eErrIE = spEntityFunction->OpenConfig(Config_Run, spConfigRun);
			if (eErrIE != Error_Succeed) {
				Dbg("open cfg file(ie) failed!");
				//return err;
			}
			ErrorCodeEnum eErrCerUrl = spEntityFunction->OpenConfig(Config_CenterSetting, spCerConfig);
			if (eErrCerUrl != Error_Succeed) {
				Dbg("open central cfg file(ie) failed!");
			}
			//if load successfully,set FailTimes to 0
			spConfigRun->WriteConfigValueInt("Run","FailTimes",0);

			if (m_bAccessAuth)
			{
				eErrCode = QueryCheckCode(m_checkCode);
				if (eErrCode && m_checkCode.GetLength() > 1)
					m_bEverAuthSucWithDevice = true;
				else
					m_bEverAuthSucWithDevice = false;
			}
			else
			{
				AuthStatus as;
				if (m_bEverAuthSucWithDevice)
				{
					as.result = 1;
					as.msg = "设备混用，请接入对应设备或后台重新绑定当前设备";
					//SpSendBroadcast(GetEntityBase()->GetFunction(), SP_MSG_OF(AuthStatus), SP_MSG_SIG_OF(AuthStatus), as);
				}
				else
				{
					as.result = 11;
					as.msg = "请检查设备是否正常初始化或是否对应绑定设备";
					//SpSendBroadcast(GetEntityBase()->GetFunction(), SP_MSG_OF(AuthStatus), SP_MSG_SIG_OF(AuthStatus), as);
				}
			}
			m_strURLValue = "";

#ifdef RVC_OS_WIN
			eErrCerUrl = spCerConfig->ReadConfigValue(GetEntityBase()->GetEntityName(), m_strURL, m_strURLValue);
			if (eErrIE == Error_Succeed)
			{
				Dbg("write ie url.sys [%s]", (const char*)m_strURLValue);
				GetEntityBase()->GetFunction()->SetSysVar("IEUrl", m_strURLValue);
			}
			CSmartPointer<IAsynWaitSp> spWait;
			CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = spEntityFunction.ConvertCase<IEntityFunctionPrivilege>();
			CEntityRunInfo acInfo;
			if (IsCutIEBrowser())
				eErrCode = spEntityFunction->GetEntityRunInfo("Chromium",acInfo);
			else
				eErrCode = spEntityFunction->GetEntityRunInfo("IEBrowser", acInfo);
			if (eErrCode == Error_Succeed && acInfo.eState == EntityState_NoStart)
			{
				//have NOT cut "IEBrowser"
				if (!IsCutIEBrowser())
				{
					GetEntityBase()->GetFunction()->ShowStartupInfo("正在启动实体IEBrowser...");
					eErrIE = pFuncPrivilege->StartEntity("IEBrowser", m_strURLValue, spWait);
					if (eErrIE == Error_Succeed)
					{
						if (spWait != NULL)
							eErrIE = spWait->WaitAnswer(MAX_AYSNC_TIMEOUT);
					}
					else
					{
						Dbg("Start IEBrowser failed(%d).", eErrIE);
					}
				}
			}
			else if (eErrCode == Error_Succeed && acInfo.eState == EntityState_Idle)
			{//if IE/Chromium start before healthmanager,we suppose healthmanager is restart unexpectly,then set m_bEnterMainPageEver true
				//m_bIEBeforeHealth = true;
			}
#endif //RVC_OS_WIN
			LogTermInfoTask* task = new LogTermInfoTask(this);
			GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
			if (!m_bAccessAuth)
				PostProcessAfterUpgrade();
		}
		break;
	case USER_EVT_MAITAIN:
		Dbg("to maintain...");
		m_stateBeforeMaintain = m_fsmState;
		m_bIdleToMaintain = true;
		pEvt->SetHandled();
		break;
	case USER_EVT_ENTER_CUSTOMER_MANAGER:
		pEvt->SetHandled();
		break;
	default:
		break;
	}
	return 0;
}

//Fault
void CHealthManagerFSM::s5_on_entry()
{
	LOG_FUNCTION();
	LogTermInfoTask* task = new LogTermInfoTask(this);
	GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
	m_fsmState = HM_FSM_STATE_FAULT;
	CSmartPointer<IConfigInfo> spConfig,spConfigRun;
	ErrorCodeEnum eErr = GetEntityBase()->GetFunction()->OpenConfig(Config_Software, spConfig);
	eErr = GetEntityBase()->GetFunction()->OpenConfig(Config_Run, spConfigRun);
	int failTimes = 0,maxFailTimes = 3;
	spConfig->ReadConfigValueInt("Run","MaxFailTimes",maxFailTimes);
	spConfigRun->ReadConfigValueInt("Run","FailTimes",failTimes);
	failTimes++;
	LogWarn(Severity_High, Error_Unexpect, LOG_ERR_HEALTH_FAILED, "HealthManager failed.");
	//oilyang@20210930 add to call for Close Page
	GetEntityBase()->GetFunction()->SetSysVar("TerminalStage", "C");
	if (failTimes > maxFailTimes)
	{
		LogEvent(Severity_Middle,LOG_EVT_HEADLIGHT_RED_ON,"设备故障");
		eErr = GetEntityBase()->GetFunction()->SetSysVar("TerminalStage","D");
		if (eErr != Error_Succeed)
			Dbg("set termstage D failed (%d).",eErr);
		else
			Dbg("Set TerminalStage D.");
	}
	else
	{
		Dbg("have failed %d times.",failTimes);
		spConfigRun->WriteConfigValueInt("Run","FailTimes",failTimes);
		eErr = GetEntityBase()->GetFunction()->SetSysVar("RunState","F");
		if (eErr != Error_Succeed)
		{
			Dbg("set RunState failed (%d).",eErr);
		}
	}
	PostProcessAfterUpgrade();
}
void CHealthManagerFSM::s5_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CHealthManagerFSM::s5_on_event(FSMEvent* pEvt)
{
	LOG_FUNCTION();
	Dbg("s5(Fault) event %d,%d",pEvt->iEvt,pEvt->param1);
	switch(pEvt->iEvt)
	{
	case USER_EVT_MAITAIN:
		Dbg("to maintain...");
		m_stateBeforeMaintain = m_fsmState;
		pEvt->SetHandled();
		break;
	case USER_EVT_ENTER_CUSTOMER_MANAGER:
		pEvt->SetHandled();
		break;
	case USER_EVT_ACCESSAUTH_FINISHED:
		pEvt->SetHandled();
		if (pEvt->param1 == 1)
		{
			SetAccessAuth(false);
			return 1;
		}
		break;
	default:
		break;
	}
	return 0;
}

//Maintaining
void CHealthManagerFSM::s6_on_entry()
{
	LOG_FUNCTION();
	m_preFsmState = m_fsmState;
	m_fsmState = HM_FSM_STATE_MAINTAINING;
	ErrorCodeEnum eErrCode;
	eErrCode = GetEntityBase()->GetFunction()->SetSysVar("RunState","M");
	if (eErrCode != Error_Succeed)
	{
		Dbg("set RunState M failed (%d).",eErrCode);
	}
	CSmartPointer<IEntityFunction> pFunc = GetEntityBase()->GetFunction();
	CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = pFunc.ConvertCase<IEntityFunctionPrivilege>();
	if (pFuncPrivilege == NULL)
	{
		Dbg("display screen NoPrivilege");
		return;
	}
	ErrorCodeEnum eErr = pFuncPrivilege->DisplayBlueScreen("暂停服务");
	Dbg("display blue screen %d",eErr);
}

void CHealthManagerFSM::s6_on_exit()
{
	LOG_FUNCTION();
}

unsigned int CHealthManagerFSM::s6_on_event(FSMEvent* pEvt)
{
	LOG_FUNCTION();
	int ret = 0;
	switch(pEvt->iEvt)
	{
	case USER_EVT_MAITAIN_FINISHED:
		pEvt->SetHandled();
		{
			CSmartPointer<IEntityFunction> pFunc = GetEntityBase()->GetFunction();
			CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = pFunc.ConvertCase<IEntityFunctionPrivilege>();
			if (pFuncPrivilege == NULL)
			{
				Dbg("un-display screen NoPrivilege");
				return 1;
			}
			ErrorCodeEnum eErr = pFuncPrivilege->UndisplayBlueScreen();
			Dbg("un-display blue screen %d",eErr);
			if (m_stateBeforeMaintain == HM_FSM_STATE_IDLE)
			{
				ErrorCodeEnum eErr = GetEntityBase()->GetFunction()->SetSysVar("RunState","O");
				if (eErr != Error_Succeed)
				{
					Dbg("set RunState O failed (%d).",eErr);
				}
			}
			ret = m_preFsmState;
		}
		break;
	case USER_EVT_ENTER_CUSTOMER_MANAGER:
		pEvt->SetHandled();
		break;
	default:
		break;
	}
	return ret;
}

//PrepareOff
void CHealthManagerFSM::s7_on_entry()
{
	LOG_FUNCTION();
	m_fsmState = HM_FSM_STATE_PREPAREOFF;
	ErrorCodeEnum eErrCode;
	eErrCode = GetEntityBase()->GetFunction()->SetSysVar("RunState","P");
	if (eErrCode != Error_Succeed)
	{
		Dbg("set RunState P failed (%d).",eErrCode);
	}
}

void CHealthManagerFSM::s7_on_exit()
{
	LOG_FUNCTION();
}

unsigned int CHealthManagerFSM::s7_on_event(FSMEvent* pEvt)
{
	LOG_FUNCTION();
	Dbg("s7(PrepareOff) event %d",pEvt->iEvt);
	switch(pEvt->iEvt)
	{
	case USER_EVT_MAITAIN:
		Dbg("to maintain...");
		m_stateBeforeMaintain = m_fsmState;
		pEvt->SetHandled();
		break;
	case USER_EVT_ENTER_CUSTOMER_MANAGER:
		pEvt->SetHandled();
		break;
	default:
		break;
	}
	return 0;
}

//Terminating
void CHealthManagerFSM::s8_on_entry()
{
	LOG_FUNCTION();
	m_fsmState = HM_FSM_STATE_TERMINATING;
	ErrorCodeEnum eErrCode;
	eErrCode = GetEntityBase()->GetFunction()->SetSysVar("RunState","T");
	if (eErrCode != Error_Succeed)
	{
		Dbg("set RunState T failed (%d).",eErrCode);
	}
}

void CHealthManagerFSM::s8_on_exit()
{
	LOG_FUNCTION();
}

unsigned int CHealthManagerFSM::s8_on_event(FSMEvent* pEvt)
{
	LOG_FUNCTION();
	Dbg("s8(Terminating) event %d",pEvt->iEvt);
	switch(pEvt->iEvt)
	{
	case USER_EVT_MAITAIN:
		Dbg("to maintain...");
		m_stateBeforeMaintain = m_fsmState;
		pEvt->SetHandled();
		break;
	case USER_EVT_ENTER_CUSTOMER_MANAGER:
		pEvt->SetHandled();
		break;
	default:
		break;
	}
	return 0;
}

//Exitting
void CHealthManagerFSM::s9_on_entry()
{
	LOG_FUNCTION();
	m_fsmState = HM_FSM_STATE_EXITTING;
	ErrorCodeEnum eErrCode;
	eErrCode = GetEntityBase()->GetFunction()->SetSysVar("RunState","E");
	if (eErrCode != Error_Succeed)
	{
		Dbg("set RunState E failed (%d).",eErrCode);
	}
}

void CHealthManagerFSM::s9_on_exit()
{
	LOG_FUNCTION();
}

unsigned int CHealthManagerFSM::s9_on_event(FSMEvent* pEvt)
{
	LOG_FUNCTION();
	Dbg("s9(Exitting) event %d",pEvt->iEvt);
	switch(pEvt->iEvt)
	{
	case USER_EVT_MAITAIN:
		Dbg("to maintain...");
		m_stateBeforeMaintain = m_fsmState;
		pEvt->SetHandled();
		break;
	case USER_EVT_ENTER_CUSTOMER_MANAGER:
		pEvt->SetHandled();
		break;
	default:
		break;
	}
	return 0;
}

//Sleep(L)
void CHealthManagerFSM::s10_on_entry()
{
	LOG_FUNCTION();
	m_fsmState = HM_FSM_STATE_SLEEP;
	ErrorCodeEnum eErrCode;
	eErrCode = GetEntityBase()->GetFunction()->SetSysVar("RunState","L");
	if (eErrCode != Error_Succeed)
	{
		Dbg("set RunState L failed (%d).",eErrCode);
	}
}

void CHealthManagerFSM::s10_on_exit()
{
	LOG_FUNCTION();
}

unsigned int CHealthManagerFSM::s10_on_event(FSMEvent* pEvt)
{
	LOG_FUNCTION();
	Dbg("s10(Sleep) event %d",pEvt->iEvt);
	switch(pEvt->iEvt)
	{
	case USER_EVT_MAITAIN:
		Dbg("to maintain...");
		m_stateBeforeMaintain = m_fsmState;
		pEvt->SetHandled();
		break;
	case USER_EVT_ENTER_CUSTOMER_MANAGER:
		pEvt->SetHandled();
		break;
	default:
		break;
	}
	return 0;
}

//In Customer Manager System
void CHealthManagerFSM::s11_on_entry()
{
	LOG_FUNCTION();
	m_preFsmState = m_fsmState;
	m_fsmState = HM_FSM_STATE_CMS;
}

void CHealthManagerFSM::s11_on_exit()
{
	LOG_FUNCTION();
}

unsigned int CHealthManagerFSM::s11_on_event(FSMEvent* pEvt)
{
	LOG_FUNCTION();
	Dbg("s11(In CMS) event %d",pEvt->iEvt);
	int ret = 0;
	switch (pEvt->iEvt)
	{
		case USER_EVT_MAITAIN:
			Dbg("to maintain...");
			m_stateBeforeMaintain = m_fsmState;
			pEvt->SetHandled();
			break;
		case USER_EVT_SWITCH_BACK_TO_RVC:
			pEvt->SetHandled();
			ret = m_preFsmState;
			break;
		default:
			break;
	}
	return ret;
}

int CHealthManagerFSM::WaitDeamonFinish()
{
	int count = 0;
	while(1)//max waiting time
	{

		count++;
		//query if update deamon process is started oiltmp
		//case custody
		//case needreboot
		//case rollback
		//case timeout
		if (count > 2)
			break;
		//Sleep(5000);
	}

	/** 添加此操作以让状态机停留在s0状态 [Gifur@20211017]*/
	if (mCofigMode) {
		return 1;
	}
	return 0;
}
int CHealthManagerFSM::DoInitialization()
{
	LOG_FUNCTION();

	ErrorCodeEnum eErr;
	CSmartPointer<IEntityFunction> pFunc = GetEntityBase()->GetFunction();
	CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = pFunc.ConvertCase<IEntityFunctionPrivilege>();
	CEntityRunInfo acInfo;
	eErr = pFunc->GetEntityRunInfo("Initializer",acInfo);
	Dbg("Initializer state return %d",eErr);
	if (eErr == Error_Succeed && (acInfo.eState == EntityState_NoStart || acInfo.eState == EntityState_Idle))
	{
		if (acInfo.eState == EntityState_NoStart)
		{
			CSmartPointer<IAsynWaitSp> spWaitInit;
			eErr = pFuncPrivilege->StartEntity("Initializer",NULL,spWaitInit);
			if (eErr == Error_Succeed)
				eErr = spWaitInit->WaitAnswer(MAX_AYSNC_TIMEOUT);
			eErr = pFunc->GetEntityRunInfo("Initializer",acInfo);
			if (eErr != Error_Succeed || acInfo.eState != EntityState_Idle)
			{
				Dbg("start Initializer failed(%d,%d).",eErr,acInfo.eState);
				return 1;
			}
		}
		if (m_pInitClient == NULL)
		{
			m_pInitClient = new InitializerService_ClientBase(this->GetEntityBase());
			eErr = m_pInitClient->Connect();
			if (eErr != Error_Succeed) {
				Dbg("Initializer connected failed.");
				m_pInitClient->SafeDelete();
				m_pInitClient = NULL;
				return 2;
			}
			else
				Dbg("Initializer connected.");
		}
		InitializerService_Initialize_Info initInfo;
		m_pInitClient->Initialize(initInfo);
		//no need to wait,just go
		return 0;
	}
	else
	{
		Dbg("Get Initializer RunInfo failed(%d).",eErr);
		return 3;
	}
}

//0:auth suc or have already authed;1:auth failed;
int CHealthManagerFSM::AccessAuthDoWork()
{
	//oilyang@20190924 comment the following Sleep(5000);
	//Sleep(5000);//oilyang wait for a few 
	//oilyang@20210329 comment the following lines,
	//as no "LOG_EVT_SYSTMECUSTOM_START_ACCESSAUTH" event throw
	//if (m_bFirstAccessAuth && m_accessAuthCheckMD5 == 1 && m_havReceiveMD5OK == 0)
	//{
	//	Dbg("wait md5 ok.");
	//	WaitForSingleObject(m_hMD5OKEvt, INFINITE);
	//	m_bFirstAccessAuth = false;
	//	Dbg("have received md5 ok event.");
	//}
	LOG_FUNCTION();
	m_bInAccessAuthDoWork = true;
	m_bAccessAuth = false;
	CSimpleStringA csTermStage("");
	ErrorCodeEnum eErr;
	eErr = GetEntityBase()->GetFunction()->GetSysVar("TerminalStage",csTermStage);
	Dbg("oninit get termstage %s",(LPCTSTR)csTermStage);
	bool bToDoInit = false;
	if (eErr == Error_Succeed)
	{
		if (csTermStage[0] == 'U')
		{
			bToDoInit = true;
			int initTime = 0;

INITIALIZATION:

			int rc = DoInitialization();
			Dbg("the %d init",initTime);
			initTime++;
			DWORD dwStart = GetTickCountRVC();
			while(1)
			{
				if (!m_bInitSuc && !m_bInitFail)
				{
					Sleep(1000);
					continue;
				}
				else if (m_bInitSuc || m_bInitFail)
				{
					Dbg("init result %d,%d",m_bInitSuc,m_bInitFail);
					if (m_bInitFail)
					{
						Sleep(5000);
						m_bInitFail = false;
						goto INITIALIZATION;
					}
					if (m_bInitSuc)
						break;
				}
			}
		}
	}
	else
	{
		Dbg("get TerminalStage failed(%d).", eErr);
		m_bInAccessAuthDoWork = false;
		return 1;
	}
	Dbg("after proc initialization.");
	if (bToDoInit)
	{
		if (m_bInitSuc)
		{
		}
		else
		{
			Dbg("initialization failed.");
			m_bInAccessAuthDoWork = false;
			return 1;
		}
	}

	//to accessauth
	ErrorCodeEnum eErrCode;
	eErrCode = GetEntityBase()->GetFunction()->GetSysVar("TerminalStage",csTermStage);
	Dbg("before accessauth get termstage %s",(LPCTSTR)csTermStage);
	if (eErrCode == Error_Succeed)
	{
		//if (csTermStage[0] == 'C' || csTermStage[0] == 'A')
		if (csTermStage[0] != 'U') 
		{
			CSmartPointer<IEntityFunction> pFunc = GetEntityBase()->GetFunction();
			CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = pFunc.ConvertCase<IEntityFunctionPrivilege>();
			//terminate pinpad
			//CSmartPointer<IAsynWaitSp> spWait;
			//eErrCode = pFuncPrivilege->CloseEntity("PinPad",spWait);
			//Dbg("close pinpad %d.",eErrCode);
			//eErrCode = spWait->WaitAnswer(MAX_AYSNC_TIMEOUT);
			//if (eErrCode != Error_Succeed)
			//{
			//	//terminate pinpad
			//	CSmartPointer<IAsynWaitSp> spWait;
			//	pFuncPrivilege->TerminateEntity("PinPad",spWait);
			//	spWait->WaitAnswer(MAX_AYSNC_TIMEOUT);
			//}
			//if (eErrCode == Error_Succeed)
			{
				CEntityRunInfo acInfo;
				eErrCode = pFunc->GetEntityRunInfo("AccessAuthorization",acInfo);
				Dbg("AccessAuth state return %d",eErrCode);
				if (eErrCode == Error_Succeed)
				{
					switch(acInfo.eState)
					{
					case EntityState_NoStart:
						{
							CSmartPointer<IAsynWaitSp> spWaitAC;
							eErrCode = pFuncPrivilege->StartEntity("AccessAuthorization",NULL,spWaitAC);
							eErrCode = spWaitAC->WaitAnswer(MAX_AYSNC_TIMEOUT);
							Dbg("start accessauth %d.",eErrCode);
						}
						break;
					case EntityState_Idle:
						Dbg("AccessAuth state idle.");
						break;
					default:
						break;
					}
					
					if (m_pACClient == NULL)
					{
						m_pACClient = new AccessAuthService_ClientBase(this->GetEntityBase());
						eErrCode = m_pACClient->Connect();
						if (eErrCode != Error_Succeed) {
							Dbg("accessauth connected failed.");
							m_pACClient->SafeDelete();
							m_pACClient = NULL;
							StartPinPadEntity();
							m_bInAccessAuthDoWork = false;
							return 1;
						}
						else
							Dbg("accessauth connected.");
					}
				}
				else
				{
					Dbg("Get AccessAuth RunInfo failed(%d).",eErrCode);
					StartPinPadEntity();
					m_bInAccessAuthDoWork = false;
					return 1;
				}
				if (m_pACClient != NULL)
				{
					DWORD dwStart = GetTickCountRVC();
					int registCount = 0;
REGIST:		eErrCode = m_pACClient->Regist();
					m_bHasAuthEver = true;
					registCount++;
					Dbg("accessauth regist %d",eErrCode);
					if (eErrCode == Error_Succeed)
					{
						while(1)
						{
							//oilyang@20210823 as have retry logic,no need to 
							//DWORD dwEnd = GetTickCount();
							//DWORD dwElapse = dwEnd - dwStart;
							//if (dwElapse > m_AccessAuthTimeout)
							//{
							//	Dbg("after x minute");
							//	StartPinPadEntity();
							//	//auth failed,rollback to C
							//	eErrCode = GetEntityBase()->GetFunction()->SetSysVar("TerminalStage", "C");
							//	Dbg("auth fail,set TerminalStage C 1");
							//	if (eErr != Error_Succeed)
							//		Dbg("set TerminalStage C failed(%d).", eErr);
							//	m_bFirstAccessAuth = false;
							//	m_bInAccessAuthDoWork = false;
							//	return 1;
							//}
							Sleep(1000);
							if (!m_bAccessAuth && !m_bACFailed)
								continue;
							// && registCount < m_AccessAuthTries
							if (m_bACFailed)
							{
								LogWarn(Severity_Low,Error_Unexpect,LOG_WARN_HEALTH_ACCESSAUTH_FAILED,"AccessAuth failed.");
								m_bACFailed = false;
								//Sleep(1000);
								//goto REGIST;
							}
							Dbg("regist try %d times",registCount);
							StartPinPadEntity();
							if (!m_bAccessAuth)
							{
								//auth failed,rollback to C
								SetAccessAuth(false);
								Dbg("auth fail,set TerminalStage C 2");
							}
							break;
						}
						m_bFirstAccessAuth = false;
						m_bInAccessAuthDoWork = false;
						return 0;
					}
					else
					{
						Dbg("accessauth regist failed(%d).",eErrCode);
						StartPinPadEntity();
						//auth failed,rollback to C
						SetAccessAuth(false);
						Dbg("auth fail,set TerminalStage C 3");
						m_bInAccessAuthDoWork = false;
						return 1;
					}
				}
				else
				{
					Dbg("Start accessauth failed(%d).",eErrCode);
					StartPinPadEntity();
                    //auth failed,rollback to C
					SetAccessAuth(false);
					Dbg("auth fail,set TerminalStage C 4");
					m_bInAccessAuthDoWork = false;
					return 1;
				}
			}
		}
		else
		{
			StartPinPadEntity();
			m_bInAccessAuthDoWork = false;
			return 0;
		}
	}
	else
		Dbg("Get termstage failed(%d).", eErrCode);
	m_bInAccessAuthDoWork = false;
	return 1;
}

//return value:
//0:all entity have started suc
//1:some entity havn't try to start
//2:all entity have tried to started,but some failed
int CHealthManagerFSM::CheckLoadResult(LoadStage eStage)
{
	int ret = 0;
	map<CSimpleStringA,EntityLoadInfo>::iterator it;
	if (eStage == LOADSTAGE_COREBOOT)
		it = m_coreBootOpt.begin();
	else if (eStage == LOADSTAGE_SAFELOAD)
		it = m_safeLoadOpt.begin();
	else
		it = m_operatingOpt.begin();
	while(1)
	{
		switch(it->second.loadOpt)
		{
		case LOADOPT_IGNORE:
			if (it->second.eResult == LOADING_INIT)
				return 1;
			break;
		case LOADOPT_ASYNC_VERIFY:
		case LOADOPT_SYNC_VERIFY:			
		default:
			if (it->second.eResult == LOADING_INIT)
				return 3;
			else if (it->second.eResult != LOADING_SUCCEED)
			{
				Dbg("m_csErrEntity:%s",(LPCTSTR)m_csErrEntity);
				m_csErrEntity = m_csErrEntity + "|" + it->first;
				ret = 2;
			}
			break;
		}
		it++;
		if (eStage == LOADSTAGE_COREBOOT && it == m_coreBootOpt.end())
			break;
		else if (eStage == LOADSTAGE_SAFELOAD && it == m_safeLoadOpt.end())
			break;
		else if (eStage == LOADSTAGE_OPERATING && it == m_operatingOpt.end())
			break;
	}
	return ret;
}
void CHealthManagerFSM::SetAccessAuth(bool bResult)
{
	m_bAccessAuth = bResult;
	ErrorCodeEnum eErrCode;
	if (bResult)
		eErrCode = GetEntityBase()->GetFunction()->SetSysVar("TerminalStage","A");
	else
		eErrCode = GetEntityBase()->GetFunction()->SetSysVar("TerminalStage", "C");
	Dbg("Set AccessAuth TerminalState %d returned: %s",bResult, SpStrError(eErrCode));
}

int CHealthManagerFSM::StartPinPadEntity()
{
	if (m_coreBootOpt.find("PinPad") == m_coreBootOpt.end() && m_safeLoadOpt.find("PinPad") == m_safeLoadOpt.end()
		&& m_operatingOpt.find("PinPad") == m_operatingOpt.end())
	{
		Dbg("not configure pinpad.");
		return 0;
	}
	CSmartPointer<IEntityFunction> pFunc = GetEntityBase()->GetFunction();
	CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = pFunc.ConvertCase<IEntityFunctionPrivilege>();
	CEntityRunInfo acInfo;
	ErrorCodeEnum eErrCode;
	eErrCode = pFunc->GetEntityRunInfo("PinPad",acInfo);
	Dbg("pinpad state %d,%d",eErrCode,acInfo.eState);
	if (acInfo.eState == EntityState_NoStart || acInfo.eState == EntityState_Close || acInfo.eState == EntityState_Killed)
	{

		CSmartPointer<IAsynWaitSp> spWait;

		eErrCode = pFuncPrivilege->StartEntity("PinPad",NULL,spWait);
		Dbg("start pinpad %d.",eErrCode);
		if (spWait != NULL)
			eErrCode = spWait->WaitAnswer(MAX_AYSNC_TIMEOUT);
		Dbg("start pinpad wait %d",eErrCode);
	}
	return eErrCode;
}

void CHealthManagerFSM::ToReAccessAuth(bool bEver)
{
	Sleep(1500);//for function "AccessAuthDoWork" to quit while
	if (m_bFirstAccessAuth)
		return;
	ToCallAccessAuthDoWork();
	//SetAccessAuth(false);
	//AccessAuthTask *pTask = new AccessAuthTask(this);
	//GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
}

ErrorCodeEnum CHealthManagerFSM::AsyncStartEntity(const char *entity_name, const char *cmdline, void *pData)
{
	CSmartPointer<IEntityFunction> pFunc = m_pEntity->GetFunction();
	ErrorCodeEnum errCode;
	CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = pFunc.ConvertCase<IEntityFunctionPrivilege>();
	if (pFuncPrivilege != NULL) {
		CSmartPointer<IAsynWaitSp> spWait;
		errCode = pFuncPrivilege->StartEntity(entity_name, cmdline, spWait);
		Dbg("start entity %s",entity_name);
		if (errCode == Error_Succeed) {
			callback_entry *entry = new callback_entry();
			entry->pRawData = pData;
			entry->EntityName = entity_name;
			entry->ErrorResult = Error_Unexpect;
			entry->op = OP_START_ENTITY;
			if (spWait != NULL)
				spWait->SetCallback(this, entry);
		}
		return errCode;
	} else {
		return Error_NoPrivilege;
	}
}

ErrorCodeEnum CHealthManagerFSM::AsyncStopEntity(const char *entity_name, void *pData)
{
	CSmartPointer<IEntityFunction> pFunc = m_pEntity->GetFunction();
	CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = pFunc.ConvertCase<IEntityFunctionPrivilege>();
	if (pFuncPrivilege != NULL) {
		CSmartPointer<IAsynWaitSp> spWait;
		ErrorCodeEnum Error = pFuncPrivilege->StopEntity(entity_name, spWait);
		if (Error == Error_Succeed) {
			callback_entry *entry = new callback_entry();
			entry->pRawData = pData;
			entry->EntityName = entity_name;
			entry->ErrorResult = Error_Unexpect;
			entry->op = OP_STOP_ENTITY;
			if (spWait != NULL)
				spWait->SetCallback(this, entry);
		}
		return Error;
	} else {
		return Error_NoPrivilege;
	}
}

ErrorCodeEnum CHealthManagerFSM::AsyncPauseEntity(const char *entity_name, void *pData)
{
	CSmartPointer<IEntityFunction> pFunc = m_pEntity->GetFunction();
	CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = pFunc.ConvertCase<IEntityFunctionPrivilege>();
	if (pFuncPrivilege != NULL) {
		CSmartPointer<IAsynWaitSp> spWait;
		ErrorCodeEnum Error = pFuncPrivilege->PauseEntity(entity_name, spWait);
		if (Error == Error_Succeed) {
			callback_entry *entry = new callback_entry();
			entry->pRawData = pData;
			entry->EntityName = entity_name;
			entry->ErrorResult = Error_Unexpect;
			entry->op = OP_PAUSE_ENTITY;
			if (spWait != NULL)
				spWait->SetCallback(this, entry);
		}
		return Error;
	} else {
		return Error_NoPrivilege;
	}
}

ErrorCodeEnum CHealthManagerFSM::AsyncContinueEntity(const char *entity_name, void *pData)
{
	CSmartPointer<IEntityFunction> pFunc = m_pEntity->GetFunction();
	CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = pFunc.ConvertCase<IEntityFunctionPrivilege>();
	if (pFuncPrivilege != NULL) {
		CSmartPointer<IAsynWaitSp> spWait;
		ErrorCodeEnum Error = pFuncPrivilege->ContinueEntity(entity_name, spWait);
		if (Error == Error_Succeed) {
			callback_entry *entry = new callback_entry();
			entry->pRawData = pData;
			entry->EntityName = entity_name;
			entry->ErrorResult = Error_Unexpect;
			entry->op = OP_CONTINUE_ENTITY;
			if (spWait != NULL)
				spWait->SetCallback(this, entry);
		}
		return Error;
	} else {
		return Error_NoPrivilege;
	}
}

ErrorCodeEnum CHealthManagerFSM::AsyncTerminateEntity(const char *entity_name, void *pData)
{
	CSmartPointer<IEntityFunction> pFunc = m_pEntity->GetFunction();
	CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = pFunc.ConvertCase<IEntityFunctionPrivilege>();
	if (pFuncPrivilege != NULL) {
		CSmartPointer<IAsynWaitSp> spWait;
		ErrorCodeEnum Error = pFuncPrivilege->TerminateEntity(entity_name, spWait);
		if (Error == Error_Succeed) {
			callback_entry *entry = new callback_entry();
			entry->pRawData = pData;
			entry->EntityName = entity_name;
			entry->ErrorResult = Error_Unexpect;
			entry->op = OP_TERMINATE_ENTITY;
			if (spWait != NULL)
				spWait->SetCallback(this, entry);
		}
		return Error;
	} else {
		return Error_NoPrivilege;
	}
}

void CHealthManagerFSM::OnAnswer(CSmartPointer<IAsynWaitSp> pAsynWaitSp)
{
	CSmartPointer<ICallbackListener> spCallback;
	CSmartPointer<IReleasable> pData;
	pAsynWaitSp->GetCallback(spCallback, pData);
	callback_entry *entry = dynamic_cast<callback_entry*>((IReleasable*)(pData.GetRawPointer()));
	entry->ErrorResult = pAsynWaitSp->AsyncGetAnswer();
	callback_entry *new_entry = new callback_entry();

	new_entry->EntityName = entry->EntityName;
	new_entry->ErrorResult = entry->ErrorResult;
	new_entry->op = entry->op;
	new_entry->state = entry->state;

	map<CSimpleStringA,EntityLoadInfo>::iterator it;
	int ret;
	Dbg("stage %d,%s,result %d",m_eStage,(LPCSTR)new_entry->EntityName,new_entry->ErrorResult);
	if (entry->op == OP_START_ENTITY && new_entry->ErrorResult != Error_Succeed) {
		//ShowEntityBootFailedAtFront(new_entry->EntityName, new_entry->ErrorResult, false);
	}

	switch(m_eStage)
	{
	case LOADSTAGE_COREBOOT:
		it = m_coreBootOpt.find(new_entry->EntityName);
		if (it != m_coreBootOpt.end())
		{
			if (new_entry->ErrorResult == Error_Succeed)
				it->second.eResult = LOADING_SUCCEED;
			else if (new_entry->ErrorResult == Error_TimeOut)
				it->second.eResult = LOADING_TIMEOUT;
			else
				it->second.eResult = LOADING_FAILED;
			if (it->second.eResult != Error_Succeed)
			{
				char tmp[64] = {0};
				sprintf(tmp, "实体 %s 启动失败", it->first.GetData());
				Dbg("%s", tmp);
			}
			ret = CheckLoadResult(LOADSTAGE_COREBOOT);
			if (ret == 0 || ret == 2)
			{
				FSMEvent *e = new FSMEvent(USER_EVT_COREBOOT_FINISHED);
				e->param1 = ret;
				PostEventFIFO(e);
			}
		}
		break;
	case LOADSTAGE_SAFELOAD:
		it = m_safeLoadOpt.find(new_entry->EntityName);
		if (it != m_safeLoadOpt.end())
		{
			if (new_entry->ErrorResult == Error_Succeed)
				it->second.eResult = LOADING_SUCCEED;
			else if (new_entry->ErrorResult == Error_TimeOut)
				it->second.eResult = LOADING_TIMEOUT;
			else
				it->second.eResult = LOADING_FAILED;
			ret = CheckLoadResult(LOADSTAGE_SAFELOAD);
			Dbg("safeload answer %d",ret);
			if (ret == 0 || ret == 2)
			{
				FSMEvent *e = new FSMEvent(USER_EVT_SAFELOAD_FINISHED);
				e->param1 = ret;
				PostEventFIFO(e);
			}
		}
		else
			Dbg("cannot find %s",(LPCTSTR)new_entry->EntityName);
		break;
	case LOADSTAGE_OPERATING:
		it = m_operatingOpt.find(new_entry->EntityName);
		if (it != m_operatingOpt.end())
		{
			if (new_entry->ErrorResult == Error_Succeed)
				it->second.eResult = LOADING_SUCCEED;
			else if (new_entry->ErrorResult == Error_TimeOut)
				it->second.eResult = LOADING_TIMEOUT;
			else
				it->second.eResult = LOADING_FAILED;
			ret = CheckLoadResult(LOADSTAGE_OPERATING);
			if (ret == 0 || ret == 2)
			{
				FSMEvent *e = new FSMEvent(USER_EVT_OPERATING_FINISHED);
				e->param1 = ret;
				PostEventFIFO(e);
			}
		}
		break;
	default:
		break;
	}
}
void CHealthManagerFSM::ToCheckUPS()
{
	CSmartPointer<IEntityFunction> pFunc = GetEntityBase()->GetFunction();
	CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = pFunc.ConvertCase<IEntityFunctionPrivilege>();
	CEntityRunInfo acInfo;
	ErrorCodeEnum eErrCode;
	eErrCode = pFunc->GetEntityRunInfo("Ups",acInfo);
	Dbg("ups state %d,%d",eErrCode,acInfo.eState);
	if (acInfo.eState != EntityState_NoStart)
	{
		CSmartPointer<IAsynWaitSp> spWait;
		eErrCode = pFuncPrivilege->TerminateEntity("Ups",spWait);
		Sleep(2000);
		eErrCode = pFuncPrivilege->StartEntity("Ups",NULL,spWait);
		if (spWait != NULL)
			eErrCode = spWait->WaitAnswer(5000);
		Dbg("restart ups wait %d",eErrCode);
	}
}

int CHealthManagerFSM::USBControl()
{
	ErrorCodeEnum eErr;
	if (m_sysInfo.strMachineType.Compare("RVC.PAD") == 0)
	{
		if (m_pDevCtrlClient == NULL)
		{
			m_pDevCtrlClient = new DeviceControlService_ClientBase(this->m_pEntity);
			ErrorCodeEnum eErr = m_pDevCtrlClient->Connect();
			if (eErr != Error_Succeed) {
				Dbg("DeviceControl connected failed(%d).",eErr);
				m_pDevCtrlClient->SafeDelete();
				m_pDevCtrlClient = NULL;
				return -1;
			}
		}
		if (m_pDevCtrlClient != NULL)
		{
			DeviceControlService_USB_Req req;
			DeviceControlService_USB_Ans ans;
			req.open = true;
			eErr = m_pDevCtrlClient->USB(req,ans,5000);
			if (eErr != Error_Succeed)
			{
				Dbg("usb control failed(%d).",eErr);
				return -1;
			}
			else
				Dbg("usb opened.");
		}
	}
	return 0;
}

CSimpleStringA CHealthManagerFSM::GetEntityCfgInfo(CSimpleStringA name,int &loadOpt)
{
	CSimpleStringA entityList(""),csBrowserName("IEBrowser");
	Dbg("GetEntityCfgInfo %s",(LPCTSTR)name);
	if (!name.IsNullOrEmpty() && name.Compare("AllConfiguredEntity") == 0)
	{
		for (auto itor = m_vAllCfgEntity.cbegin(); itor != m_vAllCfgEntity.cend(); itor++)
		{
			entityList += (*itor) + ",";
		}
		return entityList;
	}

#ifdef RVC_OS_WIN
	if (!name.IsNullOrEmpty() && name.Compare("IEBrowser") == 0)
	{
		Dbg("IEBrowser just return 2");
		loadOpt = 2;
		return "";
	}
#endif //RVC_OS_WIN

	map<CSimpleStringA,EntityLoadInfo>::iterator it;
	for (it = m_coreBootOpt.begin(); it != m_coreBootOpt.end(); ++it)
	{
		if (_strnicmp(name,it->first,name.GetLength()) == 0)
		{
			loadOpt = it->second.loadOpt;
			Dbg("GetEntityCfgInfo %d",loadOpt);
			return "";
		}
	}
	for (it = m_safeLoadOpt.begin(); it != m_safeLoadOpt.end(); ++it)
	{
		if (_strnicmp(name,it->first,name.GetLength()) == 0)
		{
			loadOpt = it->second.loadOpt;
			Dbg("GetEntityCfgInfo %d",loadOpt);
			return "";
		}
	}
	for (it = m_operatingOpt.begin(); it != m_operatingOpt.end(); ++it)
	{
		if (_strnicmp(name,it->first,name.GetLength()) == 0)
		{
			loadOpt = it->second.loadOpt;
			Dbg("GetEntityCfgInfo %d",loadOpt);
			return "";
		}
	}
	loadOpt = 99;
	return "";
}
ErrorCodeEnum CHealthManagerFSM::QueryCheckCode(CSimpleStringA& csCkCode, bool bMaster)
{
	LOG_FUNCTION();
	ErrorCodeEnum eErr = Error_Unexpect;
	CSimpleStringA tmpCheckCode("");
	PinPadService_ClientBase *pClient = new PinPadService_ClientBase(this->m_pEntity);
	if (pClient != NULL)
	{
		eErr = pClient->Connect();
		if (eErr == Error_Succeed)
		{
			PinPadService_QueryFunc_Req reqQ;
			PinPadService_QueryFunc_Ans ansQ;
			eErr = pClient->QueryFunc(reqQ, ansQ, 5000);
			if (eErr == Error_Succeed)
			{
				PinPadService_GetCheckCode_Req reqG;
				PinPadService_GetCheckCode_Ans ansG;
				if (ansQ.reserved1 == 2)//if sm only
				{
					reqG.mSN.Init(1);
					reqG.wSN.Init(1);
					reqG.mSN[0] = 1;
					if (bMaster)
						reqG.wSN[0] = 99;
					else
						reqG.wSN[0] = 0;
					eErr = pClient->GetCheckCode(reqG, ansG, 10000);
					if (eErr == Error_Succeed)
					{
						tmpCheckCode = ansG.checkcode[0];
					}
				}
				else//3des only or 3des&sm both ok
				{
					reqG.mSN.Init(1);
					reqG.wSN.Init(1);
					reqG.mSN[0] = 0;
					if (bMaster)
						reqG.wSN[0] = 99;
					else
						reqG.wSN[0] = 0;
					eErr = pClient->GetCheckCode(reqG, ansG, 10000);
					if (eErr == Error_Succeed)
					{
						tmpCheckCode = ansG.checkcode[0];
					}
				}
			}
			else
				Dbg("QueryFunc failed.error code:%d",eErr);
		}
		else
			Dbg("connect to pinpad failed.error code:%d",eErr);
	}
	csCkCode = tmpCheckCode;
	return eErr;
}
void CHealthManagerFSM::QueryDeviceInfo(std::map<std::string, std::string>& termInfo)
{
	LOG_FUNCTION();
	ErrorCodeEnum eErr = Error_Unexpect;
	//PinPad
	CSimpleStringA sm3desInfo("support:");
	PinPadService_ClientBase* pClient = new PinPadService_ClientBase(this->m_pEntity);
	if (pClient != NULL)
	{
		eErr = pClient->Connect();
		if (eErr == Error_Succeed)
		{
			PinPadService_GetDevInfo_Req reqDev;
			PinPadService_GetDevInfo_Ans ansDev;
			eErr = pClient->GetDevInfo(reqDev, ansDev, 5000);
			if (eErr == Error_Succeed)
			{
				if (ansDev.model.GetLength() > 1 && ansDev.model.GetLength() < 255)
					termInfo["pinpadModel"] = ansDev.model;
				if (ansDev.type.GetLength() > 1 && ansDev.type.GetLength() < 255)
					termInfo["pinpadType"] = ansDev.type;
			}
			else
				return;
			PinPadService_QueryFunc_Req reqQ;
			PinPadService_QueryFunc_Ans ansQ;
			eErr = pClient->QueryFunc(reqQ, ansQ, 5000);
			if (eErr == Error_Succeed)
			{
				sm3desInfo = CSimpleStringA::Format("support:%d,loadkey:%d", ansQ.encryptkey, ansQ.reserved1);
				if (ansQ.encryptkey == 3 || ansQ.encryptkey == 2){
					LogWarn(Severity_Low, Error_Unexpect, HealthManager_UserErrorCode_PinPad_Dev_SP_SM, "PinPad(hardware) support sm.");
				}
				else {
					LogWarn(Severity_Low, Error_Unexpect, HealthManager_UserErrorCode_PinPad_Dev_NOT_SP_SM, "PinPad(hardware) DON'T support sm.");
				}
				if (ansQ.reserved1 == 3|| ansQ.reserved1 == 2) {
					LogWarn(Severity_Low, Error_Unexpect, HealthManager_UserErrorCode_PinPad_HaveLoad_SM, "PinPad have loaded sm key.");
				}
				else if ((ansQ.reserved1 == 2)) {
					LogWarn(Severity_Low, Error_Unexpect, HealthManager_UserErrorCode_PinPad_HaveLoad_SM, "PinPad have loaded sm key.");
				}
				else {
					LogWarn(Severity_Low, Error_Unexpect, HealthManager_UserErrorCode_PinPad_HaveLoad_SM, "PinPad have loaded sm key.");
				}
				termInfo["pinpad"] = sm3desInfo;
			}
			else
				Dbg("QueryFunc failed.error code:%d", eErr);
		}
		else
			Dbg("connect to pinpad failed.error code:%d", eErr);
	}
	return;
}

void CHealthManagerFSM::DeviceReConnect()
{
	//if haven't called access auth ever or in the 1st accessauth processing,no need to call access auth
	if (QueryAccessAuthStatus() == 2 || m_bFirstAccessAuth)
		return;
	CSimpleStringA tmpCheckCode;
	ErrorCodeEnum eErr = QueryCheckCode(tmpCheckCode);
	if (eErr == Error_Succeed)
	{
		Dbg("pre check code size:%d,now:%d", m_checkCode.GetLength(), tmpCheckCode.GetLength());
		SetAccessFailedFlag(false);
		if (tmpCheckCode.GetLength() == 0 || m_checkCode.Compare(tmpCheckCode, true) != 0 || !GetAccessAuthFlag() || !m_bEverAuthSucWithDevice)
		{
			if (m_checkCode.GetLength() > 1 && tmpCheckCode.GetLength() > 1 && m_checkCode.Compare(tmpCheckCode, true) != 0)
			{
				AuthStatus as;
				as.result = 1;
				as.msg = "设备混用，请接入对应设备或后台重新绑定当前设备";
				//SpSendBroadcast(GetEntityBase()->GetFunction(), SP_MSG_OF(AuthStatus), SP_MSG_SIG_OF(AuthStatus), as);
			}
			else
			{
				if (m_checkCode.GetLength() > 1)
					ToReAccessAuth(true);
				else
					ToReAccessAuth();
			}
		}
	}
}
int CHealthManagerFSM::QuitFrameworkAndSaveInfo(RebootTriggerEnum eTrigger, RebootWayEnum eWay)
{
	LOG_FUNCTION();

	CSmartPointer<IEntityFunction> pFunc = GetEntityBase()->GetFunction();
	CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = pFunc.ConvertCase<IEntityFunctionPrivilege>();
	if (pFuncPrivilege == NULL) {
		Dbg("has no privilege");
		return (int)(Error_NoPrivilege);
	}
	Dbg("quit framework and info %d, %d.", eTrigger, eWay);
	const auto result = pFuncPrivilege->Reboot(eTrigger, eWay);
	return (int)result;
}

void CHealthManagerFSM::PostProcessAfterUpgrade()
{
	LOG_FUNCTION();
	CSimpleStringA csRunInfoPath(""), csFileName("");

	ErrorCodeEnum eErr = GetEntityBase()->GetFunction()->GetPath("RunInfo", csRunInfoPath);
	csFileName = csRunInfoPath + "/runcfg/starttime.dat";
	Dbg("file:%s", (const char*)csFileName);
	bool bUpgradeFileExist = false;

#ifdef RVC_OS_WIN
	bUpgradeFileExist = (_access((const char*)csFileName, 0) == 0);
#else
	bUpgradeFileExist = (access((const char*)csFileName, F_OK) == 0);
#endif //RVC_OS_WIN

	if (bUpgradeFileExist)
	{
		Dbg("exist upgrade flag file,to decide if restart framework.");
		//存在升级后的启动文件
		CSmartPointer<IConfigInfo> spConfigRun;
		eErr = GetEntityBase()->GetFunction()->OpenConfig(Config_Run, spConfigRun);
		if (eErr == Error_Succeed)
		{
			int xTimes = 0;
			spConfigRun->ReadConfigValueInt("Run", "UpgradeRestartTimes", xTimes);
			if (xTimes < 3)
			{
				xTimes++;
				Dbg("write Run--UpgradeRestartTimes:%d", xTimes);
				spConfigRun->WriteConfigValueInt("Run", "UpgradeRestartTimes", xTimes);
				if (xTimes == 3)
				{
					//DeleteFileA((const char*)csFileName);
					QuitFrameworkAndSaveInfo(RebootTrigger_Resource, RebootWay_OS);
				}
				else
					QuitFrameworkAndSaveInfo(RebootTrigger_Resource, RebootWay_Framework);
			}
		}
	}
}
void CHealthManagerFSM::SaveOsVersion()
{
#ifdef RVC_OS_WIN
	CSimpleStringA runInfoPath;
	ErrorCodeEnum eErr = GetEntityBase()->GetFunction()->GetPath("runinfo", runInfoPath);
	if (eErr != Error_Succeed) {
		Dbg("GetPath runinfo error=%d.", eErr);
		return;
	}
	runInfoPath += "\\runcfg\\osverion";
	ifstream is;
	is.open(runInfoPath.GetData(), ios::binary);
	if (!is.is_open())
	{
		DWORD dwErr = GetLastError();
		Dbg("open runcfg\\osverion file failed. [%d]", dwErr);
		CSimpleStringA csCmd;
		csCmd = CSimpleStringA::Format("cmd /c ver >%s", runInfoPath);
		WinExec((LPCSTR)csCmd, SW_HIDE);
	}
	return;
#endif
}
CSimpleStringA CHealthManagerFSM::GetOsVersion()
{
	LOG_FUNCTION();
#ifdef RVC_OS_WIN
	char   psBuffer[128];
	FILE* pPipe;

	/* Run DIR so that it writes its output to a pipe. Open this
	 * pipe with read text attribute so that we can read it
	 * like a text file.
	 */
	if ((pPipe = _popen("ver", "rt")) == NULL)
		exit(1);

	/* Read pipe until end of file, or an error occurs. */

	while (fgets(psBuffer, 128, pPipe))
	{
		//puts(psBuffer);
	}

	Dbg("%s", psBuffer);
	/* Close pipe and print return value of pPipe. */
	if (feof(pPipe))
	{
		printf("\nProcess returned %d\n", _pclose(pPipe));
	}
	else
	{
		printf("Error: Failed to read the pipe to the end.\n");
	}
	string str(psBuffer);
	int start = str.find("版本");
	if (start > 0)
		return CSimpleStringA(str.substr(start + 5, str.length() - start - 7).c_str());
	else
		return "";
#else
    const char filePath[] = "/etc/os-version";
	CSimpleStringA strVersion;
    char tmp[33];
    memset(tmp, 0, 33);
    inifile_read_str_s("Version", "MajorVersion", "unknown", tmp, 32, filePath);
    strVersion = tmp;
    strVersion += ".";
    memset(tmp, 0, 33);
	inifile_read_str_s("Version", "MinorVersion", "unknown", tmp, 32, filePath);
    strVersion += tmp;
    strVersion += ".";
    memset(tmp, 0, 33);
    inifile_read_str_s("Version", "OsBuild", "unknown", tmp, 32, filePath);
    strVersion += tmp;
    return strVersion;
#endif
}

void CHealthManagerFSM::UploadEntityStartComsumeTime()
{
    CAutoArray<CSimpleStringA> strEntityNames;
    CAutoArray<int> strEntityIdx;
    CAutoArray<CEntityStartInfo> Infos;
    ErrorCodeEnum eErr = GetEntityBase()->GetFunction()->GetAllEntityStartInfo(strEntityNames, strEntityIdx, Infos);
	int healthmangerStartTimes = 0;
	for (int i = 0; i < strEntityNames.GetCount(); ++i) {
		if (strEntityNames[i].Compare(GetEntityBase()->GetEntityName()) == 0)
		{
            Dbg("%s", (const char*)strEntityNames[i]);
			healthmangerStartTimes = Infos[i].startTimes;
			break;
		}
	}

	if (healthmangerStartTimes == 1) {
		const int i = 0; //SpShell 
		const ULONGLONG curTickCount = GetTickCount64();
		ULONGLONG oldTickCount = 0;
		/** 只有SpShell的结构体才能这样做！！ [Gifur@202193]*/
		memcpy(&oldTickCount, &Infos[i].InitEndTime, sizeof(ULONGLONG));
		const ULONGLONG deltaSeconds = (curTickCount - oldTickCount);
        LogWarn(Severity_Low, Error_Debug, LOG_TRACE_ENTITY_START_TIME,
                SP::Module::Util::generateConsumeTimeJson("total",
                                                          SP::Module::Util::formatTime(Infos[i].startTime).c_str(), deltaSeconds));
	} else {
		Dbg("entity healthmanage start times: %d", healthmangerStartTimes);
	}
}

void CHealthManagerFSM::ToLogWarnTermAboutInfo(BOOL bSuccessFlag)
{
	LOG_FUNCTION();
	bool bTmpEtyNewStart = m_bEntityNewStart;
    CSimpleStringA csOSVerion(""), csWarnMsg(""), csAsiaInfo;
    std::map<std::string, std::string> termInfo;
    termInfo["version"] = m_sysInfo.InstallVersion.ToString();
	termInfo["TerminalNo"] = m_sysInfo.strTerminalID;
	termInfo["MachineType"] = m_sysInfo.strMachineType;
	termInfo["MachineVersion"] = CSimpleStringA::Format("%d.%d", m_sysInfo.MachineVersion.GetMajor(), m_sysInfo.MachineVersion.GetMinor());
	termInfo["Screen"] = CSimpleStringA::Format("%d", m_sysInfo.eScreen);
	termInfo["Site"] = m_sysInfo.strSite;
	termInfo["EnrolGPS"] = CSimpleStringA::Format("%.3f,%.3f", m_sysInfo.EnrolGPS.GetLongitude(), m_sysInfo.EnrolGPS.GetLatitude());
	termInfo["EnrolAddr"] = m_sysInfo.strEnrolAddr;

    if (!m_csErrEntity.IsNullOrEmpty())
        termInfo["ErrEntity"] = m_csErrEntity;
	termInfo["AccessAuth"] = m_bAccessAuth ? "T" : "F";
	csOSVerion = GetOsVersion();
    if (!csOSVerion.IsNullOrEmpty())
        termInfo["OSVersion"] = csOSVerion;
#if defined(RVC_OS_WIN)
	csAsiaInfo = GetIsAsiaInfoInstalled();
#else
	csAsiaInfo = "N";
#endif //RVC_OS_WIN
    termInfo["AsiaInfo"] = csAsiaInfo;
    NetworkAddressesList macAddrs;
    NetworkAddressesList ipAddrs;
	SP::Module::Net::GetINETMacAddresses(macAddrs, ipAddrs);
    CSimpleStringA csMac(""), csIP("");
    for (int i = 0; i < macAddrs.GetCount(); i++) {
		if (!csMac.IsNullOrEmpty()) {
			csMac += ";";
		}
        csMac += macAddrs[i];
    }
    for (int i = 0; i < ipAddrs.GetCount(); i++) {
		if (!csIP.IsNullOrEmpty()) {
			csIP += ";";
		}
        csIP += ipAddrs[i];
    }
    termInfo["MACs"] = csMac;
    termInfo["IPs"] = csIP;

#if defined(RVC_OS_LINUX)
    CSystemStaticInfo sysInfo;
    ErrorCodeEnum eErr = GetEntityBase()->GetFunction()->GetSystemStaticInfo(sysInfo);
    if (eErr == Error_Succeed) {
		termInfo["Manufacturer"] = (LPCTSTR)sysInfo.strManufacturer;
        termInfo["MachineMode"] = (LPCTSTR)sysInfo.strMachineModel;
        termInfo["MachineSN"] = (LPCTSTR)sysInfo.strMachineSN;
    }
#endif //RVC_OS_LINUX

    std::pair<bool, std::string> strResult;
    strResult = generateJsonStr(termInfo);
    Dbg("[%s]", strResult.second.c_str());
    //oilyang@20210323 discard the following rule of throwing LogWarn.Always throw LogWarn 
    //oilyang@20201201 log warn every time if content of msg has changed
	if (bTmpEtyNewStart)
	{
		LogWarn(Severity_Low, Error_Unexpect, LOG_WARN_HEALTH_UPLOAD_INFO_ABOUT_TERM, strResult.second.c_str());
		LogWarn(Severity_Low, Error_Unexpect, HealthManager_UserErrorCode_First_Info_AboutTerm, strResult.second.c_str());
	}
	else
		LogWarn(Severity_Low, Error_Unexpect, LOG_WARN_HEALTH_UPLOAD_INFO_ABOUT_TERM, strResult.second.c_str());

	if (bSuccessFlag) {
		UploadEntityStartComsumeTime();
	}

    CSmartPointer<IConfigInfo> pConfig;
	GetEntityBase()->GetFunction()->OpenConfig(Config_Cache, pConfig);
    int stepStatus(0), curStep(0), lastRecordTime(0);
	CSimpleStringA strInstallVersion(true);
    CSimpleStringA strAdditonalMsg(true);
    pConfig->ReadConfigValueInt("TerminalDeploy", "CurrStep", curStep);


    if (curStep == DeployStep_Finished) {

        pConfig->ReadConfigValueInt("TerminalDeploy", "CurrState", stepStatus);
        pConfig->ReadConfigValueInt("TerminalDeploy", "TimeStamp", lastRecordTime);
		pConfig->ReadConfigValue("TerminalDeploy", "InstallVersion", strInstallVersion);
        pConfig->ReadConfigValue("TerminalDeploy", "LastInfo", strAdditonalMsg);

        LogWarn(Severity_High, Error_Debug, LOG_WARN_HEALTH_INSTALL_TIMESTAMP, 
				CSimpleString::Format("[{\"timeStamp\":\"%s\",\"step\":%d,\"state\":%d, \"version\":\"%s\", \"msg\":\"%s\"}]", 
									  CSmallDateTime(lastRecordTime).ToTimeString().GetData(), curStep, stepStatus
									  , strInstallVersion.GetData(), strAdditonalMsg.GetData()));

        pConfig->WriteConfigValueInt("TerminalDeploy", "CurrStep", DeployStep_Begin);
        pConfig->WriteConfigValueInt("TerminalDeploy", "CurrState", DEPLOYSTATE_NOTINIT);
        pConfig->WriteConfigValue("TerminalDeploy", "TimeStamp", CSimpleStringA::Format("0x%08X", (DWORD)CSmallDateTime::GetNow()));
		if (!strAdditonalMsg.IsNullOrEmpty()) {
            pConfig->WriteConfigValue("TerminalDeploy", "LastInfo", NULL);
		}
    }
}

void CHealthManagerFSM::ShowEntityBootFailedAtFront(LPCTSTR lpcszEntityName, ErrorCodeEnum bootFailedResult, bool isBlock)
{
#if defined(RVC_OS_LINUX)

	CEntityLastErrorInfo errInfo = {};
	ErrorCodeEnum errCode = GetEntityBase()->GetFunction()->GetEntityLastError(lpcszEntityName, errInfo);
	CSimpleStringA strErrMsg(true);
	if (!errInfo.strErrMsg.IsNullOrEmpty()) {
		strErrMsg = CSimpleStringA::Format("%s 模块初始化失败：%s", lpcszEntityName, (LPCTSTR)errInfo.strErrMsg);
	} else {
		strErrMsg = CSimpleStringA::Format("%s 模块初始化失败：%s", lpcszEntityName, (LPCTSTR)SpStrError(bootFailedResult));
	}

	if (isBlock) {
        SP::Module::Comm::LogErrorNotiyStruct notifyItem(bootFailedResult, 0);
        SP::Module::Comm::LogNotiyMessageStruct notifyMsg(strErrMsg);
        notifyItem.Notify(notifyMsg);
	} else {
		LogError(Severity_High, bootFailedResult, 0, strErrMsg);
	}

#endif //RVC_OS_LINUX
}

void CHealthManagerFSM::ToCallAccessAuthDoWork()
{
	if (!m_bInAccessAuthDoWork)
	{
		Dbg("ToCallAccessAuthDoWork");
		AccessAuthTask* pTask = new AccessAuthTask(this);
		GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
	}
}
void CHealthManagerFSM::JudgeIfNeedInitFWB()
{
	LOG_FUNCTION();
	CSimpleStringA csFWBDevSN("");
	GetEntityBase()->GetFunction()->GetSysVar("FWBDevSN", csFWBDevSN);
	if (csFWBDevSN.GetLength() > 12 && csFWBDevSN.IndexOf("FWB") > 2)
	{
		Dbg("This is fwb,we need to check if update master key.");
		FWBDoInitTask* pTask = new FWBDoInitTask(this);
		GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
	}
}
void CHealthManagerFSM::FWBDoInit()
{
	LOG_FUNCTION();
	Sleep(2000);
	CSimpleStringA currCheckCode(""), runcfgCkCode("");
	QueryCheckCode(currCheckCode, true);
	
	CSmartPointer<IConfigInfo> spConfigRun;
	GetEntityBase()->GetFunction()->OpenConfig(Config_Run, spConfigRun);
	spConfigRun->ReadConfigValue("Run", "ckCode", runcfgCkCode);
	//Dbg("oiltest currCheckCode[%s],runcfgCheckCode[%s]", (const char*)currCheckCode,(const char*)runcfgCkCode);
	if (!currCheckCode.IsNullOrEmpty() && !runcfgCkCode.IsNullOrEmpty() && !currCheckCode.Compare(runcfgCkCode))
	{
		Dbg("check code is the same.");
		return;
	}
	else
	{

	}
	ErrorCodeEnum eErr;
	if (m_pInitClient == NULL)
	{
		m_pInitClient = new InitializerService_ClientBase(this->GetEntityBase());
		eErr = m_pInitClient->Connect();
		if (eErr != Error_Succeed) {
			Dbg("Initializer connected failed.");
			m_pInitClient->SafeDelete();
			m_pInitClient = NULL;
			return;
		}
		else
			Dbg("Initializer connected.");
	}
	InitializerService_GetAuthServerInfo_Req getAuthInfoReq;
	InitializerService_GetAuthServerInfo_Ans getAuthInfoAns;
	eErr = m_pInitClient->GetAuthServerInfo(getAuthInfoReq, getAuthInfoAns,10000);
	if (eErr == Error_Succeed)
	{
		InitializerService_InitializeForBlueTooth_Req initReq;
		InitializerService_InitializeForBlueTooth_Ans initAns;
		initReq.strAuthServer = getAuthInfoAns.strIP;
		initReq.nAuthPort = getAuthInfoAns.nPort;
		initReq.strUserID = "admin";
		initReq.strPassword = "";
		initReq.type = 1;
		eErr = m_pInitClient->InitializeForBlueTooth(initReq, initAns, 60000);
		if (eErr == Error_Succeed)
		{
			Dbg("InitializeForBlueTooth suc.");
			Dbg("write new check code.");
			QueryCheckCode(currCheckCode, true);
			spConfigRun->WriteConfigValue("Run", "ckCode", currCheckCode);
			LogWarn(Severity_Low, Error_Unexpect, HealthManager_UserErrorCode_InitForFWB_Init_Suc, "Init for fwb suc.");
		}
		else
		{
			Dbg("InitializeForBlueTooth failed:%d",eErr);
			LogWarn(Severity_Low, Error_Unexpect, HealthManager_UserErrorCode_InitForFWB_Init_Fail, "Init for fwb failed.");
		}
	}
	else
	{
		Dbg("GetAuthServerInfo failed:%d", eErr);
		LogWarn(Severity_Low, Error_Unexpect, HealthManager_UserErrorCode_InitForFWB_GetAuthAddr_Fail, "Init for fwb,get authaccess address suc.");
	}
	return;
}
bool CHealthManagerFSM::IsCutIEBrowser()
{
	LOG_FUNCTION();
	CSimpleStringA key = "CutBrowser.";
	CSmartPointer<IConfigInfo> spCerConfig;
	ErrorCodeEnum eErr = GetEntityBase()->GetFunction()->OpenConfig(Config_CenterSetting, spCerConfig);
	if (eErr == Error_Succeed)
	{
		int tmpCut = 0;
		key += m_sysInfo.strMachineType;
		spCerConfig->ReadConfigValueInt("Common", key, tmpCut);
		if (tmpCut == 1)
			return true;
	}
	return false;

	//if (m_sysInfo.strMachineType.Compare("RVC.Stand2S",true) == 0 || m_sysInfo.strMachineType.Compare("RVC.PAD", true) == 0)
	//	return true;
	//else
	//	return false;
}