Deliver/include/BatteryMould.hpp

#pragma once
#include <memory>
#include "ResDataObject.h"
#include "CCOS.Dev.IODevice.hpp"
#include "CCOS.Dev.MouldDefine.hpp"
#include "Detector_Model_Def.h"

namespace CCOS::Dev::Detail
{
	class DeviceBatteryMould : public IntMouldWithWarn
	{
		typedef enum ECOM_Battery_state
		{
			ECOM_BAT_STATE_TOO_LOW = 0,
			ECOM_BAT_STATE_LOW,
			ECOM_BAT_STAE_NORMAL,
			ECOM_BAT_STATE_GOOD,
			ECOM_BAT_STATE_FULL
		}ECOM_BATTERY_STATE;

		int m_RemainPowerValue;
		std::shared_ptr <CCOS::Dev::IOEventCenter>  m_EventCenter;
		std::string m_Key;

	public:
		using super = IntMouldWithWarn;

		DeviceBatteryMould(const char* strkey, int initialvalue, int min, 
			int WarnMin, int WarnMax, int CalibWarnMin, int CalibWarnMax, 
			int max, int accuracy, std::shared_ptr <CCOS::Dev::IOEventCenter>  EventCenter)
			:super(strkey, initialvalue, min, WarnMin, WarnMax, CalibWarnMin, CalibWarnMax, max, accuracy)
		{
			m_Key = strkey;
			m_EventCenter = EventCenter;
			m_RemainPowerValue = 0;
		}

		~DeviceBatteryMould() {}

		std::string GetDescription()
		{
			ResDataObject temp, result;
			temp.add(ValKey::UPPERLIMIT, m_LimitMax);
			temp.add(ValKey::LOWERLIMIT, m_LimitMin);
			temp.add(ValKey::WARNUPPERLIMIT, m_WarningMax);
			temp.add(ValKey::WARNLOWERLIMIT, m_WarningMin);
			temp.add(ValKey::ACCURACY, m_Accuracy);
			temp.add(ValKey::UNIT, m_Key.c_str());
			result.add(Key.c_str(), temp);
			return result.encode();
		}

		RET_STATUS JSGetCurrentBatteryValue(std::string & out)
		{
			char szFDinfo[MAX_STRING] = { 0 };
			sprintf(szFDinfo, "%d", m_RemainPowerValue);
			out = szFDinfo;
			return RET_STATUS::RET_SUCCEED;
		}

		bool SetRemainPowerValue(int nValue, int & nStatus)
		{
			m_RemainPowerValue = nValue;
			if (m_WarningMin <= nValue)
			{
				nStatus = ECOM_BAT_STAE_NORMAL;
			}
			else if (m_LimitMin <= nValue && nValue < m_WarningMin)
			{
				nStatus = ECOM_BAT_STATE_LOW;
			}
			else if (nValue < m_LimitMin)
			{
				nStatus = ECOM_BAT_STATE_TOO_LOW;
			}

			char szFDinfo[MAX_STRING] = { 0 };
			sprintf(szFDinfo, "%d", nValue);
			m_EventCenter->OnNotify((int)ATTRACTION_SET, "Remain_Power_Value", szFDinfo);
			return true;
		}

		RET_STATUS JSGetBatteryWarningMin(std::string& out)
		{
			char szFDinfo[MAX_STRING] = { 0 };
			sprintf(szFDinfo, "%d", m_WarningMin);
			out = szFDinfo;
			return RET_STATUS::RET_SUCCEED;
		}

		RET_STATUS JSGetBatteryErrorMin(std::string& out)
		{
			char szFDinfo[MAX_STRING] = { 0 };
			sprintf(szFDinfo, "%d", m_ErrorMin);
			out = szFDinfo;
			return RET_STATUS::RET_SUCCEED;
		}

		RET_STATUS SetBatteryWarningMin(string nValue)
		{
			int temp = atoi(nValue.c_str());
			if (m_WarningMin == temp)
			{
				return RET_STATUS::RET_SUCCEED;
			}
			m_WarningMin = temp;

			char szFDinfo[MAX_STRING] = { 0 };
			sprintf(szFDinfo, "%d", m_WarningMin);
			m_EventCenter->OnNotify((int)ATTRACTION_SET, "BatLowerLimit", szFDinfo);
			return RET_STATUS::RET_SUCCEED;
		}

		RET_STATUS SetBatteryErrorMin(string nValue)
		{
			int temp = atoi(nValue.c_str());
			if (m_ErrorMin == temp)
			{
				return RET_STATUS::RET_SUCCEED;
			}
			m_ErrorMin = temp;

			char szFDinfo[MAX_STRING] = { 0 };
			sprintf(szFDinfo, "%d", m_ErrorMin);
			m_EventCenter->OnNotify((int)ATTRACTION_SET, "BatMiniLimit", szFDinfo);
			return RET_STATUS::RET_SUCCEED;
		}

		RET_STATUS JSGetBatteryCalibWarningMin(std::string& out)
		{
			char szFDinfo[MAX_STRING] = { 0 };
			sprintf(szFDinfo, "%d", m_CalibWarningMin);
			out = szFDinfo;
			return RET_STATUS::RET_SUCCEED;
		}

		bool SetBatteryCalibWarningMin(int nValue)
		{
			if (m_CalibWarningMin == nValue)
			{
				return true;
			}
			m_CalibWarningMin = nValue;

			char szFDinfo[MAX_STRING] = { 0 };
			sprintf(szFDinfo, "%d", nValue);
			m_EventCenter->OnNotify((int)ATTRACTION_SET, "BatLowerLimitInCali", szFDinfo);
			return true;
		}

		RET_STATUS SetBatLowerLimitInCalib(string nValue)
		{
			int temp = atoi(nValue.c_str());
			if (m_CalibWarningMin == temp)
			{
				return RET_STATUS::RET_SUCCEED;
			}
			m_CalibWarningMin = temp;

			char szFDinfo[MAX_STRING] = { 0 };
			sprintf(szFDinfo, "%d", m_CalibWarningMin);
			m_EventCenter->OnNotify((int)ATTRACTION_SET, "BatLowerLimitInCali", szFDinfo);
			return RET_STATUS::RET_SUCCEED;
		}

		RET_STATUS JSUpdateBatteryWarningMin(string in, string& out)
		{
			out = in;
			return SetBatteryWarningMin(in);
		}

		RET_STATUS JSUpdateBatteryErrorMin(string in, string& out)
		{
			out = in;
			return SetBatteryErrorMin(in);
		}

		RET_STATUS JSUpdateBatLowerLimitInCalib(string in, string& out)
		{
			out = in;
			return SetBatLowerLimitInCalib(in);
		}

	};//DeviceBatteryMould
}