// CCOS.Dev.FPD.Sensview.cpp : 定义 DLL 的导出函数。
//

#include "stdafx.h"
#include <stdio.h>
#include <OleAuto.h>
#include <sys/stat.h>
#include "FileVersion.hpp"
#include "common_api.h"

#include "DICOMImageHeadKey.h"
#include "CCOS.Dev.FPD.Sensview.h"
#include "SensviewCtrl.h"


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

Log4CPP::Logger* gLogger = nullptr;

static nsFPD::SensviewDriver  gIODriver;

//-----------------------------------------------------------------------------
//		GetIODriver & CreateIODriver
//-----------------------------------------------------------------------------
extern "C"  CCOS::Dev::IODriver * __cdecl GetIODriver()		// 返回静态对象的引用, 调用者不能删除 !
{
	return &gIODriver;
}

extern "C"  CCOS::Dev::IODriver * __cdecl CreateIODriver()  // 返回新对象, 调用者必须自行删除此对象 !
{
	return new nsFPD::SensviewDriver();
}

//-----------------------------------------------------------------------------
//		SensviewDriver
//-----------------------------------------------------------------------------
nsFPD::SensviewDriver::SensviewDriver()
{
	dev = NULL;
	m_bConnect = false;
	m_pAttribute.reset(new ResDataObject());
	m_pDescription.reset(new ResDataObject());
}

nsFPD::SensviewDriver::~SensviewDriver()
{
	if (dev)
	{
		delete dev;
		dev = nullptr;
	}
	m_bConnect = false;
}


extern const char* g_szMouldPath;
void nsFPD::SensviewDriver::Prepare()
{
	string strWorkPath = GetProcessDirectory();
	string strLogPath = strWorkPath + DetectorLogPath; //GetProcessDirectory() + R"(\OEMDrivers\Detector\Conf\Log4CPP.Config.FPD.xml)";
	Log4CPP::GlobalContext::Map::Set(ZSKK::Utility::Hash("LogFileName"), "FPD.SensviewDF");
	auto rc = Log4CPP::LogManager::LoadConfigFile(strLogPath.c_str());
	gLogger = Log4CPP::LogManager::GetLogger("FPD.SensviewDF");

#ifdef _WIN64
	Force("------------------------ Version: {$} (64-bit) ------------------------", FileVersion(g_szMouldPath).GetVersionString());
#else
	Force("------------------------ Version: {$} (32-bit)------------------------", FileVersion(g_szMouldPath).GetVersionString());
#endif

	dev = new FPDDeviceSensview(EventCenter, m_ConfigFileName);
	Info("new FPDDeviceSensview over");
}

bool nsFPD::SensviewDriver::Connect()
{
	Info("SensviewDriver Connect");
	m_bConnect = true;
	return true;
}

void nsFPD::SensviewDriver::Disconnect()
{
	Info("SensviewDriver Disconnect");
	m_bConnect = false;
}

bool nsFPD::SensviewDriver::isConnected() const
{
	return m_bConnect;
}


auto nsFPD::SensviewDriver::CreateDevice(int index) -> std::unique_ptr <IODevice>
{
	Info("CreateDevice({$})", index);

	auto Driver = std::unique_ptr <IODevice>(new IODevice(dev));

	dev->CreateDevice();
	dev->Register();
	return Driver;
}


std::string nsFPD::SensviewDriver::DriverProbe()
{
	Info("nsFPD::SensviewDriver::Driver_Probe");
	ResDataObject r_config, HardwareInfo;
	if (r_config.loadFile(m_ConfigFileName.c_str()))
	{
		HardwareInfo.add("MajorID", r_config["CONFIGURATION"]["MajorID"]);
		HardwareInfo.add("MinorID", r_config["CONFIGURATION"]["MinorID"]);
		HardwareInfo.add("VendorID", r_config["CONFIGURATION"]["VendorID"]);
		HardwareInfo.add("ProductID", r_config["CONFIGURATION"]["ProductID"]);
		HardwareInfo.add("SerialID", r_config["CONFIGURATION"]["SerialID"]);
	}
	else
	{
		HardwareInfo.add("MajorID", "Detector");
		HardwareInfo.add("MinorID", "DF");
		HardwareInfo.add("VendorID", "FPD");
		HardwareInfo.add("ProductID", "FPD");
		HardwareInfo.add("SerialID", "Driver");
	}
	string ret = HardwareInfo.encode();
	return ret;
}

bool nsFPD::SensviewDriver::GetDeviceConfig(std::string& Cfg)
{
	Cfg = m_DeviceConfig.encode();

	Info("GetDeviceConfig over");

	return true;
}

bool nsFPD::SensviewDriver::SetDeviceConfig(std::string Cfg)
{
	Info("--Func-- SetDeviceConfig {$} ", Cfg.c_str());

	ResDataObject DeviceConfig;
	DeviceConfig.decode(Cfg.c_str());

	ResDataObject DescriptionTempEx;
	DescriptionTempEx = DeviceConfig["DeviceConfig"]["Attribute"];
	Info("Attribute:{$}", DescriptionTempEx.encode());

	bool bSaveFile = false; //true:重新保存配置文件
	string strAccess = "";
	for (int i = 0; i < DescriptionTempEx.size(); i++)
	{
		string strKey = DescriptionTempEx.GetKey(i);
		Info("{$}", strKey.c_str());
		try
		{
			if (m_pAttribute->GetFirstOf(strKey.c_str()) >= 0)
			{
				strAccess = (string)(*m_pDescription)[strKey.c_str()]["Access"];
				if ("rw" == strAccess)
				{
					//修改对应配置，在其他单元的配置项要同时调用其修改函数修改真实值
					//1. 修改内存中的值，用于给上层发消息
					(*m_pAttribute)[strKey.c_str()] = DescriptionTempEx[i];
					//2. 拿到Innerkey
					int nConfigInfoCount = (int)m_Configurations["ConfigToolInfo"].GetKeyCount("AttributeInfo");
					Info("ConfigInfo Count: {$}", nConfigInfoCount);
					string strTemp = ""; //存储AttributeKey
					for (int nInfoIndex = 0; nInfoIndex < nConfigInfoCount; nInfoIndex++)
					{
						strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeKey"];
						if (strTemp == strKey)
						{
							strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["InnerKey"];
							break;
						}
					}
					//3. 修改配置文件中的值
					if (SetDeviceConfigValue(m_Configurations, strTemp.c_str(), 1, DescriptionTempEx[i]))
					{
						bSaveFile = true;
					}
				}
				else
				{
					Info("{$} is not a RW configuration item", strKey.c_str());
				}
			}
			else
			{
				Warn("without this attribute {$}", strKey.c_str());
			}
		}
		catch (...)
		{
			Error("SetDriverConfig crashed");
			return false;
		}
	}

	if (bSaveFile)
	{
		//3. 重新保存配置文件
		SaveConfigFile(true);
	}
	Info("SetDriverConfig over");
	return true;
}

bool nsFPD::SensviewDriver::SaveConfigFile(bool bSendNotify)
{
	m_ConfigAll["CONFIGURATION"] = m_Configurations;

	m_ConfigAll.SaveFile(m_ConfigFileName.c_str());
	Info("SaveConfigFile over");
	return true;
}

bool nsFPD::SensviewDriver::GetDeviceConfigValue(ResDataObject config, const char* pInnerKey, int nPathID, string& strValue)
{
	strValue = "";
	string strTemp = pInnerKey;
	//Trace("Inner key: {$}", strTemp);
	if (1 == nPathID) //从DriverConfig路径下每个DPC自己的配置文件读取
	{
		if (WiredIP == strTemp || WirelessIP == strTemp || LocalIP == strTemp)
		{
			strValue = (string)config["connections"][pInnerKey];
		}
		else if (DetectorVender == strTemp || DetectorModel == strTemp ||
			DetectorDescription == strTemp || DetectorSerialNumber == strTemp)
		{
			strValue = (string)config[pInnerKey];
		}
		else if (SyncType == strTemp || FPDWorkStation == strTemp ||
			ImageWidth == strTemp || ImageHeight == strTemp)
		{
			strValue = (string)config["ModeTable"]["DetectorMode"][pInnerKey];
		}
		else if (TempMaxLimit == strTemp || ReConnect == strTemp ||
			TempUpperLimit == strTemp || TempLowerLimit == strTemp || "TempMinLimit" == strTemp ||
			BatLowerLimit == strTemp || BatMiniLimit == strTemp ||
			BatLowerLimitInCali == strTemp || WifiLowerLimit == strTemp ||
			WifiMiniLimit == strTemp || HighPowerTimeout == strTemp ||
			ShowTemperature == strTemp || ShowWifi == strTemp ||
			ShowBattery == strTemp || ShowBluetooth == strTemp ||
			FPDExamMode == strTemp || FPDAcqMode == strTemp || FPDModeMatch == strTemp || "Attached" == strTemp)
		{
			strValue = (string)config[pInnerKey];
		}
		else
		{
			strValue = "";
			Warn("Error Configuration item: {$}", pInnerKey);
		}
	}
	return true;
}


/***
** 说明: 设置配置文件内容
***/
bool nsFPD::SensviewDriver::SetDeviceConfigValue(ResDataObject& config, const char* pInnerKey, int nPathID, const char* szValue)
{
	string strTemp = pInnerKey;
	Trace("Begin to change {$} item value to {$}", pInnerKey, szValue);
	if (1 == nPathID) //从DriverConfig路径下每个DPC自己的配置文件读取
	{
		if (WiredIP == strTemp || WirelessIP == strTemp || LocalIP == strTemp)
		{
			config["connections"][pInnerKey] = szValue;
		}
		else if (DetectorVender == strTemp || DetectorModel == strTemp ||
			DetectorDescription == strTemp || DetectorSerialNumber == strTemp)
		{
			config[pInnerKey] = szValue;
		}
		else if (SyncType == strTemp || FPDWorkStation == strTemp ||
			ImageWidth == strTemp || ImageHeight == strTemp)
		{
			config["ModeTable"]["DetectorMode"][pInnerKey] = szValue;
		}
		else if (TempMaxLimit == strTemp || ReConnect == strTemp ||
			TempUpperLimit == strTemp || TempLowerLimit == strTemp ||
			BatLowerLimit == strTemp || BatMiniLimit == strTemp ||
			BatLowerLimitInCali == strTemp || WifiLowerLimit == strTemp ||
			WifiMiniLimit == strTemp || HighPowerTimeout == strTemp ||
			ShowTemperature == strTemp || ShowWifi == strTemp ||
			ShowBattery == strTemp || ShowBluetooth == strTemp ||
			FPDExamMode == strTemp || FPDAcqMode == strTemp || FPDModeMatch == strTemp)
		{
			config[pInnerKey] = szValue;
		}
		else
		{
			Warn("Error Configuration item: {$}", pInnerKey);
			return false;
		}
	}


	return true;
}

std::string nsFPD::SensviewDriver::GetResource()
{
	ResDataObject r_config, temp;
	if (!temp.loadFile(m_ConfigFileName.c_str()))
	{
		return "";
	}

	m_ConfigAll = temp;

	r_config = temp["CONFIGURATION"];
	m_Configurations = r_config;

	ResDataObject DescriptionTemp;
	ResDataObject ListTemp;
	string strTemp = ""; //用于读取字符串配置信息
	string strIndex = ""; //用于读取配置信息中的List项
	int nTemp = -1; //用于读取整型配置信息
	char sstream[10] = { 0 }; //用于转换值
	string strValue = ""; //用于存储配置的值
	string strType = ""; //用于存储配置的类型 int/float/string...

	/***
	* 1. 通过循环，将所有配置项写到pDeviceConfig
	* 2. 记录配置项的内部key以及配置类型，类型对应了不同配置文件路径，用于读写真实值
	***/
	try
	{
		int nConfigInfoCount = (int)m_Configurations["ConfigToolInfo"].GetKeyCount("AttributeInfo");
		//Trace(g_pFPDCtrlLog, "ConfigInfo Count: {$}", nConfigInfoCount);
		m_pAttribute->clear();
		m_pDescription->clear();
		for (int nInfoIndex = 0; nInfoIndex < nConfigInfoCount; nInfoIndex++)
		{
			DescriptionTemp.clear();
			ListTemp.clear();
			//AttributeType
			strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeDescripition"]["Type"];
			DescriptionTemp.add(AttributeType, strTemp.c_str());
			//Trace(g_pFPDCtrlLog, "--> {$}: {$}", AttributeType, strTemp.c_str());
			strType = strTemp; //记录配置项的类型

			//AttributeKey
			//1. 根据AttributeType，内部key和配置路径，拿到当前的真实值
			strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["InnerKey"];
			nTemp = (int)m_Configurations["ConfigToolInfo"][nInfoIndex]["PathID"];
			GetDeviceConfigValue(r_config, strTemp.c_str(), nTemp, strValue);
			//2. 赋值
			strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeKey"];
			if ("int" == strType)
			{
				(*m_pAttribute).add(strTemp.c_str(), atoi(strValue.c_str()));
				//Trace(g_pFPDCtrlLog, "Key {$}: {$}", strTemp.c_str(), atoi(strValue.c_str()));
			}
			else if ("float" == strType)
			{
				(*m_pAttribute).add(strTemp.c_str(), atof(strValue.c_str()));
				//Trace(g_pFPDCtrlLog, "Key {$}: {$}", strTemp.c_str(), atof(strValue.c_str()));
			}
			else //其它先按string类型处理
			{
				(*m_pAttribute).add(strTemp.c_str(), strValue.c_str());
				//Trace(g_pFPDCtrlLog, "Key {$}: {$}", strTemp.c_str(), strValue.c_str());
			}

			//AttributeAccess
			strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeDescripition"]["Access"];
			DescriptionTemp.add(AttributeAccess, strTemp.c_str());
			//Trace(g_pFPDCtrlLog, "{$}: {$}", AttributeAccess, strTemp.c_str());

			//AttributeRangeMin
			strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeDescripition"]["RangeMin"];
			if (strTemp != "") //不需要的配置项为空
			{
				DescriptionTemp.add(AttributeRangeMin, strTemp.c_str());
				//Trace(g_pFPDCtrlLog, "{$}: {$}", AttributeRangeMin, strTemp.c_str());
			}

			//AttributeRangeMax
			strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeDescripition"]["RangeMax"];
			if (strTemp != "") //不需要的配置项为空
			{
				DescriptionTemp.add(AttributeRangeMax, strTemp.c_str());
				//Trace(g_pFPDCtrlLog, "{$}: {$}", AttributeRangeMax, strTemp.c_str());
			}

			//AttributeList
			nTemp = m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeDescripition"]["ListNum"];
			if (nTemp > 0) //ListNum不大于0时说明不需要list配置
			{
				for (int nListIndex = 0; nListIndex < nTemp; nListIndex++)
				{
					strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeDescripition"]["ListInfo"][nListIndex];
					sprintf_s(sstream, "%d", nListIndex);
					ListTemp.add(sstream, strTemp.c_str());
					//Trace(g_pFPDCtrlLog, "list {$}: {$}", nListIndex, strTemp.c_str());
				}
				DescriptionTemp.add(AttributeList, ListTemp);
			}

			//AttributeRequired
			strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeDescripition"]["Required"];
			DescriptionTemp.add(AttributeRequired, strTemp.c_str());
			//Trace(g_pFPDCtrlLog, "{$}: {$}", AttributeRequired, strTemp.c_str());

			//AttributeDefaultValue
			strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeDescripition"]["DefaultValue"];
			if (strTemp != "") //不需要的配置项为空
			{
				DescriptionTemp.add(AttributeDefaultValue, strTemp.c_str());
				//Trace(g_pFPDCtrlLog, "{$}: {$}", AttributeDefaultValue, strTemp.c_str());
			}

			strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeKey"];
			(*m_pDescription).add(strTemp.c_str(), DescriptionTemp);
		}
	}
	catch (exception e)
	{
		Error("Get config error: {$}", e.what());
		return "";
	}

	ResDataObject resDeviceResource;
	resDeviceResource.add(ConfKey::CcosDetectorAttribute, (*m_pAttribute));
	resDeviceResource.add(ConfKey::CcosDetectorDescription, (*m_pDescription));

	ResDataObject DescriptionTempEx;
	DescriptionTempEx.add(ConfKey::CcosDetectorConfig, resDeviceResource);

	m_DeviceConfig = DescriptionTempEx;

	string res = DescriptionTempEx.encode();

	return res;
}


std::string nsFPD::SensviewDriver::DeviceProbe()
{
	ResDataObject r_config, HardwareInfo;
	if (r_config.loadFile(m_ConfigFileName.c_str()))
	{
		HardwareInfo.add("MajorID", r_config["CONFIGURATION"]["MajorID"]);
		HardwareInfo.add("MinorID", "Device");
		HardwareInfo.add("VendorID", r_config["CONFIGURATION"]["VendorID"]);
		HardwareInfo.add("ProductID", r_config["CONFIGURATION"]["ProductID"]);
		HardwareInfo.add("SerialID", r_config["CONFIGURATION"]["SerialID"]);
	}
	else
	{
		HardwareInfo.add("MajorID", "Detector");
		HardwareInfo.add("MinorID", "Device");
		HardwareInfo.add("VendorID", "");
		HardwareInfo.add("ProductID", "");
		HardwareInfo.add("SerialID", "1234");
	}
	string ret = HardwareInfo.encode();
	return ret;
}


//---------------------------------------------------------------------------------------------------------------------

extern SensviewCtrl* g_pSensviewCtrl;
const float ABS_ZERO_TEMPERATURE = -273.15f; //绝对零度

nsFPD::FPDDeviceSensview::FPDDeviceSensview(std::shared_ptr <IOEventCenter> center, string ConfigPath)
	:m_strSDKPath(""),
	m_nDeviceIndex(0),
	m_eAppStatus(APP_STATUS_WORK_END),
	m_nGridLicense(0),
	m_strModuleIP(""),
	m_strShockSensor(""),
	m_strSelfTest(""),
	m_strLastError(""),
	m_bOpened(false),
	m_bBatteryCharging(false),
	m_bRecoveringImage(false),
	m_bAbortRecover(false),
	m_nBatteryCapacity(0),
	m_nBatteryCharges(0),
	m_nShockCounts(0),
	m_eWorkStation(WORK_STATION_NONE),
	m_fDoseParam(0),
	m_nRawImgWidth(0),
	m_nRawImgHeight(0),
	m_nFullImgWidth(0),
	m_nFullImgHeight(0),
	m_nTopOffset(0),
	m_nLeftOffset(0),
	m_nImageBits(0),
	m_fFactorEXI2UGY(0.0f),
	m_bPreviewEnable(false),
	m_fBatteryTemperature(0.0f),
	m_nXrayCalibNum(0),
	m_pwFullImageData(NULL),
	m_pwRawImageData(NULL),
	m_pwPreviewImg(NULL),
	m_pPreviewImageHead(NULL),
	m_pFullImageHead(NULL),
	m_pDetectors(NULL),
	m_bDisConnected(false),
	m_ExitEvt(NULL),
	m_bAttached(false),
	m_hNotifyThread(NULL),
	m_bRecoverImageStatusInit(false),
	m_bSaveRaw(false),
	m_bUIConfirmRecover(false),
	m_nCalibrationType(CCOS_CALIBRATION_TYPE_MAX),
	m_CalTemperlowWarn(0.0f),
	m_CalTemperupWarn(0.0f)
	, m_nCurrentMode(-1)
	, m_fCurrentPPS(0.0f)
{
	super::EventCenter = center;
	g_strAppPath = GetProcessDirectory() + "\\";

	m_AcqUnit.reset(new OemAcq(center, this));
	m_SyncUnit.reset(new OemSync(center, this));
	m_CalibUnit.reset(new OemCalib(center, this));
	m_DetectorCtrlUnit.reset(new OemCtrl(center, this));
	m_Battery.reset(new DeviceBatteryMould("Detector_Battery", 0, 10, 20, 30, 40, 100, 100, 0, center));
	m_Temperature.reset(new DeviceTemperatureMould("Detector_Temperature", ABS_ZERO_TEMPERATURE, 0.0f, 10.0f, 60.0f, 20.0f, 40.0f, 70.0f, 0.0f, center));
	m_Wifi.reset(new DeviceWifiMould("Detector_Wifi", 0, 20, 30, 40, 50, 100, 100, 0, center));

	m_DetectorConfiguration.reset(new DetectorConfiguration(ConfigPath));
	m_WarnAndError.reset(new FPDErrorWarning(center, DetectorUnitType, g_strAppPath));
	m_CalibProcess.reset(new CalibrationProcess());

	m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));
	m_CalibUnit->SetCalibrationStatus(to_string(CCOS_CALIBRATION_STATUS_STANDBY));

	m_WaitCalibDoseEvt = CreateEvent(0, 1, 0, 0);
	m_OffsetCalibrationEvt = CreateEvent(0, 0, 0, 0);
	m_PauseCalibrationEvt = CreateEvent(0, 1, 0, 0);
	m_CompleteCalibrationEvt = CreateEvent(0, 1, 0, 0);
	m_CrateCalibReportEvt = CreateEvent(0, 0, 0, 0);
	m_UploadCalibMapOver = CreateEvent(0, 1, 0, 0);
	m_ExitEvt = CreateEvent(0, 1, 0, 0);
	m_CalibGapEvt = CreateEvent(0, 1, 0, 0);
	m_WriteCumstomFileEvt = CreateEvent(0, 1, 0, 0);

	m_vAcqModeInfoList.clear();
}

nsFPD::FPDDeviceSensview::~FPDDeviceSensview()
{
	SetEvent(m_ExitEvt);

	CloseHandle(m_WaitCalibDoseEvt);
	CloseHandle(m_OffsetCalibrationEvt);
	CloseHandle(m_PauseCalibrationEvt);
	CloseHandle(m_CompleteCalibrationEvt);
	CloseHandle(m_CrateCalibReportEvt);
	CloseHandle(m_WriteCumstomFileEvt);
	CloseHandle(m_UploadCalibMapOver);
	CloseHandle(m_CalibGapEvt);
	if (m_hNotifyThread != NULL)
	{
		CloseHandle(m_hNotifyThread);
	}
	if (m_pDetectors)
	{
		delete m_pDetectors;
	}
	FreeImageMemory();
	m_vAcqModeInfoList.clear();
}

void nsFPD::FPDDeviceSensview::FreeImageMemory()
{
	if (nullptr != m_pwRawImageData)
	{
		delete[] m_pwRawImageData;
		m_pwRawImageData = nullptr;
	}
	if (nullptr != m_pwFullImageData)
	{
		delete[] m_pwFullImageData;
		m_pwFullImageData = nullptr;
	}
	if (nullptr != m_pwPreviewImg)
	{
		delete[] m_pwPreviewImg;
		m_pwPreviewImg = nullptr;
	}
	if (nullptr != m_pPreviewImageHead)
	{
		delete m_pPreviewImageHead;
		m_pPreviewImageHead = nullptr;
	}
	if (nullptr != m_pFullImageHead)
	{
		delete m_pFullImageHead;
		m_pFullImageHead = nullptr;
	}
	return;
}


std::string nsFPD::FPDDeviceSensview::GetGUID() const
{
	return DetectorUnitType;
}

bool nsFPD::FPDDeviceSensview::Prepare()
{
	//SetMaxBlockSize(const char *pQueName, DWORD FullBlockSize, DWORD FullBlockCount, DWORD PrevBlockSize, DWORD PrevBlockCount)
	EventCenter->OnMaxBlockSize("DrQue", m_nRawImgWidth * m_nRawImgHeight * 2, 30, 1500 * 1500 * 2, 1);
	Connect();
	return true;
}

void nsFPD::FPDDeviceSensview::RegisterCtrl(nDetail::Dispatch* Dispatch)
{
	Dispatch->Action.Push(ActionKey::GetDetectorInfo, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetDetectorInfo);
	Dispatch->Action.Push("ActiveDetector", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSActiveDetector);
	Dispatch->Action.Push("RESET", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSRESET);
	Dispatch->Action.Push("EnterExam", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSEnterExam);
	Dispatch->Action.Push("ExitExam", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSExitExam);
	Dispatch->Action.Push("AttachConnect", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSAttachConnect);
	Dispatch->Action.Push("CancelAttach", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSCancelAttach);
	Dispatch->Action.Push("RecoverImage", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSRecoverImage);
	Dispatch->Action.Push("ResetConnect", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSResetConnect);
	Dispatch->Action.Push("DisConnectFPD", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSDisConnectFPD);
	Dispatch->Action.Push("DisConnectFPDForce", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSDisConnectFPDForce);
	Dispatch->Action.Push("UpdateFirmware", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSUpdateFirmware);
	Dispatch->Action.Push("SaveSensitivity", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSSaveSensitivity);
	Dispatch->Action.Push("GetRecoverImageState", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetRecoverImageState);
	Dispatch->Action.Push("SetExposureTimes", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSSetExposureTimes);

	Dispatch->Get.Push("RecoverImageState", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetRecoverImageState);
	Dispatch->Get.Push("RecoverImageEvent", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetRecoverImageEvent);
	Dispatch->Get.Push("DetectorStatus", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetFPDStatus);
	Dispatch->Get.Push("DetectorConnectStatus", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetConnectStatus);
	Dispatch->Get.Push("DetectorAttach", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetAttachResult);
	Dispatch->Get.Push("FPDAttached", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetAttachStatus);
	Dispatch->Get.Push("DetectorInitialStatus", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetInitialStatus);
	Dispatch->Get.Push("DetectorUpdateFWStatus", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetUpdateFWStatus);
	Dispatch->Get.Push("FPDShockSensorInfo", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetShockSensorInfo);
	Dispatch->Get.Push("FieldofViewShape", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetFieldofViewShape);
	Dispatch->Get.Push("FieldofViewDimension", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetFieldofViewDimension);
	Dispatch->Get.Push("DetectorType", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetDetectorType);
	Dispatch->Get.Push("Description", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetDescription);
	Dispatch->Get.Push("DetectorID", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetDetectorID);
	Dispatch->Get.Push("DateofLastDetectorCalibration", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetDateofLastDetectorCalibration);
	Dispatch->Get.Push("TimeofLastDetectorCalibration", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetTimeofLastDetectorCalibration);
	Dispatch->Get.Push("DetectorConditionsNominalFlag", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetDetectorConditionsNominalFlag);
	Dispatch->Get.Push("FPDSensitivity", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetFPDSensitivity);
	Dispatch->Get.Push("FPDSensitivityResult", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetFPDSensitivityResult);
	Dispatch->Get.Push("PixelData", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetPixelData);
	Dispatch->Get.Push("TargetEXI", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetTargetEXI);
	Dispatch->Get.Push("FPDLastError", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetLastError);
	Dispatch->Get.Push("FirmwareStatus", m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetFirmwareStatus);

	Dispatch->Update.Push(AttrKey::NotifyStatusTimePeriod, [](std::string in, std::string& out) {out = in; return RET_STATUS::RET_SUCCEED; });
}
void nsFPD::FPDDeviceSensview::RegisterAcq(nDetail::Dispatch* Dispatch)
{
	Dispatch->Action.Push("SetAcqMode", m_AcqUnit.get(), &AcqUnit::JSSetAcqMode);
	Dispatch->Action.Push(ActionKey::SetValue_PPS, m_AcqUnit.get(), &AcqUnit::JSSetFluPPS);
	Dispatch->Action.Push("SetBinningMode", m_AcqUnit.get(), &AcqUnit::JSSetBinningMode);

	Dispatch->Get.Push(AttrKey::AcqMode, m_AcqUnit.get(), &AcqUnit::JSGetAcqMode);
	Dispatch->Get.Push("ZskkFPDState", m_AcqUnit.get(), &AcqUnit::JSGetZskkFPDState);
	Dispatch->Get.Push("NoNeedWaitImage", m_AcqUnit.get(), &AcqUnit::JSGetNoNeedWaitImage);
	Dispatch->Get.Push("ImgDataInfo", m_AcqUnit.get(), &AcqUnit::JSGetLastImage);

	Dispatch->Update.Push(AttrKey::ModeInRunning, m_AcqUnit.get(), &AcqUnit::JSUpdateModeInRunning);
}
void nsFPD::FPDDeviceSensview::RegisterSync(nDetail::Dispatch* Dispatch)
{
	Dispatch->Action.Push("SetSyncMode", m_SyncUnit.get(), &SyncUnit::JSSetSyncMode);
	Dispatch->Action.Push("SetXwindowSize", m_SyncUnit.get(), &SyncUnit::JSSetXwindowSize);
	Dispatch->Action.Push("PrepareAcquisition", m_SyncUnit.get(), &SyncUnit::JSPrepareAcquisition);
	Dispatch->Action.Push("StartAcquisition", m_SyncUnit.get(), &SyncUnit::JSStartAcquisition);
	Dispatch->Action.Push("StopAcquisition", m_SyncUnit.get(), &SyncUnit::JSStopAcquisition);
	Dispatch->Get.Push("FPDReadyStatus", m_SyncUnit.get(), &SyncUnit::JSGetFPDReady);
	Dispatch->Get.Push("XwindowStatus", m_SyncUnit.get(), &SyncUnit::JSGetXWindowStatus);
	Dispatch->Get.Push("ImageReadingStatus", m_SyncUnit.get(), &SyncUnit::JSGetImageReadingStatus);

}
void nsFPD::FPDDeviceSensview::RegisterCalib(nDetail::Dispatch* Dispatch)
{
	Dispatch->Action.Push("UploadCalibrationFiles", m_CalibUnit.get(), &CalibUnit::JSUploadCalibrationFiles);
	Dispatch->Action.Push("SetSID", m_CalibUnit.get(), &CalibUnit::JSSetSID);
	Dispatch->Action.Push("ActiveCalibration", m_CalibUnit.get(), &CalibUnit::JSActiveCalibration);
	Dispatch->Action.Push("GetRequestedDose", m_CalibUnit.get(), &CalibUnit::JSGetRequestedDose);
	Dispatch->Action.Push("PrepareCalibration", m_CalibUnit.get(), &CalibUnit::JSPrepareCalibration);
	Dispatch->Action.Push("StartCalibration", m_CalibUnit.get(), &CalibUnit::JSStartCalibration);
	Dispatch->Action.Push("StopCalibration", m_CalibUnit.get(), &CalibUnit::JSStopCalibration);
	Dispatch->Action.Push("SetCorrectionType", m_CalibUnit.get(), &CalibUnit::JSSetCorrectionType);
	Dispatch->Action.Push("StartOffset", m_CalibUnit.get(), &CalibUnit::JSStartOffset);
	Dispatch->Action.Push("AbortOffset", m_CalibUnit.get(), &CalibUnit::JSAbortOffset);

	Dispatch->Get.Push(AttrKey::CalibrationStatus, m_CalibUnit.get(), &CalibUnit::JSGetCalibStatus);
	Dispatch->Get.Push(AttrKey::CalibrationProgress, m_CalibUnit.get(), &CalibUnit::JSGetCalibProgress);
	Dispatch->Get.Push("UploadCalibrationFilesResult", m_CalibUnit.get(), &CalibUnit::JSGetUploadCalibrationFilesResult);
	Dispatch->Get.Push("OffsetStatus", m_CalibUnit.get(), &CalibUnit::JSGetOffsetStatus);
	Dispatch->Get.Push("OffsetCounts", m_CalibUnit.get(), &CalibUnit::JSGetOffsetCounts);
	Dispatch->Get.Push("OffsetProgress", m_CalibUnit.get(), &CalibUnit::JSGetOffsetProgress);
	Dispatch->Get.Push("OffsetInterval", m_CalibUnit.get(), &CalibUnit::JSGetOffsetInterval);

	Dispatch->Set.Push("OffsetInterval", m_CalibUnit.get(), &CalibUnit::SetOffsetInterval);
	Dispatch->Update.Push("OffsetInterval", m_CalibUnit.get(), &CalibUnit::JSUpdateOffsetInterval);
}
void nsFPD::FPDDeviceSensview::RegisterOthers(nDetail::Dispatch* Dispatch)
{
	Dispatch->Get.Push(AttrKey::Temperature_Value, m_Temperature.get(), &DeviceTemperatureMould::JSGetCurrentTemperatureValue);
	Dispatch->Get.Push(AttrKey::Remain_Power_Value, m_Battery.get(), &DeviceBatteryMould::JSGetCurrentBatteryValue);
	Dispatch->Get.Push(AttrKey::Wifi_Strength_Value, m_Wifi.get(), &DeviceWifiMould::JSGetCurrentSignalValue);
	Dispatch->Get.Push(m_WarnAndError->m_MSGUnit->GetKey().c_str(), [this](std::string& out) { out = m_WarnAndError->m_MSGUnit->JSGet(); return RET_STATUS::RET_SUCCEED; });

	Dispatch->Get.Push(TempMaxLimit, m_Temperature.get(), &DeviceTemperatureMould::JSGetTemperatureErrorMax);
	Dispatch->Get.Push(TempMinLimit, m_Temperature.get(), &DeviceTemperatureMould::JSGetTemperatureErrorMin);
	Dispatch->Get.Push(TempUpperLimit, m_Temperature.get(), &DeviceTemperatureMould::JSGetTemperatureWarningMax);
	Dispatch->Get.Push(TempLowerLimit, m_Temperature.get(), &DeviceTemperatureMould::JSGetTemperatureWarningMin);
	Dispatch->Get.Push(BatMiniLimit, m_Battery.get(), &DeviceBatteryMould::JSGetBatteryErrorMin);
	Dispatch->Get.Push(BatLowerLimit, m_Battery.get(), &DeviceBatteryMould::JSGetBatteryWarningMin);
	Dispatch->Get.Push(WifiMiniLimit, m_Wifi.get(), &DeviceWifiMould::JSGetSignalErrorMin);
	Dispatch->Get.Push(WifiLowerLimit, m_Wifi.get(), &DeviceWifiMould::JSGetSignalWarningMin);

	Dispatch->Set.Push(TempMaxLimit, m_Temperature.get(), &DeviceTemperatureMould::SetTemperatureErrorMax);
	Dispatch->Set.Push(TempMinLimit, m_Temperature.get(), &DeviceTemperatureMould::SetTemperatureErrorMin);
	Dispatch->Set.Push(TempUpperLimit, m_Temperature.get(), &DeviceTemperatureMould::SetTemperatureWarningMax);
	Dispatch->Set.Push(TempLowerLimit, m_Temperature.get(), &DeviceTemperatureMould::SetTemperatureWarningMin);
	Dispatch->Set.Push(BatMiniLimit, m_Battery.get(), &DeviceBatteryMould::SetBatteryErrorMin);
	Dispatch->Set.Push(BatLowerLimit, m_Battery.get(), &DeviceBatteryMould::SetBatteryWarningMin);
	Dispatch->Set.Push(WifiMiniLimit, m_Wifi.get(), &DeviceWifiMould::SetSignalErrorMin);
	Dispatch->Set.Push(WifiLowerLimit, m_Wifi.get(), &DeviceWifiMould::SetSignalWarningMin);

	Dispatch->Update.Push(TempMaxLimit, m_Temperature.get(), &DeviceTemperatureMould::JSUpdateTemperatureErrorMax);
	Dispatch->Update.Push(TempMinLimit, m_Temperature.get(), &DeviceTemperatureMould::JSUpdateTemperatureErrorMin);
	Dispatch->Update.Push(TempUpperLimit, m_Temperature.get(), &DeviceTemperatureMould::JSUpdateTemperatureWarningMax);
	Dispatch->Update.Push(TempLowerLimit, m_Temperature.get(), &DeviceTemperatureMould::JSUpdateTemperatureWarningMin);
	Dispatch->Update.Push(TemperatureCalibUpWarn, [](std::string in, std::string& out) {out = in; return RET_STATUS::RET_SUCCEED; });
	Dispatch->Update.Push(TemperatureCalibLowWarn, [](std::string in, std::string& out) {out = in; return RET_STATUS::RET_SUCCEED; });
	Dispatch->Update.Push(BatMiniLimit, m_Battery.get(), &DeviceBatteryMould::JSUpdateBatteryErrorMin);
	Dispatch->Update.Push(BatLowerLimit, m_Battery.get(), &DeviceBatteryMould::JSUpdateBatteryWarningMin);
	Dispatch->Update.Push(WifiMiniLimit, m_Wifi.get(), &DeviceWifiMould::JSUpdateSignalErrorMin);
	Dispatch->Update.Push(WifiLowerLimit, m_Wifi.get(), &DeviceWifiMould::JSUpdateSignalWarningMin);
}

void nsFPD::FPDDeviceSensview::Register()
{
	auto Disp = &Dispatch;

	RegisterCtrl(Disp);
	RegisterAcq(Disp);
	RegisterSync(Disp);
	RegisterCalib(Disp);
	RegisterOthers(Disp);
}


bool nsFPD::FPDDeviceSensview::LoadConfig()
{
	if (!m_DetectorConfiguration->LoadConfigurations(m_stDeviceConfig))
	{
		Fatal("Load configuration file failed!!!  ");
		return false;
	}

	try
	{
		m_nRawImgWidth = m_stDeviceConfig.AcqModeInfo.nRawImgWidth;
		m_nRawImgHeight = m_stDeviceConfig.AcqModeInfo.nRawImgHeight;
		m_nFullImgWidth = m_stDeviceConfig.AcqModeInfo.nImageWidth;
		m_nFullImgHeight = m_stDeviceConfig.AcqModeInfo.nImageHeight;
		m_nImageBits = m_stDeviceConfig.AcqModeInfo.nPhySizeInfoBit;
		m_nLeftOffset = m_stDeviceConfig.AcqModeInfo.nImageLeftOffset;
		m_nTopOffset = m_stDeviceConfig.AcqModeInfo.nImageTopOffset;
		m_nRightOffset = m_stDeviceConfig.AcqModeInfo.nImageRightOffset;
		m_nBottomOffset = m_stDeviceConfig.AcqModeInfo.nImageBottomOffset;
		
		m_bPreviewEnable = m_stDeviceConfig.AcqModeInfo.bPreviewEnable;
		Debug("PreviewEnable: {$}  ", m_bPreviewEnable ? "true" : "false");
		
		SetAttachStatus(1);

		m_bSaveRaw = m_stDeviceConfig.AcqModeInfo.bSaveRawEnable ? true : false;
		Debug("Set SaveRaw: {$}  ", m_bSaveRaw ? "true" : "false");

		m_bForceGridSuppress = m_stDeviceConfig.nForceGridSuppress ? true : false;
		Debug("Set ForceGridSuppress: {$}", m_bForceGridSuppress ? "true" : "false");

		//SDK目录
		m_strSDKPath = (string)m_DetectorConfiguration->m_Configurations["SDKPath"];
		Info("SDKPath: {$}", m_strSDKPath);

		//SDK探测器工作目录
		m_stDeviceConfig.strWorkDir = g_strAppPath + m_strSDKPath + "\\work_dir\\" + m_stDeviceConfig.strDetectorModel;
		Info("SDK work path: {$}", m_stDeviceConfig.strWorkDir);

		//探测器校正目录
		m_stDeviceConfig.strFPDConfFilePath = g_strAppPath + (string)m_DetectorConfiguration->m_Configurations["CalibrationDosePath"];
		Debug("Calibration patch: {$}", m_stDeviceConfig.strFPDConfFilePath);

		string strFPDinfo;

		strFPDinfo = (string)m_DetectorConfiguration->m_Configurations["FieldofViewShape"];
		m_DetectorCtrlUnit->SetFieldofViewShape(strFPDinfo);

		strFPDinfo = (string)m_DetectorConfiguration->m_Configurations["FieldofViewDimension"];
		m_DetectorCtrlUnit->SetFieldofViewDimension(strFPDinfo);

		strFPDinfo = (string)m_DetectorConfiguration->m_Configurations["VendorID"];
		m_DetectorCtrlUnit->SetDetectorType("SCINTILLATOR");

		strFPDinfo = (string)m_DetectorConfiguration->m_Configurations["Description"];
		m_DetectorCtrlUnit->SetDescription(strFPDinfo);

		m_DetectorCtrlUnit->SetDetectorConditionsNominalFlag("YES");

		auto szFDinfo = std::to_string(m_stDeviceConfig.nDoseOfEXI);
		m_fFactorEXI2UGY = 100.0f / (float)atof(szFDinfo.c_str()) * 1.0f; //统一使用IEC标准 呈现四角信息，无单位 ugy * 100 -ugy。所有Zskk探测器的FactorEXI2UGY均需*100
		Info("FactorEXI2UGY: {$} ", m_fFactorEXI2UGY);
		auto strFPDcoef = std::to_string(m_fFactorEXI2UGY);
		m_DetectorCtrlUnit->SetFPDSensitivity(strFPDcoef);//image process 重算ROIl的EXI需要此值

		std::string strFPDPixelData = (string)m_DetectorConfiguration->m_Configurations["PixelData"];
		m_DetectorCtrlUnit->SetPixelData(strFPDPixelData);
		std::string strFPDTargetEXI = (string)m_DetectorConfiguration->m_Configurations["TargetEXI"];
		m_DetectorCtrlUnit->SetTargetEXI(strFPDTargetEXI);

		auto nOffsetinteral = (string)m_DetectorConfiguration->m_Configurations["OffsetInterval"];
		m_CalibUnit->SetOffsetInterval(nOffsetinteral);
		Info("Offset interval: {$} minutes", nOffsetinteral);

		m_DetectorCtrlUnit->SetDetectorWidth(to_string(m_stDeviceConfig.AcqModeInfo.nRawImgWidth));
		m_DetectorCtrlUnit->SetDetectorHeight(to_string(m_stDeviceConfig.AcqModeInfo.nRawImgHeight));

		//加载ModeInRunning
		size_t nSize = m_DetectorConfiguration->m_Configurations["ModeInRunning"].size();
		for (size_t i = 0; i < nSize; i++)
		{
			int nModeID = (int)m_DetectorConfiguration->m_Configurations["ModeInRunning"][i]["ModeID"];
			string strFrequency = (string)m_DetectorConfiguration->m_Configurations["ModeInRunning"][i]["Frequency"];
			float fFrequency = stof(strFrequency);
			AcqModeInfo acqModeInfo;
			acqModeInfo.nModeID = nModeID;
			acqModeInfo.fFrequency = fFrequency;
			m_vAcqModeInfoList.push_back(acqModeInfo);
		}

		//--------------------------------------------------------------------------------

		m_CalibDoseList = m_DetectorConfiguration->m_Configurations["CalibConfig"];

		Debug("CalibDoseList: {$} ", m_CalibDoseList.encode());

		for (int i = 0; i < m_CalibDoseList.size(); i++)
		{
			ResDataObject temp = m_CalibDoseList[i];
		}

		m_DetectorCtrlUnit->SetDateofLastDetectorCalibration(m_stDeviceConfig.strCalibrationDate);
		m_DetectorCtrlUnit->SetTimeofLastDetectorCalibration(m_stDeviceConfig.strCalibrationTime);
	}
	catch (exception e)
	{
		Error("Get has exception error: {$}", e.what());
	}

	return true;
}


void nsFPD::FPDDeviceSensview::InitializeTemperatureConfigs()
{
	auto temperuperror = m_stDeviceConfig.fTemperMaxLimit;
	auto temperupwarn = m_stDeviceConfig.fTemperUpLimit;
	auto temperlowwarn = m_stDeviceConfig.fTemperLowLimit;
	auto temperlowerror = m_stDeviceConfig.fTemperMinLimit;
	//Caliberation Temperature ranger
	m_CalTemperupWarn = m_stDeviceConfig.fCalibTemperUp;
	m_CalTemperlowWarn = m_stDeviceConfig.fCalibTemperLow;

	if (m_Temperature)
	{
		m_Temperature->SetTemperatureErrorMax(to_string(temperuperror));
		m_Temperature->SetTemperatureWarningMax(to_string(temperupwarn));
		m_Temperature->SetTemperatureCalibWarningMax(to_string(m_CalTemperupWarn));
		m_Temperature->SetTemperatureCalibWarningMin(to_string(m_CalTemperlowWarn));
		m_Temperature->SetTemperatureWarningMin(to_string(temperlowwarn));
		m_Temperature->SetTemperatureErrorMin(to_string(temperlowerror));
	}

	Info("Temperature config initialize result {$}<{$}<{$}<{$}<{$}<{$}",
		temperlowerror, temperlowwarn, m_CalTemperlowWarn, m_CalTemperupWarn, temperupwarn, temperuperror);
}

bool nsFPD::FPDDeviceSensview::CreateDevice()
{
	if (!LoadConfig())
	{
		Info("Load configuration file failed!!!   ");
		return false;
	}

	InitializeTemperatureConfigs();

	bool bRet = false;
	if (g_pSensviewCtrl == NULL)
	{
		m_pDetectors = new SensviewCtrl();
		g_pSensviewCtrl = m_pDetectors;
		m_pDetectors->AddDPCs(this, m_DetectorConfiguration->m_Configurations, m_stDeviceConfig);

		bRet = m_pDetectors->Init(g_strAppPath);
		Info("Create SDK ctrl ok ");
	}
	else
	{
		m_pDetectors = g_pSensviewCtrl;
		Info("SDK ctrl Already exit ");
		m_pDetectors->AddDPCs(this, m_DetectorConfiguration->m_Configurations, m_stDeviceConfig);
	}

	return bRet;
}

RET_STATUS nsFPD::FPDDeviceSensview::Connect()
{
	Info("------------------------ FPD type {$}, Device {$} Start running. ------------------------ ", m_stDeviceConfig.strDeviceName.c_str(), this);

	if (m_bOpened) //已经初始化连接设备
	{
		Info("Already init, return");
		return RET_STATUS::RET_SUCCEED;
	}

	if (m_stDeviceConfig.bConnectStatus)
	{
		Info("Already Connected, return");
		return RET_STATUS::RET_SUCCEED;
	}


	if (m_hNotifyThread == NULL)
	{
		m_hNotifyThread = CreateThread(0, 0, OnNotify, this, 0, &m_NotifyThreadID);
		if (m_hNotifyThread == NULL)
		{
			Info("Start Exposure Thread Failed!");
		}
		else
		{
			Info("Start Exposure Thread End");
		}
	}

	bool bDemoEnable = ((int)m_DetectorConfiguration->m_Configurations["DemoEnable"] != 0) ? true : false;
	if (bDemoEnable)
	{
		Info("Sensview Drive run in demo");
	}
	else
	{
		if (!m_pDetectors->Connect(g_strAppPath, this))
		{
			Error("Device connect failed!");
			return RET_STATUS::RET_FAILED;
		}
	}

	m_bOpened = true;
	Info("Connect detector over ");

	return RET_STATUS::RET_SUCCEED;
}


DWORD nsFPD::FPDDeviceSensview::OnNotify(LPVOID pParam)
{
	Info("OnNotify Loop Entry-----------");
	FPDDeviceSensview* pNotifyOpr = (FPDDeviceSensview*)pParam;

	HANDLE* pHandles = new HANDLE[6];
	pHandles[0] = pNotifyOpr->m_PauseCalibrationEvt;
	pHandles[1] = pNotifyOpr->m_CompleteCalibrationEvt;
	pHandles[2] = pNotifyOpr->m_OffsetCalibrationEvt;
	pHandles[3] = pNotifyOpr->m_CrateCalibReportEvt;
	pHandles[4] = pNotifyOpr->m_WriteCumstomFileEvt;
	pHandles[5] = pNotifyOpr->m_ExitEvt;
	int nHandlesNum = 6;
	DWORD nTimeOut = 5000;

	while (1)
	{
		DWORD dwResult = WaitForMultipleObjects(nHandlesNum, pHandles, FALSE, nTimeOut);

		if (dwResult == WAIT_TIMEOUT)
		{
			if (!pNotifyOpr->m_stDeviceConfig.bConnectStatus)
			{
				Info("connect to FPD not finished");
				continue;
			}
		}
		if (dwResult == WAIT_OBJECT_0)//m_PauseCalibrationEvt
		{
			Info("OnNotify get PauseCalibration evt");
			pNotifyOpr->PauseCalibration();
		}
		if (dwResult == WAIT_OBJECT_0 + 1)//m_CompleteCalibrationEvt
		{
			ResetEvent(pNotifyOpr->m_CompleteCalibrationEvt);
			Info("OnNotify get CompleteCalibration evt");
			pNotifyOpr->CompleteCalibration();
		}
		else if (dwResult == WAIT_OBJECT_0 + 2)//m_OffsetCalibrationEvt
		{
			Info("OnNotify get m_OffsetCalibrationEvt evt");

			Info("end m_OffsetCalibrationEvt evt");
		}
		else if (dwResult == WAIT_OBJECT_0 + 3)//m_CrateCalibReportEvt
		{
			Info("OnNotify get m_CrateCalibReportEvt evt");
			pNotifyOpr->SaveFailedCalibFile();
			break;
		}
		else if (dwResult == WAIT_OBJECT_0 + 4)//m_WriteCumstomFileEvt
		{
			break;
		}
		else if (dwResult == WAIT_OBJECT_0 + 5)//m_ExitEvt
		{
			Info("Exit OnNotify Thread");
			break;
		}

	}

	delete[] pHandles;
	CloseHandle(pNotifyOpr->m_ExitEvt);

	return 0;
}



RET_STATUS nsFPD::FPDDeviceSensview::ActiveDetector(bool bActive)
{
	if (bActive)
	{
		Info("ActiveDetector");
		bool bRet = m_pDetectors->ActivePanel(this, bActive);
		if (!bRet)
		{
			return RET_STATUS::RET_FAILED;
		}
		//SendAllError();
	}
	else
	{
		Info("UnActiveDetector");

		bool bRet = m_pDetectors->ActivePanel(this, bActive);
		if (!bRet)
		{
			return RET_STATUS::RET_FAILED;
		}
		//ClearAllError();
	}
	return RET_STATUS::RET_SUCCEED;
}

void nsFPD::FPDDeviceSensview::UnactiveBySDK(void* pActviedDPC)
{

}

RET_STATUS nsFPD::FPDDeviceSensview::PrepareAcquisition()
{
	Info("==PrepareAcquisition");
	if (!m_stDeviceConfig.bConnectStatus)
	{
		return RET_STATUS::RET_THREAD_INVALID;
	}
	
	//m_SyncUnit->FPDReadyNotify(false);
	m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));
	Info("PrepareAcquisition over");
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::FPDDeviceSensview::StartAcquisition(string in)
{
	Info("==StartAcquisition: {$}", in);
	if (!m_stDeviceConfig.bConnectStatus)
	{
		return RET_STATUS::RET_THREAD_INVALID;
	}
	m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_ACQ));

	RET_STATUS Ret = RET_STATUS::RET_FAILED;
	if (in == "RAD")
	{
		Ret = SetAcqMode("RAD");
		if (Ret != RET_STATUS::RET_SUCCEED)
		{
			Error("StartAcquisition SetAcqMode(RAD) fail!");
			//return Ret;
		}
		Ret = RET_STATUS::RET_SUCCEED;
		m_pDetectors->m_bGrabStatus = true;
	}
	else if (in == "CF")
	{
		SetAcqMode("CF");
		Ret = RET_STATUS::RET_SUCCEED;
		Info("StartAcquisition(CF)");
	}
	else if (in == "PF")
	{
		SetAcqMode("PF");
		Ret = RET_STATUS::RET_SUCCEED;
		Info("StartAcquisition(PF)");
	}
	else
	{
		Error("Not support this mode, mode name:{$}", in);
		return Ret;
	}

	
	if (RET_STATUS::RET_SUCCEED == m_pDetectors->StartAcquisition(this))
	{
		Ret = RET_STATUS::RET_SUCCEED;
	}
	else
	{
		m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));
		Error("StartAcquisition failed");
	}
	Info("StartAcquisition over");
	return Ret;
}


RET_STATUS nsFPD::FPDDeviceSensview::StopAcquisition()
{
	Info("StopAcquisition");
	if (!m_stDeviceConfig.bConnectStatus)
	{
		return RET_STATUS::RET_THREAD_INVALID;
	}

	RET_STATUS Ret = RET_STATUS::RET_FAILED;
	if (RET_STATUS::RET_SUCCEED == m_pDetectors->StopAcquisition(this))
	{
		m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));
		Ret = RET_STATUS::RET_SUCCEED;
	}
	Info("StopAcquisition over");
	return Ret;
}

string nsFPD::FPDDeviceSensview::GetFileVersion(string strFilePathName)
{
	DWORD dwVerSize = GetFileVersionInfoSize(strFilePathName.c_str(), NULL);
	if (dwVerSize == 0)
	{
		return "";
	}

	LPVOID pVersionBuffer = malloc(dwVerSize);
	if (nullptr == pVersionBuffer)
	{
		return "";
	}
	GetFileVersionInfo(strFilePathName.c_str(), 0, dwVerSize, pVersionBuffer);

	VS_FIXEDFILEINFO* pInfo;
	UINT nInfoLen;
	char szValue[MAX_PATH] = { 0 };

	if (VerQueryValue(pVersionBuffer, ("\\"), (void**)&pInfo, &nInfoLen))
	{
		sprintf_s(szValue, ("%d.%d.%d.%d"),
			HIWORD(pInfo->dwFileVersionMS), LOWORD(pInfo->dwFileVersionMS),
			HIWORD(pInfo->dwFileVersionLS), LOWORD(pInfo->dwFileVersionLS));
	}

	string strVersion = szValue;


	return strVersion;

}

void nsFPD::FPDDeviceSensview::SendTemperatureValue(float fTemp)
{

	int nStatus = 0;
	m_Temperature->SetTemperature(fTemp, nStatus);
	Info("SendTemperatureValue: {$}, status {$} ", fTemp, nStatus);

	return;
}

void nsFPD::FPDDeviceSensview::SendWifiValue(int nWifi)
{
	int nStatus = 0;
	m_Wifi->SetSignalValue(nWifi, nStatus);
	Info("SendWifiValue: {$}, status {$} ", nWifi, nStatus);

	return;
}

void nsFPD::FPDDeviceSensview::SendBatteryValue(int nBattery)
{
	int nStatus = 0;
	m_Battery->SetRemainPowerValue(nBattery, nStatus);
	Info("SendBatteryValue: {$}, status {$} ", nBattery, nStatus);

	return;
}

RET_STATUS nsFPD::FPDDeviceSensview::XWindowOnNotify()
{
	RET_STATUS Ret = RET_STATUS::RET_FAILED;

	m_SyncUnit->XWindowOnNotify();
	Info("WindowOn ");
	m_stImgCreateTime = { 0 };
	GetLocalTime(&m_stImgCreateTime);
	Info("Full image create time-{$}:{$}:{$}:{$}", m_stImgCreateTime.wHour, m_stImgCreateTime.wMinute, m_stImgCreateTime.wSecond, m_stImgCreateTime.wMilliseconds);

	return Ret;
}


RET_STATUS nsFPD::FPDDeviceSensview::XWindowOffNotify()
{
	RET_STATUS Ret = RET_STATUS::RET_FAILED;
	m_SyncUnit->XWindowOffNotify();
	Info("WindowOff ");
	return Ret;
}

RET_STATUS nsFPD::FPDDeviceSensview::ActiveCalibration(CCOS_CALIBRATION_TYPE Type)
{
	Info("ActiveCalibration is {$}", (int)Type);
	if (!m_stDeviceConfig.bConnectStatus)
	{
		Info(" unconnected ");
		return RET_STATUS::RET_THREAD_INVALID;
	}

	if (Type == CCOS_CALIBRATION_TYPE_NONE || Type == CCOS_CALIBRATION_TYPE_MAX)
	{
		Info(" type error {$} ", (int)Type);
		return RET_STATUS::RET_INVALID;
	}

	m_eAppStatus = APP_STATUS_CAL_BEGIN;

	m_nCalibrationType = Type;

	OnErrorX(ERR_FPD_DOSE_LOW);
	OnErrorX(ERR_FPD_DOSE_HIGH);
	OnErrorX(ERR_FPD_DOSE_OBJ);//清除之前的错误，如果有的话

	RET_STATUS Ret = m_pDetectors->ActiveCalibration(Type, this);

	if (RET_STATUS::RET_SUCCEED == Ret)
	{
		m_CalibUnit->SetCalibrationStatus(to_string(CCOS_CALIBRATION_STATUS_ACTIVE));
		m_CalibUnit->SetCalibrationProgress("0");
		if (Type == CCOS_CALIBRATION_TYPE_XRAY)
		{
			ResetEvent(m_WaitCalibDoseEvt);
		}

		m_nXrayCalibNum = 0;
	}

	ResetEvent(m_OffsetCalibrationEvt);
	ResetEvent(m_CompleteCalibrationEvt);

	m_stDeviceConfig.fCalibTemperature1 = m_stDeviceConfig.fCurrentTemperValue;

	Info("ActiveCalibration {$} over", (int)Type);

	return Ret;
}

RET_STATUS nsFPD::FPDDeviceSensview::GetRequestedDose(string& strDose)
{
	Info("GetRequestedDose");
	if (!m_stDeviceConfig.bConnectStatus)
	{
		return RET_STATUS::RET_THREAD_INVALID;
	}

	RET_STATUS Ret = RET_STATUS::RET_FAILED;
	bool bGetDoseInfo = false;
	ResDataObject out;

	if (CCOS_CALIBRATION_TYPE_DARK == m_nCalibrationType)
	{
		out.add("Dose", 0.0f);
		out.add("kV", 0.0f);
		out.add("mA", 0.0f);
		out.add("ms", 0.0f);
		out.add("mAs", 0.0f);
		bGetDoseInfo = true;
		Ret = RET_STATUS::RET_SUCCEED;
	}
	else if (CCOS_CALIBRATION_TYPE_XRAY == m_nCalibrationType)
	{
		float fDose = (m_fDoseParam * 1.0f) / 1000.0f;
		Info("GetRequestedDose Xray {$} over {$}", fDose, m_fDoseParam);
		Ret = RET_STATUS::RET_SUCCEED;

		for (int i = 0; i < m_CalibDoseList.size(); i++)
		{
			ResDataObject temp = m_CalibDoseList[i];
			int nDose = temp["Dose"];
			if (m_fDoseParam == nDose)
			{
				out.add("Dose", nDose);
				out.add("kV", temp["kV"]);
				out.add("mA", temp["mA"]);
				out.add("ms", temp["ms"]);
				out.add("mAs", temp["mAs"]);
				bGetDoseInfo = true;
				break;
			}
		}

	}
	else
	{
		Ret = RET_STATUS::RET_FAILED;
	}

	if (bGetDoseInfo)
	{
		strDose = out.encode();
		Info("GetRequestedDose {$} over", strDose.c_str());
	}
	else
	{
		Error("GetRequestedDose failed");
	}
	return Ret;
}


RET_STATUS nsFPD::FPDDeviceSensview::PrepareCalibration()
{
	Info("PrepareCalibration");
	if (!m_stDeviceConfig.bConnectStatus)
	{
		return RET_STATUS::RET_THREAD_INVALID;
	}

	m_SyncUnit->FPDReadyNotify(true);

	if (CCOS_CALIBRATION_TYPE_XRAY == m_nCalibrationType)
	{
		WaitForSingleObject(m_CalibGapEvt, 5000);
	}

	Info("PrepareCalibration over");

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::FPDDeviceSensview::StartCalibration()
{
	Info("StartCalibration  ");
	if (!m_stDeviceConfig.bConnectStatus)
	{
		return RET_STATUS::RET_THREAD_INVALID;
	}

	if (CCOS_CALIBRATION_TYPE_DARK == m_nCalibrationType)
	{
		SetEvent(m_OffsetCalibrationEvt);
	}

	RET_STATUS Ret = RET_STATUS::RET_FAILED;
	ResetEvent(m_PauseCalibrationEvt);
	if (RET_STATUS::RET_SUCCEED == m_pDetectors->StartCalibration(this))
	{
		m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_ACQ));
		m_CalibUnit->SetCalibrationStatus(to_string(CCOS_CALIBRATION_STATUS_RUNNING));
		Ret = RET_STATUS::RET_SUCCEED;
	}
	else
	{
		Error("StartCalibration failed   ");
		Ret = RET_STATUS::RET_FAILED;
	}


	Info("StartCalibration over   ");

	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::FPDDeviceSensview::PauseCalibration()
{
	RET_STATUS Ret = RET_STATUS::RET_SUCCEED;
	m_nXrayCalibNum++;
	if (m_nXrayCalibNum != 20)
	{
		Info("start to waitting CalibDoseEvt");
		DWORD nRet = WaitForSingleObject(m_WaitCalibDoseEvt, INFINITE);
		//m_nXrayCalibNum = 0;
	}

	ResetEvent(m_PauseCalibrationEvt);
	ResetEvent(m_WaitCalibDoseEvt);
	m_AcqUnit->SendNoNeedWaitImage(true);
	if (m_nXrayCalibNum != 20)
	{
		m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));
		m_CalibUnit->PauseCalibration();
	}
	Info("Driver PauseCalibration over,m_nXrayCalibNum {$}", m_nXrayCalibNum);
	return Ret;
}

RET_STATUS nsFPD::FPDDeviceSensview::StopCalibration()
{
	Info("StopCalibration  ");
	if (!m_stDeviceConfig.bConnectStatus)
	{
		return RET_STATUS::RET_THREAD_INVALID;
	}

	if (CCOS_CALIBRATION_TYPE_DARK == m_nCalibrationType)
	{
		m_CalibUnit->SetCalibrationStatus(to_string(CCOS_CALIBRATION_STATUS_BESTOPPED));
		m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));
		m_CalibUnit->SetCalibrationProgress("100");

		Info("StopDarkCalibration over   ");
		return RET_STATUS::RET_SUCCEED;
	}

	RET_STATUS Ret = RET_STATUS::RET_FAILED;
	m_eAppStatus = APP_STATUS_CAL_END;
	if (RET_STATUS::RET_SUCCEED == m_pDetectors->AbortCalibration(this))
	{
		Ret = RET_STATUS::RET_SUCCEED;
	}
	else
	{
		Ret = RET_STATUS::RET_FAILED;
	}

	m_CalibUnit->SetCalibrationStatus(to_string(CCOS_CALIBRATION_STATUS_BESTOPPED));
	m_CalibUnit->SetCalibrationProgress("100");
	m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));
	m_AcqUnit->SendNoNeedWaitImage(true);

	Info("StopCalibration over   ");

	return RET_STATUS::RET_SUCCEED;
}

void nsFPD::FPDDeviceSensview::AbortCalibration()
{
	Info("AbortCalibration  ");

	if (CCOS_CALIBRATION_TYPE_DARK == m_nCalibrationType)
	{
		m_CalibUnit->SetCalibrationStatus(to_string(CCOS_CALIBRATION_STATUS_ERROR));
		m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));
		m_CalibUnit->SetCalibrationProgress("100");

		Info("AbortDarkCalibration over   ");
		return;
	}

	m_eAppStatus = APP_STATUS_CAL_END;
	m_pDetectors->AbortCalibration(this);

	m_CalibUnit->SetCalibrationStatus(to_string(CCOS_CALIBRATION_STATUS_ERROR));
	m_CalibUnit->SetCalibrationProgress("100");
	m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));
	m_AcqUnit->SendNoNeedWaitImage(true);

	Info("AbortXrayCalibration over");

	return;
}

void nsFPD::FPDDeviceSensview::StopCalibrationInside()
{
	Info("StopCalibrationInside");

	if (CCOS_CALIBRATION_TYPE_DARK == m_nCalibrationType)
	{
		m_CalibUnit->SetCalibrationStatus(to_string(CCOS_CALIBRATION_STATUS_STANDBY));
		m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));
		m_CalibUnit->SetCalibrationProgress("100");

		Info("StopCalibrationInside dark over");
		return;
	}

	m_eAppStatus = APP_STATUS_CAL_END;
	m_pDetectors->AbortCalibration(this);

	m_CalibUnit->SetCalibrationStatus(to_string(CCOS_CALIBRATION_STATUS_STANDBY));
	m_CalibUnit->SetCalibrationProgress("100");
	m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));
	m_AcqUnit->SendNoNeedWaitImage(true);

	Info("StopCalibrationInside xray over");

	return;
}

bool nsFPD::FPDDeviceSensview::CompleteCalibration()
{
	m_stDeviceConfig.fCalibTemperature2 = m_stDeviceConfig.fCurrentTemperValue;

	m_stDeviceConfig.fCalibTemperature = (m_stDeviceConfig.fCalibTemperature1 + m_stDeviceConfig.fCalibTemperature2) / 2;

	ResetEvent(m_UploadCalibMapOver);

	m_pDetectors->CompleteCalibration(this);

	DWORD nRet = WaitForSingleObject(m_UploadCalibMapOver, 60000);
	if (WAIT_OBJECT_0 == nRet)
	{
		Info("got event m_UploadCalibMapOver");
	}
	else if (WAIT_TIMEOUT == nRet)
	{
		Info("wait event m_UploadCalibMapOver timeout");
	}
	else
	{
		Info("wait event m_UploadCalibMapOver error");
	}

	m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));
	m_CalibUnit->SetCalibrationStatus(to_string(CCOS_CALIBRATION_STATUS_STANDBY));
	m_CalibUnit->SetCalibrationProgress("100");

	CheckCalibartionDue();

	return true;
}
void nsFPD::FPDDeviceSensview::SaveFailedCalibFile()
{
	m_pDetectors->SaveFailedCalibFiles(m_nDeviceIndex, false);

}


RET_STATUS  nsFPD::FPDDeviceSensview::ResetConnect()
{
	Info("Reset Connect");
	m_pDetectors->ResetFPD(this);
	Info("FPDDeviceSensview::ResetConnect over ");
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS  nsFPD::FPDDeviceSensview::DisConnectFPD()
{
	if (m_bDisConnected)
	{
		Info("already disconnected just return success");
		m_bDisConnected = true;
		m_DetectorCtrlUnit->SetConnectStatus(to_string(PANEL_DISCONNECT_SUCCESS));
		return RET_STATUS::RET_SUCCEED;
	}

	if (!m_pDetectors->DisConnect(this))
	{
		Error("DisConnectFPD failed");
		return RET_STATUS::RET_FAILED;
	}

	SendWifiValue(0);
	SendBatteryValue(0);
	SendTemperatureValue(ABS_ZERO_TEMPERATURE);
	ResetAllError();
	m_bDisConnected = true;
	m_DetectorCtrlUnit->SetConnectStatus(to_string(PANEL_DISCONNECT_SUCCESS));
	Info("DisConnectFPD over");
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS  nsFPD::FPDDeviceSensview::UpdateFirmware()
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS  nsFPD::FPDDeviceSensview::AttachConnect()
{
	m_DetectorCtrlUnit->SetConnectStatus(to_string(PANEL_ATTACH_START));
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS  nsFPD::FPDDeviceSensview::CancelAttach()
{
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS  nsFPD::FPDDeviceSensview::SetAttachStatus(int nStatus)
{
	return m_DetectorCtrlUnit->SetAttachStatus(to_string(nStatus));
}



void nsFPD::FPDDeviceSensview::FullImageDateArrived(WORD* pImg)
{
	AddFrameWithRawHead(IMAGE_FULL, pImg, m_nFullImgWidth * m_nFullImgHeight);
}

void nsFPD::FPDDeviceSensview::PrevImageDateArrived(WORD* pImg)
{
	AddFrameWithRawHead(IMAGE_PREVIEW, pImg, m_stDeviceConfig.nPreviewWidth * m_stDeviceConfig.nPreviewHeight);
}

RET_STATUS  nsFPD::FPDDeviceSensview::SetXwindow(float XwindowSize)
{

	Info("SetXwindowSize  {$}", XwindowSize);


	Info("SetXwindowSize over");
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::FPDDeviceSensview::EnterExam(int nExamStatus)
{
	Info("EnterExam");

	switch (nExamStatus)
	{
	case APP_STATUS_WORK_BEGIN:
		Info("Enter into Exam Windows");
		OnErrorX(ERR_FPD_DOSE_LOW);
		OnErrorX(ERR_FPD_DOSE_HIGH);
		OnErrorX(ERR_FPD_DOSE_OBJ);//清除之前校正的错误，如果有的话
		break;
	case APP_STATUS_WORK_END:
		Info("Quit Exam Windows");
		break;
	case APP_STATUS_DETSHARE_BEGIN:
		Info("Enter into Detector Share Windows");
		break;
	case APP_STATUS_DETSHAR_END:
		Info("Quit Detector Share Windows");
		break;
	case APP_STATUS_CAL_BEGIN:
		Info("Enter into Calibration Windows");
		break;
	case APP_STATUS_CAL_END:
		Info("Quit Calibration Windows");
		break;
	case APP_STATUS_WORK_IN_SENSITIVITY:
		Info("Enter into sensitivity test interface");
		break;
	default:
		Warn("Undefined app status");
		break;
	}
	m_eAppStatus = (APP_STATUS)nExamStatus;
	m_pDetectors->EnterExam(m_eAppStatus);

	return RET_STATUS::RET_SUCCEED;
}


//设置采集模式
RET_STATUS nsFPD::FPDDeviceSensview::SetAcqMode(std::string strMode)
{
	if (!m_stDeviceConfig.bConnectStatus)
	{
		Error("Detector disconnect, return");
		return RET_STATUS::RET_THREAD_INVALID;
	}
	int nMode = 0;
	bool bFindFrequency = false;
	if (strMode.find("RAD") != std::string::npos)
	{
		nMode = 1;
	}
	else if (strMode.find("PF") != std::string::npos)
	{
		for (auto tempAcqMode : m_vAcqModeInfoList)
		{
			if (tempAcqMode.fFrequency == m_fCurrentPPS)
			{
				nMode = tempAcqMode.nModeID;
				bFindFrequency = true;
				Info("Frequency: {$}, Mode: {$}", tempAcqMode.fFrequency, tempAcqMode.nModeID);
				break;
			}
		}
		if (!bFindFrequency)
		{
			nMode = 2;
		}
	}
	else if (strMode.find("CF") != std::string::npos)
	{
		for (auto tempAcqMode : m_vAcqModeInfoList)
		{
			if (tempAcqMode.fFrequency == m_fCurrentPPS)
			{
				nMode = tempAcqMode.nModeID;
				bFindFrequency = true;
				Info("Frequency: {$}, Mode: {$}", tempAcqMode.fFrequency, tempAcqMode.nModeID);
				break;
			}
		}
		if (!bFindFrequency)
		{
			nMode = 3;
		}
	}
	else
	{
		Error("Undefined acq mode");
		return RET_STATUS::RET_FAILED;
	}

	//判重
	if (m_nCurrentMode == nMode)
	{
		Info("Same mode, return true");
		return RET_STATUS::RET_SUCCEED;
	}

	//获取当前模式号对应的采集配置
	if (!m_DetectorConfiguration->GetDetModeInfo(nMode, m_stDeviceConfig.AcqModeInfo))
	{
		Error("Illegal mode!");
		return RET_STATUS::RET_FAILED;
	}

	m_nRawImgWidth = m_stDeviceConfig.AcqModeInfo.nRawImgWidth;
	m_nRawImgHeight = m_stDeviceConfig.AcqModeInfo.nRawImgHeight;
	m_nFullImgWidth = m_stDeviceConfig.AcqModeInfo.nImageWidth;
	m_nFullImgHeight = m_stDeviceConfig.AcqModeInfo.nImageHeight;
	m_nImageBits = m_stDeviceConfig.AcqModeInfo.nPhySizeInfoBit;
	m_nLeftOffset = m_stDeviceConfig.AcqModeInfo.nImageLeftOffset;
	m_nTopOffset = m_stDeviceConfig.AcqModeInfo.nImageTopOffset;
	m_nRightOffset = m_stDeviceConfig.AcqModeInfo.nImageRightOffset;
	m_nBottomOffset = m_stDeviceConfig.AcqModeInfo.nImageBottomOffset;

	m_bPreviewEnable = m_stDeviceConfig.AcqModeInfo.bPreviewEnable;
	m_bSaveRaw = m_stDeviceConfig.AcqModeInfo.bSaveRawEnable ? true : false;
	Debug("Set SaveRaw: {$}  ", m_bSaveRaw ? "true" : "false");

	int nRawX = m_stDeviceConfig.AcqModeInfo.nRawImgWidth;
	int nRawY = m_stDeviceConfig.AcqModeInfo.nRawImgHeight;
	int nImageX = m_stDeviceConfig.AcqModeInfo.nImageWidth;
	int nImageY = m_stDeviceConfig.AcqModeInfo.nImageHeight;
	int nBit = m_stDeviceConfig.AcqModeInfo.nPhySizeInfoBit;

	m_AcqUnit->SetFulImageInfo(nImageX, nImageY, nBit, false);

	//原始图内存
	if (nullptr != m_pwRawImageData)
	{
		delete[] m_pwRawImageData;
		m_pwRawImageData = nullptr;
	}
	m_pwRawImageData = new WORD[nRawX * nRawY];

	//有效图内存
	if (nullptr != m_pwFullImageData)
	{
		delete[] m_pwFullImageData;
		m_pwFullImageData = nullptr;
	}
	m_pwFullImageData = new WORD[nImageX * nImageY];

	if (nullptr != m_pFullImageHead)
	{
		delete m_pFullImageHead;
		m_pFullImageHead = nullptr;
	}

	if (!m_pDetectors->SetAcqMode(this, nMode, m_stDeviceConfig.AcqModeInfo))
	{
		Error("Set acq mode failed");
		return RET_STATUS::RET_FAILED;
	}
	m_AcqUnit->AcqModeNotify(strMode);
	m_nCurrentMode = nMode;

	Info("SetAcqMode Success");
	return RET_STATUS::RET_SUCCEED;
}


RET_STATUS nsFPD::FPDDeviceSensview::SetSyncMode(SYNC_MODE nSyncMode, HARDWARE_TRIGGER_MODE TriggerMode)
{
	if (!m_stDeviceConfig.bConnectStatus)
	{
		return RET_STATUS::RET_FAILED;
	}

	return RET_STATUS::RET_SUCCEED;
}



//保存RAW图数据
void nsFPD::FPDDeviceSensview::SaveRawImage(const char* pImgName, const WORD* pRawImg, int nWidth, int nHeight)
{
	Info("Begin SaveRawImage: {$}, width: {$}, height: {$}", pImgName, nWidth, nHeight);
	if (pRawImg == NULL || pImgName == NULL)
	{
		Error("Undefined parameter");
		return;
	}
	string strImagePath = g_strAppPath + "Image\\" + pImgName;

	FILE* fp;
	if ((fp = fopen(strImagePath.c_str(), "wb")) == NULL)
	{
		DWORD dw = GetLastError();
		Error("fopen {$} failed, {$}", strImagePath.c_str(), dw);
		return;
	}
	fwrite(pRawImg, sizeof(WORD), nWidth * nHeight, fp);
	fclose(fp);
	Info("End SaveRawImage");
	return;
}


void nsFPD::FPDDeviceSensview::OnFPDCallback(int nDetectorID, int nEventID, int nEventLevel, const char* pszMsg, int nParam1, float fParam2, int nPtrParamLen, void* pParam)
{
	switch (nEventLevel)
	{
	case EVT_LEVEL_CONFIGURATION:
	{
		OnEventProcessConf(nDetectorID, nEventID, nEventLevel, pszMsg, nParam1, fParam2, nPtrParamLen, pParam);
		break;
	}
	case EVT_LEVEL_INFORMATOION:
	{
		OnEventProcessInfo(nDetectorID, nEventID, nEventLevel, pszMsg, nParam1, fParam2, nPtrParamLen, pParam);
		break;
	}
	case EVT_LEVEL_STATUS:
	{
		OnEventProcessStatus(nDetectorID, nEventID, nEventLevel, pszMsg, nParam1, fParam2, nPtrParamLen, pParam);
		break;
	}
	case EVT_LEVEL_DATA:
	{
		OnEventProcessData(nDetectorID, nEventID, nEventLevel, pszMsg, nParam1, fParam2, nPtrParamLen, pParam);
		break;
	}
	case EVT_LEVEL_WARNING:
	{
		OnEventProcessWarning(nDetectorID, nEventID, nEventLevel, pszMsg, nParam1, fParam2, nPtrParamLen, pParam);
		break;
	}
	case EVT_LEVEL_ERROR:
	{
		OnEventProcessError(nDetectorID, nEventID, nEventLevel, pszMsg, nParam1, fParam2, nPtrParamLen, pParam);
		break;
	}
	default:
	{
		break;
	}
	}
}

void nsFPD::FPDDeviceSensview::OnEventProcessConf(int nDetectorID, int nEventID, int nEventLevel, const char* pszMsg, int nParam1, float fParam2, int nPtrParamLen, void* pParam)
{

	switch (nEventID)
	{
	case EVT_CONF_PANEL_SERIAL:
	{
		m_stDeviceConfig.strPanelSerial = pszMsg;
		Info("Receive Panel {$} SN {$}", nDetectorID, pszMsg);
		char cDetectorID[17] = { 0 };
		memcpy(cDetectorID, m_stDeviceConfig.strPanelSerial.c_str(), 16);
		string strDetectorID = cDetectorID;
		m_DetectorCtrlUnit->SetDetectorID(strDetectorID);
		Info("SedDetectorID {$}", strDetectorID.c_str());

		if (!m_bRecoverImageStatusInit)
		{
			m_RecoverImageStatus.add("DetectorName", m_stDeviceConfig.strDeviceName.c_str());
			m_RecoverImageStatus.add("DetectorSN", m_stDeviceConfig.strPanelSerial.c_str());
			m_RecoverImageStatus.add("DetectorWifiSignal", "1");
			m_RecoverImageStatus.add("Result", "-1");
			m_bRecoverImageStatusInit = true;
		}

		break;
	}
	case EVT_CONF_RAW_WIDTH:
	{
		if (m_stDeviceConfig.nFullImageWidth != nParam1)
		{
			m_stDeviceConfig.nFullImageWidth = nParam1;
		}
		Info("Panel {$} nRawWidth:{$}", nDetectorID, m_stDeviceConfig.nRawWidth);
		break;
	}
	case EVT_CONF_RAW_HIGHT:
	{
		if (m_stDeviceConfig.nFullImageHeight != nParam1)
		{
			m_stDeviceConfig.nFullImageHeight = nParam1;
		}
		Info("Panel {$} nRawHeight:{$}", nDetectorID, m_stDeviceConfig.nRawHeight);
		break;
	}
	case EVT_CONF_RAW_BITS:
	{
		m_stDeviceConfig.nImageBits = nParam1;
		Info("Panel {$} nImageBits:{$}", nDetectorID, m_stDeviceConfig.nImageBits);
		break;
	}
	case EVT_CONF_PIXELSPACE:
	{
		m_nPixelPitch = (int)fParam2;
		Info("Panel {$} PixelSpace: {$}", nDetectorID, m_nPixelPitch);
		break;
	}
	case EVT_CONF_PREVIEW_WIDTH:
	{
		if (m_stDeviceConfig.nPreviewWidth != nParam1)
		{
			m_stDeviceConfig.nPreviewWidth = nParam1;
		}
		Info("Panel {$} nPreviewWidth:{$}", nDetectorID, m_stDeviceConfig.nPreviewWidth);
		break;
	}
	case EVT_CONF_PREVIEW_HIGHT:
	{
		if (m_stDeviceConfig.nPreviewHeight != nParam1)
		{
			m_stDeviceConfig.nPreviewHeight = nParam1;
		}
		Info("Panel {$} nPreviewHeight:{$}", nDetectorID, m_stDeviceConfig.nPreviewHeight);
		break;
	}
	case EVT_CONF_MODULE_TYPE:
	{
		Info("Receive Panel {$} ModuleType {$}", nDetectorID, pszMsg);
		break;
	}
	case EVT_CONF_MODULE_IP:
	{
		m_strModuleIP = pszMsg;
		Info("Receive Panel {$} ModuleIP {$}", nDetectorID, pszMsg);
		break;
	}
	case EVT_CONF_MODULE_SN:
	{
		Info("Receive Panel {$} ModuleSN {$}", nDetectorID, pszMsg);
		break;
	}
	case EVT_CONF_FIRWARE_UPDATE:
	{
		m_DetectorCtrlUnit->SetFirmwareStatus(to_string(nParam1));
		Info("Panel {$} FirmwareUpdate:{$}", nDetectorID, nParam1);
		break;
	}
	case EVT_CONF_PART_NUMBER:
	{
		Info("Panel {$} PartNumber:{$}", nDetectorID, pszMsg);
		break;
	}
	case EVT_CONF_BATTERY_SN:
	{
		Info("Panel {$} Battery SN:{$}", nDetectorID, pszMsg);
		break;
	}
	case EVT_CONF_WIFI_SSID:
	{
		Info("Panel {$} WifiSSID:{$}", nDetectorID, pszMsg);
		break;
	}
	case EVT_CONF_IFBOARD:
	{
		Info("Panel {$} InterfaceBoard:{$}", nDetectorID, pszMsg);
		break;
	}
	case EVT_CONF_DATECODE:
	{
		Info("Panel {$} DateCode:{$}", nDetectorID, pszMsg);
		break;
	}
	case EVT_CONF_LIFETIME:
	{
		int nLifeTime = nParam1;
		break;
	}
	default:
	{
		break;
	}
	}
}


void nsFPD::FPDDeviceSensview::OnEventProcessInfo(int nDetectorID, int nEventID, int nEventLevel, const char* pszMsg, int nParam1, float fParam2, int nPtrParamLen, void* pParam)
{
	int nID = nDetectorID;
	switch (nEventID)
	{
	case EVT_INFO_POWER_ON:
	{
		int nPowerOn = nParam1;
		Info("Detector {$} PowerOn:{$}", nID, nPowerOn);
		break;
	}
	case EVT_INFO_BATTERY_CAPACITY:
	{
		m_nBatteryCapacity = nParam1;

		break;
	}
	case EVT_INFO_BATTERY_TEMPERATURE:
	{
		float fBatteryTemper = fParam2;

		if ((fBatteryTemper - m_fBatteryTemperature) >= 0.1f)
		{
			Info("temperature: {$}", fBatteryTemper);
			m_fBatteryTemperature = fBatteryTemper;
		}
		break;
	}
	case EVT_INFO_BATTERY_CHARGES:
	{
		int nBatteryCharges = nParam1;

		if (nBatteryCharges != m_nBatteryCharges)
		{
			Info("Charge number: {$}", nBatteryCharges);
			m_nBatteryCharges = nBatteryCharges;
		}
		break;
	}
	case EVT_INFO_WIFI_DATARATE:
	{
		Info("Detector {$} WifiDataRate:{$}", nID, nParam1);
		break;
	}
	case EVT_INFO_WIFI_CHANNEL:
	{
		Info("Panel {$} WifiChannel:{$}", nID, nParam1);
		break;
	}
	case EVT_INFO_WIFI_SIGNALPOWER:
	{
		break;
	}
	case EVT_INFO_WIFI_NOISEPOWER:
	{
		Info("Panel {$} WifiNoisePower:{$}", nID, nParam1);
		break;
	}
	case EVT_INFO_FIRMWARE:
	{
		Info("Panel {$} Firmware:{$}", nID, pszMsg);
		break;
	}
	case EVT_INFO_SHOCKSENSOR_INFO:
	{
		Info("Receive ShockSensor Info");
		m_strShockSensor = pszMsg;
		m_DetectorCtrlUnit->SetShockSensorInfo(m_strShockSensor);
		break;
	}
	case EVT_INFO_CALIBRATIOIN_DATE:
	{
		Info("Panel {$} STE Calibration Date:{$}", nID, pszMsg);
		break;
	}
	case EVT_INFO_CALIBRATIOIN_TIME:
	{
		Info("Panel {$} STE Calibration Time:{$}", nID, pszMsg);
		m_stDeviceConfig.strCalibrationTime = pszMsg;
		m_DetectorCtrlUnit->SetTimeofLastDetectorCalibration(m_stDeviceConfig.strCalibrationTime);
		break;
	}

	default:
	{
		break;
	}
	}
}


void nsFPD::FPDDeviceSensview::OnEventProcessStatus(int nDetectorID, int nEventID, int nEventLevel, const char* pszMsg, int nParam1, float fParam2, int nPtrParamLen, void* pParam)
{
	int nID = nDetectorID;
	string strWarnErrorCode = "";

	switch (nEventID)
	{
	case EVT_STATUS_INIT:
	{
		if (PANEL_EVENT_END_OK == nParam1)
		{
			OnInitResult(true);
			m_DetectorCtrlUnit->SetInitialStatus(to_string(DETECTOR_INI_SUCCESS));
			Info("connect FPD ok.");
		}
		else if (PANEL_EVENT_END_ERROR == nParam1)
		{
			OnInitResult(false);
			m_DetectorCtrlUnit->SetInitialStatus(to_string(DETECTOR_INI_FAILED));
		}
		else if (PANEL_EVENT_END == nParam1) //未连接探测器
		{
			m_DetectorCtrlUnit->SetInitialStatus(to_string(DETECTOR_INI_SUCCESS));
		}
		else if (PANEL_EVENT_START == nParam1)
		{
			Info("Init start...");
			m_DetectorCtrlUnit->SetInitialStatus(to_string(DETECTOR_INI_START));
		}

		break;
	}
	case EVT_STATUS_MOTION:
	{
		break;
	}
	case EVT_STATUS_UPDATE_FIRMWARE:
	{
		if (PANEL_EVENT_START == nParam1)
		{
			Info("Start update firmware");
			m_DetectorCtrlUnit->SetUpdateFWStatus(to_string(DETECTOR_UFW_START));
		}
		else if (PANEL_EVENT_BEGIN == nParam1)
		{
			Info("Update firmware begin");
			m_stDeviceConfig.bConnectStatus = false;
		}
		else if (PANEL_EVENT_END_ERROR == nParam1)
		{
			Info("Update firmware failed");
			m_DetectorCtrlUnit->SetUpdateFWStatus(to_string(DETECTOR_UFW_ERROR));
		}
		else if (PANEL_EVENT_SUCCESS == nParam1)
		{
			Info("update firmware success");
			m_DetectorCtrlUnit->SetUpdateFWStatus(to_string(DETECTOR_UFW_SUCCESS));

		}
		else if (PANEL_EVENT_FWU_ERROR_BATTERY == nParam1)
		{
			Info("update firmware failed, battery < 50");
			m_DetectorCtrlUnit->SetUpdateFWStatus(to_string(DETECTOR_UFW_ERROR_BATTERY));


		}
		else if (PANEL_EVENT_FWU_ERROR_OMIT == nParam1)
		{
			Info("update firmware failed, Omit");
			m_DetectorCtrlUnit->SetUpdateFWStatus(to_string(DETECTOR_UFW_ERROR_OMIT));

		}
		break;
	}
	case EVT_STATUS_DETECTORSHARE:
	{
		break;
	}
	case EVT_STATUS_PANEL:
	{
		if (PANEL_STANDBY == nParam1)
		{
			Info("Panel Status:PREPARE");

		}
		else if (PANEL_READY_EXP == nParam1)
		{
			Info("Panel Status:READY");
			Action_ExpReady();

		}
		else if (PANEL_OFFSET_FINISH == nParam1)
		{
			Info("Panel Status:PANEL_OFFSET_FINISH");
			StopCalibrationInside();
		}
		else if (PANEL_OFFSET_FAILED == nParam1)
		{
			Info("Panel Status:PANEL_OFFSET_FAILED");
			AbortCalibration();
		}
		else if (PANEL_XWINDOW_ON == nParam1) //Xwindow On
		{
			Info("Panel Status:XWINDOW_ON");
			XWindowOnNotify();
		}
		else if (PANEL_XWINDOW_OFF == nParam1) //Xwindow Off
		{
			Info("Panel Status:XWINDOW_OFF");
			XWindowOffNotify();
		}

		else if (PANEL_GAIN_FINISH == nParam1)
		{
			Info("Panel Status:CALIBRATION_FINISH");

		}
		else if (PANEL_GAIN_PREPARE == nParam1)
		{
			Info("Detector Notify Xray Prepare");

		}
		else if (PANEL_GAIN_READY_EXP == nParam1)
		{
			Action_ExpReady();

		}
		else
		{
			Info("Panel {$} Status is :{$}", nID, (int)nParam1);
		}

		break;
	}
	case EVT_STATUS_CALIBRATIOIN:
	{
		ENUM_PANEL_EVENT_STATE eStatus = (ENUM_PANEL_EVENT_STATE)nParam1;
		switch (eStatus)
		{
		case PANEL_EVENT_START:
			break;
		case PANEL_EVENT_END_OK:
			Info("Calibration process is success");
			//CompleteCalibration();
			SetEvent(m_CompleteCalibrationEvt);
			break;
		case PANEL_EVENT_END_ERROR:
			Info("Calibration process is failed");
			break;
		case PANEL_EVENT_TIMEOUT:
			Info("Calibration timeout");
			Info("Calibration process is failed");
			break;
		case PANEL_EVENT_CALIB_REPORT:

			Info("Create Calibration Report failed");
			//strSNote = GetPanelResource("CalibrationTimeout");
			//Info( strSNote.c_str());
			//OnWarn(nID, WAR_FPD_CALB_TIMEOUT, strSNote.c_str());
			SetEvent(m_CrateCalibReportEvt);

			break;
		default:
			break;
		}
		break;
	}
	case EVT_STATUS_SAVECALIB:
	{
		if (PANEL_EVENT_START == nParam1)
		{
			Info("Begin to Save Calibration Files");

		}
		else if (PANEL_EVENT_END_ERROR == nParam1)
		{
			SetEvent(m_UploadCalibMapOver);
			Info("Save Calibration Files failed");
		}
		else if (PANEL_EVENT_END == nParam1)
		{
			SetEvent(m_UploadCalibMapOver);
			Info("Save Calibration Files Success");
		}
		break;
	}
	case EVT_STATUS_ACQUISITION:
	{
		ENUM_PANEL_EVENT_STATE eStatus = (ENUM_PANEL_EVENT_STATE)nParam1;
		switch (eStatus)
		{
		case PANEL_EVENT_START:
			break;
		case PANEL_EVENT_END_OK:
			break;
		case PANEL_EVENT_END_ERROR: //由于断线造成指令执行失败
		{
			string strWarnErrorCode = ERR_FPD_ACQ_FAILED;//fixbug 12473 开窗失败不用ERR_FPD_RESTART上报
			OnError(strWarnErrorCode);
			break;
		}
		default:
			break;
		}
		break;
	}
	case EVT_STATUS_PREPARE_EDNCALIBRATION:
		break;
	case EVT_STATUS_SINGLEEXP:
	{
		if (DOSE_TOO_HIGH == nParam1)
		{
			Info("Dose too high");
			m_strLastError = "Current dose level is too high and beyond the tolerance interval";
			OnError(ERR_FPD_DOSE_HIGH, m_strLastError);

			AbortCalibration();

		}
		else if (DOSE_TOO_LOW == nParam1)
		{
			Info("Dose too low");
			m_strLastError = "Current dose level is too low and beyond the tolerance interval";
			OnError(ERR_FPD_DOSE_LOW, m_strLastError);

			AbortCalibration();

		}
		else if (DOSE_OBJECT == nParam1)
		{

			Info("Dose object");
			m_strLastError = "Calibration has failed. Please check emergency stop button or calibration switch, otherwise call service.";
			OnError(ERR_FPD_DOSE_OBJ, m_strLastError);

			AbortCalibration();

		}
		else if (DOSE_ACCEPT == nParam1)
		{
			Info("Calibration Result is acceptable");
			m_strLastError = "";
			OnErrorX(ERR_FPD_DOSE_LOW);
			OnErrorX(ERR_FPD_DOSE_HIGH);
			OnErrorX(ERR_FPD_DOSE_OBJ);
			SetEvent(m_PauseCalibrationEvt);


		}
		else if (PANEL_EVENT_END_OK == nParam1)
		{

		}
		else if (PANEL_EVENT_END_ERROR == nParam1)
		{
			AbortCalibration();
		}
		//endif

		break;
	}
	case EVT_STATUS_IMAGERECOVERAUTO:
	{
		OnErrorX(ERR_FPD_IMAGE_PENDING);

		m_RecoverImageStatus["Result"] = "0";
		Info("m_RecoverImageStatus[Result] = 0 by auto");
		m_DetectorCtrlUnit->SetRecoverImageState(m_RecoverImageStatus.encode());

		m_bAbortRecover = false; //终止恢复图像的变量也要重置
		m_bRecoveringImage = false; //不再恢复图像过程中
		m_nRecoverImageTimes = 0; //下次恢复图像，重置

		break;
	}
	case EVT_STATUS_TEMPERATURE:
	{
		float fTemperature = fParam2;

		OnProcessTemperature(nID, fTemperature);
		m_stDeviceConfig.fCurrentTemperValue = fTemperature;
		Info("Detector {$} Temperature Value:{$}", nID, fTemperature);

		SendTemperatureValue(fTemperature);
		break;
	}
	case EVT_STATUS_WIFI:
	{
		int nWifiLevel = nParam1;

		Info("Detector {$} Wifi Value:{$}", nID, nWifiLevel);
		strWarnErrorCode = ERR_FPD_WIFI_LOW;
		if (nWifiLevel == 0) //WIFI值为0 表明是有线连接，不报错
		{
			OnErrorX(strWarnErrorCode);
		}
		else if (nWifiLevel < m_stDeviceConfig.nWifiLimit)
		{
			//wifi error
			OnWarnX(WAR_FPD_WIFI_LOW);
			OnError(strWarnErrorCode);
		}
		else if (nWifiLevel <= m_stDeviceConfig.nWifiWarning)
		{
			//wifi error
			OnErrorX(strWarnErrorCode);
			strWarnErrorCode = WAR_FPD_WIFI_LOW;
			OnWarn(nID, strWarnErrorCode);
		}
		else
		{
			OnErrorX(strWarnErrorCode);
			strWarnErrorCode = WAR_FPD_WIFI_LOW;
			OnWarnX(strWarnErrorCode);
		}
		if (nWifiLevel != m_stDeviceConfig.nCurrentWifiValue)
		{
			Info("Channel:{$},SignalPower:{$},NoisePower:{$},DataRate:{$}",
				m_stDeviceConfig.nWifiChannel, m_stDeviceConfig.nWifiSignalPower, m_stDeviceConfig.nWifiNoisePower, m_stDeviceConfig.nWifiDataRate);

		}
		m_stDeviceConfig.nCurrentWifiValue = nWifiLevel;
		SendWifiValue(nWifiLevel);
		break;
	}
	case EVT_STATUS_BATTERY_VALUE:
	{
		int nBatteryValue = nParam1;

		Info("Detector {$} Battery:{$}", nID, nParam1);

		if (nBatteryValue < m_stDeviceConfig.nBatteryLimit)
		{
			if (!m_bBatteryCharging) //如果没有充电；
			{
				strWarnErrorCode = ERR_FPD_BATTERY_LOW;
				OnError(strWarnErrorCode);
				strWarnErrorCode = WAR_FPD_BATTERY_LOW;
				OnWarnX(strWarnErrorCode);

			}

		}
		else if (nBatteryValue < m_stDeviceConfig.nBatteryWarning)
		{
			//battery error
			strWarnErrorCode = ERR_FPD_BATTERY_LOW;
			OnErrorX(strWarnErrorCode);
			strWarnErrorCode = WAR_FPD_BATTERY_LOW;
			//这里需要滤波，如果2次以上都检测到低于告警值才上报该警告
			OnWarn(nID, strWarnErrorCode);
		}
		else
		{
			strWarnErrorCode = ERR_FPD_BATTERY_LOW;
			OnErrorX(strWarnErrorCode);
			strWarnErrorCode = WAR_FPD_BATTERY_LOW;
			OnWarnX(strWarnErrorCode);
		}

		m_stDeviceConfig.nCurrentBatteryValue = nBatteryValue;
		Info("Detector {$} Battery Value:{$}", nID, nBatteryValue);

		if (nBatteryValue < m_stDeviceConfig.nBatteryWarning)
		{
			//防止探测器电池电量状态异常跳变
			SendBatteryValue(nBatteryValue);
		}
		else
		{
			SendBatteryValue(nBatteryValue);
		}

		break;
	}
	case EVT_STATUS_BATTERY_CHARGING:
	{
		string strTemp = pszMsg;
		if (strTemp.find("true") != std::string::npos)
		{
			m_bBatteryCharging = true;
		}
		else
		{
			m_bBatteryCharging = false;
		}
		break;
	}
	case EVT_STATUS_SHOCK_SENSOR:
	{
		break;
	}
	case EVT_STATUS_HALL_SENSOR:
	{
		int nWorkstaion = nParam1;
		Info("Update Hall Status : {$} ", nWorkstaion);
		Info("Panel {$} WS:{$},Current OGP WS:{$} ", nID, nWorkstaion, (int)m_eWorkStation);

		m_stDeviceConfig.nWorkstation = nWorkstaion;
		break;
	}
	case EVT_STATUS_PING:
	{
		break;
	}
	case EVT_STATUS_RESTOREFILES:
	{
		string strTemp = pszMsg;
		Info("Restore calibration files");
		break;
	}
	case EVT_STATUS_LASTERROR:
	{
		m_strLastError = pszMsg;
		Info("Panel {$} LastError {$}", nID, pszMsg);

		break;
	}
	case PANEL_OFFSET_CAL:
	{
		if (OFFSET_IDLE == nParam1)
		{
			Info("Offset is Idle");
			m_CalibUnit->SetOffsetStatus("Idle");
		}
		else if (OFFSET_RUNNING == nParam1)
		{
			Info("Offset is Running");
			m_CalibUnit->SetOffsetStatus("Running");
		}
		else if (OFFSET_ERROR == nParam1)
		{
			Info("Offset is error");
			m_CalibUnit->SetOffsetStatus("Error");
		}
		break;
	}
	case PANEL_OFFSET_COUNT:
	{
		Info("OffsetTotal: {$}", nParam1);
		string strOffsetNode = to_string(nParam1);
		m_CalibUnit->SetOffsetCounts(strOffsetNode);
		break;
	}
	case PANEL_OFFSET_PROGRESS:
	{
		Info("OffsetProgress: {$}", nParam1);
		string strOffsetProgress = to_string(nParam1);
		m_CalibUnit->SetOffsetProgress(strOffsetProgress);
		break;
	}
	default:
	{
		break;
	}
	}
}


void nsFPD::FPDDeviceSensview::OnEventProcessData(int nDetectorID, int nEventID, int nEventLevel, const char* pszMsg, int nParam1, float fParam2, int nPtrParamLen, void* pParam)
{

	switch (nEventID)
	{
	case EVT_DATA_RAW_IMAGE:
	{
		Info("Image Arrved");
		Info("Currenct FPD RawImage Width: {$}, FullImage Height: {$}", m_nRawImgWidth, m_nRawImgHeight);
		float fImageReferUGY = 2.5;
		if (nullptr == m_pwRawImageData)
		{
			m_pwRawImageData = new WORD[m_nRawImgWidth * m_nRawImgHeight];
		}

		memcpy(m_pwRawImageData, pParam, m_nRawImgWidth * m_nRawImgHeight * sizeof(WORD));
		OnProcessImage(m_pwRawImageData, m_nFullImgWidth, m_nFullImgHeight, fImageReferUGY);
		break;
	}
	case EVT_DATA_PREVIEW_IMAGE:
	{
		Info("Preview Image Arrved");
		break;
	}
	case EVT_DATA_DOSEPARAM:
	{
		m_fDoseParam = nParam1;
		Info("calibration dose {$}, Param1 {$}", m_fDoseParam, nParam1);
		SetEvent(m_WaitCalibDoseEvt);
		break;
	}

	default:
	{
		break;
	}
	}
}

void nsFPD::FPDDeviceSensview::OnEventProcessError(int nDetectorID, int nEventID, int nEventLevel, const char* pszMsg, int nParam1, float fParam2, int nPtrParamLen, void* pParam)
{

	string strErrorName = "";

	switch (nEventID)
	{
	case EVT_ERR_COMMUNICATE:
	{
		strErrorName = ERR_FPD_DISCONNECT;

		string strTemp = pszMsg;
		if (strTemp.find("true") != std::string::npos)
		{
			m_stDeviceConfig.nWorkstation = -1;
			m_stDeviceConfig.bConnectStatus = false;
			m_nBatteryCapacity = 0;
			m_stDeviceConfig.nCurrentWifiValue = 0;
			m_stDeviceConfig.nCurrentBatteryValue = 0;

			SendWifiValue(0);
			SendBatteryValue(0);
			ProcessTempreatureOnLostCommunicate();

			OnError(strErrorName);

		}
		else if (strTemp.find("false") != std::string::npos)//成功时交给WIFI发送SendDetectorInfo
		{
			if (m_stDeviceConfig.nCurrentWifiValue != -1)
			{
				SendWifiValue(m_stDeviceConfig.nCurrentWifiValue);
				SendBatteryValue(m_stDeviceConfig.nCurrentBatteryValue);
				SendTemperatureValue(m_stDeviceConfig.fCurrentTemperValue);
			}
			m_stDeviceConfig.bConnectStatus = true;
			OnErrorX(strErrorName);
			OnErrorX(ERR_FPD_ACQ_FAILED);
		}
		break;
	}
	case EVT_ERR_EXP_REQUEST:
	{
		string strTemp = pszMsg;
		if (strTemp.find("true") != std::string::npos)
		{
			//帧曝光失败
		}
		else
		{
			return;
		}
		strErrorName = ERR_FPD_ACQ_FAILED;
		break;
	}
	case EVT_ERR_GET_IMAGE:
	{
		string strTemp = pszMsg;
		if (strTemp.find("true") != std::string::npos)
		{
			if (APP_STATUS_WORK_BEGIN != m_eAppStatus) //如果不在检查界面;
			{
				Fatal("there are image exist in current detector,do you want to continue");
			}
			else
			{
				Fatal("FPD has exposed Image!");
				CallSiemensRecoverAction(true);
			}
			//endif
		}
		else if (strTemp.find("false") != std::string::npos)
		{
			if (m_bRecoveringImage)
			{
				CallSiemensRecoverAction(false);
			}
			else
			{
				m_bAbortRecover = false; //终止恢复图像的变量也要重置
				m_bRecoveringImage = false; //不再恢复图像过程中
				m_nRecoverImageTimes = 0; //下次恢复图像，重置
			}
		}
		break;
	}
	case EVT_ERR_MAX_NUMBER:
	{
		strErrorName = ERR_FPD_MAX_NUMBER;

		string strTemp = pszMsg;
		if (strTemp.find("true") != std::string::npos)
		{
			Error("Exceed max number");
			OnError(strErrorName);
		}

		break;
	}

	case EVT_ERR_POWER_OFF:
	{
		strErrorName = ERR_FPD_POWEROFF;
		string strTemp = pszMsg;
		if (strTemp.find("true") != std::string::npos)
		{
			ProcessTempreatureOnLostCommunicate();
			OnError(strErrorName);
			m_stDeviceConfig.bConnectStatus = false;
		}
		else if (strTemp.find("false") != std::string::npos)
		{
			OnErrorX(strErrorName);

		}
		break;
	}
	case EVT_ERR_INIT_FAILED:
	{
		strErrorName = ERR_FPD_FATAL_ERROR;
		string strTemp = pszMsg;
		if (strTemp.find("true") != std::string::npos)
		{
			OnError(strErrorName);
			m_stDeviceConfig.bConnectStatus = false;
		}
		else if (strTemp.find("false") != std::string::npos)
		{
			OnErrorX(strErrorName);

		}
		break;
	}

	default:
	{

	}
	}
}

void nsFPD::FPDDeviceSensview::OnEventProcessWarning(int nDetectorID, int nEventID, int nEventLevel, const char* pszMsg, int nParam1, float fParam2, int nPtrParamLen, void* pParam)
{
	string strWarnName = "";
}


bool nsFPD::FPDDeviceSensview::OnInitResult(bool bSuccess)
{
	if (bSuccess)
	{
		m_stDeviceConfig.bConnectStatus = true;

		CheckCalibartionDue();
		m_stDeviceConfig.bInitOK = true;
	}
	else
	{

		m_stDeviceConfig.bConnectStatus = false;

	}

	m_stDeviceConfig.bExisted = true;

	auto temperuperror = m_stDeviceConfig.fTemperMaxLimit;
	auto temperlowerror = m_stDeviceConfig.fTemperMinLimit;
	auto temperupwarn = m_stDeviceConfig.fTemperUpLimit;
	auto temperlowwarn = m_stDeviceConfig.fTemperLowLimit;
	if (m_Temperature)
	{
		m_Temperature->SetTemperatureErrorMax(to_string(temperuperror));
		m_Temperature->SetTemperatureWarningMax(to_string(temperupwarn));
		m_Temperature->SetTemperatureCalibWarningMax(to_string(m_CalTemperupWarn));
		m_Temperature->SetTemperatureCalibWarningMin(to_string(m_CalTemperlowWarn));
		m_Temperature->SetTemperatureWarningMin(to_string(temperlowwarn));
		m_Temperature->SetTemperatureErrorMin(to_string(temperlowerror));
	}


	auto wifiWarning = m_stDeviceConfig.nWifiWarning;
	auto wifiError = m_stDeviceConfig.nWifiLimit;
	if (m_Wifi)
	{
		m_Wifi->SetSignalWarningMin(to_string(wifiWarning));
		m_Wifi->SetSignalErrorMin(to_string(wifiError));
	}

	return true;

}
//-----------------------------------------------------------------------------
//
// 函数名称	: CheckCalibartionDue
// 函数描述	: 检查校正文件是否过期
// 返回类型	: 过期true or false
// 接口参数	: 
//
//-----------------------------------------------------------------------------
bool nsFPD::FPDDeviceSensview::CheckCalibartionDue()
{
	Info("[Checking Calibration Date]");

	string strWarn = WAR_FPD_LOAD_CORRECT_FILE;
	if (!m_CalibProcess->CheckCalibartionDue(m_stDeviceConfig))
	{
		OnWarn(m_nDeviceIndex, strWarn);
		return false;
	}
	OnWarnX(strWarn);
	Info("[Calibration File is Normal]");
	return true;
}


bool nsFPD::FPDDeviceSensview::LoadSensitivity()
{
	Info("Load Sensitivity");
	return true;
}

RET_STATUS nsFPD::FPDDeviceSensview::SaveSensitivity()
{
	return RET_STATUS::RET_SUCCEED;
}


//预览图
bool nsFPD::FPDDeviceSensview::OnProcessPreviewImage(WORD* pwRawImage, int nWidth, int nHeight)
{
	Info("Currenct PreviewImage Width: {$}, Height: {$}", nWidth, nHeight);

	if (m_stDeviceConfig.nSaveRaw > 1)
	{
		SaveRawImage("PreviewImage.raw", pwRawImage, nWidth, nHeight);
	}

	PrevImageDateArrived(pwRawImage);
	Info("Write PreviewImage Over");
	return true;
}


//大图
bool nsFPD::FPDDeviceSensview::OnProcessImage(WORD* pwRawImage, int nImageWidth, int nImageHeight, float fImageReferUGY)
{
	Info("Process Full Image");
	Info("Image EXI2UGY factor: {$}, Image Refer UGY: {$}", m_fFactorEXI2UGY, fImageReferUGY);

	if (m_nFullImgWidth != m_nRawImgWidth || m_nFullImgHeight != m_nRawImgHeight)
	{
		Debug("Begin get effect image, RawImgWidth {$}\n", m_nRawImgWidth);
		if (!GetEffectiveImage(m_pwFullImageData, m_pwRawImageData, m_nRawImgWidth))
		{
			Error("Get effect image failed");
			return false;
		}
		Debug("Get effect image over");
	}
	else
	{
		memcpy(m_pwFullImageData, m_pwRawImageData, m_nFullImgWidth * m_nFullImgHeight * sizeof(WORD));
	}

	if (false)
	{
		m_AcqUnit->FlipX(m_pwFullImageData, m_nFullImgWidth, m_nFullImgHeight);
	}
	
	if (false)
	{
		m_AcqUnit->FlipY(m_pwFullImageData, m_nFullImgWidth, m_nFullImgHeight);
	}

	if (m_stDeviceConfig.AcqModeInfo.nRotateAngle != 0)
	{
		m_AcqUnit->RotateImage(m_pwFullImageData, m_nFullImgHeight, m_nFullImgWidth, m_stDeviceConfig.AcqModeInfo.nRotateAngle);
	}

	if (m_bSaveRaw)
	{
		string strImageName = "AfterProcess_" + to_string(m_pDetectors->m_nFrameID) + ".raw";
		SaveRawImage(strImageName.c_str(), m_pwFullImageData, m_nFullImgWidth, m_nFullImgHeight);
	}

	m_pwFullImageData[0] = 65535;
	//图像预处理完成
	FullImageDateArrived(m_pwFullImageData);
	Info("Write Frame Over");

	/*if (m_stDeviceConfig.AcqModeInfo.strExamType.find("RAD") != std::string::npos)
	{
		Info("Rad stop.");
		m_pDetectors->m_bGrabStatus = false;
	}*/
	return true;
}


// pOutImg: 裁剪后图像;	pInImg: 裁剪前图像;	nInWidth: 裁剪前图像宽度
bool nsFPD::FPDDeviceSensview::GetEffectiveImage(WORD* pOutImg, WORD* pInImg, int nInWidth)
{
	if (pOutImg == NULL || pInImg == NULL || nInWidth < 0)
	{
		Error("Illegal parameter, can not get effective image");
		return false;
	}
	try
	{
		for (int i = 0; i < m_nFullImgHeight; i++)
		{
			memcpy(pOutImg + i * m_nFullImgWidth, pInImg + (i + m_nTopOffset) * nInWidth + m_nLeftOffset, m_nFullImgWidth * sizeof(WORD));
		}
	}
	catch (...)
	{
		Error("Get effective image crashed.\n");
		return false;
	}
	return true;
}


void nsFPD::FPDDeviceSensview::OnProcessTemperature(int nID, float fTemperature)
{
	string strWarnErrorCode = "";

	auto lowerror = m_stDeviceConfig.fTemperMinLimit;
	auto uperror = m_stDeviceConfig.fTemperMaxLimit;
	auto lowwarn = m_stDeviceConfig.fTemperLowLimit;
	auto upwarn = m_stDeviceConfig.fTemperUpLimit;
	auto calupwarn = m_CalTemperupWarn;
	auto callowwarn = m_CalTemperlowWarn;

	//should be lowerror < lowwarn < callowwarn < calupwarn < upwarn < uperror

	m_stDeviceConfig.nTemperatureStatus = TEMP_NORMAL;

	if (fTemperature > callowwarn && fTemperature < calupwarn)
	{
		//normal,clear all warns&errors
		OnWarnX(WAR_FPD_EXCEED_CALB_TEMPER_HIGH);
		OnWarnX(WAR_FPD_EXCEED_CALB_TEMPER_LOW);
		OnWarnX(WAR_FPD_TEMPERTURE_LOW);
		OnWarnX(WAR_FPD_TEMPERATURE_HIGH);
		OnErrorX(ERR_FPD_TEMPHIGH_NOT_ACQ);
		OnErrorX(ERR_FPD_TEMPLOW_NOT_ACQ);
	}
	else if ((fTemperature <= callowwarn && fTemperature > lowwarn) || (fTemperature >= calupwarn && fTemperature < upwarn))
	{//out of cal range

		Info("Exceed Calibration Temperature");

		m_stDeviceConfig.nTemperatureStatus = TEMP_WARNING;

		OnWarnX(WAR_FPD_TEMPERTURE_LOW);
		OnWarnX(WAR_FPD_TEMPERATURE_HIGH);
		OnErrorX(ERR_FPD_TEMPHIGH_NOT_ACQ);
		OnErrorX(ERR_FPD_TEMPLOW_NOT_ACQ);

		strWarnErrorCode = WAR_FPD_EXCEED_CALB_TEMPER_HIGH;
		if (fTemperature <= callowwarn && fTemperature > lowwarn)
		{
			OnWarnX(WAR_FPD_EXCEED_CALB_TEMPER_HIGH);
			strWarnErrorCode = WAR_FPD_EXCEED_CALB_TEMPER_LOW;
		}
		else
		{
			OnWarnX(WAR_FPD_EXCEED_CALB_TEMPER_LOW);
		}

		OnWarn(nID, strWarnErrorCode);

	}
	else if (fTemperature > lowerror && fTemperature <= lowwarn)
	{//low warn

		Info("Exceed Temperature Low Warning");

		m_stDeviceConfig.nTemperatureStatus = TEMP_WARNING;

		OnWarnX(WAR_FPD_EXCEED_CALB_TEMPER_HIGH);
		OnWarnX(WAR_FPD_EXCEED_CALB_TEMPER_LOW);
		OnWarnX(WAR_FPD_TEMPERATURE_HIGH);
		OnErrorX(ERR_FPD_TEMPHIGH_NOT_ACQ);
		OnErrorX(ERR_FPD_TEMPLOW_NOT_ACQ);

		strWarnErrorCode = WAR_FPD_TEMPERTURE_LOW;
		OnWarn(nID, strWarnErrorCode);

	}
	else if (fTemperature <= lowerror)
	{//low error

		Info("Exceed Min Temperature");

		m_stDeviceConfig.nTemperatureStatus = TEMP_TOO_LOW;
		OnWarnX(WAR_FPD_EXCEED_CALB_TEMPER_HIGH);
		OnWarnX(WAR_FPD_EXCEED_CALB_TEMPER_LOW);
		OnWarnX(WAR_FPD_TEMPERTURE_LOW);
		OnWarnX(WAR_FPD_TEMPERATURE_HIGH);
		OnErrorX(ERR_FPD_TEMPHIGH_NOT_ACQ);

		strWarnErrorCode = ERR_FPD_TEMPLOW_NOT_ACQ;
		OnError(strWarnErrorCode);
	}
	else if (fTemperature >= upwarn && fTemperature < uperror)
	{//up warn

		Info("Exceed Temperature High Warning");

		m_stDeviceConfig.nTemperatureStatus = TEMP_WARNING;

		OnWarnX(WAR_FPD_EXCEED_CALB_TEMPER_HIGH);
		OnWarnX(WAR_FPD_EXCEED_CALB_TEMPER_LOW);
		OnWarnX(WAR_FPD_TEMPERTURE_LOW);
		OnErrorX(ERR_FPD_TEMPHIGH_NOT_ACQ);
		OnErrorX(ERR_FPD_TEMPLOW_NOT_ACQ);

		strWarnErrorCode = WAR_FPD_TEMPERATURE_HIGH;
		OnWarn(nID, strWarnErrorCode);
	}
	else if (fTemperature >= uperror)
	{//up error

		Info("Exceed Max Temperature");

		m_stDeviceConfig.nTemperatureStatus = TEMP_TOO_HIGH;

		OnWarnX(WAR_FPD_EXCEED_CALB_TEMPER_HIGH);
		OnWarnX(WAR_FPD_EXCEED_CALB_TEMPER_LOW);
		OnWarnX(WAR_FPD_TEMPERTURE_LOW);
		OnWarnX(WAR_FPD_TEMPERATURE_HIGH);
		OnErrorX(ERR_FPD_TEMPLOW_NOT_ACQ);

		strWarnErrorCode = ERR_FPD_TEMPHIGH_NOT_ACQ;
		OnError(strWarnErrorCode);
	}
}



void nsFPD::FPDDeviceSensview::Action_ExpReady()
{
	m_SyncUnit->FPDReadyNotify(true);
}



RET_STATUS nsFPD::FPDDeviceSensview::SetFluPPS(float fFluPPS)
{
	Info("=====SetFluPPS: {$}", fFluPPS);

	m_fCurrentPPS = fFluPPS;

	if (!m_pDetectors->SetFluPPS(fFluPPS))
	{
		return RET_STATUS::RET_FAILED;
	}
	m_AcqUnit->FluPPSNotify(fFluPPS);
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::FPDDeviceSensview::GetFluPPS(float& fFluPPS)
{
	m_pDetectors->GetFluPPS(fFluPPS);
	return RET_STATUS::RET_SUCCEED;
}


//刷新暗场
RET_STATUS nsFPD::FPDDeviceSensview::StartOffset(bool isAll)
{
	Info("StartOffset: {$}", isAll);
	if (!m_pDetectors->StartOffset(isAll))
	{
		Error("Start offset failed!");
		return RET_STATUS::RET_FAILED;
	}
	m_nCurrentMode = -1;
	Info("StartOffset over");
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::FPDDeviceSensview::AbortOffset()
{
	Info("AbortOffset");
	return RET_STATUS::RET_SUCCEED;
}


bool nsFPD::FPDDeviceSensview::SaveConfigFile(bool bSendNotify)
{
	m_DetectorConfiguration->SaveConfig();
	Info("SaveConfigFile over");
	return true;
}


RET_STATUS nsFPD::FPDDeviceSensview::SetSID(int nSID)
{
	if (nSID < 0 || nSID > 200)
	{
		return RET_STATUS::RET_INVALID;
	}
	m_stDeviceConfig.nSID = nSID;
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::FPDDeviceSensview::UploadCalibrationFiles(string strFileName)
{
	RET_STATUS Ret = RET_STATUS::RET_SUCCEED;
	return Ret;
}


RET_STATUS  nsFPD::FPDDeviceSensview::GetRecoverImageState(string& RCI)
{
	Info("GetRecoverImageState");
	m_bSendRecoverMessage = true;
	RCI = m_RecoverImageStatus.encode();
	return RET_STATUS::RET_SUCCEED;
}

RET_STATUS nsFPD::FPDDeviceSensview::RecoverImage(bool bRecoverIt)
{
	Info("Recover Image {$}", bRecoverIt);
	m_bUIConfirmRecover = true;
	int nRecoverOrNot = 0;
	if (bRecoverIt)
	{
		nRecoverOrNot = 1;
	}
	if (nRecoverOrNot != 0)
	{
		string strResult = (string)m_RecoverImageStatus["Result"];
		if (strResult == "0")
		{
			Info("already recover success,just return");
			return RET_STATUS::RET_SUCCEED;
		}

		m_RecoverImageStatus["Result"] = "1";
		m_DetectorCtrlUnit->SetRecoverImageState(m_RecoverImageStatus.encode());

		if (!(m_pDetectors)->RecoverLastImage())
		{
			m_RecoverImageStatus["Result"] = "2";
			m_DetectorCtrlUnit->SetRecoverImageState(m_RecoverImageStatus.encode());
			m_bUIConfirmRecover = false;
		}
		m_nRecoverImageTimes++;
	}
	else
	{
		Info("Abort Recovering Image");
		m_bAbortRecover = true; //终止恢复图像的变量也要重置
		m_bRecoveringImage = false; //不再恢复图像过程中
		m_nRecoverImageTimes = 0; //下次恢复图像，重置
		m_pDetectors->CancelImageRecover();
		if (m_stDeviceConfig.bConnectStatus)
		{
			OnError(ERR_FPD_IMAGE_PENDING);
		}
		else
		{
			OnError(ERR_FPD_IMAGE_PENDING);
			OnError(ERR_FPD_DISCONNECT);
		}

	}
	return RET_STATUS::RET_SUCCEED;
}


bool nsFPD::FPDDeviceSensview::CallSiemensRecoverAction(bool bErrorResult)
{
	string strRecoverInfo = "";
	if (bErrorResult)
	{
		if (m_bAbortRecover)
		{
			Info("Recover Image is Cancelled");
			return true;
		}

		SendWifiValue(0);
		SendBatteryValue(0);
		SendTemperatureValue(ABS_ZERO_TEMPERATURE);

		if (!m_bRecoveringImage)
		{
			m_RecoverImageStatus["Result"] = "-1";//新的imagerecover流程开始，防止之前成功recover过，上层查询状态引发误解
			m_DetectorCtrlUnit->SetRecoverImageEvent("0");
			OnError(ERR_FPD_IMAGE_PENDING);
			m_bRecoveringImage = true;
			m_bUIConfirmRecover = false;

			m_DetectorCtrlUnit->SetRecoverImageState(m_RecoverImageStatus.encode());

			Info("SetRecoverImageEvent");

			return true;
		}

		m_RecoverImageStatus["Result"] = "2";

	}
	else
	{
		m_bAbortRecover = false; //终止恢复图像的变量也要重置
		m_bRecoveringImage = false; //不再恢复图像过程中
		m_nRecoverImageTimes = 0; //下次恢复图像，重置
		if (m_bUIConfirmRecover)
		{
			Info("Recover Image Success");
			m_RecoverImageStatus["Result"] = "0";
			Info("m_RecoverImageStatus[Result] = 0");
			m_DetectorCtrlUnit->SetRecoverImageState(m_RecoverImageStatus.encode());
			m_bUIConfirmRecover = false;
			Info("send RecoverImageState over");
		}
		else
		{
			m_RecoverImageStatus["Result"] = "3";
			Info("m_RecoverImageStatus[Result] = 3");
			m_DetectorCtrlUnit->SetRecoverImageState(m_RecoverImageStatus.encode());

			Warn("UI do not confirm, image have been abandoned");

			m_RecoverImageStatus["Result"] = "0";
			m_AcqUnit->SendNoNeedWaitImage(true);
		}

		return true;

	}

	Info("CallSiemensRecoverAction {$}", m_RecoverImageStatus.encode());

	if (m_bSendRecoverMessage)
	{
		if (m_bUIConfirmRecover)
		{
			m_DetectorCtrlUnit->SetRecoverImageState(m_RecoverImageStatus.encode());
			m_bUIConfirmRecover = false;
			Info("send RecoverImageState over");
		}
		else
		{
			Warn("UI do not confirm omit send result");
		}
	}

	return true;
}


RET_STATUS nsFPD::FPDDeviceSensview::GetDetectorInfo(string& strFDI)
{
	ResDataObject strDetectorInfo;
	string strTempTemp = " ";

	Info("Get Detector Info");

	if (m_stDeviceConfig.strPanelSerial == "")
	{
		Info("Get Detector Info Failed");

		strDetectorInfo.add("DetectorName", "Simulator");
		strDetectorInfo.add("DetectorSN", "Simulator");
		strDetectorInfo.add("Firmware", " ");
		strDetectorInfo.add("APFirmware", " ");
		strDetectorInfo.add("Software", "1.0.0.1");
		strDetectorInfo.add("SSID", " ");
		strDetectorInfo.add("LifeTime", "0");
		strDetectorInfo.add("PowerOn", "0");
		strDetectorInfo.add("DateCode", " ");
		strDetectorInfo.add("PartNumber", " ");
		strDetectorInfo.add("WifiDataRate", " ");
		strDetectorInfo.add("WifiChannel", "0");
		strDetectorInfo.add("DetectorExist", "0");
		strDetectorInfo.add("SystemAS", "0");
		strDetectorInfo.add("CalibrationDate", "0");
		strDetectorInfo.add("CalibrationDue", "0");
		strDetectorInfo.add("CalibrationExist", "0");
		strDetectorInfo.add("CommunicationStatus", "0");
		strDetectorInfo.add("DetectorTemperature", "0");
		strDetectorInfo.add("FDCalibrationTemperature", "0");
		strDetectorInfo.add("TemperatureStatus", "0");
		strDetectorInfo.add("WaitTime", "0");
		strDetectorInfo.add("DetectorWifiSignal", "0");
		strDetectorInfo.add("DetectorBattery", "0");
		strDetectorInfo.add("ShockSensor", "NULL");
		strDetectorInfo.add("FirmwareUpdate", "0");
		//encode

		strFDI = strDetectorInfo.encode();

		return RET_STATUS::RET_SUCCEED;
	}

	strDetectorInfo.add("DetectorName", m_stDeviceConfig.strDeviceName.c_str());
	strDetectorInfo.add("DetectorSN", m_stDeviceConfig.strPanelSerial.c_str());
	strDetectorInfo.add("Firmware", m_stDeviceConfig.strFirmware.c_str());
	strDetectorInfo.add("APFirmware", "NULL");
	strDetectorInfo.add("Software", "1.0.0.1");
	strDetectorInfo.add("SSID", m_stDeviceConfig.strWifiSSID.c_str());
	strDetectorInfo.add("LifeTime", "0");
	strDetectorInfo.add("PowerOn", "0");
	if (m_strSelfTest != "")
	{
		ResDataObject strDetectorSelfTest;
		strDetectorSelfTest.decode(m_strSelfTest.c_str());
		strDetectorInfo += strDetectorSelfTest;
	}
	strDetectorInfo.add("FD_Voltage_List1", "NULL");
	strDetectorInfo.add("DateCode", m_stDeviceConfig.strDateCode.c_str());
	strDetectorInfo.add("PartNumber", m_stDeviceConfig.strPartNumber.c_str());
	strDetectorInfo.add("WifiDataRate", m_stDeviceConfig.nWifiDataRate);
	strDetectorInfo.add("WifiChannel", m_stDeviceConfig.nWifiChannel);
	strDetectorInfo.add("DetectorExist", m_stDeviceConfig.bExisted);

	strDetectorInfo.add("SystemAS", m_stDeviceConfig.nWorkstation);
	Info("DetectorCalibrationDate {$}", m_stDeviceConfig.strCalibrationDate.c_str());
	if (m_stDeviceConfig.strCalibrationDate != " ")
	{
		if (m_stDeviceConfig.strCalibrationDate.find("19700101") != std::string::npos)
		{
			Info("find 19700101");
			strDetectorInfo.add("CalibrationDate", "0");
			strDetectorInfo.add("CalibrationDue", "0");
			strDetectorInfo.add("CalibrationExist", 0);
		}
		else
		{
			strDetectorInfo.add("CalibrationDate", m_stDeviceConfig.strCalibrationDate.c_str());
			strDetectorInfo.add("CalibrationDue", m_stDeviceConfig.strCalibrationDue.c_str());
			strDetectorInfo.add("CalibrationExist", 1);
		}
	}
	else
	{
		strDetectorInfo.add("CalibrationDate", "0");
		strDetectorInfo.add("CalibrationDue", "0");
		strDetectorInfo.add("CalibrationExist", 0);
	}

	if (m_stDeviceConfig.bConnectStatus)
	{
		strDetectorInfo.add("CommunicationStatus", 1);
	}
	else
	{
		strDetectorInfo.add("CommunicationStatus", 0);
	}

	strDetectorInfo.add("FDCalibrationTemperature", m_stDeviceConfig.fCalibTemperature);
	strDetectorInfo.add("ShockSensor", m_nShockCounts);
	strDetectorInfo.add("FirmwareUpdate", 0);

	Trace("{$}", strDetectorInfo.encode());


	strFDI = strDetectorInfo.encode();

	return RET_STATUS::RET_SUCCEED;
}

string nsFPD::FPDDeviceSensview::MakeImageHead(IMAGE_VIEW_TYPE Type)
{
	if (Type == IMAGE_FULL)
	{
		if (m_pFullImageHead == nullptr)
		{
			m_pFullImageHead = new ResDataObject;
			ResDataObject json;
			json.add(SM_IMAGE_TYPE, (int)Type);
			json.add(SM_IMAGE_WIDTH, m_nFullImgWidth);
			json.add(SM_IMAGE_HEIGHT, m_nFullImgHeight);
			json.add(SM_IMAGE_BIT, 16);
			json.add(SM_IMAGE_TAG, 1);
			json.add(SM_IMAGE_INDEX, 1);
			json.add(SM_IMAGE_YEAR, m_stImgCreateTime.wYear);
			json.add(SM_IMAGE_MONTH, m_stImgCreateTime.wMonth);
			json.add(SM_IMAGE_DAY, m_stImgCreateTime.wDay);
			json.add(SM_IMAGE_HOUR, m_stImgCreateTime.wHour);
			json.add(SM_IMAGE_MINUTE, m_stImgCreateTime.wMinute);
			json.add(SM_IMAGE_SEC, m_stImgCreateTime.wSecond);
			json.add(SM_IMAGE_MILLSEC, m_stImgCreateTime.wMilliseconds);
			json.add(SM_IMAGE_LSB, "5000");
			json.add(SM_IMAGE_DOSE, m_stDeviceConfig.nDoseOfEXI);
			json.add(SM_IMAGE_PIXELREPRESENTATION, "0");
			json.add(SM_IMAGE_PIXELSPACING, m_nPixelPitch);
			json.add(SM_IMAGE_ROTATION, "No");
			json.add(SM_IMAGE_FLIP, "No");
			json.add(SM_IMAGE_ORIGINX, "0");
			json.add(SM_IMAGE_ORIGINY, "0");
			json.add(SM_IMAGE_EXI2UGY, m_fFactorEXI2UGY);
			json.add(SM_IMAGE_TEMP, m_stDeviceConfig.fCurrentTemperValue);
			m_pFullImageHead->add(SM_IMAGE_HEAD, json);
		}
		else
		{
			(*m_pFullImageHead)[SM_IMAGE_HEAD][SM_IMAGE_YEAR] = m_stImgCreateTime.wYear;
			(*m_pFullImageHead)[SM_IMAGE_HEAD][SM_IMAGE_MONTH] = m_stImgCreateTime.wMonth;
			(*m_pFullImageHead)[SM_IMAGE_HEAD][SM_IMAGE_DAY] = m_stImgCreateTime.wDay;
			(*m_pFullImageHead)[SM_IMAGE_HEAD][SM_IMAGE_HOUR] = m_stImgCreateTime.wHour;
			(*m_pFullImageHead)[SM_IMAGE_HEAD][SM_IMAGE_MINUTE] = m_stImgCreateTime.wMinute;
			(*m_pFullImageHead)[SM_IMAGE_HEAD][SM_IMAGE_SEC] = m_stImgCreateTime.wSecond;
			(*m_pFullImageHead)[SM_IMAGE_HEAD][SM_IMAGE_MILLSEC] = m_stImgCreateTime.wMilliseconds;
			(*m_pFullImageHead)[SM_IMAGE_HEAD][SM_IMAGE_TEMP] = m_stDeviceConfig.fCurrentTemperValue;
		}

		return (*m_pFullImageHead).encode();
	}
	else
	{
		if (m_pPreviewImageHead == NULL)
		{
			m_pPreviewImageHead = new ResDataObject;
			ResDataObject json;
			json.add(SM_IMAGE_TYPE, (int)Type);
			json.add(SM_IMAGE_WIDTH, m_stDeviceConfig.nPreviewWidth);
			json.add(SM_IMAGE_HEIGHT, m_stDeviceConfig.nPreviewHeight);
			json.add(SM_IMAGE_BIT, 16);
			json.add(SM_IMAGE_TAG, 1);
			json.add(SM_IMAGE_INDEX, 1);
			json.add(SM_IMAGE_YEAR, m_stImgCreateTime.wYear);
			json.add(SM_IMAGE_MONTH, m_stImgCreateTime.wMonth);
			json.add(SM_IMAGE_DAY, m_stImgCreateTime.wDay);
			json.add(SM_IMAGE_HOUR, m_stImgCreateTime.wHour);
			json.add(SM_IMAGE_MINUTE, m_stImgCreateTime.wMinute);
			json.add(SM_IMAGE_SEC, m_stImgCreateTime.wSecond);
			json.add(SM_IMAGE_MILLSEC, m_stImgCreateTime.wMilliseconds);
			json.add(SM_IMAGE_LSB, "5000");
			json.add(SM_IMAGE_DOSE, m_stDeviceConfig.nDoseOfEXI);
			json.add(SM_IMAGE_ROTATION, "No");
			json.add(SM_IMAGE_FLIP, "No");
			json.add(SM_IMAGE_ORIGINX, "0");
			json.add(SM_IMAGE_ORIGINY, "0");
			json.add(SM_IMAGE_PIXELSPACING, m_nPixelPitch);
			json.add(SM_IMAGE_PIXELREPRESENTATION, "0");
			json.add(SM_IMAGE_TEMP, m_stDeviceConfig.fCurrentTemperValue);
			m_pPreviewImageHead->add(SM_IMAGE_HEAD, json);
		}
		else
		{
			(*m_pPreviewImageHead)[SM_IMAGE_HEAD][SM_IMAGE_YEAR] = m_stImgCreateTime.wYear;
			(*m_pPreviewImageHead)[SM_IMAGE_HEAD][SM_IMAGE_MONTH] = m_stImgCreateTime.wMonth;
			(*m_pPreviewImageHead)[SM_IMAGE_HEAD][SM_IMAGE_DAY] = m_stImgCreateTime.wDay;
			(*m_pPreviewImageHead)[SM_IMAGE_HEAD][SM_IMAGE_HOUR] = m_stImgCreateTime.wHour;
			(*m_pPreviewImageHead)[SM_IMAGE_HEAD][SM_IMAGE_MINUTE] = m_stImgCreateTime.wMinute;
			(*m_pPreviewImageHead)[SM_IMAGE_HEAD][SM_IMAGE_SEC] = m_stImgCreateTime.wSecond;
			(*m_pPreviewImageHead)[SM_IMAGE_HEAD][SM_IMAGE_MILLSEC] = m_stImgCreateTime.wMilliseconds;
			(*m_pPreviewImageHead)[SM_IMAGE_HEAD][SM_IMAGE_TEMP] = m_stDeviceConfig.fCurrentTemperValue;
		}

		return (*m_pPreviewImageHead).encode();
	}

	return "";
}

RET_STATUS nsFPD::FPDDeviceSensview::AddFrameWithRawHead(IMAGE_VIEW_TYPE Type, WORD* pFrameBuff, DWORD FrameSize)
{
	string strImageHead = MakeImageHead(Type);
	return m_AcqUnit->AddFrameWithRawHead(Type, strImageHead, pFrameBuff, FrameSize);

}

void nsFPD::FPDDeviceSensview::ClearAllError()
{
	m_WarnAndError->ClearAllError();
}

void nsFPD::FPDDeviceSensview::SyncErrorList()
{
	if (m_WarnAndError)
	{
		m_WarnAndError->SyncErrorList();
	}
}

void nsFPD::FPDDeviceSensview::OnErrorX(string strErrCode)
{
	bool bExit = false;
	if (m_WarnAndError->IsErrorExist(strErrCode))
	{
		bExit = true;
	}

	m_WarnAndError->OnErrorX(strErrCode);

	int nErrNum = m_WarnAndError->GetExistErrorNum();
}

void nsFPD::FPDDeviceSensview::OnError(string strErrCode, string strErr)
{
	string strBackCom = "";

	m_WarnAndError->OnError(strErrCode, strErr);
}

void nsFPD::FPDDeviceSensview::OnWarn(int nIndex, string strWarnCode, string strWarn)
{

	m_WarnAndError->OnWarn(strWarnCode, strWarn);
}

void nsFPD::FPDDeviceSensview::OnWarnX(string strWarnCode)
{
	m_WarnAndError->OnWarnX(strWarnCode);
}

RET_STATUS  nsFPD::FPDDeviceSensview::ResetError()
{
	Info("ResetError");

	OnErrorX(ERR_FPD_DOSE_LOW);
	OnErrorX(ERR_FPD_DOSE_HIGH);
	OnErrorX(ERR_FPD_DOSE_OBJ); //清除之前的错误，如果有的话

	return RET_STATUS::RET_SUCCEED;
}


void nsFPD::FPDDeviceSensview::SendAllError()
{
	m_WarnAndError->SendAllError();
}

void nsFPD::FPDDeviceSensview::ProcessTempreatureOnLostCommunicate()
{
	SendTemperatureValue(ABS_ZERO_TEMPERATURE);

	OnWarnX(WAR_FPD_EXCEED_CALB_TEMPER_HIGH);
	OnWarnX(WAR_FPD_EXCEED_CALB_TEMPER_LOW);
	OnWarnX(WAR_FPD_TEMPERTURE_LOW);
	OnWarnX(WAR_FPD_TEMPERATURE_HIGH);
	OnErrorX(ERR_FPD_TEMPHIGH_NOT_ACQ);
	OnErrorX(ERR_FPD_TEMPLOW_NOT_ACQ);

	OnWarnX(WAR_FPD_WIFI_LOW);
	OnWarnX(WAR_FPD_BATTERY_LOW);
	OnErrorX(ERR_FPD_WIFI_LOW);
	OnErrorX(ERR_FPD_BATTERY_LOW);
}

void nsFPD::FPDDeviceSensview::ResetAllError()
{
	OnWarnX(WAR_FPD_EXCEED_CALB_TEMPER_HIGH);
	OnWarnX(WAR_FPD_EXCEED_CALB_TEMPER_LOW);
	OnWarnX(WAR_FPD_TEMPERTURE_LOW);
	OnWarnX(WAR_FPD_TEMPERATURE_HIGH);
	OnErrorX(ERR_FPD_TEMPHIGH_NOT_ACQ);
	OnErrorX(ERR_FPD_TEMPLOW_NOT_ACQ);
	OnWarnX(WAR_FPD_LOAD_CORRECT_FILE);
	OnWarnX(WAR_FPD_WIFI_LOW);
	OnWarnX(WAR_FPD_MAX_SHOCK_NUM);
	OnWarnX(WAR_FPD_IN_INITIAL);
	OnWarnX(WAR_FPD_BATTERY_LOW);
	OnErrorX(ERR_FPD_WIFI_LOW);
	OnErrorX(ERR_FPD_BATTERY_LOW);
	OnErrorX(ERR_FPD_DISCONNECT);
	OnErrorX(ERR_FPD_POWEROFF);
	OnErrorX(ERR_FPD_ACQ_FAILED);
	OnErrorX(ERR_FPD_DOSE_LOW);
	OnErrorX(ERR_FPD_DOSE_HIGH);
	OnErrorX(ERR_FPD_DOSE_OBJ);
	OnErrorX(ERR_FPD_IMAGE_PENDING);
	OnErrorX(ERR_FPD_FATAL_ERROR);
}


RET_STATUS nsFPD::FPDDeviceSensview::SetCorrectionType(CCOS_CORRECTION_TYPE in)
{
	return RET_STATUS::RET_SUCCEED;

}


int nsFPD::FPDDeviceSensview::GetTotalAcqModeNum()
{
	return m_DetectorConfiguration->m_nDetModeNum;
}


RET_STATUS nsFPD::FPDDeviceSensview::SetBinningMode(int nBinningX, int nBinningY)
{
	Info("SetBinningMode: {$}x{$}", nBinningX, nBinningY);
	if (nBinningX == 1 && nBinningY == 1)
	{
		int nBinningMode = 1;
	}
	else if (nBinningX == 2 && nBinningY == 2)
	{
		int nBinningMode = 2;
	}
	return RET_STATUS::RET_SUCCEED;
}


RET_STATUS nsFPD::FPDDeviceSensview::UpdateModeInRunning(std::vector<AcqModeInfo>& vAcqModeList)
{
	Info("UpdateModeInRunning===");
	m_vAcqModeInfoList.assign(vAcqModeList.begin(), vAcqModeList.end());
	for (size_t i = 0; i < m_vAcqModeInfoList.size(); i++)
	{
		Info("ModeID: {$}; Frequency: {$}", m_vAcqModeInfoList[i].nModeID, m_vAcqModeInfoList[i].fFrequency);
	}
	return RET_STATUS::RET_SUCCEED;
}