myvtm/Module/mod_pinpad/PinPadFSM.cpp

#include "stdafx.h"
#include "PinPadFSM.h"
#include "PinPad_msg_g.h"
#include "GetDevInfoHelper.h"
#include "EventCode.h"
#include "ModuleMix.h"
#include "PinPad_UserErrorCode.h"
#include "CommDevEntityErrorCode.h"
#include <map>
#include <thread>
#include <chrono>
#include "publicFunExport.h"

#include <winpr/sysinfo.h>

using namespace std;

const int PINPAD_INIT_TRIES = 3;
const int PINPAD_ANY_INPUT_TIMER = 1;
const int PINPAD_ANY_INPUT_TIMEOUT = 100;
const int MAX_PINPAD_INPUT_TIMEOUT = 60000;
const int MAX_INPUT_TIMER_TIMEOUT = 600000;
//#pragma comment(lib,"../../dev/PinPad/PinPad.lib")
bool isnostr(const char *str)
{
	int len = strlen(str);
	if (len == 0)
		return true;
	for (int i = 0; i < len; ++i)
	{
		if (*(str+i) != ' ')
			return false;
	}
	return true;
}
ErrorCodeEnum CPinPadFSM::OnInit()
{
	LOG_FUNCTION();

	{
		auto devEntity = dynamic_cast<CDevAdptEntityBase*>(GetEntityBase());
		devEntity->InitializeVendorLogSwitch();
	}

	CSystemStaticInfo sysInfo;

	m_csMachineType = m_csSite = m_terminalNo = "";
	GetEntityBase()->GetFunction()->GetSystemStaticInfo(sysInfo);
	m_csMachineType = sysInfo.strMachineType;
	m_csSite = sysInfo.strSite;
	m_terminalNo = sysInfo.strTerminalID;
	Dbg("machineType:%s,site:%s,terminalNo:%s", 
		(const char*)m_csMachineType, (const char*)m_csSite, (const char*)m_terminalNo);
	if (_strnicmp((const char*)m_csMachineType, "RPM.Stand1S", strlen("RPM.Stand1S")) == 0)
		m_bPinPadNeedless = TRUE;
	if (_strnicmp((const char*)m_csMachineType, "RVC.IL", strlen("RVC.IL")) == 0)
		m_bRVCIL = true;

	std::thread tmp_thread(&CPinPadFSM::DoWork, this);
	tmp_thread.detach();

	return Error_Succeed;
}
ErrorCodeEnum CPinPadFSM::OnExit()
{
	LOG_FUNCTION();
	m_bEntityExit = true;
	//SetEvent(m_hInputEvt);
	m_hInputConVar.Broadcast();
	ErrorCodeEnum eErr = Error_Succeed;
	if (m_hDevHelper)
	{
		m_hDevHelper->StopInput();
		m_hDevHelper.TearDown();
	}
	return eErr;
}
void CPinPadFSM::s0_on_entry()
{
	LOG_FUNCTION();
	FSMEvent *e = new FSMEvent(USER_EVT_INIT);
	PostEventFIFO(e);
}
void CPinPadFSM::s0_on_exit()
{
}
unsigned int CPinPadFSM::s0_on_event(FSMEvent* evt)
{
	LOG_FUNCTION();
	if (evt->iEvt == USER_EVT_INIT) {
		//SetEvent(m_hInputEvt);
		m_hInputConVar.Broadcast();
		evt->SetHandled();
		return 0;
	}else if (evt->iEvt == USER_EVT_QUIT) {
		evt->SetHandled();
		return 0;
	}
	return 0;
}
void CPinPadFSM::s1_on_entry()
{
	LOG_FUNCTION();
}
void CPinPadFSM::s1_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CPinPadFSM::s1_on_event(FSMEvent* evt)
{
	LOG_FUNCTION();
	Dbg("s1 event %d",evt->iEvt);
	int ret = 0;
	if (evt->iEvt == USER_EVT_INITFINISHED) {
		evt->SetHandled();
		int err = evt->param1;
		if (err == 0)
			ret = 0;
		else
			ret = 1;
		//SetEvent(m_hInitEvt);
		return ret;
	}else if (evt->iEvt == USER_EVT_QUIT) {
		evt->SetHandled();
		return 0;
	}
	return 0;
}
//Idle(anyinput)
void CPinPadFSM::s2_on_entry()
{
	LOG_FUNCTION();
	m_eDevState = DEVICE_STATUS_NORMAL;
	GetEntityBase()->GetFunction()->SetUserDefineState(USER_PINPAD_IDLE);
	m_testResult = Error_Succeed;

	//oilyang@20200119 去掉任意情况下可输入

	//if (!m_bInMainPage && !m_bRVCIL)
	//{
	//	ErrorCodeEnum eErrCode = CancelTimer(PINPAD_ANY_INPUT_TIMER);
	//	//Dbg("s2 entry cacel timer %d",eErrCode);
	//	eErrCode = ScheduleTimer(PINPAD_ANY_INPUT_TIMER, PINPAD_ANY_INPUT_TIMEOUT);
	//}

	if (m_FirstStart) {
		m_FirstStart = FALSE;
		ToLogWarnInfoAboutTerm(this, m_adapterInfo);
	}
}
void CPinPadFSM::s2_on_exit()
{
	LOG_FUNCTION();
	ErrorCodeEnum eErrCode = CancelTimer(PINPAD_ANY_INPUT_TIMER);
	Dbg("s2 cancel timer %d.",eErrCode);
}
unsigned int CPinPadFSM::s2_on_event(FSMEvent* pEvt)
{
	//LOG_FUNCTION();
	if (pEvt->iEvt != 1) 
		Dbg("s2 %d,%d",pEvt->iEvt,pEvt->param1);
	switch(pEvt->iEvt)
	{
	case USER_EVT_GETINPUT:
		{
		//SetEvent(m_hInputEvt);
		m_hInputConVar.Broadcast();
		pEvt->SetHandled();
		return 0;
		}
	case EVT_TIMER:
		if (pEvt->param1 == PINPAD_ANY_INPUT_TIMER)
		{
			if (m_bLoadKey || m_bEncrypt)
			{
				Dbg("Load,Encrypt:%d,%d",m_bLoadKey,m_bEncrypt);
				break;
			}
			void *pTmp = NULL;
			OpenInputText(pTmp);
			pEvt->SetHandled();
			return 0;
		}
		break;
	case USER_EVT_LOADKEY:
		{
			Dbg("USER_EVT_LOADKEY");
			pEvt->SetHandled();
			m_bLoadKey = true;
			LoadKeyTask* task = new LoadKeyTask(this);
			LoadKeyEvent* lke = dynamic_cast<LoadKeyEvent*>(pEvt);
			task->ctx = lke->ctx;
			GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
			return 2;
		}
	case USER_EVT_ENCRYPT:
		{
			Dbg("USER_EVT_ENCRYPT");
			pEvt->SetHandled();
			m_bEncrypt = true;
			EncryptTask* task = new EncryptTask(this);
			EncryptEvent* ee = dynamic_cast<EncryptEvent*>(pEvt);
			task->ctx = ee->ctx;
			GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
			return 2;
		}
	case USER_EVT_GETINPUT_SM:
		{
			//SetEvent(m_hInputEvt);
			m_hInputConVar.Broadcast();
			pEvt->SetHandled();
			return 0;
		}
	case USER_EVT_LOADKEY_SM:
		{
			Dbg("USER_EVT_LOADKEY(SM)");
			pEvt->SetHandled();
			m_bLoadKey = true;
			LoadKeySMTask* task = new LoadKeySMTask(this);
			LoadKeySMEvent* lke = dynamic_cast<LoadKeySMEvent*>(pEvt);
			task->ctx = lke->ctx;
			GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
			return 2;
		}
	case USER_EVT_ENCRYPT_SM:
		{
			Dbg("USER_EVT_ENCRYPT(SM)");
			pEvt->SetHandled();
			m_bEncrypt = true;
			EncryptSMTask* task = new EncryptSMTask(this);
			EncryptSMEvent* ee = dynamic_cast<EncryptSMEvent*>(pEvt);
			task->ctx = ee->ctx;
			GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
			return 2;
		}
	case USER_EVT_GET_CHECKCODE:
	{
		pEvt->SetHandled();
		GetCheckCodeTask* task = new GetCheckCodeTask(this);
		GetCheckCodeEvent* gcce = dynamic_cast<GetCheckCodeEvent*>(pEvt);
		task->ctx = gcce->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
		return 0;
	}
	case USER_EVT_QUIT:
		pEvt->SetHandled();
		break;
	default:
		break;
	}
	return 1;
}
//Input
void CPinPadFSM::s3_on_entry()
{
	LOG_FUNCTION();
	GetEntityBase()->GetFunction()->SetUserDefineState(USER_PINPAD_PININPUT);
	ErrorCodeEnum eErrCode = CancelTimer(PINPAD_ANY_INPUT_TIMER);
	Dbg("s3 cancel timer %d.",eErrCode);
}
void CPinPadFSM::s3_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CPinPadFSM::s3_on_event(FSMEvent* evt)
{
	LOG_FUNCTION();
	Dbg("s3 event %d",evt->iEvt);
	switch(evt->iEvt)
	{
	case USER_EVT_GETINPUTFINISHED:
		evt->SetHandled();
		break;
	case USER_EVT_INPUTCANCEL:
		evt->SetHandled();
		m_bFrontCancel = true;
		break;
	case USER_EVT_INPUTWAITINGMORE:
		evt->SetHandled();
		m_bWaitingMore = true;
		break;
	case USER_EVT_EXIT:
		SetExitFlag();
		break;
	case USER_EVT_QUIT:
		evt->SetHandled();
		break;
	default:
		break;
	}
	return 0;
}
//AccessAuth
void CPinPadFSM::s4_on_entry()
{
	LOG_FUNCTION();
	GetEntityBase()->GetFunction()->SetUserDefineState(USER_PINPAD_PARAM_ENCRYPTE);
	ErrorCodeEnum eErrCode = CancelTimer(PINPAD_ANY_INPUT_TIMER);
	Dbg("s4 cancel timer %d.",eErrCode);

}
void CPinPadFSM::s4_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CPinPadFSM::s4_on_event(FSMEvent* pEvt)
{
	switch(pEvt->iEvt)
	{
	case USER_EVT_LOADKEYFINISHED:
		pEvt->SetHandled();
		break;
	case USER_EVT_ENCRYPTFINISHED:
		pEvt->SetHandled();
		break;
	case USER_EVT_LOADKEY_SM_FINISHED:
		pEvt->SetHandled();
		break;
	case USER_EVT_ENCRYPT_SM_FINISHED:
		pEvt->SetHandled();
		break;
	case USER_EVT_GET_CHECKCODE:
	{
		pEvt->SetHandled();
		GetCheckCodeTask* task = new GetCheckCodeTask(this);
		GetCheckCodeEvent* gcce = dynamic_cast<GetCheckCodeEvent*>(pEvt);
		task->ctx = gcce->ctx;
		GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
		return 0;
	}
	default:
		break;
	}
	return 0;
}
void CPinPadFSM::s5_on_entry()
{
	LOG_FUNCTION();
	if (m_bDevInit)
		m_eDevState = DEVICE_STATUS_FAULT;
	GetEntityBase()->GetFunction()->SetUserDefineState(USER_PINPAD_FAILED);
	m_testResult = Error_InvalidState;
	ErrorCodeEnum eErrCode = CancelTimer(PINPAD_ANY_INPUT_TIMER);
	Dbg("s5 cancel timer %d.",eErrCode);
}
void CPinPadFSM::s5_on_exit()
{
	LOG_FUNCTION();
}
unsigned int CPinPadFSM::s5_on_event(FSMEvent* pEvt)
{
	Dbg("s5 evt %d",pEvt->iEvt);
	switch (pEvt->iEvt)
	{
	case USER_EVT_GETINPUT:
		{
			pEvt->SetHandled();
			GetInputEvent *pGie = new GetInputEvent();
			pGie = dynamic_cast<GetInputEvent*>(pEvt);
			pGie->ctx->Answer(Error_InvalidState);
		}
		break;
	case USER_EVT_LOADKEY:
		{
			pEvt->SetHandled();
			LoadKeyEvent *pLke = new LoadKeyEvent();
			pLke = dynamic_cast<LoadKeyEvent*>(pEvt);
			pLke->ctx->Answer(Error_InvalidState);
		}
		break;
	default:
		break;
	}
	return 0;
}
int CPinPadFSM::Initial()
{
	LOG_FUNCTION();
	if (m_bRVCIL)
	{
		Dbg("is RVC.IL.");
		return 0;
	}
#ifdef _WIN32
	DWORD dwCurrThId = GetCurrentThreadId();
	Dbg("Initial thread id:%d", dwCurrThId);
#endif //_WIN32
	ErrorCodeEnum eErrDev;

	CSmartPointer<IEntityFunction> spEntityFunction = GetEntityBase()->GetFunction();
	CSmartPointer<IConfigInfo> spConfig;
	eErrDev = spEntityFunction->OpenConfig(Config_Root, spConfig);
	if (eErrDev != Error_Succeed) {
		Dbg("open cfg file failed!");
		LogWarn(Severity_Middle, eErrDev, PinPad_UserErrorCode_Open_Root_File_Failed, "Initial:OpenConfig");
		return eErrDev;
	}


	CSimpleStringA dllName,tmpVendor(""), tmpDevSN(""), tmpDLLVersion(""), csDepPath(""), csBackslash(SPLIT_SLASH_STR);
	GetEntityBase()->GetFunction()->GetSysVar("FWBVendor", tmpVendor);
	GetEntityBase()->GetFunction()->GetSysVar("FWBDevSN", tmpDevSN);
	GetEntityBase()->GetFunction()->GetSysVar("FWBVersion", tmpDLLVersion);
	if (tmpDLLVersion.GetLength() < 2)//如果忘记配置，则直接使用默认值8.1
		tmpDLLVersion = "8.1";
	if (tmpDevSN.GetLength() > 12 && tmpDevSN.IndexOf("FWB") > 2)
	{
		Dbg("This is fwb device.");
		GetEntityBase()->GetFunction()->GetPath("Dep", csDepPath);
#ifdef _WIN32
		dllName = csDepPath + csBackslash + "PinPad." + tmpVendor + "." + tmpDLLVersion + ".dll";//oiltmp
#else
		dllName = csDepPath + csBackslash + "libPinPad." + tmpVendor + "." + tmpDLLVersion + ".so";
#endif //_WIN32
		Dbg("%s", (const char*)dllName);
		LogWarn(Severity_Low, Error_Unexpect, PinPad_UserErrorCode_RootInfo, dllName.GetData());
		HARDWARE_ENTITY_SET_VENDOR_NAME(m_entCode, tmpVendor);
	}
	else
	{
		Dbg("This is normal AllInOne device.");
		auto pEntity = GET_DEV_ENTITY_BASE_POINTER();
		pEntity->ExtractVendorLibFullPath(dllName);

		//eErrDev = SpGetDevAdaptorPath(m_pEntity, GetEntityBase()->GetEntityName(), dllName);
		//if (eErrDev != Error_Succeed)
		//{
		//	Dbg("SpGetDevAdaptorPath(%d) failed.", eErrDev);
		//	LogWarn(Severity_Middle, eErrDev, AlarmDECToBusiness(MEC_DLL_GET_PATH_FAILED), "Initial:SpGetDevAdaptorPath");
		//	return Error_DevLoadFileFailed;
		//}
		//Dbg("%s", (LPCTSTR)dllName);
		LogWarn(Severity_Low, Error_Unexpect, PinPad_UserErrorCode_RootInfo, dllName.GetData());

		CSimpleStringA strSection = CSimpleStringA("Device.") + GetEntityBase()->GetEntityName();
		CSimpleStringA str;
		spConfig->ReadConfigValue(strSection, "Vendor", str);
		HARDWARE_ENTITY_SET_VENDOR_NAME(m_entCode, str);
	}
	m_adapterInfo.adapterFileName = dllName;

	int baudRate, port;

	spConfig->ReadConfigValueInt("Device.PinPad", "Baudrate", baudRate);
	spConfig->ReadConfigValueInt("Device.PinPad", "Port", port);
	spConfig->ReadConfigValue("Terminal", "TerminalNo", m_deviceNo);
	spConfig->ReadConfigValue("Device.PinPad", "Checkdata", m_devCheckData);
	Dbg("to load vendor dll.");
	if (Error_Succeed != m_hDevHelper.LoadLibAddress(dllName)) {
		Dbg("load %s failed.", (const char*)dllName);
		if (!m_bPinPadNeedless) {
			if (tmpDevSN.GetLength() < 10 || tmpDevSN.IndexOf("FWB") < 1)
				GetEntityBase()->GetFunction()->ShowFatalError("密码键盘加载厂商适配器失败！请检查root.ini配置是否正确。");
			//LogWarn(Severity_Middle,Error_NotInit,LOG_ERR_PINPAD_FAILED,"PinPad init failed.");
			LogWarn(Severity_Middle, Error_NotInit, PinPad_UserErrorCode_Load_Dll_File_Failed, "PinPad init failed.");
		}
		return Error_DevLoadFileFailed;
	} else {
        Dbg("load vendor dll: %s suc.", dllName.GetData());
        //MAKEINTRESOURCE
	}



	int initTries = 0;
	ErrorCodeEnum hr;
	ErrorCodeEnum eErrCode;
	do
	{
		Dbg("dodo");
		if (!m_hDevHelper) {
			eErrCode = m_hDevHelper.CreateDevAdptObject();
			if(eErrCode != Error_Succeed) {
				Dbg("create pinpad module failed %s", SpStrError(eErrCode));
				LogWarn(Severity_Middle, eErrDev, PinPad_UserErrorCode_Create_Object_Failed, "Initial:CreateDevComponent");
				initTries++;
				continue;
			}
		}
		//PinPadInitParam initParam;


		Dbg("port: %d, baudRate:%d",port,baudRate);
		hr = m_hDevHelper->DevOpen(port,baudRate);

		if (hr == Error_Succeed)
		{
			initTries = 0;
			ErrorCodeEnum errCode1,errCode2,errCode3,errCode4;
			errCode1 = m_hDevHelper->SetParam(EPP_PT_SET_ENCRYPT_METHOD,EPP_ALGO_METHOD_3DES);
			errCode2 = m_hDevHelper->SetParam(EPP_PT_SET_MAC_ALGORITH,EPP_MAC_ALGO_ASNIX99);
			errCode3 = m_hDevHelper->SetParam(EPP_PT_SET_PIN_ALGORITH,EPP_PIN_ALGO_ISO9564_1_ANSI);
			errCode4 = m_hDevHelper->SetParam(EPP_PT_SET_ECB_CBC_MODE,EPP_ALGO_MODE_3DEC_CBC);
			if(errCode1 != Error_Succeed || errCode2 != Error_Succeed 
				|| errCode3 != Error_Succeed || errCode4 != Error_Succeed)
			{
				if (errCode1 != Error_Succeed)
				{
					SetErrPackage(m_errPkg, "Initial::SetParm(1)", m_devSN, errCode1, MEC_DEVAPI_EPP_SetParam);
					AlarmDEC(m_errPkg);
				}
				if (errCode2 != Error_Succeed)
				{
					SetErrPackage(m_errPkg, "Initial::SetParm(2)", m_devSN, errCode2, MEC_DEVAPI_EPP_SetParam);
					AlarmDEC(m_errPkg);
				}
				if (errCode3 != Error_Succeed)
				{
					SetErrPackage(m_errPkg, "Initial::SetParm(3)", m_devSN, errCode3, MEC_DEVAPI_EPP_SetParam);
					AlarmDEC(m_errPkg);
				}
				if (errCode4 != Error_Succeed)
				{
					SetErrPackage(m_errPkg, "Initial::SetParm(4)", m_devSN, errCode4, MEC_DEVAPI_EPP_SetParam);
					AlarmDEC(m_errPkg);
				}
				return 1;
			}
			Dbg("SetParam suc.");
			break;
		}
		else
		{
			initTries++;
			SetErrPackage(m_errPkg, "Initial::DevOpen", m_devSN, hr, MEC_DEVAPI_EPP_DevOpen);
			AlarmDEC(m_errPkg);
			Sleep(1200);
			continue;
		}
	}while(initTries<PINPAD_INIT_TRIES);
	
	if (initTries != 0)
	{
		//LOG_PINPAD_ERROR_MSG_MACRO(hr, DevOpen);
		Dbg("Open pinpad failed.%s",(const char*)tmpDevSN);
		if (tmpDevSN.GetLength() < 10 || tmpDevSN.IndexOf("FWB") < 1)
			GetEntityBase()->GetFunction()->ShowFatalError("密码键盘打开失败！请检查键盘是否连接，配置是否正确。");
		return 1;
	}
	m_bDevInit = true;
	LOG_TRACE("Open pinpad suc.");
	//oiltmp comment the following 20160406
	//update with the version 1.7.1
	m_encryptkey = m_hDevHelper->GetEncryptFunc();
	//m_encryptkey = 1;
	eErrDev = spEntityFunction->OpenConfig(Config_Run, spConfig);
	if (eErrDev != Error_Succeed)
	{
		Dbg("read run cfg failed(sm).");
		m_b3DESLoaded = false;
		m_bSMLoaded = false;
		LogWarn(Severity_Middle, eErrDev, PinPad_UserErrorCode_Open_RunCfgFile_Failed, "Initial:OpenConfig");
	}
	else
	{
		int tmpLoad = 0;
		eErrDev = spConfig->ReadConfigValueInt("Load", "3DES", tmpLoad);
		if (eErrDev == Error_Succeed)
			m_b3DESLoaded = tmpLoad;
		eErrDev = spConfig->ReadConfigValueInt("Load", "SM", tmpLoad);
		if (eErrDev == Error_Succeed)
			m_bSMLoaded = tmpLoad;
		//oilyang@20201026 from kmc micro service
		spConfig->ReadConfigValue("Load", "SN_3DES", m_keySN);
		spConfig->ReadConfigValue("Load", "SN_SM", m_keySNSM);
	}
	Dbg("encrypt key :%d,load key :%d,%d", m_encryptkey,m_b3DESLoaded,m_bSMLoaded);
	DevCategoryInfo devInfo;
	ZeroMemory(devInfo.szModel, MAX_DEV_MODEL_LEN);
	ZeroMemory(devInfo.szType, MAX_DEV_TYPE_LEN);
	ZeroMemory(devInfo.szVendor, MAX_DEV_VENDOR_LEN);
	eErrDev = m_hDevHelper->GetDevCategory(devInfo);
	if (eErrDev == Error_Succeed)
	{
		m_szModel = devInfo.szModel;
		m_szType = devInfo.szType;
		m_szVendor = devInfo.szVendor;
		Dbg("szModel:%s, szType:%s, szVendor:%s", devInfo.szModel, devInfo.szType, devInfo.szVendor);
		m_adapterInfo.devCatInfo = devInfo;
	}
	else
	{
		SetErrPackage(m_errPkg, "Initial::GetDevCategory", m_devSN, eErrDev, MEC_DEVAPI_EPP_GetDevCategory);
		AlarmDEC(m_errPkg);
	}
	return 0;
}

void CPinPadFSM::DoWork()
{
	LOG_FUNCTION();
	while(1)
	{
		//std::this_thread::sleep_for(std::chrono::milliseconds(60 * 1000));
		this->m_hInputConVar.Wait();
		//WaitForSingleObject(this->GetInputEvtHandle(),INFINITE);
		if (this->GetEntityExit())
			break;
		FSMEvent *evt;
		int ret;
		if (!this->GetDevInitFlag())
		{
			ret = this->Initial();
			evt = new FSMEvent(USER_EVT_INITFINISHED);
		}
		else
		{
			Dbg("getinput in thread start");
			SpReqAnsContext<PinPadService_GetInput_Req, PinPadService_GetInput_Ans>::Pointer ctx;
			SpReqAnsContext<PinPadService_GetInputSM_Req, PinPadService_GetInputSM_Ans>::Pointer ctxSM;
			bool smFlag = false;
			bool bRet = this->GetCtx(ctx,ctxSM,smFlag);
			Dbg("sm ctx or not[%d]",smFlag);
			if (!bRet)
			{
				Dbg("get ctx failed.doing nothing");
				continue;
			}
			ret = this->GetInput(ctx,ctxSM,smFlag);
			evt = new FSMEvent(USER_EVT_GETINPUTFINISHED);
			Dbg("getinput in thread end");
		}
		if (ret == 0)
			evt->param1 = 0;
		else
			evt->param1 = 1;
		this->PostEventFIFO(evt);
	}

	return;
}
static char hexCh2decCh(char c)
{
 if((c>='0')&&(c<='9'))
  return c-'0';
 else if((c>='A')&&(c<='F'))
  return c-'A'+10;
 else if((c>='a')&&(c<='f'))
  return c-'a'+10;
 else 
  return 0x10;
}
static int h2i(char *s)
{
	int ret = 0;
	while (*s) {
		int t = hexCh2decCh(*s);
		ret = ret * 16 + t;
		++s;
	}
	return ret;
}

void CPinPadFSM::push_char(char *buf, int *len, int c)
{
	Dbg("len:%d",*len);
	buf[*len] = c;
	*len = *len + 1;
	buf[*len] = 0;
	InputContent evt;
	evt.data = buf;
	SpSendBroadcast(GetEntityBase()->GetFunction(), SP_MSG_OF(InputContent), SP_MSG_SIG_OF(InputContent), evt);
}
void CPinPadFSM::PushInputChar(char *buf,int c)
{
	//Dbg("len:%d",*len);
	buf[0] = c;
	Dbg("anyinput[%d][%s]",c,buf);
	//*len = *len + 1;
	//buf[*len] = 0;
	InputContent evt;
	evt.data = buf;
	SpSendBroadcast(GetEntityBase()->GetFunction(), SP_MSG_OF(InputContent), SP_MSG_SIG_OF(InputContent), evt);
}
void CPinPadFSM::pop_char(char *buf, int *len, bool bClear)
{
	if (*len > 0) {
		if (bClear){
			memset(buf,0,*len);
			*len = 0;
		}else {
			*len -= 1;
			buf[*len] = 0;
		}
		InputContent evt;
		evt.data = buf;
		SpSendBroadcast(GetEntityBase()->GetFunction(), SP_MSG_OF(InputContent), SP_MSG_SIG_OF(InputContent), evt);
	}
}

void CPinPadFSM::clear_char(char *buf, int *len)
{
	if (*len > 0) {
		*len = 0;
		buf[*len] = 0;
		InputContent evt;
		evt.data = buf;
		SpSendBroadcast(GetEntityBase()->GetFunction(), SP_MSG_OF(InputContent), SP_MSG_SIG_OF(InputContent), evt);
	}
}
bool CPinPadFSM::Get12Account(char *szAcc)
{
	memset(m_szAccount,0,sizeof(m_szAccount));
	const int accLen = strlen(szAcc);
	if (accLen == 0) {
		return false;
	}

	if (accLen > 12)
		memcpy(m_szAccount + 4, szAcc + (accLen - 12 -1), 12);
	else if (accLen == 12)
	{
		if (strncmp(szAcc, "0755", 4) == 0)
			memcpy(m_szAccount + 4, szAcc, 12);
		else
		{
			m_szAccount[4] = '5';
			memcpy(m_szAccount + 5, szAcc + 1, 11);
		}
	}
	else if (accLen == 9)
	{
		memcpy(m_szAccount + 4, szAcc, 3);
		memcpy(m_szAccount + 7, szAcc, 9);
	}
	else
		memcpy(m_szAccount + 4, szAcc, accLen);

	return true;
}
int StrBuf2HexBuf(char* strBuf,PBYTE* hexBuf)
{
	int len = strlen(strBuf);
	if (len == 0 || len%2 != 0)
		return 0;
	BYTE* buf = new BYTE[len/2];
	if (buf == NULL)
		return 0;
	int j = 0;
	for (int i = 0; i < len;)
	{
		int tmpVal;
		sscanf(strBuf+i,"%2x",&tmpVal);
		buf[j] = tmpVal;
		//buf[j] = char2int(strBuf[i])*16 + char2int(strBuf[i+1]);
		i += 2;
		j++;
	}
	//memcpy(buf,strBuf,len);
	*hexBuf = buf;
	return j;
}
int HexBuf2StrBuf(PBYTE hexBuf,char** strBuf,DWORD len)
{
	char* tmpStr = *strBuf;
	int count = 0;
	for (int i = 0; i < len; ++i)
	{
		sprintf(tmpStr+count,"%0.2x",hexBuf[i]);
		count += 2;
	}
	return 0;
}
ErrorCodeEnum CPinPadFSM::GetEncryptText(SpReqAnsContext<PinPadService_GetInput_Req, PinPadService_GetInput_Ans>::Pointer ctx,SpReqAnsContext<PinPadService_GetInputSM_Req, PinPadService_GetInputSM_Ans>::Pointer ctxSM,bool bSM)
{
	LOG_FUNCTION();
	ErrorCodeEnum errCode;
	CSmartPointer<IEntityFunction> spEntityFunction = GetEntityBase()->GetFunction();
	CSmartPointer<IConfigInfo> spConfig;
	errCode = spEntityFunction->OpenConfig(Config_Software, spConfig);
	if (errCode != Error_Succeed)
	{
		LOG_TRACE("open device cfg file failed.");
		LogWarn(Severity_Middle, errCode, PinPad_UserErrorCode_Get_SoftWare_Pointer_Failed, "GetEncryptText:OpenConfig");
		return Error_DevLoadFileFailed;
	}
	//bSM:ctx or sm ctx;
	//bSMFlag:to use 3des or use sm
	int len,timeout;
	bool confirm, bSMFlag = false;
	if (!bSM)
	{
		len = ctx->Req.length;
		timeout = ctx->Req.timeout;
		confirm = ctx->Req.confirm;
	}
	else
	{
		len = ctxSM->Req.length;
		timeout = ctxSM->Req.timeout;
		confirm = ctxSM->Req.confirm;
		if (ctxSM->Req.smflag == 1)
		{
			Dbg("has smflag true,to use sm.");
			bSMFlag = true;
		}
	}
	if (!bSMFlag)
	{
		LogWarn(Severity_Low, Error_Unexpect, PinPad_UserErrorCode_PinPad_Not_SM, "Encryption is not SM");
	}

	AccountInfo accInfo;
	memset(accInfo.account,0,MAX_ACCOUNT_LEN);
	CSimpleStringA errMsg("");
	if (!bSM)
	{
		if (Get12Account(const_cast<char*>(ctx->Req.account.GetData())))
			memcpy(accInfo.account,m_szAccount+4,12);
		else
		{
			errMsg = CSimpleStringA::Format("Get12Account err(%s)(bSM:%d).", (const char*)ctx->Req.account, bSM);
			LogError(Severity_High, Error_Unexpect, PinPad_UserErrorCode_PinPad_GetEncryptText_Get12Account_Error, errMsg.GetData());
			return Error_DevCommFailed;
		}
	}
	else
	{
		if (Get12Account(const_cast<char*>(ctxSM->Req.account.GetData()))) {
			memcpy(accInfo.account, m_szAccount + 4, 12);
		} else {
			errMsg = CSimpleStringA::Format("Get12Account err(%s)(bSM:%d).", (const char*)ctxSM->Req.account, bSM);
			LogError(Severity_High, Error_Unexpect, PinPad_UserErrorCode_PinPad_GetEncryptText_Get12Account_Error, errMsg.GetData());
			return Error_DevCommFailed;
		}
	}

	accInfo.dwAccLen = 12;
	Dbg("acc(%s)",accInfo.account);
	errCode = m_hDevHelper->SetAccNo(accInfo);
	if (errCode != Error_Succeed)
	{
		if (!bSM)
			Dbg("set accout(%s)(%s) failed(%d).",(const char*)ctx->Req.account,accInfo.account,errCode);
		else
			Dbg("[sm]set accout(%s)(%s) failed(%d).",(const char*)ctxSM->Req.account,accInfo.account,errCode);
		SetErrPackage(m_errPkg, "GetEncryptText::SetAccNo", m_devSN, errCode, MEC_DEVAPI_EPP_SetAccNo);
		AlarmDEC(m_errPkg, true);
		return Error_DevCommFailed;
	}	
	if (!bSMFlag)
		errCode = m_hDevHelper->ActiveWorkingKey(0, 0);
	else
		errCode = m_hDevHelper->ActiveWorkingKey(1, 0);
	if (errCode != Error_Succeed)
	{
		SetErrPackage(m_errPkg, "GetEncryptText::ActiveWorkingKey", m_devSN, errCode, MEC_DEVAPI_EPP_ActiveWorkingKey);
		AlarmDEC(m_errPkg, true);
		return Error_DevCommFailed;
	}	
	if (!bSMFlag)
	{
		//errCode = m_hDevHelper->SetParam(EPP_PT_SET_ENCRYPT_METHOD, EPP_ALGO_METHOD_3DES);
		errCode = m_hDevHelper->SetParam(EPP_PT_SET_PIN_ALGORITH, EPP_PIN_ALGO_ISO9564_1_ANSI);
	}
	else
	{
		//errCode = m_hDevHelper->SetParam(EPP_PT_SET_ENCRYPT_METHOD, EPP_ALGO_METHOD_SM4);
		errCode = m_hDevHelper->SetParam(EPP_PT_SET_PIN_ALGORITH, EPP_PIN_ALGO_SM4);
	}
	if (errCode != Error_Succeed)
	{
		SetErrPackage(m_errPkg, "GetEncryptText::SetParam", m_devSN, errCode, MEC_DEVAPI_EPP_SetParam);
		AlarmDEC(m_errPkg, true);
		return Error_DevCommFailed;
	}
	Dbg("to start pininput...");
	errCode = m_hDevHelper->StartPinInput(len);
	if (errCode != Error_Succeed)
	{
		SetErrPackage(m_errPkg, "GetEncryptText::StartPinInput", m_devSN, errCode, MEC_DEVAPI_EPP_StartPinInput);
		AlarmDEC(m_errPkg, true);
		return Error_DevCommFailed;
	}
	Dbg("start pininput end");
	char *buf = new char[len+1];
	memset(buf,0,len+1);
	int readed = 0;
	DWORD elapsed = 0;
	DWORD dwStart = GetTickCount();
	DWORD dwTimeStamp = dwStart;
	ErrorCodeEnum ec4KeyRead(Error_Succeed);
	bool bCancelInput = false;
	Dbg("reqqqq(pin) len: %d, timeout:%d, confirm or not: %d",len,timeout,confirm);
	Dbg("exit flag: %d",m_bExit);
	while (elapsed < MAX_PINPAD_INPUT_TIMEOUT) 
	{
		if (m_bExit) {
			Dbg("exit read routine.");
			break;
		}
			
		if (!confirm && readed >= len) {
			Dbg("has been fulfill, exit");
			break;
		}
			
		if (m_bWaitingMore)
		{
			dwStart = GetTickCount();
			elapsed = 0;
			m_bWaitingMore = false;
			continue;
		}
		if (m_bFrontCancel)
		{
			bCancelInput = true;
			Dbg("detect cancel cmd!");
			goto Err;
		}

		BYTE btCh;
		Sleep(100);
		errCode = m_hDevHelper->KeyRead(btCh);
		ec4KeyRead = errCode;
		if (errCode == Error_Succeed) {
			LogEvent(Severity_Middle,LOG_EVT_PINPAD_OP,"PinPad op.");
			if (btCh == 0x0d) {
				if (confirm)
				{
					if (!bSM)
						ctx->Ans.enter = true;
					else
						ctxSM->Ans.enter = true;
					break;
				}
				else
				{
					elapsed = GetTickCount() - dwStart;
					continue;
				}
			} else if (btCh == 0x08) { // back
				if (confirm)
				{
					elapsed = GetTickCount() - dwStart;
					continue;
				}
				Dbg("clear input");
				pop_char(buf, &readed,true);
			} else if (btCh == 0x1b) { // quit
				if (confirm)
				{
					if (!bSM)
						ctx->Ans.enter = true;
					else
						ctxSM->Ans.enter = true;
					goto Err;
				}
				else
				{
					bCancelInput = true;
					goto Err;
				}
			} else if (btCh == 0x3f){
				if (confirm) {
					elapsed = GetTickCount() - dwStart;
					continue;
				}
				push_char(buf, &readed, '*');
			}else{
				Dbg("else[%d]",btCh);
			}
		} else {
			DWORD dwTmp = GetTickCount();
			if ((dwTmp - dwTimeStamp) >= 1000) {
				Dbg("KeyRead returned error: %s", SpStrError(ec4KeyRead));
				dwTimeStamp = dwTmp;
			}
		}

		elapsed = GetTickCount() - dwStart;
	}

	buf[readed] = 0;

Err:

	if (m_bExit)
	{
		Dbg("exit");
        if (ec4KeyRead != Error_Succeed) {
            LOG_PINPAD_ERROR_MSG_MACRO(ec4KeyRead, KeyRead);
        }
		return Error_Unexpect;
	}
	m_bExit = false;
	if (buf != NULL)
		delete []buf;
	if (bCancelInput)
	{
		Dbg("input cancel(pin)");
		return Error_Cancel;
	}
	if (readed < len) {
		if (elapsed >= MAX_PINPAD_INPUT_TIMEOUT) {
            if (ec4KeyRead != Error_Succeed) {
                LOG_PINPAD_ERROR_MSG_MACRO(ec4KeyRead, KeyRead);
            }
			return Error_TimeOut;
		}
	}
	PinBlock pinBlk;
	Dbg("to getpinblk");
	Sleep(500);//nantian
	errCode = m_hDevHelper->GetPinBlock(pinBlk);
	Dbg("getpinblock(%d),size:%d",errCode,pinBlk.dwSize);
	if (errCode == Error_Succeed)
	{
		char *tmpPinData = new char[MAX_PIN_BLOCK_SIZE];
		if (tmpPinData == NULL)
			return Error_Resource;
		memset(tmpPinData,0,MAX_PIN_BLOCK_SIZE);
		memcpy(tmpPinData,pinBlk.data,pinBlk.dwSize);
		if (!bSM)
			ctx->Ans.data = tmpPinData;
		else
			ctxSM->Ans.data = tmpPinData;
		//Dbg("pinblk(%s)",tmpPinData);
		if (tmpPinData != NULL)
		{
			delete []tmpPinData;
			tmpPinData = NULL;
		}
		EnDecryptInfo srcInfo,dstInfo;
		memset(srcInfo.data,0,MAX_EN_DECRYPT_DATA_SIZE);
		//memcpy(srcInfo.data,"0000000000000000",16);
		//PBYTE tmpCheckData = new BYTE[MAX_EN_DECRYPT_DATA_SIZE];
		//if (tmpCheckData == NULL)
		//	return Error_Resource;
		//memset(tmpCheckData,0,MAX_EN_DECRYPT_DATA_SIZE);
		//int len = StrBuf2HexBuf(const_cast<char*>(m_devCheckData.GetData()),&tmpCheckData);
		//memcpy(srcInfo.data,tmpCheckData,len);
		//srcInfo.dwSize = len;
		Dbg("encryptdata[%s]",(LPCTSTR)m_devCheckData);
		memcpy(srcInfo.data,m_devCheckData,m_devCheckData.GetLength());
		srcInfo.dwSize = m_devCheckData.GetLength();
		memset(dstInfo.data,0,MAX_EN_DECRYPT_DATA_SIZE);
		//set param
		if (!bSMFlag)
			errCode = m_hDevHelper->SetParam(EPP_PT_SET_ENCRYPT_METHOD, EPP_ALGO_METHOD_3DES);
		else
			errCode = m_hDevHelper->SetParam(EPP_PT_SET_ENCRYPT_METHOD, EPP_ALGO_METHOD_SM4);
		if (errCode == Error_Succeed)
			errCode = m_hDevHelper->SetParam(EPP_PT_SET_ECB_CBC_MODE, EPP_ALGO_MODE_CBC);
		
		if (errCode != Error_Succeed)
		{
			SetErrPackage(m_errPkg, "GetEncryptText::SetParam", m_devSN, errCode, MEC_DEVAPI_EPP_SetParam);
			AlarmDEC(m_errPkg, true);
			return Error_Param;
		}
			errCode = m_hDevHelper->EncryptData(srcInfo,dstInfo);
		//if (tmpCheckData != NULL)
		//{
		//	delete []tmpCheckData;
		//	tmpCheckData = NULL;
		//}
		if (errCode != Error_Succeed)
		{
			SetErrPackage(m_errPkg, "GetEncryptText::EncryptData", m_devSN, errCode, MEC_DEVAPI_EPP_EncryptData);
			AlarmDEC(m_errPkg, true);
			return Error_DevCommFailed;
		}
		
		char *tmpCheckCode = new char[MAX_PIN_BLOCK_SIZE];
		if (tmpCheckCode == NULL)
			return Error_Resource;
		memset(tmpCheckCode,0,MAX_PIN_BLOCK_SIZE);
		//HexBuf2StrBuf(dstInfo.data,&tmpCheckCode,dstInfo.dwSize);
		memcpy(tmpCheckCode,dstInfo.data,dstInfo.dwSize);
		Dbg("ckckck[%s]",tmpCheckCode);
		if (!bSM)
		{
			if (strnicmp(tmpCheckCode, "8CA64DE9C1B123A7", strlen("8CA64DE9C1B123A7")) == 0)
			{
				SetErrPackage(m_errPkg, "GetEncryptText::EncryptData(!SM)", m_devSN, Error_Unexpect, PinPad_UserErrorCode_PINPAD_KEY_LOST);
				AlarmDEC(m_errPkg, true);
			}
			ctx->Ans.checkcode = tmpCheckCode;
			ctx->Ans.deviceno = m_deviceNo;
			ctx->Ans.keyseq = m_keySN;
		}
		else
		{
			if (strnicmp(tmpCheckCode, "9F1F7BFF6F5511384D9430531E538FD3", 
				strlen("9F1F7BFF6F5511384D9430531E538FD3")) == 0)
			{
				SetErrPackage(m_errPkg, "GetEncryptText::EncryptData(SM)", m_devSN, Error_Unexpect, PinPad_UserErrorCode_KEY_LOST_SM);
				AlarmDEC(m_errPkg, true);
			}
			ctxSM->Ans.checkcode = tmpCheckCode;
			ctxSM->Ans.deviceno = m_deviceNo;
			if (!bSMFlag)
				ctxSM->Ans.keyseq = m_keySN;
			else
			{
				ctxSM->Ans.keyseq = m_keySNSM;
			}
		}
	}
	else
	{
		SetErrPackage(m_errPkg, "GetEncryptText::GetPinBlock", m_devSN, errCode, MEC_DEVAPI_EPP_GetPinBlock);
		AlarmDEC(m_errPkg, true);
		return Error_DevCommFailed;
	}
	Dbg("pin input succeed");
	return Error_Succeed;
}

void CPinPadFSM::OpenInputText(void *pUserdata)
{
	//Dbg("any input in");
	//char *m_buf = new char[4];
	memset(m_buf, 0, 4);

	//m_bPinInput = false;//???
	ErrorCodeEnum err;
	//while (elapsed < MAX_PINPAD_INPUT_TIMEOUT) {
	//while(1){
	if (m_bPinInput)
		return;

	if (!m_bPlainOpen)
	{
		err = m_hDevHelper->StartPlainInput();
		if (err == Error_Succeed)
		{
			Dbg("start any input");
			GetEntityBase()->GetFunction()->SetUserDefineState(USER_PINPAD_IDLE);
			m_testResult = Error_Succeed;
			m_dwDevCommFailCount = 0;
			m_bPlainOpen = true;
		}
		else
		{
			GetEntityBase()->GetFunction()->SetUserDefineState(USER_PINPAD_FAILED_RECOVERING);
			m_dwDevCommFailCount++;
			//Dbg("start any input err:%d",err);
			if (m_dwDevCommFailCount > 10 * 3)
			{
				SetErrPackage(m_errPkg, "GetEncryptText::StartPlainInput(over 3 minutes)", m_devSN, err, MEC_DEVAPI_EPP_StartPlainInput);
				AlarmDEC(m_errPkg);
				m_testResult = Error_DevCommFailed;
			}
		}
	}
	//commented by oilyang 20160628
	//don't open/stop pinpad any input periodly any more

	//m_dwPinPadRunCount++;
	////30 minutes.about every 1.5s call this function once...so...
	//if (m_dwPinPadRunCount > 40*30)
	//{
	//	m_dwPinPadRunCount = 0;
	//	Dbg("stop input in period");
	//	m_hDevHelper->StopInput();
	//	m_bPlainOpen = false;
	//}


	BYTE btCh;
	INT64 i64Start = GetTickCount();
	err = m_hDevHelper->KeyRead(btCh);
	INT64 i64End = GetTickCount();
	if ((i64End - i64Start) > 3000)//more than 3 seconds
		Dbg("KeyRead cost more than %d seconds.", (i64End - i64Start)/1000);
	if (err == Error_Succeed) {
		LogEvent(Severity_Middle, LOG_EVT_PINPAD_OP, "PinPad op(Any).");
		PushInputChar(m_buf, btCh);
	}
	else {
		//Dbg("else[%s]", buf);
	}
	//}


	//delete [] buf;

	//Dbg("input succeed");
	//GetEntityBase()->GetFunction()->ResetTimer(PINPAD_ANY_INPUT_TIMER,PINPAD_ANY_INPUT_TIMEOUT);
	ScheduleTimer(PINPAD_ANY_INPUT_TIMER, PINPAD_ANY_INPUT_TIMEOUT);
	return;
}
ErrorCodeEnum CPinPadFSM::GetText(SpReqAnsContext<PinPadService_GetInput_Req, PinPadService_GetInput_Ans>::Pointer ctx,SpReqAnsContext<PinPadService_GetInputSM_Req, PinPadService_GetInputSM_Ans>::Pointer ctxSM,bool bSM)
{
	LOG_FUNCTION();
	int len,timeout;
	bool confirm;
	if (!bSM)
	{
		len = ctx->Req.length;
		timeout = ctx->Req.timeout;
		confirm = ctx->Req.confirm;
	}
	else
	{
		len = ctxSM->Req.length;
		timeout = ctxSM->Req.timeout;
		confirm = ctxSM->Req.confirm;
	}

	char *buf = new char[len+1];
	memset(buf,0,len+1);
	int readed = 0;
	DWORD elapsed = 0;
	DWORD dwStart = GetTickCount();
	DWORD dwEnd = GetTickCount();
	bool bCancelInput = false;
	//Dbg("reqqqq[%d][%d][%d]",len,timeout,confirm);
	//bool bPlainOpen = false;
	ErrorCodeEnum err;
	//the following several lines just for Nantian as they close pinpad while mag encrypted improve. oilyang 20150513
	err = m_hDevHelper->StopInput();
	m_bPlainOpen = false;
	Dbg("plain input for nt.%d",err);
	Sleep(100);
	while (elapsed < MAX_PINPAD_INPUT_TIMEOUT) {
	//while(1){
		if (m_bExit)
		{
			Dbg("Exit");
			bCancelInput = true;
			goto Err;
		}
		if (!confirm && readed >= len)
			break;
		if (m_bWaitingMore)
		{
			Dbg("WaitMore");
			dwStart = GetTickCount();
			elapsed = 0;
			m_bWaitingMore = false;
			continue;
		}
		if (m_bFrontCancel)
		{
			Dbg("Front Cancel");
			bCancelInput = true;
			goto Err;
		}
		if (!m_bPlainOpen)
		{
			Dbg("start plain input");
			err = m_hDevHelper->StartPlainInput();
			if (err == Error_Succeed)
				m_bPlainOpen = true;
			else
			{
				SetErrPackage(m_errPkg, "GetText::StartPlainInput", m_devSN, err, MEC_DEVAPI_EPP_StartPlainInput);
				AlarmDEC(m_errPkg);
			}
		}
		BYTE btCh;
		Sleep(100);//oiltest
		//Dbg("start plain KeyRead");
		err = m_hDevHelper->KeyRead(btCh);
		//Dbg("end plain KeyRead");
		if (err == Error_Succeed) {
			//DevErrorInfo devErrInfo;
			//m_hDevHelper->GetLastErr(devErrInfo);
			//Dbg("[%s]",devErrInfo.szErrMsg);
			LogEvent(Severity_Middle,LOG_EVT_PINPAD_OP,"PinPad op(T).");
			if (btCh == 0x0d) {
				if (confirm)
				{
					if (!bSM)
						ctx->Ans.enter = true;
					else
						ctxSM->Ans.enter = true;
					break;
				}
				else
				{
					dwEnd = GetTickCount();
					elapsed = dwEnd - dwStart;
					continue;
				}
			} else if (btCh == 0x08) { // back
				if (confirm)
				{
					dwEnd = GetTickCount();
					elapsed = dwEnd - dwStart;
					continue;
				}
				pop_char(buf, &readed,true);
			} else if (btCh == 0x1b) { // quit
				bCancelInput = true;
				if (confirm)
				{
					if (!bSM)
						ctx->Ans.enter = false;
					else
						ctxSM->Ans.enter = false;
					break;
				}
				//else
				{
					//bCancelInput = true;
					break;
				}
			} else {
				if (confirm)
				{
					dwEnd = GetTickCount();
					elapsed = dwEnd - dwStart;
					continue;
				}
				switch (btCh) {
				case 0x30:
				case 0x31:
				case 0x32:
				case 0x33:
				case 0x34:
				case 0x35:
				case 0x36:
				case 0x37:
				case 0x38:
				case 0x39:
				//case 0x2e:
				//case 0x20:
					push_char(buf, &readed, btCh);
					break;
				default:
					break;
				}
			}
			
		} else {
			//Dbg("else[%s]", buf);
		}
		dwEnd = GetTickCount();
		elapsed = dwEnd - dwStart;
	}

Err:
	buf[readed] = 0;
	if (!bSM)
	{
		ctx->Ans.data = buf;
		ctx->Ans.deviceno = "";
		ctx->Ans.checkcode = "";
		ctx->Ans.keyseq = "";
	}
	else
	{
		ctxSM->Ans.data = buf;
		ctxSM->Ans.deviceno = "";
		ctxSM->Ans.checkcode = "";
		ctxSM->Ans.keyseq = "";
	}


	delete [] buf;
	if (bCancelInput)
	{
		Dbg("input cancel");
		return Error_Cancel;
	}
	if (readed < len) {
		if (elapsed >= MAX_PINPAD_INPUT_TIMEOUT) {
			return Error_TimeOut;
		}
	}
	Dbg("input succeed");
	return Error_Succeed;
}
int CPinPadFSM::GetInput(SpReqAnsContext<PinPadService_GetInput_Req, PinPadService_GetInput_Ans>::Pointer ctx,SpReqAnsContext<PinPadService_GetInputSM_Req, PinPadService_GetInputSM_Ans>::Pointer ctxSM,bool bSM)
{
	//GetEntityBase()->GetFunction()->ResetTimer(PINPAD_ANY_INPUT_TIMER,MAX_INPUT_TIMER_TIMEOUT);
	DWORD dwCurrThId = GetCurrentThreadId();
	Dbg("GetInput thread id:%d",dwCurrThId);
	//ctx = m_ctx;
	m_bWaitingMore = false;
	m_bFrontCancel = false;
	m_bExit = false;
	LogEvent(Severity_Middle,LOG_EVT_PINPAD_GREEN_ON,"PinPad light on.");
	//LogEvent(Severity_Middle,LOG_EVT_PINPAD_GREEN_ON,"PinPad green light on.");
	if (!m_hDevHelper)
	{
		LOG_TRACE("PinPad is not available！");
		if (!bSM) {
			SetErrPackage(m_errPkg, "GetInput(!SM)", m_devSN, Error_Unexpect, PinPad_UserErrorCode_PinPad_Instance_Is_Null);
			m_ctx->Answer(Error_Unexpect, AlarmDEC(m_errPkg, true));
		}
		else {
			SetErrPackage(m_errPkg, "GetInput(SM)", m_devSN, Error_Unexpect, PinPad_UserErrorCode_PinPad_Instance_Is_Null);
			m_inputSMCtx->Answer(Error_Unexpect, AlarmDEC(m_errPkg, true));
		}
		LogEvent(Severity_Middle,LOG_EVT_PINPAD_GREEN_OFF,"PinPad light off.");
		//LogEvent(Severity_Middle,LOG_EVT_PINPAD_GREEN_OFF,"PinPad green light off.");
		m_bPinInput = false;
		return 1;
	}
	bool encrypt;
	if (!bSM)
	{
		encrypt = m_ctx->Req.encrypt;
	}
	else
	{
		encrypt = m_inputSMCtx->Req.encrypt;
	}
	ErrorCodeEnum err;
	if (!encrypt) {
		err = GetText(m_ctx,m_inputSMCtx,bSM);
	} else {
		err = GetEncryptText(m_ctx,m_inputSMCtx,bSM);
	}
	//if (ctx->Req.encrypt)
	{
		//oilyang@20200428 call StopInput
		//if (m_bPlainOpen)
		{
			ErrorCodeEnum errClosePinPad = m_hDevHelper->StopInput();
			Dbg("close pinpad(%d).",errClosePinPad);
			Sleep(100);
			m_bPlainOpen = false;
		}
		if(err == Error_Succeed)
		{
			if (!bSM)
				m_ctx->Answer();
			else
				m_inputSMCtx->Answer();
		}
		else
		{
			if (!bSM)
			{
				//返回为以下的基本属于正常操作，而不是异常，无需业务故障抛出，下同
				//Error_Cancel：取消;Error_TimeOut:超时；Error_Unexpect：收到退出Exit事件
				if (err == Error_Cancel || err == Error_TimeOut || err == Error_Unexpect)
					m_ctx->Answer(err);
				else
					m_ctx->Answer(err, PinPad_UserErrorCode_GetEncryptedText_Failed);
			}
			else
			{
				if (err == Error_Cancel || err == Error_TimeOut || err == Error_Unexpect)
					m_inputSMCtx->Answer(err);
				else
					m_inputSMCtx->Answer(err, PinPad_UserErrorCode_GetEncryptedText_Failed);
			}
		}
	}
	m_bPinInput = false;
	LogEvent(Severity_Middle,LOG_EVT_PINPAD_GREEN_OFF,"PinPad light off.");
	//GetEntityBase()->GetFunction()->ResetTimer(PINPAD_ANY_INPUT_TIMER,1);
	//LogEvent(Severity_Middle,LOG_EVT_PINPAD_GREEN_OFF,"PinPad green light off.");

	return 0;
}
int CPinPadFSM::LoadKey(SpReqAnsContext<PinPadService_LoadKeys_Req, PinPadService_LoadKeys_Ans>::Pointer ctx)
{
	ErrorCodeEnum eErr;
	CSmartPointer<IEntityFunction> spEntityFunction = GetEntityBase()->GetFunction();
	CSmartPointer<IConfigInfo> spConfig;
	eErr = spEntityFunction->OpenConfig(Config_Run, spConfig);
	if (eErr != Error_Succeed)
	{
		Dbg("read run cfg failed.");
		spConfig = NULL;
	}
	if (m_bPlainOpen)
		m_hDevHelper->StopInput();
	//initialization need load master key
	if (ctx->Req.initializeflag)
	{
		MasterKeyParam mkParam;
		mkParam.dwSN = 0;
		mkParam.smFlag = 0;
		memset(mkParam.key,0,MAX_MASTER_KEY_SIZE);
		memcpy(mkParam.key,ctx->Req.masterkey,strlen(ctx->Req.masterkey));
		//Dbg("%s,%d",mkParam.key,mkParam.dwSN);
		eErr = m_hDevHelper->LoadMasterKey(mkParam);
		if (eErr != Error_Succeed)
		{
			SetErrPackage(m_errPkg, "LoadKey::LoadMasterKey", m_devSN, eErr, MEC_DEVAPI_EPP_LoadMasterKey);
			AlarmDEC(m_errPkg);
			ctx->Ans.result = 0;
			ctx->Answer(Error_Unexpect);
			m_bLoadKey = false;
			return 0;
		}
		Dbg("Load master key suc.");
		//oilyang@20170424 if load 3des master key succeed,clear load key status both of 3des and sm
		spConfig->WriteConfigValueInt("Load", "3DES", 0);
		spConfig->WriteConfigValueInt("Load", "SM", 0);
	}
	WorkKeyParam wkParam1,wkParam2;
	memset(wkParam1.key,0,MAX_WORKING_KEY_SIZE);
	memset(wkParam2.key,0,MAX_WORKING_KEY_SIZE);
	wkParam1.dwMasterSN = wkParam2.dwMasterSN = 0;
	wkParam1.dwWorkingSN = 0;
	wkParam2.dwWorkingSN = 1;
	memcpy(wkParam1.key,ctx->Req.workingkey1,strlen(ctx->Req.workingkey1));
	memcpy(wkParam2.key,ctx->Req.workingkey2,strlen(ctx->Req.workingkey2));
	wkParam1.smFlag = 0;
	eErr = m_hDevHelper->LoadWorkingKey(wkParam1);
	if (eErr != Error_Succeed)
	{
		SetErrPackage(m_errPkg, "LoadKey::LoadWorkingKey(wkParam1)", m_devSN, eErr, MEC_DEVAPI_EPP_LoadWorkingKey);
		AlarmDEC(m_errPkg);
		ctx->Ans.result = 1;
		ctx->Answer(Error_Unexpect);
		m_bLoadKey = false;
		return 0;
	}
	Dbg("Load working key1 suc.");
	wkParam2.smFlag = 0;
	eErr = m_hDevHelper->LoadWorkingKey(wkParam2);
	if (eErr != Error_Succeed)
	{
		SetErrPackage(m_errPkg, "LoadKey::LoadWorkingKey(wkParam2)", m_devSN, eErr, MEC_DEVAPI_EPP_LoadWorkingKey);
		AlarmDEC(m_errPkg);
		ctx->Ans.result = 2;
		ctx->Answer(Error_Unexpect);
		m_bLoadKey = false;
		return 0;
	}
	Dbg("Load working key2 suc.");
	if (spConfig != NULL)
	{
		eErr = spConfig->WriteConfigValueInt("Load", "3DES", 1);
		if (eErr != Error_Succeed)
		{
			SetErrPackage(m_errPkg, "LoadKey::after load key suc WriteConfigValueInt", m_devSN, eErr, PinPad_UserErrorCode_Write_RunCfgFile_Failed);
			AlarmDEC(m_errPkg);
		}
	}
	m_bLoadKey = false;
	m_b3DESLoaded = true;
	ctx->Answer(Error_Succeed);
	ClearRelatedDEC();
	return 0;
}
int CPinPadFSM::Encrypt(SpReqAnsContext<PinPadService_EncryptData_Req, PinPadService_EncryptData_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	ErrorCodeEnum eErr;
	//set param
	eErr = m_hDevHelper->SetParam(EPP_PT_SET_ENCRYPT_METHOD,EPP_ALGO_METHOD_3DES);
	if (eErr == Error_Succeed)
		eErr = m_hDevHelper->SetParam(EPP_PT_SET_ECB_CBC_MODE,EPP_ALGO_MODE_3DEC_CBC);

	if (eErr != Error_Succeed)
	{
		SetErrPackage(m_errPkg, "Encrypt::SetParm", m_devSN, eErr, MEC_DEVAPI_EPP_SetParam);
		ctx->Answer(Error_Unexpect, AlarmDEC(m_errPkg, true));
		m_bEncrypt = false;
		return 0;
	}
	Dbg("SetParam ok.");
	eErr = m_hDevHelper->ActiveWorkingKey(0, 1);
	if (eErr  != Error_Succeed)
	{
		SetErrPackage(m_errPkg, "Encrypt::ActiveWorkingKey", m_devSN, eErr, MEC_DEVAPI_EPP_ActiveWorkingKey);
		ctx->Answer(Error_Unexpect, AlarmDEC(m_errPkg, true));
		m_bEncrypt = false;
		return 0;
	}
	Dbg("Active ok.");
	EnDecryptInfo srcData,dstData;
	ZeroMemory(srcData.data,MAX_EN_DECRYPT_DATA_SIZE);
	ZeroMemory(dstData.data,MAX_EN_DECRYPT_DATA_SIZE);
	srcData.dwSize = strlen(ctx->Req.data);
	memcpy(srcData.data,ctx->Req.data,srcData.dwSize);
	
	eErr = m_hDevHelper->EncryptData(srcData,dstData);
	if (eErr != Error_Succeed)
	{
		SetErrPackage(m_errPkg, "Encrypt::EncryptData", m_devSN, eErr, MEC_DEVAPI_EPP_EncryptData);
		ctx->Answer(Error_Unexpect, AlarmDEC(m_errPkg, true));
		m_bEncrypt = false;
		return 0;
	}
	//Dbg("%d,%s",dstData.dwSize,dstData.data);

	ctx->Ans.ciphertext = (char*)dstData.data;
	Dbg("Encrypt ok.");
	m_bEncrypt = false;
	ctx->Answer(Error_Succeed);
	return 0;
}
int CPinPadFSM::LoadKeySM(SpReqAnsContext<PinPadService_LoadKeysSM_Req, PinPadService_LoadKeysSM_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	//Dbg("bOpen(%d),initflag(%d),mk(%s),wk1(%s),wk2(%s)",m_bPlainOpen,ctx->Req.initializeflag,(LPCTSTR)ctx->Req.masterkey,(LPCTSTR)ctx->Req.workingkey1,(LPCTSTR)ctx->Req.workingkey2);
	ErrorCodeEnum eErr;
	CSmartPointer<IEntityFunction> spEntityFunction = GetEntityBase()->GetFunction();
	CSmartPointer<IConfigInfo> spConfig;
	eErr = spEntityFunction->OpenConfig(Config_Run, spConfig);
	if (eErr != Error_Succeed)
	{
		SetErrPackage(m_errPkg, "LoadKeySM::OpenConfig", m_devSN, eErr, PinPad_UserErrorCode_Open_RunCfgFile_Failed);
		AlarmDEC(m_errPkg);
		spConfig = NULL;
	}
	if (m_bPlainOpen)
		m_hDevHelper->StopInput();
	bool bSM = false;
	if (ctx->Req.smflag == 1)
		bSM = true;
	//initialization need load master key
	if (ctx->Req.initializeflag)
	{
		MasterKeyParam mkParam;
		if (!bSM)
			mkParam.dwSN = 0;
		else
			mkParam.dwSN = 1;
		mkParam.smFlag = ctx->Req.smflag;
		memset(mkParam.key,0,MAX_MASTER_KEY_SIZE);
		Dbg("mkey len:%d", strlen(ctx->Req.masterkey));
		memcpy(mkParam.key,ctx->Req.masterkey,strlen(ctx->Req.masterkey));
		//Dbg("%s,%d",mkParam.key,mkParam.dwSN);
		eErr = m_hDevHelper->LoadMasterKey(mkParam);
		if (eErr != Error_Succeed)
		{
			Dbg("Load master key(%d),mkeysn:%d failed(%d).",bSM,mkParam.dwSN,eErr);
			LOG_PINPAD_ERROR_MSG_MACRO(eErr, LoadMasterKey);
			ctx->Ans.result = 0;
			SetErrPackage(m_errPkg, "LoadKeySM::LoadMasterKey", m_devSN, eErr, MEC_DEVAPI_EPP_LoadMasterKey);
			ctx->Answer(Error_Unexpect, AlarmDEC(m_errPkg));
			m_bLoadKey = false;
			return 0;
		}
		Dbg("Load master key(%d) suc.",bSM);
		//after load Master key,clear the load key status.add by oilyang 20160922
		//oilyang@20170424 if load 3des master key succeed,clear load key status both of 3des and sm
		if (!bSM)
		{
			spConfig->WriteConfigValueInt("Load", "3DES", 0);
			spConfig->WriteConfigValueInt("Load", "SM", 0);
		}
	}

	WorkKeyParam wkParam1,wkParam2;
	memset(wkParam1.key,0,MAX_WORKING_KEY_SIZE);
	memset(wkParam2.key,0,MAX_WORKING_KEY_SIZE);
	if (!bSM)
		wkParam1.dwMasterSN = wkParam2.dwMasterSN = 0;
	else
		wkParam1.dwMasterSN = wkParam2.dwMasterSN = 1;
	wkParam1.dwWorkingSN = 0;
	wkParam2.dwWorkingSN = 1;
	wkParam1.smFlag = ctx->Req.smflag;
	wkParam2.smFlag = ctx->Req.smflag;
	memcpy(wkParam1.key,ctx->Req.workingkey1,strlen(ctx->Req.workingkey1));
	memcpy(wkParam2.key,ctx->Req.workingkey2,strlen(ctx->Req.workingkey2));
	eErr = m_hDevHelper->LoadWorkingKey(wkParam1);
	if (eErr != Error_Succeed)
	{
		Dbg("load working key 1(%d) failed(%d).",bSM,eErr);
		ctx->Ans.result = 1;
		SetErrPackage(m_errPkg, "LoadKeySM::LoadWorkingKey 1", m_devSN, eErr, MEC_DEVAPI_EPP_LoadWorkingKey);
		ctx->Answer(Error_Unexpect, AlarmDEC(m_errPkg));
		m_bLoadKey = false;
		return 0;
	}
	Dbg("Load working key1(%d) suc.",bSM);

	eErr = m_hDevHelper->LoadWorkingKey(wkParam2);
	if (eErr != Error_Succeed)
	{
		SetErrPackage(m_errPkg, "LoadKeySM::LoadMasterKey 2", m_devSN, eErr, MEC_DEVAPI_EPP_LoadWorkingKey);
		ctx->Answer(Error_Unexpect, AlarmDEC(m_errPkg));
		m_bLoadKey = false;
		return 0;
	}
	Dbg("Load working key2(%d) suc.",bSM);
	if (spConfig != NULL)
	{
		if (!bSM)
		{
			eErr = spConfig->WriteConfigValueInt("Load", "3DES", 1);
			LogWarn(Severity_Low, Error_Unexpect, PinPad_UserErrorCode_PinPad_LoadKey_3DesSN, "set 3des key loaded in runcfg.");
		}
		else
		{
			eErr = spConfig->WriteConfigValueInt("Load", "SM", 1);
			if (!ctx->Req.reserved3.IsNullOrEmpty())
			{
				spConfig->WriteConfigValue("Load", "SN_SM", ctx->Req.reserved3);
				m_keySNSM = ctx->Req.reserved3;
				LogWarn(Severity_Low, Error_Unexpect, PinPad_UserErrorCode_PinPad_LoadKey_SMSN,
						CSimpleStringA::Format("{\"type\": \"SN_SM\", \"value\": \"%s\"}", m_keySNSM.GetData()));
			}
		}
		if (eErr != Error_Succeed)
		{
			SetErrPackage(m_errPkg, "LoadKeySM::WriteConfigValueInt", m_devSN, eErr, PinPad_UserErrorCode_Write_RunCfgFile_Failed);
			AlarmDEC(m_errPkg);
		}
	}
	m_bLoadKey = false;
	if (bSM)
		m_bSMLoaded = true;
	else
		m_b3DESLoaded = true;
	ctx->Answer(Error_Succeed);
	return 0;
}
int CPinPadFSM::EncryptSM(SpReqAnsContext<PinPadService_EncryptDataSM_Req, PinPadService_EncryptDataSM_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	Dbg("smflag [%d]",ctx->Req.smflag);
	ErrorCodeEnum eErr;
	bool bSM = false;
	if (ctx->Req.smflag == 1)
		bSM = true;
	//set param
	if (!bSM)
		eErr = m_hDevHelper->SetParam(EPP_PT_SET_ENCRYPT_METHOD,EPP_ALGO_METHOD_3DES);
	else
		eErr = m_hDevHelper->SetParam(EPP_PT_SET_ENCRYPT_METHOD,EPP_ALGO_METHOD_SM4);

	if (eErr == Error_Succeed)
		eErr = m_hDevHelper->SetParam(EPP_PT_SET_ECB_CBC_MODE,EPP_ALGO_MODE_CBC);

	if (eErr != Error_Succeed)
	{
		SetErrPackage(m_errPkg, "EncryptSM::SetParam", m_devSN, eErr, MEC_DEVAPI_EPP_SetParam);
		ctx->Answer(Error_Unexpect, AlarmDEC(m_errPkg, true));
		m_bEncrypt = false;
		return 0;
	}
	Dbg("SetParam ok.");
	if (!bSM)
		eErr = m_hDevHelper->ActiveWorkingKey(0, 1);
	else
		eErr = m_hDevHelper->ActiveWorkingKey(1, 1);
	if (eErr  != Error_Succeed)
	{
		SetErrPackage(m_errPkg, "EncryptSM::ActiveWorkingKey", m_devSN, eErr, MEC_DEVAPI_EPP_ActiveWorkingKey);
		ctx->Answer(Error_Unexpect, AlarmDEC(m_errPkg, true));
		m_bEncrypt = false;
		return 0;
	}
	Dbg("Active ok.");
	EnDecryptInfo srcData,dstData;
	ZeroMemory(srcData.data,MAX_EN_DECRYPT_DATA_SIZE);
	ZeroMemory(dstData.data,MAX_EN_DECRYPT_DATA_SIZE);
	srcData.dwSize = strlen(ctx->Req.data);
	memcpy(srcData.data,ctx->Req.data,srcData.dwSize);

	eErr = m_hDevHelper->EncryptData(srcData,dstData);
	if (eErr != Error_Succeed)
	{
		SetErrPackage(m_errPkg, "EncryptSM::EncryptData", m_devSN, eErr, MEC_DEVAPI_EPP_EncryptData);
		ctx->Answer(Error_Unexpect, AlarmDEC(m_errPkg, true));
		m_bEncrypt = false;
		return 0;
	}
	//Dbg("%d,%s",dstData.dwSize,dstData.data);

	ctx->Ans.ciphertext = (char*)dstData.data;
	Dbg("Encrypt ok.");
	m_bEncrypt = false;
	ctx->Answer(Error_Succeed);
	return 0;
}
int CPinPadFSM::GetCheckCode(SpReqAnsContext<PinPadService_GetCheckCode_Req, PinPadService_GetCheckCode_Ans>::Pointer ctx)
{
	LOG_FUNCTION();
	ErrorCodeEnum eErr = Error_Unexpect;
	bool bGetOK = true;
	ctx->Ans.checkcode.Init(ctx->Req.mSN.GetCount());
	for (int i = 0; i < ctx->Req.mSN.GetCount(); i++)
	{
		Dbg("mSN:%d,wSN:%d", ctx->Req.mSN[i], ctx->Req.wSN[i]);
		//set param
		if (ctx->Req.mSN[i] == 1)
			eErr = m_hDevHelper->SetParam(EPP_PT_SET_ENCRYPT_METHOD, EPP_ALGO_METHOD_SM4);
		else
			eErr = m_hDevHelper->SetParam(EPP_PT_SET_ENCRYPT_METHOD, EPP_ALGO_METHOD_3DES);
		if (eErr == Error_Succeed)
			eErr = m_hDevHelper->SetParam(EPP_PT_SET_ECB_CBC_MODE, EPP_ALGO_MODE_CBC);
		else
		{
			SetErrPackage(m_errPkg, "GetCheckCode::SetParam", m_devSN, eErr, MEC_DEVAPI_EPP_SetParam);
			AlarmDEC(m_errPkg);
			return Error_DevCommFailed;
		}
		eErr = m_hDevHelper->ActiveWorkingKey(ctx->Req.mSN[i], ctx->Req.wSN[i]);
		if (eErr != Error_Succeed)
		{
			SetErrPackage(m_errPkg, "GetCheckCode::ActiveWorkingKey", m_devSN, eErr, MEC_DEVAPI_EPP_ActiveWorkingKey);
			AlarmDEC(m_errPkg);
			ctx->Ans.checkcode[i] = "";
			return Error_DevCommFailed;
		}
		else
		{
			EnDecryptInfo srcInfo, dstInfo;
			memset(srcInfo.data, 0, MAX_EN_DECRYPT_DATA_SIZE);
			Dbg("encryptdata[%s]", (LPCTSTR)m_devCheckData);
			memcpy(srcInfo.data, m_devCheckData, m_devCheckData.GetLength());
			srcInfo.dwSize = m_devCheckData.GetLength();
			memset(dstInfo.data, 0, MAX_EN_DECRYPT_DATA_SIZE);

			eErr = m_hDevHelper->EncryptData(srcInfo, dstInfo);

			if (eErr != Error_Succeed)
			{
				SetErrPackage(m_errPkg, "GetCheckCode::EncryptData", m_devSN, eErr, MEC_DEVAPI_EPP_EncryptData);
				AlarmDEC(m_errPkg);
				return Error_DevCommFailed;
			}
			ctx->Ans.checkcode[i] = (const char*)dstInfo.data;
		}
	}
	ctx->Answer(Error_Succeed);
	return 0;
}
bool CPinPadFSM::GetDevInfo(DevCategoryInfo &devInfo)
{
	if (!m_bDevInit)
	{
		devInfo.eState = m_eDevState;
		return false;
	}

	DevCategoryInfo info;
	ZeroMemory(info.szModel, MAX_DEV_MODEL_LEN);
	ZeroMemory(info.szType, MAX_DEV_TYPE_LEN);
	ZeroMemory(info.szVendor, MAX_DEV_VENDOR_LEN);
	ErrorCodeEnum eErrDev = m_hDevHelper->GetDevCategory(info);
	if (eErrDev == Error_Succeed)
	{
		m_szModel = info.szModel;
		m_szType = info.szType;
		m_szVendor = info.szVendor;
		Dbg("%d,%d,%d", strlen(info.szModel), strlen(info.szType), strlen(info.szVendor));
	}
	else
	{
		SetErrPackage(m_errPkg, "GetDevInfo::GetDevCategory", m_devSN, eErrDev, MEC_DEVAPI_EPP_GetDevCategory);
		AlarmDEC(m_errPkg);
		m_szModel = "";
        m_szType = "";
        m_szVendor = "";
		m_eDevState = DEVICE_STATUS_NOT_READY;
	}

	ZeroMemory(devInfo.szModel,MAX_DEV_MODEL_LEN);//CM=V2.0#PM=V1.0#MID=75500001#PID=12345678#FWID=V1234567#Vendor=nantian
	ZeroMemory(devInfo.szType,MAX_DEV_TYPE_LEN);
	ZeroMemory(devInfo.szVendor,MAX_DEV_VENDOR_LEN);
	CSimpleStringA tmpModel("");
	 
	if (m_szModel.GetLength() > 1)
	{
		//oilyang@20200807 add FWBID for auth&init
		CSimpleStringA tmpDevSN(""),tmpAddStr("");
		GetEntityBase()->GetFunction()->GetSysVar("FWBDevSN", tmpDevSN);
		if (tmpDevSN.GetLength() > 12 && tmpDevSN.IndexOf("FWB") > 2)
			tmpAddStr = tmpAddStr + "Vendor=" + m_szVendor + "#FWBID=" + tmpDevSN;
		else
			tmpAddStr = tmpAddStr + "Vendor=" + m_szVendor;
		if (m_szModel[m_szModel.GetLength() - 1] == '#')
			tmpModel = m_szModel + tmpAddStr;
		else
			tmpModel = m_szModel + "#" + tmpAddStr;
		strncpy(devInfo.szModel, (const char*)tmpModel, tmpModel.GetLength());
	}
	if (m_szType.GetLength() > 1)
		strncpy(devInfo.szType, (const char*)m_szType, m_szType.GetLength());
	if (m_szVendor.GetLength() > 1)
		strncpy(devInfo.szVendor, (const char*)m_szVendor, m_szVendor.GetLength());
	devInfo.eState = m_eDevState;
	return true;
}
void CPinPadFSM::SetEnterMainPage(bool bValue)
{ 
	m_bInMainPage = bValue;
	return;//oilyang@20200319 去掉任意情况下可输入
	ErrorCodeEnum eErr = Error_Unexpect;
	if (!m_bRVCIL)//非简版无需定时任务
	{
		if (m_bInMainPage)
		{
			eErr = CancelTimer(PINPAD_ANY_INPUT_TIMER);
			Dbg("Cancel any input timer%d.", eErr);
		}
		else
		{
			eErr = ScheduleTimer(PINPAD_ANY_INPUT_TIMER, PINPAD_ANY_INPUT_TIMEOUT);
			Dbg("Start any input timer%d.", eErr);
		}
	}
}
void CPinPadFSM::SelfTest(EntityTestEnum eTestType,CSmartPointer<ITransactionContext> pTransactionContext)
{
	//for simple
	if(m_bPinPadNeedless)
		pTransactionContext->SendAnswer(Error_Succeed);
	else
		pTransactionContext->SendAnswer(m_testResult);
	//DevCategoryInfo devCatInfo;
	//ErrorCodeEnum eErr = m_pPinPad->GetDevCategory(devCatInfo);
}

void CPinPadFSM::CrossTermCall(SpReqAnsContext<PinPadService_CrossTermCall_Req, PinPadService_CrossTermCall_Ans>::Pointer cctx)
{
	ErrorCodeEnum eErr = Error_Unexpect;
	Dbg("CrossTermCall,type:%x", cctx->Req.type);
	switch (cctx->Req.type)
	{
	case PinPadService_Method_GetInputSM:
	{
		DEFINE_PUPPET_CONTEXT_WITH_TYPE(PinPadService_GetInputSM_Req, PinPadService_GetInputSM_Ans);
		if ((eErr = SpBlob2Object(cctx->Req.paramX, ctx->Req)) == Error_Succeed) {
			SetCtx(NULL, ctx, true);
			if (this->GetInput(NULL,ctx,true) != 0) {
				Dbg("GetInput failed.");
				eErr = Error_Unexpect;
			}
			else {
				eErr = SpObject2Blob(ctx->Ans, cctx->Ans.retParamX);
				Dbg("after GetInput,eErr:%d,paramX.len:%d", eErr, cctx->Ans.retParamX.m_iLength);
			}
		}
		cctx->Answer(eErr);
	}
	break;
	case PinPadService_Method_InputCancel:
		m_bFrontCancel = true;
		break;
	case PinPadService_Method_InputWaitMore:
		m_bWaitingMore = true;
	break;
	case PinPadService_Method_Exit:
		SetExitFlag();
		break;
	default:
		break;
	}
}
void CPinPadFSM::CrossTermInvokeInfo(SpOnewayCallContext<PinPadService_CrossTermInvokeInfo_Info>::Pointer ctx)
{
	LOG_FUNCTION();
	Dbg("entity sn:%x,type:%d,errcode:%x", ctx->Info.nEntityID, ctx->Info.type, ctx->Info.result);
	if (ctx->Info.paramX.m_iLength <= 1)
	{

	}
	ErrorCodeEnum eErr = Error_Unexpect;
	CSmartPointer<ITransactionContext> pTransactionContext;
	switch (ctx->Info.type)
	{
	case PinPadService_Method_GetInputSM:
	{
		//auto pt = reinterpret_cast<SpReqAnsContext<PinPadService_GetInputSM_Req,
		//	PinPadService_GetInputSM_Ans>*>(GetCtx(ctx->Info.type));
		//SpReqAnsContext<PinPadService_GetInputSM_Req,
		//	PinPadService_GetInputSM_Ans>::Pointer xctx;
		//xctx.Attach(pt);
		eErr = SpBlob2Object(ctx->Info.paramX, m_inputSMCtx->Ans);
		Dbg("eErr:%d,Y len:%d", eErr, ctx->Info.paramX.m_iLength);
		m_inputSMCtx->Answer((ErrorCodeEnum)ctx->Info.result);
	}
	break;
	default:
		break;
	}
}
int CPinPadFSM::LocalCallHeartBeat(int method, CBlob &bbSend, bool bTwoWay)
{
	//LogEvent()
	//use LogEvent or Client Call? oiltmp
	//LogEvent(Severity_Middle, CROSS_CALL_PINPAD_GET_PIN_INPUT, csCmd);
	HeartBeatService_ClientBase* pClient = new HeartBeatService_ClientBase(GetEntityBase());
	if (pClient == NULL)
	{
		Dbg("create HeartBeat client failed.GetLastError:%d", GetLastError());
		return -1;
	}
	ErrorCodeEnum eErr = Error_Unexpect;
	eErr = pClient->Connect();
	if (eErr != Error_Succeed)
	{
		Dbg("client connect to HeartBeat failed:%x", eErr);
		return -1;
	}
	HeartBeatService_CrossTermCall_Req req;
	HeartBeatService_CrossTermCall_Ans ans;
	req.nEntityID = 0x206;
	req.isTwoWay = bTwoWay;
	req.fromTerminalNo = m_terminalNo;
	GetAttachedTerminal(req.toTerminalNo);
	//req.toTerminalNo = "7717715004";
	req.param1 = "";
	req.param2 = "";
	req.paramX = bbSend;
	req.type = method;
	eErr = pClient->CrossTermCall(req, ans, 20000);
	Dbg("CrossTermCall to HeartBeat from %s to %s, result:%x", (const char*)req.fromTerminalNo, (const char*)req.toTerminalNo, eErr);
	return 0;
}
bool CPinPadFSM::GetAttachedTerminal(CSimpleStringA &csTerm)
{
	return GetEntityBase()->GetFunction()->GetSysVar("AttachedTerminal", csTerm);
}