PhysicalDevice/Detector/CCOS.Dev.FPDDeviceMould/CCOS.Dev.FPD.CtrlUnit.cpp

// CCOS.Dev.FPD.DEMO.cpp : 定义 DLL 应用程序的导出函数。
//

#include "CCOS.Dev.FPDDeviceMould.hpp"
#include "LogLocalHelper.h"       
#include "Log4CPP.h"

using namespace CCOS::Dev;
using namespace CCOS::Dev::Detail::Detector;
namespace nsFPD = CCOS::Dev::Detail::Detector;

//extern Log4CPP::Logger* mLog::gLogger;

//-----------------------------------------------------------------------------
//		CtrlUnit
//-----------------------------------------------------------------------------
nsFPD::DetectorCtrlUnit::DetectorCtrlUnit()
{
	m_DetectorStatus = DETECTOR_STATUS_MAX;
	m_DetectorConnectStatus = PANEL_CONNECT_ERROR;
	m_strUpdateFWStatus = "4";
	m_strInitialStatus = "3";
	m_strAttachStatus = "0";
	m_strAttachResult = "0";
	m_strShockSensor = "";

	ResDataObject ResRecoverImageState;
	ResRecoverImageState.add("DetectorName", "FPD");
	ResRecoverImageState.add("DetectorSN", "01");
	ResRecoverImageState.add("DetectorWifiSignal", "1");
	ResRecoverImageState.add("Result", "-1");
	m_strRecoverImageState = ResRecoverImageState.encode();

	m_strRecoverImageEvent = "0";

	m_strFieldofViewShape = "RECTANGLE";
	m_strFieldofViewDimension = "RECTANGLE";
	m_strDetectorType = "ZSKK";
	m_strDescription = "FPD";
	m_strDetectorID = "0";
	m_strDateofLastDetectorCalibration = " ";
	m_strTimeofLastDetectorCalibration = " ";
	m_strDetectorConditionsNominalFlag = "1";
	m_strFPDSensitivity = "600";
	m_strFPDSensitivityResult = "0";
	m_strPixelData = "140";
	m_strTargetEXI = "5000";
	m_strFirmwareStatus = "4";
	m_strSupportDDR = "YES";
	m_strDetectorWidth = "";
	m_strDetectorHeight = "";
	m_strDetectorWiredIP = "";
	m_strDetectorWirelessIP = "";
	m_strLocalIP = "";
	m_strSerialNumber = "";
	m_strShowTemperature = "1";
	m_strShowWifi = "1";
	m_strShowBattery = "1";
	m_strShowBluetooth = "0";
	m_strSupportSwitchResolution = "0";
	m_strCurrentResolution = "0";
}

nsFPD::DetectorCtrlUnit:: ~DetectorCtrlUnit()
{

}

void OEM_IF nsFPD::DetectorCtrlUnit::SetEventCenter(std::shared_ptr <CCOS::Dev::IOEventCenter>  EventCenter)
{
	m_EventCenter = EventCenter;
}


RET_STATUS nsFPD::DetectorCtrlUnit::JSActiveDetector(std::string in, std::string & out)
{
	ResDataObject json;
	json.decode(in.c_str());
	bool bActive = false;
	try
	{
		bActive = (bool)json[0];
	}
	catch (...)
	{
		return RET_STATUS::RET_FAILED;
	}

	FINFO("JSActiveDetector. {$}", in.c_str());
	ActiveDetector(bActive);
	out = "test@ActiveDetector";
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSWakeupDetector(std::string in, std::string & out)
{
	FINFO("JSWakeupDetector. {$}", in.c_str());
	out = "test@WakeupDetector";
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSRESET(std::string in, std::string& out)
{
	FINFO("JSRESET");
	RESET();
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS CCOS::Dev::Detail::Detector::DetectorCtrlUnit::JSScanDetector(std::string in, std::string& out)
{
	string strDetectorInfo;

	RET_STATUS nRet = ScanDetector(strDetectorInfo);
	out = strDetectorInfo;
	return nRet;
}

RET_STATUS CCOS::Dev::Detail::Detector::DetectorCtrlUnit::JSConnectDetector(std::string in, std::string& out)
{
	return RET_STATUS();
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSEnterExam(std::string in, std::string & out)
{
	ResDataObject json;
	json.decode(in.c_str());
	int mode = 0;
	try
	{
		mode = (int)json[0];
	}
	catch (...)
	{
		return RET_STATUS::RET_FAILED;
	}
	FINFO("JSEnterExam.{$}", in.c_str());
	EnterExam(mode);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSExitExam(std::string in, std::string& out)
{
	FINFO("JSExitExam.");
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSAttachConnect(std::string in, std::string& out)
{
	FINFO("JSAttachConnect.");
	AttachConnect();
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSCancelAttach(std::string in, std::string& out)
{
	FINFO("JSCancelAttach.");
	CancelAttach();
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSGetConnectStatus(std::string & out)
{
	FINFO("JSGetConnectStatus.");
	out = to_string(m_DetectorConnectStatus);
	return RET_STATUS::RET_SUCCEED;
}


RET_STATUS nsFPD::DetectorCtrlUnit::JSResetConnect(std::string in, std::string& out)
{
	FINFO("JSResetConnect.");
	ResetConnect();
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSDisConnectFPD(std::string in, std::string& out)
{
	FINFO("JSDisConnectFPD.");
	DisConnectFPD();
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSDisConnectFPDForce(std::string in, std::string& out)
{
	FINFO("JSDisConnectFPDForce.");
	DisConnectFPDForce();
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSUpdateFirmware(std::string in, std::string& out)
{
	FINFO("JSUpdateFirmware.");
	return UpdateFirmware();
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSGetDetectorInfo(std::string in, std::string & out)
{
	FINFO("JSGetDetectorInfo.");
	string strFPDinfo;
	GetDetectorInfo(strFPDinfo);

	out = strFPDinfo;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSGetRecoverImageState(std::string in, std::string & out)
{
	FINFO("JSGetRecoverImageState.");
	string strFPDinfo;
	GetRecoverImageState(strFPDinfo);

	out = strFPDinfo;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSRecoverImage(std::string in, std::string & out)
{
	ResDataObject json;
	json.decode(in.c_str());
	bool mode = false;
	try
	{
		mode = (bool)json[0];
	}
	catch (...)
	{
		FERROR("JSRecoverImage decode failed {$}", in.c_str());
		return RET_STATUS::RET_FAILED;
	}
	FINFO("JSRecoverImage. {$}",in.c_str());
	RecoverImage(mode);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSSaveSensitivity(std::string in, std::string& out)
{
	FINFO("JSSaveSensitivity.");
	SaveSensitivity();
	return RET_STATUS::RET_SUCCEED;
}


//动态探测器先采图，后出线。出线时调用这个接口告知探测器可以取曝光图像
RET_STATUS DetectorCtrlUnit::JSSetXrayOnNum(std::string in, std::string& out)
{
	FINFO("JSSetXrayOnNum.{$}",in.c_str());
	SetXrayOnNum();
	return RET_STATUS::RET_SUCCEED;
}


//告知探测器序列采集图像张数，停止采集时等图使用
RET_STATUS DetectorCtrlUnit::JSSetExposureTimes(std::string in, std::string& out)
{
	FINFO("JSSetExposureTimes.{$}", in.c_str());
	ResDataObject json;
	json.decode(in.c_str());
	int nTimes = 0;
	try {
		nTimes = (int)json[0];
	}
	catch (...)
	{
		return RET_STATUS::RET_FAILED;
	}
	SetExposureTimes(nTimes);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS OEM_IF nsFPD::DetectorCtrlUnit::SetConnectStatus(string in)
{
	FINFO("SetConnectStatus in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}

	int nConnectStatus = atoi(in.c_str());
	string strStatus = "Unknown";
	switch (nConnectStatus)
	{
	case PANEL_CONNECT_ERROR:
		strStatus = "PANEL_CONNECT_ERROR";
		break;
	case PANEL_ATTACH_START:
		strStatus = "PANEL_ATTACH_START";
		break;
	case PANEL_CONNECT_OK:
		strStatus = "PANEL_CONNECT_OK";
		break;
	case PANEL_DISCONNECT_SUCCESS:
		strStatus = "PANEL_DISCONNECT_SUCCESS";
		break;
	case PANEL_DISCONNECT_ERROR:
		strStatus = "PANEL_DISCONNECT_ERROR";
		break;
	case PANEL_ATTACH_OVER:
		strStatus = "PANEL_ATTACH_OVER";
		break;
	case PANEL_ATTACH_FAILED:
		strStatus = "PANEL_ATTACH_FAILED";
		break;
	case PANEL_ATTACH_FAILED_WITH_IMG:
		strStatus = "PANEL_ATTACH_FAILED_WITH_IMG";
		break;
	case PANEL_ATTACH_NULL:
		strStatus = "PANEL_ATTACH_NULL";
		break;
	default:
		break;
	}
	m_DetectorConnectStatus = (DETECTOR_SHARE_STATUS)nConnectStatus;
	FINFO("DetectorConnectStatus: {$}", strStatus);
	m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::DetectorConnectStatus, in);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSGetFPDStatus(std::string & out)
{
	FINFO("JSGetFPDStatus");
	auto szFDinfo = std::to_string(m_DetectorStatus);
	out = szFDinfo;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS OEM_IF nsFPD::DetectorCtrlUnit::SetDetectorStatus(string in)
{
	FINFO("SetDetectorStatus in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}

	int nDetectorStatus = atoi(in.c_str());
	string strStatus = "Unknown";
	switch (nDetectorStatus)
	{
	case DETECTOR_STATUS_SHUTDOWN:
		strStatus = "Shutdown";
		break;
	case DETECTOR_STATUS_INIT:
		strStatus = "Init";
		break;
	case DETECTOR_STATUS_SLEEP:
		strStatus = "Sleep";
		break;
	case DETECTOR_STATUS_WAKEUP:
		strStatus = "WakeUp";
		break;
	case DETECTOR_STATUS_STANDBY:
		strStatus = "Standby";
		break;
	case DETECTOR_STATUS_ACQ:
		strStatus = "Acq";
		break;
	case DETECTOR_STATUS_ERROR:
		strStatus = "Error";
		break;
	case DETECTOR_STATUS_MAX:
		strStatus = "StatusMax";
		break;
	default:
		break;
	}
	m_DetectorStatus = (DETECTOR_STATUS)nDetectorStatus;

	FINFO("DetectorStatus: {$}", strStatus);
	m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::DetectorStatus, in);
	return RET_STATUS::RET_SUCCEED;
}

DETECTOR_STATUS OEM_IF nsFPD::DetectorCtrlUnit::GetDetectorStatus()
{
	return m_DetectorStatus;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSGetAttachResult(std::string & out)
{
	FINFO("JSGetAttachResult");
	ResDataObject json;
	json.add(DetectorDescription, "test");
	json.add(DetectorSerialNumber, "987");

	m_strAttachResult = json.encode();
	out = m_strAttachResult;
	return RET_STATUS::RET_SUCCEED;
}

//服务没用过这个
RET_STATUS OEM_IF nsFPD::DetectorCtrlUnit::SetAttachResult(string in)
{
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}
	/*ResDataObject json;
	json.add(DetectorDescription, DetectorType);
	json.add(DetectorSerialNumber, DetectorSN);
	json.add("IsNewSN", result);

	m_strAttachResult = json.encode();

	m_EventCenter->OnNotify((int)ATTRACTION_MSG, AttrKey::DetectorAttach, m_strAttachResult);*/

	return RET_STATUS::RET_SUCCEED; 
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSGetAttachStatus(std::string & out)
{
	FINFO("JSGetAttachStatus");
	out = m_strAttachStatus;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS OEM_IF nsFPD::DetectorCtrlUnit::SetAttachStatus(string in)
{
	FINFO("SetAttachStatus in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}
	m_strAttachStatus = in;
	m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::FPDAttached, m_strAttachStatus);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSGetInitialStatus(std::string & out)
{
	FINFO("JSGetInitialStatus");
	out = m_strInitialStatus;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS OEM_IF nsFPD::DetectorCtrlUnit::SetInitialStatus(string in)
{
	FINFO("SetInitialStatus in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}
	m_strInitialStatus = in;
	m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::DetectorInitialStatus, m_strInitialStatus);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSGetUpdateFWStatus(std::string & out)
{
	FINFO("JSGetUpdateFWStatus");
	out = m_strUpdateFWStatus;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS OEM_IF nsFPD::DetectorCtrlUnit::SetUpdateFWStatus(string in)
{
	FINFO("SetUpdateFWStatus in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}
	m_strUpdateFWStatus = in;
	m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::DetectorUpdateFWStatus, m_strUpdateFWStatus);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS OEM_IF nsFPD::DetectorCtrlUnit::SetShockSensorInfo(string in)
{
	FINFO("SetShockSensorInfo in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}

	m_strShockSensor = in;
	m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::FPDShockSensorInfo, m_strShockSensor);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSGetShockSensorInfo(std::string & out)
{
	out = m_strShockSensor;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS OEM_IF nsFPD::DetectorCtrlUnit::SetRecoverImageState(string in)
{
	FINFO("SetRecoverImageState in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}

	m_strRecoverImageState = in;
	m_EventCenter->OnNotify((int)ATTRACTION_SET, "RecoverImageState", m_strRecoverImageState);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSGetRecoverImageState(std::string& out)
{
	out = m_strRecoverImageState;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS OEM_IF nsFPD::DetectorCtrlUnit::SetRecoverImageEvent(string in)
{
	FINFO("SetRecoverImageEvent in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}

	m_strRecoverImageEvent = in;
	m_EventCenter->OnNotify((int)ATTRACTION_MSG, "RecoverImageEvent", m_strRecoverImageEvent);
	return RET_STATUS::RET_SUCCEED;
}
RET_STATUS nsFPD::DetectorCtrlUnit::JSGetRecoverImageEvent(std::string& out)
{
	out = m_strRecoverImageEvent;

	return RET_STATUS::RET_SUCCEED;
}


RET_STATUS OEM_IF nsFPD::DetectorCtrlUnit::SetFieldofViewShape(string in)
{
	FINFO("SetFieldofViewShape in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}

	m_strFieldofViewShape = in;
	m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::FieldofViewShape, m_strFieldofViewShape);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSGetFieldofViewShape(std::string & out)
{
	out = m_strFieldofViewShape;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS OEM_IF nsFPD::DetectorCtrlUnit::SetFieldofViewDimension(string in)
{
	FINFO("SetFieldofViewDimension in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}

	m_strFieldofViewDimension = in;
	m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::FieldofViewDimension, m_strFieldofViewDimension);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSGetFieldofViewDimension(std::string & out)
{
	out = m_strFieldofViewDimension;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS OEM_IF nsFPD::DetectorCtrlUnit::SetDetectorType(string in)
{
	FINFO("SetDetectorType in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}

	m_strDetectorType = in;
	m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::DetectorType, m_strDetectorType);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSGetDetectorType(std::string & out)
{
	out = m_strDetectorType;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS OEM_IF nsFPD::DetectorCtrlUnit::SetDescription(string in)
{
	FINFO("SetDescription in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}

	m_strDescription = in;
	m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::Description, m_strDescription);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSGetDescription(std::string & out)
{
	out = m_strDescription;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS OEM_IF nsFPD::DetectorCtrlUnit::SetDetectorID(string in)
{
	FINFO("SetDetectorID in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}

	m_strDetectorID = in;
	m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::DetectorID, m_strDetectorID);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSGetDetectorID(std::string & out)
{
	out = m_strDetectorID;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS OEM_IF nsFPD::DetectorCtrlUnit::SetDateofLastDetectorCalibration(string in)
{
	FINFO("SetDateofLastDetectorCalibration in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}

	m_strDateofLastDetectorCalibration = in;
	m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::DateofLastDetectorCalibration, m_strDateofLastDetectorCalibration);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSGetDateofLastDetectorCalibration(std::string & out)
{
	out = m_strDateofLastDetectorCalibration;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS OEM_IF nsFPD::DetectorCtrlUnit::SetTimeofLastDetectorCalibration(string in)
{
	FINFO("SetTimeofLastDetectorCalibration in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}

	m_strTimeofLastDetectorCalibration = in;
	m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::TimeofLastDetectorCalibration, m_strTimeofLastDetectorCalibration);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSGetTimeofLastDetectorCalibration(std::string & out)
{
	out = m_strTimeofLastDetectorCalibration;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS OEM_IF nsFPD::DetectorCtrlUnit::SetDetectorConditionsNominalFlag(string in)
{
	FINFO("SetDetectorConditionsNominalFlag in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}

	m_strDetectorConditionsNominalFlag = in;
	m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::DetectorConditionsNominalFlag, m_strDetectorConditionsNominalFlag);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSGetDetectorConditionsNominalFlag(std::string & out)
{
	out = m_strDetectorConditionsNominalFlag;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS OEM_IF nsFPD::DetectorCtrlUnit::SetFPDSensitivity(string in)
{
	FINFO("SetFPDSensitivity in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}

	m_strFPDSensitivity = in;
	m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::FPDSensitivity, m_strFPDSensitivity);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS OEM_IF nsFPD::DetectorCtrlUnit::SetFPDSensitivityResult(string in)
{
	FINFO("SetFPDSensitivityResult in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}

	m_strFPDSensitivityResult = in;
	m_EventCenter->OnNotify((int)ATTRACTION_SET, "FPDSensitivityResult", m_strFPDSensitivityResult);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSGetFPDSensitivityResult(std::string& out)
{
	out = m_strFPDSensitivityResult;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSGetFPDSensitivity(std::string & out)
{
	out = m_strFPDSensitivity;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS OEM_IF nsFPD::DetectorCtrlUnit::SetPixelData(string in)
{
	FINFO("SetPixelData in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}

	m_strPixelData = in;
	m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::PixelData, m_strPixelData);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSGetPixelData(std::string & out)
{
	out = m_strPixelData;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS OEM_IF nsFPD::DetectorCtrlUnit::SetTargetEXI(string in)
{
	FINFO("SetTargetEXI in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}

	m_strTargetEXI = in;
	m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::TargetEXI, m_strTargetEXI);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSGetTargetEXI(std::string & out)
{
	out = m_strTargetEXI;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSGetSupportDDR(std::string& out)
{
	if (m_strSupportDDR == "YES" || m_strSupportDDR == "1")
	{
		out = "YES";
	}
	else 
	{
		out = "NO";
	}
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::SetSupportDDR(string in)
{
	FINFO("SetSupportDDR in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}
	m_strSupportDDR = in;
	m_EventCenter->OnNotify((int)ATTRACTION_SET, SupportDDR, m_strSupportDDR);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSGetSupportSwitchResolution(std::string& out)
{
	FINFO("JSGetSupportSwitchResolution m_strSupportSwitchResolution:{$}", m_strSupportSwitchResolution);
	if (m_strSupportSwitchResolution == "1")
	{
		out = "1";
	}
	else
	{
		out = "0";
	}
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::SetSupportSwitchResolution(string in)
{
	FINFO("SetSupportSwitchResolution in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}
	m_strSupportSwitchResolution = in;
	m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::SupportSwitchResolution, m_strSupportSwitchResolution);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSGetCurrentResolution(std::string& out)
{
	out = m_strCurrentResolution;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::SetCurrentResolution(string in)
{
	FINFO("SetCurrentResolution in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}
	m_strCurrentResolution = in;
	m_EventCenter->OnNotify((int)ATTRACTION_SET, AttrKey::CurrentResolution, m_strCurrentResolution);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS OEM_IF nsFPD::DetectorCtrlUnit::SetLastError(string in)
{
	FINFO("SetLastError in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS OEM_IF nsFPD::DetectorCtrlUnit::JSGetLastError(std::string& out)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::ScanDetector(string& strDetectorInfo)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS DetectorCtrlUnit::RESET()
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS DetectorCtrlUnit::WakeupDetector()
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS DetectorCtrlUnit::ExitExam()
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS DetectorCtrlUnit::AttachConnect()
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS DetectorCtrlUnit::CancelAttach()
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS DetectorCtrlUnit::ResetConnect()
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS DetectorCtrlUnit::DisConnectFPD()
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS DetectorCtrlUnit::DisConnectFPDForce()
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS DetectorCtrlUnit::UpdateFirmware()
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS DetectorCtrlUnit::RecoverImage(bool bRecoverIt)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS DetectorCtrlUnit::GetRecoverImageState(string& strREI)
{
	strREI = "";
	return RET_STATUS::RET_FAILED;
}

RET_STATUS DetectorCtrlUnit::SaveSensitivity()
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS DetectorCtrlUnit::SetXrayOnNum()
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS DetectorCtrlUnit::SetExposureTimes(int nTimes)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS DetectorCtrlUnit::JSSetFilterType(std::string in, std::string& out)
{
	ResDataObject json;
	json.decode(in.c_str());
	int nValue = 0;
	try
	{
		nValue = atoi((const char*)json[0]);
	}
	catch (ResDataObjectExption& e)
	{
		FERROR("JSSetFilterType exception %s\n", e.what());
		return RET_STATUS::RET_FAILED;
	}
	SetFilterType(nValue);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS DetectorCtrlUnit::SetFilterType(int nFilter)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS OEM_IF nsFPD::DetectorCtrlUnit::SetFirmwareStatus(string in)
{
	FINFO("SetFirmwareStatus in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}
	m_strFirmwareStatus = in;
	m_EventCenter->OnNotify((int)ATTRACTION_SET, "FirmwareStatus", m_strFirmwareStatus);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSGetFirmwareStatus(std::string& out)
{
	out = m_strFirmwareStatus;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSSaveRawDataMode(std::string in, std::string& out)
{
	FINFO("JSSaveRawDataMode.\n{$}", in.c_str());
	ResDataObject jsonInput;
	jsonInput.decode(in.c_str());
	int nSaveRawDataMode = 0;
	try
	{
		nSaveRawDataMode = (int)jsonInput[0];
	}
	catch (...)
	{
		FERROR("Get SaveRawDataMode parameter error");
		return RET_STATUS::RET_FAILED;
	}
	RET_STATUS nRet = SaveRawDataMode(nSaveRawDataMode);
	out = "test@SaveRawDataMode";
	return nRet;
}

RET_STATUS nsFPD::DetectorCtrlUnit::SaveRawDataMode(int nSaveRawDataMode)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSOfflineFPD(std::string in, std::string& out)
{
	FINFO("JSOfflineFPD.\n{$}", in.c_str());
	ResDataObject jsonInput;
	jsonInput.decode(in.c_str());
	int nOfflineFPDMode = 0;
	try 
	{
		nOfflineFPDMode = (int)jsonInput[0];
	}
	catch (...)
	{
		FERROR("Get OfflineFPD parameter error");
		return RET_STATUS::RET_FAILED;
	}
	RET_STATUS nRet = OfflineFPD(nOfflineFPDMode);
	out = "test@OfflineFPD";
	return nRet;
}

RET_STATUS nsFPD::DetectorCtrlUnit::OfflineFPD(int nOfflineFPDMode)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSOnlineFPD(std::string in, std::string& out)
{
	FINFO("JSOnlineFPD.\n{$}", in.c_str());
	ResDataObject jsonInput;
	jsonInput.decode(in.c_str());
	int nOnlineFPDMode = 0;
	try
	{
		nOnlineFPDMode = (int)jsonInput[0];
	}
	catch (...)
	{
		FERROR("Get OnlineFPD parameter error");
		return RET_STATUS::RET_FAILED;
	}
	RET_STATUS nRet = OnlineFPD(nOnlineFPDMode);
	out = "test@OnlineFPD";
	return nRet;
}

RET_STATUS nsFPD::DetectorCtrlUnit::OnlineFPD(int nOnlineFPDMode)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSGetAutonumousImageList(std::string in, std::string& out)
{
	FINFO("JSGetAutonumousImageList.\n{$}", in.c_str());
	ResDataObject jsonInput;
	vector<string> vecAutonumousList;
	ResDataObject jsonAutonumousList;

	jsonInput.decode(in.c_str());
	int nDetectorID = 0;
	try
	{
		nDetectorID = (int)jsonInput[0];
	}
	catch (...)
	{
		FERROR("Get GetAutonumousImageList parameter error");
		return RET_STATUS::RET_FAILED;
	}
	RET_STATUS nRet = GetAutonumousImageList(nDetectorID, vecAutonumousList);
	size_t nPatientNum = vecAutonumousList.size();
	FINFO("Get patient number: {$}", nPatientNum);
	for (int i = 0; i < nPatientNum; ++i)
	{
		char tempKey[32];
		snprintf(tempKey, 32, "%d", i);
		jsonAutonumousList.add(tempKey, vecAutonumousList[i].c_str());
	}

	out = jsonAutonumousList.encode();
	FINFO("Out List.\n{$}", out.c_str());
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::GetAutonumousImageList(int nDetectorID, vector<string>& AutonumousList)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSRemoveAutonumousImageList(std::string in, std::string& out)
{
	FINFO("JSRemoveAutonumousImageList.\n{$}", in.c_str());
	ResDataObject jsonInput;
	jsonInput.decode(in.c_str());
	string strMeta;
	try
	{
		strMeta = (string)jsonInput[0];
	}
	catch (...)
	{
		FERROR("Get RemoveAutonumousImageList parameter error");
		return RET_STATUS::RET_FAILED;
	}
	RET_STATUS nRet = RemoveAutonumousImageList(strMeta);
	out = "test@RemoveAutonumousImageList";
	return nRet;
}

RET_STATUS nsFPD::DetectorCtrlUnit::RemoveAutonumousImageList(string strMeta)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSRemoveAutonumousAll(std::string in, std::string& out)
{
	FINFO("JSRemoveAutonumousAll.\n{$}", in.c_str());
	RET_STATUS nRet = RemoveAutonumousAll();
	out = "test@RemoveAutonumousAll";
	return nRet;
}

RET_STATUS nsFPD::DetectorCtrlUnit::RemoveAutonumousAll()
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSGetImageMetaData(std::string in, std::string& out)
{
	FINFO("JSGetImageMetaData.\n{$}", in.c_str());
	ResDataObject jsonInput;
	jsonInput.decode(in.c_str());
	string strMeta;
	try
	{
		strMeta = (string)jsonInput[0];
	}
	catch (...)
	{
		FERROR("Get GetImageMetaData parameter error");
		return RET_STATUS::RET_FAILED;
	}
	RET_STATUS nRet = GetImageMetaData(strMeta);
	out = "test@RemoveAutonumousImageList";
	return nRet;
}

RET_STATUS nsFPD::DetectorCtrlUnit::GetImageMetaData(string strMetaData)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSExportAutonumousAll(std::string in, std::string& out)
{
	FINFO("JSExportAutonumousAll.\n{$}", in.c_str());
	RET_STATUS nRet = ExportAutonumousAll();
	out = "test@ExportAutonumousAll";
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::ExportAutonumousAll()
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSGetDetectorWidth(std::string& out)
{
	out = m_strDetectorWidth;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS OEM_IF nsFPD::DetectorCtrlUnit::SetDetectorWidth(string in)
{
	FINFO("SetDetectorWidth in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}
	m_strDetectorWidth = in;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSGetDetectorHeight(std::string& out)
{
	out = m_strDetectorHeight;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS OEM_IF nsFPD::DetectorCtrlUnit::SetDetectorHeight(string in)
{
	FINFO("SetDetectorHeight in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}
	m_strDetectorHeight = in;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSUpdateNotifyStatusTimePeriod(std::string in, std::string& out)
{
	FINFO("JSUpdateNotifyStatusTimePeriod in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}
	int nTime = std::stoi(in);
	return UpdateNotifyStatusTimePeriod(nTime);
}

RET_STATUS nsFPD::DetectorCtrlUnit::UpdateNotifyStatusTimePeriod(int nTime)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSUpdateReconnectTimePeriod(std::string in, std::string& out)
{
	FINFO("JSUpdateReconnectTimePeriod in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}
	int nTime = std::stoi(in);
	return UpdateReconnectTimePeriod(nTime);
}

RET_STATUS nsFPD::DetectorCtrlUnit::UpdateReconnectTimePeriod(int nTime)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSUpdateDetectorWiredIP(std::string in, std::string& out)
{
	FINFO("JSUpdateDetectorWiredIP in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}
	if (UpdateDetectorWiredIP(in) == RET_STATUS::RET_SUCCEED)
	{
		m_strDetectorWiredIP = in;
	}
	else 
	{
		return RET_STATUS::RET_FAILED;
	}
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::UpdateDetectorWiredIP(string strWiredIP)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSUpdateDetectorWirelessIP(std::string in, std::string& out)
{
	FINFO("JSUpdateDetectorWirelessIP in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}
	if (UpdateDetectorWirelessIP(in) == RET_STATUS::RET_SUCCEED)
	{
		m_strDetectorWirelessIP = in;
	}
	else
	{
		return RET_STATUS::RET_FAILED;
	}
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::UpdateDetectorWirelessIP(string strWirelessIP)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSUpdateLocalIP(std::string in, std::string& out)
{
	FINFO("JSUpdateLocalIP in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}
	if (UpdateLocalIP(in) == RET_STATUS::RET_SUCCEED)
	{
		m_strLocalIP = in;
	}
	else
	{
		return RET_STATUS::RET_FAILED;
	}
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::UpdateLocalIP(string strLocalIP)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSGetDetectorWiredIP(std::string& out)
{
	out = m_strDetectorWiredIP;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS OEM_IF nsFPD::DetectorCtrlUnit::SetDetectorWiredIP(string in)
{
	FINFO("SetDetectorWiredIP in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}
	m_strDetectorWiredIP = in;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSGetDetectorWirelessIP(std::string& out)
{
	out = m_strDetectorWirelessIP;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS OEM_IF nsFPD::DetectorCtrlUnit::SetDetectorWirelessIP(string in)
{
	FINFO("SetDetectorWirelessIP in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}
	m_strDetectorWirelessIP = in;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSGetLocalIP(std::string& out)
{
	out = m_strLocalIP;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS OEM_IF nsFPD::DetectorCtrlUnit::SetLocalIP(string in)
{
	FINFO("SetLocalIP in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}
	m_strLocalIP = in;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSGetSerialNumber(std::string& out)
{
	out = m_strSerialNumber;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS OEM_IF nsFPD::DetectorCtrlUnit::SetSerialNumber(string in)
{
	FINFO("SetSerialNumber in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}
	m_strSerialNumber = in;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSUpdateSerialNumber(std::string in, std::string& out)
{
	FINFO("JSUpdateSerialNumber in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}
	m_strSerialNumber = in;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSGetShowTemperature(std::string& out)
{
	out = m_strShowTemperature;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS OEM_IF nsFPD::DetectorCtrlUnit::SetShowTemperature(string in)
{
	FINFO("SetShowTemperature in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}
	m_strShowTemperature = in;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSUpdateShowTemperature(std::string in, std::string& out)
{
	FINFO("JSUpdateShowTemperature in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}
	m_strShowTemperature = in;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSGetShowWifi(std::string& out)
{
	out = m_strShowWifi;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS OEM_IF nsFPD::DetectorCtrlUnit::SetShowWifi(string in)
{
	FINFO("SetShowWifi in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}
	m_strShowWifi = in;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSUpdateShowWifi(std::string in, std::string& out)
{
	FINFO("JSUpdateShowWifi in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}
	m_strShowWifi = in;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSGetShowBattery(std::string& out)
{
	out = m_strShowBattery;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS OEM_IF nsFPD::DetectorCtrlUnit::SetShowBattery(string in)
{
	FINFO("SetShowBattery in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}
	m_strShowBattery = in;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSUpdateShowBattery(std::string in, std::string& out)
{
	FINFO("JSUpdateShowBattery in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}
	m_strShowBattery = in;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSGetShowBluetooth(std::string& out)
{
	out = m_strShowBluetooth;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS OEM_IF nsFPD::DetectorCtrlUnit::SetShowBluetooth(string in)
{
	FINFO("SetShowBluetooth in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}
	m_strShowBluetooth = in;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSUpdateShowBluetooth(std::string in, std::string& out)
{
	FINFO("JSUpdateShowBluetooth in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}
	m_strShowBluetooth = in;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSFaultInjection(std::string in, std::string& out)
{
	FINFO("JSFaultInjection in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}
	return FaultInjection(in);
}

RET_STATUS nsFPD::DetectorCtrlUnit::FaultInjection(string strErrorCode)
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::DetectorCtrlUnit::JSEliminateFault(std::string in, std::string& out)
{
	FINFO("JSEliminateFault in:{$}", in);
	if (in == "")
	{
		return RET_STATUS::RET_FAILED;
	}
	return EliminateFault(in);
}

RET_STATUS nsFPD::DetectorCtrlUnit::EliminateFault(string strErrorCode)
{
	return RET_STATUS::RET_SUCCEED;
}