#include <unistd.h>
#include <fstream>
#include <sstream>
#include "webrtc/WebRTCVideoChat.h"
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>


#include "rw_zlog.h"
#include "common_utils.h"
#include "assert.h"
#include "cmd_process.h"
#include "db_manage.h"
#include "BackStage.h"
#include "file_utils.h"
#include "rw_protocol.h"
#include "detector/detector_tracker.h"
#include "decision_actuator/standby.h"
#include "dev_version.h"
#include "libcJSON.h"
#include "ScopeGuard.h"
#include "Peripheral.h"
#include "cmd_process.h"
#include "pe_input/pe_input.h"
#include "decision_center/decision_center.h"
#include "tracker_lock/tracker_lock.h"
#include "camera/camera.h"
#include "UiConfig.h"
#include "bluetooth.h"
#include "View.h"
#include "person_manage.h"

#include "CardReaderProp.h"
#include "decision_actuator/decision_actuator.h"


Backstage::Backstage(void* pParaMng,   void* pObjs)
{
    m_paramMng = reinterpret_cast<ParamManage*>(pParaMng);
    m_objs = reinterpret_cast<GOBJ>(pObjs);
}

Backstage::~Backstage()
{
}

int Backstage::registerPerson(char *name, char *term, int nDataOrigin)
{
	if ((name == nullptr) || (term == nullptr))
	{
		LOGE("param error!name==%p, term===%p", name, term);
		return -1;
	}

	return 0;
}
      
int Backstage::startIdentyState(bool setfaceReco, bool setPeInput)
{
	 LOGI("startIdentyState");
     if(setfaceReco && m_objs){
        GDetectorTracker *tracker = (GDetectorTracker*)m_objs->findObject("DetectorTracker");
        GStandby *pStandby = (GStandby*)m_objs->findObject("standby");
	 	GTrackerLock *pTrackLock = (GTrackerLock*)m_objs->findObject("trackerLock"); 
        if (tracker && pStandby && pTrackLock){
            if(!Singleton<Peripheral>::GetInstance()->isHardwareTesting()){
                tracker->setRgbFaceDetMode(false);
                pStandby->setKeepAwake(false); 
            }
            else{
                LOGI("is testing hardware...");
                tracker->setRgbFaceDetMode(true);
                pStandby->setKeepAwake(true);
            }				
            pTrackLock->lockCtrl(false);
        }
    }
	if(setPeInput){
		Singleton<Peripheral>::GetInstance()->enableUserInput(Peripheral::enOptorMid, false, true);
	}
	return 0;
}

int Backstage::stopIdentyState(bool setfaceReco, bool setPeInput)
{
	LOGI("stopIdentyState");
    if(setfaceReco && m_objs){
        GDetectorTracker *tracker = (GDetectorTracker*)m_objs->findObject("DetectorTracker");
        GStandby *pStandby = (GStandby*)m_objs->findObject("standby");
		GTrackerLock *pTrackLock = (GTrackerLock*)m_objs->findObject("trackerLock");
        if (tracker && pStandby && pTrackLock){ 
            tracker->setRgbFaceDetMode(false, true);
            pStandby->setKeepAwake(true);
			pTrackLock->lockCtrl(true);
        }
    }
	if(setPeInput){
		Singleton<Peripheral>::GetInstance()->enableUserInput(Peripheral::enOptorMid, true, false);
	}
	return 0;
}

int Backstage::verifyFactorySettingPwd(const char *pwd)
{
    int ret = -1;
    if(nullptr == pwd)
	{
		LOGE("param pwd is NULL!");
		return -1;
	}
    if (FileUtils::fileIsExist(PASSWORD_FILE))
	{
        ifstream infile; 
        infile.open(PASSWORD_FILE);  
        if(infile.is_open()){            
            //std::string s;
            //while(getline(infile,s)) {
                //cout<<s<<endl;
            //}
            std::string user;
            std::string password;
            getline(infile,user);
            getline(infile,password);
            infile.close();   
            ret = password.compare(pwd);
        }
        else{
            LOGE("open password file failed!");
        }
    }
    else
    {
        ret = std::string(pwd).compare(DEFAULT_PASSWORD);
    }
	return ret;
}

int Backstage::recoveryFactorySetting()
{
    LOGD("recovery factory setting!");
    //if(cleanData() != 0)
    if(clearData(true) != 0)
    {
        LOGE("clean data failed!");        
    }
    m_paramMng->clearParam();
    FileUtils::removeFile(AGEING_TIME_FILE);
    FileUtils::removeFile(DB_PATH"faceGate.db");
    FileUtils::removeFile(NETWORK_CFG_FILE);
	FileUtils::remove_dir(MEETING_DIR);
	FileUtils::remove_dir(TTS_PERSISTENCE_DIR);
	
    //devReboot();  //need black page before reboot
	
	return resetNetworkCfg();
}

int Backstage::getDeviceId(char *devId, int len)// 获取设备id
{
    int ret = -1;
    constexpr auto macFile = "/data/.mac";
    memset(devId, 0, len);
    if (FileUtils::fileIsExist(macFile) && FileUtils::getFileSize(macFile) > 0) {
        const std::string sDevId = getDevId();
        LOGD("sDevId=%s", sDevId.c_str());
        if (sDevId.length() < (unsigned)len) {
            strcpy(devId, sDevId.c_str());
            ret = 0;
        }
    }
    return ret;
}

std::string Backstage::getUnderScreenNfcModuleId(){
    CardReaderProp prop(CARD_READER_PROP_FILE);
    return prop.UnderScreenCardReaderModuleId();
}
	
std::string Backstage::getExtendNfcModuleId(){
    CardReaderProp prop(CARD_READER_PROP_FILE);
    return prop.ExtendUsbCardReaderModuleId();
}

bool Backstage::isIdModuleInfoUploaded(){
	LOGI("isIdModuleInfoUploaded");
	return FileUtils::fileIsExist("/tmp/.idModuleInfoUpload2Iot");
}

bool Backstage::isDevSettingDisable()
{
	return m_paramMng->getDisableDevSettingSw();
}

void Backstage::setAntiDemolitionAvail(bool avail, bool upload)
{
	m_paramMng->setAntiDemolitionAvail(avail);

	static int outputType = 0;
	if(avail){
		outputType = getAntiDemolitionOutput();
		if(1 == outputType){
			GDecisionActuator::relayOnCB(2);
		}else if(2 == outputType){
			Singleton<Peripheral>::GetInstance()->controlGpioOut(BasePeripheral::enGpio2, false); 
		}else if(3 == outputType){
			Singleton<Peripheral>::GetInstance()->controlGpioOut(BasePeripheral::enGpio3, false); 
		}

		if(upload){
			RWProtocol::getInstance()->addAlarmEvent(2, utils::getNowTimeS(), "");
		}
	}else if(outputType){
		if(1 == outputType){
			GDecisionActuator::relayOnCB(3);
		}else if(2 == outputType){
			Singleton<Peripheral>::GetInstance()->controlGpioOut(BasePeripheral::enGpio2, true); 
		}else if(3 == outputType){
			Singleton<Peripheral>::GetInstance()->controlGpioOut(BasePeripheral::enGpio3, true); 
		}
	}
}

bool Backstage::getAntiDemolitionSw()
{
	return m_paramMng->getAntiDemolitionSw();
}

void Backstage::setAntiDemolitionSw(bool sw)
{
	m_paramMng->setAntiDemolitionSw(sw);
}

int Backstage::getAntiDemolitionOutput()
{
	return m_paramMng->getAntiDemolitionOutput();
}

void Backstage::setAntiDemolitionOutput(int output)
{
	m_paramMng->setAntiDemolitionOutput(output);
}

int Backstage::getGpio4Cfg()
{
	return m_paramMng->getGpio4Cfg();
}

void Backstage::setGpio4Cfg(int cfg)
{
	m_paramMng->setGpio4Cfg(cfg);
}

int Backstage::getGpio5Cfg()
{
	return m_paramMng->getGpio5Cfg();
}

void Backstage::setGpio5Cfg(int cfg)
{
	m_paramMng->setGpio5Cfg(cfg);
}

int Backstage::getDoorCloseOvertime()
{
	return m_paramMng->getDoorCloseOvertime();
}

void Backstage::setDoorCloseOvertime(int overtime)
{
	m_paramMng->setDoorCloseOvertime(overtime);
}

bool Backstage::getDisableDevSettingSw()
{
	return m_paramMng->getDisableDevSettingSw();
}

void Backstage::setDisableDevSettingSw(bool sw)
{
	m_paramMng->setDisableDevSettingSw(sw);
}

int Backstage::getTicketCheckCountToday()
{
	const std::string curDay = utils::format_time(time(nullptr)).substr(0, 10);
	const std::string cntDay = RWProtocol::getInstance()->m_paramMng->getTicketCheckDay();
	if(curDay != cntDay){
		return 0;
	}
	return m_paramMng->getTicketCheckCount();
}

int Backstage::getTicketModePeopleCountType()
{
	return m_paramMng->getTicketModePeopleCountType();
}

int Backstage::getCallDevList() {
    WebRTCVideoChat::instance()->requestContacts();
    return 0;
}

int Backstage::queryCallDevList(const std::string &text, std::vector<stCallDev> &devList) {
    devList.clear();
    auto contacts = WebRTCVideoChat::instance()->contactsSearch(text);
    for (auto &contact : contacts) {
        stCallDev info;
        info.code = contact.code;
        info.devTag = contact.uniqueTag;
        info.name = contact.name;
        info.type = contact.type;
        info.status = contact.status;
        devList.push_back(info);
    }
    return 0;
}

int Backstage::callDev(const std::string &devTag, int devType) {
    WebRTCVideoChat::instance()->callRemote(devType == 2 ? WebRTCVideoChat::Platform : WebRTCVideoChat::Device, devTag);
    return 0;
}

int Backstage::callAbort() {
    WebRTCVideoChat::instance()->setCurrentSessionAction(WebRTCVideoChat::Action::Cancel);
    return 0;
}

int Backstage::callHangUp() {
    WebRTCVideoChat::instance()->setCurrentSessionAction(WebRTCVideoChat::Action::Hangup);
    return 0;
}

int Backstage::callReject() {
    WebRTCVideoChat::instance()->setCurrentSessionAction(WebRTCVideoChat::Action::Reject);
    return 0;
}

int Backstage::callAccept() {
    WebRTCVideoChat::instance()->setCurrentSessionAction(WebRTCVideoChat::Action::Pickup);
    return 0;
}

int Backstage::openCallRemoteDoor() {
    WebRTCVideoChat::instance()->setCurrentSessionAction(WebRTCVideoChat::Action::OpenDoor);
    return 0;
}

void Backstage::verifyAbort()
{	
	GDecisionActuator *decAor = (GDecisionActuator*)m_objs->findObject("decisionActuator");
	if (!decAor){return;}
	decAor->verifyAbort();
}

bool Backstage::getShowIdAndVerSw()
{
	return m_paramMng->getRecoUiShowDevIdAndVerSw();
}

int Backstage::setShowIdAndVerSw(bool sw)
{
	m_paramMng->setRecoUiShowDevIdAndVerSw(sw);
	return 0;
}

int Backstage::playAudio(enAudioIndex index)
{
	GDecisionActuator *decAor = (GDecisionActuator*)m_objs->findObject("decisionActuator");
	if (!decAor){return -1;}
	const std::vector<int> indexMap{32};
	if(index < 0 || index >= indexMap.size()){return -2;}
	return decAor->_playAudioProc(indexMap.at(index));
}

int Backstage::userItemChoose(int index)
{
	GDecisionCenter *decCenter = (GDecisionCenter*)m_objs->findObject("decisionCenter");
	if (decCenter){
		decCenter->userItemChoose(index);
	}
	return 0;
}

int Backstage::callSetVideoStream(bool enable) {
    WebRTCVideoChat::instance()->setCurrentSessionAction(enable ? WebRTCVideoChat::Action::EnableVideo
                                                                : WebRTCVideoChat::Action::DisableVideo);
    return 0;
}

int Backstage::getHardwareConfig(char *hardVer, int len)//获取系统版本
{
	int ret = -1;
    std::string version;
    getHardVersion(version);
	LOGD("version=%s",version.c_str());
    if(version.length() < (unsigned)len){
        strcpy(hardVer, version.c_str());
        ret = 0;
    }
	return ret;
}

int Backstage::getStorSpace(int &total, float &free)//获取存储空间
{    
    int ret = -1;

#if 0
    char buf[1024] = {0};        
    FILE *fp = popen("df -h | grep \"/data\"", "r"); 
    if (fp == NULL)
    {
        LOGE("popen FAIL!");
        return ret;
    }
    while(fgets(buf, 1024, fp) != NULL)
    {
        LOGD("read buf : %s", buf);
        if (strstr(buf, "/data") && strstr(buf, "G"))
        {
            unsigned iPos = 0;
            std::string line(buf);
            for(int i=0; i<2; i++){
            iPos = line.find_last_of(" ");
                if(iPos != std::string::npos){
                    line = std::string(line.begin(), line.begin() + iPos);
                    line = line.substr(line.find_first_not_of(' '), line.find_last_not_of(' ') + 1);
                }
            }
            iPos = line.find_last_of(" ");
            if(iPos != std::string::npos)
            {
                line = line.substr(iPos + 1);
                line = line.substr(line.find_first_not_of(' '), line.find_last_not_of(' ') + 1);
                LOGD("avai space:%s", line.c_str());
                line.erase(line.length() - 1);
                if(line.length() > 0){
                    free = std::stof(line);
                    ret = 0;
                }
            }
        }
    }
    total = 16;
    if(SERIES_B021 == DevVersion::getInstance()->getDevSeries())
    {
        total = 8;
    }
#else
    ret = getStoreSpace(free, total);
#if 0
    total = 16;
    if(SERIES_B021 == DevVersion::getInstance()->getDevSeries())
    {
        total = 8;
    }
#endif
#endif
	return ret;
}

int Backstage::getAppVersion(char *appVer, int len)//获取应用版本号
{	
	int ret = -1;
    std::string version;
    getSoftVersion(version);
    if (version.at(version.length() - 1) == '\n')
    {
        version.erase(version.length() - 1);
    }
    
    if(version.length() < (unsigned)len){
        strcpy(appVer, version.c_str());
        ret = 0;
    }
	return ret;
}

int Backstage::getRegisterNum()//获取注册人员数
{
    int personCount = 0;
    DBManage::getInstance()->getPersonAllCount(personCount);
	return personCount;
}

int Backstage::getAccessRecordQty()
{
    int sum = 0;
    const string countSql = "select count(*) from access_record";
	DBManage::getInstance()->getCountOfTableBySQL(countSql, sum);
	LOGD("sum==%d", sum);
    return sum;
}

int Backstage::getAccessRecordNotUpload()//获取未上传通行记录
{
	return DBManage::getInstance()->getAccessRecordsNumByUploadSta(dbspace::enRodUpNotYet);
}

int Backstage::getVolume()//获取音量大小
{
	assert(nullptr != m_paramMng);
    return m_paramMng->getVolume();
}

int Backstage::setVolume(int vol)//设置音量大小
{
	assert(nullptr != m_paramMng);
    m_paramMng->setVolume(vol);

    int res = blueToothMng::getInstance().setVolume(vol);
    if (res != 0)
    {
        LOGE("bluetooth fail!");
    }

    return 0;
}

int Backstage::getLcdBrightness()//获取屏幕亮度
{
	assert(nullptr != m_paramMng);
    return m_paramMng->getLcdBrightness();
}

int Backstage::setLcdBrightness(int brightness)//设置屏幕亮度
{
	assert(nullptr != m_paramMng);
    m_paramMng->setLcdBrightness(brightness);
    return 0;
}

bool Backstage::getFillLightSw()//获取智能补光开关
{
	return 0;
}

int Backstage::setFillLightSw(bool isOpen)//获取智能补光开关
{
	return 0;
}

int Backstage::getStandbyTime()//获取待机时间
{
	assert(nullptr != m_paramMng);
    return m_paramMng->getStandbyTime();
}

int Backstage::setStandbyTime(int time)//设置待机时间
{
	assert(nullptr != m_paramMng);
	const bool isMeetingMode = m_paramMng->getMeetingMode() >= 0;
    const bool isDndMode = m_paramMng->getDndMode() >= 0;
    if (isMeetingMode) { // 会议模式
        m_paramMng->setMeetingScreensaverTimeBackup(time);
    } else if (isDndMode) {
        m_paramMng->setDndModeStandbyTime(time);
    } else {
        m_paramMng->setStandbyTime(time);
    }
    return 0;
}

int Backstage::getCloseScreenTime()//获取关屏等待时间
{
	assert(nullptr != m_paramMng);
    return m_paramMng->getCloseScreenTime();
}

int Backstage::setCloseScreenTime(int time)//获取关屏等待时间
{
	assert(nullptr != m_paramMng);
    m_paramMng->setCloseScreenTime(time);
    return 0;
}

int Backstage::getLanguage()//获取语言
{
	assert(nullptr != m_paramMng);
    return m_paramMng->getLanguage();
}

int Backstage::setLanguage(int lang)//设置语言
{
	assert(nullptr != m_paramMng);
    m_paramMng->setLanguage(lang);
    return 0;
}

int Backstage::getIP(char *ip, int len, int& type)//获取IP
{
    std::string maskString;
	std::string ipString;
    std::string ifName;
	
	if(utils::checkNetRun(std::string("eth0")))
    {
        ifName = "eth0";
        type = 0;
    }
    else if(utils::checkNetRun(std::string("wlan0")))
    {
        ifName = "wlan0";
        type = 1;
    }
    else if(utils::checkNetRun(std::string("wwan0")))
    {
        ifName = "wwan0";
        type = 2;
    }
	else if(utils::checkNetRun(std::string("ppp0")))
	{
		ifName = "ppp0";
		type = -1;

		static int lastType = 6; //满格信号
		std::string text;
		do{
			if(0 != utils::read_file("/tmp/.4G_signal_intensity", text)){break;}
			if(text.find("+CSQ:") == std::string::npos){break;}
			size_t end = text.find_last_of(",");
			if(end == std::string::npos){break;}
			const std::string sigStr = text.substr(6, end - 6); //+CSQ: 24,99
			int nSig = -1;
			try{nSig = std::stoi(sigStr);}catch(...){break;}
			if(nSig >= 5 && nSig <= 6){type = 2;}			//1格
			else if(nSig >= 7 && nSig <= 9){type = 3;}		//2格
			else if(nSig >= 10 && nSig <= 11){type = 4;}	//3格
			else if(nSig >= 12 && nSig <= 14){type = 5;}	//4格
			else if(nSig >= 15 && nSig <= 31){type = 6;}	//5格
			else{type = 7;}									//无信号
			lastType = type;
		}while(0);
		if(type < 0){LOGE("sig text:%s", text.c_str());type = lastType;}
	}
    else{
        type = -1;
    }
    int iRet = 0;
    if(type >= 0){
    	iRet = utils::getIpAndMask(ifName, ipString, maskString);
    	snprintf(ip, len, "%s", ipString.c_str());
    	//LOGD("local ip==%s", ip);
    }
    //LOGI("getIP type:%d", type);
	return iRet;
}

int Backstage::setIP(char *ip)//设置IP
{
	return 0;
}

enIpMethod Backstage::getIpMethod()//获取IP方法
{
	return (enIpMethod)0;
}

int Backstage::setIpMethod(enIpMethod ipMethod)//设置IP方法
{
	return 0;//MVC_Ctrler::getInstance()->setIpMethod(ipMethod);
}

int Backstage::getSubnetMask(char *mask, int len)//获取子网掩码
{
	return 0;//MVC_Ctrler::getInstance()->getSubnetMask(mask, len);
}

int Backstage::setSubnetMask(char *mask)//设置子网掩码
{
	return 0;//MVC_Ctrler::getInstance()->setSubnetMask(mask);
}

int Backstage::getGateway(char *gateway, int len)//获取默认网关
{
	return 0;//MVC_Ctrler::getInstance()->getGateway(gateway, len);
}

int Backstage::setGateway(char *gateway)//设置默认网关
{
	return 0;//MVC_Ctrler::getInstance()->setGateway(gateway);
}

int Backstage::getDNS(char *dns, int len)//获取DNS
{
	return 0;//MVC_Ctrler::getInstance()->getDNS(dns, len);
}

int Backstage::setDNS(char *dns)//设置DNS
{
	return 0;//MVC_Ctrler::getInstance()->setDNS(dns);
}

int Backstage::getEthMac(char *mac, int len)//获取mac
{
    int ret = -1;
    const std::string macString = utils::getNetMac("eth0");
	LOGD("macString=%s", macString.c_str());
    if(macString.length() < (unsigned)len){
        strcpy(mac, macString.c_str());
        ret = 0;
    }
	return ret;
}

int Backstage::getWifiMac(char *mac, int len)//获取wifi mac
{
	return 0;
} 

int Backstage::getServerAddr(char *addr, int len)//获取服务器ip
{
	assert(nullptr != m_paramMng);
    int ret = -1;
    std::string serverinfo = m_paramMng->getServerIP();
    if(serverinfo.length() < (unsigned)len){
        strcpy(addr, serverinfo.c_str());
        ret = 0;
    }
	return ret;
}

int Backstage::setServerAddr(char *addr, bool byQrcode)//设置服务器ip
{
	assert(nullptr != m_paramMng);
	m_paramMng->setLastModifyServer(1);
    m_paramMng->setServerIP(addr);
    if (!byQrcode)
    {
        FileUtils::removeFile(QRCODE_CONFIG_FILE);//用户修改平台IP后就删除保存的二维码信息文件,modify by wwb-20220104
    }
    //RWProtocol::getInstance()->modifySrvAddrInfo(1);
	return 0;
}

int Backstage::testServerIP(char *addr, float &time)//测试服务器ip
{
	return 0;
}

int Backstage::getIotServerIP(char *ip, int len)//获取服务器ip
{
	return 0;//MVC_Ctrler::getInstance()->getIotServerIP(ip, len);
}

int Backstage::setIotServerIP(char *ip)//设置服务器ip
{
	return 0;//MVC_Ctrler::getInstance()->setIotServerIP(ip);
}

int Backstage::getIotPort()//获取端口号, 成功返回端口号，失败返回-1
{
	return 0;//MVC_Ctrler::getInstance()->getIotPort();
}

int Backstage::setIotPort(int port)//设置端口号
{
	return 0;//MVC_Ctrler::getInstance()->setIotPort(port);
}

bool Backstage::getIpShowSw()
{
    assert(nullptr != m_paramMng);
	return m_paramMng->getIpShowSw();
}

int Backstage::setIpShowSw(bool sw)
{
    assert(nullptr != m_paramMng);
    m_paramMng->setIpShowSw(sw);
    return 0;
}

int Backstage::getBtSwitch(bool &isOpen)
{
    assert(nullptr != m_paramMng);
    isOpen = m_paramMng->getBluetoothSw();
    return 0;
}

int Backstage::getBtName(string &devName)
{
    assert(nullptr != m_paramMng);
    devName = m_paramMng->getDevName();
    return 0;
}

int Backstage::getBtPairedDev(list<BluetoothDev_t> &devList)
{
    std::list<blueToothMng::pkgOfOneBT> pairedList;
    blueToothMng::getInstance().getPairedDevs(pairedList);
    devList.clear();
    for(const auto &iter : pairedList)
    {
        BlueToothDevStat_e state = BlueToothDevStat_paired;
        //连接状态:0搜索到, 1配对中, 2已配对, 3连接中, 4已连接
//        if (std::get<0>(iter) == 3)
//        {
//            state = BlueToothDevStat_connecting;
//        }
        //else 
        if (std::get<0>(iter) == 4)
        {
            state = BlueToothDevStat_connected;
        }
        LOGD("name:%s, state:%d", std::get<3>(iter).c_str(), std::get<0>(iter));
        devList.emplace_back(BluetoothDev_t(std::get<2>(iter), std::get<3>(iter), state));
    }

    return 0;
}

int Backstage::getBtAvailDev(list<BluetoothDev_t> &devList)
{
    std::list<blueToothMng::pkgOfOneBT> scanedList;
    blueToothMng::getInstance().getScanedDevs(scanedList);

    devList.clear();
    for(const auto &iter : scanedList)
    {
        //LOGD("name:%s, state:%d", std::get<1>(iter).c_str(), std::get<0>(iter));
        devList.emplace_back(BluetoothDev_t(std::get<2>(iter), std::get<3>(iter), BlueToothDevStat_idle));
    }
    
    return 0;
}

int Backstage::getBtAllInfo(BluetoothStat_t &bluetoothStat)
{
    assert(nullptr != m_paramMng);
    
    bluetoothStat.clear();
    bluetoothStat.devName = m_paramMng->getDevName();
    bluetoothStat.isEnable = m_paramMng->getBluetoothSw();
    getBtPairedDev(bluetoothStat.pairedDev);
    getBtAvailDev(bluetoothStat.availableDev);

    return 0;
}

//blueToothMng模块里有一个线程循环再搜索，所以没有提供主动搜索接口，只提供了获取搜索列表的接口，这里调用getBtAvailDev即可
int Backstage::btScan(list<BluetoothDev_t> &devList)
{
#if 0
    std::list<blueToothMng::pkgOfOneBT> searchedList;
    blueToothMng::getInstance().search(searchedList);
    devList.clear();
    
    for(const auto &iter : searchedList)
    {
        LOGD("name:%s, state:%d", std::get<1>(iter).c_str(), std::get<0>(iter));
        devList.emplace_back(BluetoothDev_t(std::get<2>(iter), std::get<1>(iter), BlueToothDevStat_idle));
    }
#endif
    return 0;
}

int Backstage::btSetSwitch(bool isOpen)
{
    assert(nullptr != m_paramMng);
    
    m_paramMng->setBluetoothSw(isOpen);	
    if (isOpen)
    {
        blueToothMng::getInstance().open();
    }
    else
    {
    	m_paramMng->setBleLockSw(false);
        blueToothMng::getInstance().close();
    }

    return 0;
}

int Backstage::btSetName(const string &devName)
{
    if (blueToothMng::getInstance().modifySysName(devName) == 0)
    {
        m_paramMng->setDevName(devName);
        return 0;
    }
    return -1;
}

int Backstage::btPaire(const string &devId)
{
    int res = blueToothMng::getInstance().pair(devId);
    if (res != 0)
    {
        LOGE("bluetooth pairing fail! res:%d", res);
    }
    return res;
}

int Backstage::btDisPaire(const string &devId)
{
    int res = blueToothMng::getInstance().disPair(devId);
    if (res != 0)
    {
        LOGE("bluetooth disPairing fail! res:%d", res);
    }

    return res;
}

int Backstage::btConnect(const string &devId)
{
    int res = blueToothMng::getInstance().connect(devId);
    if (res != 0)
    {
        LOGE("bluetooth connect fail!");
    }

    return res;
}

int Backstage::btDisConnect(const string &devId)
{
    int res = blueToothMng::getInstance().disConnect(devId);
    if (res != 0)
    {
        LOGE("bluetooth disConnect fail! res:%d", res);
    }

    return res;
}

int Backstage::btRenameDev(const string &devId, const string &devName)
{
    return blueToothMng::getInstance().modifyDevName(devId, devName);
}

#if 1   //for test
bool g_isBluetoothEnable = false;
#endif
bool Backstage::getParamBluetoothEnable()
{
    return g_isBluetoothEnable;
}

int Backstage::setParamBluetoothEnable(bool sw)
{
    g_isBluetoothEnable = sw;
    return 0;
}

#if 1   //for test
string  g_bluetoothName = "rw-bluetooth";
#endif
string Backstage::getParamBluetoothName()
{
    return g_bluetoothName;
}

int Backstage::setParamBluetoothName(string name)
{
    g_bluetoothName = name;
    return 0;
}

int Backstage::getUnlockTime()//获取开锁时间
{
	assert(nullptr != m_paramMng);    
    return m_paramMng->getUnlockTime();
}

int Backstage::setUnlockTime(int time)//设置开锁时间
{
	assert(nullptr != m_paramMng);
    m_paramMng->setUnlockTime(time);
    return 0;
}

int Backstage::getUnlockDelay()//获取开锁延时
{
	assert(nullptr != m_paramMng);
    return m_paramMng->getUnlockDelay();
}

int Backstage::setUnlockDelay(int time)//设置开锁延时
{
	assert(nullptr != m_paramMng);
    m_paramMng->setUnlockDelay(time);
    return 0;
}

enUnlockSignal Backstage::getUnlockSig()//获取开锁信号
{
	assert(nullptr != m_paramMng);
	if(m_paramMng->getUnlockSig() >= UnlockSigButt){
	    return UnlockSigRelay;
	}
    return (enUnlockSignal)m_paramMng->getUnlockSig();
}

int Backstage::setUnlockSig(enUnlockSignal value)//设置开锁信号
{
	assert(nullptr != m_paramMng);
    m_paramMng->setUnlockSig(value);
    return 0;
}

enAssist Backstage::getAssistIn()//获取辅助输入
{
	return (enAssist)0;//MVC_Ctrler::getInstance()->getAssistIn();
}

int Backstage::setAssistIn(enAssist assist)//设置辅助输入	
{
	return 0;//MVC_Ctrler::getInstance()->setAssistIn(assist);
}

enAssist Backstage::getAssistOut()//获取辅助输出
{
	return (enAssist)0;//MVC_Ctrler::getInstance()->getAssistOut();
}

int Backstage::setAssistOut(enAssist assist)//设置辅助输出
{
	return 0;//MVC_Ctrler::getInstance()->setAssistOut(assist);
}

enWiegand Backstage::getWiegandIn()//获取韦根输入
{
	return (enWiegand)0;//MVC_Ctrler::getInstance()->getWiegandIn();
}

int Backstage::setWiegandIn(enWiegand wiegand)//设置韦根输入
{
	return 0;//MVC_Ctrler::getInstance()->setWiegandIn(wiegand);
}

enWiegand Backstage::getWiegandOut()//获取韦根输出
{
	return (enWiegand)0;
}

int Backstage::setWiegandOut(enWiegand wiegand)//设置韦根输出
{
	return 0;
}

enBaudRate Backstage::getBaudRate()//获取波特率
{
	return (enBaudRate)0;
}

int Backstage::setBaudRate(enBaudRate baudRate)//设置波特率
{
	return 0;
}

int Backstage::getWarningSig()//获取报警信号v
{
	assert(nullptr != m_paramMng);
    return m_paramMng->getWarningSig();
}

int Backstage::setWarningSig(int signal)//设置报警信号
{
	assert(nullptr != m_paramMng);
    m_paramMng->setWarningSig(signal);
    return 0;
}

enLogo Backstage::getLogo()//获取logo
{
    assert(nullptr != m_paramMng);
	return (enLogo)m_paramMng->getLogo();
}

int Backstage::setLogo(enLogo logo)//设置logo
{
	assert(nullptr != m_paramMng);
    m_paramMng->setLogo((int)logo);
    return 0;
}

int Backstage::getCustomLogo(char *logo, int len)//获取自定义logo
{
    assert(nullptr != m_paramMng);
    std::string customLogo = m_paramMng->getCustomLogo();
	snprintf(logo, len, "%s", customLogo.c_str());
	LOGD("customLogo: %s", customLogo.c_str());
	return 0;
}

enLogo Backstage::getLogoTime()//获取logo+time
{
	return (enLogo)0;//MVC_Ctrler::getInstance()->getLogoTime();

}
int Backstage::setLogoTime(enLogo logo)//设置logo+time
{
	return 0;//MVC_Ctrler::getInstance()->setLogoTime(logo);
}

enLogo Backstage::getBackground()//获取背景图
{
	return (enLogo)0;//MVC_Ctrler::getInstance()->getBackground();
}

int Backstage::setBackground(enLogo logo)//设置背景图
{
	return 0;//MVC_Ctrler::getInstance()->setBackground(logo);
}

enRecogResult Backstage::getSuccessResult(char *data, int len)//获取成功结果
{
	int nRet = 0;//MVC_Ctrler::getInstance()->getSuccessResult(data, len);
	nRet = (nRet < 0) ? RecogResultButt : nRet;
	return (enRecogResult)nRet;
}

int Backstage::setSuccessResult(enRecogResult result, char *data)//设置成功结果
{
	return 0;//MVC_Ctrler::getInstance()->setSuccessResult(result, data);
}

enRecogResult Backstage::getFailResult(char *data, int len)//获取失败结果
{
	int nRet = 0;//MVC_Ctrler::getInstance()->getFailResult(data, len);
	nRet = (nRet < 0) ? RecogResultButt : nRet;
	return (enRecogResult)nRet;
}

int Backstage::setFailResult(enRecogResult result, char *data)//设置失败结果
{
	return 0;//MVC_Ctrler::getInstance()->setFailResult(result, data);
}

bool Backstage::getPlayAudioSw()//获取语音播报开关
{
	return 0;//MVC_Ctrler::getInstance()->getPlayAudioSw();
}

int Backstage::setPlayAudioSw(bool isOpen)//设置语音播报开关
{
	return 0;//MVC_Ctrler::getInstance()->setPlayAudioSw(isOpen);
}

bool Backstage::getIdentificationSw()//获取身份核验开关
{
    assert(nullptr != m_paramMng);
    return m_paramMng->getRecoSw();    
}

int Backstage::setIdentificationSw(bool sw)//设置身份核验开关
{
    assert(nullptr != m_paramMng);
    m_paramMng->setRecoSw(sw);
    return 0;
}

enSimilarityTh Backstage::getSimilarityTh()//获取相似度阈值
{
	assert(nullptr != m_paramMng);
    return (enSimilarityTh)m_paramMng->getSimilarityType();
}

int Backstage::setSimilarityTh(enSimilarityTh th)//设置相似度阈值
{
	assert(nullptr != m_paramMng);
    m_paramMng->setSimilarityType(th);
    return 0;
}

int Backstage::setCustomSimilarity(int sim)	//设置自定义识别相似度
{
	assert(nullptr != m_paramMng);
    m_paramMng->setSimilarityTh(sim);
    return 0;
}

int Backstage::getCustomSimilarity() //获取自定义识别相似度
{
	assert(nullptr != m_paramMng);
    return m_paramMng->getSimilarityTh();
}

bool Backstage::getLivingBodySw()//获取活体开关
{
	assert(nullptr != m_paramMng);
    return m_paramMng->getInfraAntiAttack();
}

int Backstage::setLivingBodySw(bool isOpen)//设置活体开关	
{
	assert(nullptr != m_paramMng);
    m_paramMng->setInfraAntiAttack(isOpen);
    return 0;
}

enLivingBodyTh Backstage::getLivingBodyTh()//获取活体检测阈值
{
	return (enLivingBodyTh)0;
}

int Backstage::setLivingBodyTh(enLivingBodyTh th)//设置活体检测阈值	
{
	return 0;
}

bool Backstage::getLivingBodyFailSw()//获取活体失败图片留存开关
{
	return 0;
}

int Backstage::setLivingBodyFailSw(bool isOpen)//设置失败图片留存开关	
{
	return 0;
}

int Backstage::getVerifyInterval()//获取验证间隔时间
{
	return 0;
}

int Backstage::setVerifyInterval(int time)//设置验证间隔时间	
{
	return 0;
}

enRecogDistance Backstage::getRecogDistance()//获取识别距离
{
	return (enRecogDistance)0;//MVC_Ctrler::getInstance()->getRecogDistance();
}

int Backstage::setRecogDistance(enRecogDistance distance)//设置识别距离
{
	return 0;//MVC_Ctrler::getInstance()->setRecogDistance(distance);
}

enRecogAngle Backstage::getRecogAngle()//获取识别角度
{
	return (enRecogAngle)0;//MVC_Ctrler::getInstance()->getRecogAngle();
}

int Backstage::setRecogAngle(enRecogAngle angle)//设置识别角度
{
	return 0;//MVC_Ctrler::getInstance()->setRecogAngle(angle);
}

int Backstage::getMaxTraceNum()//获取人脸最大跟踪数
{
	return 0;//MVC_Ctrler::getInstance()->getMaxTraceNum();
}

int Backstage::setMaxTraceNum(int num)//设置人脸最大跟踪数
{
	return 0;//MVC_Ctrler::getInstance()->setMaxTraceNum(num);
}

enFaceQuality Backstage::getFaceQuality()//获取人脸质量阈值
{
	return (enFaceQuality)0;//MVC_Ctrler::getInstance()->getFaceQuality();
}

int Backstage::setFaceQuality(enFaceQuality quality)//设置人脸质量阈值
{
    return 0;//MVC_Ctrler::getInstance()->setFaceQuality(quality);
}

bool Backstage::getDynamicFeatureSw()
{
    return m_paramMng->getDynamicFeatureSw();
}

int Backstage::setDynamicFeatureSw(bool sw)
{
    LOGD("setDynamicFeatureSw:%d", sw);
    m_paramMng->setDynamicFeatureSw(sw);
    return 0;
}

bool Backstage::getNtpServerSw()//获取NTP服务开关
{
	assert(nullptr != m_paramMng);
    return m_paramMng->getNtpServerSw();
}

int Backstage::setNtpServerSw(bool isOpen)//设置NTP服务开关
{
	assert(nullptr != m_paramMng);
    m_paramMng->setNtpServerSw(isOpen);
    return 0;
}

int Backstage::getNtpServerAddr(char *addr, int len)//获取NTP服务地址
{
    assert(nullptr != m_paramMng);
    int ret = -1;
    std::string serverinfo = m_paramMng->getNtpServerAddr();
    if(serverinfo.length() < (unsigned)len){
        strcpy(addr, serverinfo.c_str());
        ret = 0;
    }
	return ret;
}

int Backstage::setNtpServerAddr(char *addr)//设置NTP服务地址
{
    assert(nullptr != m_paramMng);
    m_paramMng->setNtpServerAddr(addr);
	return 0;
}

int Backstage::testNtpServer(char *addr, float &time)//测试NTP服务
{
	return 0;//MVC_Ctrler::getInstance()->testNtpServer(addr, time);
}

int Backstage::getNtpServerPort()//获取NTP端口，成功返回端口号，失败返回-1
{
	return m_paramMng->getNtpServerPort();
}

int Backstage::setNtpServerPort(int port)//设置NTP服务端口
{
	m_paramMng->setNtpServerPort(port);
    return 0;
}
int Backstage::getNtpCheckInterval()
{
    return m_paramMng->getNtpSyncInterval();
}

int Backstage::setNtpCheckInterval(int interval)
{
    m_paramMng->setNtpSyncInterval(interval);
    return 0;
}

int Backstage::getNtpTimeZone(char *timeZone, int len)
{
    assert(nullptr != m_paramMng);
    int ret = -1;
    std::string zone = m_paramMng->getZone();
    if(zone.length() < (unsigned)len){
        strcpy(timeZone, zone.c_str());
        ret = 0;
    }
	return ret;
}

int Backstage::setNtpTimeZone(char *timeZone)
{
    assert(nullptr != m_paramMng);
    m_paramMng->setZone(timeZone);
	return 0;
}

int Backstage::setVerifyFactorySettingPwd(char *pwd)//设置工程密码
{
	return 0; 
}

int Backstage::testHardware()//硬件检测
{
	return 0; 
}

int Backstage::cleanData()//清除数据
{
	int ret = clearData();
	//清空数据会隐藏密码输入显示，需检查是否有本地设置密码
	if(m_paramMng->getLocalDevPwd().length()){
		View::getInstance()->setPwdButton(true);
	}
	return ret;
}

int Backstage::devReboot()//重启设备
{
    m_paramMng->setLcdBrightness(0, true);
    sleep(1);
    //deviceReboot();
    DEV_REBOOT;
    //system("reboot -f");
	return 0;
}

int Backstage::startCapture()
{
	int nRet = 0; 
    return nRet;
}

int Backstage::deletePerson(long long personID)
{
	int nRet = 0; 

	return nRet;
}

int Backstage::queryPersonList(long long* pPersonIDBuff, int nBuffCount, long long startID, int& nRealPerson)
{
	int nRet = 0; 

	return nRet;
}

unsigned Backstage::queryPerson(const char* searchText)
{
    LOGD("searchText:%s", searchText);
    const std::string countSql = std::string("select count(*) from person_info where 1=1 and name like '%") + searchText + "%'";    
    int sum = 0;
    DBManage::getInstance()->getCountOfTableBySQL(countSql, sum);
    LOGD("sum:%d", sum);
    return (unsigned)sum;
}

unsigned Backstage::queryPerson(const char* searchText, int pageIndex, stQueryPersonInfo personRet[], int personRetSize)
{
	unsigned nRet = 0;
    const std::string persql = std::string("select * from person_info where 1=1 and name like '%") + searchText
                                            + "%' order by reg_time desc limit " + utils::to_string(personRetSize)
                                            + " offset " + utils::to_string(pageIndex * personRetSize);
        
    std::list<dbspace::rwPersonInfo> personInfoList;
    DBManage::getInstance()->queryPersonListBySQL(persql, personInfoList);
    int i = 0;
    for (auto &personInfo : personInfoList)
    {
        if(i < personRetSize){
#if 0
            snprintf(personRet[i].name, sizeof(personRet[i].name), personInfo.name.c_str());
            snprintf(personRet[i].regTime, sizeof(personRet[i].regTime), utils::format_time(personInfo.regTime).c_str());       
            snprintf(personRet[i].expTime, sizeof(personRet[i].expTime), personInfo.expTime.c_str());
#endif
            personRet[i].name = personInfo.name;
            personRet[i].regTime = utils::format_time(personInfo.regTime).c_str();
            personRet[i].expTime = personInfo.expTime;

            personRet[i].personId = personInfo.personId;
            personRet[i].idNum = personInfo.idNum;
            personRet[i].jobNum = personInfo.jobNum;
            personRet[i].phoneNum = personInfo.phoneNum;
            personRet[i].icNum = personInfo.cpuCardContent.empty() ? personInfo.icNum : personInfo.cpuCardContent;
            personRet[i].personType = personInfo.personType;
			string imgPath = utils::makeRegisterImgPath(personInfo.personId, personInfo.source, 1);
            if(0 != access(imgPath.c_str(), F_OK))//如果不存在就去数据库中查找图片路径
            {
                LOGE("register img %s not exsit .", imgPath.c_str());
                dbspace::rwFeatInfo faceInfo;
                if (0 == DBManage::getInstance()->queryFaceByPersonId(personInfo.personId, faceInfo))
        		{
        		    imgPath = faceInfo.image;
        		}
            }
#if 0
            snprintf(personRet[i].imgPath, sizeof(personRet[i].imgPath), imgPath.c_str());
#endif
            personRet[i].imgPath = imgPath;
            i++;
            nRet = (unsigned)i;
        }
    }
	return nRet;
}

unsigned Backstage::queryAccessRecord(const char* name, const char* time)
{
    unsigned nRet = 0;
    std::string countSql("select count(*) from access_record where 1=1");
    if(name){
        countSql += " and name like '%";
        countSql += name;
        countSql += "%'";
    }
    if(time){
        std::string timeBegin(time);
        timeBegin += " 00:00:00";
        std::string timeEnd(time);
        timeEnd += " 23:59:59";
        
        long long beginTime = utils::format_time(timeBegin.c_str());
        long long endTime = utils::format_time(timeEnd.c_str());
		LOGD("beginTime:%lld, endTime:%lld", beginTime, endTime);
        countSql += " and access_time<=";
        countSql += utils::to_string(endTime*1000);
        countSql += " and access_time>=";
        countSql += utils::to_string(beginTime*1000);//通行记录里面保存的是ms
    }   
    int sum = 0;
    DBManage::getInstance()->getCountOfTableBySQL(countSql, sum);
    LOGD("sum:%d", sum);
    nRet = (unsigned)sum;
    return nRet;
}

unsigned Backstage::queryAccessRecord(const char* name, const char* time, int pageIndex, stQueryAccRedInfo recordRet[], int recordRetSize)
{
    unsigned nRet = 0;
    std::string dataSql("select * from access_record where 1=1");
    if(name){
        dataSql += " and name like '%";
        dataSql += name;
        dataSql += "%'";
    }
    //时间格式必须为2020-04-05 00:00:00
    if(time){
        std::string timeBegin(time);
        timeBegin += " 00:00:00";
        std::string timeEnd(time);
        timeEnd += " 23:59:59";
        
        long long beginTime = utils::format_time(timeBegin.c_str());
        long long endTime = utils::format_time(timeEnd.c_str());
		LOGD("beginTime:%lld, endTime:%lld", beginTime, endTime);
        dataSql += " and access_time<=";
        dataSql += utils::to_string(endTime*1000);
        dataSql += " and access_time>=";
        dataSql += utils::to_string(beginTime*1000);//通行记录里面保存的是ms
    }  
    dataSql += " order by access_time desc";
    dataSql += " limit ";
    dataSql += utils::to_string(recordRetSize);
    dataSql += " offset ";
    dataSql += utils::to_string(recordRetSize * pageIndex);
    
	std::list<dbspace::rwAccessRecord> accessInfoList;
	DBManage::getInstance()->queryAccessRecordListBySQL(dataSql, accessInfoList);	
	int i = 0;    
	for (std::list<dbspace::rwAccessRecord>::iterator itr = accessInfoList.begin(); itr != accessInfoList.end(); itr++)
	{
	    if(i < recordRetSize){
            snprintf(recordRet[i].name, sizeof(recordRet[i].name), (*itr).name.length() > 0 ? (*itr).name.c_str() : (m_paramMng->getLanguage() < 2 ? "陌生人" : "stranger"));
    		snprintf(recordRet[i].accessTime, sizeof(recordRet[i].accessTime), utils::format_time((*itr).accessTime/1000).c_str());
            snprintf(recordRet[i].imgPath, sizeof(recordRet[i].imgPath), (*itr).imgFile.c_str());
            recordRet[i].allowPass = (bool)((*itr).gateStatus);
    		i++;
            nRet = (unsigned)i;
       }
	}
    return nRet;
}

int Backstage::clearPeople()
{
	int nRet = 0; 

	return nRet;
}

int Backstage::getPersonListState(int &sum, unsigned long long &maxPersonID)
{
	int nRet = 0; 

	return nRet;
}

int Backstage::wakeUpFromScreenSaverOrScreenOff()
{ 
    return 0;
}

int Backstage::delPerson(long long personId)
{
    return Singleton<PersonManage>::GetInstance()->deletePerson(personId);
}

int Backstage::modifyPerson(stQueryPersonInfo &personInfo)
{
    dbspace::rwPersonInfo dbPersonInfo;
    dbPersonInfo.source = 1;
    dbPersonInfo.personId = personInfo.personId;
    dbPersonInfo.name = personInfo.name;
    dbPersonInfo.idNum = personInfo.idNum;
    dbPersonInfo.jobNum = personInfo.jobNum;
    dbPersonInfo.phoneNum = personInfo.phoneNum;
    dbPersonInfo.expTime = personInfo.expTime;
    dbPersonInfo.icNum = personInfo.icNum;
    int ret = Singleton<PersonManage>::GetInstance()->modifyPerson(dbPersonInfo);

    return ret;
}

int Backstage::addPerson(stQueryPersonInfo &personInfo)
{
    int count = 0;
    DBManage::getInstance()->getPersonAllCount(count);
    if (count >= REG_PERSON_NUM_MAX)
    {
        LOGE("The maximum number(%d) of people!", count);
        return -99;
    }

    dbspace::rwPersonInfo dbPersonInfo;
    dbPersonInfo.source = 1;
    //dbPersonInfo.personId = personInfo.personId;
    dbPersonInfo.name = personInfo.name;
    dbPersonInfo.idNum = personInfo.idNum;
    dbPersonInfo.jobNum = personInfo.jobNum;
    dbPersonInfo.phoneNum = personInfo.phoneNum;
    dbPersonInfo.expTime = personInfo.expTime;
    dbPersonInfo.icNum = personInfo.icNum;

    struct stat st;
    if ((stat(personInfo.imgPath.c_str(), &st)<0) || (!S_ISREG(st.st_mode))){
        LOGE("file:%s is Non-existent!", personInfo.imgPath.c_str());
        return -1;
    }
    int len = st.st_size;
    unsigned char *pImg = (unsigned char *)malloc(len);
    if(pImg == nullptr){
        LOGE("malloc size(%d) FAIL!", len);
        return -1;
    }
    ON_SCOPE_EXIT([&]{free(pImg);pImg = NULL;});

    int faceImgLen = utils::read_file(personInfo.imgPath.c_str(), pImg, len);
    if (faceImgLen <= 0)
    {
        LOGE("file: %s size is 0!", personInfo.imgPath.c_str());
        return -1;
    }

    dbspace::rwFaceImg faceImg;
    faceImg.imgType = dbspace::jpg;
    faceImg.imgData = pImg;
    faceImg.imgLen = len;
	faceImg.faceX = 0;
    faceImg.faceY = 0;
    faceImg.faceW = 0;
    faceImg.faceH = 0;
    int ret = Singleton<PersonManage>::GetInstance()->registerPerson(dbPersonInfo, faceImg);

    return ret;
#if 0
    if (ret != 0)
    {
        if (ret == -6)
        {
            code = CODE_CARD_ALREDDY_EXISTS;
        }
        else if (ret == -5)
        {
            code = CODE_EXTRACT_FEATURE;
        }
        else if (ret == -7)
        {
            code = CODE_ID_ALREDDY_EXISTS;
        }
        else
        {
            code = CODE_REGISTER_PERSON_FAIL;
        }
        ret = -1;
    }
#endif
}

int Backstage::snapFace(std::string &feature, std::string &savePath)
{
    GPeInput* pPeInput = (GPeInput*)m_objs->findObject("peInput");
    //GCamera* pCamera = (GCamera*)m_objs->findObject("normal");
    if(pPeInput){
        std::shared_ptr<GOSPImageFrame> spOriImage;
        pPeInput->getSpImageFrame(spOriImage);
        if (spOriImage.get() == nullptr)
        {
            LOGE("spOriImage is nullptr");
            return -1;
        }
#if 0
        //fds::RwImage *pflipImg = spOriImage->getFlipImage();
        int width = spOriImage->image.ext.width;
        int height = spOriImage->image.ext.height;
        uint8_t* nv21 = (uint8_t*)spOriImage->image.data;
        uint8_t* size = (uint8_t*)spOriImage->image.ext.size;
        dbspace::rwFaceImg faceImg = {0, 0, 0, 0, width, height, width, dbspace::nv21, size, nv21, savePath};
#endif
        fds::RwImage *rwImage = spOriImage->getJpegImage();
#if 0
        #ifdef __RV1109__
        fds::RwImage* rwImage = spOriImage->getFlipJpegImage();
        #else
        fds::RwImage* rwImage =  spOriImage->getJpegImage();
        #endif
#endif
        if(rwImage == nullptr)
        {
            LOGE("getJpegImage is nullptr");
            return -1;
        }
        dbspace::rwFaceImg faceImg = {0, 0, 0, 0, rwImage->ext.width, rwImage->ext.height, rwImage->ext.width,
                                      dbspace::jpg, rwImage->ext.size, (uint8_t*)rwImage->data, savePath};


        std::vector<unsigned char> tmp(FEATURE_SIZE);
        RwFeature feat = {0};
        feat.feature_size = FEATURE_SIZE;
        feat.feature = tmp.data();
        int ret = faceImg.getFeature(feat);
        if (ret != 0)
        {
            LOGE("getFeature fail-->ret:%d", ret);
            return -5;
        }

        if (faceImg.imgJpgData == nullptr)
        {
            LOGE("jpg is null!");
            return -1;
        }

        feature.assign((char*)feat.feature, feat.feature_size);
        LOGD("jpg name:%s, imgdata:%p, imgLen:%d", faceImg.imgName.c_str(), faceImg.imgJpgData.get(), faceImg.imgLen);
        ret = utils::write_file(faceImg.imgName, (char *)(faceImg.imgJpgData.get()), faceImg.imgLen);

        return ret;
    }

    return -1;
}

bool Backstage::getMaskCheckSwitch()
{
    assert(nullptr != m_paramMng);
    return m_paramMng->getMaskSw();
}

int Backstage::setMaskCheckSwitch(const bool sw)
{
	assert(nullptr != m_paramMng);
    m_paramMng->setMaskSw(sw);
    return 0;
}


bool Backstage::getNoMaskNoPassSwitch()
{
	assert(nullptr != m_paramMng);
    return m_paramMng->getNoMaskPassSw();
}

int Backstage::setNoMaskNoPassSwitch(const bool sw)
{
	assert(nullptr != m_paramMng);
    m_paramMng->setNoMaskPassSw(sw);
    return 0;
}

bool Backstage::getTemperatureCheckSwitch()
{	
	assert(nullptr != m_paramMng);
    return m_paramMng->getTempSw();
}

int Backstage::setTemperatureCheckSwitch(const bool sw)
{
	assert(nullptr != m_paramMng);
    m_paramMng->setTempSw(sw);
    return 0;
}

bool Backstage::getNoTemperatureNoPassSwitch()
{
	return 0;//MVC_Ctrler::getInstance()->getTempAnomalyNoEntrySwitch();
}

int Backstage::setNoTemperatureNoPassSwitch(const bool sw)
{
	return 0;//MVC_Ctrler::getInstance()->setTempAnomalyNoEntrySwitch(sw);
}

	
float Backstage::getLowTemperature()
{
	return 0;//MVC_Ctrler::getInstance()->getLowTemperature();
}

int Backstage::setLowTemperature(const float temp)
{
	return 0;//MVC_Ctrler::getInstance()->setLowTemperature(temp);
}

float Backstage::getHighTemperature()
{
	return 0;//MVC_Ctrler::getInstance()->getHighTemperature();
}

int Backstage::setHighTemperature(const float temp)
{
	return 0;//MVC_Ctrler::getInstance()->setHighTemperature(temp);
}

bool Backstage::getQRCodeSwitch()
{	
	return 0;//MVC_Ctrler::getInstance()->getQRCodeSwitch();
}

int Backstage::setQRCodeSwitch(const bool sw)
{
	return 0;
}

int Backstage::setDateTime(const char *dateTime)
{
    const std::string cmd = std::string("date -s \"") + dateTime + "\" && hwclock -w -u -f /dev/rtc0";
	LOGD("setDateTime cmd:%s", cmd.c_str());
	return utils::RW_System(cmd.c_str());
}

bool Backstage::getDataEncryptSw()
{
    assert(nullptr != m_paramMng);
    return m_paramMng->getEncryptSw();
}


int Backstage::setDataEncryptSw(bool sw)
{
    LOGD("setEncryptSw:%d", sw);
    m_paramMng->setEncryptSw(sw);
    return 0;
}

bool Backstage::getAutoRebootSw()
{
    assert(nullptr != m_paramMng);
	return m_paramMng->getAutoRebootSw();
}

int Backstage::setAutoRebootSw(bool sw)
{
    assert(nullptr != m_paramMng);
    m_paramMng->setAutoRebootSw(sw);
    updateRebootTime(sw, m_paramMng->getAutoRebootInterval(), m_paramMng->getAutoRebootTime().c_str());
    return 0;
}

int Backstage::getAutoRebootTime(char* time, int len)
{
    assert(nullptr != m_paramMng);
    int ret = -1;
    std::string rebootTime = m_paramMng->getAutoRebootTime();
    if(rebootTime.length() < (unsigned)len){
        strcpy(time, rebootTime.c_str());
        ret = 0;
    }
	return ret;
}

int Backstage::setAutoRebootTime(const char *time)
{
    assert(nullptr != m_paramMng);
    m_paramMng->setAutoRebootTime(time);
    updateRebootTime(m_paramMng->getAutoRebootSw(), m_paramMng->getAutoRebootInterval(), time);
	return 0;
}

int Backstage::getAutoRebootInterval()
{

    assert(nullptr != m_paramMng);
    return m_paramMng->getAutoRebootInterval();
}

int Backstage::setAutoRebootInterval(int interval)
{
	assert(nullptr != m_paramMng);
    m_paramMng->setAutoRebootInterval(interval);
    updateRebootTime(m_paramMng->getAutoRebootSw(), interval, m_paramMng->getAutoRebootTime().c_str());
    return 0;
}

int Backstage::ntpTimeCorrect()
{
    int ret = -1;
    do{
        bool ntpSw = getNtpServerSw();
        if(ntpSw){
            char ntpaddr[64] = {'\0'};
            if(0 != getNtpServerAddr(ntpaddr, sizeof(ntpaddr))){
                break;
            }
            char timeZone[64] = {'\0'};
            if(0 != getNtpTimeZone(timeZone, sizeof(timeZone))){
                break;
            }
            ret = ntpUpdater::getInstance().setParam(ntpSw, ntpaddr, getNtpCheckInterval(), timeZone);
            //ret = ntpTimeCorrection(ntpSw, ntpaddr, getNtpCheckInterval(), timeZone);
        }
        else{
            //ret = ntpTimeCorrection(false, "", 0, "");
            ret = ntpUpdater::getInstance().setParam(false, "", 0, "");
        }
    }while(0);
    return ret;
}

int Backstage::ntpTimeCorrectForDevTest(const std::string& ntpServerIp)
{
    int ret = 0;
	//工厂生产时Mes服务器开启NTP校时服务
    std::string cmd = utils::to_string(APP_BIN_PATH"ntpdate.sh ") + utils::to_string("/dev/rtc0 ") + ntpServerIp;
    LOGI("update ntp time for device test, cmd:%s", cmd.c_str());
    
    int nReturn = utils::RW_System(cmd.c_str());//return 1 is
    int err = WEXITSTATUS(nReturn);
    if (0 != err)
    {
        LOGE("exec [%s] fail,err=%d,nReturn=%d", cmd.c_str(), err, nReturn);
        ret = -1;
    }
    return ret;
}

int Backstage::getNetWireCfg(stNetWire& wireCfg)
{	
    int ret = -1;
    cJSON *json = cJSON_CreateObject();
	if (!json){
		LOGE("cJSON_CreateObject list FAIL!");		
		return ret;
	}
    ON_SCOPE_EXIT([&]{cJSON_Delete(json);});
    cJSON_AddStringToObject(json, "cmd", "get_networkSettings");     
	char *jsonBuf = cJSON_PrintUnformatted(json);
    if(jsonBuf){
        LOGI("udp json:%s", jsonBuf);
        std::string reply;
        if(0 == udpSend(std::string(jsonBuf), reply)){
            do{
            	cJSON *root = cJSON_Parse(reply.c_str());
            	if (!root){
            		LOGE("parse root error. ");
            		ret = -2;
                    break;
            	}
            	ON_SCOPE_EXIT([&]{cJSON_Delete(root);});

                cJSON *obj = cJSON_GetObjectItem(root, "data");
                if (NULL == obj){
        			LOGE("parse data error!");
        			ret = -3;
                    break;
        		}

                cJSON *jsTmp = cJSON_GetObjectItem(obj, "type");
            	if (NULL == jsTmp) {
            		LOGE("parse type error!");
            		ret = -6;
                    break;
            	}
            	if (jsTmp->valueint < 0 || jsTmp->valueint > 1){
            		LOGE("type error: %d", jsTmp->valueint);
            		ret = -7;
                    break;
            	}
                wireCfg.cfg.type = jsTmp->valueint;
                LOGI("wireCfg.cfg.type:%d", wireCfg.cfg.type);

                jsTmp = cJSON_GetObjectItem(obj, "status");
                if (NULL == jsTmp){
        			LOGE("parse status error!");
        			ret = -4;
                    break;
        		}
            	if (jsTmp->valueint < 0 || jsTmp->valueint > 1){
            		LOGE("status error: %d", jsTmp->valueint);
            		ret = -5;
                    break;
            	}
                wireCfg.cfg.enable = jsTmp->valueint;
            	LOGI("wireCfg.cfg.enable:%d", wireCfg.cfg.enable);
                if(false == wireCfg.cfg.enable){
                    ret = 0;
                    break;
                }
                
                if(wireCfg.cfg.type){  //dhcp
                    std::string maskString;
                	std::string ipString;
                	if(0 == utils::getIpAndMask("eth0", ipString, maskString)){
                        snprintf(wireCfg.cfg.ip, sizeof(wireCfg.cfg.ip), ipString.c_str());
                        snprintf(wireCfg.cfg.mask, sizeof(wireCfg.cfg.mask), maskString.c_str());
                    }
                    std::string gw;
                    if(0 == utils::GetDefaultGw(gw)){
                        snprintf(wireCfg.cfg.gw, sizeof(wireCfg.cfg.gw), gw.c_str());
                    }
                    snprintf(wireCfg.cfg.dns, sizeof(wireCfg.cfg.dns), utils::getDNS().c_str());
                    ret = 0;
                    break;
                }

        		jsTmp = cJSON_GetObjectItem(obj, "ip");
                if (NULL == jsTmp){
        			LOGE("parse ip error!");
        			ret = -8;
                    break;
        		}
                snprintf(wireCfg.cfg.ip, sizeof(wireCfg.cfg.ip), jsTmp->valuestring);
                LOGI("ip:%s", wireCfg.cfg.ip);

                jsTmp = cJSON_GetObjectItem(obj, "netmask");
                if (NULL == jsTmp){
        			LOGE("parse netmask error!");
        			ret = -9;
                    break;
        		}
                snprintf(wireCfg.cfg.mask, sizeof(wireCfg.cfg.mask), jsTmp->valuestring);
                LOGI("netmask:%s", wireCfg.cfg.mask);

                jsTmp = cJSON_GetObjectItem(obj, "gateway");
                if (NULL == jsTmp){
        			LOGE("parse gateway error!");
        			ret = -10;
                    break;
        		}
                snprintf(wireCfg.cfg.gw, sizeof(wireCfg.cfg.gw), jsTmp->valuestring);
                LOGI("gateway:%s", wireCfg.cfg.gw);

                jsTmp = cJSON_GetObjectItem(obj, "dns");
                if (NULL == jsTmp){
        			LOGE("parse dns error!");
        			ret = -11;
                    break;
        		}
                snprintf(wireCfg.cfg.dns, sizeof(wireCfg.cfg.dns), jsTmp->valuestring);
                LOGI("dns:%s", wireCfg.cfg.dns);
                ret = 0;
            }while(0);
        }
        free(jsonBuf);
    }
	return ret;
}

int Backstage::setNetWireCfg(const stNetWire& wireCfg)
{
    int ret = -1;
    cJSON *json = cJSON_CreateObject();
	if (!json){
		LOGE("cJSON_CreateObject list FAIL!");		
		return ret;
	}
    ON_SCOPE_EXIT([&]{cJSON_Delete(json);});
    cJSON_AddStringToObject(json, "cmd", "set_networkSettings"); 
    cJSON_AddNumberToObject(json, "type", wireCfg.cfg.type);
    if(!wireCfg.cfg.type){
        cJSON_AddStringToObject(json, "ip", wireCfg.cfg.ip);
        cJSON_AddStringToObject(json, "netmask", wireCfg.cfg.mask);
        if(wireCfg.cfg.gw[0]){
            cJSON_AddStringToObject(json, "gateway", wireCfg.cfg.gw);
        }
        if(wireCfg.cfg.dns[0]){
        cJSON_AddStringToObject(json, "dns", wireCfg.cfg.dns);
        }
    }
	char *jsonBuf = cJSON_PrintUnformatted(json);
    if(jsonBuf){
        LOGI("udp json:%s", jsonBuf);
        std::string reply;
        if(0 == udpSend(std::string(jsonBuf), reply)){
            do{
            	cJSON *root = cJSON_Parse(reply.c_str());
            	if (!root){
            		LOGE("parse root error. ");
            		ret = -2;
                    break;
            	}
            	ON_SCOPE_EXIT([&]{cJSON_Delete(root);});

                cJSON *jsTmp = cJSON_GetObjectItem(root, "ret");
                if (NULL == jsTmp){
        			LOGE("parse status error!");
        			ret = -3;
                    break;
        		}
            	if (0 != jsTmp->valueint){
            		LOGE("netconfig ret: %d", jsTmp->valueint);
            		ret = -4;
                    break;
            	}
                ret = 0;
            }while(0);
        }
        free(jsonBuf);
    }
	return ret;
}
int Backstage::setNetWireEnable(bool enable)
{
    int ret = -1;
    cJSON *json = cJSON_CreateObject();
	if (!json){
		LOGE("cJSON_CreateObject list FAIL!");		
		return ret;
	}
    ON_SCOPE_EXIT([&]{cJSON_Delete(json);});
    cJSON_AddStringToObject(json, "cmd", "update_network_status"); 
    cJSON_AddBoolToObject(json, "status", enable);
	char *jsonBuf = cJSON_PrintUnformatted(json);
    if(jsonBuf){
        LOGI("udp json:%s", jsonBuf);
        std::string reply;
        if(0 == udpSend(std::string(jsonBuf), reply)){
            do{
            	cJSON *root = cJSON_Parse(reply.c_str());
            	if (!root){
            		LOGE("parse root error. ");
            		ret = -2;
                    break;
            	}
            	ON_SCOPE_EXIT([&]{cJSON_Delete(root);});

                cJSON *jsTmp = cJSON_GetObjectItem(root, "ret");
                if (NULL == jsTmp){
        			LOGE("parse status error!");
        			ret = -3;
                    break;
        		}
            	if (0 != jsTmp->valueint){
            		LOGE("netconfig ret: %d", jsTmp->valueint);
            		ret = -4;
                    break;
            	}
                ret = 0;
            }while(0);
        }
        free(jsonBuf);
    }
	return ret;
}


int Backstage::getNetWifiCfg(stNetWifi& wifiCfg)
{
    int ret = -1;
    cJSON *json = cJSON_CreateObject();
	if (!json){
		LOGE("cJSON_CreateObject list FAIL!");		
		return ret;
	}
    ON_SCOPE_EXIT([&]{cJSON_Delete(json);});
    cJSON_AddStringToObject(json, "cmd", "get_wifiSettings");     
	char *jsonBuf = cJSON_PrintUnformatted(json);
    if(jsonBuf){
        LOGI("udp json:%s", jsonBuf);
        std::string reply;
        if(0 == udpSend(std::string(jsonBuf), reply)){
            do{
            	cJSON *root = cJSON_Parse(reply.c_str());
            	if (!root){
            		LOGE("parse root error. ");
            		ret = -2;
                    break;
            	}
            	ON_SCOPE_EXIT([&]{cJSON_Delete(root);});

                cJSON *obj = cJSON_GetObjectItem(root, "data");
                if (NULL == obj){
        			LOGE("parse data error!");
        			ret = -3;
                    break;
        		}

                cJSON *jsTmp = cJSON_GetObjectItem(obj, "status");
                if (NULL == jsTmp){
        			LOGE("parse status error!");
        			ret = -4;
                    break;
        		}
            	if (jsTmp->valueint < 0 || jsTmp->valueint > 1){
            		LOGE("status error: %d", jsTmp->valueint);
            		ret = -5;
                    break;
            	}
                wifiCfg.cfg.enable = jsTmp->valueint;
            	LOGI("wireCfg.cfg.enable:%d", wifiCfg.cfg.enable);
                if(false == wifiCfg.cfg.enable){
                    ret = 0;
                    break;
                }

				jsTmp = cJSON_GetObjectItem(obj, "enableAp");
                if (NULL == jsTmp){
        			LOGE("parse enableAp error!");
        			ret = -12;
                    break;
        		}
				wifiCfg.enableAp = jsTmp->valueint;

				if(wifiCfg.enableAp){
					jsTmp = cJSON_GetObjectItem(obj, "apPwd");
	                if (NULL == jsTmp){
	        			LOGE("parse apPwd error!");
	        			ret = -12;
	                    break;
	        		}								
					snprintf(wifiCfg.apPwd, sizeof(wifiCfg.apPwd), jsTmp->valuestring);
					ret = 0;
					break;
				}

                jsTmp = cJSON_GetObjectItem(obj, "enctype");
                if (NULL == jsTmp){
        			LOGE("parse enctype error!");
        			ret = -12;
                    break;
        		}
                snprintf(wifiCfg.encType, sizeof(wifiCfg.encType), jsTmp->valuestring);
                LOGI("encType:%s", wifiCfg.encType);

                jsTmp = cJSON_GetObjectItem(obj, "ssid");
                if (NULL == jsTmp){
        			LOGE("parse ssid error!");
        			ret = -13;
                    break;
        		}
                snprintf(wifiCfg.ssid, sizeof(wifiCfg.ssid), jsTmp->valuestring);
                LOGI("ssid:%s", wifiCfg.ssid);

                jsTmp = cJSON_GetObjectItem(obj, "pwd");
                if (NULL == jsTmp){
        			LOGE("parse pwd error!");
        			ret = -14;
                    break;
        		}
                snprintf(wifiCfg.pwd, sizeof(wifiCfg.pwd), jsTmp->valuestring);
                LOGI("pwd:%s", wifiCfg.pwd);

                jsTmp = cJSON_GetObjectItem(obj, "connected");
                if (NULL == jsTmp){
        			LOGE("parse status error!");
        			ret = -15;
                    break;
        		}
            	if (jsTmp->valueint < 0 || jsTmp->valueint > 1){
            		LOGE("connected error: %d", jsTmp->valueint);
            		ret = -16;
                    break;
            	}
                wifiCfg.isConnected = jsTmp->valueint;
            	LOGI("wireCfg.connected:%d", wifiCfg.isConnected);
                
            	jsTmp = cJSON_GetObjectItem(obj, "type");
            	if (NULL == jsTmp) {
            		LOGE("parse type error!");
            		ret = -6;
                    break;
            	}
            	if (jsTmp->valueint < 0 || jsTmp->valueint > 1){
            		LOGE("type error: %d", jsTmp->valueint);
            		ret = -7;
                    break;
            	}
                wifiCfg.cfg.type = jsTmp->valueint;
                LOGI("wifiCfg.cfg.type:%d", wifiCfg.cfg.type);
                if(wifiCfg.cfg.type){  //dhcp
                    std::string maskString;
                	std::string ipString;
                	if(0 == utils::getIpAndMask("wlan0", ipString, maskString)){
                        snprintf(wifiCfg.cfg.ip, sizeof(wifiCfg.cfg.ip), ipString.c_str());
                        snprintf(wifiCfg.cfg.mask, sizeof(wifiCfg.cfg.mask), maskString.c_str());
                    }
                    std::string gw;
                    if(0 == utils::GetDefaultGw(gw)){
                        snprintf(wifiCfg.cfg.gw, sizeof(wifiCfg.cfg.gw), gw.c_str());
                    }
                    snprintf(wifiCfg.cfg.dns, sizeof(wifiCfg.cfg.dns), utils::getDNS().c_str());
                    ret = 0;
                    break;
                }

        		jsTmp = cJSON_GetObjectItem(obj, "ip");
                if (NULL == jsTmp){
        			LOGE("parse ip error!");
        			ret = -8;
                    break;
        		}
                snprintf(wifiCfg.cfg.ip, sizeof(wifiCfg.cfg.ip), jsTmp->valuestring);
                LOGI("ip:%s", wifiCfg.cfg.ip);

                jsTmp = cJSON_GetObjectItem(obj, "netmask");
                if (NULL == jsTmp){
        			LOGE("parse netmask error!");
        			ret = -9;
                    break;
        		}
                snprintf(wifiCfg.cfg.mask, sizeof(wifiCfg.cfg.mask), jsTmp->valuestring);
                LOGI("netmask:%s", wifiCfg.cfg.mask);

                jsTmp = cJSON_GetObjectItem(obj, "gateway");
                if (NULL == jsTmp){
        			LOGE("parse gateway error!");
        			ret = -10;
                    break;
        		}
                snprintf(wifiCfg.cfg.gw, sizeof(wifiCfg.cfg.gw), jsTmp->valuestring);
                LOGI("gateway:%s", wifiCfg.cfg.gw);

                jsTmp = cJSON_GetObjectItem(obj, "dns");
                if (NULL == jsTmp){
        			LOGE("parse dns error!");
        			ret = -11;
                    break;
        		}
                snprintf(wifiCfg.cfg.dns, sizeof(wifiCfg.cfg.dns), jsTmp->valuestring);
                LOGI("ip:%s", wifiCfg.cfg.dns);
                ret = 0;
            }while(0);
        }
        free(jsonBuf);
    }
	return ret;
}

int Backstage::setNetWifiCfg(const stNetWifi& wifiCfg)
{
    int ret = -1;
    cJSON *json = cJSON_CreateObject();
	if (!json){
		LOGE("cJSON_CreateObject list FAIL!");		
		return ret;
	}
    ON_SCOPE_EXIT([&]{cJSON_Delete(json);});
    cJSON_AddStringToObject(json, "cmd", "set_wifiSettings"); 
    cJSON_AddStringToObject(json, "enctype", wifiCfg.encType);
    cJSON_AddStringToObject(json, "ssid", wifiCfg.ssid);
    cJSON_AddStringToObject(json, "pwd", wifiCfg.pwd);
    cJSON_AddNumberToObject(json, "type", wifiCfg.cfg.type);
    if(!wifiCfg.cfg.type){
        cJSON_AddStringToObject(json, "ip", wifiCfg.cfg.ip);
        cJSON_AddStringToObject(json, "netmask", wifiCfg.cfg.mask);
        if(wifiCfg.cfg.gw[0]){
            cJSON_AddStringToObject(json, "gateway", wifiCfg.cfg.gw);
        }
        if(wifiCfg.cfg.dns[0]){
        cJSON_AddStringToObject(json, "dns", wifiCfg.cfg.dns);
        }
    }
	cJSON_AddBoolToObject(json, "enableAp", wifiCfg.enableAp);
	cJSON_AddStringToObject(json, "apPwd", wifiCfg.apPwd); 
	cJSON_AddBoolToObject(json, "isApCfg", wifiCfg.isAPCfg);
	cJSON_AddBoolToObject(json, "isDevCfg", true);
	char *jsonBuf = cJSON_PrintUnformatted(json);
    if(jsonBuf){
        LOGI("udp json:%s", jsonBuf);
        std::string reply;
        if(0 == udpSend(std::string(jsonBuf), reply)){
            do{
            	cJSON *root = cJSON_Parse(reply.c_str());
            	if (!root){
            		LOGE("parse root error. ");
            		ret = -2;
                    break;
            	}
            	ON_SCOPE_EXIT([&]{cJSON_Delete(root);});

                cJSON *jsTmp = cJSON_GetObjectItem(root, "ret");
                if (NULL == jsTmp){
        			LOGE("parse status error!");
        			ret = -3;
                    break;
        		}
            	if (0 != jsTmp->valueint){
            		LOGE("netconfig ret: %d", jsTmp->valueint);
            		ret = -4;
                    break;
            	}
                ret = 0;
            }while(0);
        }
        free(jsonBuf);
    }
	return ret;
}

int Backstage::setNetWifiEnable(bool enable)
{
    int ret = -1;
    cJSON *json = cJSON_CreateObject();
	if (!json){
		LOGE("cJSON_CreateObject list FAIL!");		
		return ret;
	}
    ON_SCOPE_EXIT([&]{cJSON_Delete(json);});
    cJSON_AddStringToObject(json, "cmd", "update_wifi_status"); 
    cJSON_AddBoolToObject(json, "status", enable);
	char *jsonBuf = cJSON_PrintUnformatted(json);
    if(jsonBuf){
        LOGI("udp json:%s", jsonBuf);
        std::string reply;
        if(0 == udpSend(std::string(jsonBuf), reply)){
            do{
            	cJSON *root = cJSON_Parse(reply.c_str());
            	if (!root){
            		LOGE("parse root error. ");
            		ret = -2;
                    break;
            	}
            	ON_SCOPE_EXIT([&]{cJSON_Delete(root);});

                cJSON *jsTmp = cJSON_GetObjectItem(root, "ret");
                if (NULL == jsTmp){
        			LOGE("parse status error!");
        			ret = -3;
                    break;
        		}
            	if (0 != jsTmp->valueint){
            		LOGE("netconfig ret: %d", jsTmp->valueint);
            		ret = -4;
                    break;
            	}
                ret = 0;
            }while(0);
        }
        free(jsonBuf);
    }
	return ret;
}

int Backstage::getSsidList(stAccPoint accPointList[], int accPointListSize)
{
#if 0 //test
    int ret = -1;
    std::vector<std::string> vSsidList;        
    std::vector<int> vSigLev;
    std::vector<bool> vEncrypt;
    ret = wifiScan(vSsidList, vSigLev, vEncrypt, targetSsid);
    if(0 == ret){
        int i = 0;
        for(auto& s : vSsidList){
            if(i < accPointListSize){
                if("" != s){
                    snprintf(accPointList[i].ssid, sizeof(accPointList[i].ssid), s.c_str());
                    accPointList[i].sigLev = vSigLev[i];
                    accPointList[i].isEncrypt = vEncrypt[i];
                    if(s == targetSsid){
                        targetConn = wifiConnect(targetSsid, targetSsidPwd);
                    }
                    i++;
                }
            }
            else{
                break;
            }
        }
        ret = i;
    }
    return ret;    
#else
    int ret = -1;
    cJSON *json = cJSON_CreateObject();
    if (!json){
        LOGE("cJSON_CreateObject list FAIL!");      
        return ret;
    }
    ON_SCOPE_EXIT([&]{cJSON_Delete(json);});
    cJSON_AddStringToObject(json, "cmd", "get_wifiList");
    char *jsonBuf = cJSON_PrintUnformatted(json);
    if(jsonBuf){
        LOGI("udp json:%s", jsonBuf);
        std::string reply;
        if(0 == udpSend(std::string(jsonBuf), reply)){
            do{
                cJSON *root = cJSON_Parse(reply.c_str());
            	if (!root){
            		LOGE("parse root error. ");
            		ret = -2;
                    break;
            	}
            	ON_SCOPE_EXIT([&]{cJSON_Delete(root);});

                cJSON *obj = cJSON_GetObjectItem(root, "data");
                if (NULL == obj){
        			LOGE("parse data error!");
        			ret = -3;
                    break;
        		}

                cJSON *ap_arry = cJSON_GetObjectItem(obj, "wifiList"); 
                if( NULL == ap_arry ){
                    LOGE("parse wifiList error!");
        			ret = -4;
                    break;                    
                }  
                int i = 0;
                cJSON *client_list = ap_arry->child;
                while( client_list != NULL ){
                    if(i < accPointListSize){
                        char *ssid = cJSON_GetObjectItem( client_list , "ssid")->valuestring;
                        if(ssid && *ssid){
                            LOGI("ssid:%s", accPointList[i].ssid);
                            snprintf(accPointList[i].ssid, sizeof(accPointList[i].ssid), ssid);                        
                            accPointList[i].sigLev = cJSON_GetObjectItem( client_list , "sig")->valueint;
                            accPointList[i].isEncrypt = (bool)cJSON_GetObjectItem( client_list , "ept")->valueint;
                            accPointList[i].isConnected = (bool)cJSON_GetObjectItem( client_list , "conn")->valueint;
                        i++;
                        LOGI("ssid:%s, sigLev:%d, isEncrypt:%d, isConnected:%d", accPointList[i].ssid, accPointList[i].sigLev, accPointList[i].isEncrypt, accPointList[i].isConnected);
                        }
                    }
                    else{
                        LOGE("space for ssid list not enough");
                        break;
                    }
                    client_list = client_list->next ;
                }                
                ret = i;
            }while(0);
        }
        free(jsonBuf);
    }
    return ret;
#endif
}

int Backstage::claerNetWifiCfg()
{
    int ret = -1;
    cJSON *json = cJSON_CreateObject();
    if (!json){
        LOGE("cJSON_CreateObject list FAIL!");      
        return ret;
    }
    ON_SCOPE_EXIT([&]{cJSON_Delete(json);});
    cJSON_AddStringToObject(json, "cmd", "clear_wifiSettings");
    char *jsonBuf = cJSON_PrintUnformatted(json);
    if(jsonBuf){
        LOGI("udp json:%s", jsonBuf);
        std::string reply;
        if(0 == udpSend(std::string(jsonBuf), reply)){
            do{
                cJSON *root = cJSON_Parse(reply.c_str());
                if (!root){
                    LOGE("parse root error. ");
                    ret = -2;
                    break;
                }
                ON_SCOPE_EXIT([&]{cJSON_Delete(root);});

                cJSON *jsTmp = cJSON_GetObjectItem(root, "ret");
                if (NULL == jsTmp){
                    LOGE("parse status error!");
                    ret = -3;
                    break;
                }
                if (0 != jsTmp->valueint){
                    LOGE("netconfig ret: %d", jsTmp->valueint);
                    ret = -4;
                    break;
                }
                ret = 0;
            }while(0);
        }
        free(jsonBuf);
    }
    return ret;
}

int Backstage::getNet4GCfg(stNet4G& n4gCfg)
{
    int ret = -1;
    cJSON *json = cJSON_CreateObject();
	if (!json){
		LOGE("cJSON_CreateObject list FAIL!");		
		return ret;
	}
    ON_SCOPE_EXIT([&]{cJSON_Delete(json);});
    cJSON_AddStringToObject(json, "cmd", "get_4g_status");     
	char *jsonBuf = cJSON_PrintUnformatted(json);
    if(jsonBuf){
        LOGI("udp json:%s", jsonBuf);
        std::string reply;
        if(0 == udpSend(std::string(jsonBuf), reply)){
            do{
            	cJSON *root = cJSON_Parse(reply.c_str());
            	if (!root){
            		LOGE("parse root error. ");
            		ret = -2;
                    break;
            	}
            	ON_SCOPE_EXIT([&]{cJSON_Delete(root);});

                cJSON *obj = cJSON_GetObjectItem(root, "data");
                if (NULL == obj){
        			LOGE("parse data error!");
        			ret = -3;
                    break;
        		}

                cJSON *jsTmp = cJSON_GetObjectItem(obj, "hasDevice");
                if (NULL == jsTmp){
        			LOGE("parse available error!");
        			ret = -4;
                    break;
        		}
            	if (jsTmp->valueint < 0 || jsTmp->valueint > 1){
            		LOGE("status available: %d", jsTmp->valueint);
            		ret = -5;
                    break;
            	}
                n4gCfg.available = jsTmp->valueint;
            	LOGI("n4gCfg.available:%d", n4gCfg.available);
                if(false == n4gCfg.available){
                    ret = 0;
                    break;
                }

                jsTmp = cJSON_GetObjectItem(obj, "status");
                if (NULL == jsTmp){
        			LOGE("parse status error!");
        			ret = -6;
                    break;
        		}
            	if (jsTmp->valueint < 0 || jsTmp->valueint > 1){
            		LOGE("status error: %d", jsTmp->valueint);
            		ret = -7;
                    break;
            	}
                n4gCfg.enable = jsTmp->valueint;
            	LOGI("n4gCfg.enable:%d", n4gCfg.enable);
                if(false == n4gCfg.enable){
                    ret = 0;
                    break;
                }

                jsTmp = cJSON_GetObjectItem(obj, "service_provider_type");
                if (NULL == jsTmp){
        			LOGE("parse provider error!");
        			ret = -8;
                    break;
        		}
                n4gCfg.provider = jsTmp->valueint;
                LOGI("provider:%d", n4gCfg.provider);

                ret = 0;
            }while(0);
        }
        free(jsonBuf);
    }
	return ret;
}

int Backstage::setNet4GEnable(bool enable)
{
    int ret = -1;
    cJSON *json = cJSON_CreateObject();
    if (!json){
        LOGE("cJSON_CreateObject list FAIL!");      
        return ret;
    }
    ON_SCOPE_EXIT([&]{cJSON_Delete(json);});
    cJSON_AddStringToObject(json, "cmd", "update_4g_status"); 
    cJSON_AddBoolToObject(json, "status", enable);
    char *jsonBuf = cJSON_PrintUnformatted(json);
    if(jsonBuf){
        LOGI("udp json:%s", jsonBuf);
        std::string reply;
        if(0 == udpSend(std::string(jsonBuf), reply)){
            do{
                cJSON *root = cJSON_Parse(reply.c_str());
                if (!root){
                    LOGE("parse root error. ");
                    ret = -2;
                    break;
                }
                ON_SCOPE_EXIT([&]{cJSON_Delete(root);});

                cJSON *jsTmp = cJSON_GetObjectItem(root, "ret");
                if (NULL == jsTmp){
                    LOGE("parse status error!");
                    ret = -3;
                    break;
                }
                if (0 != jsTmp->valueint){
                    LOGE("netconfig ret: %d", jsTmp->valueint);
                    ret = -4;
                    break;
                }
                ret = 0;
            }while(0);
        }
        free(jsonBuf);
    }
    return ret;
}

int Backstage::reboot4G()
{
    int ret = -1;
    cJSON *json = cJSON_CreateObject();
    if (!json){
        LOGE("cJSON_CreateObject list FAIL!");      
        return ret;
    }
    ON_SCOPE_EXIT([&]{cJSON_Delete(json);});
    cJSON_AddStringToObject(json, "cmd", "reboot_4g");
    char *jsonBuf = cJSON_PrintUnformatted(json);
    if(jsonBuf){
        LOGI("udp json:%s", jsonBuf);
        std::string reply;
        if(0 == udpSend(std::string(jsonBuf), reply)){
            do{
                cJSON *root = cJSON_Parse(reply.c_str());
                if (!root){
                    LOGE("parse root error. ");
                    ret = -2;
                    break;
                }
                ON_SCOPE_EXIT([&]{cJSON_Delete(root);});

                cJSON *jsTmp = cJSON_GetObjectItem(root, "ret");
                if (NULL == jsTmp){
                    LOGE("parse status error!");
                    ret = -3;
                    break;
                }
                if (0 != jsTmp->valueint){
                    LOGE("netconfig ret: %d", jsTmp->valueint);
                    ret = -4;
                    break;
                }
                ret = 0;
            }while(0);
        }
        free(jsonBuf);
    }
    return ret;
}

int Backstage::getScreenSaverConfig(stScreensaverCfg& cfg)
{
    cfg.type = m_paramMng->getScreensaverType();
    cfg.interval = m_paramMng->getScreensaverInter();
    cfg.picQty = 0;
    std::string screensaverCfg(m_paramMng->getScreensaverPics());
    while(screensaverCfg.length()){
        unsigned iPos = screensaverCfg.find(";");
        if(iPos != std::string::npos){
            snprintf(&cfg.pic[cfg.picQty][0], sizeof(cfg.pic[0]), screensaverCfg.substr(0, iPos).c_str());
            LOGI("screenasver %d : %s", cfg.picQty, &cfg.pic[cfg.picQty][0]);
            cfg.picQty++;
            screensaverCfg = (screensaverCfg.length() > iPos + 1 ? screensaverCfg.substr(iPos + 1) : "");
        }
        else{
            return -1;
        }
    }
	
    return 0;
}

int Backstage::sendPassword(const char *password)
{
	if(m_objs){
		LOGI("sendPassword");
		GPeInput *peinput = (GPeInput*)m_objs->findObject("peinput");
		if (nullptr != peinput){
			peinput->sendPassword(password);
		}
	}
	return 0;
}

void Backstage::resetDecisionCenterTimer()
{
	if(m_objs){
		LOGI("resetDecisionCenterTimer");
		GDecisionCenter *decCenter = (GDecisionCenter*)m_objs->findObject("decisionCenter");
		if (nullptr != decCenter){
			decCenter->timerReset();
		}
	}
}

int Backstage::pauseDataFlow()
{
     if(m_objs){
     	LOGI("pause Data Flow");
		#if 0
        GDecisionCenter *decCenter = (GDecisionCenter*)m_objs->findObject("decisionCenter");
		if (nullptr != decCenter){
            if(!Singleton<Peripheral>::GetInstance()->isHardwareTesting()){
                decCenter->pauseDataFlowAfterAllNotRecoResRecvd();           
            }
            else{
                LOGI("is testing hardware...");
            }
            return 0;
        }
		#else
		GTrackerLock *pTrackLock = (GTrackerLock*)m_objs->findObject("trackerLock");
		GStandby *pStandby = (GStandby*)m_objs->findObject("standby");
        if (nullptr != pTrackLock && nullptr != pStandby){ 
            if(!Singleton<Peripheral>::GetInstance()->isHardwareTesting()){
                pTrackLock->lockCtrl(true);
            }
            else{
                LOGI("is testing hardware...");
            }
            return 0;
        }  
		#endif
    }
	return -1;
}

int Backstage::resumeDataFlow()
{
    if(m_objs){
	    LOGI("resume Data Flow");
		#if 0
        GDecisionCenter *decCenter = (GDecisionCenter*)m_objs->findObject("decisionCenter");
		if (nullptr != decCenter){
			decCenter->resumeDataFlow();
            return 0;
        }
		#else
		GTrackerLock *pTrackLock = (GTrackerLock*)m_objs->findObject("trackerLock");
        if (pTrackLock){ 
            pTrackLock->lockCtrl(false);
            return 0;
        }
		#endif
    }
	return -1;
}

int Backstage::candidateChoosedInPopupWindow(int index)
{
	LOGI("candidateChoosedInPopupWindow:%d", (int)index);
	if(index >= 0){
		RWProtocol::getInstance()->sendSelectedItem(index);
	}
	else{
		if(m_objs){
			LOGI("cancle choosed by user");
			GDecisionCenter *decCenter = (GDecisionCenter*)m_objs->findObject("decisionCenter");
			if (nullptr != decCenter){
				decCenter->recheckResult(2);//二次核验未经许可人员
			}
		}
	}
	return 0;
}

int Backstage::resetNetworkCfg()
{
    int ret = -1;
    cJSON *json = cJSON_CreateObject();
    if (!json){
        LOGE("cJSON_CreateObject list FAIL!");      
        return ret;
    }
    ON_SCOPE_EXIT([&]{cJSON_Delete(json);});
    cJSON_AddStringToObject(json, "cmd", "set_default_setting");
    char *jsonBuf = cJSON_PrintUnformatted(json);
    if(jsonBuf){
        LOGI("udp json:%s", jsonBuf);
        std::string reply;
        if(0 == udpSend(std::string(jsonBuf), reply)){
            do{
                cJSON *root = cJSON_Parse(reply.c_str());
                if (!root){
                    LOGE("parse root error. ");
                    ret = -2;
                    break;
                }
                ON_SCOPE_EXIT([&]{cJSON_Delete(root);});

                cJSON *jsTmp = cJSON_GetObjectItem(root, "ret");
                if (NULL == jsTmp){
                    LOGE("parse status error!");
                    ret = -3;
                    break;
                }
                if (0 != jsTmp->valueint){
                    LOGE("reset Network Cfg ret: %d", jsTmp->valueint);
                    ret = -4;
                    break;
                }
                ret = 0;
            }while(0);
        }
        free(jsonBuf);
    }
    return ret;
}

int Backstage::udpSend(const string &sendData, string &recvData)
{
    int fd = socket(AF_INET, SOCK_DGRAM, 0);
    if (fd < 0) 
    {
        LOGE("create socket fail!");
        return -1;
    }

    timeval tv = {30, 0};
    int ret = setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, (char*)&tv, sizeof(timeval));
    if (ret)
    {
        ::close(fd);
        return -2;
    }
    
    struct sockaddr_in sin;
    bzero(&sin, sizeof(sin));
    sin.sin_family = AF_INET;
    sin.sin_addr.s_addr = htonl(INADDR_ANY);
    sin.sin_port = htons(6788);
    sendto(fd, sendData.c_str(), sendData.length(), 0, (struct sockaddr *)&sin, sizeof(struct sockaddr));

    char buff[1024 * 8] = {0};
    #if 0
    int len = recvfrom(fd, buff, sizeof(buff) - 1, 0, nullptr, nullptr);
    #else
    int len = 0;
    int tryTime = 3;
    do{
        len = recvfrom(fd, buff, sizeof(buff) - 1, 0, nullptr, nullptr);
    }while(len < 0 && 4 == errno && tryTime--);
    #endif
    if (len < 0)
    {
        LOGE("no recv data, ret:%d, errno:%d", len, errno);
        ::close(fd);
        return -3;
    }
    if (buff[len - 2] == '\n' && buff[len - 1] == '\0') 
    {
        buff[len - 2] = '\0';
        len -= 1;
    }
    else
    {
        buff[len] = '\0';
        len++;
    }
    LOGD("recv[%d]:%s", strlen(buff), buff);
    recvData = buff;
    
    ::close(fd);
	return 0;
}
    
bool Backstage::isWiegandIoTestOk()
{
	LOGI("isWiegandIoTestOk");
	GPeInput* pPeInput = (GPeInput*)m_objs->findObject("peInput");
	if(pPeInput){
		pPeInput->hardwareTest(enWgOut);
		usleep(300000);
		return pPeInput->isWiegandLoopTestOk();
	}
	return false;
}

bool Backstage::isRelayAndGpioTestOk()
{
	LOGI("isRelayAndGpioTestOk");
	bool ret = true;
	for(int i=0; i<BasePeripheral::enGpioButt; i++){
		if(!Singleton<Peripheral>::GetInstance()->hasGpio((BasePeripheral::enGpio)i)){
			LOGI("has no gpio%d", i);
			continue;
		}
		int value = 0;
    	if(Singleton<Peripheral>::GetInstance()->getGpioValue((BasePeripheral::enGpio)i, value) < 0){
			LOGE("get Gpio%d Value failed!", i);
			ret = false;
    	}
		if(value != 1){
			LOGE("gpio%d not high before relay on", i);
			ret =  false;
		}
	}
	LOGI("relay on");
	Singleton<Peripheral>::GetInstance()->controlKZOut(true);		 
	usleep(100000);
	for(int i=0; i<BasePeripheral::enGpioButt; i++){
		if(!Singleton<Peripheral>::GetInstance()->hasGpio((BasePeripheral::enGpio)i)){
			LOGI("has no gpio%d", i);
			continue;
		}
		int value = 0;
		if(Singleton<Peripheral>::GetInstance()->getGpioValue((BasePeripheral::enGpio)i, value) < 0){
			LOGE("get Gpio%d Value failed!", i);
			ret =  false;
		}
		if(value != 0){
			LOGE("gpio%d not low after relay on", i);
			ret =  false;
		}
	}
	LOGI("relay off");
	Singleton<Peripheral>::GetInstance()->controlKZOut(false);
	return ret;
}

bool Backstage::isRs485TestOk()
{
	LOGI("isRs485TestOk");

	Singleton<Peripheral>::GetInstance()->setTestingFlag(true);
    ON_SCOPE_EXIT([] { Singleton<Peripheral>::GetInstance()->setTestingFlag(false); });
    usleep(100000);

	std::string usbTo485DevNode;
	do{
		std::string cmd = "ls /sys/bus/usb-serial/drivers/ftdi_sio/ | grep tty";
		if(utils::read_popen(cmd, usbTo485DevNode) > 0){
			LOGI("get ftdi_sio usb to rs485 dev node:%s", usbTo485DevNode.c_str());
			break;
		}
		cmd = "ls /sys/bus/usb-serial/drivers/ch341-uart/ | grep ttyUSB0";
		if(utils::read_popen(cmd, usbTo485DevNode) > 0){
			LOGI("get ch341-uart usb to rs485 dev node:%s", usbTo485DevNode.c_str());
			break;
		}
		LOGE("get usb to rs485 dev node failed!");
		return false;
	}while(0);
	LOGI("Dev Node:%s", usbTo485DevNode.c_str());
	const std::string devNode = "/dev/" + usbTo485DevNode;
	int usbTo485 = open(devNode.c_str(), O_RDWR | O_NOCTTY);
    if(usbTo485 < 0){
    	return false;    
    }
	setSerialOpt(usbTo485, 9600, 8, 'N', 1);

	LOGI("rs485 send str 123456");
	Singleton<Peripheral>::GetInstance()->rs485Send((const unsigned char*)"123456", strlen("123456"));

	char buffer[32] = {0};
	int readBytes = read(usbTo485, buffer, sizeof(buffer) - 1);
    LOGI("usb2485 recv: %s", buffer);
    if(readBytes <= 0){
        close(usbTo485);
        return false;
    }
	
	int writeLen = write(usbTo485, buffer, readBytes);
	LOGI("usb2485 send data:%s, len:%d", buffer, writeLen);

	usleep(100000);

	int len = Singleton<Peripheral>::GetInstance()->rs485Recv((unsigned char*)buffer, sizeof(buffer));
	LOGI("rs485 recv len:%d", len);
	if(len <= 0){
		close(usbTo485);
        return false;		
	}
	LOGI("data: %s", (const char*)buffer);
	close(usbTo485);
	
	return (!memcmp("123456", buffer, strlen("123456")));
}

bool Backstage::isReaderUnderScreenTestOk()
{
	LOGI("isReaderUnderScreenTestOk");
	GPeInput* pPeInput = (GPeInput*)m_objs->findObject("peInput");
	if(!pPeInput){
		return false;
	}	
	pPeInput->hardwareTest(enReadCardUnderScreen);
	return pPeInput->isReaderUnderScreenTestOk();
}

bool Backstage::isWifiTestOk()
{
	LOGI("isWifiTestOk");
	#define TEST_SSID       "reconova"	//  "RW-5F"   //
	#define TEST_PWD        "12345678" 	//"RW@sz=B103#" // 

	const int ssidListSize = 64;
    stAccPoint ssidList[ssidListSize];
    int ret = getSsidList(ssidList, ssidListSize);
	LOGI("ssid list size:%d", ret);
    if(ret > 0){
		for(int i=0; i<ret; i++){
			LOGI("ssid:%s, lev:%d", ssidList[i].ssid, ssidList[i].sigLev);
			if(std::string(ssidList[i].ssid) == TEST_SSID && ssidList[i].sigLev > 45){
				return wifiConnect(TEST_SSID, TEST_PWD);
			}
		}
    }
	return false;
}

bool Backstage::isRtcTestOk()
{
	LOGI("isRtcTestOk, time:%lld", utils::getNowTimeMS());
	//return utils::getNowTimeMS() > 946656000000; //20000101 00:00:00
	return FileUtils::fileIsExist("/data/.rtc_test_ok");
}

bool Backstage::isWireEthTestOk()
{
	LOGI("isWireEthTestOk");sleep(1);return true;
}

bool Backstage::is4gTestOk()
{
	LOGI("is4gTestOk");sleep(1);return true;
}

bool Backstage::isSerial1TestOk()
{
	LOGI("isSerial1TestOk");

	system("killall skcaper");
	Singleton<Peripheral>::GetInstance()->setTestingFlag(true);
    ON_SCOPE_EXIT([] { Singleton<Peripheral>::GetInstance()->setTestingFlag(false); });
    usleep(100000);

	const std::string devNode = "/dev/ttyS3";
	LOGI("Dev Node:%s", devNode.c_str());
	int fdSerial1 = open(devNode.c_str(), O_RDWR | O_NOCTTY);
    if(fdSerial1 < 0){
		LOGE("open %s failed!", devNode.c_str());
    	return false;    
    }
	setSerialOpt(fdSerial1, 9600, 8, 'N', 1);

	const char* testData = "123456";
	int writeLen = write(fdSerial1, testData, strlen(testData));
	LOGI("write len:%d", writeLen);

	usleep(100000);
	
	char buffer[32] = {0};
	int readBytes = read(fdSerial1, buffer, sizeof(buffer) - 1);
    LOGI("serial0 read bytes: %d", readBytes);
    if(readBytes <= 0){
        close(fdSerial1);
        return false;
    }	
	close(fdSerial1);
	LOGI("data: %s", (const char*)buffer);
	return (!memcmp(testData, buffer, strlen(testData)));
}


void Backstage::screenTest()
{
	LOGI("screenTest");
	GPeInput* pPeInput = (GPeInput*)m_objs->findObject("peInput");
	if(pPeInput){
		pPeInput->hardwareTest(enLcd);
	}
}

void Backstage::speakerTest()
{
	LOGI("speakerTest");
	GPeInput* pPeInput = (GPeInput*)m_objs->findObject("peInput");
	if(pPeInput){
		pPeInput->hardwareTest(enSpeaker);
	}
}

void Backstage::microphoneTest(bool record)
{
    LOGI("microphoneTest");
    GPeInput *pPeInput = (GPeInput *)m_objs->findObject("peInput");
    if (pPeInput) {
        pPeInput->hardwareTest(record ? enMicrophoneRecord : enMicrophonePlay);
    }
}

void Backstage::audioSwitchTest() {
    LOGI("Backstage::audioSwitchTest()");
    auto pPeInput = reinterpret_cast<GPeInput *>(m_objs->findObject("peInput"));
    if (pPeInput != nullptr) {
        pPeInput->hardwareTest(enAuidoSwitch);
    }
}

void Backstage::tpTest()
{
	LOGI("tpTest");
	GPeInput* pPeInput = (GPeInput*)m_objs->findObject("peInput");
	if(pPeInput){
		//pPeInput->hardwareTest(enTp);		
	}
}	

void Backstage::irCamTest()
{
	LOGI("irCamTest");
	GPeInput* pPeInput = (GPeInput*)m_objs->findObject("peInput");
	if(pPeInput){
		pPeInput->hardwareTest(enIrCamOn);
		sleep(3);
		pPeInput->hardwareTest(enIrCamOff);
	}
}

void Backstage::irLedTest()
{
	LOGI("irLedTest");
	GPeInput* pPeInput = (GPeInput*)m_objs->findObject("peInput");
	if(pPeInput){
		pPeInput->hardwareTest(enIrCamOn);
		for(int i=0; i<3; i++){
			Singleton<Peripheral>::GetInstance()->setIRledBrightness(0);
			usleep(500000);
			Singleton<Peripheral>::GetInstance()->setIRledBrightness(255);
			usleep(500000);
		}
		pPeInput->hardwareTest(enIrCamOff);
	}
}

void Backstage::ageingTest(unsigned hours)
{
	LOGI("ageingTest");
	std::string cmd{"{\"cmd\":\"set_ageing_test\",\"sw\":"};
	if(hours){
		cmd += "true,\"all_time\":";
		cmd += utils::to_string(hours);
		cmd += "}";
		}
	else{
		cmd += "false}";
	}
	udpLoopToSvr(cmd);
}

int Backstage::getMacFromMes(const char* mesAddrAndProdNo, const char* pcbSeq, std::string& mac)
{
	LOGI("getMacFromMes:%s, %s", mesAddrAndProdNo, pcbSeq);
	const std::string tmp(mesAddrAndProdNo);
    unsigned iPos = tmp.find("/");
    if(iPos == std::string::npos){
        return -1;
    }
            
	std::string mesAddr = tmp.substr(0, iPos);
	std::string prodNo = tmp.substr(iPos + 1);
	std::string strPcbSeq = pcbSeq;
	std::string cmd = "curl -s -K 12 -m 20 -k -X POST \"http://";
	cmd += utils::trim(mesAddr);
	cmd += "/mrs/getProdField?prodNo=";
	cmd += utils::trim(prodNo);
	cmd += "&pcbSeq=";
	cmd += utils::trim(strPcbSeq);
	cmd += "&fieldName=lanmac\"";
	LOGI("cmd:%s", cmd.c_str());	
	if(utils::read_popen(cmd, mac) <= 0){
		LOGE("get mac failed!");
		return -2;
	}
    if(mac.length() != 12){
		LOGE("mac invalid, len:%d, mac:%s", mac.length(), mac.c_str());
		return -3;
    }
	for(int i=5; i>0; i--){
		mac.insert(i * 2, 1, ':');
	}
	LOGI("mac:%s", mac.c_str());
	cmd = "keydata set mac ";
	cmd += mac;
	cmd += " -f";
	LOGI("cmd:%s", cmd.c_str());
	int nReturn = utils::RW_System(cmd.c_str());
    int nResult = WEXITSTATUS(nReturn);
    if(nResult != 0){
		LOGE("str=%s, nReturn=%d, nResult=%d", cmd.c_str(), nReturn, nResult);
    	return -1;
    }
	cmd = "echo -n \"";
	cmd += mac;
	cmd += " \" > /data/.HWaddr";
	LOGI("cmd:%s", cmd.c_str());
	nReturn = utils::RW_System(cmd.c_str());
    nResult = WEXITSTATUS(nReturn);
    if(nResult != 0){
		LOGE("str=%s, nReturn=%d, nResult=%d", cmd.c_str(), nReturn, nResult);
    	return -1;
    }
	return 0;
}

bool Backstage::isAgeing(std::string& hours)
{
	LOGI("isAgeing");
	if(FileUtils::fileIsExist(AGEING_TIME_FILE)){
		if(0 == utils::read_file(AGEING_TIME_FILE, hours)){
			LOGI("ageing time:%s hours", hours.c_str());
			return true;
		}
	}
	return false;
}

int Backstage::getKeyDataMac(std::string& mac)
{
	LOGI("getKeyDataMac");
	return utils::read_popen("keydata get mac", mac);
}

int Backstage::getRecoUiAdConfig(stScreensaverCfg& cfg)
{
	cfg.type = 1;
    cfg.interval = m_paramMng->getAdInter(); 
    cfg.picQty = 0;
	LOGI("reco ui ad config:%s", m_paramMng->getAdPics().c_str());
    std::string screensaverCfg(m_paramMng->getAdPics());
    while(screensaverCfg.length()){
        unsigned iPos = screensaverCfg.find(";");
        if(iPos != std::string::npos){
            snprintf(&cfg.pic[cfg.picQty][0], sizeof(cfg.pic[0]), screensaverCfg.substr(0, iPos).c_str());
            LOGI("ad %d : %s", cfg.picQty, &cfg.pic[cfg.picQty][0]);
            cfg.picQty++;
            screensaverCfg = (screensaverCfg.length() > iPos + 1 ? screensaverCfg.substr(iPos + 1) : "");
        }
        else{
            return -1;
        }
    }
    return 0;
}

int Backstage::recoUiTypeSwitch(unsigned x, unsigned y, unsigned w, unsigned h)
{
	GCamera* pcam = (GCamera*)m_objs->findObject("normal");
	if (nullptr != pcam){ 
		pcam->voSetDisWin(x, y, w, h);
	}
	setLogo(getLogo());//get logo when reci ui switch
	
	return 0;
}

int Backstage::getDevPwd(int& type, std::string& pwd)
{
	int ret = DBManage::getInstance()->getDevicePin(pwd);
	if(0 == ret && pwd.length()){
		type = 2;
		return 0;
	}
	
	pwd = m_paramMng->getLocalDevPwd();
	type = 1;
	return 0;
}

int Backstage::setLocalDevPwd(const std::string& pwd)
{
	m_paramMng->setLocalDevPwd(pwd);
	
	//该参数配置需要支持清空（取消本地密码操作）
	//清空时参数对应的更新处理不会关闭识别界面密码按键
	//因此需要在这里关闭密码按键显示
	if(0 == pwd.length()){
		LOGI("hide password button cause pwd deleted by user");
		View::getInstance()->setPwdButton(false); 
	}
	
	return 0;
}

int Backstage::getKeyDataHardware(std::string& hardware)
{
	LOGI("getKeyDataHardware");
	return utils::read_popen("keydata get hardware", hardware);
}

int Backstage::setKeyDataHardwareAndUpdataFunction(const std::string& hardware)
{
	LOGI("set hardware:%s", hardware.c_str());
	std::string setHwCmd{"keydata set hardware "};
	setHwCmd += hardware;
	setHwCmd += " -f";
	system(setHwCmd.c_str());

    std::ostringstream oss;
    oss << "echo " << hardware << " > " WEB_DATA_PATH ".hardversion; sync";
    auto command = oss.str();
    LOGD("command: %s", command.c_str());
    system(command.c_str());

    DevVersion::getInstance()->init();  // 工装重新录入型号后，再重新加载

    auto manufacturer = DevVersion::getInstance()->getManu();
    if (manufacturer == Manu_E::ManuRWRk1109V05) {
        Singleton<Peripheral>::GetInstance()->setAudioOutEnabled(m_paramMng->getAudioOutEnabled());
    }

    const bool hasReaderUnderScreen = ('2' == hardware[strlen("HWA531052") - 1]);
	Singleton<Peripheral>::GetInstance()->functionSwitch(0, hasReaderUnderScreen);
	const bool hasTp = ('1' == hardware[strlen("HWA5310522C11") - 1]);
	LOGI("has TP:%d", hasTp);
	View::getInstance()->showCursorSwitch(!hasTp);
	return 0;
}


int Backstage::setSetupAlreadyFlag()
{
	FileUtils::removeFile(SETUP_ALREADY_FILE);
	return 0;
}

int Backstage::getParkInfo(std::string& info)
{
	info = m_paramMng->getParkInfo();
	return 0;
}

int Backstage::setParkInfo(const std::string& info)
{	
	m_paramMng->setParkInfo(info);
	return 0;
}

int Backstage::getDevPosi(std::string& posi)
{
 	posi = m_paramMng->getDevicePosition();
 	return 0;
}

int Backstage::setDevPosi(const std::string& posi)
{
	m_paramMng->setDevicePosition(posi);
	return 0;
}

int Backstage::getRs485Cfg()
{
	if(m_paramMng->getRs485Cfg() == -1){
		if(m_paramMng->getAccessController() >= 0){return 1;}	//协议1
		else if(m_paramMng->getPassCheckByRs485()){return 2;}	//协议2
		return 0;												//禁用
	}
	return m_paramMng->getRs485Cfg();
}

int Backstage::setRs485Cfg(int cfg)
{
	#if 0
	switch (cfg){
	    case 0:{m_paramMng->setAccessController(-1);m_paramMng->setPassCheckByRs485(false);}break;
	    case 1:{m_paramMng->setPassCheckByRs485(false);m_paramMng->setAccessController(0);}break;//协议1：门禁控制器
	    case 2:{m_paramMng->setPassCheckByRs485(true);m_paramMng->setAccessController(-1);}break;//协议2：闸机信号反馈
	    default:LOGE("rs485 cfg error!");break;
	}
	#else
	m_paramMng->setRs485Cfg(cfg);
	#endif
	return 0;
}

int Backstage::setReverseAccessSw(bool enabled) {
    int ret = -1;
    if (m_paramMng != nullptr) {
        m_paramMng->setReverseAccessSw(enabled);
        ret = 0;
    }
    return ret;
}

bool Backstage::getReverseAccessSw() const {
    bool ret = false;
    if (m_paramMng != nullptr) {
        ret = m_paramMng->getReverseAccessSw();
    }
    return ret;
}

int Backstage::getRs485Prot1Addr()
{
	return m_paramMng->getAccessController();
}

int Backstage::setRs485Prot1Addr(int addr)
{
	if(addr < 0 || addr > 255){return -1;}
	m_paramMng->setAccessController(addr);return 0;
}

int Backstage::getRs485Prot3Cfg(int& handCfg, int& feetCfg)
{
	handCfg = m_paramMng->getStaticHandCfg();
	feetCfg = m_paramMng->getStaticFeetCfg();
	return 0;	
}

int Backstage::setRs485Prot3Cfg(int handCfg, int feetCfg)
{
	m_paramMng->setStaticHandCfg(handCfg);
	m_paramMng->setStaticFeetCfg(feetCfg);
	return 0;
}

int Backstage::getGPIOCfg()
{
	//return m_paramMng->getGpio4Sw() ? m_paramMng->getGpio4Use() + 1 : 0;
	return 0;
}

int Backstage::setGPIOCfg(int cfg)
{
#if 0
	switch (cfg){
	    case 0:{m_paramMng->setGpio4Sw(false);}break;//禁用
	    case 1:{m_paramMng->setGpio4Sw(true);m_paramMng->setGpio4Use(0);}break;//开门信号上报（门磁）
		default:LOGE("gpio cfg error!");break;
	}
#endif
	return 0;
}

int Backstage::getIDFaceVerifySw()
{
	return m_paramMng->getFaceIDVerifySw();
}

int Backstage::setIDFaceVerifySw(bool sw)
{
	m_paramMng->setFaceIDVerifySw(sw);
	return 0;
}

int Backstage::getBtLockCfg(BtDoorLock& cfg)
{
	cfg.isEnable = m_paramMng->getBleLockSw();

    int manu[5] = {0};
    std::string manuS = m_paramMng->getBleManu();
    sscanf(manuS.c_str(), "%d,%d,%d,%d,%d", manu, manu+1, manu+2, manu+3, manu+4);

	char name[5][128] = {0};
    std::string nameS = m_paramMng->getBleName();
    sscanf(nameS.c_str(), "%[^,],%[^,],%[^,],%[^,],%s", name[0], name[1], name[2], name[3], name[4]);

	char mac[5][20] = {0};
    std::string macS = m_paramMng->getBleMac();
    sscanf(macS.c_str(), "%[^,],%[^,],%[^,],%[^,],%s", mac[0], mac[1], mac[2], mac[3], mac[4]);
	
    for(cfg.qty = 0; cfg.qty < 5 && manu[cfg.qty] > 0; cfg.qty++)
    {
        LOGD("manu[%d]=%d", cfg.qty, manu[cfg.qty]);
		cfg.manufacturer.emplace_back(manu[cfg.qty]);

		LOGD("name[%d]=%s", cfg.qty, name[cfg.qty]);
		cfg.position.emplace_back(name[cfg.qty]);
		
		LOGD("mac[%d]=%s", cfg.qty, mac[cfg.qty]);
		cfg.mac.emplace_back(mac[cfg.qty]);
    }
	return 0;
}

int Backstage::setBtLockCfg(const BtDoorLock& cfg)
{
	LOGI("setBtLockCfg");

	blueToothMng::getInstance().clearBleLock();
	
	std::string bleManu;
    std::string bleName;
    std::string bleId;
	for(int i=0; i<cfg.qty; i++){
	    #define PACKAGE_SEPARATOR(s) (s.empty() ? utils::to_string("") : utils::to_string(","))

        bleManu = bleManu + PACKAGE_SEPARATOR(bleManu) + utils::to_string(cfg.manufacturer.at(i));
        bleName = bleName + PACKAGE_SEPARATOR(bleName) + cfg.position.at(i);
        bleId = bleId + PACKAGE_SEPARATOR(bleId) + cfg.mac.at(i);
	}
    LOGD("bleManu==%s", bleManu.c_str());
    LOGD("bleName==%s", bleName.c_str());
    LOGD("bleId==%s", bleId.c_str());
    m_paramMng->setBleManu(bleManu.c_str());
    m_paramMng->setBleName(bleName.c_str());
    m_paramMng->setBleMac(bleId.c_str());
	m_paramMng->setBleLockSw(cfg.isEnable);
	return 0;
}

int Backstage::getBtLockRemainingBatPwr(const std::string& mac)
{
	return blueToothMng::getInstance().getElecValue(blueToothMng::enBleLockManu::BYX, mac.c_str()); 
}

bool Backstage::getHealthCodeSw()
{
	return m_paramMng->getHealthCodeSw();
}

int Backstage::setHealthCodeSw(bool sw)
{
	m_paramMng->setHealthCodeSw(sw);
	if(sw){
		m_paramMng->setRecoSw(true);
		m_paramMng->setFaceIDVerifySw(true);
	}
	return 0;
}

bool Backstage::getHealthCodeNoFaceRequired(){
	return m_paramMng->getHealthNoFaceRequired();
}

int Backstage::setHealthCodeNoFaceRequired(bool sw){
	m_paramMng->setHealthNoFaceRequired(sw);
	return 0;
}

bool Backstage::getHealthCodeAllowStranger()
{
	return m_paramMng->getHealthCodeAllowStrangerSw();
}

int Backstage::setHealthCodeAllowStranger(bool sw)
{
	m_paramMng->setHealthCodeAllowStrangerSw(sw);
	return 0;
}

int Backstage::getHealthCodePassCfg(int& codeColorCfg, int& c19tCfg, int& tripCfg, int& abtCfg)
{
	codeColorCfg = m_paramMng->getHealthCodeColorPassCfg();
	c19tCfg = m_paramMng->getHealthC19TResPassCfg();
	tripCfg = m_paramMng->getHealthTripResPassCfg();
	abtCfg = m_paramMng->getHealthAbtResPassCfg();
	return 0;
}

int Backstage::setHealthCodePassCfg(int codeColorCfg, int c19tCfg, int tripCfg, int abtCfg)
{
	m_paramMng->setHealthCodeColorPassCfg(codeColorCfg);
	m_paramMng->setHealthC19TResPassCfg(c19tCfg);
	m_paramMng->setHealthTripResPassCfg(tripCfg);
	m_paramMng->setHealthAbtResPassCfg(abtCfg);
	return 0;
}

std::string Backstage::utfRawStrToEncodeStr(const std::string &str) {
    return utils::utfRawStrToEncodeStr(str);
}

int Backstage::udpLoopToSvr(const std::string &sendData)
{
	int udpFd = socket(AF_INET, SOCK_DGRAM, 0);
    if (udpFd < 0){
        LOGE("create socket fail!");
    }

    timeval tv = {1, 0};
    int ret = setsockopt(udpFd, SOL_SOCKET, SO_RCVTIMEO, (char*)&tv, sizeof(timeval));
    if (ret){
		LOGE("setsockopt failed");
        ::close(udpFd);
        udpFd = -1;
    }
	struct sockaddr_in sin;
    bzero(&sin, sizeof(sin));
    sin.sin_family = AF_INET;
	sin.sin_addr.s_addr = htonl(INADDR_ANY);
    sin.sin_port = htons(6790);
    sendto(udpFd, sendData.c_str(), sendData.length(), 0, (struct sockaddr *)&sin, sizeof(struct sockaddr));
	LOGI("udp send:%s", sendData.c_str());
	::close(udpFd);
	return 0;
}