PhysicalDevice/Detector/Yuying/DIOS.Dev.FPD.YuyingDM/DIOS.Dev.FPDDeviceMould/DIOS.Dev.FPDDeviceMould.hpp

#pragma once
#include <string>
#include "ResDataObject.h"
#include "Detector_Model_Def.h"
#include "CCOSConfigurations.h"

#include "CCOS.Dev.IODevice.hpp"
#include "CCOS.Dev.IODevice.Detail.hpp"

#include "BatteryMould.hpp"
#include "TemperatureMould.hpp"
#include "WifiMould.hpp"

#ifndef CCOSDEVFPDDEVICEMOULD_EXPORTS
#ifdef _WIN64
#pragma message("import WIN64 CCOSDEVFPDDEVICEMOULD")

#ifdef _DEBUG
#pragma message("import WIN64 Debug CCOSDEVFPDDEVICEMOULD")
#pragma comment(lib, "CCOS.Dev.FPDDeviceMould64D.lib")
#else
#pragma message("import WIN64 Release CCOSDEVFPDDEVICEMOULD")
#pragma comment(lib, "CCOS.Dev.FPDDeviceMould64.lib")
#endif
#else
#ifdef _DEBUG
#pragma comment(lib, "CCOS.Dev.FPDDeviceMouldD.lib")
#else
#pragma comment(lib, "CCOS.Dev.FPDDeviceMould.lib")
#endif
#endif
#endif


#ifdef CCOSDEVFPDDEVICEMOULD_EXPORTS
#define _CCOSDEVFPDDEVICEMOULD_API __declspec(dllexport)
#else
#define _CCOSDEVFPDDEVICEMOULD_API __declspec(dllimport)
#endif


namespace CCOS::Dev::Detail::Detector
{
	static const char* DetectorDriverType = "{18CAB88A-C61C-4BB2-AC28-184FDD4FD160}";
	static const char* DetectorUnitType = "{A209866C-A049-4A17-B5C9-421974E59D68}";
	static const char* DetectorAcqType = "{A209866C-A049-4A17-B5C9-421974000000}";
	static const char* DetectorSyncType = "{A209866C-A049-4A17-B5C9-421974000001}";
	static const char* DetectorCalibType = "{A209866C-A049-4A17-B5C9-421974000002}";
	static const char* DetectorCtrlType = "{A209866C-A049-4A17-B5C9-421974000003}";

	namespace ConfKey
	{
		constexpr auto CcosDetectorType = "DetectorVender";
		constexpr auto CcosDetectorModel = "DetectorModel";
		constexpr auto CcosDetectorConfig = "DeviceConfig";
		constexpr auto CcosDetectorAttribute = "Attribute";
		constexpr auto CcosDetectorDescription = "Description";
		constexpr auto CcosDetectorSerialNumber = "SerialNumber";
		constexpr auto CcosWiredIP = "WiredIP";
		constexpr auto CcosWirelessIP = "WirelessIP";
		constexpr auto CcosLocalIP = "LocalIP";
		constexpr auto CcosSyncType = "SyncType";
		constexpr auto CcosWorkStation = "WorkStation";
		constexpr auto CcosTempMaxLimit = "TempMaxLimit";
		constexpr auto CcosTempUpperLimit = "TempUpperLimit";
		constexpr auto CcosTempLowerLimit = "TempLowerLimit";
		constexpr auto CcosTempMinLimit = "TempMinLimit";
		constexpr auto CcosBatLowerLimit = "BatLowerLimit";
		constexpr auto CcosBatMiniLimit = "BatMiniLimit";
		constexpr auto CcosWifiLowerLimit = "WifiLowerLimit";
		constexpr auto CcosWifiMiniLimit = "WifiMiniLimit";
		constexpr auto CcosImageFullWidth = "ImageFullWidth";
		constexpr auto CcosImageFullHeight = "ImageFullHeight";
		constexpr auto CcosShowTemperature = "ShowTemperature";
		constexpr auto CcosShowWifi = "ShowWifi";
		constexpr auto CcosShowBattery = "ShowBattery";
		constexpr auto CcosShowBluetooth = "ShowBluetooth";
		constexpr auto CcosIsConnect = "IsConnect";
	}

	namespace ActionKey
	{
		//DetecorCtrl
		constexpr auto GetDetectorInfo = "GetFPDinformation";
		constexpr auto CcosActiveDetector = "ActiveDetector";
		constexpr auto RESET = "RESET";
		constexpr auto EnterExam = "EnterExam";
		constexpr auto ExitExam = "ExitExam";
		constexpr auto AttachConnect = "AttachConnect";
		constexpr auto CancelAttach = "CancelAttach";
		constexpr auto RecoverImage = "RecoverImage";
		constexpr auto ResetConnect = "ResetConnect";
		constexpr auto DisConnectFPD = "DisConnectFPD";
		constexpr auto UpdateFirmware = "UpdateFirmware";
		constexpr auto SaveSensitivity = "SaveSensitivity";
		constexpr auto SetXrayOnNum = "SetXrayOnNum";
		constexpr auto SetExposureTimes = "SetExposureTimes";
		constexpr auto SetValue_PPS = "SetValue_PPS";

		//Synchronization
		constexpr auto SetAcqMode = "SetAcqMode";
		constexpr auto SetSyncMode = "SetSyncMode";
		constexpr auto SetXwindowSize = "SetXwindowSize";
		constexpr auto PrepareAcquisition = "PrepareAcquisition";
		constexpr auto StartAcquisition = "StartAcquisition";
		constexpr auto StopAcquisition = "StopAcquisition";

		//Calibration
		constexpr auto SetSID = "SetSID";
		constexpr auto ActiveCalibration = "ActiveCalibration";
		constexpr auto PrepareCalibration = "PrepareCalibration";
		constexpr auto StartCalibration = "StartCalibration";
		constexpr auto StopCalibration = "StopCalibration";
		constexpr auto SetCorrectionType = "SetCorrectionType";
		constexpr auto UploadCalibrationFiles = "UploadCalibrationFiles";
		constexpr auto GetRequestedDose = "GetRequestedDose";
		constexpr auto SetRequestedDose = "SetRequestedDose";
		constexpr auto AcceptCalibration = "AcceptCalibration";
		constexpr auto RejectCalibration = "RejectCalibration";
		constexpr auto SaveCalibrationFile = "SaveCalibrationFile";
		constexpr auto GetCalibrationStep = "GetCalibrationStep";
	}

	namespace AttrKey
	{
		//sensor status
		constexpr auto GetTemperatureValue = "GetTemperatureValue";
		constexpr auto GetRemainPowerValue = "GetRemainPowerValue";
		constexpr auto GetWifiStrengthValue = "GetWifiStrengthValue";
		constexpr auto Temperature_Value = "Temperature_Value";
		constexpr auto Remain_Power_Value = "Remain_Power_Value";
		constexpr auto Wifi_Strength_Value = "Wifi_Strength_Value";

		//DetecorCtrl
		constexpr auto DetectorStatus = "DetectorStatus";
		constexpr auto DetectorConnectStatus = "DetectorConnectStatus";
		constexpr auto DetectorAttach = "DetectorAttach";
		constexpr auto DetectorAttachedFlag = "FPDAttached";
		constexpr auto DetectorInitialStatus = "DetectorInitialStatus";
		constexpr auto DetectorUpdateFWStatus = "DetectorUpdateFWStatus";
		constexpr auto FPDShockSensorInfo = "FPDShockSensorInfo";
		constexpr auto SaveRawDataMode = "SaveRawDataMode";

		//Calibration
		constexpr auto CalibrationStatus = "CalibrationStatus";
		constexpr auto CalibrationProgress = "CalibrationProgress";
		constexpr auto UploadCalibrationFilesResult = "UploadCalibrationFilesResult";
		constexpr auto SupportCalibrationType = "SupportCalibrationType";
		constexpr auto SaveCalibrationFileFinish = "SaveCalibrationFileFinish";
		constexpr auto HaveImgCalibration = "HaveImgCalibration";

		//Synchronization
		constexpr auto FPDReadyStatus = "FPDReadyStatus";
		constexpr auto XwindowStatus = "XwindowStatus";
		constexpr auto ImageReadingStatus = "ImageReadingStatus";
		constexpr auto ZskkFPDState = "ZskkFPDState";
		constexpr auto FPDExpReady = "FPDExpReady";
		constexpr auto XrayON = "XrayON";
		constexpr auto SyncMode = "SyncMode";

		//Acquisition
		constexpr auto NoNeedWaitImage = "NoNeedWaitImage";
		constexpr auto ImgDataInfo = "ImgDataInfo";
		constexpr auto AutonumousMapFinish = "AutonumousMapFinish";
		constexpr auto FluPPS = "FluPPS";
		constexpr auto AcqMode = "AcqMode";
		constexpr auto MaxFrameRate = "MaxFrameRate";

		//DICOM 
		constexpr auto DetectorType = "DetectorType";
		constexpr auto Description = "Description";
		constexpr auto DetectorID = "DetectorID";
		constexpr auto FieldofViewShape = "FieldofViewShape";
		constexpr auto FieldofViewDimension = "FieldofViewDimension";
		constexpr auto DateofLastDetectorCalibration = "DateofLastDetectorCalibration";
		constexpr auto TimeofLastDetectorCalibration = "TimeofLastDetectorCalibration";
		constexpr auto DetectorConditionsNominalFlag = "DetectorConditionsNominalFlag";
		constexpr auto FPDSensitivity = "FPDSensitivity";
		constexpr auto PixelData = "PixelData";
		constexpr auto TargetEXI = "TargetEXI";
		constexpr auto ImagerPixelSpacing = "ImagerPixelSpacing";
		constexpr auto DistanceSourcetoDetector = "DistanceSourcetoDetector";
		constexpr auto DistanceSourcetoPatient = "DistanceSourcetoPatient";
		constexpr auto EstimatedRadiographicMagnificationFactor = "EstimatedRadiographicMagnificationFactor";
		constexpr auto DetectorElementSpacing = "DetectorElementSpacing";
	}

	namespace nsDev = CCOS::Dev;


	//-----------------------------------------------------------------------------
	//		AcqUnit
	//-----------------------------------------------------------------------------
	class _CCOSDEVFPDDEVICEMOULD_API AcqUnit : public IOLogicUnit, public IODeviceDetail
	{
		string m_strZskkFPDState;
		string m_strNoNeedWaitImage;
		string m_strLastImage;
		string m_strAutonumousMapFinish;
		string m_strFluPPS;
		string m_strMaxFrameRate;
		string m_strAcqMode;

		DWORD m_nFullWidth;
		DWORD m_nFullHeight;
		DWORD m_nPrevWidth;
		DWORD m_nPrevHeight;
		DWORD m_nBits;

		PVOID m_pFullImageQueue;
		PVOID m_pPrevImageData;

	protected:
		std::shared_ptr <CCOS::Dev::IOEventCenter>  m_EventCenter;

	public:
		AcqUnit();
		~AcqUnit();

		std::string GetGUID() const override { return DetectorAcqType; }
		void OEM_IF SetEventCenter(std::shared_ptr <CCOS::Dev::IOEventCenter>  EventCenter);
		RET_STATUS JSGetAcqMode(std::string& out);
		RET_STATUS JSSetAcqMode(std::string in, std::string& out);
		RET_STATUS JSSetGainMode(std::string in, std::string& out);
		RET_STATUS JSSetBinningMode(std::string in, std::string& out);
		RET_STATUS JSSetZoomMode(std::string in, std::string& out);
		RET_STATUS JSSetDemoImage(std::string in, std::string& out);
		RET_STATUS JSGetZskkFPDState(std::string& out);
		RET_STATUS SetZskkFPDState(string in);
		RET_STATUS JSGetNoNeedWaitImage(std::string& out);
		RET_STATUS JSSetNoNeedWaitImage(std::string in);
		RET_STATUS JSGetLastImage(std::string& out);
		RET_STATUS JSSetFluPPS(std::string in, std::string& out);
		RET_STATUS JSGetFluPPS(std::string& out);
		RET_STATUS JSGetMaxFrameRate(std::string& out);
		RET_STATUS JSAutonumousMapFinish(std::string& out);
		DWORD AddFrame(IMAGE_VIEW_TYPE Type, string ImageHead, WORD* pFrameBuff, DWORD FrameSize);
		RET_STATUS OEM_IF AddFrameWithRawHead(IMAGE_VIEW_TYPE Type, string ImageHead, WORD* pFrameBuff, DWORD FrameSize);

		bool OEM_IF SetMaxBlockSize(const char* pQueName, DWORD BlockSize, DWORD FulBlockCount, DWORD PrevBlockCount);
		bool OEM_IF SetFulImageInfo(DWORD Height, DWORD Width, DWORD Bits, bool FetchFlag);
		bool OEM_IF SetPrevImageInfo(bool Support, DWORD Height, DWORD Width, bool FetchFlag);
		bool OEM_IF FlipX(WORD* pData, UINT nWidth, UINT nHeight);
		bool OEM_IF FlipY(WORD* pData, UINT nWidth, UINT nHeight);
		bool OEM_IF RotateImage(WORD* imageBuffer, int nImageHeight, int nImageWidth, int nAngle);
		void OEM_IF SetMaxFrameRate(float fMaxFrameRate);

		void OEM_NOTIFY SendNoNeedWaitImage(bool bflag);
		void OEM_NOTIFY SendAutonumousMapFinish(int bFlag);
		void OEM_NOTIFY FluPPSNotify(float nCurrentFps);
		void OEM_NOTIFY AcqModeNotify(string strAcqMode);
		void OEM_NOTIFY ImagerPixelSpacingNotify(int nPixelSpacing);
		void OEM_NOTIFY SidNotify(float fSid);
		void OEM_NOTIFY SodNotify(float fSod);
		void OEM_NOTIFY ErmfNotify(float fErmf);

	protected:
		virtual RET_STATUS SetAcqMode(int mode) = 0;
		virtual RET_STATUS SetGainMode(float nGain);
		virtual RET_STATUS SetBinningMode(int nBinningX, int nBinningY);
		virtual RET_STATUS SetZoomMode(int nZOOMX1, int nZOOMY1, int nZOOMX2, int nZOOMY2);
		virtual RET_STATUS SetDemoImage(string strFile);
		virtual RET_STATUS SetFluPPS(float fFluPPS);
		virtual RET_STATUS GetFluPPS(float& fFluPPS);
	};

	//-----------------------------------------------------------------------------
	//		SyncUnit
	//-----------------------------------------------------------------------------
	class _CCOSDEVFPDDEVICEMOULD_API SyncUnit : public IOLogicUnit, public IODeviceDetail
	{
		string m_strReady4EXP;
		string m_strXwindowStatus;
		string m_strFPDExpReady;
		string m_strXrayON;
		string m_strConnectStatus;
		string m_strImageReadingStatus;
		string m_strSupportSyncMode;
		
	protected:
		std::shared_ptr <CCOS::Dev::IOEventCenter>  m_EventCenter;
	public:
		SyncUnit();
		~SyncUnit();

		std::string GetGUID() const override { return DetectorSyncType; }

		void OEM_IF SetEventCenter(std::shared_ptr <CCOS::Dev::IOEventCenter>  EventCenter);
		RET_STATUS JSSetSyncMode(std::string in, std::string& out);
		RET_STATUS JSGetSyncMode(std::string& out);
		RET_STATUS JSSetXwindowSize(std::string in, std::string& out);
		RET_STATUS JSSetFrameRate(std::string in, std::string& out);
		RET_STATUS JSPrepareAcquisition(std::string in, std::string& out);
		RET_STATUS JSStartAcquisition(std::string in, std::string& out);
		RET_STATUS JSStopAcquisition(std::string in, std::string& out);
		RET_STATUS JSActiveSyncMode(std::string in, std::string& out);

		RET_STATUS JSGetFPDReady(std::string& out);
		RET_STATUS JSSetFPDReady(std::string in);
		RET_STATUS JSGetConnectStatus(std::string& out);
		RET_STATUS JSGetXrayON(std::string& out);
		RET_STATUS JSGetImageReadingStatus(std::string& out);
		RET_STATUS JSSetImageReadingStatus(std::string in);
		RET_STATUS JSGetExpReadyStatus(std::string& out);
		RET_STATUS JSGetXWindowStatus(std::string& out);
		RET_STATUS JSSetXWindowStatus(std::string in);
		RET_STATUS JSGetSupportSyncMode(std::string& out);
		RET_STATUS JSSetSupportSyncMode(std::string in);
		
		void OEM_NOTIFY FPDReadyNotify(bool bReady);
		void OEM_NOTIFY FPDConnectStatusNotify(bool bConnect);
		void OEM_NOTIFY XWindowOnNotify();
		void OEM_NOTIFY XWindowOffNotify();
		void OEM_NOTIFY FakeEIPONNotify();
		void OEM_NOTIFY XrayONNotify();
		void OEM_NOTIFY XrayOffNNotify();
		void OEM_NOTIFY ImageReadingNotify();
		void OEM_NOTIFY ExpReadyNotify(int nMillisecond);
		
	protected:
		virtual RET_STATUS SetSyncMode(SYNC_MODE nSyncMode, HARDWARE_TRIGGER_MODE TriggerMode) = 0;
		virtual RET_STATUS GetSyncMode(SYNC_MODE& nSyncMode);
		virtual RET_STATUS SetXwindow(float XwindowSize) = 0;
		virtual RET_STATUS SetFrameRate(float fFrameRate);
		virtual RET_STATUS PrepareAcquisition() = 0;
		virtual RET_STATUS StartAcquisition(string in = "") = 0;
		virtual RET_STATUS StopAcquisition() = 0;
		virtual RET_STATUS ActiveSyncMode(int nSyncMode) = 0;
	};

	//-----------------------------------------------------------------------------
	//		CalibUnit
	//-----------------------------------------------------------------------------
	class _CCOSDEVFPDDEVICEMOULD_API CalibUnit : public IOLogicUnit, public IODeviceDetail
	{
		CCOS_CALIBRATION_TYPE m_CurrentCalibType;
		CCOS_CALIBRATION_STATUS m_CalibStatus;
		string m_strCalibProgress;
		string m_strUploadCalibrationFilesResult;
		string m_strSaveCalibrationFileFinish;
	protected:
		std::shared_ptr <CCOS::Dev::IOEventCenter>  m_EventCenter;
	public:
		CalibUnit();
		~CalibUnit();
		std::string GetGUID() const override { return DetectorCalibType; }

		void OEM_IF SetEventCenter(std::shared_ptr <CCOS::Dev::IOEventCenter>  EventCenter);
		RET_STATUS JSActiveCalibration(std::string in, std::string& out);
		RET_STATUS JSGetRequestedDose(std::string in, std::string& out);
		RET_STATUS JSSetRequestedDose(std::string in, std::string& out);
		RET_STATUS JSPrepareCalibration(std::string in, std::string& out);
		RET_STATUS JSStartCalibration(std::string in, std::string& out);
		RET_STATUS JSStopCalibration(std::string in, std::string& out);
		RET_STATUS JSSetSID(std::string in, std::string& out);
		RET_STATUS JSSetCorrectionType(std::string in, std::string& out);
		RET_STATUS JSUploadCalibrationFiles(std::string in, std::string& out);
		RET_STATUS JSGetCalibrationStep(std::string in, std::string& out);
		RET_STATUS JSAcceptCalibration(std::string in, std::string& out);
		RET_STATUS JSRejectCalibration(std::string in, std::string& out);
		RET_STATUS JSSaveCalibrationFile(std::string in, std::string& out);
		RET_STATUS JSGetCalibStatus(std::string& out);
		RET_STATUS JSGetCalibProgress(std::string& out);
		RET_STATUS JSGetUploadCalibrationFilesResult(std::string& out);
		RET_STATUS JSGetSupportCalibrationType(std::string& out);
		RET_STATUS JSGetHaveImgCalibration(std::string& out);
		RET_STATUS JSGetSaveCalibrationFileFinish(std::string& out);

		RET_STATUS OEM_IF PauseCalibration();
		RET_STATUS SetCalibrationStatus(string in);
		RET_STATUS SetCalibrationProgress(string in);
		RET_STATUS SetUploadCalibrationFilesResult(string in);
		void OEM_IF SetSaveCalibrationFileFinish(bool bResult);
		CCOS_CALIBRATION_TYPE OEM_IF GetCalibrationType();
		CCOS_CALIBRATION_STATUS OEM_IF GetCalibrationStatus();

	protected:
		virtual RET_STATUS SetSID(int nSID) = 0;
		virtual RET_STATUS ActiveCalibration(CCOS_CALIBRATION_TYPE in) = 0;
		virtual RET_STATUS PrepareCalibration() = 0;
		virtual RET_STATUS GetRequestedDose(std::string& out) = 0;
		virtual RET_STATUS SetRequestedDose(std::string in);
		virtual RET_STATUS StartCalibration() = 0;
		virtual RET_STATUS StopCalibration() = 0;
		virtual RET_STATUS SetCorrectionType(CCOS_CORRECTION_TYPE in) = 0;
		virtual RET_STATUS UploadCalibrationFiles(string strFileName) = 0;
		virtual RET_STATUS GetCalibrationStep(int nDetectorID, string& strCalibrationStepInfo);
		virtual RET_STATUS AcceptCalibration();
		virtual RET_STATUS RejectCalibration();
		virtual RET_STATUS SaveCalibrationFile(bool bSaveFlag);
		virtual bool Support_DarkCalib();
		virtual bool Support_XrayCalib();
		virtual bool Support_HaveImageCalib();
	};

	//-----------------------------------------------------------------------------
	//		DetectorCtrlUnit
	//-----------------------------------------------------------------------------
	class _CCOSDEVFPDDEVICEMOULD_API DetectorCtrlUnit : public IOLogicUnit, public IODeviceDetail
	{
		DETECTOR_STATUS m_DetectorStatus;
		DETECTOR_SHARE_STATUS m_DetectorConnectStatus;
		string m_strUpdateFWStatus;
		string m_strInitialStatus;
		string m_strAttachStatus;
		string m_strAttachResult;
		string m_strShockSensor;
		string m_strRecoverImageState;
		string m_strRecoverImageEvent;

		string m_strFieldofViewShape;
		string m_strFieldofViewDimension;
		string m_strDetectorType;
		string m_strDescription;
		string m_strDetectorID;
		string m_strDateofLastDetectorCalibration;
		string m_strTimeofLastDetectorCalibration;
		string m_strDetectorConditionsNominalFlag;
		string m_strFPDSensitivity;
		string m_strFPDSensitivityResult;
		string m_strPixelData;
		string m_strTargetEXI;
		string m_strFirmwareStatus;
		string m_strSupportDDR;
		
	protected:
		std::shared_ptr <CCOS::Dev::IOEventCenter>  m_EventCenter;
	public:
		DetectorCtrlUnit();
		~DetectorCtrlUnit();

		std::string GetGUID() const override { return DetectorCtrlType; }

		void OEM_IF SetEventCenter(std::shared_ptr <CCOS::Dev::IOEventCenter>  EventCenter);
		//Action
		RET_STATUS JSRESET(std::string in, std::string& out);
		RET_STATUS JSActiveDetector(std::string in, std::string& out);
		RET_STATUS JSWakeupDetector(std::string in, std::string& out);
		RET_STATUS JSEnterExam(std::string in, std::string& out);
		RET_STATUS JSExitExam(std::string in, std::string& out);
		RET_STATUS JSAttachConnect(std::string in, std::string& out);
		RET_STATUS JSCancelAttach(std::string in, std::string& out);
		RET_STATUS JSGetDetectorInfo(std::string in, std::string& out);
		RET_STATUS JSResetConnect(std::string in, std::string& out);
		RET_STATUS JSDisConnectFPD(std::string in, std::string& out);
		RET_STATUS JSDisConnectFPDForce(std::string in, std::string& out);
		RET_STATUS JSUpdateFirmware(std::string in, std::string& out);
		RET_STATUS JSRecoverImage(std::string in, std::string& out);
		RET_STATUS JSSaveSensitivity(std::string in, std::string& out);
		RET_STATUS JSSetXrayOnNum(std::string in, std::string& out);
		RET_STATUS JSSetExposureTimes(std::string in, std::string& out);
		RET_STATUS JSGetRecoverImageState(std::string in, std::string& out);
		//Get Set
		RET_STATUS OEM_IF SetDetectorStatus(string in);
		RET_STATUS JSGetFPDStatus(std::string& out);
		RET_STATUS OEM_IF SetConnectStatus(string in);
		RET_STATUS JSGetConnectStatus(std::string& out);
		RET_STATUS OEM_IF SetAttachResult(string in);
		RET_STATUS JSGetAttachResult(std::string& out);
		RET_STATUS OEM_IF SetAttachStatus(string in);
		RET_STATUS JSGetAttachStatus(std::string& out);
		RET_STATUS OEM_IF SetInitialStatus(string in);
		RET_STATUS JSGetInitialStatus(std::string& out);
		RET_STATUS OEM_IF SetUpdateFWStatus(string in);
		RET_STATUS JSGetUpdateFWStatus(std::string& out);
		RET_STATUS OEM_IF SetShockSensorInfo(string in);
		RET_STATUS JSGetShockSensorInfo(std::string& out);
		RET_STATUS OEM_IF SetRecoverImageState(string in);
		RET_STATUS JSGetRecoverImageState(std::string& out);
		RET_STATUS OEM_IF SetRecoverImageEvent(string in);
		RET_STATUS JSGetRecoverImageEvent(std::string& out);
		RET_STATUS OEM_IF SetFieldofViewShape(string in);
		RET_STATUS JSGetFieldofViewShape(std::string& out);
		RET_STATUS OEM_IF SetFieldofViewDimension(string in);
		RET_STATUS JSGetFieldofViewDimension(std::string& out);
		RET_STATUS OEM_IF SetDetectorType(string in);
		RET_STATUS JSGetDetectorType(std::string& out);
		RET_STATUS OEM_IF SetDescription(string in);
		RET_STATUS JSGetDescription(std::string& out);
		RET_STATUS OEM_IF SetDetectorID(string in);
		RET_STATUS JSGetDetectorID(std::string& out);
		RET_STATUS OEM_IF SetDateofLastDetectorCalibration(string in);
		RET_STATUS JSGetDateofLastDetectorCalibration(std::string& out);
		RET_STATUS OEM_IF SetTimeofLastDetectorCalibration(string in);
		RET_STATUS JSGetTimeofLastDetectorCalibration(std::string& out);
		RET_STATUS OEM_IF SetDetectorConditionsNominalFlag(string in);
		RET_STATUS JSGetDetectorConditionsNominalFlag(std::string& out);
		RET_STATUS OEM_IF SetFPDSensitivity(string in);
		RET_STATUS JSGetFPDSensitivity(std::string& out);
		RET_STATUS OEM_IF SetFPDSensitivityResult(string in);
		RET_STATUS JSGetFPDSensitivityResult(std::string& out);
		RET_STATUS OEM_IF SetPixelData(string in);
		RET_STATUS JSGetPixelData(std::string& out);
		RET_STATUS OEM_IF SetTargetEXI(string in);
		RET_STATUS JSGetTargetEXI(std::string& out);
		//DDR
		RET_STATUS OEM_IF SetSupportDDR(string in);
		RET_STATUS JSGetSupportDDR(std::string& out);
		//DDR
		RET_STATUS OEM_IF SetLastError(string in);
		RET_STATUS JSGetLastError(std::string& out);

		RET_STATUS JSSetFilterType(std::string in, std::string& out);

		RET_STATUS OEM_IF SetFirmwareStatus(string in);
		RET_STATUS JSGetFirmwareStatus(std::string& out);

		RET_STATUS JSSaveRawDataMode(std::string in, std::string& out);

		RET_STATUS JSOfflineFPD(std::string in, std::string& out);
		RET_STATUS JSOnlineFPD(std::string in, std::string& out);
		RET_STATUS JSGetAutonumousImageList(std::string in, std::string& out);
		RET_STATUS JSRemoveAutonumousImageList(std::string in, std::string& out);
		RET_STATUS JSRemoveAutonumousAll(std::string in, std::string& out);
		RET_STATUS JSGetImageMetaData(std::string in, std::string& out);
		RET_STATUS JSExportAutonumousAll(std::string in, std::string& out);

		DETECTOR_STATUS GetDetectorStatus();
	protected:
		virtual RET_STATUS ActiveDetector(bool bActive) = 0;
		virtual RET_STATUS EnterExam(int nExamStatus) = 0;
		virtual RET_STATUS GetDetectorInfo(string& strFDI) = 0;
		virtual RET_STATUS RESET();
		virtual RET_STATUS WakeupDetector();
		virtual RET_STATUS ExitExam();
		virtual RET_STATUS AttachConnect();
		virtual RET_STATUS CancelAttach();
		virtual RET_STATUS ResetConnect();
		virtual RET_STATUS DisConnectFPD();
		virtual RET_STATUS DisConnectFPDForce();
		virtual RET_STATUS UpdateFirmware();
		virtual RET_STATUS RecoverImage(bool bRecoverIt);
		virtual RET_STATUS SaveSensitivity();
		virtual RET_STATUS SetXrayOnNum();
		virtual RET_STATUS SetExposureTimes(int nTimes);
		virtual RET_STATUS GetRecoverImageState(string& strREI);
		virtual RET_STATUS SetFilterType(int nFilter);
		virtual RET_STATUS SaveRawDataMode(int nSaveRawDataMode);
		virtual RET_STATUS OfflineFPD(int nOfflineFPDMode);
		virtual RET_STATUS OnlineFPD(int nOnlineFPDMode);
		virtual RET_STATUS GetAutonumousImageList(int nDetectorID, vector<string>& AutonumousList);
		virtual RET_STATUS RemoveAutonumousImageList(string strMeta);
		virtual RET_STATUS RemoveAutonumousAll();
		virtual RET_STATUS GetImageMetaData(string strMetaData);
		virtual RET_STATUS ExportAutonumousAll();
	};

	//-----------------------------------------------------------------------------
	//		ConfigInfo
	//-----------------------------------------------------------------------------
	class _CCOSDEVFPDDEVICEMOULD_API ConfigInfo
	{
	public:
		ConfigInfo(const char* Key, const char* strType, const char* strAccess, const char* strRequired, const char* strDefaultValue);
		virtual ~ConfigInfo();
		void SetList(const char* str);
		void SetRange(const char* strmin, const char* strmax);
		const char* GetCurrentValue();
		void SetCurrentValue(const char* res);
		const char* GetDescription();
		const char* GetKey();


	private:
		std::string strConfKey;
		std::string resValue;
		std::string resDescription;
	};

	//-----------------------------------------------------------------------------
	//		FPDDeviceMould
	//-----------------------------------------------------------------------------
	class  _CCOSDEVFPDDEVICEMOULD_API  FPDDeviceMould : public IODeviceDetail
	{
	public:
		FPDDeviceMould();
		~FPDDeviceMould();

		//protected:

		//	virtual void RegisterCtrl();
		//	virtual void RegisterAcq();
		//	virtual void RegisterSync();
		//	virtual void RegisterCalib();
		//	virtual void RegisterOthers();
	};
}

namespace CCOS::Dev::Detail::Detector
{
	class  _CCOSDEVFPDDEVICEMOULD_API  FPDDriverMould : public CCOS::Dev::IODriver
	{
	public:
		FPDDriverMould();
		~FPDDriverMould();

	public:

		virtual std::string GetGUID() const;

		//virtual void Prepare() override;
		//virtual int  Connect() override;
		//virtual void Disconnect() override;
		//virtual bool isConnected() const override;
		//virtual void FireNotify(int code, std::string key, std::string content) override;
		//virtual auto CreateDevice(int index)->std::unique_ptr <IODevice> override;
		//virtual std::string DriverProbe() override;
		//virtual std::string GetResource() override;
		//virtual std::string DeviceProbe() override;

		void AddConfig(ConfigInfo config);

	protected:
		std::list <ConfigInfo> m_ConfigInfo;
	};
}