myvtm/Module/mod_watchdog/WatchDogFSM.cpp

#include "stdafx.h"
#include "SpBase.h"
#include "WatchDogFSM.h"
#include "GetDevInfoHelper.h"
const int MAX_INIT_TRIES = 3;

ErrorCodeEnum CWatchDogFSM::OnInit()
{
	LOG_FUNCTION();
	auto pEntity = GET_DEV_ENTITY_BASE_POINTER();
	pEntity->InitializeVendorLogSwitch();
	FulfillAdapterInfoFrom(pEntity->vendorLibInfo);
	ErrorCodeEnum err = Load();
	return err;
}

ErrorCodeEnum CWatchDogFSM::OnExit()
{
	LOG_FUNCTION();
	ErrorCodeEnum errCode = Error_Succeed;
	m_hDevHelper.TearDown();
	return errCode;
}

void CWatchDogFSM::s0_on_entry()
{
	LOG_FUNCTION();
	if (m_FirstStart) {
		m_FirstStart = FALSE;
		ToLogRootINIInfoOnce();
		ToLogWarnInfoAboutTerm();
	}
}

void CWatchDogFSM::s0_on_exit()
{
	LOG_FUNCTION();
}

unsigned int CWatchDogFSM::s0_on_event(FSMEvent* pEvt)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("s0 evt %d",pEvt->iEvt);
	int rt = 0;
	switch(pEvt->iEvt)
	{
	case USER_EVT_STARTWATCH:
		{
			StartWatchEvent* swe = dynamic_cast<StartWatchEvent*>(pEvt);
			StartWatchTask* task = new StartWatchTask(this);
			task->ctx = swe->ctx;
			GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
			pEvt->SetHandled();
			rt = 0;
		}
		break;
	case USER_EVT_QUIT:
		pEvt->SetHandled();
		rt = 0;
		break;
	default:
		break;
	}
	return rt;
}

void CWatchDogFSM::s1_on_entry()
{
	LOG_FUNCTION();
}

void CWatchDogFSM::s1_on_exit()
{
	LOG_FUNCTION();
}

unsigned int CWatchDogFSM::s1_on_event(FSMEvent* evt)
{
	LOG_FUNCTION();
	int rt = 0;
	switch(evt->iEvt)
	{
	case USER_EVT_STARTWATCH_FINISHED:
		{
			rt = evt->param1;
			evt->SetHandled();
		}
		break;
	case USER_EVT_QUIT:
		evt->SetHandled();
		rt = 0;
		break;
	default:
		break;
	}
	return rt;
}

void CWatchDogFSM::s2_on_entry()
{
	LOG_FUNCTION();
}
void CWatchDogFSM::s2_on_exit()
{

}

unsigned int CWatchDogFSM::s2_on_event(FSMEvent* evt)
{
	//LOG_FUNCTION();
	int rt = 0;
	switch(evt->iEvt)
	{
	case USER_EVT_REFRESH:
		{
			RefreshEvent* re = dynamic_cast<RefreshEvent*>(evt);
			RefreshTask* task = new RefreshTask(this);
			task->ctx = re->ctx;
			GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
			evt->SetHandled();
			rt = 0;
		}
		break;
	case USER_EVT_REFRESH_FINISHED:
		{
			if (evt->param1 != 0)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Refresh failed(%d).",evt->param1);
				rt = 1;
			}
			else
				rt = 0;
			evt->SetHandled();
		}		
		break;
	case USER_EVT_STOPWATCH:
		{
			StopWatchEvent* swe = dynamic_cast<StopWatchEvent*>(evt);
			StopWatchTask* task = new StopWatchTask(this);
			task->ctx = swe->ctx;
			GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
			evt->SetHandled();
			rt = 0;
		}
		break;
	case USER_EVT_QUIT:
		evt->SetHandled();
		break;
	default:
		break;
	}
	return rt;
}
void CWatchDogFSM::s3_on_entry()
{
	LOG_FUNCTION();
}
void CWatchDogFSM::s3_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CWatchDogFSM::s3_on_event(FSMEvent* pEvt)
{
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("s3 evt %d",pEvt->iEvt);
	int rt = 0;
	switch(pEvt->iEvt)
	{
	case USER_EVT_STOPWATCH_FINISHED:
		if (pEvt->param1 == 0)
			rt = 0;
		else
			rt = 1;
		pEvt->SetHandled();
		break;
	case USER_EVT_QUIT:
		pEvt->SetHandled();
		break;
	default:
		break;
	}
	return rt;
}
void CWatchDogFSM::s4_on_entry()
{
	LOG_FUNCTION();
}
void CWatchDogFSM::s4_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CWatchDogFSM::s4_on_event(FSMEvent* evt)
{
	LOG_FUNCTION();
	int rt = 0;
	switch(evt->iEvt)
	{
	case USER_EVT_QUIT:
		evt->SetHandled();
		break;
	default:
		break;
	}
	return rt;
}

ErrorCodeEnum CWatchDogFSM::Load()
{
	CSimpleStringA dllName;
    auto pEntity = GET_DEV_ENTITY_BASE_POINTER();
    auto result = pEntity->ExtractVendorLibFullPath(dllName);
	if (result != Error_Succeed) {
		return result;
	}

    HARDWARE_ENTITY_SET_VENDOR_NAME(m_entCode, pEntity->vendorLibInfo.strVendor);

	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("vendor library path: %s", (LPCTSTR)dllName);
	result = m_hDevHelper.LoadUp(dllName);
	if (result != Error_Succeed) {
		return result;
	}
	m_adapterInfo.adapterFileName = dllName;

	result = m_hDevHelper->DevOpen();
    if (result == Error_Succeed) {
		ZeroMemory(m_devCatInfo.szModel, sizeof(m_devCatInfo.szModel));
		ZeroMemory(m_devCatInfo.szType, sizeof(m_devCatInfo.szType));
		ZeroMemory(m_devCatInfo.szVendor, sizeof(m_devCatInfo.szVendor));
		result = m_hDevHelper->GetDevCategory(m_devCatInfo);
        if (result == Error_Succeed) {
            m_adapterInfo.FulfillCategoryInfo(m_devCatInfo);
        } else {
            SetErrPackage("OnInit::GetDevCategory", m_devSN, result, MEC_DEVAPI_WATCHDOG_GetDevCategory);
            AlarmDEC();
        }
    } else {
		SetErrPackage("OnInit::DevOpen", m_devSN, result, MEC_DEVAPI_WATCHDOG_DevOpen);
		AlarmDEC();
        return Error_DevConnFailed;
    }

	return Error_Succeed;
}
int CWatchDogFSM::StartWatch(SpReqAnsContext<WatchDogService_StartWatch_Req,WatchDogService_StartWatch_Ans>::Pointer ctx)
{
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER)("fsm starwatch %d,%d", ctx->Req.Delay, ctx->Req.Timeout);
	if (ctx->Req.Delay < 0 || ctx->Req.Timeout < 0) {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("error param");
		ctx->Answer(Error_Param);
		return 2;
	}
	ErrorCodeEnum eErrCode = m_hDevHelper->StartWatch(ctx->Req.Delay, ctx->Req.Timeout);
	if (eErrCode != Error_Succeed)
	{
		LOG_WATCHDOG_ERROR_MSG_MACRO(eErrCode, StartWatch);
        if (ctx != NULL)
            ctx->Answer(Error_Unexpect);
		return 1;
	}
	ctx->Answer(Error_Succeed);
	return 0;
}
int CWatchDogFSM::Refresh(SpReqAnsContext<WatchDogService_Refresh_Req,WatchDogService_Refresh_Ans>::Pointer ctx)
{
	ErrorCodeEnum eErrCode = m_hDevHelper->RefreshDog();
	if (eErrCode != Error_Succeed)
	{
		LOG_WATCHDOG_ERROR_MSG_MACRO(eErrCode, RefreshDog);
        if (ctx != NULL)
            ctx->Answer(Error_Unexpect);
		return 1;
	}
	ctx->Answer(Error_Succeed);
	return 0;
}
int CWatchDogFSM::StopWatch(SpReqAnsContext<WatchDogService_StopWatch_Req,WatchDogService_StopWatch_Ans>::Pointer ctx)
{
	ErrorCodeEnum eErrCode = m_hDevHelper->StopWatch();
	if (eErrCode != Error_Succeed)
	{
		LOG_WATCHDOG_ERROR_MSG_MACRO(eErrCode, StopWatch);
		if (ctx != NULL)
			ctx->Answer(Error_Unexpect);
		return 1;
	}
	if (ctx != NULL)
		ctx->Answer(Error_Succeed);
	return 0;
}