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 "HealthManager_msg_g.h"
#include "AccessAuthorization_client_g.h"
#include "Initializer_client_g.h"
#include "DeviceControl_client_g.h"
#include "PinPad_client_g.h"

using namespace AccessAuthorization;
using namespace Initializer;
using namespace DeviceControl;
using namespace PinPad;

#if defined(RVC_OS_WIN)
#include "CardSwiper_msg_g.h"
using namespace CardSwiper;
#endif //RVC_OS_WIN
enum HealthManger_UserErrorCode {
	HealthManager_UserErrorCode_Start = 0x50100200,
	HealthManager_UserErrorCode_InitForFWB_GetAuthAddr_Fail,//蓝牙多合一获取准入地址失败
	HealthManager_UserErrorCode_InitForFWB_Init_Suc,		//蓝牙多合一初始化成功
	HealthManager_UserErrorCode_InitForFWB_Init_Fail,		//蓝牙多合一初始化失败
	HealthManager_UserErrorCode_Enum_OSVersion,				//枚举os版本
	HealthManager_UserErrorCode_Enum_AsianInfo_Start,		//查询是否安装亚信
	HealthManager_UserErrorCode_Enum_AsianInfo_End,			//查询是否安装亚信
	HealthManager_UserErrorCode_Enter_SafeLoad_State,		//用于后台判定启动次数
	HealthManager_UserErrorCode_PinPad_Dev_SP_SM,			//密码键盘硬件支持国密
	HealthManager_UserErrorCode_PinPad_Dev_NOT_SP_SM,		//密码键盘硬件不支持国密
	HealthManager_UserErrorCode_PinPad_HaveLoad_SM,			//密码键盘已加载国密密钥
	HealthManager_UserErrorCode_PinPad_HaveNotLoad_SM,		//密码键盘未加载国密密钥
	HealthManager_UserErrorCode_Receive_Browser_Idle,		//健康收到浏览器Idle事件
	HealthManager_UserErrorCode_First_Info_AboutTerm,		//健康启动结束后第一次终端信息上送
	HealthManager_UserErrorCode_AutoDoInit_Suc,				//自动初始化成功
	HealthManager_UserErrorCode_AutoDoInit_Fail,			//自动初始化失败
	HealthManager_UserErrorCode_Need_Guardian,				//健康需要启动guardian
	HealthManager_UserErrorCode_Need_No_Guardian,			//健康不需要启动guardian	
	HealthManager_UserErrorCode_WaitForAccessGrayResult,	//健康等待准入灰度结果
	HealthManager_UserErrorCode_First_Info_AboutPC,			//健康启动结束后第一次上送计算机信息(主要是确定pad的归属厂商信息)
};
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,
};
enum LoadStage
{
	LOADSTAGE_UNKNOWN,
	LOADSTAGE_COREBOOT,
	LOADSTAGE_SAFELOAD,
	LOADSTAGE_OPERATING
};
enum EntityLoadFaultStage
{
	ENTITYLOAD_SAFELOADFAULT,
	ENTITYLOAD_OPERATINGFAULT,
};
enum EntityOption
{
	WATCHDOG,
	UPS,
	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,
};
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;
};

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,s5,USER_EVT_WAIT_DEAMON_FINISHED,1)
		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_bAccessAuth(false),m_bACFailed(false),m_pInitClient(NULL),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_bEverAuthSucWithDevice(false)
	, m_bIEBeforeHealth(false), m_hasCfgGpioInRootIni(false), m_csErrEntity(""), m_bInAccessAuthDoWork(false)
	, m_bEntityNewStart(true), m_autoDoInitCount(0), m_bDoingAutoInit(false), m_iDoNotUpdateWKDaily(0)
	, mCofigMode(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(bool bResult=true);
	bool GetAccessAuthFlag(){return m_bAccessAuth;}
	void SetAccessFailedFlag(bool bValue = true) { m_bACFailed = bValue; }
	void SetInitSucFlag() {m_bInitSuc = true; m_bInitFail = false;}
	void SetInitFailFlag() {m_bInitFail = true; m_bInitSuc = false;}
	int StartPinPadEntity();
	int GetFSMState(){return m_fsmState;}
	void ToReAccessAuth(bool bEver=false);
	void SetCustomerMngerState(int iValue){m_custMngerState = iValue;}
	int GetCustomerMngerState(){return m_custMngerState;}
	int USBControl();
	CSimpleStringA GetEntityCfgInfo(CSimpleStringA name,int &loadOpt);
	CSimpleStringA GetUrlValue(){ return m_strURLValue; }
	void SetMD5OK(const int value){ m_havReceiveMD5OK = value; SetEvent(m_hMD5OKEvt); }
	int QueryAccessAuthStatus()
	{
		if (m_bAccessAuth)
			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);
	void DeviceReConnect();
	bool IfIEBeforeHealth(){ return m_bIEBeforeHealth; }
	int QuitFrameworkAndSaveInfo(RebootTriggerEnum eTrigger, RebootWayEnum eWay = RebootWay_Unknown);
	void PostProcessAfterUpgrade();
	void ToCallAccessAuthDoWork();
	void ToLogWarnTermAboutInfo(BOOL bSuccessFlag = TRUE);
	void JudgeIfNeedInitFWB();
	void FWBDoInit();
	bool IsCutIEBrowser();
	void AutoDoInitForAll();
	void CheckIfNeedAutoInit();

	void WKUpdatePeriod();

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);

	int DoInitialization();
	void ToCheckUPS();
	void SaveOsVersion();
	CSimpleStringA GetOsVersion();
	
	int sumday(int year, int month, int day);//计算天数

	void UploadEntityStartComsumeTime();

	/*获取启动失败实体的最后的错误信息并抛送到错误页，注意仅核心实体启动失败才需要执行此函数*/
	void ShowEntityBootFailedAtFront(LPCTSTR lpcszEntityName, ErrorCodeEnum bootFailedResult, bool isBlock = true);

    bool IsCoolBootThisTime();

private:
	LoadStage m_eStage;
	CSimpleStringA m_SysState,m_strURL,m_strURLValue,m_checkCode,m_csErrEntity;
	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;
	InitializerService_ClientBase *m_pInitClient;
	bool m_bAccessAuth,m_bACFailed,m_bInitSuc,m_bInitFail,m_bIdleToMaintain,m_bHasAuthEver,m_bFirstAccessAuth,m_bEverAuthSucWithDevice
		,m_bIEBeforeHealth, m_hasCfgGpioInRootIni,m_bInAccessAuthDoWork,m_bEntityNewStart, m_bDoingAutoInit;
	DWORD m_AccessAuthTimeout,m_InitializationTimeout;
	DeviceControlService_ClientBase *m_pDevCtrlClient;
	HANDLE m_hMD5OKEvt;
	CSystemStaticInfo m_sysInfo;

	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 CoreBootTask : public ITaskSp
{
	CHealthManagerFSM* fsm;
	CoreBootTask(CHealthManagerFSM* f) : fsm(f) {}
	void Process()
	{
		LOG_FUNCTION();
		FSMEvent *e = new FSMEvent(USER_EVT_COREBOOT_FINISHED);
		e->param1 = fsm->CoreBootDoWork();
		fsm->PostEventFIFO(e);
	}
};
struct SafeLoadTask : public ITaskSp
{
	CHealthManagerFSM* fsm;
	SafeLoadTask(CHealthManagerFSM* f) : fsm(f) {}
	void Process()
	{
		LOG_FUNCTION();
		FSMEvent *e = new FSMEvent(USER_EVT_SAFELOAD_FINISHED);
		e->param1 = fsm->SafeLoadDoWork();
		fsm->PostEventFIFO(e);
	}
};
struct OpLoadTask : public ITaskSp
{
	CHealthManagerFSM* fsm;
	OpLoadTask(CHealthManagerFSM* f) : fsm(f) {}
	void Process()
	{
		LOG_FUNCTION();
		FSMEvent *e = new FSMEvent(USER_EVT_OPERATING_FINISHED);
		e->param1 = fsm->OpLoadDoWork();
		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();
	}
};
#endif // __HEALTHMANAGER_FSM_H