PhysicalDevice/Detector/CareRay/DIOS.Dev.FPD.CareRayDM/DIOS.Dev.FPD.CareRay.cpp

#include "stdafx.h"
#include "FileVersion.hpp"
#include "CCOS.Dev.FPD.CareRay.h"
#include "common_api.h"
#include "DICOMImageHeadKey.h"
#include "CareRayCtrl.h"

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

extern const char* g_szMouldPath;

Log4CPP::Logger* gLogger = nullptr;

static std::unique_ptr <CareRayCtrl> g_pDetector;

static nsFPD::CareRayDriver  gIODriver;

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


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


nsFPD::CareRayDriver::CareRayDriver()
{
	pObjDev = nullptr;
	m_bConnect = false; //缺省为false
	m_pAttribute.reset(new ResDataObject());
	m_pDescription.reset(new ResDataObject());
}


nsFPD::CareRayDriver::~CareRayDriver()
{
	//貌似已经被上层释放了，此处再次释放会崩溃
	//if (nullptr != pObjDev)
	//{
	//	delete pObjDev;
	//	pObjDev = nullptr;
	//}
}


void nsFPD::CareRayDriver::Prepare()
{
	string strWorkPath = GetProcessDirectory();
	string strLogPath = strWorkPath + DetectorLogPath;
	Log4CPP::GlobalContext::Map::Set(ZSKK::Utility::Hash("LogFileName"), "FPD.CareRayDM");
	auto rc = Log4CPP::LogManager::LoadConfigFile(strLogPath.c_str());
	gLogger = Log4CPP::LogManager::GetLogger("FPD.CareRayDM");

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

	FINFO(__FUNCTION__);
}


bool nsFPD::CareRayDriver::Connect()
{
	FINFO(__FUNCTION__);

	pObjDev = new FPDDeviceCareRay(EventCenter, m_ConfigFileName);
	m_bConnect = true; //connect执行完毕，置为true
	return true;
}


void nsFPD::CareRayDriver::Disconnect()
{
	FINFO(__FUNCTION__);
	m_bConnect = false; //disconnect置为false
}


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


auto nsFPD::CareRayDriver::CreateDevice(int index)->std::unique_ptr <IODevice>
{
	FINFO(__FUNCTION__);

	auto Device = std::unique_ptr<IODevice>(new IODevice(pObjDev));
	if (!pObjDev->CreateDevice())
	{
		return nullptr;
	}
	pObjDev->Register();
	return Device;
}


std::string nsFPD::CareRayDriver::DriverProbe()
{
	Debug(__FUNCTION__);
	ResDataObject r_config, HardwareInfo;
	if (r_config.loadFile(m_ConfigFileName.c_str()))
	{
		auto Child = r_config[NODE_CONFIGURATION];
		HardwareInfo.add(NODE_MajorID, Child[NODE_MajorID]);
		HardwareInfo.add(NODE_MinorID, Child[NODE_MinorID]);
		HardwareInfo.add(NODE_VendorID, Child[NODE_VendorID]);
		HardwareInfo.add(NODE_ProductID, Child[NODE_ProductID]);
		HardwareInfo.add(NODE_SerialID, Child[NODE_SerialID]);
	}
	else
	{
		HardwareInfo.add(NODE_MajorID, "Detector");
		HardwareInfo.add(NODE_MinorID, "Driver");
		HardwareInfo.add(NODE_VendorID, "CareRay");
		HardwareInfo.add(NODE_ProductID, "CareRay");
		HardwareInfo.add(NODE_SerialID, "1234");
	}
	string str = HardwareInfo.encode();
	return str;
}


/***
** 获取ID和配置
***/
std::string nsFPD::CareRayDriver::GetResource()
{
	printf("CareRay driver: GetResource m_ConfigFileName:%s\r\n", m_ConfigFileName.c_str());
	FINFO("CareRay driver: GetResource m_ConfigFileName:{$}", m_ConfigFileName.c_str());

	ResDataObject temp;
	if (!temp.loadFile(m_ConfigFileName.c_str()))
	{
		FERROR("Load {$} failed!!!", m_ConfigFileName.c_str());
		return "";
	}
	m_ConfigAll = temp;
	m_Configurations = temp["CONFIGURATION"];

	ResDataObject DescriptionTemp;
	ResDataObject ListTemp;
	string strTemp = ""; //用于读取字符串配置信息
	string strIndex = ""; //用于读取配置信息中的List项
	int nTemp = -1; //用于读取整型配置信息
	string strValue = ""; //用于存储配置的值
	string strType = ""; //用于存储配置的类型 int/float/string...
	string strAccess = ""; //用于存储权限的类型 R/W/RW
	string strRequired = ""; // TRUE/FALSE
	string strDefaultValue = "";
	string strRangeMin = "";
	string strRangeMax = "";

	try
	{
		int nConfigInfoCount = (int)m_Configurations["ConfigToolInfo"].GetKeyCount("AttributeInfo");
		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());
			strType = strTemp; //记录配置项的类型

			//AttributeKey
			//1. 根据AttributeType，内部key和配置路径，拿到当前的真实值
			strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["InnerKey"];
			nTemp = (int)m_Configurations["ConfigToolInfo"][nInfoIndex]["PathID"];
			GetDeviceConfigValue(m_Configurations, 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()));
			}
			else if ("float" == strType)
			{
				(*m_pAttribute).add(strTemp.c_str(), atof(strValue.c_str()));
			}
			else //其它先按string类型处理
			{
				(*m_pAttribute).add(strTemp.c_str(), strValue.c_str());
			}

			//AttributeAccess
			strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeDescripition"]["Access"];
			DescriptionTemp.add(AttributeAccess, strTemp.c_str());

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

			//AttributeRangeMax
			strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeDescripition"]["RangeMax"];
			if (strTemp != "") //不需要的配置项为空
			{
				DescriptionTemp.add(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];
					auto temKey = std::to_string(nListIndex);
					ListTemp.add(temKey.c_str(), strTemp.c_str());
				}
				DescriptionTemp.add(AttributeList, ListTemp);
			}

			//AttributeRequired
			strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeDescripition"]["Required"];
			DescriptionTemp.add(AttributeRequired, strTemp.c_str());

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

			strTemp = (string)m_Configurations["ConfigToolInfo"][nInfoIndex]["AttributeKey"];
			(*m_pDescription).add(strTemp.c_str(), DescriptionTemp);
		}
	}
	catch (ResDataObjectExption& e)
	{
		FERROR("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();

	printf("CareRay driver module: get resource over \r\n");
	FINFO("CareRay driver module: get resource over \r\n");
	return res;
}


std::string nsFPD::CareRayDriver::DeviceProbe()
{
	Debug(__FUNCTION__);
	ResDataObject r_config, HardwareInfo;
	if (r_config.loadFile(m_ConfigFileName.c_str()))
	{
		auto Child = r_config[NODE_CONFIGURATION];
		HardwareInfo.add(NODE_MajorID, Child[NODE_MajorID]);
		HardwareInfo.add(NODE_MinorID, "Device");
		HardwareInfo.add(NODE_VendorID, Child[NODE_VendorID]);
		HardwareInfo.add(NODE_ProductID, Child[NODE_ProductID]);
		HardwareInfo.add(NODE_SerialID, Child[NODE_SerialID]);
	}
	else
	{
		HardwareInfo.add(NODE_MajorID, "Detector");
		HardwareInfo.add(NODE_MinorID, "Device");
		HardwareInfo.add(NODE_VendorID, "CareRay");
		HardwareInfo.add(NODE_ProductID, "CareRay");
		HardwareInfo.add(NODE_SerialID, "1234");
	}
	string str = HardwareInfo.encode();
	return str;
}


bool nsFPD::CareRayDriver::GetDeviceConfig(std::string& Cfg)
{
	//FINFO("GetDeviceConfig Cfg:{$}", Cfg.c_str());
	Cfg = m_DeviceConfig.encode();
	return true;
}


bool nsFPD::CareRayDriver::SetDeviceConfig(std::string Cfg)
{
	printf("SetDeviceConfig Cfg:%s\n",Cfg.c_str());
	//FINFO("SetDeviceConfig Cfg:{$}", Cfg.c_str());
	ResDataObject DeviceConfig;
	DeviceConfig.decode(Cfg.c_str());

	ResDataObject DescriptionTempEx;
	DescriptionTempEx = DeviceConfig["DeviceConfig"];

	bool bSaveFile = false; //true:重新保存配置文件
	string strAccess = "";
	for (int i = 0; i < DescriptionTempEx.size(); i++)
	{
		ResDataObject temp = DescriptionTempEx[i];
		FINFO("DeviceConfig: {$}", temp.encode());
		for (int j = 0; j < temp.size(); j++)
		{
			string strKey = temp.GetKey(j);
			FINFO("strKey:{$}", strKey.c_str());
			try
			{
				if (m_pAttribute->GetFirstOf(strKey.c_str()) >= 0)
				{
					strAccess = (string)(*m_pDescription)[strKey.c_str()][AttributeAccess];
					if ("rw" == strAccess || "RW" == strAccess)
					{
						//修改对应配置，在其他单元的配置项要同时调用其修改函数修改真实值
						//1. 修改内存中的值，用于给上层发消息
						(*m_pAttribute)[strKey.c_str()] = temp[j];
						//2. 拿到AttributeKey
						int nConfigInfoCount = (int)m_Configurations[NODE_ConfigToolInfo].GetKeyCount(NODE_AttributeInfo);
						string strTemp = "";
						for (int nInfoIndex = 0; nInfoIndex < nConfigInfoCount; nInfoIndex++)
						{
							strTemp = (string)m_Configurations[NODE_ConfigToolInfo][nInfoIndex][NODE_AttributeKey];
							if (strTemp == strKey)
							{
								strTemp = (string)m_Configurations[NODE_ConfigToolInfo][nInfoIndex][NODE_InnerKey];
								break;
							}
						}
						//3. 修改配置文件中的值
						if (SetDeviceConfigValue(m_Configurations, strTemp.c_str(), 1, temp[j]))
						{
							bSaveFile = true;
						}
					}
					else
					{
						FINFO("{$} is not a RW configuration item", strKey.c_str());
					}
				}
			}
			catch (ResDataObjectExption& e)
			{
				FERROR("SetDriverConfig crashed: {$}", e.what());
				return false;
			}
		}
	}

	if (bSaveFile)
	{
		//4. 重新保存配置文件
		SaveConfigFile(true);
	}
	return true;
}


bool nsFPD::CareRayDriver::SaveConfigFile(bool bSendNotify)
{
	m_ConfigAll[NODE_CONFIGURATION] = m_Configurations;
	m_ConfigAll.SaveFile(m_ConfigFileName.c_str());

	//FINFO("SaveConfigFile m_ConfigAll:{$}", m_ConfigAll.encode());
	return true;
}


bool nsFPD::CareRayDriver::GetDeviceConfigValue(ResDataObject config, const char* pInnerKey, int nPathID, string& strValue)
{
	strValue = "";
	string strTemp = pInnerKey;
	if (1 == nPathID) //从DriverConfig路径下每个DPC自己的配置文件读取
	{
		if (WiredIP == strTemp || WirelessIP == strTemp || LocalIP == strTemp)
		{
			strValue = (string)config[NODE_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 
			|| RawImgWidth == strTemp || RawImgHeight == strTemp || WidthOffset == strTemp || HeightOffset == strTemp 
			|| CcosXwindowSize == strTemp || IsSaveRaw == strTemp)
		{
			strValue = (string)config[NODE_ModeTable][NODE_DetectorMode][pInnerKey];
		}
		else if (TempMaxLimit == 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 
			|| ReConnect == strTemp || FPDExamMode == strTemp || FPDAcqMode == strTemp || FPDModeMatch == strTemp 
			|| CcosDetectorAttachedFlag == strTemp || AmplificationFactor == strTemp || SID == strTemp || SOD == strTemp)
		{
			strValue = (string)config[pInnerKey];
		}
		else
		{
			strValue = "";
			FERROR("Error Configuration item: {$}", pInnerKey);
		}
	}
	printf("GetDeviceConfigValue pInnerKey:%s,strValue:%s\n", pInnerKey, strValue.c_str());
	//FINFO("GetDeviceConfigValue pInnerKey:{$},strValue:{$}", pInnerKey, strValue.c_str());
	return true;
}


bool nsFPD::CareRayDriver::SetDeviceConfigValue(ResDataObject& config, const char* pInnerKey,int nPathID, const char* szValue)
{
	string strTemp = pInnerKey;
	printf("SetDeviceConfigValue pInnerKey:%s,szValue:%s\n", pInnerKey, szValue);
	//FINFO("SetDeviceConfigValue pInnerKey:{$},szValue:{$}", pInnerKey, szValue);
	if (1 == nPathID) //从DriverConfig路径下每个DPC自己的配置文件读取
	{
		if (WiredIP == strTemp || WirelessIP == strTemp || LocalIP == strTemp)
		{
			config[NODE_connections][pInnerKey] = szValue;
		}
		else if (DetectorVender == strTemp || DetectorModel == strTemp || 
			DetectorDescription == strTemp || DetectorSerialNumber == strTemp)
		{
			config[pInnerKey] = szValue;
		}
		else if (SyncType == strTemp || FPDWorkStation == strTemp || RawImgWidth == strTemp || RawImgHeight == strTemp || 
			ImageWidth == strTemp || ImageHeight == strTemp || WidthOffset == strTemp || HeightOffset == strTemp || 
			CcosXwindowSize == strTemp || IsSaveRaw == strTemp)
		{
			config[NODE_ModeTable][NODE_DetectorMode][pInnerKey] = szValue;
		}
		else if (TempMaxLimit == 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 || ReConnect == strTemp || FPDExamMode == strTemp || 
			FPDAcqMode == strTemp || FPDModeMatch == strTemp || CcosDetectorAttachedFlag == strTemp || 
			AmplificationFactor == strTemp || SID == strTemp || SOD == strTemp)
		{
			config[pInnerKey] = szValue;
		}
		else
		{
			FERROR("Error Configuration item: {$}", pInnerKey);
			return false;
		}
	}
	return true;
}


nsFPD::FPDDeviceCareRay::FPDDeviceCareRay(std::shared_ptr<IOEventCenter> center,std::string strConfigPath)
{
	m_strWorkPath = GetProcessDirectory();
	m_pImgBuffer = nullptr;
	m_eAppStatus = APP_STATUS_IDLE;
	m_bConnect = false;
	m_eSyncMode = SYNC_HARDWARE;
	m_fFactorEXI2UGY = 0.0f;
	m_nCurrentMode = -1;
	m_nCurrentActiveDetectorID = -1;
	m_fCurrentDetectorTemperature = 0.0f;
	m_nCurrentBatteryValue = 0;
	m_nCurrentWifiValue = 0;

	m_DetectorCtrlUnit.reset(new OemCtrl(center, this));
	m_AcqUnit.reset(new OemAcq(center, this));
	m_SyncUnit.reset(new OemSync(center, this));
	m_CalibUnit.reset(new OemCalib(center, this));
	m_DetectorConfiguration.reset(new DetectorConfiguration(strConfigPath));

	m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_INIT));
	m_CalibUnit->SetCalibrationStatus(to_string(CCOS_CALIBRATION_STATUS_STANDBY));
	EventCenter = center;
}


nsFPD::FPDDeviceCareRay::~FPDDeviceCareRay()
{
}


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


bool nsFPD::FPDDeviceCareRay::Prepare()
{
	FINFO(__FUNCTION__);

	EventCenter->OnMaxBlockSize("DrQue", m_stDeviceConfig.nMaxImgWidth * m_stDeviceConfig.nMaxImgHeight * 2, 3, 1500 * 1500 * 2, 1);

	Connect();
	return true;
}


bool nsFPD::FPDDeviceCareRay::CreateDevice()
{
	if (!LoadConfig())
	{
		return false;
	}

	if (!g_pDetector)
	{
		g_pDetector.reset(new CareRayCtrl());
	}

	return g_pDetector->DriverEntry(this, m_DetectorConfiguration->m_Configurations);
}


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

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


RET_STATUS nsFPD::FPDDeviceCareRay::Connect()
{
	m_DetectorCtrlUnit->SetAttachStatus("1"); //没有attach功能，直接上发1，使客户端显示探测器状态

	RET_STATUS ret = RET_STATUS::RET_FAILED;
	if (g_pDetector->Connect(this, m_strWorkPath.c_str()))
	{
		m_bConnect = true;
		ret = RET_STATUS::RET_SUCCEED;
	}
	return ret;
}


/***
* 客户端获取探测器信息
***/
RET_STATUS nsFPD::FPDDeviceCareRay::GetDetectorInfo(string& strFPDInfo)
{
	ResDataObject strDetectorInfo;
	string strTempTemp = " ";

	FINFO("Get Detector Info");

	if (m_stDeviceConfig.strPanelSerial == "")
	{
		FINFO("Get Detector Info Failed, Send Default Info");

		strDetectorInfo.add("DetectorName", "Simulator");
		strDetectorInfo.add("DetectorSN", "Simulator");
		//strDetectorInfo.add("Firmware", " ");
		//strDetectorInfo.add("APFirmware", " ");
		//strDetectorInfo.add("Software", m_stDeviceConfig.strSoftware.c_str());
		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

		strFPDInfo = 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", m_stDeviceConfig.strSoftware.c_str());
	//strDetectorInfo.add("SSID", m_stDeviceConfig.strWifiSSID.c_str());
	//strDetectorInfo.add("LifeTime", m_stDeviceConfig.nLifeTime);
	//strDetectorInfo.add("PowerOn", m_stDeviceConfig.nPowerOn);
	//strDetectorInfo.add("FD_Voltage_List1", m_strVoltage.c_str());
	//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.pDetModeInfoStruct[0].nWorkStation);
	//DetectorCalibrationDate
	if (m_stDeviceConfig.strCalibrationDate != " ")
	{
		if (m_stDeviceConfig.strCalibrationDate.find("19700101") != std::string::npos)
		{
			strDetectorInfo.add("CalibrationDate", "0");
			strDetectorInfo.add("CalibrationDue", "0");
			strDetectorInfo.add("CalibrationExist", 0);
		}
		else
		{
			strDetectorInfo.add("CalibrationDate", m_stDeviceConfig.strCalibrationDate.c_str()/*"20210610"*/);
			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);

	//FINFO( "{$}", strDetectorInfo.encode());
	strFPDInfo = strDetectorInfo.encode();

	return RET_STATUS::RET_SUCCEED;
}


RET_STATUS nsFPD::FPDDeviceCareRay::EnterExam(int nExamMode)
{
	FINFO("{$} {$}",__FUNCTION__, nExamMode);
	switch (nExamMode)
	{
	case APP_STATUS_WORK_BEGIN:
		FINFO("Enter into Exam Windows");
		m_eAppStatus = APP_STATUS_WORK_BEGIN;
		break;
	case APP_STATUS_WORK_END:
		FINFO("Quit Exam Windows");
		m_eAppStatus = APP_STATUS_WORK_END;
		break;
	case APP_STATUS_DETSHARE_BEGIN:
		FINFO("Enter into Detector Share Windows");
		m_eAppStatus = APP_STATUS_DETSHARE_BEGIN;
		break;
	case APP_STATUS_DETSHAR_END:
		m_eAppStatus = APP_STATUS_IDLE;
		FINFO("Quit Detector Share Windows");
		m_eAppStatus = APP_STATUS_DETSHAR_END;
		break;
	case APP_STATUS_CAL_BEGIN:
		FINFO("Enter into Calibration Windows");
		m_eAppStatus = APP_STATUS_CAL_BEGIN;
		break;
	case APP_STATUS_CAL_END:
		FINFO("Quit Calibration Windows");
		m_eAppStatus = APP_STATUS_CAL_END;
		break;
	case APP_STATUS_WORK_IN_SENSITIVITY:
		FINFO("Enter into sensitivity test interface");
		m_eAppStatus = APP_STATUS_WORK_IN_SENSITIVITY;
		break;
	default:
		break;
	}

	g_pDetector->EnterExamMode(nExamMode);

	return RET_STATUS::RET_SUCCEED;
}

/***
* 激活对应的探测器
***/
RET_STATUS nsFPD::FPDDeviceCareRay::ActiveDetector(bool bActive)
{
	FINFO("{$}", __FUNCTION__);
	int nDetectorID = 1;
	if (m_nCurrentActiveDetectorID == nDetectorID)
	{
		FINFO("Same active detector ID, return true");
		return RET_STATUS::RET_SUCCEED;
	}
	else 
	{
		m_nCurrentActiveDetectorID = nDetectorID;
	}

	if (!g_pDetector->ActiveDetector(nDetectorID)) //暂时就考虑一块探测器
	{
		return RET_STATUS::RET_FAILED;
	}
	return RET_STATUS::RET_SUCCEED;
}

bool nsFPD::FPDDeviceCareRay::GetLogicMode(string& strAcqMode, int& nLogicMode)
{
	if (strAcqMode == "RAD")
	{
		nLogicMode = RAD;
	}
	else if (strAcqMode == "AEC")
	{
		nLogicMode = AEC;
	}
	else if (strAcqMode == "1")
	{
		nLogicMode = RAD;
	}
	else if (strAcqMode == "2")
	{
		nLogicMode = AEC;
	}
	else
	{
		FERROR("Not support mode!");
		return false;
	}
	return true;
}

RET_STATUS nsFPD::FPDDeviceCareRay::SetAcqMode(string strAcqMode)
{
	FINFO("SetAcqMode strAcqMode:{$}", strAcqMode);
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	//如果没连接，不执行
	if (!m_bConnect)
	{
		FERROR("Detector not connected, return");
		return ret;
	}

	int nMode = RAD;
	bool bRet = GetLogicMode(strAcqMode, nMode);
	if (!bRet)
	{
		return ret;
	}

	//ready后分三种情况
	//1、切换View
	//2、退出检查重新进View
	//3、正常曝光结束流程
	//不管哪种情况这里都把采集状态置为false，重新调用StartAcq
	g_pDetector->SetCanelFlag(true);
	g_pDetector->SetAcqStatus(false);

	m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_WAKEUP));

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

	//获取当前模式号对应的配置
	if (!m_DetectorConfiguration->GetDetModeInfo(m_stModeInfo, m_stCalibInfo, nMode))
	{
		FERROR("Illegal mode!");
		return ret;
	}

	int nImgX = m_stModeInfo.nImageWidth;
	int nImgY = m_stModeInfo.nImageHeight;
	//申请图像内存
	if (nullptr != m_pImgBuffer)
	{
		delete m_pImgBuffer;
		m_pImgBuffer = nullptr;
	}
	m_pImgBuffer = new WORD[(size_t)nImgX * (size_t)nImgY];

	//发送图像信息
	if (m_stModeInfo.nRotateAngle == 90 || m_stModeInfo.nRotateAngle == 270)
	{
		m_AcqUnit->SetFulImageInfo(nImgX, nImgY, m_stModeInfo.nPhySizeInfoBit, false);
	}
	else
	{
		m_AcqUnit->SetFulImageInfo(nImgY, nImgX, m_stModeInfo.nPhySizeInfoBit, false);
	}
	m_AcqUnit->SetPrevImageInfo(true, 96, 96, false);

	m_fFactorEXI2UGY = 100.0f / (float)m_stModeInfo.nSensitivity * 1.0f;
	FINFO("SyncType: {$}, EXI2UGY: {$}", m_stModeInfo.nSyncType, m_fFactorEXI2UGY);

	if (g_pDetector->SetAcqMode(m_stModeInfo, m_stCalibInfo, nMode))
	{
		m_nCurrentMode = nMode;
		ret = RET_STATUS::RET_SUCCEED;
	}

	//add by wxx for 万东:20230809
	int Sensitivity = (int)m_stModeInfo.nSensitivity;
	char szValue[64];
	sprintf(szValue, "%i", Sensitivity);
	m_DetectorCtrlUnit->SetFPDSensitivity(szValue); 
	FINFO("FPDSensitivity[{$}]", Sensitivity);

	return ret;
}


RET_STATUS nsFPD::FPDDeviceCareRay::GetSyncMode(SYNC_MODE& eSyncMode)
{
	eSyncMode = (SYNC_MODE)m_stModeInfo.nSyncType;
	return RET_STATUS::RET_SUCCEED;
}


RET_STATUS nsFPD::FPDDeviceCareRay::PrepareAcquisition()
{
	FINFO("PrepareAcquisition start");
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if (!m_bConnect)
	{
		FERROR("Detector not connected, return");
		return ret;
	}

	if ((m_CalibUnit->GetCalibrationStatus() == CCOS_CALIBRATION_STATUS_RUNNING) ||
		(m_CalibUnit->GetCalibrationStatus() == CCOS_CALIBRATION_STATUS_ACTIVE))
	{
		FERROR("PrepareAcquisition failed! Detector at Calibration status");
		return ret;
	}

	if (DETECTOR_STATUS_ACQ == m_DetectorCtrlUnit->GetDetectorStatus())
	{
		FERROR("Detector already at Acq status");
		return RET_STATUS::RET_SUCCEED;//进检查后退检查，如果再次调用prepare，在这里防护
	}

	if (g_pDetector->PrepareAcquisition(this))
	{
		ret = RET_STATUS::RET_SUCCEED;
		FINFO("PrepareAcquisition over");
	}
	else 
	{
		FERROR("PrepareAcquisition fail!");
	}
	
	return ret;
}


RET_STATUS nsFPD::FPDDeviceCareRay::StartAcquisition(string in)
{
	FINFO("StartAcquisition start");
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if (!m_bConnect)
	{
		FERROR("Detector not connected, return");
		return ret;
	}

	if (DETECTOR_STATUS_STANDBY != m_DetectorCtrlUnit->GetDetectorStatus())
	{
		if ((m_CalibUnit->GetCalibrationStatus() == CCOS_CALIBRATION_STATUS_RUNNING) ||
			(m_CalibUnit->GetCalibrationStatus() == CCOS_CALIBRATION_STATUS_ACTIVE))
		{
			FERROR("PrepareAcquisition failed. Detector at Calibration status.");
		}

		if (DETECTOR_STATUS_ACQ == m_DetectorCtrlUnit->GetDetectorStatus())
		{
			FERROR("Detector already at Acq status.");
			ret = RET_STATUS::RET_SUCCEED;
		}
	}
	else
	{
		if (g_pDetector->StartAcquisition(this))
		{
			ret = RET_STATUS::RET_SUCCEED;
			m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_ACQ));
		}
		else
		{
			m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));
		}
	}
	FINFO("StartAcquisition over");
	return ret;
}


RET_STATUS nsFPD::FPDDeviceCareRay::StopAcquisition()
{
	FINFO(__FUNCTION__);
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if (!m_bConnect)
	{
		FERROR("Detector not connected, return");
		return ret;
	}

	//if (g_pDetector->StopAcquisition(this)) //先不调用，避免影响采集时序 --ys
	{
		ret = RET_STATUS::RET_SUCCEED;
		m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));
	}

	FINFO("StopAcquisition over");
	return ret;
}


RET_STATUS nsFPD::FPDDeviceCareRay::ActiveCalibration(CCOS_CALIBRATION_TYPE eType)
{
	FINFO("{$} {$}", __FUNCTION__, (int)eType);
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if (!m_bConnect)
	{
		FERROR("Detector not connected, return");
		return ret;
	}

	if (eType == CCOS_CALIBRATION_TYPE_NONE || eType == CCOS_CALIBRATION_TYPE_MAX)
	{
		return RET_STATUS::RET_INVALID;
	}

	if (DETECTOR_STATUS_STANDBY != m_DetectorCtrlUnit->GetDetectorStatus())
	{
		if (DETECTOR_STATUS_ACQ == m_DetectorCtrlUnit->GetDetectorStatus())
		{
			FERROR("ActiveCalibration failed. Detector at Acq status");
		}
		return RET_STATUS::RET_FAILED;
	}

	assert(g_pDetector);

	if (g_pDetector->ActiveCalibration(this, eType))
	{
		ret = RET_STATUS::RET_SUCCEED;
		m_CalibUnit->SetCalibrationStatus(to_string(CCOS_CALIBRATION_STATUS_ACTIVE));
		m_CalibUnit->SetCalibrationProgress("0");
	}
	else
	{
		FERROR("Active calibration failed");
	}
	FINFO("ActiveCalibration over");
	return ret;
}


RET_STATUS nsFPD::FPDDeviceCareRay::PrepareCalibration()
{
	FINFO(__FUNCTION__);
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if (!m_bConnect)
	{
		FERROR("Detector not connected, return");
		return ret;
	}

	if (g_pDetector->PrepareCalibration(this))
	{
		ret = RET_STATUS::RET_SUCCEED;
	}
	else
	{
		FERROR("Prepare calibration failed");
	}
	FINFO("PrepareCalibration over");
	return ret;
}


RET_STATUS nsFPD::FPDDeviceCareRay::GetRequestedDose(string& strDose)
{
	//fDose = m_fDose;
	strDose = to_string(100); //暂时写死
	FINFO("Dose request: {$}", strDose.c_str());
	return RET_STATUS::RET_SUCCEED;
}


RET_STATUS nsFPD::FPDDeviceCareRay::StartCalibration()
{
	FINFO(__FUNCTION__);
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if (!m_bConnect)
	{
		FERROR("Detector not connected, return");
		return ret;
	}

	if ((m_CalibUnit->GetCalibrationStatus() != CCOS_CALIBRATION_STATUS_PAUSE) && (m_CalibUnit->GetCalibrationStatus() != CCOS_CALIBRATION_STATUS_ACTIVE))
	{
		FERROR("Start calibration failed, in {$} status", (int)m_CalibUnit->GetCalibrationStatus());
		return ret;
	}

	if (DETECTOR_STATUS_STANDBY != m_DetectorCtrlUnit->GetDetectorStatus())
	{
		if (DETECTOR_STATUS_ACQ == m_DetectorCtrlUnit->GetDetectorStatus())
		{
			FERROR("Start calibration failed. Detector at Acq status");
		}
		return ret;
	}

	if (m_CalibUnit->GetCalibrationStatus() == CCOS_CALIBRATION_STATUS_RUNNING)
	{
		FERROR("Detector already at calib status");
		return ret;
	}

	if (g_pDetector->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
	{
		FERROR("Start calibration failed");
	}
	FINFO("StartCalibration over");
	return ret;
}


RET_STATUS nsFPD::FPDDeviceCareRay::StopCalibration()
{
	FINFO(__FUNCTION__);
	RET_STATUS ret = RET_STATUS::RET_FAILED;

	if (!m_bConnect)
	{
		FERROR("Detector not connected, return");
		return ret;
	}

	if (g_pDetector->StopCalibration(this))
	{
		ret = RET_STATUS::RET_SUCCEED;
		m_CalibUnit->SetCalibrationStatus(to_string(CCOS_CALIBRATION_STATUS_STANDBY));
		m_CalibUnit->SetCalibrationProgress("100");
	}
	else
	{
		FERROR("Start calibration failed");
	}
	FINFO("StopCalibration over");
	return ret;
}


void nsFPD::FPDDeviceCareRay::ConfirmCalExposure()
{
	FINFO(__FUNCTION__);
	g_pDetector->ConfirmCalExposure();
}


void nsFPD::FPDDeviceCareRay::RejectCalExposure()
{
	FINFO(__FUNCTION__);
	g_pDetector->RejectCalExposure();
}


bool nsFPD::FPDDeviceCareRay::Support_DarkCalib()
{
	return true;
}


bool nsFPD::FPDDeviceCareRay::Support_XrayCalib()
{
	return true;
}


void nsFPD::FPDDeviceCareRay::SendTemperatureValue(float fValue)
{
	int nStatus = 0;
	m_Temperature->SetTemperature(fValue, nStatus);
	FINFO("SendTemperatureValue: {$}, status {$}", fValue, nStatus);
}

void nsFPD::FPDDeviceCareRay::SendTemperatureMaxLimit(float fValue)
{
	m_Temperature->SetTemperatureErrorMax(to_string(fValue));
	FINFO("SendTemperatureMaxLimit: {$}", fValue);
}

void nsFPD::FPDDeviceCareRay::SendTemperatureLowLimit(float fValue)
{
	m_Temperature->SetTemperatureErrorMin(to_string(fValue));
	FINFO("SendTemperatureLowLimit: {$}", fValue);
}

void nsFPD::FPDDeviceCareRay::SendTemperatureMaxWarn(float fValue)
{
	m_Temperature->SetTemperatureWarningMax(to_string(fValue));
	FINFO("SendTemperatureMaxWarn: {$}", fValue);
}

void nsFPD::FPDDeviceCareRay::SendTemperatureMinWarn(float fValue)
{
	m_Temperature->SetTemperatureWarningMin(to_string(fValue));
	FINFO("SendTemperatureMinWarn: {$}", fValue);
}

void nsFPD::FPDDeviceCareRay::SendWifiValue(int nValue)
{
	int nStatus = 0;
	m_Wifi->SetSignalValue(nValue, nStatus);
	FINFO("SendWifiValue: {$}, status {$}", nValue, nStatus);
}

void nsFPD::FPDDeviceCareRay::SendWifiMinLimit(int nValue)
{
	m_Wifi->SetSignalErrorMin(to_string(nValue));
	FINFO("SendWifiMinLimit: {$}", nValue);
}

void nsFPD::FPDDeviceCareRay::SendWifiMinWarn(int nValue)
{
	m_Wifi->SetSignalWarningMin(to_string(nValue));
	FINFO("SendWifiMinWarn: {$}", nValue);
}


void nsFPD::FPDDeviceCareRay::SendBatteryValue(int nValue)
{
	int nStatus = 0;
	m_Battery->SetRemainPowerValue(nValue, nStatus);
	FINFO("SendBatteryValue: {$}, status {$}", nValue, nStatus);
}

void nsFPD::FPDDeviceCareRay::SendBatteryMinLimit(int nValue)
{
	m_Battery->SetBatteryErrorMin(to_string(nValue));
	FINFO("SendBatteryMinLimit: {$}", nValue);
}

void nsFPD::FPDDeviceCareRay::SendBatteryMinWarn(int nValue)
{
	m_Battery->SetBatteryWarningMin(to_string(nValue));
	FINFO("SendBatteryMinWarn: {$}", nValue);
}


bool nsFPD::FPDDeviceCareRay::LoadConfig()
{
	if (!m_DetectorConfiguration->LoadConfigurations(m_stDeviceConfig, m_ACQMODElist))
	{
		FERROR("Load configuration file failed!!!");
		return false;
	}
	m_eSyncMode = (SYNC_MODE)m_stDeviceConfig.pDetModeInfoStruct[0].nSyncType; //临时方案，先加载同步配置，供子系统使用
	FINFO("LoadConfig m_eSyncMode:{$}", (int)m_eSyncMode);

	m_DetectorCtrlUnit->SetDetectorType("SCINTILLATOR");
	//不同采集模式可能会有不同的值，后面在考虑
	auto strSensitivity = to_string(m_stDeviceConfig.pDetModeInfoStruct[0].nSensitivity);
	m_DetectorCtrlUnit->SetFPDSensitivity(strSensitivity);
	m_DetectorCtrlUnit->SetPixelData("");
	m_DetectorCtrlUnit->SetTargetEXI("5000");

	//暂时发特定值
	m_DetectorCtrlUnit->SetDateofLastDetectorCalibration(m_stDeviceConfig.strCalibrationDate);
	m_DetectorCtrlUnit->SetTimeofLastDetectorCalibration(m_stDeviceConfig.strCalibrationTime);

	m_Battery.reset(new DeviceBatteryMould("DetectorBattery", 0, m_stDeviceConfig.nBatteryLimit, 
		m_stDeviceConfig.nBatteryWarning, 100, m_stDeviceConfig.nBatteryLimit, 100, 100, 0, EventCenter));

	m_Temperature.reset(new DeviceTemperatureMould("DetectorTemperature", 0.0f, m_stDeviceConfig.fTemperLowLimit, 
		m_stDeviceConfig.fTemperMinWarn, m_stDeviceConfig.fTemperMaxWarn,
		m_stDeviceConfig.fTemperMinWarn, m_stDeviceConfig.fTemperMaxWarn,
		m_stDeviceConfig.fTemperMaxLimit, 0.0f, EventCenter));

	m_Wifi.reset(new DeviceWifiMould("DetectorWifi", 0, m_stDeviceConfig.nWifiLimit, m_stDeviceConfig.nWifiWarning,
		100, m_stDeviceConfig.nWifiLimit, 100, 100, 0, EventCenter));

	return true;
}


void nsFPD::FPDDeviceCareRay::RegisterCtrl(nsDetail::Dispatch* Dispatch)
{
	Dispatch->Action.Push(ActionKey::CcosActiveDetector, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSActiveDetector);
	Dispatch->Action.Push(ActionKey::GetDetectorInfo, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetDetectorInfo);
	Dispatch->Action.Push(ActionKey::EnterExam, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSEnterExam);
	Dispatch->Action.Push(ActionKey::ExitExam, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSExitExam);
	Dispatch->Get.Push(AttrKey::DetectorStatus, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetFPDStatus);
	Dispatch->Get.Push(AttrKey::DetectorType, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetDetectorType);
	Dispatch->Get.Push(AttrKey::Description, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetDescription);
	Dispatch->Get.Push(AttrKey::DetectorID, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetDetectorID);
	Dispatch->Get.Push(AttrKey::FPDSensitivity, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetFPDSensitivity);
	Dispatch->Get.Push(AttrKey::PixelData, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetPixelData);
	Dispatch->Get.Push(AttrKey::TargetEXI, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetTargetEXI);
	Dispatch->Action.Push(ActionKey::SetXrayOnNum, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSSetXrayOnNum);
	Dispatch->Action.Push(ActionKey::SetExposureTimes, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSSetExposureTimes);
	Dispatch->Get.Push(CcosDetectorAttachedFlag, m_DetectorCtrlUnit.get(), &DetectorCtrlUnit::JSGetAttachStatus);
}


void nsFPD::FPDDeviceCareRay::RegisterAcq(nsDetail::Dispatch* Dispatch)
{
	Dispatch->Action.Push(ActionKey::SetAcqMode, m_AcqUnit.get(), &AcqUnit::JSSetAcqMode);
	Dispatch->Get.Push(AttrKey::ZskkFPDState, m_AcqUnit.get(), &AcqUnit::JSGetZskkFPDState);
	Dispatch->Get.Push(AttrKey::NoNeedWaitImage, m_AcqUnit.get(), &AcqUnit::JSGetNoNeedWaitImage);
	Dispatch->Get.Push(AttrKey::ImgDataInfo, m_AcqUnit.get(), &AcqUnit::JSGetLastImage);
}


void nsFPD::FPDDeviceCareRay::RegisterSync(nsDetail::Dispatch* Dispatch)
{
	Dispatch->Action.Push(ActionKey::SetSyncMode, m_SyncUnit.get(), &SyncUnit::JSSetSyncMode);
	Dispatch->Action.Push(ActionKey::SetXwindowSize, m_SyncUnit.get(), &SyncUnit::JSSetXwindowSize);
	Dispatch->Action.Push(ActionKey::PrepareAcquisition, m_SyncUnit.get(), &SyncUnit::JSPrepareAcquisition);
	Dispatch->Action.Push(ActionKey::StartAcquisition, m_SyncUnit.get(), &SyncUnit::JSStartAcquisition);
	Dispatch->Action.Push(ActionKey::StopAcquisition, m_SyncUnit.get(), &SyncUnit::JSStopAcquisition);
	Dispatch->Get.Push(AttrKey::SyncMode, m_SyncUnit.get(), &SyncUnit::JSGetSyncMode);
	Dispatch->Get.Push(AttrKey::FPDReadyStatus, m_SyncUnit.get(), &SyncUnit::JSGetFPDReady);
	Dispatch->Get.Push(AttrKey::DetectorConnectStatus, m_SyncUnit.get(), &SyncUnit::JSGetConnectStatus);
	Dispatch->Get.Push(AttrKey::XwindowStatus, m_SyncUnit.get(), &SyncUnit::JSGetXWindowStatus);
	Dispatch->Get.Push(AttrKey::ImageReadingStatus, m_SyncUnit.get(), &SyncUnit::JSGetImageReadingStatus);
	Dispatch->Get.Push(AttrKey::FPDExpReady, m_SyncUnit.get(), &SyncUnit::JSGetExpReadyStatus);
}


void nsFPD::FPDDeviceCareRay::RegisterCalib(nsDetail::Dispatch* Dispatch)
{
	Dispatch->Action.Push(ActionKey::ActiveCalibration, m_CalibUnit.get(), &CalibUnit::JSActiveCalibration);
	Dispatch->Action.Push(ActionKey::GetRequestedDose, m_CalibUnit.get(), &CalibUnit::JSGetRequestedDose);
	Dispatch->Action.Push(ActionKey::PrepareCalibration, m_CalibUnit.get(), &CalibUnit::JSPrepareCalibration);
	Dispatch->Action.Push(ActionKey::StartCalibration, m_CalibUnit.get(), &CalibUnit::JSStartCalibration);
	Dispatch->Action.Push(ActionKey::StopCalibration, m_CalibUnit.get(), &CalibUnit::JSStopCalibration);
	Dispatch->Action.Push(ActionKey::SetCorrectionType, m_CalibUnit.get(), &CalibUnit::JSSetCorrectionType);
	Dispatch->Get.Push(AttrKey::CalibrationStatus, m_CalibUnit.get(), &CalibUnit::JSGetCalibStatus);
	Dispatch->Get.Push(AttrKey::CalibrationProgress, m_CalibUnit.get(), &CalibUnit::JSGetCalibProgress);
	Dispatch->Get.Push(AttrKey::UploadCalibrationFilesResult, m_CalibUnit.get(), &CalibUnit::JSGetUploadCalibrationFilesResult);
	Dispatch->Get.Push(AttrKey::SupportCalibrationType, m_CalibUnit.get(), &CalibUnit::JSGetSupportCalibrationType);
}


void nsFPD::FPDDeviceCareRay::RegisterOthers(nsDetail::Dispatch* Dispatch)
{
	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->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);
}


void nsFPD::FPDDeviceCareRay::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::FPDDeviceCareRay::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;
		FINFO("OnEventProcessConf: Detector {$} SN {$}", nDetectorID, pszMsg);
		m_DetectorCtrlUnit->SetDetectorID(m_stDeviceConfig.strPanelSerial);
		break;
	}
	default:
		break;
	}
}


void nsFPD::FPDDeviceCareRay::OnEventProcessInfo(int nDetectorID, int nEventID, int nEventLevel, const char* pszMsg, int nParam1, float fParam2, int nPtrParamLen, void* pParam)
{
	switch (nEventID)
	{
	case EVT_INFO_CALIBRATIOIN_TIME:
	{
		m_stDeviceConfig.strCalibrationDate = pszMsg;
		FINFO("OnEventProcessInfo: Detector {$} Calibration Time: {$}", nDetectorID, pszMsg);
		m_DetectorCtrlUnit->SetDateofLastDetectorCalibration(m_stDeviceConfig.strCalibrationDate);
		m_DetectorCtrlUnit->SetTimeofLastDetectorCalibration("");
		break;
	}
	default:
		break;
	}
}


void nsFPD::FPDDeviceCareRay::OnEventProcessStatus(int nDetectorID, int nEventID, int nEventLevel,
	const char* pszMsg, int nParam1, float fParam2, int nPtrParamLen, void* pParam)
{
	switch (nEventID)
	{
	case EVT_STATUS_PANEL:
	{
		ENUM_PANEL_STATUS m_ePanelStatus = (ENUM_PANEL_STATUS)nParam1;
		if (PANEL_STANDBY == nParam1)
		{
			FINFO("set detector standby");
			m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));
		}
		else if (PANEL_END_ACQ == nParam1)
		{
			FINFO("Panel Status: End acq");
			if (g_pDetector->StopAcquisition(this))
			{
				m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));
			}
		}
		else if (PANEL_AEC_PRE_END == nParam1)
		{
			FINFO("Panel Status: AEC pre-shoot end");
			m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));
		}
		else if (PANEL_READY_EXP == nParam1)
		{
			string strTemp = pszMsg;
			if (strTemp.find("true") != std::string::npos)
			{
				m_SyncUnit->ExpReadyNotify(m_stModeInfo.nXwindow);
			}
			else
			{
				m_SyncUnit->ExpReadyNotify(0);
			}
		}
		else if (PANEL_XWINDOW_ON == nParam1) //Xwindow On
		{
			m_stImgCreateTime = { 0 };
			GetLocalTime(&m_stImgCreateTime);
			FINFO("Full image create time-{$}:{$}:{$}:{$}", m_stImgCreateTime.wHour, m_stImgCreateTime.wMinute, m_stImgCreateTime.wSecond, m_stImgCreateTime.wMilliseconds);
			FINFO("XWindow on SyncMode:{$}", (int)m_eSyncMode);
			if (SYNC_MANUAL == m_eSyncMode || SYNC_SOFTWARE == m_eSyncMode || SYNC_HARDWARE == m_eSyncMode)
			{
				m_SyncUnit->XWindowOnNotify();
			}
			else if (SYNC_AED == m_eSyncMode)
			{
				m_SyncUnit->FakeEIPONNotify();
			}
		}
		else if (PANEL_XWINDOW_OFF == nParam1) // Xwindow Off
		{
			FINFO("XWindow off SyncMode:{$}", (int)m_eSyncMode);
			if (SYNC_MANUAL == m_eSyncMode || SYNC_SOFTWARE == m_eSyncMode || SYNC_HARDWARE == m_eSyncMode) //探测器的关窗是模拟计算的，所以非软同步模式也没必要发送了
			{
				m_SyncUnit->XWindowOffNotify();
			}
		}
		else if(PANEL_CONNECT == nParam1)
		{
			FINFO("Notify FPD Connect");
			m_SyncUnit->FPDConnectStatusNotify(true);
		}
		else if (PANEL_DISCONNECT == nParam1)
		{
			FINFO("Notify FPD Disconnect");
			m_SyncUnit->FPDConnectStatusNotify(false);
		}
		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:
		case PANEL_EVENT_END_ERROR:
			m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));
			m_CalibUnit->SetCalibrationStatus(to_string(CCOS_CALIBRATION_STATUS_STANDBY));
			m_CalibUnit->SetCalibrationProgress("100");
			break;
		case PANEL_EVENT_TIMEOUT:
			break;
		default:
			break;
		}
		break;
	}
	case EVT_STATUS_SINGLEEXP:
	{
		if (DOSE_ACCEPT == nParam1)
		{
			FINFO("Calibration Result is acceptable");
			m_DetectorCtrlUnit->SetDetectorStatus(to_string(DETECTOR_STATUS_STANDBY));
			m_CalibUnit->PauseCalibration();
		}
		else
		{
			FERROR("Not support this param({$})", nParam1);
		}
		break;
	}
	case EVT_STATUS_TEMPERATURE:
	{
		float fTemperature = fParam2;
		m_fCurrentDetectorTemperature = fParam2;
		//达到温度高低警告值时、达到温度高低最大限制时向上通知
		if (fTemperature > m_stDeviceConfig.fTemperMaxLimit)
		{
			SendTemperatureMaxLimit(fTemperature);
		}
		else if (fTemperature > m_stDeviceConfig.fTemperMaxWarn)
		{
			SendTemperatureMaxWarn(fTemperature);
		}
		else if (fTemperature < m_stDeviceConfig.fTemperLowLimit)
		{
			SendTemperatureLowLimit(fTemperature);
		}
		else if (fTemperature < m_stDeviceConfig.fTemperMinWarn)
		{
			SendTemperatureMinWarn(fTemperature);
		}
		SendTemperatureValue(fTemperature);
		break;
	}
	case EVT_STATUS_WIFI:
	{
		int nWifiLevel = nParam1;
		m_nCurrentWifiValue = nParam1;
		//wifi信号达到警告值时，wifi信号达到最低限制时向上通知
		if (nWifiLevel < m_stDeviceConfig.nWifiLimit)
		{
			SendWifiMinLimit(nWifiLevel);
		}
		else if (nWifiLevel < m_stDeviceConfig.nWifiWarning)
		{
			SendWifiMinWarn(nWifiLevel);
		}
		SendWifiValue(nWifiLevel);
		break;
	}
	case EVT_STATUS_BATTERY_VALUE:
	{
		int nBatteryValue = nParam1;
		m_nCurrentBatteryValue = nParam1;
		//电量达到警告值时，电量达到最低限制时向上通知
		if (nBatteryValue < m_stDeviceConfig.nBatteryLimit)
		{
			SendBatteryMinLimit(nBatteryValue);
		}
		else if (nBatteryValue < m_stDeviceConfig.nBatteryWarning)
		{
			SendBatteryMinWarn(nBatteryValue);
		}
		SendBatteryValue(nBatteryValue);
		break;
	}
	default:
		FERROR("Not support this status({$})", nEventID);
		break;
	}
}


void nsFPD::FPDDeviceCareRay::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:
	{
		FINFO("Image Arrived");
		int nImgX = m_stModeInfo.nImageWidth;
		int nImgY = m_stModeInfo.nImageHeight;
		int nAngle = m_stModeInfo.nRotateAngle;
		memcpy(m_pImgBuffer, pParam, (size_t)nImgX * (size_t)nImgY * sizeof(WORD));

		//单独通知ImagerPixelSpacing，否则会造成ImageSave崩溃
		m_AcqUnit->ImagerPixelSpacingNotify(m_stModeInfo.nPixelPitch);// DCS 像素间距
		m_AcqUnit->SidNotify(m_stDeviceConfig.fSid);
		m_AcqUnit->SodNotify(m_stDeviceConfig.fSod);
		m_AcqUnit->ErmfNotify(m_stDeviceConfig.fAmplificationFactor);
		
		//ImageHeader DICOM
		ResDataObject objImageHead, objTemp;
		objTemp.add(SM_IMAGE_TYPE, (int)IMAGE_FULL);
		objTemp.add(SM_IMAGE_BIT, 16);
		objTemp.add(SM_IMAGE_TAG, 1);
		objTemp.add(SM_IMAGE_INDEX, 1);
		objTemp.add(SM_IMAGE_YEAR, m_stImgCreateTime.wYear);
		objTemp.add(SM_IMAGE_MONTH, m_stImgCreateTime.wMonth);
		objTemp.add(SM_IMAGE_DAY, m_stImgCreateTime.wDay);
		objTemp.add(SM_IMAGE_HOUR, m_stImgCreateTime.wHour);
		objTemp.add(SM_IMAGE_MINUTE, m_stImgCreateTime.wMinute);
		objTemp.add(SM_IMAGE_SEC, m_stImgCreateTime.wSecond);
		objTemp.add(SM_IMAGE_MILLSEC, m_stImgCreateTime.wMilliseconds);
		objTemp.add(SM_IMAGE_LSB, "5000");
		objTemp.add(SM_IMAGE_DOSE, m_stModeInfo.nSensitivity);
		objTemp.add(SM_IMAGE_PIXELSPACING, m_stModeInfo.nPixelPitch / m_stDeviceConfig.fAmplificationFactor);// DCS / 放大因子（ SID/(SOD-20)）
		FINFO("PixelSpacing:{$}", m_stModeInfo.nPixelPitch / m_stDeviceConfig.fAmplificationFactor);
		//objTemp.add(SM_IMAGE_PIXELSPACING, m_stModeInfo.nPixelPitch);// DCS / 放大因子（ SID/(SOD-20)）
		objTemp.add(SM_IMAGE_PIXELREPRESENTATION, "1");
		objTemp.add(SM_IMAGE_FLIP, "No");
		objTemp.add(SM_IMAGE_ORIGINX, "0");
		objTemp.add(SM_IMAGE_ORIGINY, "0");
		objTemp.add(SM_IMAGE_EXI2UGY, m_fFactorEXI2UGY);
		objTemp.add(SM_IMAGE_TEMP, m_fCurrentDetectorTemperature);

		if (0 != nAngle)
		{
			m_AcqUnit->RotateImage(m_pImgBuffer, nImgY, nImgX, nAngle);
		}
		if (90 == nAngle || 270 == nAngle)
		{
			objTemp.add(SM_IMAGE_WIDTH, nImgY);
			objTemp.add(SM_IMAGE_HEIGHT, nImgX);
			objTemp.add(SM_IMAGE_ROTATION, "Yes");
		}
		else
		{
			objTemp.add(SM_IMAGE_WIDTH, nImgX);
			objTemp.add(SM_IMAGE_HEIGHT, nImgY);
			objTemp.add(SM_IMAGE_ROTATION, "No");
		}
		objImageHead.add(SM_IMAGE_HEAD, objTemp);
		FINFO("Full image head: {$}", objImageHead.encode());

		RET_STATUS ret = RET_STATUS::RET_FAILED;
		FINFO("nImgX:{$},nImgY:{$}", nImgX, nImgY);
		ret = m_AcqUnit->AddFrameWithRawHead(IMAGE_FULL, objImageHead.encode(), m_pImgBuffer, nImgX * nImgY);
		FINFO("Add image over, {$}", (int)ret);
		break;
	}
	case EVT_DATA_PREVIEW_IMAGE:
	{
		FINFO("Preview Image Arrived");
		int nImgX = 96;
		int nImgY = 96;
		int nAngle = m_stModeInfo.nRotateAngle;
		memcpy(m_pImgBuffer, pParam, (size_t)nImgX * (size_t)nImgY * sizeof(WORD));

		//暂时先用假值，有需要再改
		ResDataObject objImageHead, objTemp;
		objTemp.add(SM_IMAGE_TYPE, (int)IMAGE_AEC_PREVIEW);
		objTemp.add(SM_IMAGE_BIT, 16);
		objTemp.add(SM_IMAGE_TAG, 1);
		objTemp.add(SM_IMAGE_INDEX, 1);
		objTemp.add(SM_IMAGE_YEAR, m_stImgCreateTime.wYear);
		objTemp.add(SM_IMAGE_MONTH, m_stImgCreateTime.wMonth);
		objTemp.add(SM_IMAGE_DAY, m_stImgCreateTime.wDay);
		objTemp.add(SM_IMAGE_HOUR, m_stImgCreateTime.wHour);
		objTemp.add(SM_IMAGE_MINUTE, m_stImgCreateTime.wMinute);
		objTemp.add(SM_IMAGE_SEC, m_stImgCreateTime.wSecond);
		objTemp.add(SM_IMAGE_MILLSEC, m_stImgCreateTime.wMilliseconds);
		objTemp.add(SM_IMAGE_LSB, "5000");
		objTemp.add(SM_IMAGE_DOSE, m_stModeInfo.nSensitivity);
		objTemp.add(SM_IMAGE_PIXELSPACING, m_stModeInfo.nPixelPitch);
		objTemp.add(SM_IMAGE_PIXELREPRESENTATION, "1");
		objTemp.add(SM_IMAGE_FLIP, "No");
		objTemp.add(SM_IMAGE_ORIGINX, "0");
		objTemp.add(SM_IMAGE_ORIGINY, "0");
		objTemp.add(SM_IMAGE_EXI2UGY, m_fFactorEXI2UGY);
		objTemp.add(SM_IMAGE_TEMP, m_fCurrentDetectorTemperature);

		if (0 != nAngle)
		{
			m_AcqUnit->RotateImage(m_pImgBuffer, nImgY, nImgX, nAngle);
		}
		if (90 == nAngle || 270 == nAngle)
		{
			objTemp.add(SM_IMAGE_WIDTH, nImgY);
			objTemp.add(SM_IMAGE_HEIGHT, nImgX);
			objTemp.add(SM_IMAGE_ROTATION, "Yes");
		}
		else
		{
			objTemp.add(SM_IMAGE_WIDTH, nImgX);
			objTemp.add(SM_IMAGE_HEIGHT, nImgY);
			objTemp.add(SM_IMAGE_ROTATION, "No");
		}
		objImageHead.add(SM_IMAGE_HEAD, objTemp);
		FINFO("Preview image head: {$}", objImageHead.encode());
		RET_STATUS ret = RET_STATUS::RET_FAILED;
		ret = m_AcqUnit->AddFrameWithRawHead(IMAGE_AEC_PREVIEW, objImageHead.encode(), m_pImgBuffer, nImgX * nImgY);
		FINFO("Add preview image over, {$}", (int)ret);
		break;
	}
	default:
		FERROR("Not support this data({$})", nEventID);
		break;
	}
}


void nsFPD::FPDDeviceCareRay::OnEventProcessError(int nDetectorID, int nEventID, int nEventLevel,
	const char* pszMsg, int nParam1, float fParam2, int nPtrParamLen, void* pParam)
{
	switch (nEventID)
	{
	case EVT_ERR_COMMUNICATE:
	{
		string strTemp = pszMsg;
		if (strTemp.find("true") != std::string::npos)
		{
			SendTemperatureValue(0.0f);
			SendWifiValue(0);
			SendBatteryValue(0);
		}
		else if (strTemp.find("false") != std::string::npos)
		{

		}
		break;
	}
	case EVT_ERR_INIT_FAILED:
	{
		string strTemp = pszMsg;
		if (strTemp.find("true") != std::string::npos)
		{
			//AddErrMsg("6", "initialize error");
		}
		else if (strTemp.find("false") != std::string::npos)
		{
			//一般不可恢复
		}
		break;
	}
	default:
		FERROR("Not support this error({$})", nEventID);
		break;
	}
}


void nsFPD::FPDDeviceCareRay::OnEventProcessWarning(int nDetectorID, int nEventID, int nEventLevel,
	const char* pszMsg, int nParam1, float fParam2, int nPtrParamLen, void* pParam)
{
	FERROR("Not support this event id:{$}", nEventID);
}