#include "stdafx.h"
#include "mod_gpio.h"
#include "publicFunExport.h"
#include <bitset>

const int MAX_GPIO_INIT_TRIES = 3;
const int INPUT_PORT_2 = 2;
const int MAX_MOVE_HOLD_TIMES = 5000;
const int ON_EVENT_DETECT_TIMOUE_MILLSECS = 500;
const int REPEAT_FIRE_TIMEOUT_VALUE = 10000; //10s

#define SETBIT(x,y) x|=(1<<(y))
#define CLEARBIT(x,y) x&=((1<<(y))^0xffffff)

using namespace SP::Module::Comm;

static const char* GetDriverPortStringZhCN(int pin)
{
    switch (pin) {
    case 1: return "【驱动】读卡发卡器提示灯";
    case 2: return "【驱动】前端USB通断控制";
    case 3: return "【驱动】身份证阅读器提示灯";
    case 4: return "【驱动】密码键盘提示灯";
    case 5: return "【驱动】脸部照明灯";
    case 6: return "【驱动】故障灯";
    case 7: return "【驱动】读卡发卡器维护提示灯";
    case 8: return "【驱动】前端USB口提示灯";
    case 9: return "【驱动】非接IC读卡器提示灯";
    case 10: return "";
    case 11: return "【驱动】指纹仪提示灯";
    case 12: return "【驱动】凭条打印提示灯";
    case 13: return "【驱动】高拍仪提示灯";
    case 14: return "";
    case 15: return "";
    case 16: return "";
    case 17: return "【接收】震动探测器";
    case 18: return "【接收】机具门感应开关";
    case 19: return "【接收】话机提机感应开关";
    case 20: return "【接收】人体探测感应器";
    case 21: return "【接收】发卡器卡嘴覆盖探测器";
    //case 22: return "";
    //case 23: return "";
    //case 24: return "";
    //case 25: return "";
    case 26: return "【驱动】高拍仪提示灯";
    //case 27: return "";
    //case 28: return "";
    //case 29: return "";
    //case 30: return "";
    //case 31: return "";
    //case 32: return "";
    //case 33: return "";
    //case 34: return "";
    //case 35: return "";
    //case 36: return "";
    //case 37: return "";
    //case 38: return "";
    //case 39: return "";
    //case 40: return "";
    //case 41: return "";
    //case 42: return "";
    default:
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Unkown pin sequence: %d", pin);
        return "";
        break;
    }
}

static const char* pinStatusName[8][2] =
{
	{"无震动", "**有震动**"},
	{"关门", "**开门**"},
	{"挂机", "**摘机**"},
	{"无移动", "**移动**"},
	{"卡嘴正常", "**卡嘴不正常**"},
	{"Pin 22 Normal", "**Pin 22 High**"},
	{"Pin 23 Normal", "**Pin 23 High**"},
	{"Pin 24 Normal", "**Pin 24 High**"}
};

static const char* GetDriverPortString(int pin)
{
	switch (pin) {
	case 1: return "[Driver] CarIssuer Tip Light";
	case 2: return "[Driver] USB Switch";
	case 3: return "[Driver] IDCer Tip Light";
	case 4: return "[Driver] PinPad Tip Light";
	case 5: return "[Driver] Face Light";
	case 6: return "[Driver] Maintain Light";
	case 7: return "[Driver] CardIssuser Mouse Maintain Light";
	case 8: return "[Driver] USB Tip Light";
	case 9: return "[Driver] RF Tip Light";
	case 10: return "";
	case 11: return "[Driver] FingerPrint Tip Light";
	case 12: return "[Driver] Printer Tip Light";
	case 13: return "[Driver] HSPSCanner Read Light";
	case 14: return "";
	case 15: return "";
	case 16: return "";
	case 17: return "[Receiver] Shake Detecter";
	case 18: return "[Receiver] Door Detecter";
	case 19: return "[Receiver] Phone Detecter";
	case 20: return "[Receiver] Body Detecter";
	case 21: return "[Receiver] CardIssuer Mouse Detecter";
		//case 22: return "";
		//case 23: return "";
		//case 24: return "";
		//case 25: return "";
	case 26: return "[Driver] HSPSCanner Tip Light";
		//case 27: return "";
		//case 28: return "";
		//case 29: return "";
		//case 30: return "";
		//case 31: return "";
		//case 32: return "";
		//case 33: return "";
		//case 34: return "";
		//case 35: return "";
		//case 36: return "";
		//case 37: return "";
		//case 38: return "";
		//case 39: return "";
		//case 40: return "";
		//case 41: return "";
		//case 42: return "";
	default:
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Unkown pin sequence: %d", pin);
		return "";
		break;
	}
}

#define LIGHT_STRING_CONVERT(str)   case str : return #str; break;

static const char* GetLightSeqString(int seq)
{
    switch (seq) {
    LIGHT_STRING_CONVERT(UNKNOWN_DEVICE)
    LIGHT_STRING_CONVERT(CARDREADER)
    LIGHT_STRING_CONVERT(CARDREADER_RED)
    LIGHT_STRING_CONVERT(IDCERTIFICATE)
    LIGHT_STRING_CONVERT(PINPAD)
    LIGHT_STRING_CONVERT(SHAKEDETECT)
    LIGHT_STRING_CONVERT(SWITCHINDUCTOR)
    LIGHT_STRING_CONVERT(PHONEPICKUP)
    LIGHT_STRING_CONVERT(MOVEDETECT)
    LIGHT_STRING_CONVERT(CARDGATEDETECT)
    LIGHT_STRING_CONVERT(HEADLIGHT)
    LIGHT_STRING_CONVERT(HEADLIGHT_RED)
    LIGHT_STRING_CONVERT(CONTACTLESSCARD)
    LIGHT_STRING_CONVERT(HEADLIGHT_ASSIST)
    LIGHT_STRING_CONVERT(HSPSCANNER)
    LIGHT_STRING_CONVERT(FINGERPRINT)
    default:
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Unkonwn LightSeq: %d", seq);
        return "UnConver One";
        break;
    }
}
#undef LIGHT_STRING_CONVERT


/** Just for Debug  [Gifur@2024911]*/
void LogPinStatus(ULONG val)
{
	char byteString[9] = { 0 };
	_itoa((int)val, byteString, 2);
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("ReadPort returned btInput[%s]", byteString);

	std::bitset<8> pinSet((int)val);
	if (pinSet[0])
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(pinStatusName[0][1]);
	}
	else
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(pinStatusName[0][0]);
	}

	if (pinSet[1])
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(pinStatusName[1][1]);
	}
	else
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(pinStatusName[1][0]);
	}
	if (pinSet[2])
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(pinStatusName[2][1]);
	}
	else
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(pinStatusName[2][0]);
	}
	if (pinSet[3])
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(pinStatusName[3][1]);
	}
	else
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(pinStatusName[3][0]);
	}
	if (pinSet[4])
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(pinStatusName[4][1]);
	}
	else
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(pinStatusName[4][0]);
	}
	if (pinSet[5])
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(pinStatusName[5][1]);
	}
	else
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(pinStatusName[5][0]);
	}
	if (pinSet[6])
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(pinStatusName[6][1]);
	}
	else
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(pinStatusName[6][0]);
	}
	if (pinSet[7])
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(pinStatusName[7][1]);
	}
	else
	{
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(pinStatusName[7][0]);
	}
	return;
}

CSimpleStringA CombineJsonContext(const char* szMessage)
{
	CSimpleStringA result(true);
	if (szMessage == NULL || strlen(szMessage) == 0) {
		return result;
	}
	result = CSimpleStringA::Format("{\"addition\": \"%s\"}", szMessage);
	return  result;
}

void CGpioServiceSession::Handle_GetDevInfo(SpReqAnsContext<GpioService_GetDevInfo_Req,
    GpioService_GetDevInfo_Ans>::Pointer ctx)
{
    DbgToBeidou(ctx->link, __FUNCTION__)();
    m_pEntity->GetDevInfo(ctx);
}

void CGpioServiceSession::Handle_Exit(SpOnewayCallContext<GpioService_Exit_Info>::Pointer ctx)
{
    DbgToBeidou(ctx->link, __FUNCTION__)();
    m_pEntity->Exit(ctx);
}


/** 因为GPIO没有状态机的概念，所以抛送信息的代码单独实现，没有跟其他硬件类似使用基类中的公有函数 [Gifur@2023810]*/
void CGpioEntity::ToLogRootINIInfo()
{
    CSmartPointer<IConfigInfo> spConfigRoot;
    GetFunction()->OpenConfig(Config_Root, spConfigRoot);

    CSimpleStringA entityName(GetEntityName());
	if (!entityName.IsNullOrEmpty()) {
		CSimpleStringA sectionName = CSimpleStringA::Format("Device.%s", entityName.GetData());
		CSimpleStringA csVendor(true), csVersion(true), csBatch(true), csPort(true), csBaudrate(true);
		spConfigRoot->ReadConfigValue(sectionName, "Vendor", csVendor);
		spConfigRoot->ReadConfigValue(sectionName, "Version", csVersion);
		spConfigRoot->ReadConfigValue(sectionName, "Batch", csBatch);
		spConfigRoot->ReadConfigValue(sectionName, "Port", csPort);
		spConfigRoot->ReadConfigValue(sectionName, "Baudrate", csBaudrate);

		std::map<std::string, std::string> rootInfo;
		CSimpleStringA csCheckData(true), csKeySN(true);
		rootInfo["Vendor"] = csVendor.GetData();
		rootInfo["Version"] = csVersion.GetData();
		rootInfo["Batch"] = csBatch.GetData();
		rootInfo["Port"] = csPort.GetData();
		rootInfo["Baudrate"] = csBaudrate.GetData();
		std::pair<bool, std::string> strResult;
		strResult = generateJsonStr(rootInfo);
		LogWarn(Severity_Low, Error_Debug, GPIO_UserErrorCode_Real_Root_Config, strResult.second.c_str());
	}
    return;
}

struct GpioInitTask : public ITaskSp {
	CGpioEntity* m_entity;
	CSmartPointer<ITransactionContext> m_pTransactionContext;
	GpioInitTask(CGpioEntity* entity, CSmartPointer<ITransactionContext> pTransactionContext) :m_entity(entity), m_pTransactionContext(pTransactionContext) {}

	void Process()
	{
		m_entity->InitializeVendorLogSwitch();
		ErrorCodeEnum err = m_entity->Initial();
		if (err == Error_Succeed)
		{
            DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Gpio open succeeded.");
			//oiltest 20130118 for audiodg handle
			m_entity->StartDetectWorkThread();
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("subscribelog...");
            //oiltmp the subscribelog should distinct machine type?
			m_entity->GetFunction()->SubscribeLog(m_entity->m_uuidHealth, m_entity, Log_Event, Severity_Middle, Error_IgnoreAll, -1, "HealthManager");
			m_entity->GetFunction()->SubscribeLog(m_entity->m_uuidIDC, m_entity, Log_Event, Severity_Middle, Error_IgnoreAll, -1, "IDCertificate");
			m_entity->GetFunction()->SubscribeLog(m_entity->m_uuidFP, m_entity, Log_Event, Severity_Middle, Error_IgnoreAll, -1, "FingerPrint");
			m_entity->GetFunction()->SubscribeLog(m_entity->m_uuidKB, m_entity, Log_Event, Severity_Middle, Error_IgnoreAll, -1, "PinPad");
			m_entity->GetFunction()->SubscribeLog(m_entity->m_uuidCR, m_entity, Log_Event, Severity_Middle, Error_IgnoreAll, -1, "CardIssuerStand");
			m_entity->GetFunction()->SubscribeLog(m_entity->m_uuidCA, m_entity, Log_Event, Severity_Middle, Error_IgnoreAll, -1, "CustomerAware");
			m_entity->GetFunction()->SubscribeLog(m_entity->m_uuidCC, m_entity, Log_Event, Severity_Middle, Error_IgnoreAll, -1, "ContactlessCard");
			m_entity->GetFunction()->SubscribeLog(m_entity->m_uuidDD, m_entity, Log_Event, Severity_Middle, Error_IgnoreAll, -1, "DeviceControl");
			m_entity->GetFunction()->SubscribeLog(m_entity->m_uuidCS, m_entity, Log_Event, Severity_Middle, Error_IgnoreAll, -1, "CardIssuerStore");
			m_entity->GetFunction()->SubscribeLog(m_entity->m_uuidHSPscanner, m_entity, Log_Event, Severity_Middle, Error_IgnoreAll, -1, "HSPScanner");
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("sub ok...");
		}
		else
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("gpio open failed: %s.", SpStrError(err));
		}
		m_pTransactionContext->SendAnswer(Error_Succeed);
	}
};

void CGpioEntity::OnPreStart(CAutoArray<CSimpleStringA> strArgs, CSmartPointer<ITransactionContext> pTransactionContext)
{
	GpioInitTask* initTask = new GpioInitTask(this, pTransactionContext);
	GetFunction()->PostThreadPoolTask(initTask);
}

void CGpioEntity::ToLogWarnInfoAboutTerm(const AdapterInfo& m_adapterInfo)
{
	std::map<std::string, std::string> termInfo;
	char* strFileHash = new char[128];
	ZeroMemory(strFileHash, 128);
	BYTE fileHash[32];
	SM3File(const_cast<char*>(m_adapterInfo.adapterFilePath.GetData()), fileHash);
    SP::Module::Util::HexBuf2StrBuf(fileHash, &strFileHash, 32);
    DWORD fileSize = SP::Module::FileSystem::FetchFileSize(m_adapterInfo.adapterFilePath);
	termInfo["VendorDllName"] = m_adapterInfo.adapterFileName;
	termInfo["VendorDllFileHash"] = strFileHash;
	ZeroMemory(strFileHash, 128);
	termInfo["VendorDllFileSize"] = _itoa(fileSize, strFileHash, 10);
	termInfo["szModel"] = m_adapterInfo.devCatInfo.szModel;
	termInfo["szType"] = m_adapterInfo.devCatInfo.szType;
	termInfo["Port"] = m_adapterInfo.strPort.GetData();
	termInfo["PortNum"] = m_adapterInfo.strPortNum.GetData();
	termInfo["Baudrate"] = m_adapterInfo.strBaudrate.GetData();
	if (strFileHash != nullptr) {
		delete[] strFileHash;
		strFileHash = nullptr;
	}

	std::pair<bool, std::string> strResult;
	strResult = generateJsonStr(termInfo);
	LogWarn(Severity_Low, Error_Unexpect, GPIO_UserErrorCode_LogInfoAboutTerm, strResult.second.c_str());
	return;
}

void CGpioEntity::SetErrorAndLog(ErrorCodeEnum errCode
	, DWORD userCode
	, CSimpleStringA devApi
	, CSimpleStringA funPath
	, bool bInBusiness /*= false*/
	, int costTime /*= 0*/
	, CSimpleStringA logCode /*= ""*/
	, CSimpleStringA context /*= ""*/)
{
	DevErrorInfo devErrInfo;
	ZeroMemory(&devErrInfo, sizeof(devErrInfo));
	if (m_hDevHelper != nullptr) {
		m_hDevHelper->GetLastErr(devErrInfo);
	}
	else {
		strcpy(devErrInfo.szErrMsg, "{\"Description\": \"DevAdapter handle is null\"}");
	}
	const CSimpleStringA alarmMsg = CSimpleStringA::Format("{\"Function\":\"%s\", \"DevApi\":\"%s\", \"ReturnCode\":\"%s\", \"Msg\":\"%s\", \"Context\":\"%s\"}"
		, funPath.GetData(), devApi.GetData(), SpStrError(errCode), devErrInfo.szErrMsg, context.GetData());
	
	std::map<std::string, std::string> msgInfo;
	msgInfo["ReturnCode"] = SpStrError(errCode);
	msgInfo["ErrMsg"] = devErrInfo.szErrMsg;
	msgInfo["Context"] = context.GetData();
	std::pair<bool, std::string> strResult;
	strResult = generateJsonStr(msgInfo);
	CSimpleStringA csErrMsgWithReturnCode = strResult.second.c_str();

	CSimpleStringA tmpRTA(true), tmpDesc(true);
	if (GetFunction()->GetVTMErrMsg(userCode, tmpDesc, tmpRTA) != Error_Succeed)
		tmpRTA = CSimpleStringA::Format("0x%X", userCode);//if map failed, use dwCode instead

	if (bInBusiness) {
		LogError(Severity_High, errCode, userCode, alarmMsg.GetData());
		DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_USER).setLogCode(logCode).setAPI(devApi).setResultCode(tmpRTA.GetData()).setCostTime(costTime)(csErrMsgWithReturnCode.GetData());
	}
	else {
		LogWarn(Severity_High, errCode, userCode, alarmMsg.GetData());
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(logCode).setAPI(devApi).setResultCode(tmpRTA.GetData()).setCostTime(costTime)(csErrMsgWithReturnCode.GetData());
	}
	return;
}

bool CGpioEntity::DetectBit(ULONG data, int pos)
{
    if (!m_bFuncVer2) {
        ULONG tmp = 0;
        SETBIT(tmp, pos);
        return (data & tmp);
    } 
#if defined(RVC_OS_LINUX)
    else {
		DWORD dwReq = (GPIO_DEV_SN_SENSOR_SHAKE << pos);
		return (data & dwReq);
    }
#endif //RVC_OS_LINUX
    return 0;
}

ErrorCodeEnum CGpioEntity::Initial()
{
    CSimpleStringA dllName;
	ErrorCodeEnum eErrDev = ExtractVendorLibFullPath(dllName);
    if (eErrDev != Error_Succeed) {
        DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM)("load vendor dll or so(%s) failed, ec=%s", dllName.GetData(), SpStrError(eErrDev));
        m_bOpening = false;
        return Error_DevLoadFileFailed;
    }
	LogWarn(Severity_Low, Error_Unexpect, GPIO_UserErrorCode_RootInfo, dllName.GetData());

	m_adapterInfo.adapterFilePath = dllName;
    m_adapterInfo.adapterFileName = vendorLibInfo.toLibNameString();
	m_adapterInfo.strVendor = vendorLibInfo.strVendor;
	m_adapterInfo.strVersion = vendorLibInfo.strVersion;
	m_adapterInfo.strBatch = vendorLibInfo.strBatch;

    CSmartPointer<IEntityFunction> spEntityFunction = GetFunction();
    CSmartPointer<IConfigInfo> spConfigRoot;
    eErrDev = spEntityFunction->OpenConfig(Config_Root, spConfigRoot);
    if (eErrDev != Error_Succeed) {
        DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM)("open cfg file failed %s", SpStrError(eErrDev));
        m_bOpening = false;
        return eErrDev;
    }
	CSimpleStringA csPort(true), csBaudrate(true);
	CSimpleStringA csPortNum(true);
	spConfigRoot->ReadConfigValue("Device.Gpio", "Port", csPort);
	spConfigRoot->ReadConfigValue("Device.Gpio", "Baudrate", csBaudrate);
	spConfigRoot->ReadConfigValue("Device.Gpio", "PortNum", csPortNum);
	m_adapterInfo.strPort = csPort;
	m_adapterInfo.strBaudrate = csBaudrate;
	m_adapterInfo.strPortNum = csPortNum; //Just load from Config

#if defined(RVC_OS_WIN)
    DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("[%s],[%s],[%s]", m_adapterInfo.strVendor.GetData()
		, m_adapterInfo.strVersion.GetData(), m_adapterInfo.strBatch.GetData());
    //TODO: 这个看怎么兼容后移除  [Gifur@202494]
	//Gpio.keba.1.1 , Gpio.Hyosung.1.1, Gpio.kxd.1.1 均为 老设备，2024-9-11发现现有生产有2249台
	if (!_stricmp(m_adapterInfo.strVendor, "Hyosung") || !_stricmp(m_adapterInfo.strVendor, "Keba") || !_stricmp(m_adapterInfo.strVendor, "Kxd")) {
		if (m_adapterInfo.strVersion == "1" && m_adapterInfo.strVersion == "1") {
			m_bNewVersion = FALSE;
		}
	}
#endif
	bool theSameFlag = false;
	if ((m_bNewVersion && csPortNum.Compare("4") == 0) || (!m_bNewVersion && csPortNum.Compare("3") == 0)) { theSameFlag = true; }
	LogWarn(Severity_Low, Error_Debug, GPIO_UserErrorCode_PortNumOldVersion
		, CSimpleStringA::Format("Required:%s,NewVersion:%s,PortNum:%s", theSameFlag ? "True" : "False", m_bNewVersion ? "True" : "False", csPortNum.GetData()));

	m_hDevHelper.SetAdapterName(GetEntityName());
    eErrDev = m_hDevHelper.LoadUp(dllName);
    if (eErrDev != Error_Succeed) {
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("load up %s failed: %s", dllName.GetData(), SpStrError(eErrDev));
        m_bOpening = false;
        return Error_DevLoadFileFailed;
    }

	GpioInitParam initParam;
	initParam.dwPort = m_adapterInfo.GetPortInt();
	initParam.dwBaudRate = m_adapterInfo.GetBaudrateInt();
    //TODO:   [Gifur@202495]
	initParam.dir[0] = true;
	initParam.dir[1] = true;
	initParam.dir[2] = false;
	initParam.dir[3] = false;
	initParam.dwPortNum = 3;
	if (m_bNewVersion) {
		initParam.dwPortNum = 4;
		initParam.dir[3] = true;
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("New available 4 port num");
	}
    int initTries = 0;
	ErrorCodeEnum err;
    do {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("to open device...port(%d), baudrate(%d).", m_adapterInfo.GetPortInt(), m_adapterInfo.GetBaudrateInt());
		ULONGLONG ullStart = SP::Module::Comm::RVCGetTickCount();
        err = m_hDevHelper->DevOpen(initParam);
		ULONGLONG ullEnd = SP::Module::Comm::RVCGetTickCount();
        if (err == Error_Succeed) {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::DevOpen").setCostTime(ullEnd - ullStart)("open device succ");
			ToLogRootINIInfo(); //WARN：这里是重新读一遍原生的root配置信息
            DevCategoryInfo devCatInfo;
			ZeroMemory(devCatInfo.szModel, sizeof(devCatInfo.szModel));
			ZeroMemory(devCatInfo.szType, sizeof(devCatInfo.szType));
			ZeroMemory(devCatInfo.szVendor, sizeof(devCatInfo.szVendor));
			ullStart = SP::Module::Comm::RVCGetTickCount();
            err = m_hDevHelper->GetDevCategory(devCatInfo);
			ullEnd = SP::Module::Comm::RVCGetTickCount();
            if (err == Error_Succeed) {
                m_adapterInfo.FulfillCategoryInfo(devCatInfo);
				ToLogWarnInfoAboutTerm(m_adapterInfo);
#if defined(RVC_OS_LINUX)
				CSimpleStringA strType(devCatInfo.szType);
				if (strType.IndexOf("FUNCVER=2.0") != -1) {
					m_bFuncVer2 = TRUE;
					DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Detect new interface version: %s", strType.GetData());
				}
#endif //RVC_OS_LINUX
            } else {
				SetErrorAndLog(err, GPIO_UserErrorCode_GetDevCategory_Failed, "DevAdapter::GetDevCategory", "FulfillAdapterDevCategory", false, ullEnd - ullStart);
            }
            m_bOpened = true;
            break;
        } else {
			SetErrorAndLog(err, GPIO_UserErrorCode_DevOpen_Failed, "DevAdapter::DevOpen", __FUNCTION__, false, ullEnd - ullStart);
            Sleep(300);
            initTries++;
            continue;
        }
    } while (initTries < MAX_GPIO_INIT_TRIES);

    m_bOpening = false;
    if (!m_bOpened) {
        err = Error_DevConnFailed;
    }
    else {
        if (!m_bFuncVer2) {
			ULONGLONG ullStart = SP::Module::Comm::RVCGetTickCount();
            eErrDev = m_hDevHelper->WritePort(0, 0x00);
			ULONGLONG ullEnd = SP::Module::Comm::RVCGetTickCount();
            if (eErrDev != Error_Succeed)
				SetErrorAndLog(eErrDev, GPIO_UserErrorCode_WritePort_Failed, "DevAdapter::WritePort", __FUNCTION__, false, ullEnd - ullStart, "", CombineJsonContext("WritePort(0) after DevOpen"));
			ullStart = SP::Module::Comm::RVCGetTickCount();
            eErrDev = m_hDevHelper->WritePort(1, 0x00);
			ullEnd = SP::Module::Comm::RVCGetTickCount();
            if (eErrDev != Error_Succeed)
				SetErrorAndLog(eErrDev, GPIO_UserErrorCode_WritePort_Failed, "DevAdapter::WritePort", __FUNCTION__, false, ullEnd - ullStart, "", CombineJsonContext("WritePort(1) after DevOpen"));
            if (m_bNewVersion) {
				ullStart = SP::Module::Comm::RVCGetTickCount();
                eErrDev = m_hDevHelper->WritePort(3, 0x00);
				ullEnd = SP::Module::Comm::RVCGetTickCount();
                if (eErrDev != Error_Succeed)
					SetErrorAndLog(eErrDev, GPIO_UserErrorCode_WritePort_Failed, "DevAdapter::WritePort", __FUNCTION__, false, ullEnd - ullStart, "", CombineJsonContext("WritePort(3) after DevOpen"));
            }
        }
        else {
#if defined(RVC_OS_LINUX)
			ULONGLONG ullStart = SP::Module::Comm::RVCGetTickCount();
            eErrDev = m_hDevHelper->SetStatus(GPIO_DEV_SN_LIGHT_SENSOR_ALL, GPIO_DEV_LIGHT_MODE_RESET);
			ULONGLONG ullEnd = SP::Module::Comm::RVCGetTickCount();
            if (eErrDev != Error_Succeed)
				SetErrorAndLog(eErrDev, GPIO_UserErrorCode_SetStatus_Failed, "DevAdapter::SetStatus", __FUNCTION__, false, ullEnd - ullStart, "", CombineJsonContext("SetStatus after DevOpen"));
#endif //RVC_OS_LINUX
        }
    }
	m_eMachineType = SP::Module::Comm::GetTerminalMachineInfo(this).type;
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("machine type: %s", SP::Module::Comm::Type2Str(m_eMachineType));
    m_moveHoldTimes = MAX_MOVE_HOLD_TIMES;//oiltmp about 5000*300ms = 25 minutes
    m_moveDisappearTimes = m_moveHoldTimes;
    return err;
}

void CGpioEntity::OnLog(const CAutoArray<CUUID>& SubIDs, const CUUID nLogID, const LogTypeEnum eLogType, const SeverityLevelEnum eLevel,
                        const DWORD dwSysError, const DWORD dwUserCode, const DWORD dwEntityInstanceID, const WORD wEntityDevelID,
                        const CAutoArray<DWORD>& Param, const char* pszEntityName, const char* pszModuleName, const char* pszMessage, const linkContext& pLinkInfo)
{
    
    GpioService_Set_Info Req;
	if (!m_bOpened) {
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("usercode [%x], but device is not open", dwUserCode);
        return;
	}
	else {
        DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("receive usercode [%x]", dwUserCode);
	}
    Req.close = 0;
    switch (dwUserCode) {
    case LOG_EVT_CARDISSUER_GREEN_ON:
    case LOG_EVT_CARDISSUER_STORE_GREEN_ON:
        Req.devseq = CARDREADER;
        Req.mode = 1;
        break;
    case LOG_EVT_CARDISSUER_RED_ON:
        Req.devseq = CARDREADER_RED;
        Req.mode = 1;
        break;
    case LOG_EVT_IDCERTIFICATE_GREEN_ON:
        Req.devseq = IDCERTIFICATE;
        Req.mode = 1;
        break;
    case LOG_EVT_FINGERPRINT_GREEN_ON:
        Req.devseq = FINGERPRINT;
        Req.mode = 1;
        break;
    case LOG_EVT_PINPAD_GREEN_ON:
        Req.devseq = PINPAD;
        Req.mode = 1;
        break;
    case LOG_EVT_HEADLIGHT_GREEN_ON:
        m_bHeadLightFlag = true;
        Req.devseq = HEADLIGHT;
        Req.mode = 0;
        DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("machine light on");
        break;
    case LOG_EVT_HEADLIGHT_RED_ON:
        Req.devseq = HEADLIGHT_RED;
        Req.mode = 1;
        break;
    case LOG_EVT_CONTACTLESS_CARD_GREEN_ON:
        Req.devseq = CONTACTLESSCARD;
        Req.mode = 1;
        break;
    case LOG_EVT_IEBROWSER_LIGHT_ASSISTANT_ON:
        Req.devseq = HEADLIGHT_ASSIST;
        Req.mode = 1;
        break;
    case LOG_EVT_CARDISSUER_GREEN_OFF:
    case LOG_EVT_CARDISSUER_STORE_GREEN_OFF:
        Req.devseq = CARDREADER;
        Req.mode = 1;
        Req.close = 1;
        break;
    case LOG_EVT_CARDISSUER_RED_OFF:
        Req.devseq = CARDREADER_RED;
        Req.mode = 1;
        Req.close = 1;
        break;
    case LOG_EVT_IDCERTIFICATE_GREEN_OFF:
        Req.devseq = IDCERTIFICATE;
        Req.mode = 1;
        Req.close = 1;
        break;
    case LOG_EVT_FINGERPRINT_GREEN_OFF:
        Req.devseq = FINGERPRINT;
        Req.mode = 1;
        Req.close = 1;
        break;
    case LOG_EVT_PINPAD_GREEN_OFF:
        Req.devseq = PINPAD;
        Req.mode = 1;
        Req.close = 1;
        break;
    case LOG_EVT_HEADLIGHT_GREEN_OFF:
        m_bHeadLightFlag = false;
        Req.devseq = HEADLIGHT;
        Req.mode = 1;
        Req.close = 1;
        DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("machine light off");
        break;
    case LOG_EVT_HEADLIGHT_RED_OFF:
        Req.devseq = HEADLIGHT_RED;
        Req.mode = 1;
        Req.close = 1;
        break;
    case LOG_EVT_CONTACTLESS_CARD_GREEN_OFF:
        Req.devseq = CONTACTLESSCARD;
        Req.mode = 1;
        Req.close = 1;
        break;
    case LOG_EVT_IEBROWSER_LIGHT_ASSISTANT_OFF:
        Req.devseq = HEADLIGHT_ASSIST;
        Req.mode = 1;
        Req.close = 1;
        break;
    case LOG_EVT_HSPS_LIGHT_ON:
        Req.devseq = HSPSCANNER;
        Req.mode = 1;
        DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("hspscanner light on");
        break;
    case LOG_EVT_HSPS_LIGHT_OFF:
        Req.devseq = HSPSCANNER;
        Req.mode = 1;
        Req.close = 1;
        DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("hspscanner light off");
        break;
    default:
        //DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("unkown event: 0x%X", dwUserCode);
        return;
    }
	DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("devseq[%d],mode[%d]close[%d]", Req.devseq, Req.mode, Req.close);
	m_bFuncVer2 ? SetEx(Req) : Set(Req);
}

void CGpioEntity::WritePin(DWORD dwPinSeq, bool bHighLevel)
{
    ErrorCodeEnum result(Error_Succeed);
    int idx = -1;
    DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Write Pin %s with %s", GetDriverPortString(dwPinSeq + 1), bHighLevel ? "[Active]" : "[InActive]");
    if (dwPinSeq > 16) {/** 目前只有一个高拍仪的提示灯会超过该值  [Gifur@202495]*/
        if (!m_bNewVersion && dwPinSeq < 24) {
            DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER)("not support pin number:%d", dwPinSeq);
            return;
        }
        idx = 3;
    } else if (dwPinSeq < 8) {
        idx = 0;
    } else {
		idx = 1;
    }

	if (bHighLevel)
		SETBIT(m_btOutputStatus[idx], dwPinSeq - 8 * idx);
	else
		CLEARBIT(m_btOutputStatus[idx], dwPinSeq - 8 * idx);

	const auto iBegin = SP::Module::Comm::RVCGetTickCount();
	result = m_hDevHelper->WritePort(idx, m_btOutputStatus[idx]);
	const auto iEnd = SP::Module::Comm::RVCGetTickCount();
	if (result != Error_Succeed) {
		SetErrorAndLog(result, GPIO_UserErrorCode_WritePort_Failed, "DevAdapter::WritePort", __FUNCTION__, false, iEnd - iBegin, "", CombineJsonContext(CSimpleStringA::Format("write port[%d] with %d", idx, m_btOutputStatus[idx])));
	}
	else {
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::WritePort").setAPI(__FUNCTION__).setCostTime(iEnd - iBegin)("write port[%d] with %d succ", idx, m_btOutputStatus[idx]);
	}
    return;
}

void CGpioEntity::SetEx(GpioService_Set_Info req)
{
#if defined(RVC_OS_LINUX)

	int devicePort;
	DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("SetEx request %s arrived!", GetLightSeqString(req.devseq));
	switch (req.devseq) {
	case CARDREADER:
	{
		devicePort = GPIO_DEV_SN_LIGHT_CARDISSUER;
		break;
	}
	case CARDREADER_RED:
	{
		devicePort = GPIO_DEV_SN_LIGHT_CARDISSUER_MAINTAIN;
		break;
	}
	case IDCERTIFICATE:
	{
		devicePort = GPIO_DEV_SN_LIGHT_IDCERTIFICATE;
		break;
	}
	case FINGERPRINT:
	{
		devicePort = GPIO_DEV_SN_LIGHT_FINGERPRINT;
		break;
	}
	case PINPAD:
	{
		devicePort = GPIO_DEV_SN_LIGHT_PINPAD;
		break;
	}
	case HEADLIGHT:
	{
		devicePort = GPIO_DEV_SN_LIGHT_FACE;
		break;
	}
	case HEADLIGHT_RED:
	{
		devicePort = 6/*GPIO_DEV_SN_LIGHT_MACHINE_FAULT*/;
		break;
	}
	case CONTACTLESSCARD:
	{
		devicePort = GPIO_DEV_SN_LIGHT_CONTACTLESSCARD;
		break;
	}
	case HEADLIGHT_ASSIST:
	{
		devicePort = GPIO_DEV_SN_LIGHT_FACE;
		break;
	}
	break;
	default:
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setAPI(__FUNCTION__)("unsupport device seq: %d", req.devseq);
		return;
	}

	if (m_hDevHelper != nullptr) {
		DWORD dwReq = devicePort;
		DWORD dwMode = 0;
		if (!req.close) {
			dwMode |= GPIO_DEV_LIGHT_MODE_COLOR_NORMAL;
			if (!!req.mode) {
				dwMode |= GPIO_DEV_LIGHT_MODE_LIGHT_FLICKER;
			} else {
				dwMode |= GPIO_DEV_LIGHT_MODE_LIGHT_SUSTAIN;
			}
		}
        const auto iBegin = SP::Module::Comm::RVCGetTickCount();
		const ErrorCodeEnum ec = m_hDevHelper->SetStatus(dwReq, dwMode);
        const auto iEnd = SP::Module::Comm::RVCGetTickCount();
		if (ec != Error_Succeed) {
			SetErrorAndLog(ec, GPIO_UserErrorCode_SetStatus_Failed, "DevAdapter::SetStatus", __FUNCTION__, false, iEnd - iBegin, "", CombineJsonContext(CSimpleStringA::Format("SetStatus with 0x%X,0x%X", dwReq, dwMode)));
		}
		else {
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM).setAPI("DevAdapter::SetStatus").setAPI(__FUNCTION__).setCostTime(iEnd - iBegin)("SetStatus with 0x%X,0x%X", dwReq, dwMode);
		}
	} else {
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("dev helper object is invalid pointer!");
	}
#endif //RVC_OS_LINUX
}

void CGpioEntity::Set(GpioService_Set_Info req)
{
    CSimpleStringA activeModeSecName = "";
    int devicePort;
    OutDrivingInfo odi;
    DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("Set request %s arrived!", GetLightSeqString(req.devseq));
    switch (req.devseq) {
    case CARDREADER:
    case PINPAD:
    case CONTACTLESSCARD:
    {
        devicePort = req.devseq == CARDREADER ? 0 : (req.devseq == PINPAD ? 3 : 8);
		odi.OutputMode = OM_POSITIVE_FLICKER;
		odi.StopMode = SM_CYCLE;
		odi.SetTime = 200;
		odi.ResetTime = 200;
		odi.TimeOut = 5000;
        break;
    }
    case CARDREADER_RED:
    case HEADLIGHT_RED:
    {
        devicePort = req.devseq == CARDREADER_RED ? 6 : 5;
		odi.OutputMode = OM_POSITIVE_LEVEL;
		odi.StopMode = SM_CALLTRIGGER;
		odi.SetTime = 200;
		odi.ResetTime = 200;
		odi.TimeOut = 3000;
        break;
    }
    case IDCERTIFICATE:
    case FINGERPRINT:
    {
        devicePort = req.devseq == IDCERTIFICATE ? 2 : 10;
		odi.OutputMode = OM_POSITIVE_FLICKER;
		odi.StopMode = SM_CYCLE;
		odi.SetTime = 150;
		odi.ResetTime = 150;
		odi.TimeOut = 5000;
        break;
    }
    case HEADLIGHT:
    case HSPSCANNER:
    {
        devicePort = req.devseq == HEADLIGHT ? 4 : 12;
		odi.OutputMode = OM_POSITIVE_LEVEL;
		odi.StopMode = SM_CALLTRIGGER;
		odi.SetTime = 1000;
		odi.ResetTime = 1000;
		odi.TimeOut = 5000;
        break;
    }
    case HEADLIGHT_ASSIST:
    {
        devicePort = 4;
		odi.OutputMode = OM_POSITIVE_FLICKER;
		odi.StopMode = SM_CYCLE;
		odi.SetTime = 1000;
		odi.ResetTime = 500;
		odi.TimeOut = 5000;
        break;
    }
    default:
		odi.OutputMode = OM_POSITIVE_LEVEL;
		odi.StopMode = SM_CALLTRIGGER;
		odi.SetTime = 200;
		odi.ResetTime = 200;
		odi.TimeOut = 5000;
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setAPI(__FUNCTION__)("unsupport device seq: %d", req.devseq);
        return;
    }
    SetOutDriving(req, odi, 0, devicePort);
}

void CGpioEntity::StartDetectWorkThread()
{
	ReceivingInfo ri;
    ri.ContinuousTriggerTime = 2;

	GetContextInfo* pGci = new GetContextInfo();
    /** 注意设备序号是实体内定义的逻辑，不是设备端口号，最后用作于计时器的ID去了*/
	pGci->timerID = PHONEPICKUP;
	m_PickUpTimeStamp = m_PutDownTimeStamp = SP::Module::Comm::RVCGetTickCount();
	m_DoorOpenTimeStamp = m_DoorCloseTimeStamp = SP::Module::Comm::RVCGetTickCount();
	ITimerListener* pListener = new TimerOutHelper<CGpioEntity>(this, &CGpioEntity::OnEventDetect, pGci);
	GetFunction()->SetTimer(pGci->timerID, pListener, 100);
}

void CGpioEntity::OnPositiveFlickerSetTimerout(void* pData)
{
    SetContextInfo* pSCI = (SetContextInfo*)pData;
    GetFunction()->KillTimer(pSCI->timerID);
    WritePin(pSCI->pinSeq, false); //实际操作
    pSCI->timerID = pSCI->timerID;
    ITimerListener* pListener = new TimerOutHelper<CGpioEntity>(this, &CGpioEntity::OnPositiveFlickerResetTimerout, pSCI, true);
    GetFunction()->SetTimer(pSCI->timerID, pListener, pSCI->resetTime);
}

void CGpioEntity::OnPositiveFlickerResetTimerout(void* pData)
{
    SetContextInfo* pSCI = (SetContextInfo*)pData;
    GetFunction()->KillTimer(pSCI->timerID);
    WritePin(pSCI->pinSeq, true); //实际操作
    ITimerListener* pListener = new TimerOutHelper<CGpioEntity>(this, &CGpioEntity::OnPositiveFlickerSetTimerout, pSCI, true);
    GetFunction()->SetTimer(pSCI->timerID, pListener, pSCI->setTime);
}

void CGpioEntity::OnSelfTest(EntityTestEnum eTestType, CSmartPointer<ITransactionContext> pTransactionContext)
{
    if (!m_bOpened && m_hDevHelper) {
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("let selftest to restart it!");
        pTransactionContext->SendAnswer(Error_InvalidState);
        return;
    }
    else if(!m_bOpened) {
        DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("process failed before DevOpen, do not try to restart");
        pTransactionContext->SendAnswer(Error_Succeed);
        return;
    }
    pTransactionContext->SendAnswer(Error_Succeed);
    return;
}

void CGpioEntity::OnSysVarEvent(const char* pszKey, const char* pszValue, const char* pszOldValue, const char* pszEntityName)
{
	if ((_strnicmp(pszKey, "UIState", strlen("UIState")) == 0))
	{
		if (_strnicmp(pszValue, "M", strlen("M")) == 0)
			SetInWhatPage(PageType_MainPage);
		else if (_strnicmp(pszValue, "U", strlen("U")) == 0)
			SetInWhatPage(PageType_UserDesktop);
		else
			SetInWhatPage(PageType_Other);
	}
}

void CGpioEntity::GetDevInfo(SpReqAnsContext<GpioService_GetDevInfo_Req, GpioService_GetDevInfo_Ans>::Pointer ctx)
{
    if (m_bOpening) {
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(GpioService_LogCode_GetDevInfo).setAPI(__FUNCTION__)("device is opening");
        ctx->Answer(Error_NotInit);
        return;
    }
    if (!m_bOpened) {
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_USER).setLogCode(GpioService_LogCode_GetDevInfo).setResultCode("RTA2901").setAPI(__FUNCTION__)("GPIO未打开");
        ctx->Answer(Error_DevNotAvailable, GPIO_UserErrorCode_DevOpen_Failed);
    }
    else {
        DevCategoryInfo info = { 0 };
        const ULONGLONG ullStart = SP::Module::Comm::RVCGetTickCount();
        ErrorCodeEnum erroCode = m_hDevHelper->GetDevCategory(info);
        const ULONGLONG ullEnd = SP::Module::Comm::RVCGetTickCount();
        ctx->Ans.state = (int)erroCode;
        if (erroCode == Error_Succeed) {
            ctx->Ans.model = info.szModel;
            ctx->Ans.type = info.szType;
            ctx->Ans.version = CSimpleStringA::Format("%d.%d.%d.%d",
                info.version.wMajor, info.version.wMinor, info.version.wRevision, info.version.wBuild);
            DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode(GpioService_LogCode_GetDevInfo)
                .setAPI("DevAdapter::GetDevCategory").setCostTime(ullEnd - ullStart)("model: %s, state:%d, type:%s, version:%s"
                , ctx->Ans.model.GetData(), ctx->Ans.state, ctx->Ans.type.GetData(), ctx->Ans.version.GetData());
        }
        else {
			SetErrorAndLog(erroCode, GPIO_UserErrorCode_GetDevCategory_Failed, "DevAdapter::GetDevCategory", __FUNCTION__, IsInBusiness(), ullEnd - ullStart, GpioService_LogCode_GetDevInfo);
        }
        ctx->Answer(Error_Succeed);
    }
}

//老接口，用于控制灯
bool CGpioEntity::SetOutDriving(GpioService_Set_Info req, OutDrivingInfo od, ULONG iIndex, ULONG pinSeq)
{
    if (req.close == 1) {
        GetFunction()->KillTimer(req.devseq);

        //oilyang add 20161222
        //如果关闭照明灯，以感知为准
        if (pinSeq == m_headlightDevPort)
            WritePin(pinSeq, m_bHeadLightFlag);
        else {
            if (pinSeq == PIN_HSPSCANNER_PREVIEW_LIGHT) {
                //额外多关闭高拍仪提示灯
                DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("off light hspsanner.");
                WritePin(PIN_HSPSCANNER_LIGHT, false);
            }
            WritePin(pinSeq, false);
        }
        return true;
    }

    switch (od.OutputMode) {
    case OM_POSITIVE_LEVEL:
    {
		if (od.StopMode == SM_CALLTRIGGER) {
			DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("0.0 mode: pinSeq=%u", pinSeq);
			//if it is hspsanner
			if (pinSeq == PIN_HSPSCANNER_PREVIEW_LIGHT) {
				DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("light hspsanner.");
				WritePin(PIN_HSPSCANNER_LIGHT, true);
			}
			WritePin(pinSeq, true);
		}
    }
    break;
    case OM_POSITIVE_FLICKER:
        if (od.StopMode == SM_CYCLE) {
			SetContextInfo* pSci = new SetContextInfo();
			pSci->pinSeq = pinSeq;
			pSci->timerID = req.devseq;
			pSci->setTime = od.SetTime;
			pSci->resetTime = od.ResetTime;
			pSci->timeout = od.TimeOut;

			WritePin(pinSeq, true);

			ITimerListener* pListener = new TimerOutHelper<CGpioEntity>(this, &CGpioEntity::OnPositiveFlickerSetTimerout, pSci, true);
			GetFunction()->SetTimer(pSci->timerID, pListener, pSci->setTime);
        }
        break;
    default:
        break;
    }
    return true;
}

void CGpioEntity::OnEventDetect(void* pData)
{
	GetContextInfo* pGci = (GetContextInfo*)pData;

	ULONG input = 0;
	BYTE btInput;
	ErrorCodeEnum err(Error_Succeed);
	if (!m_bFuncVer2) {
		const auto iBegin = SP::Module::Comm::RVCGetTickCount();
		err = m_hDevHelper->ReadPort(INPUT_PORT_2, btInput);
		const auto iEnd = SP::Module::Comm::RVCGetTickCount();
		if (err != Error_Succeed) {
			SetErrorAndLog(err, GPIO_UserErrorCode_ReadPort_Failed, "DevAdapter::ReadPort", __FUNCTION__, false, iEnd - iBegin, "",
				CombineJsonContext(CSimpleStringA::Format("read port[%d] with %d", INPUT_PORT_2, btInput)));
		}
		else if(btInput != m_btLastRevcInput){
			m_btLastRevcInput = btInput;
			LogPinStatus(btInput);
		}
	}
	else {
#if defined(RVC_OS_LINUX)
		DWORD dwReq(GPIO_DEV_SN_LIGHT_SENSOR_ALL);
		DWORD dwMode = 0;
		const auto iBegin = SP::Module::Comm::RVCGetTickCount();
		err = m_hDevHelper->DetectStatus(dwReq, dwMode);
		const auto iEnd = SP::Module::Comm::RVCGetTickCount();
		btInput = dwMode;
		if (err != Error_Succeed) {
			SetErrorAndLog(err, GPIO_UserErrorCode_DetectStatus_Failed, "DevAdapter::DetectStatus", __FUNCTION__, false, iEnd - iBegin, "",
				CombineJsonContext(CSimpleStringA::Format("detect status[%d] with %d", dwReq, dwMode)));
		}
		else if (btInput != m_btLastRevcInput) {
			m_btLastRevcInput = btInput;
			LogPinStatus(btInput);
		}
#else
		err = Error_NotSupport;
#endif //RVC_OS_LINUX
	}
	if (err != Error_Succeed) {
		m_btLastRevcInput = (BYTE)(-1);
		GetFunction()->ResetTimer(pGci->timerID, ON_EVENT_DETECT_TIMOUE_MILLSECS);
		return;
	}
	/** 震动感应 */
	if (DetectBit(btInput, VIBRATIONSENSOR) && !m_bVibrationFlag) {
		m_bVibrationFlag = true;
		LogEvent(Severity_Middle, LOG_EVT_VIBRATIONSENSOR, CSimpleStringA::Format("%s [Active] line: %d", GetDriverPortString(17), __LINE__));
	} else if (!DetectBit(btInput, VIBRATIONSENSOR) && m_bVibrationFlag) {
		LogEvent(Severity_Middle, LOG_EVT_VIBRATIONSENSOR_OFF, CSimpleStringA::Format("%s [InActive] line: %d", GetDriverPortString(17), __LINE__));
		m_bVibrationFlag = false;
	}

	/** 机箱门开关检测*/
	if (DetectBit(btInput, OPENSENSOR) && !m_bOpenFlag) {
		m_bOpenFlag = true;
		m_DoorOpenTimeStamp = SP::Module::Comm::RVCGetTickCount();
		LogEvent(Severity_Middle, LOG_EVT_OPENSENSOR_ON, CSimpleStringA::Format("%s [Active] line: %d", GetDriverPortString(18), __LINE__));
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode(GpioService_LogCode_Detect_DoorOpen)("[GPIO] The chassis door is open");
	}
	else if (!DetectBit(btInput, OPENSENSOR) && m_bOpenFlag) {
		m_bOpenFlag = false;
		m_DoorCloseTimeStamp = SP::Module::Comm::RVCGetTickCount();
		LogEvent(Severity_Middle, LOG_EVT_OPENSENSOR_OFF, CSimpleStringA::Format("%s [InActive] line: %d", GetDriverPortString(18), __LINE__));
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode(GpioService_LogCode_Detect_DoorClose).setCostTime(m_DoorCloseTimeStamp-m_DoorOpenTimeStamp)("[GPIO] The chassis door is close");
	}

	/**话机检测*/
	if (DetectBit(btInput, PICKUPSENSOR)) {
		if (m_ePickUpFlag == InActive) {
			m_ePickUpFlag = Actived;
			m_PickUpTimeStamp = SP::Module::Comm::RVCGetTickCount();
			LogEvent(Severity_Middle, LOG_EVT_PICKUP, "Life the Phone up");
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode(GpioService_LogCode_Detect_PhonePickup)("[GPIO] 话机提起");
		}
		else if (m_ePickUpFlag == UnknownStatus) {
			m_ePickUpFlag = Actived;
			m_PickUpTimeStamp = SP::Module::Comm::RVCGetTickCount();
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode(GpioService_LogCode_Detect_PhonePickup)("[GPIO] 话机提起（启动时）");
		}
	} else if (!DetectBit(btInput, PICKUPSENSOR)) {
		if (m_ePickUpFlag == Actived) {
			m_ePickUpFlag = InActive;
			m_PutDownTimeStamp = SP::Module::Comm::RVCGetTickCount();
			LogEvent(Severity_Middle, LOG_EVT_ONHOOK, "Put the Phone down");
			DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode(GpioService_LogCode_Detect_PhonePutDown).setCostTime(m_PutDownTimeStamp - m_PickUpTimeStamp)("话机放下");
		}
		else if (m_ePickUpFlag == UnknownStatus) {
			m_ePickUpFlag = InActive;
			m_PutDownTimeStamp = SP::Module::Comm::RVCGetTickCount();
		}
	}
	/*物体靠近感知检测*/
	if (DetectBit(btInput, MOVESENSOR)) {
		if (!m_bMoveFlag) {
			m_bMoveFlag = true;
			m_moveDisappearTimes = 0;
			LogEvent(Severity_Middle, LOG_EVT_MOVESENSOR_ON, CSimpleStringA::Format("%s [Active] line: %d, times: %lu", GetDriverPortString(20), __LINE__, m_moveHoldTimes));
		}
		/** 只是发一次时间时，发现感知实体没有收到或者不处理第一次发出的时间，所以需要沿用原有的发送频率，再继续发送消失的事件，下同  [Gifur@202496]*/
		else if(m_moveHoldTimes != 0 && (m_moveHoldTimes % (REPEAT_FIRE_TIMEOUT_VALUE / ON_EVENT_DETECT_TIMOUE_MILLSECS))== 0){
			LogEvent(Severity_Middle, LOG_EVT_MOVESENSOR_ON, CSimpleStringA::Format("%s [Active] line: %d, times: %lu", GetDriverPortString(20), __LINE__, m_moveHoldTimes));
		}
		const bool toCheck = !!(m_moveHoldTimes != 0 && (m_moveHoldTimes % (8/*mins*/ * 60 * 1000 / ON_EVENT_DETECT_TIMOUE_MILLSECS) == 0));
		if (toCheck) {
			SYSTEMTIME localTime;
			GetLocalTime(&localTime);
			if (localTime.wHour < (WORD)8 || (localTime.wHour == 8 && localTime.wMinute <= (WORD)30) || localTime.wHour >= (WORD)18)
			{
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA2903")("Move detect is abnormal(off work).");
				LogWarn(Severity_High, Error_Unexpect, LOG_EVT_MOVEDETECT_ABNORMAL_OFFWORK, "Move detect is abnormal(off work).");
			}
			else {
				DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM).setResultCode("RTA2902")("Move detect is abnormal(Work time).");
				LogWarn(Severity_High, Error_Unexpect, LOG_EVT_MOVEDETECT_ABNORMAL_WORKTIME, "Move detect is abnormal(Work time).");
			}
		}
		m_moveHoldTimes++;
	}
	else if (!DetectBit(btInput, MOVESENSOR)) {
		if (m_bMoveFlag) {
			m_bMoveFlag = false;
			m_moveHoldTimes = 0;
			LogEvent(Severity_Middle, LOG_EVT_MOVESENSOR_OFF, CSimpleStringA::Format("%s [InActive] line: %d", GetDriverPortString(20), __LINE__));
		} 
		else if (m_moveDisappearTimes != 0 && (m_moveDisappearTimes % (REPEAT_FIRE_TIMEOUT_VALUE / ON_EVENT_DETECT_TIMOUE_MILLSECS)) == 0){
			LogEvent(Severity_Middle, LOG_EVT_MOVESENSOR_OFF, CSimpleStringA::Format("%s [InActive] line: %d", GetDriverPortString(20), __LINE__));
		}
		m_moveDisappearTimes++;
	}
	/*卡嘴异物检测*/
	if (DetectBit(btInput, CARDGATESENSOR) && !m_bCardGateFlag) {
		m_bCardGateFlag = true;
		LogEvent(Severity_Middle, LOG_EVT_CARDGATESENSOR, CSimpleStringA::Format("%s [Active] line: %d", GetDriverPortString(21), __LINE__));
		DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_USER).setLogCode(GpioService_LogCode_Detect_CardMouseJam)("[GPIO] The card mouse is jam");
	}
	else if (!DetectBit(btInput, CARDGATESENSOR) && m_bCardGateFlag) {
		LogEvent(Severity_Middle, LOG_EVT_CARDGATESENSOR_OFF, CSimpleStringA::Format("%s [InActive] line: %d", GetDriverPortString(21), __LINE__));
		m_bCardGateFlag = false;
	}

	GetFunction()->ResetTimer(pGci->timerID, ON_EVENT_DETECT_TIMOUE_MILLSECS);
}

SP_BEGIN_ENTITY_MAP()
	SP_ENTITY(CGpioEntity)
SP_END_ENTITY_MAP()