myvtm/Module/mod_healthmanager/HealthManagerFSM.cpp

#include "stdafx.h"
#include <fstream>
#include <string>
#include <algorithm>
#include "CommEntityUtil.hpp"
#if defined(RVC_OS_WIN)
#include <TlHelp32.h>
#include <iphlpapi.h>
#include <ws2tcpip.h>
#include <Winsock2.h>
#include <io.h>
#include "CSystemStatus.h"
#pragma comment(lib, "IPHLPAPI.lib")
#pragma comment(lib, "libpublicFun.lib")
#else
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include "iniutil.h"
#endif //RVC_OS_WIN


#include "mod_healthmanager.h"
#include "publicFunExport.h"

using namespace std;

const int MAX_AYSNC_TIMEOUT = 60000;
const int MAX_IGNORE_TIMEOUT = 100;

unsigned long long GetTickCountRVC() {
#if defined(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() {
#if defined(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::ReadConfigFromCenterSettings(m_pEntity, "SleepColdBootMS", NULL, &millsec);
        if (millsec <= 0) {
			//need TODO:boot reform
#if defined(RVC_OS_LINUX)
			millsec = 30000;
#endif // defined(RVC_OS_LINUX)
			millsec = 10000;
        }

        DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Sleep a little time %d", millsec);
        Sleep(millsec);
    }
}

ErrorCodeEnum CHealthManagerFSM::Initial()
{
#if defined(RVC_OS_WIN)
	GetEntityBase()->GetFunction()->SetSysVar("InitFWBFromStart", "N");
	SaveOsVersion();
#endif
	CSmartPointer<IEntityFunction> pFunc = GetEntityBase()->GetFunction();
	CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = pFunc.ConvertCase<IEntityFunctionPrivilege>();
	CSmartPointer<IAsynWaitSp> spWait;
	
	ErrorCodeEnum err;
	CSimpleStringA cfgPath = "", strCoreBoot("CoreBoot"), strSafeLoad("SafeLoad"), strOp("Operating");
	GetEntityBase()->GetFunction()->GetSystemStaticInfo(m_sysInfo);
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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;
	err = GetEntityBase()->GetFunction()->GetPath("cfg", cfgPath);
	cfgPath = cfgPath +  SPLIT_SLASH_STR + "HealthManager.ini";
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("cfgpath[%s]", (const char*)cfgPath);
	ifstream is;
	is.open(cfgPath, ios::binary);
	if (!is.is_open())
	{
		DWORD dwErr = GetLastErrorRVC();
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("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;
	CSmartPointer<IConfigInfo> spConfigCen;
	GetEntityBase()->GetFunction()->OpenConfig(Config_CenterSetting, spConfigCen);
	m_AccessAuthTries = 4;
	do {
		int value(0);
		spConfigCen->ReadConfigValueInt(GetEntityBase()->GetEntityName(), "AccessAuthTries", value);
		if (value > 0) {
			m_AccessAuthTries = value;
		}
	} while (false);
	m_InitTries = 4;
	do {
		int value(0);
		spConfigCen->ReadConfigValueInt(GetEntityBase()->GetEntityName(), "InitTries", value);
		if (value > 0) {
			m_InitTries = value;
		}
	} while (false);
	m_AccessAuthTimeout = 180000;
	do {
		int value(0);
		spConfigCen->ReadConfigValueInt(GetEntityBase()->GetEntityName(), "AccessAuthTimeout", value);
		if (value > 0) {
			m_AccessAuthTimeout = value;
		}
	} while (false);
	m_InitializationTimeout = 180000;
	do {
		int value(0);
		spConfigCen->ReadConfigValueInt(GetEntityBase()->GetEntityName(), "InitializationTimeout", value);
		if (value > 0) {
			m_InitializationTimeout = value;
		}
	} while (false);

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

	CSmartPointer<IConfigInfo> spConfig;
	err = GetEntityBase()->GetFunction()->OpenConfig(Config_Software, spConfig);
	if (err != Error_Succeed) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("Initial")("open cfg file failed!");
		return Error_IO;
	}

	int count, cbNum, slNum, opNum;
	count = cbNum = slNum = opNum = 0;
	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) {
						DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("opt num:[%d]c[%d]s[%d]o[%d]", count, m_coreBootOpt.size(), m_safeLoadOpt.size(), m_operatingOpt.size());

#if defined(RVC_OS_LINUX)
    if (!m_sysInfo.strMachineType.IsNullOrEmpty() && m_sysInfo.strMachineType.Compare("RVC.Stand2S") != 0
		&& m_sysInfo.strMachineType.Compare("RVC.Stand1SPlus") != 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

	spConfigCen->ReadConfigValueInt(GetEntityBase()->GetEntityName(), "SleepEnterOpMS", m_sleepEnterOpMS);
	if (m_sleepEnterOpMS <= 0 || m_sleepEnterOpMS > 20000)
		m_sleepEnterOpMS = 8000;//default
	spConfigCen->ReadConfigValueInt(GetEntityBase()->GetEntityName(), "SleepColdBootMS", m_sleepColdBootMS);
	if (m_sleepColdBootMS <= 0 || m_sleepColdBootMS > 10000)
		m_sleepColdBootMS = 10000;//default
	spConfigCen->ReadConfigValueInt(GetEntityBase()->GetEntityName(), "WKUpdatePeriod", m_wkUpdatePeriod);
	if (m_wkUpdatePeriod <= 0 || m_wkUpdatePeriod > 365)
		m_wkUpdatePeriod = 30;//default
	spConfigCen->ReadConfigValueInt(GetEntityBase()->GetEntityName(), "DoNotUpdateWKDaily", m_iDoNotUpdateWKDaily);

	//oilyang@20210929
	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)
	{
		DbgWithLink(LOG_LEVEL_WARN,LOG_TYPE_SYSTEM)("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;
	m_ullElapseFromOSStart = SP::Module::Comm::RVCGetTickCount();
	m_elapseTimeFromOSStart = m_ullElapseFromOSStart / 1000;
	CSimpleStringA xMsg = CSimpleStringA::Format("{\"Decripstion\":\"Entity start\",\"version\":\"%s\",\"elapseTime\":\"%d\"}", m_sysInfo.InstallVersion.ToString().GetData(), m_elapseTimeFromOSStart);
	LogWarn(Severity_Low, Error_Unexpect, HealthManager_UserErrorCode_Enter_SafeLoad_State, xMsg.GetData());
}
void CHealthManagerFSM::s0_on_exit(void)
{
}
unsigned int CHealthManagerFSM::s0_on_event(FSMEvent* pEvt)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("s0_on_event: %d, %d", pEvt->iEvt, pEvt->param1);
	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分钟，认为是冷启动
	m_ullElapseFromOSStart = GetTickCount64();
	int millsec = 0;
	SP::Module::Comm::Settings::ReadConfigFromCenterSettings(m_pEntity, "BootMaxMillsecsSeeAsAutoRun", NULL, &millsec);
	if (millsec <= 0) {
		millsec = 90000;
	}
    DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("have elapsed %d seconds from system start vs %d", m_ullElapseFromOSStart / 1000, millsec / 1000);
    if (m_ullElapseFromOSStart < millsec) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR0402501Z10101")("start cold boot");
        return true;
    }
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR0402501Z10102")("start warn boot");
    return false;
}

//CoreBoot
void CHealthManagerFSM::s1_on_entry()
{
	ErrorCodeEnum eErrCode;
	CSmartPointer<IEntityFunction> spEntityFunction = GetEntityBase()->GetFunction();
	CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = spEntityFunction.ConvertCase<IEntityFunctionPrivilege>();
	CEntityRunInfo browserInfo;
	eErrCode = spEntityFunction->GetEntityRunInfo("Chromium", browserInfo);

	if (browserInfo.eState == EntityState_Idle)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("IE idle before healthmanager, maybe healthmanager have been losted.");
		m_bIEBeforeHealth = true;
	}

	m_fsmState = HM_FSM_STATE_COREBOOT;

	m_ullElapseFromOSStart = GetTickCount64();
	m_elapseTimeFromOSStart = m_ullElapseFromOSStart / 1000;

	WaitALittleIfNecessary();

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

	bool 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())
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("cannot find %s", (LPCSTR)* vIt);
			continue;
		}
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("AsyncStartEntity:%d", errCode);
			bAsync = true;
			break;
		case LOADOPT_SYNC_VERIFY:
		{
			pFuncPrivilege->StartEntity(it->first, NULL, spWait);
			if (spWait != NULL)
				errCode = spWait->WaitAnswer(MAX_AYSNC_TIMEOUT);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("(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 (errCode != Error_Succeed) {
				return;
#if defined(RVC_OS_LINUX)
				ShowEntityBootFailedAtFront(it->first, errCode);
				return;
#endif //RVC_OS_LINUX
			}
			else
				ret = CheckLoadResult(LOADSTAGE_COREBOOT);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("s1 check ret %d", ret);
			if (ret == 0 || ret == 2)
				goto COREBOOT_FINISH;
		}
		break;
		default:
			break;
		}
	}
COREBOOT_FINISH:

	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();
	DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM)("s1 evt %d",pEvt->iEvt);
	switch(pEvt->iEvt)
	{
	case USER_EVT_COREBOOT_FINISHED:
		pEvt->SetHandled();
		if (pEvt->param1 == 2) {
#if defined(RVC_OS_LINUX)
			ShowEntityBootFailedAtFront(m_csErrEntity, Error_InvalidState);
#endif
		}
		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;
	ErrorCodeEnum eErrCode;
	eErrCode = GetEntityBase()->GetFunction()->SetSysVar("RunState", "S");
	if (eErrCode != Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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())
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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;
		}
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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);
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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 (it->second.eResult != Error_Succeed)
			{
				char tmp[128] = { 0 };
				if (it->first.Compare("SIPPhone", true) == 0) {
					if (LOADING_TIMEOUT == it->second.eResult) {
						sprintf(tmp, "实体 %s 启动超时（%d），请尝试重启应用解决", it->first.GetData(), it->second.eResult);
					}
					else {
						sprintf(tmp, "实体 %s 启动失败（%d），识别不到声卡，请尝试重启计算机解决，多次无效后请联系厂商处理", it->first.GetData(), it->second.eResult);
					}
				}
				else {
					sprintf(tmp, "实体 %s 启动失败 %d", it->first.GetData(), it->second.eResult);
				}
#if defined(RVC_OS_WIN)
				GetEntityBase()->GetFunction()->ShowFatalError(tmp);
				GetEntityBase()->GetFunction()->SetSysVar("AuthErrMsg", tmp);//实体启动失败保存到错误页字段
#else
				ShowEntityBootFailedAtFront(it->first, errCode);
#endif
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("启动失败:%s", tmp);
				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);
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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;
	DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM)("s2 event %d,%d",pEvt->iEvt,pEvt->param1);
	switch(pEvt->iEvt)
	{
	case USER_EVT_SAFELOAD_FINISHED:
		{
			pEvt->SetHandled();
			//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);
					DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM)("after safeload to get termstage %s",(LPCTSTR)csTermStage);
					if (csTermStage == "B" || csTermStage == "N")
						return 1;
				}
				else if (pEvt->param1 == 2)
				{
#if defined(RVC_OS_LINUX)
					ShowEntityBootFailedAtFront(m_csErrEntity, Error_InvalidState);
#endif 
					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()
{
	m_fsmState = HM_FSM_STATE_OP;
	Sleep(m_sleepEnterOpMS);//oilyang@20220120 for temp change from 5000 to 8000 for accessauth
	if (m_custMngerState == CM_ENTER)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("in CMS,no need to start hardware.");
		return;
	}
	ErrorCodeEnum eErrCode;
	eErrCode = GetEntityBase()->GetFunction()->SetSysVar("RunState", "O");
	if (eErrCode != Error_Succeed)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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())
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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;
		}
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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[128] = { 0 };
				if (it->first.Compare("SIPPhone", true) == 0) {
					if (LOADING_TIMEOUT == it->second.eResult) {
						sprintf(tmp, "实体 %s 启动超时（%d），请尝试重启应用解决", it->first.GetData(), it->second.eResult);
					}
					else {
						sprintf(tmp, "实体 %s 启动失败（%d），识别不到声卡，请尝试重启计算机解决，多次无效后请联系厂商处理", it->first.GetData(), it->second.eResult);
					}
				}
				else {
					sprintf(tmp, "实体 %s 启动失败 %d", it->first.GetData(), it->second.eResult);
				}
#if defined(RVC_OS_WIN)
				GetEntityBase()->GetFunction()->ShowFatalError(tmp);
#else
				ShowEntityBootFailedAtFront(it->first, errCode);
#endif 
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("启动失败:%s", tmp);
				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;
			}
			if (errCode != Error_Succeed)
				return;
			else
				ret = CheckLoadResult(LOADSTAGE_OPERATING);
			if (ret == 0 || ret == 2)
				goto OPERATING_FINISH;
		}
		break;
		default:
			break;
		}
	}
OPERATING_FINISH:
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("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();
	DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM)("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) {
#if defined(RVC_OS_LINUX)
            ShowEntityBootFailedAtFront(m_csErrEntity, Error_InvalidState);
#endif
        }
		pEvt->SetHandled();
		break;
	case USER_EVT_ENTER_CUSTOMER_MANAGER:
		pEvt->SetHandled();
		break;
	default:
		break;
	}
	return ret;
}
//Idle(Operating finished)
void CHealthManagerFSM::s4_on_entry()
{
	m_fsmState = HM_FSM_STATE_IDLE;
	LOG_FUNCTION();
	m_accessAuthCheckMD5 = 0;
	CSmartPointer<IEntityFunction> spEntityFunction = GetEntityBase()->GetFunction();
	CSmartPointer<IConfigInfo> spConfig, spCerConfig;
	ErrorCodeEnum eErrCer = spEntityFunction->OpenConfig(Config_CenterSetting, spCerConfig);
	if (eErrCer != Error_Succeed) {
		DbgWithLink(LOG_LEVEL_WARN,LOG_TYPE_SYSTEM)("open central cfg file failed!");
	}
	else
	{
		spCerConfig->ReadConfigValueInt("AccessAuthorization", "CheckMD5", m_accessAuthCheckMD5);
		m_NewStartPage = "";
		spCerConfig->ReadConfigValue("NonExclusive", "NewStartPage", m_NewStartPage);
	}
	DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM)("before access auth,read MD5 flag:%d",m_accessAuthCheckMD5);
}
void CHealthManagerFSM::s4_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CHealthManagerFSM::s4_on_event(FSMEvent* pEvt)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM)("s4 event %d,%d",pEvt->iEvt,pEvt->param1);
	switch(pEvt->iEvt)
	{
	case USER_EVT_ACCESSAUTH_FINISHED:
		{
			pEvt->SetHandled();
			
			CSimpleStringA csTermStage;
			ErrorCodeEnum eErrCode;
			eErrCode = GetEntityBase()->GetFunction()->GetSysVar("TerminalStage",csTermStage);
			DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM)("after accessauth to get termstage %s",(LPCTSTR)csTermStage);
			//oilyang@20220614 添加密钥更新逻辑
			if (csTermStage[0] == 'A')
			{
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("WKUpdatePeriodTask")("after auth suc,to call WKUpdatePeriodTask");
				WKUpdatePeriodTask* pTask = new WKUpdatePeriodTask(this);
				GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
			}
			//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)
			{
				DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM)("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) {
				DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM)("open cfg file(ie) failed!");
				//return err;
			}
			ErrorCodeEnum eErrCerUrl = spEntityFunction->OpenConfig(Config_CenterSetting, spCerConfig);
			if (eErrCerUrl != Error_Succeed) {
				DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM)("open central cfg file(ie) failed!");
			}
			//if load successfully,set FailTimes to 0
			spConfigRun->WriteConfigValueInt("Run","FailTimes",0);


			CSmartPointer<IAsynWaitSp> spWait;
			CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = spEntityFunction.ConvertCase<IEntityFunctionPrivilege>();
			CEntityRunInfo acInfo;
			eErrCode = spEntityFunction->GetEntityRunInfo("Chromium",acInfo);
			if (eErrCode == Error_Succeed && acInfo.eState == EntityState_NoStart)
			{
			}
			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;
			}
			LogTermInfoTask* task = new LogTermInfoTask(this);
			GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
			if (m_iAccessAuth == AccessAuth_Fail)
				PostProcessAfterUpgrade();
		}
		break;
	case USER_EVT_MAITAIN:
		DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM)("to maintain...");
		m_stateBeforeMaintain = m_fsmState;
		m_bIdleToMaintain = true;
		pEvt->SetHandled();
		break;
	case USER_EVT_ENTER_CUSTOMER_MANAGER:
		pEvt->SetHandled();
		break;
	case USER_EVT_VTMLOADER_FINISHED:
	{
		pEvt->SetHandled();
		if (pEvt->iEvt == 1)
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("VtmLoader load entity failed, to Set TerminalStage C.");
			GetEntityBase()->GetFunction()->SetSysVar("TerminalStage", "C");
			break;
		}
		if (!m_bIdleToMaintain)//???no use anymore?
		{
			if (m_iAccessAuth == AccessAuth_Init)
			{
				WaitToCallAccessAuthTask* pTask = new WaitToCallAccessAuthTask(this);
				GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
			}
		}
		else
			m_bIdleToMaintain = false;
	}
		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> spConfigCen,spConfigRun;
	ErrorCodeEnum eErr = GetEntityBase()->GetFunction()->OpenConfig(Config_CenterSetting, spConfigCen);
	eErr = GetEntityBase()->GetFunction()->OpenConfig(Config_Run, spConfigRun);
	int failTimes = 0,maxFailTimes = 2;
	do {
		int value(0);
		spConfigCen->ReadConfigValueInt(GetEntityBase()->GetEntityName(), "MaxFailTimes", value);
		if (value > 0) {
			maxFailTimes = value;
		}
	} while (false);
	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){
			DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM)("set termstage D failed (%d).",eErr);
		}else{
			DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM)("Set TerminalStage D.");
		}
	}
	else
	{
		DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM)("have failed %d times.",failTimes);
		spConfigRun->WriteConfigValueInt("Run","FailTimes",failTimes);
		eErr = GetEntityBase()->GetFunction()->SetSysVar("RunState","F");
		if (eErr != Error_Succeed)
		{
			DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM)("set RunState failed (%d).",eErr);
		}
	}
	PostProcessAfterUpgrade();
}
void CHealthManagerFSM::s5_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CHealthManagerFSM::s5_on_event(FSMEvent* pEvt)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM)("s5(Fault) event %d,%d",pEvt->iEvt,pEvt->param1);
	switch(pEvt->iEvt)
	{
	case USER_EVT_MAITAIN:
		DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM)("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)
		{
			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)
	{
		DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM)("set RunState M failed (%d).",eErrCode);
	}
	CSmartPointer<IEntityFunction> pFunc = GetEntityBase()->GetFunction();
	CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = pFunc.ConvertCase<IEntityFunctionPrivilege>();
	if (pFuncPrivilege == NULL)
	{
		DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM)("display screen NoPrivilege");
		return;
	}
	ErrorCodeEnum eErr = pFuncPrivilege->DisplayBlueScreen("暂停服务");
	DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM)("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)
			{
				DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM)("un-display screen NoPrivilege");
				return 1;
			}
			ErrorCodeEnum eErr = pFuncPrivilege->UndisplayBlueScreen();
			DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM)("un-display blue screen %d",eErr);
			if (m_stateBeforeMaintain == HM_FSM_STATE_IDLE)
			{
				ErrorCodeEnum eErr = GetEntityBase()->GetFunction()->SetSysVar("RunState","O");
				if (eErr != Error_Succeed)
				{
					DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM)("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)
	{
		DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM)("set RunState P failed (%d).",eErrCode);
	}
}
void CHealthManagerFSM::s7_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CHealthManagerFSM::s7_on_event(FSMEvent* pEvt)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM)("s7(PrepareOff) event %d",pEvt->iEvt);
	switch(pEvt->iEvt)
	{
	case USER_EVT_MAITAIN:
		DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM)("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)
	{
		DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM)("set RunState T failed (%d).",eErrCode);
	}
}
void CHealthManagerFSM::s8_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CHealthManagerFSM::s8_on_event(FSMEvent* pEvt)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM)("s8(Terminating) event %d",pEvt->iEvt);
	switch(pEvt->iEvt)
	{
	case USER_EVT_MAITAIN:
		DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM)("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)
	{
		DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM)("set RunState E failed (%d).",eErrCode);
	}
}
void CHealthManagerFSM::s9_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CHealthManagerFSM::s9_on_event(FSMEvent* pEvt)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM)("s9(Exitting) event %d",pEvt->iEvt);
	switch(pEvt->iEvt)
	{
	case USER_EVT_MAITAIN:
		DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM)("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)
	{
		DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM)("set RunState L failed (%d).",eErrCode);
	}
}
void CHealthManagerFSM::s10_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CHealthManagerFSM::s10_on_event(FSMEvent* pEvt)
{
	LOG_FUNCTION();
	DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM)("s10(Sleep) event %d",pEvt->iEvt);
	switch(pEvt->iEvt)
	{
	case USER_EVT_MAITAIN:
		DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM)("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();
	DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM)("s11(In CMS) event %d",pEvt->iEvt);
	int ret = 0;
	switch (pEvt->iEvt)
	{
		case USER_EVT_MAITAIN:
			DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM)("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;
}

//0:auth suc or have already authed;1:auth failed;
int CHealthManagerFSM::AccessAuthDoWork()
{
	LOG_FUNCTION();
	//to check if PinPad is ok, wait for 5 seconds,then go on
	//RVC.CardStore have no PinPad
	int waitCount = 0;
	while (waitCount < 5)
	{
		if (m_bPinPadOpenSuc || m_sysInfo.strMachineType.Compare("RVC.CardStore",true) == 0)
			break;
		else
		{
			Sleep(1000);
			waitCount++;
		}
	}

	m_bInAccessAuthDoWork = true;
	CSimpleStringA csTermStage("");
	ErrorCodeEnum eErr;
	eErr = GetEntityBase()->GetFunction()->GetSysVar("TerminalStage", csTermStage);
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("oninit get termstage %s", (LPCTSTR)csTermStage);
	bool bToDoInit = false;
	if (eErr == Error_Succeed)
	{

	}
	else
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("AccessAuthDoWork")("get TerminalStage failed(%d).", eErr);
		m_bInAccessAuthDoWork = false;
		return 1;
	}
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("AccessAuthDoWork")("after proc initialization.");
	if (bToDoInit)
	{
		if (m_bInitSuc)
		{
		}
		else
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("AccessAuthDoWork")("initialization failed.");
			m_bInAccessAuthDoWork = false;
			return 1;
		}
	}
	//to accessauth
	ErrorCodeEnum eErrCode;
	eErrCode = GetEntityBase()->GetFunction()->GetSysVar("TerminalStage", csTermStage);
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("AccessAuthDoWork")("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>();
			{
				CEntityRunInfo acInfo;
				eErrCode = pFunc->GetEntityRunInfo("AccessAuthorization", acInfo);
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("AccessAuthDoWork")("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);
						DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("AccessAuthDoWork")("start accessauth %d.", eErrCode);
					}
					break;
					case EntityState_Idle:
						DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("AccessAuthDoWork")("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) {
							DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("AccessAuthDoWork")("accessauth connected failed.");
							m_pACClient->SafeDelete();
							m_pACClient = NULL;
							m_bInAccessAuthDoWork = false;
							return 1;
						}
						else {
							DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("AccessAuthDoWork")("accessauth connected.");
						}
					}
				}
				else
				{
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("AccessAuthDoWork")("Get AccessAuth RunInfo failed(%d).", eErrCode);
					m_bInAccessAuthDoWork = false;
					return 1;
				}
				if (m_pACClient != NULL)
				{
					DWORD dwStart = GetTickCountRVC();
					int registCount = 0;
#if defined(RVC_OS_WIN)
					GetEntityBase()->GetFunction()->ShowStartupInfo("正在准入");
#endif
				REGIST:
					//存在循环刷数据的情况，暂时不记这个，只记失败
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR0402501Z10301")();
					eErrCode = (*m_pACClient)(EntityResource::getLink().upgradeLink())->Regist();
					m_bHasAuthEver = true;
					registCount++;
					DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("AccessAuthDoWork")("accessauth regist %d", eErrCode);
					if (eErrCode == Error_Succeed)
					{
						do {
							if (m_iAccessAuth == AccessAuth_Suc || m_iAccessAuth == AccessAuth_Fail)
								break;
							Sleep(1000);
						} while (1);
						m_bFirstAccessAuth = false;
						m_bInAccessAuthDoWork = false;
						return 0;
					}
					else
					{
						DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR0402501Z10301").setResultCode("RTA5102")("call accessauth Regist failed:%d", eErrCode);
						m_bInAccessAuthDoWork = false;
						return 1;
					}
				}
				else
				{
					m_bInAccessAuthDoWork = false;
					return 1;
				}
			}
		}
		else
		{
			m_bInAccessAuthDoWork = false;
			return 0;
		}
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("AccessAuthDoWork")("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)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode("QLR0402501Z10201").setResultCode("RTA5101")("%s start failed", 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;
	}
	if (ret == 0) {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode("QLR0402501Z10201")("entity start succ");
	}
	return ret;
}
void CHealthManagerFSM::SetAccessAuth(int bResult)
{
	m_iAccessAuth = bResult;
	ErrorCodeEnum eErrCode;
	if (bResult == AccessAuth_Suc)
	{
		eErrCode = GetEntityBase()->GetFunction()->SetSysVar("TerminalStage", "A");
	}
	else if (bResult == AccessAuth_servFail) //准入服务端返回失败
	{
		eErrCode = GetEntityBase()->GetFunction()->SetSysVar("TerminalStage", "S");
	}
	else //准入其他失败
	{
		eErrCode = GetEntityBase()->GetFunction()->SetSysVar("TerminalStage", "C");
	}
	DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM).setAPI("SetAccessAuth")("SetAccessAuth %d",bResult);

}

void CHealthManagerFSM::ToReAccessAuth(bool bEver)
{
	Sleep(1500);//for function "AccessAuthDoWork" to quit while
	if (m_bFirstAccessAuth)
		return;
	ToCallAccessAuthDoWork();
}
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);
		DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM).setAPI("AsyncStartEntity")("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;
	DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM).setAPI("OnAnswer")("stage %d,%s,result %d",m_eStage,(LPCSTR)new_entry->EntityName,new_entry->ErrorResult);
	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());
				DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM).setAPI("OnAnswer")("启动失败:%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);
			DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM).setAPI("OnAnswer")("safeload answer %d",ret);
			if (ret == 0 || ret == 2)
			{
				FSMEvent *e = new FSMEvent(USER_EVT_SAFELOAD_FINISHED);
				e->param1 = ret;
				PostEventFIFO(e);
			}
		}else{
			DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM).setAPI("OnAnswer")("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;
	}
}

CSimpleStringA CHealthManagerFSM::GetEntityCfgInfo(CSimpleStringA name,int &loadOpt)
{
	CSimpleStringA entityList(""),csBrowserName("IEBrowser");

	if (!name.IsNullOrEmpty() && name.Compare("AllConfiguredEntity") == 0)
	{
		for (auto itor = m_vAllCfgEntity.cbegin(); itor != m_vAllCfgEntity.cend(); itor++)
		{
			entityList += (*itor) + ",";
		}
		return entityList;
	}
	csBrowserName = "Chromium";
	if (!name.IsNullOrEmpty() && name.Compare(csBrowserName.GetData()) == 0)
	{

		DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM).setAPI("GetEntityCfgInfo")("IE/Chromium just return 2");
		loadOpt = 2;
		return "";
	}
	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;
			return "";
		}
	}
	for (it = m_safeLoadOpt.begin(); it != m_safeLoadOpt.end(); ++it)
	{
		if (_strnicmp(name,it->first,name.GetLength()) == 0)
		{
			loadOpt = it->second.loadOpt;
			return "";
		}
	}
	for (it = m_operatingOpt.begin(); it != m_operatingOpt.end(); ++it)
	{
		if (_strnicmp(name,it->first,name.GetLength()) == 0)
		{
			loadOpt = it->second.loadOpt;
			return "";
		}
	}
	loadOpt = 99;
	return "";
}
ErrorCodeEnum CHealthManagerFSM::QueryCheckCode(CSimpleStringA& csCkCode, bool bMaster)
{
	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)(EntityResource::getLink().upgradeLink())->QueryFunc(reqQ, ansQ, 5000);
			if (eErr == Error_Succeed)
			{
				PinPadService_GetCheckCode_Req reqG;
				PinPadService_GetCheckCode_Ans ansG;
				//oilyang@20220425 sm only,no more 3des
				//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)(EntityResource::getLink().upgradeLink())->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)(EntityResource::getLink().upgradeLink())->GetCheckCode(reqG, ansG, 10000);
				//	if (eErr == Error_Succeed)
				//	{
				//		tmpCheckCode = ansG.checkcode[0];
				//	}
				//}
			}else{
				DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM).setAPI("QueryCheckCode")("QueryFunc failed.error code:%d",eErr);
			}
		}else{
			DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM).setAPI("QueryCheckCode")("connect to pinpad failed.error code:%d",eErr);
		}
	}
	csCkCode = tmpCheckCode;
	return eErr;
}
int CHealthManagerFSM::QuitFrameworkAndSaveInfo(RebootTriggerEnum eTrigger, RebootWayEnum eWay)
{
	CSmartPointer<IEntityFunction> pFunc = GetEntityBase()->GetFunction();
	CSmartPointer<IEntityFunctionPrivilege> pFuncPrivilege = pFunc.ConvertCase<IEntityFunctionPrivilege>();
	if (pFuncPrivilege == NULL) {
			DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM)("has no privilege");
		return (int)(Error_NoPrivilege);
	}
	DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM)("quit framework and info %d,%d.", eTrigger, eWay);
	const auto result = pFuncPrivilege->Reboot(eTrigger, eWay);
	return (int)result;
}
void CHealthManagerFSM::PostProcessAfterUpgrade()
{
	LOG_FUNCTION();

	if (IfInUpgradeProcess())
	{
		DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM)("exist upgrade flag file,to decide if restart framework.");
		//存在升级后的启动文件
		CSmartPointer<IConfigInfo> spConfigRun;
		ErrorCodeEnum eErr = GetEntityBase()->GetFunction()->OpenConfig(Config_Run, spConfigRun);
		if (eErr == Error_Succeed)
		{
			int restartOSTime = 0;
			spConfigRun->ReadConfigValueInt("Run", "UpgradeRestartOSTimes", restartOSTime);
			if(restartOSTime==1){
				DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM).setAPI("PostProcessAfterUpgrade")("升级切换已重启过系统");
				//重启过的系统过的升级，在重试一定次数后等guardian 10分钟回退
				int xTimes = 0;
				spConfigRun->ReadConfigValueInt("Run", "UpgradeRestartTimes", xTimes);
				if (xTimes < 3)
				{
					xTimes++;
					DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM).setAPI("PostProcessAfterUpgrade")("写入: UpgradeRestartTimes:%d", xTimes);
					spConfigRun->WriteConfigValueInt("Run", "UpgradeRestartTimes", xTimes);
					QuitFrameworkAndSaveInfo(RebootTrigger_Resource, RebootWay_Framework);
				}
			}else{
				//未重启过操作系统
				DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM).setAPI("PostProcessAfterUpgrade")("升级切换未重启过系统");
				int xTimes = 0;
				spConfigRun->ReadConfigValueInt("Run", "UpgradeRestartTimes", xTimes);
				if (xTimes < 3)
				{
					xTimes++;
					DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM).setAPI("PostProcessAfterUpgrade")("写入: UpgradeRestartTimes:%d", xTimes);
					spConfigRun->WriteConfigValueInt("Run", "UpgradeRestartTimes", xTimes);
					//oilyang@20211130 change from 3 to 2
					if (xTimes == 2)
					{
						//重启操作系统前把重启框架次数重置，重启OS次数置为1
						DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM).setAPI("PostProcessAfterUpgrade")("准备尝试重启系统后再切换升级");
						spConfigRun->WriteConfigValueInt("Run", "UpgradeRestartTimes", 0);
						spConfigRun->WriteConfigValueInt("Run", "UpgradeRestartOSTimes", 1);
						Sleep(2000);
						QuitFrameworkAndSaveInfo(RebootTrigger_Resource, RebootWay_OS);
					}
					else
						QuitFrameworkAndSaveInfo(RebootTrigger_Resource, RebootWay_Framework);
				}
			}
		}
	}
}
void CHealthManagerFSM::SaveOsVersion()
{
#if defined(RVC_OS_WIN)
	CSimpleStringA runInfoPath;
	ErrorCodeEnum eErr = GetEntityBase()->GetFunction()->GetPath("runinfo", runInfoPath);
	if (eErr != Error_Succeed) {
		DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM)("GetPath runinfo error=%d.", eErr);
		return;
	}
	runInfoPath += "\\runcfg\\osverion";
	ifstream is;
	is.open(runInfoPath.GetData(), ios::binary);
	if (!is.is_open())
	{
		DWORD dwErr = GetLastError();
		DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM)("open runcfg\\osverion file failed. [%d]", dwErr);
		CSimpleStringA csCmd;
		csCmd = CSimpleStringA::Format("cmd /c ver >%s", runInfoPath);
		WinExec((LPCSTR)csCmd, SW_HIDE);
	}
#endif
	return;
}
CSimpleStringA CHealthManagerFSM::GetOsVersion()
{
#if defined(RVC_OS_WIN)
	CSimpleStringA runInfoPath;
	ErrorCodeEnum eErr = GetEntityBase()->GetFunction()->GetPath("runinfo", runInfoPath);
	if (eErr != Error_Succeed) {
		DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM).setAPI("GetOsVersion")("GetPath runinfo error=%d.", eErr);
		return "";
	}
	runInfoPath += "\\runcfg\\osverion";
	ifstream is;
	is.open(runInfoPath.GetData(), ios::binary);
	if (!is.is_open())
	{
		DWORD dwErr = GetLastError();
		DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM).setAPI("GetOsVersion")("open runcfg\\osverion file failed. [%d]", dwErr);
		return "";
	}
	string line;
	while(!is.eof()){
		getline(is, line);
		int start = line.find("版本");
		if (start > 0)
			return CSimpleStringA(line.substr(start + 5, line.length() - start - 7).c_str());
		else
			continue;
	}
	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
}

CSimpleStringA CHealthManagerFSM::GetPathInfo()
{
	CSimpleStringA result("");
	CAutoArray<CSimpleStringA> arrSections, arrKeys;

	CSmartPointer<IConfigInfo> spRootConfig;
	CSmartPointer<IEntityFunction> spEntityFunction = GetEntityBase()->GetFunction();
	spEntityFunction->OpenConfig(Config_Root, spRootConfig);
	ErrorCodeEnum errCode = spRootConfig->ReadAllSections(arrSections);
	if(Error_Succeed != errCode){
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("GetPathInfo sections failed.");
		return result;
	}

	if(arrSections.GetCount() == 0){
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Has no section in root.");
		return result;
	}

	for(int i = 0; i < arrSections.GetCount(); ++i)
	{
		if(arrSections[i].Compare("Path") == 0){
			spRootConfig->ReadAllKeys(arrSections[i].GetData(), arrKeys);
			for (int j = 0; j < arrKeys.GetCount(); ++j)
			{
				CSimpleStringA strValue, strMsg;
				spRootConfig->ReadConfigValue(arrSections[i].GetData(), arrKeys[j].GetData(), strValue);
				strMsg = CSimpleStringA::Format("{\"%s\":\"%s\"}", arrKeys[j].GetData(), strValue.GetData());
				result = (j == arrKeys.GetCount() - 1) ? result + strMsg : result + strMsg + ",";
			}
			break;
		}
	}
	return result;
}

#if defined(RVC_OS_WIN)
const char* dmi_string(const dmi_header* dm, BYTE s)
{

	char* bp = (char*)dm;
	size_t i, len;

	if (s == 0)
		return "Not Specified";

	bp += dm->length;
	while (s > 1 && *bp)
	{

		bp += strlen(bp);
		bp++;
		s--;
	}

	if (!*bp)
		return "BAD_INDEX";

	/* ASCII filtering */
	len = strlen(bp);
	for (i = 0; i < len; i++)
		if (bp[i] < 32 || bp[i] == 127)
			bp[i] = '.';

	return bp;
}

void CHealthManagerFSM::QueryComputerInfo()
{
	int ret = 0;
	RawSMBIOSData* Smbios;
	dmi_header* h = NULL;
	int flag = 1;

	ret = GetSystemFirmwareTable('RSMB', 0, 0, 0);
	if (!ret)
	{

		Dbg("Function failed!");
		return;
	}

	DWORD bufsize = ret;
	char* buf = new char[bufsize];
	memset(buf, 0, bufsize);

	ret = GetSystemFirmwareTable('RSMB', 0, buf, bufsize);
	if (!ret)
	{

		Dbg("Function failed!");
		delete[]buf;
		return;
	}

	Smbios = (RawSMBIOSData*)buf;

	BYTE* p = Smbios->SMBIOSTableData;

	if (Smbios->Length != bufsize - 8)
	{

		Dbg("Smbios length error");
		delete[]buf;
		return;
	}

	for (int i = 0; i < Smbios->Length; i++) {
		h = (dmi_header*)p;

		if (h->type == 1)
		{
			m_computerInfo["Manufacturer"] = dmi_string(h, p[0x4]);
			m_computerInfo["ComputerName"] = dmi_string(h, p[0x5]);
			m_computerInfo["ComputerVersion"] = dmi_string(h, p[0x6]);
			m_computerInfo["SerialNumber"] = dmi_string(h, p[0x7]);

			break;
		}
		p += h->length;
		while ((*(WORD*)p) != 0) p++;
		p += 2;
	}
	delete[]buf;
}
#endif //RVC_OS_WIN

DWORD GetDualTime(SYSTEMTIME& t1, SYSTEMTIME& t2)
{
	//assume t2 > t1...
	//oiltest for simple
	int s1, s2;
	s1 = (t1.wMinute * 60 + t1.wSecond) * 1000 + t1.wMilliseconds;
	s2 = (t2.wMinute * 60 + t2.wSecond) * 1000 + t2.wMilliseconds;
	return s2 - s1;
}

void CHealthManagerFSM::ToLogWarnTermAboutInfo()
{
	LOG_FUNCTION();
	bool bTmpEtyNewStart = m_bEntityNewStart;
	if (m_bEntityNewStart)
	{
		SYSTEMTIME shellStartTime;
		ULONGLONG totalCost = 0;
		m_bEntityNewStart = false;
		CAutoArray<CSimpleStringA> strEntityNames;
		CAutoArray<int> strEntityIdx;
		CAutoArray<CEntityStartInfo> Infos;
		ErrorCodeEnum eErr = GetEntityBase()->GetFunction()->GetAllEntityStartInfo(strEntityNames, strEntityIdx, Infos);
		for (int i = 0; i < Infos.GetCount(); ++i)
		{
			if (strEntityIdx[i] == 0)
			{
				shellStartTime = Infos[i].startTime;
				ULONGLONG dwElapseNow = GetTickCount64();
				totalCost = dwElapseNow - m_ullElapseFromOSStart;
				LogWarn(Severity_Low, Error_Debug, LOG_TRACE_ENTITY_START_TIME,
					SP::Module::Util::generateConsumeTimeJson("total", SP::Module::Util::formatTime(shellStartTime).c_str(), totalCost).GetData());
			}				
			LogWarn(Severity_Low, Error_Debug, LOG_TRACE_ENTITY_START_TIME,
					SP::Module::Util::generateConsumeTimeJson(strEntityNames[i], SP::Module::Util::formatTime(Infos[i].startTime).c_str(), GetDualTime(Infos[i].startTime, Infos[i].startEndTime)).GetData());
		}
		
	}
    CSimpleStringA csOSVerion(""), csWarnMsg("");
	std::map<std::string, std::string> termInfo;
	std::map<std::string, std::string> pcInfo;
	termInfo["version"] = m_sysInfo.InstallVersion.ToString();

	if (!m_csErrEntity.IsNullOrEmpty())
	{
		termInfo["ErrEntity"] = m_csErrEntity;

		CSimpleStringA tErr = CSimpleStringA::Format("实体启动失败：%s", m_csErrEntity.SubString(1).GetData());
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("auth错误信息为：%s.", tErr.GetData());

		CSimpleStringA tmp;
		GetEntityBase()->GetFunction()->GetSysVar("AuthErrMsg", tmp);//获取当前已保存的报错信息
		
		if (tmp.GetLength() <= 3)
		{
			GetEntityBase()->GetFunction()->SetSysVar("AuthErrMsg", tErr.GetData());//实体启动失败保存到错误页字段
		}

	}
	termInfo["AccessAuth"] = (m_iAccessAuth == AccessAuth_Suc)?"T":"F";//oiltmp modify to init/fail/suc?
	csOSVerion = GetOsVersion();
	if (!csOSVerion.IsNullOrEmpty())
		termInfo["OSVersion"] = csOSVerion;
	pcInfo["TerminalNo"] = m_sysInfo.strTerminalID;//20220704 add by zjw
	pcInfo["MachineType"]  = m_sysInfo.strMachineType;
	pcInfo["MachineVersion"] = CSimpleStringA::Format("%d.%d", m_sysInfo.MachineVersion.GetMajor(), m_sysInfo.MachineVersion.GetMinor());
	pcInfo["Screen"] = CSimpleStringA::Format("%d", m_sysInfo.eScreen);
	pcInfo["Site"]  = m_sysInfo.strSite;
	pcInfo["EnrolGPS"]  = CSimpleStringA::Format("%.3f,%.3f", m_sysInfo.EnrolGPS.GetLongitude(), m_sysInfo.EnrolGPS.GetLatitude());
	pcInfo["EnrolAddr"]  = m_sysInfo.strEnrolAddr;

#if defined(RVC_OS_WIN)
	termInfo["OSType"] = "Windows";
	QueryComputerInfo();
	pcInfo["Manufacturer"] = m_computerInfo["Manufacturer"];
	pcInfo["ComputerName"] = m_computerInfo["ComputerName"];
	pcInfo["ComputerVersion"] = m_computerInfo["ComputerVersion"];
	pcInfo["SerialNumber"] = m_computerInfo["SerialNumber"];
	std::string strOSVersionName, strOSArch;
	CSystemStatus tempStatus;
	tempStatus.GetOsInfo(strOSVersionName, strOSArch);
	if (!strOSArch.empty()) {
		pcInfo["SystemArch"] = strOSArch;
	}
#else
	termInfo["OSType"] = "UOS";
	pcInfo["Manufacturer"] = m_sysInfo.strManufacturer.IsNullOrEmpty() ? "": m_sysInfo.strManufacturer.GetData();
	pcInfo["MachineModel"] = m_sysInfo.strMachineModel.IsNullOrEmpty() ? "" : m_sysInfo.strMachineModel.GetData();
	pcInfo["SN"] = m_sysInfo.strMachineSN.IsNullOrEmpty() ? "" : m_sysInfo.strMachineSN.GetData();
	//???oiltmp
	termInfo["Manufacturer"] = m_sysInfo.strManufacturer.IsNullOrEmpty() ? "" : m_sysInfo.strManufacturer.GetData();
	termInfo["MachineMode"] = m_sysInfo.strMachineModel.IsNullOrEmpty() ? "" : m_sysInfo.strMachineModel.GetData();
	termInfo["MachineSN"] = m_sysInfo.strMachineSN.IsNullOrEmpty() ? "" : m_sysInfo.strMachineSN.GetData();
#endif



	//加载Path节点
	CSimpleStringA pathInfo = GetPathInfo();

	CSmartPointer<IConfigInfo> spConfigRun;
	GetEntityBase()->GetFunction()->OpenConfig(Config_Run, spConfigRun);

	CAutoArray<SP::Module::Net::NetworkAdapterItem> netList;
	SP::Module::Net::GetINETMacAddresses(netList);
	CSimpleStringA csMac(""), csIP("");
    for (int i = 0; i < netList.GetCount(); i++) {
		if (!csMac.IsNullOrEmpty()) {
			csMac += ";";
		}
		csMac += netList[i].mac.c_str();
	}
    for (int i = 0; i < netList.GetCount(); i++) {
		if (!csIP.IsNullOrEmpty()) {
			csIP += ";";
		}
        csIP += netList[i].ip.c_str();
    }

	termInfo["MACs"] = csMac;
	termInfo["IPs"] = csIP;
	char xOSTime[64] = {0};

	char elapseTime[64] = {0};//使用机器启动时间秒数
	ULONGLONG dwElapse = GetTickCountRVC();
	DWORD elapseTimeTemp = dwElapse / 1000;
#if defined(RVC_OS_WIN)
	termInfo["OSTime"] = itoa(m_elapseTimeFromOSStart, xOSTime, 10);
	termInfo["elapseTime"] = itoa(elapseTimeTemp, elapseTime, 10);
#else
	termInfo["OSTime"] = _itoa(m_elapseTimeFromOSStart, xOSTime, 10);
	termInfo["elapseTime"] = _itoa(elapseTimeTemp, elapseTime, 10);
#endif
	
	CSimpleStringA csRunPath("");
	GetEntityBase()->GetFunction()->GetPath("Run", csRunPath);
	termInfo["AppPath"] = csRunPath;

	std::pair<bool, std::string> strResult;
	std::pair<bool, std::string> strPCInfo;
	strResult = generateJsonStr(termInfo);
	strPCInfo = generateJsonStr(pcInfo);

	spConfigRun->ReadConfigValue("Run", "WarnMsg", csWarnMsg);
	DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM)("ToLogWarnTermAboutInfo:[%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());
		LogWarn(Severity_Low, Error_Unexpect, HealthManager_UserErrorCode_First_Info_AboutPC, strPCInfo.second.c_str());
		LogWarn(Severity_Low, Error_Unexpect, HealthManager_UserErrorCode_Upload_PathInfo, pathInfo.GetData());
	}
	else
		LogWarn(Severity_Low, Error_Unexpect, LOG_WARN_HEALTH_UPLOAD_INFO_ABOUT_TERM, strResult.second.c_str());

#if defined(RVC_OS_LINUX)
	/** 上送安装记录信息，包括安装时间，安装耗时时长，使用的安装版本等 [Gifur@2023823]*/
    CSmartPointer<IConfigInfo> pConfig;
	GetEntityBase()->GetFunction()->OpenConfig(Config_Cache, pConfig);
    int stepStatus(0), curStep(0), lastRecordTime(0), beginInstallRecordTime(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);
		pConfig->ReadConfigValueInt("TerminalDeploy", "StartTimeStamp", beginInstallRecordTime);

		const DWORD consumeTick = lastRecordTime - beginInstallRecordTime;

        LogWarn(Severity_High, Error_Debug, LOG_WARN_HEALTH_INSTALL_TIMESTAMP, 
				CSimpleString::Format("{\"begin\":\"%s\",\"finished\":\"%s\", \"consume\":\"%s\", \"step\":%d,\"state\":%d, \"version\":\"%s\", \"msg\":\"%s\"}", 
                                      CSmallDateTime(beginInstallRecordTime).ToTimeString().GetData(),
									  CSmallDateTime(lastRecordTime).ToTimeString().GetData(), 
                                      CSmallDateTime(consumeTick).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);
		}
        pConfig->WriteConfigValue("TerminalDeploy", "StartTimeStamp", NULL);

		do 
		{
            CSmartPointer<IConfigInfo> spConfigRun;
            GetEntityBase()->GetFunction()->OpenConfig(Config_Run, spConfigRun);
			spConfigRun->WriteConfigValue("DeployInfo", "InstallVersion", strInstallVersion);
			spConfigRun->WriteConfigValueInt("DeployInfo", "InstallTimeStamp", lastRecordTime);

		} while (false);
    }
#endif 
}
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 (CSimpleStringA(lpcszEntityName).Compare("SIPPhone", true) == 0)
	{
		GetEntityBase()->GetFunction()->SetSysVar("AuthErrMsg", strErrMsg.GetData());//实体启动失败保存到错误页字段
	}
	
	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)
	{
		DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM).setAPI("ToCallAccessAuthDoWork")("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)
	{
		DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM).setAPI("JudgeIfNeedInitFWB")("This is fwb,we need to check if update master key.");
		FWBDoInitTask* pTask = new FWBDoInitTask(this);
		GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
	}
}
void CHealthManagerFSM::FWBDoInit()
{
#if defined(RVC_OS_WIN)
	//准入通过则进行检查，否则等待准入通过，直到永远~
	while (true)
	{
		Sleep(1000);
		CSimpleStringA csTerminalStage("");
		if (GetEntityBase()->GetFunction()->GetSysVar("TerminalStage", csTerminalStage) == Error_Succeed
			&& csTerminalStage.Compare("A") == 0)
			break;
	}
	CSimpleStringA currCheckCode("");
	QueryCheckCode(currCheckCode, true);

	CSimpleStringA csCkCode("");
	GetEntityBase()->GetFunction()->GetSysVar("ckCode", csCkCode);

	if (!currCheckCode.IsNullOrEmpty() && !csCkCode.IsNullOrEmpty() && !currCheckCode.Compare(csCkCode, true))
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("FWBDoInit")("check code is the same.");
		return;
	}
	else
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("FWBDoInit")("curr:[%s],ckCode:[%s]", currCheckCode.GetData(), csCkCode.GetData());
	}
	ErrorCodeEnum eErr;
	if (m_pACClient == NULL || m_pACClient->QuerySessionClosed())
	{
		m_pACClient = new AccessAuthService_ClientBase(this->GetEntityBase());
		eErr = m_pACClient->Connect();
		if (eErr != Error_Succeed) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("FWBDoInit")("AccessAuth connected failed.");
			m_pACClient->SafeDelete();
			m_pACClient = NULL;
			return;
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("FWBDoInit")("AccessAuth connected.");
		}
	}


	eErr = (*m_pACClient)(EntityResource::getLink().upgradeLink())->UpdateWK();
	if (eErr == Error_Succeed)
	{
		GetEntityBase()->GetFunction()->SetSysVar("InitFWBFromStart", "Y");
		QueryCheckCode(currCheckCode, true);
		GetEntityBase()->GetFunction()->SetSysVar("ckCode", currCheckCode, true);
		LogWarn(Severity_Low, Error_Unexpect, HealthManager_UserErrorCode_InitForFWB_Init_Suc, "Init for fwb suc.");
	}
	else
		LogWarn(Severity_Low, Error_Unexpect, HealthManager_UserErrorCode_InitForFWB_Init_Fail,
			CSimpleStringA::Format("Init for fwb failed:%d", eErr));
#endif
	return;
}

bool CHealthManagerFSM::IfInUpgradeProcess()
{
	CSimpleStringA csRunCfgPath(""), csFileName("");

	ErrorCodeEnum eErr = GetEntityBase()->GetFunction()->GetPath("RunCfg", csRunCfgPath);
	csFileName = csRunCfgPath + SPLIT_SLASH_STR + "starttime.dat";
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("csFileName:%s", csFileName.GetData());
#if defined(RVC_OS_WIN)
	if (_access((const char*)csFileName, 0) == 0) {
#else
	if (access((const char*)csFileName, F_OK) == 0) {
#endif
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("IfInUpgradeProcess")("升级切换中");
		return true;
	}
	else
		return false;
}
void CHealthManagerFSM::AutoDoInitForAll()
{
	LOG_FUNCTION();
	m_bDoingAutoInit = true;
	ErrorCodeEnum eErr;
	if (m_pACClient == NULL || m_pACClient->QuerySessionClosed())
	{
		m_pACClient = new AccessAuthService_ClientBase(this->GetEntityBase());
		eErr = m_pACClient->Connect();
		if (eErr != Error_Succeed) {
			m_bDoingAutoInit = false;
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("AutoDoInitForAll")("AccessAuth connected failed.");
			m_pACClient->SafeDelete();
			m_pACClient = NULL;
			return;
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("AutoDoInitForAll")("AccessAuth connected.");
		}
	}

	AccessAuthService_InitializeNew_Req initReq;
	AccessAuthService_InitializeNew_Ans initAns;
	initReq.strAuthServer = "";
	initReq.strUserID = "admin";
	initReq.strPassword = "";
	eErr = (*m_pACClient)(EntityResource::getLink().upgradeLink())->InitializeNew(initReq, initAns, 60000);
	m_autoDoInitCount++;
	if (eErr == Error_Succeed)
	{
		//Dbg("Auto Init suc.");
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("AutoDoInitForAll")("Auto Init suc.");
		LogWarn(Severity_Low, Error_Unexpect, HealthManager_UserErrorCode_AutoDoInit_Suc, "Auto Init suc.");
		m_bDoingAutoInit = false;
	}
	else
	{
		//Dbg("Auto Init failed:%d", eErr);
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("AutoDoInitForAll")("Auto Init failed:%d", eErr);
		LogWarn(Severity_Low, Error_Unexpect, HealthManager_UserErrorCode_AutoDoInit_Fail, "Auto Init failed.");
	}

	m_bDoingAutoInit = false;
	return;
}
void CHealthManagerFSM::CheckIfNeedAutoInit()
{
	ErrorCodeEnum eErr = Error_Unexpect;
	bool bNeedAutoInit = false;
	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)(EntityResource::getLink().upgradeLink())->QueryFunc(reqQ, ansQ, 5000);
			if (eErr == Error_Succeed)
			{
				if ((ansQ.encryptkey == 3 || ansQ.encryptkey == 2) && ansQ.reserved1 == 1)
				{
					bNeedAutoInit = true;
				}
			}else{
				DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM).setAPI("CheckIfNeedAutoInit")("QueryFunc failed.error code:%d", eErr);
			}
			pClient->GetFunction()->CloseSession();
		}else{
			DbgWithLink(LOG_LEVEL_INFO,LOG_TYPE_SYSTEM).setAPI("CheckIfNeedAutoInit")("connect to pinpad failed.error code:%d", eErr);
			pClient->SafeDelete();
		}
	}
	if (bNeedAutoInit && !m_bDoingAutoInit && m_autoDoInitCount < 2)
	{
		AutoDoInitForAllTask* pTask = new AutoDoInitForAllTask(this);
		GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
	}
}
void CHealthManagerFSM::WaitToCallAccessAuthDoWork()
{
	//WaitForSingleObject
	bool bHaveShowMsg = false;
	while (1)
	{
		CSimpleStringA csHavePath("N");
		GetEntityBase()->GetFunction()->GetSysVar("AccessHavePath", csHavePath);
		if (csHavePath.Compare("Y") == 0 || csHavePath.Compare("E") == 0)
		{
			AccessAuthTask* pTask = new AccessAuthTask(this);
			GetEntityBase()->GetFunction()->PostThreadPoolTask(pTask);
			break;
		}
		else
		{
			Sleep(5000);
			if (m_NewStartPage.IndexOf(m_sysInfo.strMachineType) < 0)
			{
				if (!bHaveShowMsg)
				{
					GetEntityBase()->GetFunction()->ShowStartupInfo("等待准入灰度访问结果");
					bHaveShowMsg = true;
				}
			}
			else {
				LogWarn(Severity_High, Error_Unexpect, HealthManager_UserErrorCode_WaitForAccessGrayResult, "等待准入灰度访问结果");
			}
		}
	}
}
void CHealthManagerFSM::WKUpdatePeriod()
{
	auto pEntity = ((CHealthManagerEntity*)m_pEntity);
	//oilyang@20220421 if have init fwb from HealthManager start,no need to update working key
	//oilyang@20220413 control update working key by CenterSetting
	CSimpleStringA xInitFWBFlag("N");
	GetEntityBase()->GetFunction()->GetSysVar("InitFWBFromStart", xInitFWBFlag);
	if (m_iDoNotUpdateWKDaily == 1 || xInitFWBFlag.Compare("Y") == 0)
	{
		// 没有密码键盘 或 集中配置告知无需更新 或 蓝牙多合一正在更新，无需更新
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)
			(CSimpleStringA::Format("DoNotUpdateWKDaily:%d or InitFWB:%s, ignore update wk"
				, m_iDoNotUpdateWKDaily, xInitFWBFlag.GetData()));
		return;
	}

	// 检查上次密钥同步时间（一天只同步一次）
	CSmartPointer<IConfigInfo> pConfigRun;
	m_pEntity->GetFunction()->OpenConfig(Config_Run, pConfigRun);

	int nWKLastSyncTime(0);
	pConfigRun->ReadConfigValueInt("Main", "WKSyncSuccTime", nWKLastSyncTime);
	int nWKSyncFailCount(0);
	pConfigRun->ReadConfigValueInt("Main", "WKSyncFailCount", nWKSyncFailCount);

	SYSTEMTIME stSyncTime = CSmallDateTime(nWKLastSyncTime).ToSystemTime();
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)
		("last WK sync time: %04d-%02d-%02d %02d:%02d:%02d",
			stSyncTime.wYear, stSyncTime.wMonth, stSyncTime.wDay,
			stSyncTime.wHour, stSyncTime.wMinute, stSyncTime.wSecond);

	SYSTEMTIME stNow = {};
	GetLocalTimeRVC(stNow);
	int lastUpdateDays = sumday(stSyncTime.wYear, stSyncTime.wMonth, stSyncTime.wDay);
	int todayDays = sumday(stNow.wYear, stNow.wMonth, stNow.wDay);
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("lastUpdateDays:%d,todayDays:%d,x:%d", lastUpdateDays,todayDays, todayDays-lastUpdateDays);
	//if ((nWKLastSyncTime > 0 && stSyncTime.wYear == stNow.wYear
	//	&& stSyncTime.wMonth == stNow.wMonth && stSyncTime.wDay == stNow.wDay
	//	&& nWKSyncFailCount == 0))	// 最近一次同步成功，才能跳过
	if (todayDays - lastUpdateDays < m_wkUpdatePeriod)
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)
			("WK has been updated, last sync time: %s", (const char*)CSmallDateTime(nWKLastSyncTime).ToTimeString());
	}
	else
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("begin update WK now");
		ErrorCodeEnum eErrCode = Error_Succeed;
		if (m_pACClient == NULL)
		{
			m_pACClient = new AccessAuthService_ClientBase(this->GetEntityBase());
			eErrCode = m_pACClient->Connect();
			if (eErrCode != Error_Succeed) {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("accessauth connected failed.");
				m_pACClient->SafeDelete();
				m_pACClient = NULL;
				m_bInAccessAuthDoWork = false;
				return;
			}
			else {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("WKUpdatePeriod")("accessauth connected.");
			}
		}

		eErrCode = (*m_pACClient)(EntityResource::getLink().upgradeLink())->UpdateWK();
		if(Error_Succeed == eErrCode)
		{
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setLogCode("QLR0402501Z0001")("accessauth updatewk succ.");
			pConfigRun->WriteConfigValue("Main", "WKSyncSuccTime", 
				(const char*) CSimpleStringA::Format("0x%08X", (DWORD)CSmallDateTime::GetNow()));
			pConfigRun->WriteConfigValueInt("Main", "WKSyncFailCount", 0);

		}
		else
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setLogCode("QLR0402501Z0001").setResultCode("RTA5110")("accessauth updatewk failed.");
			nWKSyncFailCount++;
			pConfigRun->WriteConfigValueInt("Main", "WKSyncFailCount", nWKSyncFailCount);
		}
	}
}
int CHealthManagerFSM::sumday(int year, int month, int day)
{
	int days[2][13] = { {0,31,59,90,120,151,181,212,243,273,304,334,365},{0,31,60,91,121,152,182,213,244,274,305,335,366} };
	int iLeapYear = 0;
	if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0)
		iLeapYear = 1;
	int yearday = year * 365 + year / 4 - year / 100 + year / 400;
	int monthday = days[iLeapYear][month - 1];
	return yearday + monthday + day;
}
void CHealthManagerFSM::QueryHardwareInfo(SpReqAnsContext<HealthManagerService_QueryHardwareInfo_Req, HealthManagerService_QueryHardwareInfo_Ans>::Pointer ctx)
{
	CSystemStaticInfo info;
	GetEntityBase()->GetFunction()->GetSystemStaticInfo(info);

	CAutoArray<SP::Module::Net::NetworkAdapterItem> netList;
	SP::Module::Net::GetINETMacAddresses(netList);

	CAutoArray<CSimpleStringA> ipAddrs, macAddrs;
	for (int i = 0; i < netList.GetCount(); i++) {
		CSimpleStringA tmpip = netList[i].ip.c_str();
		CSimpleStringA tmpmac = netList[i].mac.c_str();
		ipAddrs.Append(&tmpip, 0, 1);
		macAddrs.Append(&tmpmac, 0, 1);
	}
	ctx->Ans.ip = ipAddrs;
	ctx->Ans.mac = macAddrs;
	ctx->Ans.machineType = info.strMachineType;
	ctx->Ans.site = info.strSite;
	ctx->Ans.terminalNo = info.strTerminalID;
	ctx->Ans.termLimit = "";
	ctx->Ans.termVersion = info.InstallVersion.ToString();
#if defined(RVC_OS_WIN)
	//oiltmp 备注reserved3、reserved4这是什么情况下用的？看得莫名其妙，在一个常用调用接口里面每次都取，这是不怕亚信？
	//reserved3, 获取windows系统版本
	DWORD dwMajorVer, dwMinorVer, dwBuildNumber;
	BOOL bRet = FALSE;
	HMODULE hModNtdll = NULL;
	if (hModNtdll = ::LoadLibraryW(L"ntdll.dll"))
	{
		typedef void (WINAPI* pfRTLGETNTVERSIONNUMBERS)(DWORD*, DWORD*, DWORD*);
		pfRTLGETNTVERSIONNUMBERS pfRtlGetNtVersionNumbers;
		pfRtlGetNtVersionNumbers = (pfRTLGETNTVERSIONNUMBERS)::GetProcAddress(hModNtdll, "RtlGetNtVersionNumbers");
		if (pfRtlGetNtVersionNumbers)
		{
			pfRtlGetNtVersionNumbers(&dwMajorVer, &dwMinorVer, &dwBuildNumber);
			dwBuildNumber &= 0x0ffff;
			bRet = TRUE;
		}

		::FreeLibrary(hModNtdll);
		hModNtdll = NULL;
	}

	//reserved4
	char buffer[1024];
	sprintf(buffer, "%d.%d.%d", dwMajorVer, dwMinorVer, dwBuildNumber);
	string sysVer = "Windows ver[" + string(buffer) + "]";
	ctx->Ans.reserved3 = CSimpleStringA(sysVer.c_str());

	CSimpleStringA deviceFct("");
	// pad设备厂商为Microsoft， 其他设备读取root中的pinpad字段下的vendor
	if (info.strMachineType == "RVC.PAD")
	{
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("This is PAD device.");
		deviceFct = "Microsoft";
	}
	else
	{
		CSmartPointer<IConfigInfo> spConfig;
		GetEntityBase()->GetFunction()->OpenConfig(Config_Root, spConfig);
		spConfig->ReadConfigValue("Device.PinPad", "Vendor", deviceFct);
	}
	ctx->Ans.reserved4 = deviceFct;
#endif //RVC_OS_WIN

	//reserved1
#ifdef DEVOPS_ON_ST /*DevOps流水线编译，ST环境*/
	ctx->Ans.reserved1 = 1;
#elif defined(DEVOPS_ON_UAT)/*DevOps流水线编译，UAT环境*/
	ctx->Ans.reserved1 = 2;
#elif defined(DEVOPS_ON_PRD)/*DevOps流水线编译，PRD环境*/
	ctx->Ans.reserved1 = 3;
#elif defined(DEVOPS_ON_DEV)/*DevOps流水线编译，Dev环境*/
	ctx->Ans.reserved1 = 0;
#else/*本地编译等非DevOps环境编译的版本*/
	ctx->Ans.reserved1 = 0;
#endif	

	//oilyang@20230518 用来标注支持搜狗输入法新旧模式
	ctx->Ans.reserved2 = 0;
	ResourceWatcherService_ClientBase* pClient = new ResourceWatcherService_ClientBase(m_pEntity);
	ErrorCodeEnum ec  = pClient->Connect();
	if (IS_SUCCEED(ec)) {
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("to Connect ResourceWatcher...");
		ResourceWatcherService_GetThirdPartyInstallState_Req req = {};
		ResourceWatcherService_GetThirdPartyInstallState_Ans ans = {};
		req.mode = 1;
		ec = (*pClient)(EntityResource::getLink().upgradeLink())->GetThirdPartyInstallState(req, ans, 15000);
		if (IS_SUCCEED(ec)) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Get Sogou version: %s, %d", ans.version.GetData(), ans.reserverd3);
			DWORD dwUserCode(HealthManager_UserErrorCode_SogouInput_UsingSDK);
			if (ans.reserverd3 == 1) {
				dwUserCode = HealthManager_UserErrorCode_SogouInput_UsingSys;
				ctx->Ans.reserved2 = 1;
			}
			LogWarn(Severity_Low, Error_Debug, dwUserCode,
				CSimpleStringA::Format("{\"version\": %s,\"installTime\": %s}", ans.version.GetData(), ans.reserverd1.GetData()));
		} else {
			LogWarn(Severity_Low, ec, HealthManager_UserErrorCode_SogouInput_UsingSDK,
				CSimpleStringA::Format("ResourceWatcher::GetThirdPartyInstallState invoked failed: %s", SpStrError(ec)));
		}
		pClient->GetFunction()->CloseSession();
	} else {
		LogWarn(Severity_Low, ec, HealthManager_UserErrorCode_SogouInput_UsingSDK,
			CSimpleStringA::Format("Connet to ResourceWatcher failed: %s", SpStrError(ec)));
		pClient->SafeDelete();
	}

	ctx->Answer(Error_Succeed);
}