myvtm/Module/mod_healthmanager/HealthManagerFSM.h

#ifndef __HEALTHMANAGER_FSM_H
#define __HEALTHMANAGER_FSM_H
#pragma once

#include "stdafx.h"
#include "SpFSM.h"
#include <map>
#include <vector>
using namespace std;

#include "CommEntitySettings.hpp"
#include "HealthManager_msg_g.h"
#include "HealthManager_def_g.h"
#include "AccessAuthorization_client_g.h"
#include "DeviceControl_client_g.h"
#include "PinPad_client_g.h"
using namespace HealthManager;
using namespace AccessAuthorization;
using namespace DeviceControl;

#include "ResourceWatcher_client_g.h"
using namespace ResourceWatcher;
#include "json/json.h"

#if defined(RVC_OS_WIN)
#include <xstring>
#endif //RVC_OS_WIN

using namespace PinPad;
enum HealthManger_UserErrorCode {
	HealthManager_UserErrorCode_Start = 0x50100200,
	HealthManager_UserErrorCode_GetAuthAddr_Fail = 0x50100201,			//获取准入地址失败
	HealthManager_UserErrorCode_InitForFWB_Init_Suc = 0x50100202,		//蓝牙多合一初始化成功
	HealthManager_UserErrorCode_InitForFWB_Init_Fail = 0x50100203,		//蓝牙多合一初始化失败
	HealthManager_UserErrorCode_Enum_OSVersion = 0x50100204,				//枚举os版本
	HealthManager_UserErrorCode_Enum_AsianInfo_Start = 0x50100205,		//查询是否安装亚信
	HealthManager_UserErrorCode_Enum_AsianInfo_End = 0x50100206,			//查询是否安装亚信
	HealthManager_UserErrorCode_Enter_SafeLoad_State = 0x50100207,		//用于后台判定启动次数 0x50100207
	HealthManager_UserErrorCode_PinPad_Dev_SP_SM = 0x50100208,			//密码键盘硬件支持国密
	HealthManager_UserErrorCode_PinPad_Dev_NOT_SP_SM = 0x50100209,		//密码键盘硬件不支持国密
	HealthManager_UserErrorCode_PinPad_HaveLoad_SM = 0x5010020A,			//密码键盘已加载国密密钥
	HealthManager_UserErrorCode_PinPad_HaveNotLoad_SM = 0x5010020B,		//密码键盘未加载国密密钥
	HealthManager_UserErrorCode_Receive_Browser_Idle = 0x5010020C,		//健康收到浏览器Idle事件 0x5010020c
	HealthManager_UserErrorCode_First_Info_AboutTerm = 0x5010020D,		//健康启动结束后第一次终端信息上送 0x5010020d
	HealthManager_UserErrorCode_AutoDoInit_Suc = 0x5010020E,				//自动初始化成功
	HealthManager_UserErrorCode_AutoDoInit_Fail = 0x5010020F,			//自动初始化失败
	HealthManager_UserErrorCode_Need_Guardian = 0x50100210,				//健康需要启动guardian
	HealthManager_UserErrorCode_Need_No_Guardian = 0x50100211,			//健康不需要启动guardian	
	HealthManager_UserErrorCode_WaitForAccessGrayResult = 0x50100212,	//健康等待准入灰度结果
	HealthManager_UserErrorCode_First_Info_AboutPC = 0x50100213,			//健康启动结束后第一次上送计算机信息(主要是确定pad的归属厂商信息)
	HealthManager_UserErrorCode_Upload_PathInfo = 0x50100214,				//上送全量root中Path结点信息
	HealthManager_UserErrorCode_PrivilegeCMD = 0x50100215,				//上送终端收到的启动、重启事件（非关门页、用户桌面？需要调查后理清楚）
	HealthManager_UserErrorCode_SogouInput_UsingSys = 0x50100216,    // 使用普通调用的搜狗输入法
	HealthManager_UserErrorCode_SogouInput_UsingSDK = 0x50100217    // 使用SDK版本调用的搜狗输入法
};

enum EvtType
{
	USER_EVT_TEST = EVT_USER+1,
	USER_EVT_QUIT,
	USER_EVT_INIT,
	USER_EVT_WAIT_DEAMON_FINISHED,
	USER_EVT_COREBOOT_FINISHED,
	USER_EVT_SAFELOAD_FINISHED,
	USER_EVT_SAFELOAD_EXMINE_FINISHED,
	USER_EVT_OPERATING_FINISHED,
	USER_EVT_ACCESSAUTH_FINISHED,
	USER_EVT_MAITAIN,
	USER_EVT_MAITAIN_FINISHED,
	USER_EVT_ENTER_CUSTOMER_MANAGER,
	USER_EVT_SWITCH_BACK_TO_RVC,
	USER_EVT_VTMLOADER_FINISHED,
};
enum LoadStage
{
	LOADSTAGE_UNKNOWN,
	LOADSTAGE_COREBOOT,
	LOADSTAGE_SAFELOAD,
	LOADSTAGE_OPERATING
};
enum EntityLoadFaultStage
{
	ENTITYLOAD_SAFELOADFAULT,
	ENTITYLOAD_OPERATINGFAULT,
};
enum EntityOption
{
	HEARTBEAT,
	SELFCHECKER
};
enum LoadingOpt
{
	LOADOPT_IGNORE,
	LOADOPT_ASYNC_VERIFY,
	LOADOPT_SYNC_VERIFY
};
enum LoadingResult
{
	LOADING_SUCCEED,
	LOADING_INIT,
	LOADING_FAILED,
	LOADING_TIMEOUT,
};
enum CustomerManagerState
{
	CM_INIT,
	CM_ENTER,
	CM_NOT_ENTER,
};
enum HealthManagerFSMState
{
	HM_FSM_INIT,
	HM_FSM_STATE_COREBOOT,
	HM_FSM_STATE_SAFELOAD,
	HM_FSM_STATE_OP,
	HM_FSM_STATE_IDLE,
	HM_FSM_STATE_FAULT,
	HM_FSM_STATE_MAINTAINING,
	HM_FSM_STATE_PREPAREOFF,
	HM_FSM_STATE_TERMINATING,
	HM_FSM_STATE_EXITTING,
	HM_FSM_STATE_SLEEP,
	HM_FSM_STATE_CMS,
};

const int AccessAuth_servFail = -2;
const int AccessAuth_Init = -1;
const int AccessAuth_Fail = 0;
const int AccessAuth_Suc = 1;
struct callback_entry : public IReleasable
{
	virtual ~callback_entry() {}
	CSimpleStringA EntityName;
	union {
		void *pRawData;
		int state;
	};
	int op;
	ErrorCodeEnum ErrorResult;
};
struct EntityLoadInfo
{
	int initSn;
	int loadOpt;
	LoadingResult eResult;
};
struct EntityLoadFault
{
	CSimpleStringA name;
	int count;
};

typedef struct _dmi_header
{
	BYTE type;
	BYTE length;
	WORD handle;
}dmi_header;

typedef struct _RawSMBIOSData
{

	BYTE    Used20CallingMethod;
	BYTE    SMBIOSMajorVersion;
	BYTE    SMBIOSMinorVersion;
	BYTE    DmiRevision;
	DWORD   Length;
	BYTE    SMBIOSTableData[];
}RawSMBIOSData;
extern unsigned long long GetTickCountRVC();

class	CHealthManagerEntity;

class CHealthManagerFSM : public FSMImpl<CHealthManagerFSM>,public ICallbackListener
{
public:
	enum {s0,s1,s2,s3,s4,s5,s6,s7,s8,s9,s10,s11};
	BEGIN_FSM_STATE(CHealthManagerFSM)
		FSM_STATE_ENTRY(s0,"Init",s0_on_entry,s0_on_exit,s0_on_event)
		FSM_STATE_ENTRY(s1,"CoreBoot",s1_on_entry,s1_on_exit,s1_on_event)
		FSM_STATE_ENTRY(s2,"SafeLoad",s2_on_entry,s2_on_exit,s2_on_event)
		FSM_STATE_ENTRY(s3,"Loading",s3_on_entry,s3_on_exit,s3_on_event)
		FSM_STATE_ENTRY(s4,"Operating",s4_on_entry,s4_on_exit,s4_on_event)
		FSM_STATE_ENTRY(s5,"Fault",s5_on_entry,s5_on_exit,s5_on_event)
		FSM_STATE_ENTRY(s6,"Maintaining",s6_on_entry,s6_on_exit,s6_on_event)
		FSM_STATE_ENTRY(s7,"PrepareOff",s7_on_entry,s7_on_exit,s7_on_event)
		FSM_STATE_ENTRY(s8,"Terminating",s8_on_entry,s8_on_exit,s8_on_event)
		FSM_STATE_ENTRY(s9,"Exitting",s9_on_entry,s9_on_exit,s9_on_event)
		FSM_STATE_ENTRY(s10,"Sleep",s10_on_entry,s10_on_exit,s10_on_event)
		FSM_STATE_ENTRY(s11,"CustomerManager",s11_on_entry,s11_on_exit,s11_on_event)
	END_FSM_STATE()

	BEGIN_FSM_RULE(CHealthManagerFSM,s0)
		//FSM_RULE_ENTRY(s0,s1,USER_EVT_WAIT_DEAMON_FINISHED,0)
		FSM_RULE_ENTRY(s0,s4, USER_EVT_WAIT_DEAMON_FINISHED,0)
		FSM_RULE_ENTRY(s1,s2,USER_EVT_COREBOOT_FINISHED,0)
		FSM_RULE_ENTRY(s1,s2,USER_EVT_COREBOOT_FINISHED,1)
		FSM_RULE_ENTRY(s1,s5,USER_EVT_COREBOOT_FINISHED,2)
		FSM_RULE_ENTRY(s1,s11,USER_EVT_ENTER_CUSTOMER_MANAGER,0)
		FSM_RULE_ENTRY(s2,s3,USER_EVT_SAFELOAD_FINISHED,0)
		FSM_RULE_ENTRY(s2,s5,USER_EVT_SAFELOAD_FINISHED,2)
		FSM_RULE_ENTRY(s2,s11,USER_EVT_ENTER_CUSTOMER_MANAGER,0)
		//FSM_RULE_ENTRY(s2,s4,USER_EVT_ACCESSAUTH_FINISHED,0)
		//FSM_RULE_ENTRY(s2,s5,USER_EVT_ACCESSAUTH_FINISHED,1)
		FSM_RULE_ENTRY(s3,s4,USER_EVT_OPERATING_FINISHED,0)
		FSM_RULE_ENTRY(s3,s5,USER_EVT_OPERATING_FINISHED,2)
		FSM_RULE_ENTRY(s3,s11,USER_EVT_ENTER_CUSTOMER_MANAGER,0)
		FSM_RULE_ENTRY(s4,s5,USER_EVT_ACCESSAUTH_FINISHED,1)
		FSM_RULE_ENTRY(s4,s6,USER_EVT_MAITAIN,0)
		FSM_RULE_ENTRY(s4,s11,USER_EVT_ENTER_CUSTOMER_MANAGER,0)
		FSM_RULE_ENTRY(s5,s6,USER_EVT_MAITAIN,0)
		FSM_RULE_ENTRY(s5,s11,USER_EVT_ENTER_CUSTOMER_MANAGER,0)
		FSM_RULE_ENTRY(s5,s4, USER_EVT_ACCESSAUTH_FINISHED, 0)
		FSM_RULE_ENTRY(s7,s6,USER_EVT_MAITAIN,0)
		FSM_RULE_ENTRY(s7,s11,USER_EVT_ENTER_CUSTOMER_MANAGER,0)
		FSM_RULE_ENTRY(s8,s6,USER_EVT_MAITAIN,0)
		FSM_RULE_ENTRY(s8,s11,USER_EVT_ENTER_CUSTOMER_MANAGER,0)
		FSM_RULE_ENTRY(s9,s6,USER_EVT_MAITAIN,0)
		FSM_RULE_ENTRY(s9,s11,USER_EVT_ENTER_CUSTOMER_MANAGER,0)
		FSM_RULE_ENTRY(s10,s6,USER_EVT_MAITAIN,0)
		FSM_RULE_ENTRY(s10,s11,USER_EVT_ENTER_CUSTOMER_MANAGER,0)
		FSM_RULE_ENTRY(s6,s4,USER_EVT_MAITAIN_FINISHED,4)
		FSM_RULE_ENTRY(s6,s5,USER_EVT_MAITAIN_FINISHED,5)
		FSM_RULE_ENTRY(s6,s7,USER_EVT_MAITAIN_FINISHED,7)
		FSM_RULE_ENTRY(s6,s8,USER_EVT_MAITAIN_FINISHED,8)
		FSM_RULE_ENTRY(s6,s9,USER_EVT_MAITAIN_FINISHED,9)
		FSM_RULE_ENTRY(s6,s10,USER_EVT_MAITAIN_FINISHED,10)
		FSM_RULE_ENTRY(s11, s6, USER_EVT_MAITAIN, 0)
		FSM_RULE_ENTRY(s11,s2,USER_EVT_SWITCH_BACK_TO_RVC,2)
		FSM_RULE_ENTRY(s11,s3,USER_EVT_SWITCH_BACK_TO_RVC,3)
		FSM_RULE_ENTRY(s11,s4,USER_EVT_SWITCH_BACK_TO_RVC,4)
		FSM_RULE_ENTRY(s11,s5,USER_EVT_SWITCH_BACK_TO_RVC,5)
		FSM_RULE_ENTRY(s11,s6,USER_EVT_SWITCH_BACK_TO_RVC,6)
		FSM_RULE_ENTRY(s11,s7,USER_EVT_SWITCH_BACK_TO_RVC,7)
		FSM_RULE_ENTRY(s11,s8,USER_EVT_SWITCH_BACK_TO_RVC,8)
		FSM_RULE_ENTRY(s11,s9,USER_EVT_SWITCH_BACK_TO_RVC,9)
		FSM_RULE_ENTRY(s11,s10,USER_EVT_SWITCH_BACK_TO_RVC,10)
	END_FSM_RULE()

	CHealthManagerFSM():m_eStage(LOADSTAGE_COREBOOT),m_SysState("I"),m_pACClient(NULL)
	, m_iAccessAuth(AccessAuth_Init),m_bInitSuc(false),m_bInitFail(false)
	, m_bIdleToMaintain(false), m_custMngerState(0), m_pDevCtrlClient(NULL), m_bHasAuthEver(false)
	, m_checkCode(""), m_accessAuthCheckMD5(0), m_havReceiveMD5OK(0), m_bFirstAccessAuth(true)
	, m_bIEBeforeHealth(false), m_hasCfgGpioInRootIni(false), m_csErrEntity(""), m_bInAccessAuthDoWork(false)
	, m_bEntityNewStart(true), m_autoDoInitCount(0), m_bDoingAutoInit(false), m_iDoNotUpdateWKDaily(0)
	, m_wkUpdatePeriod(1), mCofigMode(false), m_bPinPadOpenSuc(false){}
	~CHealthManagerFSM(){}
	virtual ErrorCodeEnum OnInit();
	virtual ErrorCodeEnum OnExit();

	void s0_on_entry();
	void s0_on_exit();
	unsigned int s0_on_event(FSMEvent* pEvt);
	void s1_on_entry();
	void s1_on_exit();
	unsigned int s1_on_event(FSMEvent* pEvt);
	void s2_on_entry();
	void s2_on_exit();
	unsigned int s2_on_event(FSMEvent* pEvt);
	void s3_on_entry();
	void s3_on_exit();
	unsigned int s3_on_event(FSMEvent* pEvt);
	void s4_on_entry();
	void s4_on_exit();
	unsigned int s4_on_event(FSMEvent* pEvt);
	void s5_on_entry();
	void s5_on_exit();
	unsigned int s5_on_event(FSMEvent* pEvt);
	void s6_on_entry();
	void s6_on_exit();
	unsigned int s6_on_event(FSMEvent* pEvt);
	void s7_on_entry();
	void s7_on_exit();
	unsigned int s7_on_event(FSMEvent* pEvt);
	void s8_on_entry();
	void s8_on_exit();
	unsigned int s8_on_event(FSMEvent* pEvt);
	void s9_on_entry();
	void s9_on_exit();
	unsigned int s9_on_event(FSMEvent* pEvt);
	void s10_on_entry();
	void s10_on_exit();
	unsigned int s10_on_event(FSMEvent* pEvt);
	void s11_on_entry();
	void s11_on_exit();
	unsigned int s11_on_event(FSMEvent* pEvt);

	void SetConfigMode(bool inConfig = true) {
		mCofigMode = inConfig;
	}

	void WaitALittleIfNecessary();

	ErrorCodeEnum Initial();

	//该函数建议废弃
	int WaitDeamonFinish();
	int CoreBootDoWork();
	int SafeLoadDoWork();
	int OpLoadDoWork();
	int AccessAuthDoWork();
	int CheckLoadResult(LoadStage eStage);
	int CheckSafeLoadResult();
	int CheckOperatingResult();
	void SetAccessAuth(int bResult);
	bool GetAccessAuthFlag(){return m_iAccessAuth == AccessAuth_Suc;}
	void SetInitSucFlag() {m_bInitSuc = true; m_bInitFail = false;}
	void SetInitFailFlag() {m_bInitFail = true; m_bInitSuc = false;}
	int GetFSMState(){return m_fsmState;}
	void ToReAccessAuth(bool bEver=false);
	void SetCustomerMngerState(int iValue){m_custMngerState = iValue;}
	int GetCustomerMngerState(){return m_custMngerState;}
	CSimpleStringA GetEntityCfgInfo(CSimpleStringA name,int &loadOpt);
	void SetMD5OK(const int value){ m_havReceiveMD5OK = value; SetEvent(m_hMD5OKEvt); }
	int QueryAccessAuthStatus()
	{
		if (m_iAccessAuth == AccessAuth_Suc)
			return 0;
		else
		{
			if (m_bHasAuthEver)
				return 1;
			else
				return 2;
		}
	}
	bool QueryHaveAuthEver() { return m_bHasAuthEver; }
	ErrorCodeEnum QueryCheckCode(CSimpleStringA &csCkCode,bool bMaster = false);
	void QueryDeviceInfo(std::map<std::string, std::string> &info);
	bool IfIEBeforeHealth(){ return m_bIEBeforeHealth; }
	int QuitFrameworkAndSaveInfo(RebootTriggerEnum eTrigger, RebootWayEnum eWay = RebootWay_Unknown);
	void PostProcessAfterUpgrade();
	void ToCallAccessAuthDoWork();
	void ToLogWarnTermAboutInfo();
	void JudgeIfNeedInitFWB();
	void FWBDoInit();
	bool IfInUpgradeProcess();
	void AutoDoInitForAll();
	void CheckIfNeedAutoInit();
	void WaitToCallAccessAuthDoWork();

	CSimpleStringA GetPathInfo();

	void WKUpdatePeriod();

	CSimpleStringA GetAuthErrMsg();
	void QueryHardwareInfo(SpReqAnsContext<HealthManagerService_QueryHardwareInfo_Req, HealthManagerService_QueryHardwareInfo_Ans>::Pointer ctx);
	void SetPinPadOpenSuc() { m_bPinPadOpenSuc = true; }

private:
	
	virtual ErrorCodeEnum AsyncStartEntity(const char *entity_name, const char *cmdline, void *pData);
	virtual ErrorCodeEnum AsyncStopEntity(const char *entity_name, void *pData);
	virtual ErrorCodeEnum AsyncPauseEntity(const char *entity_name, void *pData);
	virtual ErrorCodeEnum AsyncContinueEntity(const char *entity_name, void *pData);
	virtual ErrorCodeEnum AsyncTerminateEntity(const char *entity_name, void *pData);
	virtual void OnAnswer(CSmartPointer<IAsynWaitSp> pAsynWaitSp);
	void SaveOsVersion();
	CSimpleStringA GetOsVersion();
	void QueryComputerInfo();
	int sumday(int year,int month,int day);//计算天数
	/*获取启动失败实体的最后的错误信息并抛送到错误页，注意仅核心实体启动失败才需要执行此函数*/
	void ShowEntityBootFailedAtFront(LPCTSTR lpcszEntityName, ErrorCodeEnum bootFailedResult, bool isBlock = true);

    bool IsCoolBootThisTime();

private:
	LoadStage m_eStage;
	CSimpleStringA m_SysState,m_checkCode,m_csErrEntity,m_NewStartPage;
	map<int,int> m_enOpt;//entity option
	vector<CSimpleStringA> m_vCoreBoot,m_vSafeLoad,m_vOperating,m_vAllCfgEntity;
	map<CSimpleStringA,EntityLoadInfo> m_coreBootOpt;
	map<CSimpleStringA,EntityLoadInfo> m_safeLoadOpt;
	map<CSimpleStringA,EntityLoadInfo> m_operatingOpt;
	map<CSimpleStringA,EntityLoadFault> m_safeLoadFault;
	map<CSimpleStringA,EntityLoadFault> m_operatingFault;
	int m_devCfgNum, m_AccessAuthTries, m_InitTries, m_fsmState, m_stateBeforeMaintain, m_custMngerState, m_preFsmState, m_accessAuthCheckMD5
		,m_havReceiveMD5OK,m_autoDoInitCount, m_sleepEnterOpMS/*启动第三阶段等待时间，单位毫秒*/, m_sleepColdBootMS/*冷启动等待时间，单位毫秒*/
		,m_iAccessAuth/*-1 未准入; 0 准入失败；1 准入成功*/, m_iDoNotUpdateWKDaily, m_wkUpdatePeriod;
	AccessAuthService_ClientBase *m_pACClient;
	bool m_bInitSuc, m_bInitFail, m_bIdleToMaintain, m_bHasAuthEver, m_bFirstAccessAuth
		, m_bIEBeforeHealth, m_hasCfgGpioInRootIni, m_bInAccessAuthDoWork, m_bEntityNewStart, m_bDoingAutoInit, m_bPinPadOpenSuc;
	DWORD m_AccessAuthTimeout,m_InitializationTimeout,m_elapseTimeFromOSStart;
	ULONGLONG m_ullElapseFromOSStart;
	DeviceControlService_ClientBase *m_pDevCtrlClient;
	HANDLE m_hMD5OKEvt;
	CSystemStaticInfo m_sysInfo;
	std::map<string, string> m_computerInfo;
	bool mCofigMode;
};

struct WaitDeamonFinishTask : public ITaskSp
{
	CHealthManagerFSM* fsm;
	WaitDeamonFinishTask(CHealthManagerFSM* f) : fsm(f) {}
	void Process()
	{
		LOG_FUNCTION();
		FSMEvent *e = new FSMEvent(USER_EVT_WAIT_DEAMON_FINISHED);
		e->param1 = fsm->WaitDeamonFinish();
		fsm->PostEventFIFO(e);
	}
};

struct AccessAuthTask : public ITaskSp
{
	CHealthManagerFSM* fsm;
	AccessAuthTask(CHealthManagerFSM* f) : fsm(f) {}
	void Process()
	{
		LOG_FUNCTION();
		FSMEvent *e = new FSMEvent(USER_EVT_ACCESSAUTH_FINISHED);
		e->param1 = fsm->AccessAuthDoWork();
		fsm->PostEventFIFO(e);
	}
};
struct LogTermInfoTask : public ITaskSp
{
	CHealthManagerFSM* fsm;
	LogTermInfoTask(CHealthManagerFSM* f) : fsm(f) {}
	void Process()
	{
		fsm->ToLogWarnTermAboutInfo();
	}
};
struct FWBDoInitTask : public ITaskSp
{
	CHealthManagerFSM* fsm;
	FWBDoInitTask(CHealthManagerFSM* f) : fsm(f) {}
	void Process()
	{
		fsm->FWBDoInit();
	}
};

struct AutoDoInitForAllTask : public ITaskSp
{
	CHealthManagerFSM* fsm;
	AutoDoInitForAllTask(CHealthManagerFSM* f) : fsm(f) {}
	void Process()
	{
		fsm->AutoDoInitForAll();
	}
};
struct WaitToCallAccessAuthTask : public ITaskSp
{
	CHealthManagerFSM* fsm;
	WaitToCallAccessAuthTask(CHealthManagerFSM* f) : fsm(f) {}
	void Process()
	{
		fsm->WaitToCallAccessAuthDoWork();
	}
};
struct WKUpdatePeriodTask : public ITaskSp
{
	CHealthManagerFSM* fsm;
	WKUpdatePeriodTask(CHealthManagerFSM* f) : fsm(f) {}
	void Process()
	{
		fsm->WKUpdatePeriod();
	}
};
struct QueryHardwareInfoTask : public ITaskSp
{
	CHealthManagerFSM* fsm;
	SpReqAnsContext<HealthManagerService_QueryHardwareInfo_Req, HealthManagerService_QueryHardwareInfo_Ans>::Pointer ctx;
	QueryHardwareInfoTask(CHealthManagerFSM* f) : fsm(f) {}
	void Process()
	{
		fsm->QueryHardwareInfo(ctx);
	}
};
#endif // __HEALTHMANAGER_FSM_H