myvtm/Module/mod_ResourceWatcher/ResourceWatcherFSM.cpp

#include "stdafx.h"
#include "ResourceWatcherFSM.h"
#include "DeviceBaseClass.h"
#include <string.h>
#include <string> 
#include <assert.h>
#include <algorithm>
#include "fileutil.h"
#include <ctime>
#include "CommEntityUtil.hpp"
#include <stdio.h>
#include <stdlib.h>
#include "ResourceWatcher_UserCode.h"

#ifdef RVC_OS_LINUX
#include <vector>
#include <dirent.h>
#include <sstream>  
#include <fstream> 
#include <iostream> 
#include "publicFunExport.h"
#include "toolkit.h"
#include "iniutil.h"
#include "osutil.h"
#include "SpUtility.h"
#include "RestfulFunc.h"
#else
#include <intrin.h>
#include <ShlObj.h>
#include <ShellAPI.h>
#include <Pdh.h>
#include <io.h>
#include <direct.h>
#include "memutil.h"
#include "array.h"
#include <Windows.h>
#include <wintrust.h>  
#include <direct.h>
#include <Mscat.h>
#include <Softpub.h>  
#include <wlanapi.h>
#include <Netlistmgr.h>  //网络检测添加
#include <psapi.h>  
#include <tlhelp32.h> 
#include "Mmdeviceapi.h"
#include "PolicyConfig.h"
#include "Propidl.h"
#include "Functiondiscoverykeys_devpkey.h"
#include "NetConfigCommon.h"
#include "NetworkInfo.h"
#include "NetworkProbe.h"
#include "MbnEventImpl.h"
#pragma comment(lib, "pdh.lib")
#pragma comment(lib,"winmm.lib" )
#pragma comment(lib, "shell32.lib")
#pragma comment(lib, "Wintrust.lib")   
#pragma comment(lib, "crypt32.lib")
#pragma comment(lib, "wlanapi.lib")
#endif

//硬件信息搜集参数  
#define DEFAULT_HARDWARE_CHECK_TIME 60 * 1000 //CPU、内存扫描默认间隔，1分钟
#define TIMER_HARDWARE_CHECK 2
//硬盘扫描
#define DEFAULT_DISK_CHECK_TIME 4 * 60 * 60 * 1000 //硬盘默认4小时扫描一次
#define TIMER_DISK_CHECK 3
//保留版本数目
#define DEFAULT_VERSION_SAVED_COUNT 2
#define MAX_VERSION_PATH 256

const int MAX_DAY_OF_BACKWARD = 365;
const char* DEFAULT_DELETE_FILE_SUFFIX = "*";
LPCTSTR UPLOAD_VIDEO_PATH = "UploadVideo";

CRITICAL_SECTION g_csVideoMoreClear;

const int AD0_DAY_OF_BACKWARD = 7;
const int TIMER_INTERVAL_CLEARVIDEO_ENHANCE = 60 * 1000;

#ifdef RVC_OS_LINUX
#define PROCESS_ITEM 14 //进程CPU信息读取位置参数
const int MAX_MAINLINK_CHECK_TIME = 5000;
const int TIMER_MAINLINK_CHECK = 4;
#else
const int TIMER_ID_CLEARVIDEO_ENHANCE = 1;
const int THOUSAND = 1024;
const int MILLION = 1048576;
#endif // RVC_OS_LINUX
static int hardwareCheckTime = 60 * 1000;  //初始化硬件检测间隔
static int hardwareCheckFlag = 1;
static int cpuWarnTime = 0;
static int cpuWarnThreshold = 10;
static int memWarnTime = 0;
static int memWarnThreshold = 10;    //初始化CUP、内存告警阈值次数
static int diskCheckTime = 4 * 60 * 60 * 1000; //初始化硬盘检测间隔
static int diskCheckFlag = 1;

#define MAX_VOLUME_COUNT 26
#define BUFSIZE 512
static BOOL sBDiskValStatus[MAX_VOLUME_COUNT + 1] = { FALSE };

#define MAX_SUBFILES_COUNT 1000

#define DIV (1024 * 1024)
#define DAY_DIV (24 * 60 * 60)
#define HOURS_DIV (60 * 60)
#define MINUS_DIV (60)

const char* SystemElapsedQuery = "\\System\\System Up Time";

#ifndef RVC_OS_LINUX
#define ENCODING (X509_ASN_ENCODING | PKCS_7_ASN_ENCODING) 
#define SafeDeleteArraySize(pData) { if(pData){delete []pData;pData=NULL;} }  
#endif // !RVC_OS_LINUX

template<class T>
class TimerOutHelper : public ITimerListener
{
public:
    typedef void (T::* FuncTimer)(void* pUserdata);

    TimerOutHelper(T* p, FuncTimer pTimerFunc, void* pData, bool bDeleteSelf = false)
        : m_pObject(p), m_pUserData(pData), m_pTimer(pTimerFunc), m_bDeleteSelf(bDeleteSelf)
    {
    }

    virtual void OnTimeout(DWORD dwTimerID)
    {
        (m_pObject->*m_pTimer)(m_pUserData);
        if (m_bDeleteSelf)
            delete this;
    }
private:
    void* m_pUserData;
    T* m_pObject;
    FuncTimer m_pTimer;
    bool m_bDeleteSelf;
};

#ifdef RVC_OS_WIN
ResourceWatcherFSM::ResourceWatcherFSM(void)
    :m_IsPadDevice(FALSE),
    m_csUploadVideoPath(true),
    m_nDayOfBackward(DEFAULT_DAY_OF_BACKWARD),
    m_bReadyFlag(false),
    m_bVideoClearReady(false),
    m_nMinSavedDay(DEFAULT_SAVE_DATE_COUNT),
    m_strTerminalNo(true),
    m_bFirstRunAfterBoot(FALSE),
    m_csDelFileSuffix(true),
    m_failDelCnt(0),
    m_cpuTop(0)
{
    m_iNonSignedTotal = 0;
    m_xIdlePre = 0;
    m_xKernelPre = 0;
    m_xUserPre = 0;
    m_bNeedForceDiskCheck = false;
    m_DoneDetectAutostart = true;
    mUiRequireBytes.QuadPart = 0ui64;
    mUiCalibration.QuadPart = 0ui64;
}
#endif // RVC_OS_WIN

ResourceWatcherFSM::~ResourceWatcherFSM(void)
{
}

#ifdef RVC_OS_LINUX
void ResourceWatcherFSM::ClearVideoQueue()
{
    while (!m_VideoFiles.empty()) {
        TmpFileInfo* pNodeInfo = m_VideoFiles.top();
        m_VideoFiles.pop();
        if (pNodeInfo != NULL) {
            delete pNodeInfo;
        }
    }

    memset(mszMaxSizeFilePath, 0, sizeof(mszMaxSizeFilePath));

    mAllVideoFileSizeCal = 0;
    mMaxFileSize = 0;
    mUiRequireBytes = 0;
    VideoDailyRecord.clear();
}

void ResourceWatcherFSM::PrintVideEmurateResult()
{
    char szResult[DEFAULT_OUTPUT_FORMAT_SIZE];
    ByteSprintf(szResult, (double)mMaxFileSize);
    DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Max Video file: %s size: %s", mszMaxSizeFilePath, szResult);
    DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("mAllVideoFileSizeCal : %llu Bytes", mAllVideoFileSizeCal);
    ByteSprintf(szResult, (double)mAllVideoFileSizeCal);
    DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Totally(size: %d) directory size: %s", m_VideoFiles.size(), szResult);
}

#else

void ResourceWatcherFSM::ClearVideoQueue()
{
    while (!m_VideoFiles.empty()) {
        TmpFileInfo* pNodeInfo = m_VideoFiles.top();
        m_VideoFiles.pop();
        if (pNodeInfo != NULL) {
            delete pNodeInfo;
        }
    }

    memset(mszMaxSizeFilePath, 0, sizeof(mszMaxSizeFilePath));

    mAllVideoFileSizeCal.QuadPart = 0ui64;
    mMaxFileSize.QuadPart = 0ui64;
    mUiRequireBytes.QuadPart = 0ui64;
    VideoDailyRecord.clear();
}

#endif // RVC_OS_LINUX

void ResourceWatcherFSM::s0_on_entry()
{
    LOG_FUNCTION();
#if defined(RVC_OS_WIN)
	this->PostEventFIFO(new RunEvent());
	BOOL fInstallBySetup(FALSE);
	ErrorCodeEnum rc = DetectVTMInstalledBySetup(fInstallBySetup);
	if (Error_Succeed == rc && !fInstallBySetup) {
		GetEntityBase()->GetFunction()->PostThreadPoolTask(new CreateLinkTask(this));
	}
	else {
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("detect install type return %s, setup type: %d", SpStrError(rc), fInstallBySetup);
	}
#endif //RVC_OS_WIN
}

unsigned int ResourceWatcherFSM::s0_on_event(FSMEvent* e)
{
    LOG_FUNCTION();
    unsigned int unRes = 0;
    switch (e->iEvt)
    {
    case USER_EVT_RUN:
    {
#ifdef RVC_OS_LINUX
        RunTask* videoTask = new RunTask(this);
        videoTask->SetFlag(m_bReadyFlag ? 1 : 0);
        GetEntityBase()->GetFunction()->PostThreadPoolTask(videoTask);
#else
        ClearVideoFilesTask* videoTask = new ClearVideoFilesTask(this);
        videoTask->SetFlag(m_bReadyFlag ? 1 : 0);
        GetEntityBase()->GetFunction()->PostThreadPoolTask(videoTask);
        ClearAd0Task* ad0Task = new ClearAd0Task(this);
        GetEntityBase()->GetFunction()->PostThreadPoolTask(ad0Task);
#endif // RVC_OS_LINUX
        e->SetHandled();
    }
    break;
    default:
    {
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Unexpecetd Event(%d)", e->iEvt);
    }
    break;
    }
    return unRes;
}

void ResourceWatcherFSM::s0_on_exit()
{

}

void ResourceWatcherFSM::s1_on_entry()
{
    LOG_FUNCTION();
}

unsigned int ResourceWatcherFSM::s1_on_event(FSMEvent* e)
{
    LOG_FUNCTION();
    unsigned int unRes = 0;
    switch (e->iEvt)
    {
    case USER_EVT_CLEAR_UPLOADEDVIDEOFILES_FINISHED:
    {
        DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%s::There are %d file(s), successfully delete %d file(s) in path %s", __FUNCTION__,
            e->param2, e->param1, (LPCTSTR)m_csUploadVideoPath);
        if (m_failDelCnt != 0)
        {
            CSimpleStringA strMsg = CSimpleStringA::Format("There are %d matched files should be deleted", m_failDelCnt);
            LogWarn(Severity_Middle, Error_Unexpect, 0, (LPCTSTR)strMsg);
        }
        ClearVideoFilesEnhanceTask* task = new ClearVideoFilesEnhanceTask(this);
        GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
    }
    e->SetHandled();
    break;
#ifndef RVC_OS_LINUX
    case EVT_TIMER:
    {
        if (e->param1 == TIMER_ID_CLEARVIDEO_ENHANCE)
        {
            ClearVideoFilesEnhanceTask* task = new ClearVideoFilesEnhanceTask(this);
            GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
        }
    }
    e->SetHandled();
    break;
#endif // !RVC_OS_LINUX
    case USER_EVT_CLEAR_VIDEOFILE_ENHANCE_FINISHED:
        e->SetHandled();
        break;
    case USER_EVT_VERSION_CLEAR_FINISHED:
        e->SetHandled();
        break;
    default:
    {
        DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Unexpecetd Event(%d)", e->iEvt);
    }
    break;
    }
    return unRes;
}

void ResourceWatcherFSM::s1_on_exit()
{
}

void ResourceWatcherFSM::s2_on_entry()
{
    LOG_FUNCTION();
}

unsigned int ResourceWatcherFSM::s2_on_event(FSMEvent* e)
{
    LOG_FUNCTION();
    unsigned int unRes = 0;
    switch (e->iEvt)
    {
    case USER_EVT_RUN:
    {
        e->SetHandled();
    }
    break;
#ifndef RVC_OS_LINUX
    case EVT_TIMER:
    {
        if (e->param1 == TIMER_ID_CLEARVIDEO_ENHANCE)
        {
            ClearVideoFilesEnhanceTask* task = new ClearVideoFilesEnhanceTask(this);
            GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
        }
    }
    e->SetHandled();
    break;
#endif // !RVC_OS_LINUX
    case USER_EVT_CLEAR_VIDEOFILE_ENHANCE_FINISHED:
    {
    }
    e->SetHandled();
    break;
    }

    return unRes;
}

void ResourceWatcherFSM::s2_on_exit()
{
}

void ResourceWatcherFSM::s3_on_entry()
{
    LOG_FUNCTION();
    m_bVideoClearReady = true;
}

unsigned int ResourceWatcherFSM::s3_on_event(FSMEvent* e)
{
    unsigned int unRes = 0;
    switch (e->iEvt)
    {
    case USER_EVT_RUN:
    {
        e->SetHandled();
    }
    break;
#ifndef RVC_OS_LINUX
    case EVT_TIMER:
    {
        if (e->param1 == TIMER_ID_CLEARVIDEO_ENHANCE)
        {
            ClearVideoFilesEnhanceTask* task = new ClearVideoFilesEnhanceTask(this);
            GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
        }
    }
    e->SetHandled();
    break;
#endif // !RVC_OS_LINUX
    case USER_EVT_CLEAR_VIDEOFILE_ENHANCE:
    {
        ClearVideoFilesEnhanceTask* task = new ClearVideoFilesEnhanceTask(this);
        GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
    }
    e->SetHandled();
    break;
    case USER_EVT_CLEAR_VIDEOFILE_ENHANCE_FINISHED:
    {
    }
    e->SetHandled();
    break;
    }
    return unRes;
}

void ResourceWatcherFSM::s3_on_exit()
{
    m_bVideoClearReady = false;
}

#ifdef RVC_OS_LINUX
bool ResourceWatcherFSM::GetMonitorInfo(CSimpleStringA& outInfo)
{
    std::string sucContent, failedContent;
    CSimpleStringA strCmd("xrandr | grep \" connected\" | sed -e \"s/\([A-Z0-9]\+\) connected.*/\1/\"");
    bool ret = SP::Module::Util::ShellExecute(strCmd.GetData(), sucContent, failedContent);
    DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("{%s}:{%s}{%s}", strCmd.GetData(), sucContent.c_str(), failedContent.c_str());
    std::string msg = SP::Utility::ToTrim(sucContent);
    SP::Utility::replaceInPlace(msg, "\n", "|");
    outInfo = msg.c_str();
    return ret;
}
#endif // RVC_OS_LINUX

void ResourceWatcherFSM::readVideoStorePath()
{
    CSmartPointer<IConfigInfo> spCtSettingConfig;
    GetEntityBase()->GetFunction()->OpenConfig(Config_CenterSetting, spCtSettingConfig);
    // From CenterSetting --Josephus at 10:02:10 201759
    spCtSettingConfig->ReadConfigValueInt(GetEntityBase()->GetEntityName(), "BackwardDays", m_nDayOfBackward);
    if (m_nDayOfBackward <= 0) {
        m_nDayOfBackward = 90;
    }
    else
    {
        DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Detect BackwardDays from CentralSetting %d", m_nDayOfBackward);
    }

    if (m_nDayOfBackward <= 0 || m_nDayOfBackward > MAX_DAY_OF_BACKWARD) {
        DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Detect BackwardDays(%d) is illegal and Set default %d", m_nDayOfBackward, DEFAULT_DAY_OF_BACKWARD);
        m_nDayOfBackward = DEFAULT_DAY_OF_BACKWARD;
    }

    int minSavedDay = 0;
    spCtSettingConfig->ReadConfigValueInt(GetEntityBase()->GetEntityName(), "MinSavedDays", minSavedDay);
    if (minSavedDay >= 1 && minSavedDay < DEFAULT_SAVE_DATE_COUNT) {
        m_nMinSavedDay = minSavedDay;
        DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Detect MinSavedDays from CentralSetting %d", m_nMinSavedDay);
    }
}

void ResourceWatcherFSM::TriggerAtStatusChanged(bool bMStatus)
{
    if (firstMpage)
    {
        firstMpage = false;

        CSmartPointer<IConfigInfo> spRunConfig;
        CSmartPointer<IConfigInfo> spCtSettingConfig;
        GetEntityBase()->GetFunction()->OpenConfig(Config_Run, spRunConfig);
        GetEntityBase()->GetFunction()->OpenConfig(Config_CenterSetting, spCtSettingConfig);
        spCtSettingConfig->ReadConfigValueInt("ResourceWatcher", "HardwareCheckTime", hardwareCheckTime);
        spCtSettingConfig->ReadConfigValueInt("ResourceWatcher", "HardwareCheckFlag", hardwareCheckFlag);
        spCtSettingConfig->ReadConfigValueInt("ResourceWatcher", "DiskCheckTime", diskCheckTime);
        spCtSettingConfig->ReadConfigValueInt("ResourceWatcher", "DiskCheckFlag", diskCheckFlag);
        spCtSettingConfig->ReadConfigValueInt("ResourceWatcher", "CpuTooHighPercent", m_cpuHighPercent);
        spCtSettingConfig->ReadConfigValueInt("ResourceWatcher", "CpuWarnThreshold", cpuWarnThreshold);
        spCtSettingConfig->ReadConfigValueInt("ResourceWatcher", "MemoryTooHighPercent", m_memHighPercent);
        spCtSettingConfig->ReadConfigValueInt("ResourceWatcher", "MemWarnThreshold", memWarnThreshold);
        spCtSettingConfig->ReadConfigValueInt("ResourceWatcher", "HardDiskTooHighPercent", m_diskHighPercent);
        spCtSettingConfig->ReadConfigValueInt(m_pEntity->GetEntityName(), "VerifySignature", m_iVerify);

#if defined(RVC_OS_WIN)
        if (m_iVerify == 1) {//文件签名校验
            DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Verify digitsign...");
            VerifyDigitSignTask* task = new VerifyDigitSignTask(this);
            GetEntityBase()->GetFunction()->PostThreadPoolTask(task);
        }

        if (IsHasSetAutoStartupByFolder()) {
            /**  因为安装时已经设置为开机自启动了，所以要把注册表的开机自启动取消掉（如果有） Gifur@20221017]*/
            m_forceStartupWithExeFlag = 3;
        }
        else {
            InitialAutoStartupSetType();
        }
#endif //RVC_OS_WIN

        if (hardwareCheckTime <= 0) { //非法数值情况下设置为默认一分钟
            hardwareCheckTime = DEFAULT_HARDWARE_CHECK_TIME;
        }
        void* pTmpData = NULL;
        ITimerListener* pListener = new TimerOutHelper<ResourceWatcherFSM>(this, &ResourceWatcherFSM::HardwareInfoTimer, pTmpData);
        GetEntityBase()->GetFunction()->SetTimer(TIMER_HARDWARE_CHECK, pListener, hardwareCheckTime);
        DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Set Hardware Timer!");

        if (diskCheckFlag > 0) {
            GetSystemDiskStatus(); //仅启动时检测一次硬盘状态即可
        }

        if (diskCheckTime <= 0) {
            diskCheckTime = DEFAULT_DISK_CHECK_TIME;
        }
        void* pTmpData2 = NULL;
        ITimerListener* pListener2 = new TimerOutHelper<ResourceWatcherFSM>(this, &ResourceWatcherFSM::DiskCheckTimer, pTmpData2);
        GetEntityBase()->GetFunction()->SetTimer(TIMER_DISK_CHECK, pListener2, diskCheckTime);
        DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Set DISK CHECK Timer!");

        DeleteFileTask* deleteFilesTask = new DeleteFileTask(this);
        GetEntityBase()->GetFunction()->PostThreadPoolTask(deleteFilesTask);

#if defined(RVC_OS_LINUX)
        if (m_bFirstRunAfterBoot) {
            UINT sysVer = 0;
            UploadSysVersionInfo(sysVer);
            ConfirmWindowEffectHasBeenOpen();
            DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("fetch os version: %u", sysVer);
            if (1031 < sysVer) {
                ConfirmDDEClipboardDisable();
                ConfirmNotificationCenterDisable();
            }
            else {
                RecoverDDEClipboardEnable();
            }
            GetEntityBase()->GetFunction()->PostThreadPoolTask(new DetectSoftwareInstallStatusTask(this));
            GetEntityBase()->GetFunction()->PostThreadPoolTask(new UploadMonitorInfoTask(this));
            AlarmSystemBasicInfo();
        }
#endif //RVC_OS_LINUX
    }
}

ErrorCodeEnum ResourceWatcherFSM::OnInit()
{
    firstMpage = true;		//是否首次进入首页

    ErrorCodeEnum erroCode = Error_Succeed;
    DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Complied at: %s %s", __DATE__, __TIME__);
#ifdef WIDE_CONDITION
    setlocale(LC_ALL, "chs");
#endif
    CSmartPointer<IConfigInfo> spRunConfig;
    CSmartPointer<IConfigInfo> spCtSettingConfig;
    GetEntityBase()->GetFunction()->OpenConfig(Config_Run, spRunConfig);
    GetEntityBase()->GetFunction()->OpenConfig(Config_CenterSetting, spCtSettingConfig);
    erroCode = GetEntityBase()->GetFunction()->GetSystemStaticInfo(m_RvcSysinfo);
    m_strTerminalNo = m_RvcSysinfo.strTerminalID;
    if (m_RvcSysinfo.strMachineType.Compare("RVC.Pad", true)) {
        m_IsPadDevice = FALSE;
    }

    readVideoStorePath();
    erroCode = GetEntityBase()->GetFunction()->GetPath("LocalVideo", m_csUploadVideoPath);
    if (m_csUploadVideoPath.GetLength() > 0) {
        DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)(m_csUploadVideoPath.GetData());
        m_bReadyFlag = true;
    }
    else
    {
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("GetPath returned empty string.");
        return Error_NotInit;
    }

    erroCode = spCtSettingConfig->ReadConfigValueInt("TOPProcess", "cpu", m_cpuTop);    //读取需要监控的CPU进程个数
    if (erroCode != Error_Succeed) {
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Get CPU TOP NUM failed: %s.", SpStrError(erroCode));
    }
    if (m_cpuTop == 0) {
        m_cpuTop = 10; //From static config
    }
    else if (m_cpuTop == -1) {
        DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("No need for TOP PROCESS!");
        m_cpuTop = 0;
    }

    m_bReadyFlag = IsNeedToFirstClear();
    DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Retrieve uploadedVideo path[%s], backwardDays(%d) done(%d)",
        (LPCTSTR)m_csUploadVideoPath, m_nDayOfBackward, !m_bReadyFlag);

    m_bFirstRunAfterBoot = DetectIsFirstRunAtBoot();
    if (m_bFirstRunAfterBoot) {
        DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("First time to run after system boot.");
#if defined(RVC_OS_WIN)
        m_DoneDetectAutostart = false;
#endif //RVC_OS_WIN
    }
    InitializeCriticalSection(&g_csVideoMoreClear);

    if (m_bFirstRunAfterBoot) {
#if defined(RVC_OS_WIN)
        DetectDestopFileAndWarn();
		//GetSystemMetrics (SM_CMONITORS) 计数仅显示可见的显示器
		const int screenNums = GetSystemMetrics(SM_CMONITORS);
		const int aimScreenNums4Stand2S = 2;
		const int aimScreenNums4Other = 1;
		if (0 == m_RvcSysinfo.strMachineType.Compare("RVC.Stand2S", true) && screenNums != aimScreenNums4Stand2S) {
			LogWarn(Severity_Low, Error_Unexpect, LOG_RESOURCEWATCHER_LACK_OF_MONITOR
				, CSimpleStringA::Format("{\"subject\":\"screen_count\",\"machine_type\":\"%s\",\"expect\":%d,\"actual\":%d}"
                    , m_RvcSysinfo.strMachineType.GetData(), aimScreenNums4Stand2S, screenNums));
        }
        else if (0 != m_RvcSysinfo.strMachineType.Compare("RVC.Stand2S", true) && screenNums != aimScreenNums4Other) {
			LogWarn(Severity_Low, Error_Unexpect, LOG_RESOURCEWATCHER_LACK_OF_MONITOR
				, CSimpleStringA::Format("{\"subject\":\"screen_count\",\"machine_type\":\"%s\",\"expect\":%d,\"actual\":%d}"
					, m_RvcSysinfo.strMachineType.GetData(), aimScreenNums4Other, screenNums));
        }
#endif //RVC_OS_WIN
    }
    spCtSettingConfig->ReadConfigValueInt(m_pEntity->GetEntityName(), "DisplayCnt", m_iNonSignedDisplay);
    if (m_iNonSignedDisplay <= 0)
        m_iNonSignedDisplay = 10;

    spRunConfig->ReadConfigValueInt("WarnRecord", "disk", m_diskLastWarnHour);
    return Error_Succeed;
}

ErrorCodeEnum ResourceWatcherFSM::OnExit()
{
#ifdef RVC_OS_LINUX
    GetEntityBase()->GetFunction()->KillTimer(TIMER_HARDWARE_CHECK);
#endif // RVC_OS_LINUX
    ClearVideoQueue();
    DeleteCriticalSection(&g_csVideoMoreClear);
    return Error_Succeed;
}

void ResourceWatcherFSM::AfterInit()
{
}

#ifdef RVC_OS_LINUX
void ResourceWatcherFSM::AppendVideoSizeTogether()
{
    DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Add UploadFile size together...");
    unsigned long long uiAdditionBytes;
    CalculateWillUploadDirSize(uiAdditionBytes);
    mAllVideoFileSizeCal += uiAdditionBytes;
    diskInfo.SetUploadVideoDirSize(uiAdditionBytes);
}

void ResourceWatcherFSM::CalculateFreeDiskNeeded()
{
    const_map_cu_iter citer = VideoDailyRecord.cbegin();
    UINT uCount = 0;
    while (citer != VideoDailyRecord.cend()) {
        DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("date[%d]: %d", (citer->first), citer->second);
        uCount += citer->second;
        citer++;
    }
    DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("count %d and video file size#%d", uCount, m_VideoFiles.size());
    diskInfo.CalAverRequreSpaceEachDay(mAllVideoFileSizeCal,
        uCount, VideoDailyRecord.size(),
        BASE_AVAILALBE_DATE_COUNT, mUiRequireBytes);
}

void ResourceWatcherFSM::RecordFreeDiskNeededToRunCfg()
{
    CSmartPointer<IConfigInfo> spConfigRun;
    GetEntityBase()->GetFunction()->OpenConfig(Config_Run, spConfigRun);
    spConfigRun->WriteConfigValueHexInt("Video", "RequiredBytes", mUiRequireBytes);
    spConfigRun->WriteConfigValue("LastClearTime", "Video", (const char*)CSimpleStringA::Format("0x%08X", (DWORD)CSmallDateTime::GetNow()));
    m_bReadyFlag = false;
}

void ResourceWatcherFSM::GetFreeDiskNeededFromRunCfg()
{
    CSmartPointer<IConfigInfo> spConfigRun;
    GetEntityBase()->GetFunction()->OpenConfig(Config_Run, spConfigRun);
    UINT64 value(0);
    spConfigRun->ReadConfigValueHexInt("Video", "RequiredBytes", value);
    mUiRequireBytes = value;
    DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Retrieve from runcfg about required bytes: %llu", value);
}
#endif // RVC_OS_LINUX

int ResourceWatcherFSM::CleanVideoFiles(int& newDeletedFilesNum, int initFlag)
{
#ifdef RVC_OS_LINUX
    ClearVideoQueue();
    newDeletedFilesNum = 0;
    CSimpleStringA filePath = m_csUploadVideoPath;
    DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("(InitFlag:%d) filePath %s", initFlag, (LPCTSTR)filePath);
    newDeletedFilesNum = 0;
    m_failDelCnt = 0;
    const int nRet = RemoveExpireVideoFileAndRecord((LPCTSTR)filePath, newDeletedFilesNum, m_failDelCnt, initFlag);
    PrintVideEmurateResult();
    DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("nRet: %d, new Deleted Files Num:%d, video counts:%d", nRet, newDeletedFilesNum, m_VideoFiles.size());
    LOG_ASSERT(nRet - newDeletedFilesNum == m_VideoFiles.size());

    if (!!initFlag) {
        AppendVideoSizeTogether();
        CalculateFreeDiskNeeded();
        RecordFreeDiskNeededToRunCfg();
    }
    else {
        GetFreeDiskNeededFromRunCfg();
    }
    return nRet;
#else
    ClearVideoQueue();
    CSimpleStringA filePath = m_csUploadVideoPath + "\\*";
    newDeletedFilesNum = 0;
    m_failDelCnt = 0;
    int nRet = ProcessVideoFile((LPCTSTR)filePath, newDeletedFilesNum, m_failDelCnt, initFlag);
    PrintResult();
    assert(nRet - newDeletedFilesNum == m_VideoFiles.size());

    CSmartPointer<IConfigInfo> spConfigRun;
    GetEntityBase()->GetFunction()->OpenConfig(Config_Run, spConfigRun);

    if (initFlag == 1)
    {
        ULARGE_INTEGER uiAdditionBytes;
        CalCulateUploadFileAddition(uiAdditionBytes);
        mAllVideoFileSizeCal.QuadPart += uiAdditionBytes.QuadPart;
        diskInfo.SetUploadVideoDirSize(uiAdditionBytes);

        const_map_cu_iter citer = VideoDailyRecord.cbegin();
        UINT uCount = 0;
        while (citer != VideoDailyRecord.cend())
        {
            uCount += citer->second;
            citer++;
        }
        DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("uCount#%d, size#%d", uCount, m_VideoFiles.size());

        diskInfo.CalAverRequreSpaceEachDay(mAllVideoFileSizeCal,
            uCount,
            VideoDailyRecord.size(),
            BASE_AVAILALBE_DATE_COUNT,
            mUiRequireBytes);

        FILETIME ftCurTime;
        GetSystemTimeAsFileTime(&ftCurTime);
        SYSTEMTIME stUTC, stLocal;
        FileTimeToSystemTime(&ftCurTime, &stUTC);
        SystemTimeToTzSpecificLocalTime(NULL, &stUTC, &stLocal);
        int nYear = stLocal.wYear;
        int nMonth = stLocal.wMonth;
        int nDay = stLocal.wDay;
        char displayTime[MAX_PATH] = { 0 };
        GetTimeFormatStr(displayTime, MAX_PATH, &ftCurTime);
        CSimpleStringA csRecord = displayTime;
        spConfigRun->WriteConfigValueHexInt("Video", "RequiredBytes", mUiRequireBytes.QuadPart);
        spConfigRun->WriteConfigValueInt("Video", "FilesNum", nRet);
        spConfigRun->WriteConfigValueInt("Video", "Deleted", newDeletedFilesNum);
        spConfigRun->WriteConfigValueInt("Video", "FailedDel", m_failDelCnt);
        spConfigRun->WriteConfigValue("Video", "LastTime", csRecord);
        spConfigRun->WriteConfigValueInt("Video", "Year", nYear);
        spConfigRun->WriteConfigValueInt("Video", "Month", nMonth);
        spConfigRun->WriteConfigValueInt("Video", "Day", nDay);
        m_bReadyFlag = false;

    }
    else
    {
        ErrorCodeEnum erroCode = spConfigRun->ReadConfigValueHexInt("Video", "RequiredBytes",
            mUiRequireBytes.QuadPart);
        if (erroCode != Error_Succeed)
        {
            LogWarn(Severity_Middle, Error_Unexpect, 0, "Get RequiredBytes failed !");
            mUiRequireBytes.QuadPart = 0ui64;
        }
    }
    return nRet;
#endif // RVC_OS_LINUX
}

#ifdef RVC_OS_LINUX
void ResourceWatcherFSM::CalculateBackTime(time_t* ftResultTime, int days)
{
    time_t ftCurTime = time(NULL);//获取当前时间
    time_t ftBackTime = ftCurTime - (60 * 60 * 24 * days);
    *ftResultTime = ftBackTime;
    return;
}

BOOL ResourceWatcherFSM::CalculateWillUploadDirSize(unsigned long long& uiBytesCal)
{
    uiBytesCal = 0;
    BOOL bRet = FALSE;
    CSimpleStringA uploadVideoPath;
    CSimpleStringA tmpValue;
    ErrorCodeEnum ec = GetEntityBase()->GetFunction()->GetPath(UPLOAD_VIDEO_PATH, uploadVideoPath);
    if (uploadVideoPath.GetLength() <= 0) {
        ec = Error_Param;
    }
    if (ec == Error_Succeed) {
        DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("UploadVideo path: %s", (LPCTSTR)uploadVideoPath);
        uiBytesCal = 0;
        const int nFileCnt = CalculateAllVideoSize(uploadVideoPath, &uiBytesCal);
        char szResult[DEFAULT_OUTPUT_FORMAT_SIZE];
        ByteSprintf(szResult, (double)uiBytesCal);
        DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Result: Files(%d), Size: %s", nFileCnt, szResult);
    }
    return (ec == Error_Succeed);
}

int ResourceWatcherFSM::RemoveExpireVideoFileAndRecord(LPCTSTR dirName, int& deletedFileCnt, int& deleteFailedCnt, const int nFlag)
{
    int fileCnt = 0;
    int fileLength = strlen(dirName);
    // =>=>  /*foundFileData.cFileName[0] != '.'*/ !!! be careful for backdate call for the function.
    char searchFilePath[MAX_PATH] = { 0 };
    char tempFilePath[MAX_PATH] = { 0 };
    char displayTime[MAX_PATH] = { 0 };

    time_t tmp_time;
    CalculateBackTime(&tmp_time, m_nDayOfBackward);
    deletedFileCnt = deleteFailedCnt = 0;
    GetTimeFormatStr(displayTime, MAX_PATH, &tmp_time);
    DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("video backtrace time: %s", displayTime);

    struct stat st;
    if (stat(dirName, &st) < 0 || !S_ISDIR(st.st_mode)) {
        return 0;
    }
    DIR* d = opendir(dirName);
    if (!d) {
        return 0;
    }

    struct dirent* dp = NULL;
    while ((dp = readdir(d)) != NULL) {
        if ((!strcmp(dp->d_name, ".")) || (!strcmp(dp->d_name, ".."))) {
            continue;
        }
        strcpy(tempFilePath, dirName);
        if (strlen(tempFilePath) + strlen(dp->d_name) + 3 >= MAX_PATH) {
            DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("filePath is too long for current.");
            continue;
        }
        strcat(tempFilePath, "/");
        strcat(tempFilePath, dp->d_name);
        if (-1 == stat(tempFilePath, &st)) {
            DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("stat video file: %s error: %d", tempFilePath, errno);
            continue;
        }
        const bool isdir = !!(S_ISDIR(st.st_mode));
        if (isdir) {
            fileCnt += RemoveExpireVideoFileAndRecord((LPCTSTR)tempFilePath, deletedFileCnt, deleteFailedCnt, nFlag);
        }
        else {
            if (nFlag == 1 && st.st_mtime < tmp_time) {
                GetTimeFormatStr(displayTime, MAX_PATH, &st.st_mtime);
                if (RemoveFileA(tempFilePath)) {
                    deletedFileCnt++;
                    DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Delete matched %s(%s) suc.", dp->d_name, displayTime);
                }
                else {
                    deleteFailedCnt++;
                    DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Delete matched %s(%s) failed: %d", dp->d_name, displayTime, errno);
                }
            }
            RecordVideoFileInfomation(tempFilePath, &st);
            fileCnt++;
        }
    }
    closedir(d);
    return fileCnt;
}

void ResourceWatcherFSM::RecordVideoFileInfomation(LPCTSTR lpFilePath, struct stat* pWfdata)
{
    m_VideoFiles.push(new TmpFileInfo(lpFilePath, pWfdata->st_mtime, pWfdata->st_size));
    mAllVideoFileSizeCal += pWfdata->st_size;

    if (mMaxFileSize < pWfdata->st_size) {
        strcpy(mszMaxSizeFilePath, lpFilePath);
        mMaxFileSize = pWfdata->st_size;
    }
    SyncUpdateVideoCreateDaily(&pWfdata->st_mtime, 1);
}
#else

void ResourceWatcherFSM::CalculateBackTime(PFILETIME ftResultTime, int days)
{
    //Contains a 64-bit value representing the number of 100-nanosecond intervals since January 1, 1601 (UTC).
    FILETIME ftCurTime, ftBackTime;
    GetSystemTimeAsFileTime(&ftCurTime);
    ULARGE_INTEGER uliCurTime, uliOffset, uliBackTime;
    uliCurTime.HighPart = ftCurTime.dwHighDateTime;
    uliCurTime.LowPart = ftCurTime.dwLowDateTime;

    if (days > 0)
    {
        uliOffset.QuadPart = UInt32x32To64(days * 24 * 60 * 60, 1e7);
        uliBackTime.QuadPart = uliCurTime.QuadPart - uliOffset.QuadPart;
    }
    else
    {
        uliOffset.QuadPart = UInt32x32To64(-1 * days * 24 * 60 * 60, 1e7);
        uliBackTime.QuadPart = uliCurTime.QuadPart + uliOffset.QuadPart;
    }

    ftBackTime.dwHighDateTime = uliBackTime.HighPart;
    ftBackTime.dwLowDateTime = uliBackTime.LowPart;

    *ftResultTime = ftBackTime;
    return;
}

int ResourceWatcherFSM::ProcessVideoFile(
    LPCTSTR dirName
    , int& deletedFileCnt
    , int& deleteFailedCnt
    , const int nFlag)
{
    int fileCnt = 0;
    int fileLength = strlen(dirName);

    // =>=>  /*foundFileData.cFileName[0] != '.'*/ !!! be careful for backdate call for the function.
    char searchFilePath[MAX_PATH] = { 0 };
    char tempFilePath[MAX_PATH] = { 0 };
    char displayTime[MAX_PATH] = { 0 };

    WIN32_FIND_DATA foundFileData;
    HANDLE hFind;

    FILETIME ftRemoveTime;
    CalculateBackTime(&ftRemoveTime, m_nDayOfBackward);
    GetTimeFormatStr(displayTime, MAX_PATH, &ftRemoveTime);
    DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("The date backward to delete: %s", displayTime);

    hFind = FindFirstFile(dirName, &foundFileData);
    if (hFind == INVALID_HANDLE_VALUE)
    {
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM) ("FindFirstFile failed (%u)", GetLastError());
        return 0;
    }

    if ((foundFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY)
    {
        if (/*foundFileData.cFileName[0] != '.'*/FALSE)
        {
            strcpy_s(tempFilePath, dirName);
            tempFilePath[fileLength - 1] = '\0';
            if (strlen(tempFilePath) + strlen(foundFileData.cFileName) + 3 >= MAX_PATH)
            {
                DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("filePath is too long for current.");
            }
            else
            {
                strcat_s(tempFilePath, foundFileData.cFileName);
                strcat_s(tempFilePath, "\\*");
                fileCnt += ProcessVideoFile((LPCTSTR)tempFilePath, deletedFileCnt, deleteFailedCnt, nFlag);
            }
        }
    }
    else
    {
        strcpy_s(searchFilePath, dirName);
        searchFilePath[fileLength - 1] = '\0';
        strcat_s(searchFilePath, foundFileData.cFileName);

        if (nFlag == 1 && CompareVideoFileTime(&ftRemoveTime, &foundFileData.ftLastWriteTime) >= 0)
        {
            GetTimeFormatStr(displayTime, MAX_PATH, &foundFileData.ftLastWriteTime);
            if (DeleteFile(searchFilePath) != 0)
            {
                deletedFileCnt++;
                DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Delete matched %s(%s) suc.", foundFileData.cFileName, displayTime);
            }
            else
            {
                deleteFailedCnt++;
                DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Delete matched %s(%s) failed(%d).", foundFileData.cFileName, displayTime, GetLastError());

                CalCulateFileInfo(searchFilePath, &foundFileData);
            }
        }
        else
        {
            CalCulateFileInfo(searchFilePath, &foundFileData);
        }
        fileCnt++;
    }

    while (FindNextFile(hFind, &foundFileData))
    {
        if ((foundFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY)
        {
            if (/*foundFileData.cFileName[0] != '.'*/FALSE)
            {
                strcpy_s(tempFilePath, dirName);
                tempFilePath[fileLength - 1] = '\0';
                strcat_s(tempFilePath, foundFileData.cFileName);
                strcat_s(tempFilePath, "\\*");
                fileCnt += ProcessVideoFile((LPCTSTR)tempFilePath, deletedFileCnt, deleteFailedCnt, nFlag);
            }
        }
        else
        {
            strcpy_s(searchFilePath, dirName);
            searchFilePath[fileLength - 1] = '\0';
            strcat_s(searchFilePath, foundFileData.cFileName);
            if (nFlag == 1 && CompareVideoFileTime(&ftRemoveTime, &foundFileData.ftLastWriteTime) >= 0)
            {
                GetTimeFormatStr(displayTime, MAX_PATH, &foundFileData.ftLastWriteTime);
                if (DeleteFile(searchFilePath) != 0)
                {
                    deletedFileCnt++;
                    DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Delete matched %s(%s) suc.", foundFileData.cFileName, displayTime);
                }
                else
                {
                    deleteFailedCnt++;
                    DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Delete matched %s(%s) failed(%d).",
                        foundFileData.cFileName, displayTime, GetLastError());

                    CalCulateFileInfo(searchFilePath, &foundFileData);
                }
            }
            else
            {
                CalCulateFileInfo(searchFilePath, &foundFileData);
            }
            fileCnt++;
        }
    }

    FindClose(hFind);
    return fileCnt;
}

#endif // RVC_OS_LINUX

void ResourceWatcherFSM::LinkDetect(int detectType, const char* url, bool& status, unsigned int& delay, int warnFlag)
{
    string tUrl = url;
    string host = "http://";

    int flag = 0;
    unsigned int tInterval = 0;

#if defined(RVC_OS_LINUX)
    string msg;
    if (tUrl.find("http") == string::npos) {
        tUrl = host + tUrl;
    }
    DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Check url:[%s].", tUrl.c_str());
    timeval begin, end;
    gettimeofday(&begin, NULL);
    int curFlag = HttpProbe(tUrl, msg, 5);
    gettimeofday(&end, NULL);
    tInterval = (end.tv_sec - begin.tv_sec) * 1000 + (end.tv_usec - begin.tv_usec) / 1000;

    if (curFlag > 0 && curFlag < 400) {
        flag = true;
    }
    else {
        flag = false;
    }
#else
    DWORD start, finish;
    if (tUrl.find("http") == string::npos) {
        tUrl = host + tUrl;
    }
    char tmpUrl[MAX_PATH] = { 0 };
    strcpy_s(tmpUrl, tUrl.c_str());

    start = timeGetTime();
    flag = http_probe(tmpUrl, 5000, 0, warnFlag);
    finish = timeGetTime();

    tInterval = finish - start;
#endif //RVC_OS_LINUX

    if (flag == false) {
        status = false;
    }
    else {
        status = true;
    }

    delay = tInterval;
}

ErrorCodeEnum ResourceWatcherFSM::BizLinkDetect(
    SpReqAnsContext<ResourceWatcherService_BizLinkDetect_Req, ResourceWatcherService_BizLinkDetect_Ans>::Pointer ctx)
{
    LOG_FUNCTION();
    ErrorCodeEnum ec = Error_Succeed;

    int detectType = ctx->Req.protocol;
    CSimpleStringA url = ctx->Req.bizLink;
    bool linkStatus = false;
    unsigned int delay = 0;

    LinkDetect(detectType, url.GetData(), linkStatus, delay);

    ctx->Ans.bizLinkStatus = linkStatus;
    ctx->Ans.bizLinkDelayMS = delay;
    ctx->Ans.intParam = 0;

    CSimpleStringA warn;
    if (!linkStatus) {
        warn = CSimpleStringA::Format("BizLink disconnected[%s].", url.GetData());
    }
    else
    {
        warn = CSimpleStringA::Format("BizLink connected[%s], Delay time [%d]ms.", url.GetData(), delay);
    }
    LogWarn(Severity_Low, Error_Param, LOG_WARN_BIZLINK_CONNECT_CHECK, warn.GetData());
    if (ctx != NULL) {
        ctx->Answer(ec);
    }
    return ec;

}

#if defined(RVC_OS_LINUX)

int ResourceWatcherFSM::RemoveSpecifiedFile(DealFileType fileType, LPCTSTR szFilePath, LPCTSTR szFileName)
{
    CSimpleStringA ssFileName = szFileName;
    if (ssFileName.IsNullOrEmpty()) return FALSE;
    if ((fileType == DFT_CenterSetting && ssFileName.IsStartWith("centersetting", true) && !ssFileName.IsEndWith(".ini", true))
        || fileType == DFT_Ad0
        ) {
        if (RemoveFileA(szFilePath)) {
            DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("%s delete suc.", szFileName);
            return 1;
        }
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("%s delete failed %d.", szFileName, GetLastError());
        return -1;
    }
    return 0;
}

#else

int ResourceWatcherFSM::DoSomethingWith(DealFileType fileType, LPCTSTR szFilePath, LPCTSTR szFileName)
{
    CSimpleStringA ssFileName = szFileName;
    if (ssFileName.GetLength() <= 0)
        return FALSE;
    if ((fileType == DFT_CenterSetting && ssFileName.IsStartWith("centersetting", true) && !ssFileName.IsEndWith(".ini", true))
        ||
        fileType == DFT_Ad0
        ) {
        if (DeleteFileA(szFilePath) != 0) {
            return 1;
        }
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("%s delete failed %d.", szFileName, GetLastError());
        return -1;
    }
    return 0;
}

void ResourceWatcherFSM::CalCulateFileInfo(LPCTSTR lpFilePath, PWIN32_FIND_DATA pWfdata)
{
    m_VideoFiles.push(new TmpFileInfo(lpFilePath,
        &(pWfdata->ftLastWriteTime),
        pWfdata->nFileSizeHigh, pWfdata->nFileSizeLow));

    ULARGE_INTEGER uiTemp;
    uiTemp.HighPart = pWfdata->nFileSizeHigh;
    uiTemp.LowPart = pWfdata->nFileSizeLow;

    mAllVideoFileSizeCal.QuadPart += uiTemp.QuadPart;

    if (mMaxFileSize.QuadPart < uiTemp.QuadPart) {
        strcpy_s(mszMaxSizeFilePath, lpFilePath);
        mMaxFileSize.QuadPart = uiTemp.QuadPart;
    }

    SYSTEMTIME stUTC, stLocal;
    FileTimeToSystemTime(&(pWfdata->ftLastWriteTime), &stUTC);
    SystemTimeToTzSpecificLocalTime(NULL, &stUTC, &stLocal);
    UINT uDate = stLocal.wYear * 10000 + stLocal.wMonth * 100 + stLocal.wDay;
    VideoDailyRecord[uDate]++;
}


#endif //RVC_OS_LINUX

int ResourceWatcherFSM::ClearSpecifieFile(
    DealFileType fileType,
    LPCTSTR dirName,
    int& deletedFileCnt,
    int& deleteFailedCnt)
{
#if defined(RVC_OS_WIN)
    int nRes;
    int nfileCnt = 0;
    int fileLength = strlen(dirName);
    char searchFilePath[MAX_PATH] = { 0 };
    char tempFilePath[MAX_PATH] = { 0 };

    char displayTime[MAX_PATH] = { 0 };

    WIN32_FIND_DATA fndFileData;
    HANDLE hFind;

    hFind = FindFirstFile(dirName, &fndFileData);
    if (hFind == INVALID_HANDLE_VALUE) {
        return -2;
    }

    if ((fndFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY) {
        if (fndFileData.cFileName[0] != '.') {
            memset(tempFilePath, 0, sizeof(tempFilePath));
            strcpy_s(tempFilePath, dirName);
            tempFilePath[fileLength - 1] = '\0';
            if (strlen(tempFilePath) + strlen(fndFileData.cFileName) + 3 >= MAX_PATH) {
                DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("filePath is too long for current.");
            }
            else
            {
                strcat_s(tempFilePath, fndFileData.cFileName);
                strcat_s(tempFilePath, "\\*");
                int nRes = ClearSpecifieFile(fileType, (LPCTSTR)tempFilePath, deletedFileCnt, deleteFailedCnt);
                if (nRes >= 0) nfileCnt += nRes;
            }
        }
    }
    else
    {
        memset((void*)searchFilePath, 0, MAX_PATH);
        strcpy_s(searchFilePath, dirName);
        searchFilePath[fileLength - 1] = '\0';
        strcat_s(searchFilePath, fndFileData.cFileName);
        if (fileType == DFT_Ad0) {
            if (CompareFileTime(&mftAd0RemoveTime, &fndFileData.ftLastWriteTime) >= 0) {
                nRes = DoSomethingWith(fileType, searchFilePath, fndFileData.cFileName);
            }
            else
            {
                nRes = 0;
            }
        }
        else
        {
            nRes = DoSomethingWith(fileType, searchFilePath, fndFileData.cFileName);
        }
        if (nRes == -1) deleteFailedCnt++;
        else if (nRes == 1) deletedFileCnt++;
        nfileCnt++;
    }

    while (FindNextFile(hFind, &fndFileData)) {
        if ((fndFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY) {
            if (fndFileData.cFileName[0] != '.') {
                memset(tempFilePath, 0, sizeof(tempFilePath));
                strcpy_s(tempFilePath, dirName);
                tempFilePath[fileLength - 1] = '\0';
                strcat_s(tempFilePath, fndFileData.cFileName);
                strcat_s(tempFilePath, "\\*");
                int nRes = ClearSpecifieFile(fileType, (LPCTSTR)tempFilePath, deletedFileCnt, deleteFailedCnt);
                if (nRes >= 0) nfileCnt += nRes;
            }
        }
        else
        {
            memset((void*)searchFilePath, 0, MAX_PATH);
            strcpy_s(searchFilePath, dirName);
            searchFilePath[fileLength - 1] = '\0';
            strcat_s(searchFilePath, fndFileData.cFileName);
            if (fileType == DFT_Ad0) {
                if (CompareFileTime(&mftAd0RemoveTime, &fndFileData.ftLastWriteTime) >= 0) {
                    nRes = DoSomethingWith(fileType, searchFilePath, fndFileData.cFileName);
                }
                else
                {
                    nRes = 0;
                }
            }
            else
            {
                nRes = DoSomethingWith(fileType, searchFilePath, fndFileData.cFileName);
            }
            if (nRes == -1) deleteFailedCnt++;
            else if (nRes == 1) deletedFileCnt++;
            nfileCnt++;
        }
    }
    FindClose(hFind);
    return nfileCnt;
#else
    int nRes;
    int nfileCnt = 0;
    int fileLength = strlen(dirName);
    char searchFilePath[MAX_PATH] = { 0 };
    char tempFilePath[MAX_PATH] = { 0 };
    char displayTime[MAX_PATH] = { 0 };

    struct stat st;
    if (stat(dirName, &st) < 0) {
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("stat for %s failed: %d %s", dirName, errno, strerror(errno));
        return -2;
    }
    if (!S_ISDIR(st.st_mode)) {
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)(" %s is not directory", dirName);
        return -2;
    }

    DIR* d = opendir(dirName);
    if (!d) {
        return -3;
    }
    struct dirent* dp = NULL;
    while ((dp = readdir(d)) != NULL) {
        if ((!strcmp(dp->d_name, ".")) || (!strcmp(dp->d_name, ".."))) {
            continue;
        }
        strcpy(tempFilePath, dirName);
        if (strlen(tempFilePath) + strlen(dp->d_name) + 3 >= MAX_PATH) {
            DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("filePath is too long for current.");
            continue;
        }
        strcat(tempFilePath, "/");
        strcat(tempFilePath, dp->d_name);
        DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("fileName: %s", dp->d_name);
        struct stat stFile;
        stat(tempFilePath, &stFile);
        const bool isdir = !!(S_ISDIR(stFile.st_mode));
        if (isdir && fileType != DFT_CenterSetting) {
            int nRes = ClearSpecifieFile(fileType, (LPCTSTR)tempFilePath, deletedFileCnt, deleteFailedCnt);
            if (nRes >= 0) nfileCnt += nRes;
        }
        else if (!isdir)
        {
            if (fileType != DFT_Ad0 || (CompareVideoFileTime(&mftAd0RemoveTime, &stFile.st_mtime) >= 0)) {
                nRes = RemoveSpecifiedFile(fileType, tempFilePath, dp->d_name);
            }
            else
            {
                nRes = 0;
            }
            if (nRes == -1) deleteFailedCnt++;
            else if (nRes == 1) deletedFileCnt++;
            nfileCnt++;
        }
    }
    closedir(d);
    return nfileCnt;
#endif //RVC_OS_WIN
}

void ResourceWatcherFSM::ClearMoreVideoFiles()
{
#ifdef RVC_OS_LINUX
    EnterCriticalSection(&g_csVideoMoreClear);
    ErrorCodeEnum erroCode = Error_Succeed;
    BOOL bOK = FALSE;
    char szResult3[DEFAULT_OUTPUT_FORMAT_SIZE * 2] = { 0 };
    CSmartPointer<IConfigInfo> spConfigRun;
    ErrorCodeEnum ecRunCfg = GetEntityBase()->GetFunction()->OpenConfig(Config_Run, spConfigRun);

    if (m_VideoFiles.empty() || mUiRequireBytes == 0) {
        int reseved = 0;
        int nRes = CleanVideoFiles(reseved, IsNeedToFirstClear() ? 1 : 0);
        if (nRes - reseved == 0) {
            DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("There are no any video files in facts.");
            //SetSysValAndBroadcast(0, "There are no any video files in facts.");
            LeaveCriticalSection(&g_csVideoMoreClear);
            return;
        }
    }

    int CurRank = 3; //default
    int BfRank = 0;
    if (spConfigRun->ReadConfigValueInt("Video", "RequiredRank", BfRank) != Error_Succeed || BfRank < 0) {
        BfRank = 0;
    }
    if (BfRank > 0) {
        unsigned long long uiTotalBytes;
        unsigned long long uiFreeDiskBytes;
        if (!DiskInfo::GetDiskSpace((LPCTSTR)m_csUploadVideoPath, uiTotalBytes, uiFreeDiskBytes)) {
            LeaveCriticalSection(&g_csVideoMoreClear);
            return;
        }
        //对比上次，剩余的可用磁盘空间更小了。
        if (mUiCalibration >= uiFreeDiskBytes) {
            DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Previous Set CurRank from %d to %d.", CurRank, BfRank);
            CurRank = BfRank == 4 ? 1 : BfRank;
        }
        mUiCalibration = uiFreeDiskBytes;
    }

    const int InitialRank = CurRank;
    char szResult[DEFAULT_OUTPUT_FORMAT_SIZE];
    int nEnoughLevel = 0;
    unsigned long long uiFactor;

    char displayTime[MAX_PATH] = { 0 };
    time_t ftSavedTime;
    CalculateBackTime(&ftSavedTime, m_nMinSavedDay);
    GetTimeFormatStr(displayTime, MAX_PATH, &ftSavedTime);
    DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("It's SavedTime backtrace: %s", displayTime);

    do {
        uiFactor = DEFAULT_AVAILALBE_DATE_COUNT; // 7天
        if (CurRank == 2) uiFactor = LESS_AVAILALBE_DATE_COUNT; // 3天
        else if (CurRank == 1) uiFactor = LEAST_AVAILALBE_DATE_COUNT; // 1天

        const unsigned long long uiSpaceRequired = mUiRequireBytes * uiFactor;
        ByteSprintf(szResult, (double)uiSpaceRequired);
        DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Required free disk size: %s, current rank: %d", szResult, CurRank);
        unsigned long long uiMoreSpaceRealRequired(0);
        unsigned long long uiAdjustment(0);
        if (diskInfo.IsNeedToDoClearJobEx((LPCTSTR)m_csUploadVideoPath, uiSpaceRequired, uiAdjustment, &uiMoreSpaceRealRequired)
            && uiMoreSpaceRealRequired) {
            unsigned long long uiNewFreeBytes(0);
            UINT uDeletedCnt = 0, uFailedDeleteCnt = 0;
            BOOL bTrackBackStop = FALSE;
            DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("the more space required: %llu.", uiMoreSpaceRealRequired);
            while (!m_VideoFiles.empty() && uiNewFreeBytes < uiMoreSpaceRealRequired) {
                TmpFileInfo* pCurFileInfo = m_VideoFiles.top();
                if (pCurFileInfo != NULL) {
                    GetTimeFormatStr(displayTime, MAX_PATH, &(pCurFileInfo->mftEditTime));
                    if (CompareVideoFileTime(&ftSavedTime, &(pCurFileInfo->mftEditTime)) < 0) {
                        DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("stop at %s: %s", pCurFileInfo->msFileName.c_str(), displayTime);
                        bTrackBackStop = TRUE;
                        break;
                    }
                    if (RemoveFileA(pCurFileInfo->msFileName.c_str()) != 0) {
                        uiNewFreeBytes += pCurFileInfo->ftSize;
                        uDeletedCnt++;
                        DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Delete suc: %s: %s", pCurFileInfo->msFileName.c_str(), displayTime);
                        SyncUpdateVideoCreateDaily(&(pCurFileInfo->mftEditTime), -1);
                    }
                    else {
                        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("[DelFail] File(%s) %d", pCurFileInfo->msFileName.c_str(), errno);
                        uFailedDeleteCnt++;
                    }
                }
                m_VideoFiles.pop();
                if (pCurFileInfo != NULL) delete pCurFileInfo;
            }

            char szOutput[DEFAULT_OUTPUT_FORMAT_SIZE] = { 0 };
            char szOutput2[DEFAULT_OUTPUT_FORMAT_SIZE] = { 0 };
            ByteSprintf(szOutput, (double)uiNewFreeBytes);
            ByteSprintf(szOutput2, (double)uiMoreSpaceRealRequired);
            DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Result(Rank#%d): Succeed deleted<%d>, Failed deleted<%d>, Deleted Size<%s> Real Required Size<%s>",
                CurRank, uDeletedCnt, uFailedDeleteCnt, szOutput, szOutput2);
            if (uiNewFreeBytes >= uiMoreSpaceRealRequired) {
                break;
            }
            else {
                --CurRank;
            }

#ifdef WITH_DEBUG
            UINT uCount = 0;
            for (const_map_cu_iter citer = VideoDailyRecord.cbegin(); citer != VideoDailyRecord.cend(); citer++) { uCount += citer->second; }
            DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("FileCount(%d)(%d)", uCount, m_VideoFiles.size());
#endif
        }
        else if (InitialRank > CurRank) {
            break;
        }
        else {
            LeaveCriticalSection(&g_csVideoMoreClear);
            return;
        }
    } while (CurRank > 0);

    if (CurRank < 3) {
        unsigned long long uiTotalBytes;
        unsigned long long uiFreeDiskBytes;
        if (DiskInfo::GetDiskSpace((LPCTSTR)m_csUploadVideoPath, uiTotalBytes, uiFreeDiskBytes)) {
            char szResult2[DEFAULT_OUTPUT_FORMAT_SIZE];
            ByteSprintf(szResult, (double)uiTotalBytes);
            ByteSprintf(szResult2, (double)uiFreeDiskBytes);
            double dFreeRate = (uiFreeDiskBytes * kConversion[3]) / (uiTotalBytes * kConversion[3]);
            sprintf(szResult3, "[Disk# %s] total: %s, free: %s, rate: %.1lf%%.",
                m_csUploadVideoPath.GetData(), szResult, szResult2, dFreeRate * 100);
            mUiCalibration = uiFreeDiskBytes;
        }
        else {
            strcpy(szResult3, "It's not enough disk space for recording video !");
        }
    }
    else {
        strcpy(szResult3, "Disk space is enough for recording.");
    }

    if (CurRank == 0) { CurRank = 4; }
    if (BfRank != CurRank) {
        erroCode = spConfigRun->WriteConfigValueInt("Video", "RequiredRank", CurRank);
    }
    SetSysValAndBroadcast(CurRank, szResult3);
    LeaveCriticalSection(&g_csVideoMoreClear);
    return;
#else
    EnterCriticalSection(&g_csVideoMoreClear);
    ErrorCodeEnum erroCode = Error_Succeed;
    BOOL bOK = FALSE;
    CSmartPointer<IConfigInfo> spConfigRun;
    ErrorCodeEnum ecRunCfg = GetEntityBase()->GetFunction()->OpenConfig(Config_Run, spConfigRun);

    if (m_VideoFiles.empty())
    {
        int reseved = 0;
        IsNeedToFirstClear();
        int nRes = CleanVideoFiles(reseved, m_bReadyFlag ? 1 : 0);
        if (nRes - reseved == 0)
        {
            SetSysValAndBroadcast(0, "There are no any video files in facts.");
            LeaveCriticalSection(&g_csVideoMoreClear);
            return;
        }
    }
    if (mUiRequireBytes.QuadPart == 0ui64)
    {//更新记录运行时，并等待下一次的自检执行。
        int reseved = 0;
        CleanVideoFiles(reseved);
        LeaveCriticalSection(&g_csVideoMoreClear);
        return;
    }

    ULARGE_INTEGER uiSpaceRequired;
    ULARGE_INTEGER uiSpaceRealRequired;
    ULARGE_INTEGER uiFactor;
    int CurRank = 3;
    int BfRank = 0;
    if (spConfigRun->ReadConfigValueInt("Video", "RequiredRank", BfRank) != Error_Succeed || BfRank < 0)
        BfRank = 0;

    if (BfRank > 0)
    {
        ULARGE_INTEGER uiTotalBytes;
        ULARGE_INTEGER uiFreeDiskBytes;
        if (DiskInfo::GetDiskSpace((LPCTSTR)m_csUploadVideoPath, uiTotalBytes, uiFreeDiskBytes))
        {
            //对比上次，剩余的可用磁盘空间更小了。
            if (mUiCalibration.QuadPart >= uiFreeDiskBytes.QuadPart)
            {
                CurRank = BfRank;
            }
            mUiCalibration.QuadPart = uiFreeDiskBytes.QuadPart;
        }
    }

    char szResult[DEFAULT_OUTPUT_FORMAT_SIZE];
    int nEnoughLevel = 0;

    do
    {
        uiFactor.QuadPart = 0;
        switch (CurRank)
        {
        case 3:
            uiSpaceRequired.QuadPart = mUiRequireBytes.QuadPart * DEFAULT_AVAILALBE_DATE_COUNT;
            break;
        case 2:
            uiSpaceRequired.QuadPart = mUiRequireBytes.QuadPart * LESS_AVAILALBE_DATE_COUNT;
            break;
        case 1:
            uiSpaceRequired.QuadPart = mUiRequireBytes.QuadPart * LEAST_AVAILALBE_DATE_COUNT;
            break;
        default:
            CurRank = 3;
            uiSpaceRequired.QuadPart = mUiRequireBytes.QuadPart * DEFAULT_AVAILALBE_DATE_COUNT;
        }
        ByteSprintf(szResult, (double)uiSpaceRequired.QuadPart);

        if (bOK = diskInfo.IsNeedToDoClearJobEx((LPCTSTR)m_csUploadVideoPath,
            uiSpaceRequired, uiFactor, &uiSpaceRealRequired))
        {
            if (uiSpaceRealRequired.QuadPart == 0)
            {
                break;
            }

            char displayTime[MAX_PATH] = { 0 };
            FILETIME ftSavedTime;
            //TODO: 暂时设置为至少保存两星期的录像文件，如果一天都不保留，那么 m_VideoFiles 要做即时更新 。2017-5-10
            CalculateBackTime(&ftSavedTime, m_nMinSavedDay);
            GetTimeFormatStr(displayTime, MAX_PATH, &ftSavedTime);
            DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("SavedTime backtrace: %s", displayTime);

            ULARGE_INTEGER uiFreeBytes;
            uiFreeBytes.QuadPart = 0;
            UINT uDeletedCnt = 0, uFailedDeleteCnt = 0;
            BOOL bTrackBackStop = FALSE;
            while (!m_VideoFiles.empty() && uiFreeBytes.QuadPart < uiSpaceRealRequired.QuadPart)
            {
                TmpFileInfo* pCurFileInfo = m_VideoFiles.top();
                if (pCurFileInfo != NULL)
                {
                    SYSTEMTIME stUTC, stLocal;
                    FileTimeToSystemTime(&(pCurFileInfo->mftEditTime), &stUTC);
                    SystemTimeToTzSpecificLocalTime(NULL, &stUTC, &stLocal);
                    if (CompareVideoFileTime(&ftSavedTime, &(pCurFileInfo->mftEditTime)) < 0)
                    {
                        DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("yet %s: %02d/%02d/%d %02d:%02d", pCurFileInfo->msFileName.c_str(),
                            stLocal.wMonth, stLocal.wDay, stLocal.wYear,
                            stLocal.wHour, stLocal.wMinute);
                        bTrackBackStop = TRUE;
                        break;
                    }
                    if (DeleteFile(pCurFileInfo->msFileName.c_str()) != 0)
                    {
                        ULARGE_INTEGER tmpBytes;
                        tmpBytes.HighPart = pCurFileInfo->mDwFileSizeHeight;
                        tmpBytes.LowPart = pCurFileInfo->mDwFileSizeLow;
                        uiFreeBytes.QuadPart += tmpBytes.QuadPart;
                        uDeletedCnt++;
                        DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Delete suc: %s: %02d/%02d/%d %02d:%02d", pCurFileInfo->msFileName.c_str(),
                            stLocal.wMonth, stLocal.wDay, stLocal.wYear,
                            stLocal.wHour, stLocal.wMinute);
                        UINT uDate = stLocal.wYear * 10000 + stLocal.wMonth * 100 + stLocal.wDay;
                        VideoDailyRecord[uDate]--;
                    }
                    else
                    {
                        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("[DelFail] File(%s) %u", pCurFileInfo->msFileName.c_str(), GetLastError());
                        uFailedDeleteCnt++;
                    }
                }
                m_VideoFiles.pop();
                if (pCurFileInfo != NULL) delete pCurFileInfo;
            }

            char szOutput[DEFAULT_OUTPUT_FORMAT_SIZE] = { 0 };
            char szOutput2[DEFAULT_OUTPUT_FORMAT_SIZE] = { 0 };
            ByteSprintf(szOutput, (double)uiFreeBytes.QuadPart);
            ByteSprintf(szOutput2, (double)uiSpaceRealRequired.QuadPart);
            DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Result(Rank#%d): Succeed deleted<%d>, Failed deleted<%d>, Deleted Size<%s> Real Required Size<%s>",
                CurRank, uDeletedCnt, uFailedDeleteCnt, szOutput, szOutput2);
            if (uiFreeBytes.QuadPart >= uiSpaceRealRequired.QuadPart)
            {
                break;
            }
            --CurRank;
#if 1
            UINT uCount = 0;
            for (const_map_cu_iter citer = VideoDailyRecord.cbegin();
                citer != VideoDailyRecord.cend(); citer++)
            {
                uCount += citer->second;
            }
#endif
        }
        else
        {
            LogWarn(Severity_Middle, Error_Unexpect, 0, "IsNeedToDoClearJobEx invoked failed !");
            LeaveCriticalSection(&g_csVideoMoreClear);
            return;
        }
    } while (CurRank > 0);

    char szResult3[DEFAULT_OUTPUT_FORMAT_SIZE * 2] = { 0 };
    if (CurRank < 3)
    {
        ULARGE_INTEGER uiTotalBytes;
        ULARGE_INTEGER uiFreeDiskBytes;
        if (DiskInfo::GetDiskSpace((LPCTSTR)m_csUploadVideoPath, uiTotalBytes, uiFreeDiskBytes))
        {
            char szResult2[DEFAULT_OUTPUT_FORMAT_SIZE];
            ByteSprintf(szResult, (double)uiTotalBytes.QuadPart);
            ByteSprintf(szResult2, (double)uiFreeDiskBytes.QuadPart);
            double dFreeRate = (uiFreeDiskBytes.QuadPart * kConversion[3]) / (uiTotalBytes.QuadPart * kConversion[3]);
            sprintf_s(szResult3, "[Disk# %c:\\] total: %s, free: %s, rate: %.1lf%%.",
                m_csUploadVideoPath[0], szResult, szResult2, dFreeRate * 100);
            mUiCalibration.QuadPart = uiFreeDiskBytes.QuadPart;
        }
        else
        {
            strcpy_s(szResult3, "It's not enough disk space for recording video !");
        }
        if (CurRank == 0)
        {
            CurRank = 4;
        }
    }
    else
    {
        strcpy_s(szResult3, "Disk space is enough for recording.");
    }
    if (BfRank != CurRank)
    {
        erroCode = spConfigRun->WriteConfigValueInt("Video", "RequiredRank", CurRank);
    }
    SetSysValAndBroadcast(CurRank, szResult3);
    LeaveCriticalSection(&g_csVideoMoreClear);
    return;
#endif // RVC_OS_LINUX
}

#ifdef RVC_OS_LINUX
BOOL ResourceWatcherFSM::RemoveDuplicateCenterSettingFiles()
{
    LOG_FUNCTION();

    ErrorCodeEnum erroCode = Error_Succeed;
    CSmartPointer<IConfigInfo> spConfigRun;
    erroCode = GetEntityBase()->GetFunction()->OpenConfig(Config_Run, spConfigRun);
    if (erroCode != Error_Succeed) {
        DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("OpenConfig of 'Config_Run' failed 0x%x(%d).", erroCode, erroCode);
        return FALSE;
    }
    int nLastTaskTime(0);
    spConfigRun->ReadConfigValueInt("LastClearTime", "CenterSetting", nLastTaskTime);
    if (IsTodayDone(nLastTaskTime)) {
        return TRUE;
    }
    CSimpleStringA ssFilePath(true);
    erroCode = GetEntityBase()->GetFunction()->GetPath("cfg", ssFilePath);
    if (erroCode != Error_Succeed || ssFilePath.IsNullOrEmpty()) {
        DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Get path of 'cfg' failed 0x%x(%d).", erroCode, erroCode);
        return FALSE;
    }

    DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("filePath %s", (LPCTSTR)ssFilePath);
    int nDelSuc = 0;
    int nDelFailed = 0;
    int nfileSum = ClearSpecifieFile(DFT_CenterSetting, ssFilePath, nDelSuc, nDelFailed);
    DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("#CenterSetting#There are %d file(s), delete: %d, failed: %d.", nfileSum, nDelSuc, nDelFailed);
    spConfigRun->WriteConfigValue("LastClearTime", "CenterSetting", (const char*)CSimpleStringA::Format("0x%08X", (DWORD)CSmallDateTime::GetNow()));
    return TRUE;
}
#endif // RVC_OS_LINUX

bool ResourceWatcherFSM::IsNeedToFirstClear()
{
#ifdef RVC_OS_LINUX
    int nLastTaskTime(0);
    CSmartPointer<IConfigInfo> spRunConfig;
    GetEntityBase()->GetFunction()->OpenConfig(Config_Run, spRunConfig);
    spRunConfig->ReadConfigValueInt("LastClearTime", "Video", nLastTaskTime);
    return !IsTodayDone(nLastTaskTime);
#else
    bool result = true;
    CSimpleStringA csLstExecTime;
    CSmartPointer<IConfigInfo> spRunConfig;
    GetEntityBase()->GetFunction()->OpenConfig(Config_Run, spRunConfig);
    spRunConfig->ReadConfigValue("Video", "LastTime", csLstExecTime);
    if (csLstExecTime.GetLength() > 1) {
        int nYear = 0, nMonth = 0, nDay = 0;
        spRunConfig->ReadConfigValueInt("Video", "Year", nYear);
        spRunConfig->ReadConfigValueInt("Video", "Month", nMonth);
        spRunConfig->ReadConfigValueInt("Video", "Day", nDay);
        if (nYear != 0 && nMonth != 0 && nDay != 0) {
            SYSTEMTIME stUTC, stLocal;
            GetSystemTime(&stUTC);
            SystemTimeToTzSpecificLocalTime(NULL, &stUTC, &stLocal);
            if (nYear == stLocal.wYear && nMonth == stLocal.wMonth && nDay == stLocal.wDay) {
                DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Video Clear job has been done today in %s", (LPCTSTR)csLstExecTime);
                result = false;
            }
        }
    }
    return result;
#endif // RVC_OS_LINUX
}

void ResourceWatcherFSM::DeleteFiles()
{
    string p;
    CSmartPointer<IConfigInfo> spCtSettingConfig;
    GetEntityBase()->GetFunction()->OpenConfig(Config_CenterSetting, spCtSettingConfig);
    CSimpleStringA upPath(""), tempPath(""), tPath(""), upgradePath("");
    spCtSettingConfig->ReadConfigValue("ResourceWatcher", "DocumentCleanPath", tempPath);
    if (tempPath.GetLength() == 0) {
        return;
    }
    ErrorCodeEnum erroCode = Error_Succeed;
    CSmartPointer<IEntityFunction> pFunc = GetEntityBase()->GetFunction();
    CSmartPointer<IConfigInfo> spConfigRun;
    //判断是否需要被清理
    erroCode = pFunc->OpenConfig(Config_Run, spConfigRun);
    if (erroCode != Error_Succeed) {
        LogWarn(Severity_Middle, erroCode, 0, "Open Run Config failed");
        return;
    }

    int nLastTaskTime = 0;
    int nLstFlag = 0;
    bool bFailFlag = false;
    CSimpleStringA optFileName("");
    UINT64 utVersion = 0;

    spConfigRun->ReadConfigValueHexInt("DeleteDocumentTask", "OptVer", utVersion);
    spConfigRun->ReadConfigValue("DeleteDocumentTask", "DocumentName", optFileName);
    spConfigRun->ReadConfigValueInt("DeleteDocumentTask", "LastCondi", nLstFlag);
    spConfigRun->ReadConfigValueInt("DeleteDocumentTask", "LastTime", nLastTaskTime);

    CVersion optVer(utVersion);
    SYSTEMTIME stTaskTime = CSmallDateTime(nLastTaskTime).ToSystemTime();
    DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("LastTime<%04d-%02d-%02d %02d:%02d:%02d>: OptVer: %s, LastCondi: %d",
        stTaskTime.wYear, stTaskTime.wMonth, stTaskTime.wDay,
        stTaskTime.wHour, stTaskTime.wMinute, stTaskTime.wSecond,
        (LPCTSTR)optVer.ToString(), nLstFlag);
    if (optVer.IsValid() && optVer == m_RvcSysinfo.InstallVersion && !nLstFlag && optFileName == tempPath)
    {
        DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Certain document cleaning has been done before.");
        return;
    }
#ifdef RVC_OS_WIN
    //删除upPath目录下的文件
    struct _finddata_t upfileinfo;
    long upFile = 0;

    WIN32_FIND_DATA wfd;
    HANDLE hFind;

    upPath = tempPath;
    upPath.Append("\\*");
    hFind = FindFirstFile(upPath.GetData(), &wfd);
    if (hFind != INVALID_HANDLE_VALUE) {
        if ((wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY) {
            int nDelSuc = 0, nDelFail = 0, nFileCount = 0;
            nFileCount = ProcessFileDelete(upPath.GetData(), nDelSuc, nDelFail);
            DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Process result(%s): count(%d), suc(%d), failed(%d).", upPath.GetData(), nFileCount, nDelSuc, nDelFail);
            if (nDelFail != 0) {
                bFailFlag = true;
                //break;
            }
            FindClose(hFind);
        }
        else
        {
            if (DeleteFile(tempPath.GetData()) != 0) {
                DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("删除文件%s成功。", tempPath.GetData());
                //break;
            }
            else
            {
                bFailFlag = true;
                DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("删除文件%s失败。", tempPath.GetData());
            }
        }
    }
    else
    {
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("FindFirstFile failed (%s)(%u)", upPath.GetData(), GetLastError());
    }
#else //LINUX
    struct stat buffer;
    upPath = tempPath;
    if (stat(upPath.GetData(), &buffer) == 0 && S_ISDIR(buffer.st_mode)) //判断是不是文件夹
    {
        int nDelSuc = 0, nDelFail = 0, nFileCount = 0;
        nFileCount = ProcessFileDelete(upPath.GetData(), nDelSuc, nDelFail);
        DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Process result(%s): count(%d), suc(%d), failed(%d).", upPath.GetData(), nFileCount, nDelSuc, nDelFail);
        if (nDelFail != 0) {
            bFailFlag = true;
            //break;
        }
    }
    else
    {
        if (RemoveFileA(tempPath.GetData()) != 0) {
            DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("删除文件%s成功。", tempPath.GetData());
            //break;
        }
        else
        {
            bFailFlag = true;
            DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("删除文件%s失败。", tempPath.GetData());
        }
    }
#endif // RVC_OS_WIN

    nLstFlag = bFailFlag ? 1 : 0;
    spConfigRun->WriteConfigValueHexInt("DeleteDocumentTask", "OptVer", m_RvcSysinfo.InstallVersion.GetVersion64());
    spConfigRun->WriteConfigValue("DeleteDocumentTask", "DocumentName", tempPath);
    spConfigRun->WriteConfigValueInt("DeleteDocumentTask", "LastCondi", nLstFlag);
    spConfigRun->WriteConfigValue("DeleteDocumentTask", "LastTime",
        (LPCTSTR)CSimpleStringA::Format("0x%08X", (DWORD)CSmallDateTime::GetNow()));

    if (!bFailFlag) {
        LogWarn(Severity_Low, Error_Debug, LOG_WARN_DIR_DELETE, CSimpleStringA::Format("Delete files in [%s] success", tempPath.GetData()));
    }
    else
    {
        DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Delete files in [%s] failed.", tempPath.GetData());
    }
}

int ResourceWatcherFSM::ProcessFileDelete(LPCTSTR lpszPath, int& nDelSucCnt, int& nDelFailedCnt)
{
#ifdef RVC_OS_LINUX
    int fileCnt = 0;
    int fileLength = strlen(lpszPath);
    char* searchFilePath = new char[MAX_PATH];
    char* tempFilePath = new char[MAX_PATH];

    if (searchFilePath == NULL || tempFilePath == NULL) {
        if (searchFilePath) delete[] searchFilePath;
        if (tempFilePath) delete[] tempFilePath;
        return fileCnt;
    }
    ZeroMemory(searchFilePath, MAX_PATH);
    ZeroMemory(tempFilePath, MAX_PATH);

    struct stat st;
    if (stat(lpszPath, &st) < 0 || !S_ISDIR(st.st_mode)) {
        if (searchFilePath) delete[] searchFilePath;
        if (tempFilePath) delete[] tempFilePath;
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("stat failed or is not dir.");
        return fileCnt;
    }
    DIR* d = opendir(lpszPath);
    if (!d) {
        if (searchFilePath) delete[] searchFilePath;
        if (tempFilePath) delete[] tempFilePath;
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("opendir failed: %d", errno);
        return fileCnt;
    }
    struct dirent* dp = NULL;
    while ((dp = readdir(d)) != NULL) {
        if ((!strcmp(dp->d_name, ".")) || (!strcmp(dp->d_name, ".."))) {
            continue;
        }
        strcpy(tempFilePath, lpszPath);

        if (strlen(tempFilePath) + strlen(dp->d_name) + 3 >= MAX_PATH) {
            DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("filePath is too long for current.");
            continue;
        }
        strcat(tempFilePath, "/");
        strcat(tempFilePath, dp->d_name);
        stat(tempFilePath, &st);
        bool isdir = !!(S_ISDIR(st.st_mode));
        if (isdir) {
            int tDelSucCnt = 0, tDelFailedCnt = 0;
            fileCnt += ProcessFileDelete((LPCTSTR)tempFilePath, tDelSucCnt, tDelFailedCnt);
            if (tDelFailedCnt == 0 && rmdir(tempFilePath) != 0) {
                DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("rmdir(%s) failed, GLE = %u.", (LPCTSTR)tempFilePath, errno);
                nDelFailedCnt++;
            }
            nDelFailedCnt += tDelFailedCnt;
            nDelSucCnt += tDelSucCnt;
        }
        else {
            if (RemoveFileA(tempFilePath)) {
                nDelSucCnt++;
                DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Delete [%s] suc.", dp->d_name);
            }
            else {
                nDelFailedCnt++;
                DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("RemoveFileA [%s] failed, GLE = %u.", tempFilePath, errno);
            }
            fileCnt++;
        }
    }
    closedir(d);

    if (searchFilePath) delete[] searchFilePath;
    if (tempFilePath) delete[] tempFilePath;
    searchFilePath = NULL;
    tempFilePath = NULL;
    return fileCnt;
#else
    int fileCnt = 0;
    int fileLength = strlen(lpszPath);

    WIN32_FIND_DATA wfd;
    HANDLE hFind;

    hFind = FindFirstFile(lpszPath, &wfd);
    if (hFind == INVALID_HANDLE_VALUE)
    {
        DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("FindFirstFile failed GLE = %u.", GetLastError());
        return 0;
    }

    char* searchFilePath = new char[MAX_PATH];
    char* tempFilePath = new char[MAX_PATH];
    if (searchFilePath == NULL || tempFilePath == NULL)
    {
        if (searchFilePath) delete[] searchFilePath;
        if (tempFilePath) delete[] tempFilePath;
        searchFilePath = NULL;
        tempFilePath = NULL;
        return fileCnt;
    }
    ZeroMemory(searchFilePath, MAX_PATH);
    ZeroMemory(tempFilePath, MAX_PATH);

    do
    {
        if ((wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY)
        {
            if (wfd.cFileName[0] != '.')
            {
                strcpy_s(tempFilePath, MAX_PATH, lpszPath);
                tempFilePath[fileLength - 1] = '\0';
                if (strlen(tempFilePath) + strlen(wfd.cFileName) + 3 >= MAX_PATH)
                {
                    DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("filePath is too long for current.");
                }
                else
                {
                    strcat_s(tempFilePath, MAX_PATH, wfd.cFileName);
                    CSimpleStringA tmpPath = tempFilePath;
                    strcat_s(tempFilePath, MAX_PATH, "\\*");
                    int tDelSucCnt = 0, tDelFailedCnt = 0;
                    fileCnt += ProcessFileDelete((LPCTSTR)tempFilePath, tDelSucCnt, tDelFailedCnt);
                    if (tDelFailedCnt == 0 && !RemoveDirectoryA(tmpPath))
                    {
                        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("RemoveDirectoryA(%s) failed, GLE = %u.", (LPCTSTR)tmpPath, GetLastError());
                        nDelFailedCnt++;
                    }
                    nDelFailedCnt += tDelFailedCnt;
                    nDelSucCnt += tDelSucCnt;
                }
            }
        }
        else
        {
            strcpy_s(searchFilePath, MAX_PATH, lpszPath);
            searchFilePath[fileLength - 1] = '\0';
            strcat_s(searchFilePath, MAX_PATH, wfd.cFileName);

            if (DeleteFile(searchFilePath) != 0)
            {
                nDelSucCnt++;
            }
            else
            {
                nDelFailedCnt++;
                DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Delete [%s] failed, GLE = %u.", wfd.cFileName, GetLastError());
            }
            fileCnt++;
        }
    } while (FindNextFileA(hFind, &wfd));
    FindClose(hFind);

    if (searchFilePath) delete[] searchFilePath;
    if (tempFilePath) delete[] tempFilePath;
    searchFilePath = NULL;
    tempFilePath = NULL;
    return fileCnt;
#endif // RVC_OS_LINUX
}

BOOL ResourceWatcherFSM::DeleteVersionPackage()
{
    BOOL bRet = FALSE;
    ErrorCodeEnum erroCode = Error_Succeed;
    CSmartPointer<IEntityFunction> pFunc = GetEntityBase()->GetFunction();
    CSmartPointer<IConfigInfo> spConfigRun;
    CSmartPointer<IConfigInfo> spConfig;
    CSystemStaticInfo info;
    if (pFunc->GetSystemStaticInfo(info) != Error_Succeed) {
        LogWarn(Severity_Middle, erroCode, 0, "Get system static info error");
        return FALSE;
    }
    DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Current version: %s", (LPCTSTR)info.InstallVersion.ToString());

    //判断是否需要被清理
    int nLastTaskTime = 0;
    int nLstFlag = 0;
    int nDelCount = 0;
    UINT64 utVersion = 0;

    int verSaved = DEFAULT_VERSION_SAVED_COUNT;
    int tmpSaved = 0;
    pFunc->OpenConfig(Config_CenterSetting, spConfig);
    spConfig->ReadConfigValueInt("VersionSaved", "default", tmpSaved);
    if (tmpSaved > DEFAULT_VERSION_SAVED_COUNT) {
        verSaved = tmpSaved;
    }

    pFunc->OpenConfig(Config_Run, spConfigRun);
    spConfigRun->ReadConfigValueHexInt("VersionClear", "OptVer", utVersion);
    spConfigRun->ReadConfigValueInt("VersionClear", "DelVerCnt", nDelCount);
    spConfigRun->ReadConfigValueInt("VersionClear", "LastCondi", nLstFlag);
    spConfigRun->ReadConfigValueInt("VersionClear", "LastTime", nLastTaskTime);

    CVersion optVer(utVersion);
    SYSTEMTIME stTaskTime = CSmallDateTime(nLastTaskTime).ToSystemTime();
    DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("LastTime<%04d-%02d-%02d %02d:%02d:%02d>: OptVer: %s, LastCondi: %d",
        stTaskTime.wYear, stTaskTime.wMonth, stTaskTime.wDay,
        stTaskTime.wHour, stTaskTime.wMinute, stTaskTime.wSecond,
        (LPCTSTR)optVer.ToString(), nLstFlag);
    //判断是否需要被清理
    if (optVer.IsValid() && optVer == info.InstallVersion && !nLstFlag) {
        DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("VersionPackage cleaning has been done before.");
        return TRUE;
    }

    CSimpleStringA strRunInfo, strStartTime;
    if (m_pEntity->GetFunction()->GetPath("RunInfo", strRunInfo) == Error_Succeed) {
        strStartTime = strRunInfo + SPLIT_SLASH_STR + "runcfg" + SPLIT_SLASH_STR + "starttime.dat";
        if (!ExistsFileA(strStartTime.GetData())) {
            DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("upgrade prpcess done, try to delete version files.");//完成升级过程，通过
        }
        else
        {
            DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("upgrade process is not end ,should not delete version files.");
            return FALSE;//升级未完成，不进行删除
        }
    }
    else
    {
        DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("upgrade process is not end ,get runinfo path is error, should not delete version files.");
        return FALSE;//失败,继续等待
    }

    //获取当前目录下的文件夹名称, 将符合命名规则的终端版本名称push_back
    CSimpleStringA csPath;
    ErrorCodeEnum Error = m_pEntity->GetFunction()->GetPath("RootVer", csPath);   //获取当前版本路劲 例如：C:\Run
    if (Error_Succeed == Error) {
        if (csPath.IsNullOrEmpty()) {
            DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("get currVer path is null");
            return FALSE;
        }
        else
        {
            DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("CUR VERSION PATH = %s.", csPath.GetData());
        }
    }
    else
    {
        DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("get Ver path error");
        return FALSE;
    }

    vector<CVersion> intallInfoVects;
    vector<string> files;

    CSimpleStringA upPath;
    ErrorCodeEnum upError = pFunc->GetPath("Upgraded", upPath);
    if (Error_Succeed != upError) {
        DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("get Upgraded path error");
        return FALSE;
    }

#ifdef RVC_OS_LINUX
    DIR* dp;
    struct dirent* dirp;

    if ((dp = opendir(csPath.GetData())) != NULL) {
        while ((dirp = readdir(dp)) != NULL) {
            //files.push_back(string(dirp->d_name));
            CInstallInfo verInfo = {};
            DWORD dwMajor(0), dwMinor(0), dwRevision(0), dwBuild(0);
            int n = sscanf(dirp->d_name, "%d.%d.%d.%d", &dwMajor, &dwMinor, &dwRevision, &dwBuild);
            if (n != 4)
            {
                DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Not version file.[%s]", dirp->d_name);
                continue;
            }
            else {
                CVersion verName(dwMajor, dwMinor, dwRevision, dwBuild);
                if (verName.IsValid() && verName < info.InstallVersion)   //对高于自身版本的文件不予删除
                {
                    intallInfoVects.push_back(verName);
                }
                else {
                    DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Not version file.[%s]", dirp->d_name);
                }
            }
        }
        closedir(dp);
    }

    //删除rvc/Upgraded目录下的文件
    DIR* updp;
    struct dirent* updirp;
    if ((updp = opendir(upPath.GetData())) != NULL) {
        while ((updirp = readdir(updp)) != NULL) {
            char szPath[MAX_VERSION_PATH] = { 0 };
            strcat(szPath, upPath.GetData());
            CSimpleStringA tmpDirPath = szPath;
            strcat(szPath, SPLIT_SLASH_STR);
            strcat(szPath, updirp->d_name);
            DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("operating Upgrade path: [%s][%s]", (LPCTSTR)tmpDirPath, szPath);
            RemoveFileA(szPath);
        }
        closedir(updp);
    }

#else
    long hFile = 0;
    struct _finddata_t fileinfo;//文件信息读取结构
    string p;

    if ((hFile = _findfirst(p.assign(string(csPath.GetData())).append("\\*").c_str(), &fileinfo)) != -1) {
        do {
            CInstallInfo verInfo = {};
            DWORD dwMajor(0), dwMinor(0), dwRevision(0), dwBuild(0);
            int n = sscanf(fileinfo.name, "%d.%d.%d.%d", &dwMajor, &dwMinor, &dwRevision, &dwBuild);
            if (n != 4)
            {
                DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Not version file.[%s]", fileinfo.name);
                continue;
            }
            else {
                CVersion verName(dwMajor, dwMinor, dwRevision, dwBuild);
                if (verName.IsValid() && verName < info.InstallVersion)
                {
                    intallInfoVects.push_back(verName);
                }
                else {
                    DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Not version file.[%s]", fileinfo.name);
                }
            }
        } while (_findnext(hFile, &fileinfo) == 0);
        _findclose(hFile);
    }

    //删除rvc/Upgraded目录下的文件
    struct _finddata_t upfileinfo;
    long upFile = 0;

    if ((upFile = _findfirst(p.assign(string(upPath.GetData())).append("\\*").c_str(), &upfileinfo)) != -1) {
        do {
            char szPath[MAX_VERSION_PATH] = { 0 };
            strcat_s(szPath, upPath.GetData());
            CSimpleStringA tmpDirPath = szPath;
            strcat_s(szPath, SPLIT_SLASH_STR);
            strcat_s(szPath, upfileinfo.name);
            DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("operating Upgrade path: [%s][%s]", (LPCTSTR)tmpDirPath, szPath);
            RemoveFileA(szPath);
        } while (_findnext(upFile, &upfileinfo) == 0);
        _findclose(upFile);
    }

#endif // RVC_OS_LINUX

    int nPackCount = intallInfoVects.size();
    DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Install Package's count: %d", nPackCount);
    bool bFailFlag = false;
    int nDelVersionCnt = 0;
    std::string tInfo("");

    if (nPackCount != 0) {
        int nSavedCount = 0;
        sort(intallInfoVects.begin(), intallInfoVects.end());
        vector<CVersion>::reverse_iterator riter = intallInfoVects.rbegin();
        while (riter != intallInfoVects.rend()) {
            DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("InstallPackage Info: %s", (LPCTSTR)(*riter).ToString());
            if (++nSavedCount <= verSaved) {
                DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Save above version");
                riter++;
                continue;
            }
            if (!DeleteSpecificeVersionDir(*riter)) bFailFlag = true;
            else {
                nDelVersionCnt++;
                tInfo = tInfo + "|" + std::string((*riter).ToString().GetData());
            }
            riter++;
        }
    }

    nLstFlag = bFailFlag ? 1 : 0;
    spConfigRun->WriteConfigValueHexInt("VersionClear", "OptVer", info.InstallVersion.GetVersion64());
    spConfigRun->WriteConfigValueInt("VersionClear", "DelVerCnt", nDelCount + nDelVersionCnt);
    spConfigRun->WriteConfigValueInt("VersionClear", "LastCondi", nLstFlag);
    spConfigRun->WriteConfigValue("VersionClear", "LastTime",
        (LPCTSTR)CSimpleStringA::Format("0x%08X", (DWORD)CSmallDateTime::GetNow()));

    if (nDelVersionCnt > 0) {
        std::string warn = "Delete Vesion file count : " + std::to_string((long long)nDelVersionCnt) + ".  ----- " + tInfo + ".";
        LogWarn(Severity_Low, Error_Debug, LOG_WARN_VER_DELETE, CSimpleStringA::Format("%s", warn.c_str()));
    }

    return TRUE;
}

BOOL ResourceWatcherFSM::DeleteSpecificeVersionDir(CVersion version)
{
#ifdef RVC_OS_LINUX
    ErrorCodeEnum erroCode = Error_Unexpect;
    CSimpleStringA strPath;
    if (GetEntityBase()->GetFunction()->GetPath("RootVer", strPath) != Error_Succeed)
        return FALSE;
    strPath = strPath + SPLIT_SLASH_STR + version.ToString();
    if (!ExistsDirA(strPath)) {
        DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Directory(%s) Not Existed, Maybe delete before !!", strPath.GetData());
        return TRUE;
    }
    CSimpleStringA tmpDirPath = strPath;
    DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("operating version path: [%s][%s]", (LPCTSTR)tmpDirPath, (LPCTSTR)strPath);
    int nDelSuc = 0, nDelFail = 0, nFileCount = 0;
    nFileCount = ProcessFileDelete((LPCTSTR)tmpDirPath, nDelSuc, nDelFail);
    DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Process result(%s): count(%d), suc(%d), failed(%d).", tmpDirPath.GetData(), nFileCount, nDelSuc, nDelFail);

    if (nDelFail != 0 || rmdir(tmpDirPath) != 0) {
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Unexpect condition happen: (%d)", nDelFail);
        return FALSE;
    }
    return TRUE;
#else
    ErrorCodeEnum erroCode = Error_Unexpect;
    char szPath[MAX_VERSION_PATH] = { 0 };
    ZeroMemory(szPath, MAX_VERSION_PATH);
    DWORD dwLen = GetModuleFileNameA(NULL, szPath, MAX_VERSION_PATH);
    if (dwLen != 0)
    {
        char* pch = strstr(szPath, "\\bin");
        if (pch != NULL)
        {
            pch[0] = '\0';
            CSimpleStringA strPath = szPath;
            pch = strrchr(szPath, '\\');
            if (pch != NULL)
            {
                pch[1] = '\0';
                strcat_s(szPath, (LPCTSTR)version.ToString());
                if (!ExistsDirA(szPath))
                {
                    return TRUE;
                }
                CSimpleStringA tmpDirPath = szPath;
                strcat_s(szPath, "\\*");
                int nDelSuc = 0, nDelFail = 0, nFileCount = 0;
                nFileCount = ProcessFileDelete(szPath, nDelSuc, nDelFail);
                DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Process result(%s): count(%d), suc(%d), failed(%d).", szPath, nFileCount, nDelSuc, nDelFail);
                if (nDelFail != 0 || !RemoveDirectoryA(tmpDirPath))
                {
                    DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Unexpect condition happen: (%d)(%u).", nDelFail, GetLastError());
                    return FALSE;
                }
                erroCode = Error_Succeed;
            }
        }
    }
    else
    {
        LogWarn(Severity_Middle, Error_Unexpect, 0, "GetModuleFileNameA failed !");
    }
    return (erroCode == Error_Succeed);
#endif // RVC_OS_LINUX
}

#ifdef RVC_OS_LINUX
int ResourceWatcherFSM::CalculateAllVideoSize(LPCTSTR lpszPath, unsigned long long* puliSpaceBytes)
{
    int fileCnt = 0;
    int fileLength = strlen(lpszPath);
    char* searchFilePath = new char[MAX_PATH];
    char* tempFilePath = new char[MAX_PATH];
    if (searchFilePath == NULL || tempFilePath == NULL) {
        if (searchFilePath) delete[] searchFilePath;
        if (tempFilePath) delete[] tempFilePath;
        return fileCnt;
    }
    ZeroMemory(searchFilePath, MAX_PATH);
    ZeroMemory(tempFilePath, MAX_PATH);

    struct stat st;
    if (stat(lpszPath, &st) < 0 || !S_ISDIR(st.st_mode)) {
        if (searchFilePath) delete[] searchFilePath;
        if (tempFilePath) delete[] tempFilePath;
        return fileCnt;
    }
    DIR* d = opendir(lpszPath);
    if (!d) {
        if (searchFilePath) delete[] searchFilePath;
        if (tempFilePath) delete[] tempFilePath;
        return fileCnt;
    }
    struct dirent* dp = NULL;
    while ((dp = readdir(d)) != NULL) {
        if ((!strcmp(dp->d_name, ".")) || (!strcmp(dp->d_name, ".."))) {
            continue;
        }
        strcpy(tempFilePath, lpszPath);
        if (strlen(tempFilePath) + strlen(dp->d_name) + 3 >= MAX_PATH) {
            DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("filePath is too long for current.");
            continue;
        }
        strcat(tempFilePath, "/");
        strcat(tempFilePath, dp->d_name);
        stat(tempFilePath, &st);
        const bool isdir = !!(S_ISDIR(st.st_mode));
        if (isdir) {
            fileCnt += CalculateAllVideoSize((LPCTSTR)tempFilePath, puliSpaceBytes);
        }
        else {
            *puliSpaceBytes += st.st_size;
            SyncUpdateVideoCreateDaily(&st.st_mtime, 1);
            fileCnt++;
        }
    }
    closedir(d);
    if (searchFilePath) delete[] searchFilePath;
    if (tempFilePath) delete[] tempFilePath;
    return fileCnt;
}
#endif // RVC_OS_LINUX

void ResourceWatcherFSM::SelfTest(EntityTestEnum eTestType,
    CSmartPointer<ITransactionContext> pTransactionContext)
{
#ifdef RVC_OS_LINUX
    static uint32_t times = 0;
    pTransactionContext->SendAnswer(Error_Succeed);
    times++;
    if (m_bVideoClearReady && times > 60 * 2) { //2 hour per times
        times = 0;
        PostEventFIFO(new FSMEvent(USER_EVT_CLEAR_VIDEOFILE_ENHANCE));
    }
#else
    pTransactionContext->SendAnswer(Error_Succeed);
    if (m_bVideoClearReady)
    {
        PostEventFIFO(new FSMEvent(USER_EVT_CLEAR_VIDEOFILE_ENHANCE));
    }
#endif // RVC_OS_LINUX
}

void ResourceWatcherFSM::SetSysValAndBroadcast(DWORD dwVal, LPCTSTR lpszMessage)
{
    static DWORD dwOldVal = (DWORD)-1;
    CSmartPointer<IEntityFunction> spFunction = this->GetEntityBase()->GetFunction();
    CSimpleStringA csVPStatus = VIDEO_SPACE_UNKNOWN;
    CSimpleStringA csNewVPSatus = VIDEO_SPACE_UNKNOWN;
    spFunction->GetSysVar(SYSVAR_DISKSTATEUS_FOR_VIDEO, csVPStatus);
    if (dwVal == 4)
    {
        csNewVPSatus = VIDEO_SPACE_INSUFF_FATAL;
        LogWarn(Severity_High, Error_TooSmallBuffer, LOG_ERR_RES_VIDEO_INSUFFICIENT, lpszMessage);
    }
    else if (dwVal == 2)
    {
        csNewVPSatus = VIDEO_SPACE_INSUFF_LITTLE;
        if (dwVal != dwOldVal)
            LogWarn(Severity_Middle, Error_TooSmallBuffer, LOG_WARN_RES_VIDEO_INSUFFICIENT, lpszMessage);
    }
    else if (dwVal == 1)
    {
        csNewVPSatus = VIDEO_SPACE_INSUFF_LESS;
        if (dwVal != dwOldVal)
            LogWarn(Severity_Low, Error_TooSmallBuffer, LOG_WARN_RES_VIDEO_INSUFFICIENT, lpszMessage);
    }
    else if (dwVal == 3)
    {
        csNewVPSatus = VIDEO_SPACE_SUFFICIENT;
        if (dwVal != dwOldVal)
            LogEvent(Severity_High, LOG_EVT_RES_VIDEO_SUFFICIENT, lpszMessage);
    }
    else if (dwVal == 0)
    {
        if (dwVal != dwOldVal)
            LogEvent(Severity_High, LOG_EVT_RES_VIDEO_SUFFICIENT, lpszMessage);
    }
    if (csNewVPSatus != csVPStatus)
    {
        ErrorCodeEnum eRet = spFunction->SetSysVar(SYSVAR_DISKSTATEUS_FOR_VIDEO, csNewVPSatus);
        DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("SetSysVar(%s) from '%s' to '%s' returned %d",
            SYSVAR_DISKSTATEUS_FOR_VIDEO
            , (LPCTSTR)csVPStatus
            , (LPCTSTR)csNewVPSatus
            , eRet);
    }
    dwOldVal = dwVal;
}

void ResourceWatcherFSM::HardwareInfoTimer(void* pData)
{
    if (hardwareCheckFlag > 0) {
        GetSystemCPUStatus();
        GetSystemMemoryStatus();
    }

    GetEntityBase()->GetFunction()->ResetTimer(TIMER_HARDWARE_CHECK, hardwareCheckTime);
}

void ResourceWatcherFSM::DiskCheckTimer(void* pData)
{
    if (diskCheckFlag > 0) {
        GetSystemDiskStatus();
#ifdef RVC_OS_LINUX
        GetOperationDiskStatus();
#endif // RVC_OS_LINUX
    }

    GetEntityBase()->GetFunction()->ResetTimer(TIMER_DISK_CHECK, diskCheckTime);
}

#define CNNTYPE_UNKONWN 0 //0:未知
#define CNNTYPE_LAN 1            //网线已连接
#define CNNTYPE_LAN_DISCONNECT 2 //网线未连接（行内PAD，本应连接网线的）
#define CNNTYPE_DONGLE_CNTED 3 //外接卡托已连接（这种情况几乎没有）
#define CNNTYPE_DONGLE_DISCONNECT 4 //外接卡托未连接（这种情况几乎没有）
#define CNNTYPE_LTE_CNTED 5 //5：LTE设备，处于已连接状态
#define CNNTYPE_LTE_DISCONNECT 6 //LTE设备，处于未连接状态
#define CNNTYPE_MIFI_WIFI_SIM 7 //MIFI连接模式，WIFI已连接，SIM卡已连接
#define CNNTYPE_MIFI_WIFI_CNTED 8 //MIFI连接模式，WIFI已连接，SIM卡未连接
#define CNNTYPE_MIFI_WIFI_DISCONNECT 9 //MIFI连接模式，WIFI未连接
#define CNNTYPE_WIFI_CONNECT 10 //WIFI已连接（非MIFI模式，手工连接等其他场景）
#define CNNTYPE_NO_ANY_CONNECT 11 //无任何其他内容连接

ErrorCodeEnum ResourceWatcherFSM::CheckNetType(
    SpReqAnsContext<ResourceWatcherService_CheckNetType_Req, ResourceWatcherService_CheckNetType_Ans>::Pointer ctx)
{
    ErrorCodeEnum ec = Error_Succeed;
    int netType = 0; //默认未知

#ifdef RVC_OS_LINUX
    int i = 0;
    int sockfd;
    struct ifconf ifconf;
    struct ifreq* ifreq;
    char buf[1024];

    //初始化ifconf
    ifconf.ifc_len = 1024;
    ifconf.ifc_buf = buf;
    if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("socket error");
    }
    //获取所有接口信息
    ioctl(sockfd, SIOCGIFCONF, &ifconf);

    //逐个获取Ip地址
    int size = ifconf.ifc_len / sizeof(struct ifreq);
    ifreq = (struct ifreq*)buf;
    string netName(ifreq->ifr_name);

    if (size == 1 && netName == "lo") //只有逻辑地址 -- 网线被拔出
    {
        netType = 1;
    }
    else
    {
        for (i = size; i > 0; i--) {
            string netName(ifreq->ifr_name); //有其他网卡 -- 有线
            if (netName != "lo") {
                netType = 2;
            }
            ifreq++;
        }
    }

#else
    CSystemStaticInfo info;
    GetEntityBase()->GetFunction()->GetSystemStaticInfo(info);
    if (info.strMachineType.Compare("RVC.PAD") == 0) //PAD机型
    {
        CMbnImplHelper mbnHelper;
        ResetDongleInfos();
        const int nMBN = mbnHelper.EnumerateInterfaces();
        const int cnt = g_DongleInfos.GetCount();
        for (int i = 0; i < cnt; ++i) {
            if (g_DongleInfos[i].state == MBD_ACTIVATION_CONNECTED) {
                netType = 4;  //移动网络
            }
        }

        if (netType == 0 && 1 == IsWifiConnected()) {
            netType = 3;  //无线网络
        }
        if (netType == 0) {
            if (SP::Module::Net::CheckLANConnectStatus()) {
                netType = 2;  //有线
            }
            else {
                netType = 1;  //未连接
            }
        }
    }
    else //大机、低柜、卡库
    {
        CoInitialize(NULL);
        //  通过NLA接口获取网络状态
        IUnknown* pUnknown = NULL;
        bool  bOnline = true;//是否在线  
        HRESULT Result = CoCreateInstance(CLSID_NetworkListManager, NULL, CLSCTX_ALL,
            IID_IUnknown, (void**)&pUnknown);
        if (SUCCEEDED(Result)) {
            INetworkListManager* pNetworkListManager = NULL;
            if (pUnknown)
                Result = pUnknown->QueryInterface(IID_INetworkListManager, (void
                    **)&pNetworkListManager);
            if (SUCCEEDED(Result)) {
                VARIANT_BOOL IsConnect = VARIANT_FALSE;
                if (pNetworkListManager) {
                    //Result = pNetworkListManager->get_IsConnectedToInternet(&IsConnect);  //检测互联网连接
                    Result = pNetworkListManager->get_IsConnected(&IsConnect); //检测本地网络
                }
                if (SUCCEEDED(Result)) {
                    bOnline = (IsConnect == VARIANT_TRUE) ? true : false;
                }
            }
            if (pNetworkListManager)
                pNetworkListManager->Release();
        }
        if (pUnknown)
            pUnknown->Release();

        if (bOnline == true) {
            netType = 2;
        }
        else
        {
            netType = 1;
        }
    }

#endif // RVC_OS_LINUX

    if (ctx != NULL) {
        ctx->Ans.netType = netType;
        ctx->Answer(ec);
    }
    return ec;
}

ErrorCodeEnum ResourceWatcherFSM::GetBizLinks(
    SpReqAnsContext<ResourceWatcherService_GetBizLinks_Req, ResourceWatcherService_GetBizLinks_Ans>::Pointer ctx)
{
    LOG_FUNCTION();
    ErrorCodeEnum ec = Error_Succeed;

    int filter = ctx->Req.filter;  //后续过滤使用
    CAutoArray<CSimpleStringA> bizLinks;
    CAutoArray<CSimpleStringA> bizNames;


    CSmartPointer<IConfigInfo> spCtSettingConfig;
    GetEntityBase()->GetFunction()->OpenConfig(Config_CenterSetting, spCtSettingConfig);

    if (filter == 0) //用户管理桌面业务网址
    {
        CSimpleStringA mLink(""), adLink(""), tLink("");
        spCtSettingConfig->ReadConfigValue("Chromium", "UserMgrUrlFulture", mLink);
        if (mLink.GetLength() != 0) {
            CSimpleStringA tName = CSimpleStringA("主站点");
            bizNames.Append(&tName, 0, 1);
            bizLinks.Append(&mLink, 0, 1);
        }

        spCtSettingConfig->ReadConfigValue("Chromium", "UserMgrAd", adLink);
        if (adLink.GetLength() != 0) {
            CSimpleStringA tName = CSimpleStringA("广告站点");
            bizNames.Append(&tName, 0, 1);
            bizLinks.Append(&adLink, 0, 1);
        }
        int bizCnt = 0, outCnt = 0;
        CSimpleStringA getLink("");
        do {
            bizCnt++;
            getLink = CSimpleStringA("UserBizLink").Append(std::to_string(bizCnt).c_str());
            spCtSettingConfig->ReadConfigValue("Chromium", (LPCTSTR)getLink, tLink);
            if (tLink.GetLength() != 0) {
                CAutoArray<CSimpleStringA> arr = tLink.Split('|');
                if (arr.GetCount() == 3) {
                    DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Not bizlink info.");
                    continue;
                }
                outCnt++;
                CSimpleStringA tName = CSimpleStringA("业务站点").Append(std::to_string(outCnt).c_str());
                bizNames.Append(&tName, 0, 1);
                bizLinks.Append(&tLink, 0, 1);
            }

        } while (tLink.GetLength() != 0);
    }
    else if (filter == 1) //错误页集中配置、准入网址
    {
        int bizCnt = 0;
        CSimpleStringA info(""), getLink("");
        do {
            bizCnt++;
            CSimpleStringA chineseName(""), entityName(""), key("");
            CSimpleStringA url("");
            getLink = CSimpleStringA("UserBizLink").Append(std::to_string(bizCnt).c_str());
            spCtSettingConfig->ReadConfigValue("Chromium", (LPCTSTR)getLink, info);
            if (info.GetLength() != 0) {
                CAutoArray<CSimpleStringA> arr = info.Split('|');
                int len = arr.GetCount();
                if (len != 3) {
                    DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Not errPage Check config info.");
                }
                else
                {
                    chineseName = arr[0];
                    entityName = arr[1];
                    key = arr[2];

                    spCtSettingConfig->ReadConfigValue(entityName.GetData(), key.GetData(), url);
                    if (url.GetLength() != 0) {
                        bizNames.Append(&chineseName, 0, 1);
                        bizLinks.Append(&url, 0, 1);
                    }
                    else
                    {
                        DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Get errPage detecet url failed. EntityName:(%s), Key:(%s).",
                            entityName.GetData(), key.GetData());
                    }
                }
            }
        } while (info.GetLength() != 0);
    }
    ctx->Ans.bizLinks = bizLinks;
    ctx->Ans.bizNames = bizNames;

    if (ctx != NULL) {
        ctx->Answer(ec);
    }
    return ec;
}

#ifdef _MSC_VER

BOOL ResourceWatcherFSM::CalCulateUploadFileAddition(ULARGE_INTEGER& uiBytesCal)
{
    uiBytesCal.QuadPart = 0;
    BOOL bRet = FALSE;
    ErrorCodeEnum ec = Error_Unexpect;
    CSimpleStringA uploadVideoPath;
    ec = GetEntityBase()->GetFunction()->GetPath(UPLOAD_VIDEO_PATH, uploadVideoPath);
    if (uploadVideoPath.GetLength() <= 0) ec = Error_Param;
    if (ec == Error_Succeed) {
        CSimpleStringA filePath = uploadVideoPath + "\\*";
        ULARGE_INTEGER uliSpaceSize;
        uliSpaceSize.QuadPart = 0;
        int nFileCnt = ProcessFileSpaceCalculation(filePath, &uliSpaceSize);
        char szResult[DEFAULT_OUTPUT_FORMAT_SIZE];
        ByteSprintf(szResult, (double)uliSpaceSize.QuadPart);
        DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Result: Files(%d), Size(%s).", nFileCnt, szResult);
        uiBytesCal.QuadPart = uliSpaceSize.QuadPart;
    }
    return (ec == Error_Succeed);
}

int ResourceWatcherFSM::ProcessFileSpaceCalculation(LPCTSTR lpszPath, PULARGE_INTEGER puliSpaceBytes)
{
    int fileCnt = 0;
    int fileLength = strlen(lpszPath);
    char* searchFilePath = new char[MAX_PATH];
    char* tempFilePath = new char[MAX_PATH];
    if (searchFilePath == NULL || tempFilePath == NULL)
    {
        if (searchFilePath) delete[] searchFilePath;
        if (tempFilePath) delete[] tempFilePath;
        return fileCnt;
    }
    ZeroMemory(searchFilePath, MAX_PATH);
    ZeroMemory(tempFilePath, MAX_PATH);

    WIN32_FIND_DATA wfd;
    HANDLE hFind;

    hFind = FindFirstFile(lpszPath, &wfd);
    if (hFind == INVALID_HANDLE_VALUE)
    {
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("FindFirstFile failed GLE = %u.", GetLastError());
        if (searchFilePath) delete[] searchFilePath;
        if (tempFilePath) delete[] tempFilePath;
        return 0;
    }
    do
    {
        if ((wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY)
        {
            if (wfd.cFileName[0] != '.')
            {
                strcpy_s(tempFilePath, MAX_PATH, lpszPath);
                tempFilePath[fileLength - 1] = '\0';
                if (strlen(tempFilePath) + strlen(wfd.cFileName) + 3 >= MAX_PATH)
                {
                    DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("filePath is too long for current.");
                }
                else
                {
                    strcat_s(tempFilePath, MAX_PATH, wfd.cFileName);
                    strcat_s(tempFilePath, MAX_PATH, "\\*");
                    fileCnt += ProcessFileSpaceCalculation((LPCTSTR)tempFilePath, puliSpaceBytes);
                }
            }
        }
        else
        {
            strcpy_s(searchFilePath, MAX_PATH, lpszPath);
            searchFilePath[fileLength - 1] = '\0';
            strcat_s(searchFilePath, MAX_PATH, wfd.cFileName);

            ULARGE_INTEGER uiTemp;
            uiTemp.HighPart = wfd.nFileSizeHigh;
            uiTemp.LowPart = wfd.nFileSizeLow;
            puliSpaceBytes->QuadPart += uiTemp.QuadPart;

            SYSTEMTIME stUTC, stLocal;
            FileTimeToSystemTime(&wfd.ftLastWriteTime, &stUTC);
            SystemTimeToTzSpecificLocalTime(NULL, &stUTC, &stLocal);
            UINT uDate = stLocal.wYear * 10000 + stLocal.wMonth * 100 + stLocal.wDay;
            VideoDailyRecord[uDate]++;
            fileCnt++;
        }
    } while (FindNextFileA(hFind, &wfd));
    FindClose(hFind);
    if (searchFilePath) delete[] searchFilePath;
    if (tempFilePath) delete[] tempFilePath;
    return fileCnt;
}
#endif // _MSC_VER

DWORD ResourceWatcherFSM::ExecuteFile(LPCTSTR lpszFilePath, LPCTSTR lpParam)
{
    DWORD dwRes = 0;
#ifdef _MSC_VER
    SHELLEXECUTEINFOA shell;
    memset(&shell, 0, sizeof(SHELLEXECUTEINFOA));
    shell.cbSize = sizeof(SHELLEXECUTEINFOA);
    shell.lpFile = lpszFilePath;
    shell.lpParameters = lpParam;
    shell.fMask = SEE_MASK_INVOKEIDLIST;
    shell.lpVerb = NULL;
    shell.nShow = SW_SHOWDEFAULT;
    if (!ShellExecuteExA(&shell))
    {
        dwRes = GetLastError();
        int nRes = (int)shell.hInstApp;
        DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("GLE=%u, InstApp=%d", dwRes, nRes);
        switch (dwRes) {
        case ERROR_NO_ACE_CONDITION:
            LogWarn(Severity_Middle, Error_MethodNotFound, dwRes,
                CSimpleStringA::Format("Target file(%s) association not available !", lpszFilePath));
            break;
        case ERROR_ACCESS_DENIED:
            LogWarn(Severity_Middle, Error_NoPrivilege, dwRes,
                CSimpleStringA::Format("Target file(%s) not privilege !", lpszFilePath));
            break;
        case ERROR_PATH_NOT_FOUND:
        case ERROR_FILE_NOT_FOUND:
            LogWarn(Severity_Middle, Error_NotExist, dwRes,
                CSimpleStringA::Format("Target file(%s) not existed !", lpszFilePath));
            break;
        case ERROR_DLL_NOT_FOUND:
            LogWarn(Severity_Middle, Error_NotExist, dwRes,
                CSimpleStringA::Format("One of library file for Target(%s) not existed !", lpszFilePath));
            break;
        case ERROR_NOT_ENOUGH_MEMORY:
            LogWarn(Severity_Middle, Error_Resource, dwRes,
                CSimpleStringA::Format("Not enough memory for Target(%s) to perform !", lpszFilePath));
            break;
        case ERROR_SHARING_VIOLATION:
            LogWarn(Severity_Middle, Error_Overflow, dwRes,
                CSimpleStringA::Format("Violation occurred for Target(%s) to share !", lpszFilePath));
            break;
        default:
            LogWarn(Severity_Middle, Error_Unexpect, dwRes,
                CSimpleStringA::Format("Unpected condtion for Target(%s) to execute(%u) !"
                    , lpszFilePath, dwRes));
            break;
        }
    }
#else
    dwRes = 1;
#endif //_MSC_VER
    return dwRes;
}

#ifdef _MSC_VER
BOOL ResourceWatcherFSM::ClearDirRecursiveEx(LPCSTR lpDirPath)
{
    int len = strlen(lpDirPath);
    if (lpDirPath == NULL || len == 0)
        return FALSE;
    if (len + 2 >= MAX_PATH)
    {
        return FALSE;
    }
    char* path = new char[MAX_PATH];
    if (path == NULL) return FALSE;
    memset(path, 0, sizeof(path));
    strcpy_s(path, MAX_PATH, lpDirPath);
    int pos = len - 1;
    for (; pos >= 0 && (path[pos] == '/' || path[pos] == '\\'); --pos)
        path[pos] = '\0';
    path[pos + 1] = '\0';
    strcat_s(path, MAX_PATH, "\\*");
    len = strlen(path);

    char tempFilePath[MAX_PATH];
    ZeroMemory(tempFilePath, MAX_PATH);
    WIN32_FIND_DATA wfd;
    HANDLE hFind;
    hFind = FindFirstFile(path, &wfd);
    if (hFind == INVALID_HANDLE_VALUE)
    {
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("FindFirstFile failed GLE = %u.", GetLastError());
        delete[] path;
        return FALSE;
    }
    BOOL bResult = TRUE;
    do
    {
        if ((wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY)
        {
            if (wfd.cFileName[0] != '.')
            {
                strcpy_s(tempFilePath, path);
                tempFilePath[len - 1] = '\0';
                if (len + strlen(wfd.cFileName) > MAX_PATH)
                {
                    bResult = FALSE;
                    break;
                }
                else
                {
                    strcat_s(tempFilePath, wfd.cFileName);
                    if (!RemoveDirRecursiveA(tempFilePath))
                    {
                        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("RemoveDirRecursiveA(%s) failed", tempFilePath);
                        bResult = FALSE;
                        break;
                    }
                }
            }
        }
        else
        {
            strcpy_s(tempFilePath, path);
            tempFilePath[len - 1] = '\0';
            strcat_s(tempFilePath, wfd.cFileName);
            if (!RemoveFileA(tempFilePath))
            {
                DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("RemoveFileA(%s) failed", tempFilePath);
                bResult = FALSE;
                break;
            }
        }
    } while (FindNextFileA(hFind, &wfd));
    FindClose(hFind);
    if (path) delete[] path;
    return bResult;
}
#endif // _MSC_VER

BOOL ResourceWatcherFSM::ClearAd0Folder()
{
    LOG_FUNCTION();
    ErrorCodeEnum ec;
    CSimpleStringA strAd0Path;
    CSmartPointer<IConfigInfo> spConfigRun;
    int nLastTaskTime(0);
    CSimpleStringA ssFilePath(true);
    ec = GetEntityBase()->GetFunction()->OpenConfig(Config_Run, spConfigRun);
    spConfigRun->ReadConfigValueInt("LastClearTime", "Ad0Task", nLastTaskTime);
    if (IsTodayDone(nLastTaskTime)) {
        return TRUE;
    }

    ec = GetEntityBase()->GetFunction()->GetPath("Ad0", strAd0Path);
    if (ec != Error_Succeed || strAd0Path.IsNullOrEmpty()) {
        return FALSE;
    }
    if (!ExistsDirA(strAd0Path)) {
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("The Folder is not existed");
        spConfigRun->WriteConfigValue("LastClearTime", "Ad0Task",
            (const char*)CSimpleStringA::Format("0x%08X", (DWORD)CSmallDateTime::GetNow()));
        return TRUE;
    }

    char displayTime[MAX_PATH] = { 0 };
    ZeroMemory(&mftAd0RemoveTime, sizeof(FILETIME));
    CalculateBackTime(&mftAd0RemoveTime, AD0_DAY_OF_BACKWARD);
    GetTimeFormatStr(displayTime, MAX_PATH, &mftAd0RemoveTime);
    DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("The date backward to delete: %s", displayTime);

#ifdef RVC_OS_LINUX
    ssFilePath = strAd0Path;
#else
    ssFilePath = strAd0Path + "\\*";
#endif // RVC_OS_LINUX
    int nDelSuc = 0;
    int nDelFailed = 0;
    int nfileSum = ClearSpecifieFile(DFT_Ad0, (LPCTSTR)ssFilePath, nDelSuc, nDelFailed);
    DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("#Ad0#There are %d file(s), delete: %d, failed: %d.", nfileSum, nDelSuc, nDelFailed);

    spConfigRun->WriteConfigValue("LastClearTime", "Ad0Task",
        (const char*)CSimpleStringA::Format("0x%08X", (DWORD)CSmallDateTime::GetNow()));
    return TRUE;
}

BOOL ResourceWatcherFSM::IsTodayDone(int nRecordTime)
{
    if (nRecordTime <= 0) {
        return FALSE;
    }
    SYSTEMTIME stNow = {};
    SYSTEMTIME stTaskTime = CSmallDateTime(nRecordTime).ToSystemTime();
    DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Last record time: %04d-%02d-%02d %02d:%02d:%02d",
        stTaskTime.wYear, stTaskTime.wMonth, stTaskTime.wDay,
        stTaskTime.wHour, stTaskTime.wMinute, stTaskTime.wSecond);
#ifdef RVC_OS_LINUX
    stNow = CSmallDateTime::GetNow().ToSystemTime();
#else
    GetLocalTime(&stNow);
#endif // RVC_OS_LINUX
    if (stTaskTime.wYear == stNow.wYear
        && stTaskTime.wMonth == stNow.wMonth
        && stTaskTime.wDay == stNow.wDay)
    {
        DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("task has been executed today, last clear time: %s",
            (const char*)CSmallDateTime(nRecordTime).ToTimeString());
        return TRUE;
    }
    return FALSE;
}

///*TODO: 使用共用库的接口 (80374374@11/24/2023)*/
BOOL ResourceWatcherFSM::GetSystemBootTime(CSmallDateTime& systemBootTime)
{
#ifdef RVC_OS_LINUX
    DWORD ticks = 0;
    SYSTEMTIME systemTime;

    struct sysinfo info;
    time_t curTime = 0;
    time_t bootTime = 0;
    struct tm* ptm = NULL;
    if (sysinfo(&info)) {
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Failed to get sysinfo, errno:%u, reason:%s", errno, strerror(errno));
        return FALSE;
    }
    time(&curTime);
    if (curTime > info.uptime) {
        bootTime = curTime - info.uptime;
    }
    else
    {
        bootTime = info.uptime - curTime;
    }
    ptm = localtime(&bootTime);
    struct timespec ts;
    if (!clock_gettime(CLOCK_MONOTONIC_RAW, &ts))
        ticks = (ts.tv_sec * 1000) + (ts.tv_nsec / 1000000);

    systemTime.wYear = (WORD)(ptm->tm_year + 1900);
    systemTime.wMonth = (WORD)(ptm->tm_mon + 1);
    systemTime.wDayOfWeek = (WORD)ptm->tm_wday;
    systemTime.wDay = (WORD)ptm->tm_mday;
    systemTime.wHour = (WORD)ptm->tm_hour;
    systemTime.wMinute = (WORD)ptm->tm_min;
    systemTime.wSecond = (WORD)ptm->tm_sec;
    systemTime.wMilliseconds = (WORD)(ticks % 1000);

    systemBootTime.FromSystemTime(systemTime);
    DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("OSStartTime: %s", systemBootTime.ToTimeString().GetData());
    return TRUE;
#else
    PDH_STATUS Status;
    HQUERY Query = NULL;
    HCOUNTER hcElapsedTimeCount;
    BOOL fSuc = FALSE;
    /** 杀毒软件会对附件这几个系统调用函数有所监控，导致有时会耗费5s时间 Gifur@20221019]*/
    Status = PdhOpenQuery(NULL, NULL, &Query);
    PDH_FMT_COUNTERVALUE counterValue;
    if (Status != ERROR_SUCCESS) {
        DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM)("PdhOpenQuery failed with status 0x%x.", Status);
        goto Cleanup;
    }
    Status = PdhAddCounter(Query, SystemElapsedQuery, NULL, &hcElapsedTimeCount);
    if (Status != ERROR_SUCCESS) {
        DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM)("PdhAddCounter for SystemElapsedQuery failed with status 0x%x.", Status);
        goto Cleanup;
    }
    // 查询性能监视器数据
    Status = PdhCollectQueryData(Query);
    if (Status != ERROR_SUCCESS) {
        DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM)("PdhCollectQueryData failed with 0x%x.", Status);
        goto Cleanup;
    }
    Status = PdhGetFormattedCounterValue(hcElapsedTimeCount, PDH_FMT_LARGE, NULL, &counterValue);
    if (Status == ERROR_SUCCESS) {
        ULONGLONG ulSinceSeconds = counterValue.largeValue;
        ULONG days = 0, hours = 0, minutes = 0, seconds = 0;
        days = ULONG(ulSinceSeconds / DAY_DIV);
        ulSinceSeconds %= DAY_DIV;
        hours = ULONG(ulSinceSeconds / HOURS_DIV);
        ulSinceSeconds %= HOURS_DIV;
        minutes = ULONG(ulSinceSeconds / MINUS_DIV);
        ulSinceSeconds %= MINUS_DIV;
        seconds = ULONG(ulSinceSeconds);

        DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("SystemElapseTime: %u %02u:%02u:%02u", days, hours, minutes, seconds);

        FILETIME ftCurTime, ftStartTime;
        GetSystemTimeAsFileTime(&ftCurTime);
        ULARGE_INTEGER uliCurTime;
        uliCurTime.HighPart = ftCurTime.dwHighDateTime;
        uliCurTime.LowPart = ftCurTime.dwLowDateTime;
        uliCurTime.QuadPart -= counterValue.largeValue * 1e7;

        ftStartTime.dwHighDateTime = uliCurTime.HighPart;
        ftStartTime.dwLowDateTime = uliCurTime.LowPart;

        SYSTEMTIME stUTC, stLocal;

        FileTimeToSystemTime(&ftStartTime, &stUTC);
        char temp[22];
        SystemTimeToTzSpecificLocalTime(NULL, &stUTC, &stLocal);
        sprintf_s(temp, 22, "%d-%02d-%02d %02d:%02d:%02d",
            stLocal.wYear, stLocal.wMonth, stLocal.wDay, stLocal.wHour, stLocal.wMinute, stLocal.wSecond);
        DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("OSStartTime: %s", temp);
        systemBootTime.FromSystemTime(stLocal);
        fSuc = TRUE;
    }
Cleanup:
    Status = PdhRemoveCounter(hcElapsedTimeCount);
    if (Query) {
        PdhCloseQuery(Query);
    }
    return fSuc;
#endif // RVC_OS_LINUX
}

#ifdef _MSC_VER
bool ResourceWatcherFSM::CreateLinkFile(const CSimpleStringA& szStartAppPath, const CSimpleStringA& szAddCmdLine,
    const CSimpleStringA& szDestLnkPath, const CSimpleStringA& szIconPath)
{
    HRESULT hr = CoInitialize(NULL);
    bool bRet = false;
    if (SUCCEEDED(hr))
    {
        IShellLink* pShellLink;
        hr = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_IShellLink, (void**)&pShellLink);
        if (SUCCEEDED(hr))
        {
            pShellLink->SetPath(szStartAppPath);
            string strTmp = szStartAppPath;
            int nStart = strTmp.find_last_of("/\\");
            pShellLink->SetWorkingDirectory(strTmp.substr(0, nStart).c_str());
            pShellLink->SetArguments(szAddCmdLine);
            if (szIconPath)
            {
                pShellLink->SetIconLocation(szIconPath, 0);
            }
            IPersistFile* pPersistFile;
            hr = pShellLink->QueryInterface(IID_IPersistFile, (void**)&pPersistFile);
            if (SUCCEEDED(hr))
            {
                hr = pPersistFile->Save(CSimpleStringA2W(szDestLnkPath).GetData(), FALSE);
                if (SUCCEEDED(hr))
                {
                    bRet = true;
                }
                pPersistFile->Release();
            }
            pShellLink->Release();
        }
        CoUninitialize();
    }
    return bRet;
}

void ResourceWatcherFSM::CreateLink(const CSimpleStringA& exePath, const CSimpleStringA& csVersion)
{
    LPITEMIDLIST lp;
    SHGetSpecialFolderLocation(0, CSIDL_DESKTOPDIRECTORY, &lp);
    CHAR lstr[100] = "";
    SHGetPathFromIDList(lp, lstr);
    CSimpleStringA s = lstr;
    s += "\\可视柜台.lnk";

    CSimpleStringA icoPath;
    ErrorCodeEnum Error = GetEntityBase()->GetFunction()->GetPath("RootVer", icoPath);
	icoPath = icoPath + "\\" + csVersion.GetData() + "\\bin\\VTM.ico";
	if (!CreateLinkFile(exePath, "", s, icoPath))
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("CreateLinkFile DESKTOP fail");
	}

	SHGetSpecialFolderLocation(0, CSIDL_PROGRAMS, &lp);
	memset(lstr, 0, strlen(lstr));
	SHGetPathFromIDList(lp, lstr);
	s = lstr;
	s += "\\可视柜台.lnk";
	if (!CreateLinkFile(exePath, "", s, icoPath))
	{
		DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("CreateLinkFile CSIDL_PROGRAMS fail");
	}
}

bool ResourceWatcherFSM::CopyExeToRoot(const CSimpleStringA& csVersion)
{
    CSimpleStringA rootVerPath, exePath;
    ErrorCodeEnum rc = GetEntityBase()->GetFunction()->GetPath("RootVer", rootVerPath);
    exePath = rootVerPath + "\\VTM.exe";
    DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("exePath:%s", exePath.GetData());
    if (rc == Error_Succeed)
    {
        CSimpleStringA srcExePath, csPath = rootVerPath;
		srcExePath = rootVerPath + "\\" + csVersion.GetData() + "\\bin\\VTM.exe";
		DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("srcExePath:%s exePath：%s", srcExePath.GetData(), exePath.GetData());
        if (!ExistsFileA(srcExePath)) {
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("%s is not exist!", srcExePath.GetData());
			return false;
        }
		if (!CopyFileA(srcExePath.GetData(), exePath.GetData(), FALSE))
		{
			DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("CopyFileA Fail error :%d ", GetLastError());
			return false;
		}
    }
    else {
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("GetPath 4 RootVer failed: %s", SpStrError(rc));
        return false;
    }
    return true;
}

bool ResourceWatcherFSM::GetVtmVersionFromActiveTxt(CSimpleStringA& csVersion)
{
    bool bRet = false;
    CSimpleStringA rootVerPath;
    ErrorCodeEnum rc = GetEntityBase()->GetFunction()->GetPath("RootVer", rootVerPath);//获取version根路径
    if (rc != Error_Succeed) {
        LogWarn(Severity_Middle, Error_Exception, LOG_RESOURCEWATCHER_OPEN_ACTIVE_FAIL, "testActive fail , get RootVer path is fai");
        return false;
    }
    CSimpleStringA strActiveFile = CSimpleStringA::Format("%s\\active.txt", rootVerPath.GetData());
    FILE* pFile = fopen(strActiveFile.GetData(), "rb+");
    if (pFile != NULL)
    {
        char szTemp[256] = {};
        char szVersion[32] = {};
        int n = fread(szTemp, 1, 256, pFile);
        strncpy_s(szVersion, sizeof(szVersion), szTemp, _TRUNCATE);
        csVersion = szVersion;
        fclose(pFile);
        bRet = true;
    }
    else
    {
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Open active.txt failed.");
        bRet = false;
    }
    return bRet;

}

bool ResourceWatcherFSM::GetRegValue(HKEY hKey, LPCTSTR lpcszParam,
    CHAR* pSzValue, DWORD* pDwSizeOfSz)
{
    DWORD dwType = REG_SZ;
    TCHAR szValue[MAX_PATH + 1] = { 0 };
    DWORD dwSize = MAX_PATH * sizeof(CHAR);
    LONG lResult = RegQueryValueEx(hKey, lpcszParam, NULL, &dwType, (LPBYTE)szValue, pDwSizeOfSz);
    if (lResult == ERROR_SUCCESS) {
        strcpy_s(pSzValue, *pDwSizeOfSz, szValue);
        return true;
    }
    else {
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("RegQueryValueEx for \"%s\" error, result=%ld.", lpcszParam, lResult);
        return false;
    }

}

void ResourceWatcherFSM::DetectAutoStartupCover()
{
    int bStartupByVbs(0);
    DetectAutoStartup(bStartupByVbs);
    if (m_forceStartupWithExeFlag == 1 && bStartupByVbs == 1 && !m_IsPadDevice) {
        ChangeAutoStartupWithExe(); //test succ
    }
    else if (m_forceStartupWithExeFlag == 2 && (bStartupByVbs == 0 || bStartupByVbs == 1) && !m_IsPadDevice)
    {
        ChangeAutoStartupWithExe(); //test succ || test succ
    }
    else if (m_forceStartupWithExeFlag == 3 && (bStartupByVbs == 1 || bStartupByVbs == 2))
    {
        ChangeAutoStartupWithExe(true); //test succ || test succ
    }
}

static int Is32R64Platform()
{
    static int isWow64 = -1;
    typedef BOOL(WINAPI* LPFN_ISWOW64PROCESS)(HANDLE, PBOOL);
    if (isWow64 == -1) {
        BOOL bIsWow64 = FALSE;
        LPFN_ISWOW64PROCESS fnIsWow64Process =
            (LPFN_ISWOW64PROCESS)GetProcAddress(GetModuleHandle("kernel32"), "IsWow64Process");
        if (NULL != fnIsWow64Process) {
            if (!fnIsWow64Process(GetCurrentProcess(), &bIsWow64)) {
                DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("detect is running with 64bit or not failed: %u", GetLastError());
                return -1;
            }
            else
            {
                isWow64 = bIsWow64 ? 1 : 0;
            }
        }
    }
    return isWow64;
}

void ResourceWatcherFSM::DetectAutoStartup(int& vbsType)
{
    LOG_FUNCTION();

    vbsType = -1;
    if (m_DoneDetectAutostart) {
        vbsType = -2;
        return;
    }
    DWORD dwFlag = KEY_READ | KEY_QUERY_VALUE | KEY_ENUMERATE_SUB_KEYS;
    if (Is32R64Platform() != 0) {
        dwFlag |= KEY_WOW64_64KEY;
    }

    HKEY hKey;
    LONG lResult = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
        TEXT("SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Winlogon"),
        0, dwFlag, &hKey);
    if (lResult == ERROR_SUCCESS) {
        DWORD dwType = REG_SZ;
        DWORD dwSize = MAX_PATH * sizeof(TCHAR);
        TCHAR szValue[MAX_PATH + 1] = { 0 };
        lResult = RegQueryValueEx(hKey, "Shell", NULL, &dwType, (LPBYTE)szValue, &dwSize);
        if (lResult == ERROR_SUCCESS) {
            CSimpleStringA value(szValue);
            if (value.IsNullOrEmpty() || value.Compare("explorer.exe") != 0) {
                if (value.IsEndWith(".vbs", true)) {
                    LogWarn(Severity_Low, Error_Debug, LOG_WARN_AUTO_STARTUP_FROM_REGIST, value);
                    vbsType = 1;
                }
                else if (value.IsEndWith("VTM.exe", true)) {
                    LogWarn(Severity_Low, Error_Debug, LOG_WARN_CHECK_AUTO_STARTUP_WITH_EXE, value);
                    vbsType = 2;
                }
            }
            else {
                LogWarn(Severity_Low, Error_Debug, LOG_WARN_NOT_AUTO_STARTUP_FROM_REGIST, value);
                if (value.Compare("explorer.exe") == 0) {
                    vbsType = 0;
                }
            }
        }
        else {
            LogWarn(Severity_Low, Error_Unexpect, LOG_WARN_CHECK_AUTO_STARTUP_FROM_REGIST_FAILED,
                CSimpleStringA::Format("RegQueryValueEx error returned %u, GLE=%u.", lResult, GetLastError()));
        }
    }
    else {
        LogWarn(Severity_Middle, Error_Unexpect, LOG_WARN_CHECK_AUTO_STARTUP_FROM_REGIST_FAILED,
            CSimpleStringA::Format("RegOpenKeyEx error, GLE=%u.", GetLastError()));
    }
    RegCloseKey(hKey);
    m_DoneDetectAutostart = true;
    return;
}

ErrorCodeEnum ResourceWatcherFSM::ChangeAutoStartupWithExe(bool resetExplorer)
{
    const char* exploreExe = "explorer.exe";
    ErrorCodeEnum result(Error_Succeed);
    CSimpleStringA exePath(true);
    if (resetExplorer) {
        exePath = exploreExe;
    }
    else
    {
        result = GetEntityBase()->GetFunction()->GetPath("RootVer", exePath);
        if (exePath.IsNullOrEmpty() || result != Error_Succeed) {
            DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Get RootVer path failed: %d", result);
            return Error_Unexpect;
        }
        exePath.Append("\\VTM.exe");
        if (!ExistsFileA(exePath)) {
            DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("[%s] is not existed!", exePath.GetData());
            return Error_NotExist;
        }
    }

    DWORD dwFlag = KEY_WRITE;
    if (Is32R64Platform() != 0) {
        dwFlag |= KEY_WOW64_64KEY;
    }
    HKEY hKey;
    LONG lResult = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
        TEXT("SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Winlogon"), 0, dwFlag, &hKey);
    if (lResult == ERROR_SUCCESS) {
        lResult = RegSetValueExA(hKey, "Shell", 0, REG_SZ, (const BYTE*)exePath.GetData(), exePath.GetLength());
        if (lResult == ERROR_SUCCESS) {
            LogWarn(Severity_Low, Error_Debug, LOG_WARN_UPDATE_AUTO_STARTUP_WITH_EXE_SUCC
                , CSimpleStringA::Format("RegSetValueExA for Shell with %s succ!", exePath.GetData()));
            result = Error_Succeed;
        }
        else
        {
            LogWarn(Severity_Middle, Error_Unexpect, LOG_WARN_UPDATE_AUTO_STARTUP_WITH_EXE_FAILED
                , CSimpleStringA::Format("RegSetValueExA for Shell with %s failed: %d", exePath.GetData(), lResult));
            result = Error_Unexpect;
        }
    }
    else
    {
        LogWarn(Severity_Middle, Error_Unexpect, LOG_WARN_UPDATE_AUTO_STARTUP_WITH_EXE_FAILED
            , CSimpleStringA::Format("RegOpenKeyEx for write %s failed: %d", exePath.GetData(), lResult));
        result = Error_Unexpect;
    }

    RegCloseKey(hKey);
    return result;
}

void ResourceWatcherFSM::InitialAutoStartupSetType()
{
    CSmartPointer<IConfigInfo> spConfig;
    GetEntityBase()->GetFunction()->OpenConfig(Config_CenterSetting, spConfig);
    int value(0);
    spConfig->ReadConfigValueInt(GetEntityBase()->GetEntityName(), "AutoStartCMD", value);
    if (value != 0) {
        m_forceStartupWithExeFlag = value;
        DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Get AutoStartCMD from CS: %d", m_forceStartupWithExeFlag);
    }
}

BOOL ResourceWatcherFSM::IsHasSetAutoStartupByFolder()
{
    BOOL result(FALSE);

    const char* STARTUP_DIR_FULL_PATH = "C:\\ProgramData\\Microsoft\\Windows\\Start Menu\\Programs\\StartUp";

#ifdef DEVOPS_ON_ST /*DevOps流水线编译，ST环境*/
    const char* CMB_LINK_FILE_NAME = "招商银行可视柜台（ST测试）.lnk";
#elif defined(DEVOPS_ON_UAT)/*DevOps流水线编译，UAT环境*/
    const char* CMB_LINK_FILE_NAME = "招商银行可视柜台（UAT测试）.lnk";
#elif defined(DEVOPS_ON_PRD)/*DevOps流水线编译，PRD环境*/
    const char* CMB_LINK_FILE_NAME = "招商银行可视柜台.lnk";
#elif defined(DEVOPS_ON_DEV)/*DevOps流水线编译，Dev环境*/
    const char* CMB_LINK_FILE_NAME = "招商银行可视柜台（开发）.lnk";
#else/*本地编译等非DevOps环境编译的版本*/
    const char* CMB_LINK_FILE_NAME = "招商银行可视柜台.lnk";
#endif
    if (!ExistsDirA(STARTUP_DIR_FULL_PATH)) {
        DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("[%s] dir is not exist!", STARTUP_DIR_FULL_PATH);
        return result;
    }

    auto arr = fileutil_get_sub_files(STARTUP_DIR_FULL_PATH);
    if (arr != NULL) {
        for (int i = 0; i < arr->nelts; ++i) {
            char* file = ARRAY_IDX(arr, i, char*);
            char* filename = strrchr(file, '\\');
            if (filename != NULL) { filename += 1; }
            DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("autostartup[%s]", filename);
            if (filename != NULL/* && strcmp(filename, CMB_LINK_FILE_NAME) == 0*/) {
                CSimpleStringA strfilename(filename);
                if (strfilename.IsStartWith("招商银行可视柜台") && strfilename.IsEndWith(".lnk")) {
                    result = TRUE;
                    break;
                }
            }
        }
        toolkit_array_free2(arr);
    }
    return result;
}

void ResourceWatcherFSM::DetectVersionHasChangedAndWarn()
{
    CSmartPointer<IConfigInfo> spRunConfig;
    GetEntityBase()->GetFunction()->OpenConfig(Config_Run, spRunConfig);
    UINT64 utVersion = 0;
    spRunConfig->ReadConfigValueHexInt("VersionMonitor", "LastVer", utVersion);
    CVersion lastVer(utVersion);
    if (lastVer.IsValid() && lastVer > m_RvcSysinfo.InstallVersion) {
        CSimpleStringA rootVerPath;
        CSimpleStringA warnInfo = CSimpleStringA::Format("version changed from %s to %s", lastVer.ToString().GetData(), m_RvcSysinfo.InstallVersion.ToString().GetData());
        GetEntityBase()->GetFunction()->GetPath("RootVer", rootVerPath);
        CSimpleStringA csPath = rootVerPath + "\\active.txt";
        if (!ExistsFileA(csPath)) {
            LogWarn(Severity_Low, Error_Debug, LOG_WARN_ACTIVE_FILE_CHANGE, CSimpleStringA::Format("%s: active.txt not exist!", warnInfo.GetData()));
        }
        else
        {
            CSimpleFileComponent activeFileInfo;
            HANDLE hFile = CreateFileA(
                csPath,
                GENERIC_READ,
                FILE_SHARE_READ,
                NULL,
                OPEN_EXISTING,
                FILE_ATTRIBUTE_NORMAL | FILE_FLAG_BACKUP_SEMANTICS,
                NULL);
            if (hFile == INVALID_HANDLE_VALUE) {
                LogWarn(Severity_Low, Error_Debug, LOG_WARN_ACTIVE_FILE_CHANGE, CSimpleStringA::Format("%s: active.txt open failed %u", warnInfo.GetData(), GetLastError()));
            }
            else
            {
                GetFileTime(hFile, (LPFILETIME)&activeFileInfo.mftCreate,
                    (LPFILETIME)&activeFileInfo.mftAccess, (LPFILETIME)&activeFileInfo.mftModified);
                CloseHandle(hFile);
                char szFormat1[128] = { 0 };
                GetTimeFormatStr(szFormat1, 128, (FILETIME*)&activeFileInfo.mftCreate);
                char szFormat2[128] = { 0 };
                GetTimeFormatStr(szFormat2, 128, (FILETIME*)&activeFileInfo.mftAccess);
                char szFormat3[128] = { 0 };
                GetTimeFormatStr(szFormat3, 128, (FILETIME*)&activeFileInfo.mftModified);
                LogWarn(Severity_Low, Error_Debug, LOG_WARN_ACTIVE_FILE_CHANGE, CSimpleStringA::Format(
                    "%s: active.txt create at %s, access at %s, modified at %s", warnInfo.GetData(), szFormat1, szFormat2, szFormat3));
            }
        }
    }
    if (!lastVer.IsValid() || lastVer != m_RvcSysinfo.InstallVersion) {
        spRunConfig->WriteConfigValueHexInt("VersionMonitor", "LastVer", m_RvcSysinfo.InstallVersion.GetVersion64());
    }
}

void ResourceWatcherFSM::DetectDestopFileAndWarn()
{
    const DWORD INFO_BUFFER_SIZE = 2048;
    char infoBuf[INFO_BUFFER_SIZE];
    DWORD bufCharCount = INFO_BUFFER_SIZE;
    char sys_disk = '\0';
    bufCharCount = INFO_BUFFER_SIZE;
    if (!GetComputerName(infoBuf, &bufCharCount))
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("GetComputerName failed, GLE=%u", GetLastError());
    else DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Computer name:      %s", infoBuf);

    // Get and display the user name. 
    ZeroMemory(infoBuf, INFO_BUFFER_SIZE);
    bufCharCount = INFO_BUFFER_SIZE;
    if (!GetUserName(infoBuf, &bufCharCount)) {
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("GetUserName failed, GLE=%u", GetLastError());
    }
    else
    {
        DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("User name:          %s", infoBuf);
        CSimpleStringA desktopFullPath = CSimpleStringA::Format("C:\\Users\\%s\\Desktop", infoBuf);
        auto arr = fileutil_get_sub_files(desktopFullPath);
        CSimpleStringA filelist(true);
        int dirCount(0), fileCount(0);
        if (arr != NULL) {
            for (int i = 0; i < arr->nelts; ++i) {
                char* file = ARRAY_IDX(arr, i, char*);
                char* filename = strrchr(file, '\\');
                if (filename != NULL) { filename += 1; }
                else { filename = file; }
                fileCount++;
                if (!filelist.IsNullOrEmpty()) {
                    filelist += "|";
                }
                filelist += filename;
            }
            toolkit_array_free2(arr);
        }

        filelist += ";";
        arr = fileutil_get_sub_dirs(desktopFullPath);
        if (arr != NULL) {
            for (int i = 0; i < arr->nelts; ++i) {
                char* dir = ARRAY_IDX(arr, i, char*);
                char* dirname = strrchr(dir, '\\');
                if (dirname != NULL) { dirname += 1; }
                else { dirname = dir; }
                dirCount++;
                if (!filelist.IsNullOrEmpty() && i != 0) {
                    filelist += "|";
                }
                filelist += dirname;
            }
            toolkit_array_free2(arr);
        }
        LogWarn(Severity_Low, Error_Debug, LOG_INFO_DESKTOP_FILESTATUS, CSimpleStringA::Format(
            "%s's deskop: file(%d),dir(%d), list:(%s)", infoBuf, fileCount, dirCount,
            filelist.GetLength() < 950 ? filelist.GetData() : (filelist.SubString(0, 950) + "....").GetData()));
    }
}

ErrorCodeEnum ResourceWatcherFSM::DetectVTMInstalledBySetup(BOOL& fYes)
{
    HKEY key;
    ErrorCodeEnum result(Error_Succeed);
    fYes = FALSE;
    CSimpleStringA regPath = "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\{123BBC1D-8555-4E90-96CA-70E678FF5C24}_is1";
    LONG lResult = RegOpenKeyEx(HKEY_LOCAL_MACHINE, regPath, 0, KEY_ALL_ACCESS, &key);
    if (ERROR_SUCCESS == lResult) {
        fYes = TRUE;
        DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Found {123BBC1D-8555-4E90-96CA-70E678FF5C24}");
        LogWarn(Severity_Low, Error_Debug, LOG_INFO_INSTALL_BY_SETUP, "Intalled by Setup");
    }
    else if (ERROR_FILE_NOT_FOUND == lResult)
    {
        DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Not Found {123BBC1D-8555-4E90-96CA-70E678FF5C24}");
        fYes = FALSE;
    }
    else
    {
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("RegOpenKeyEx For{123BBC1D-8555-4E90-96CA-70E678FF5C24} error, Result=%ld.", lResult);
        fYes = FALSE;
        result = Error_Unexpect;
    }
    RegCloseKey(key);
    return result;
}

bool ResourceWatcherFSM::RegRdVtmVersion(CSimpleStringA& VTMpath, CSimpleStringA& vtmVersion)
{
    bool bRet = false;
    HKEY key;
    CSimpleStringA regPath = "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths\\VTM";
    CSimpleStringA regParaPath = "path";
    CSimpleStringA regParaVersion = "version";
    LONG lResult = RegOpenKeyEx(HKEY_LOCAL_MACHINE, regPath, 0, KEY_ALL_ACCESS, &key);
    char arrVTMpath[MAX_PATH] = { 0 }, arrVTMversion[MAX_PATH] = { 0 };
    if (ERROR_SUCCESS == lResult)
    {
        DWORD dwValue = MAX_PATH * sizeof(CHAR);
        bool res1 = GetRegValue(key, regParaPath, arrVTMpath, &dwValue);
        if (res1) {
            bRet = true;
            VTMpath = arrVTMpath;
        }
        else {
            bRet = false;
            RegCloseKey(key);
            return bRet;
        }

        dwValue = MAX_PATH * sizeof(CHAR);
        bool res2 = GetRegValue(key, regParaVersion, arrVTMversion, &dwValue);
        if (res2) {
            bRet = true;
            vtmVersion = arrVTMversion;
        }
        else {
            bRet = false;
            RegCloseKey(key);
            return bRet;
        }
    }
    else
    {
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("%s::RegOpenKeyEx error, Result=%ld.", __FUNCTION__, lResult);
        bRet = false;
    }
    RegCloseKey(key);
    return bRet;
}

bool ResourceWatcherFSM::RegWtVtmPath()
{
    bool bRet = true;
    HKEY key;
    CSimpleStringA regPath = "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths";
    if (ERROR_SUCCESS != RegOpenKeyEx(HKEY_LOCAL_MACHINE, regPath, 0, KEY_ALL_ACCESS, &key))
    {
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Open Reg failed.");
        bRet = false;
    }

    DWORD dwDisposition;
    regPath += "\\VTM";
    if (ERROR_SUCCESS != RegCreateKeyEx(HKEY_LOCAL_MACHINE, regPath.GetData(), 0, NULL,
        REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &key, &dwDisposition))
    {
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Create key failed");
        bRet = false;
    }
    if (ERROR_SUCCESS != RegOpenKeyEx(HKEY_LOCAL_MACHINE, regPath.GetData(), 0, KEY_ALL_ACCESS, &key))
    {
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Set value failed");
        bRet = false;
    }

    CSimpleStringA para = "path";
    CSimpleStringA exePath;
    ErrorCodeEnum Error = GetEntityBase()->GetFunction()->GetPath("RootVer", exePath);
    if (Error_Succeed == Error)
    {
        exePath += "\\VTM.exe";
        if (ERROR_SUCCESS != RegSetValueEx(key, para.GetData(), 0, REG_SZ, (BYTE*)exePath.GetData(), MAX_PATH))
        {
            DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Set path value failed");
            bRet = false;
        }
    }
    else
    {
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Get path of VTM.exe failed.");
    }

    ::RegCloseKey(key);
    return bRet;
}

bool ResourceWatcherFSM::RegWtVtmVersion()
{
    bool bRet = true;
    HKEY key;
    CSimpleStringA regPath = "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\App Paths";
    if (ERROR_SUCCESS != RegOpenKeyEx(HKEY_LOCAL_MACHINE, regPath, 0, KEY_ALL_ACCESS, &key))
    {
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Open Reg failed.");
        bRet = false;
    }

    DWORD dwDisposition;
    regPath += "\\VTM";
    if (ERROR_SUCCESS != RegCreateKeyEx(HKEY_LOCAL_MACHINE, regPath.GetData(), 0, NULL,
        REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &key, &dwDisposition))
    {
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Create key failed");
        bRet = false;
    }

    if (ERROR_SUCCESS != RegOpenKeyEx(HKEY_LOCAL_MACHINE, regPath.GetData(), 0, KEY_ALL_ACCESS, &key))
    {
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Set value failed");
        bRet = false;
    }
    CSimpleStringA para = "version";
    CSimpleStringA csVersion;
    if (GetVtmVersionFromActiveTxt(csVersion))
    {
        //RegSetValueEx(key, para.GetData(), 0, REG_SZ, (BYTE*)csVersion.GetData(), MAX_PATH);
        if (ERROR_SUCCESS != RegSetValueEx(key, para.GetData(), 0, REG_SZ, (BYTE*)csVersion.GetData(), MAX_PATH))
        {
            DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Set value failed");
            bRet = false;
        }
    }
    else
    {
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Get version of VTM.exe failed.");
    }

    ::RegCloseKey(key);
    return bRet;
}

bool ResourceWatcherFSM::RegOperation()
{
    bool bRet = true;
    CSimpleStringA  csVersion, VtmRegPath, VtmRegVersion;
    bool bGetActive = GetVtmVersionFromActiveTxt(csVersion);
    bool bRegRead = RegRdVtmVersion(VtmRegPath, VtmRegVersion);

    CSimpleStringA rootVerPath, exePath;
    ErrorCodeEnum rc = GetEntityBase()->GetFunction()->GetPath("RootVer", rootVerPath);
    exePath = rootVerPath + "\\VTM.exe";

    DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("csVersion :%s ,VtmRegVersion:%s ", csVersion.GetData(), VtmRegVersion.GetData());
    if (!ExistsFileA(exePath) || !bGetActive || !bRegRead || (0 != VtmRegVersion.Compare(csVersion, true)))
    {
        if (!ExistsFileA(exePath) && !CopyExeToRoot(csVersion))
        {
            DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Copy VTM.exe to version root fail.");
            bRet = false;
        }
        else
        {
            if (!RegWtVtmPath())
            {
                DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("RegWtVtmPath failed.");
            }
            if (!RegWtVtmVersion())
            {
                DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("RegWtVtmVersion failed.");
            }
            CreateLink(exePath, csVersion);
        }
    }

    return bRet;
}

bool ResourceWatcherFSM::UpdateExe()
{
    int updateExe = 0;
    CSmartPointer<IConfigInfo> spCtSettingConfig;
    GetEntityBase()->GetFunction()->OpenConfig(Config_CenterSetting, spCtSettingConfig);
    spCtSettingConfig->ReadConfigValueInt("NonExclusive", "UpdateExe", updateExe);

    if (updateExe == 1)
        return true;

    return false;
}

void ResourceWatcherFSM::VerifySignature()
{
    LOG_FUNCTION();
    CSimpleStringA strMsg(true);
    char* buffer = new char[MAX_PATH];
    getcwd(buffer, MAX_PATH);
    strcat(buffer, "\\*");
    DWORD elapsed = 0;
    DWORD dwStart = GetTickCount();
    DWORD dwEnd = GetTickCount();

    VerifySignature(buffer);
    if (m_nonSignedFiles.size() > 0)
    {
        CSimpleStringA fileList = "";
        for (size_t i = 0; i < m_nonSignedFiles.size(); i++)
        {

            fileList += GetFileName(m_nonSignedFiles[i]);
            if (i < m_nonSignedFiles.size() - 1)
                fileList += ",";
        }

        int toDisplay = m_iNonSignedTotal < m_iNonSignedDisplay ? m_iNonSignedTotal : m_iNonSignedDisplay;

        strMsg = CSimpleStringA::Format("共有%d个文件未签名，其中%d个为：%s.",
            m_iNonSignedTotal, toDisplay, fileList.GetData());
    }

    dwEnd = GetTickCount();
    elapsed = dwEnd - dwStart;

    strMsg = strMsg + CSimpleStringA::Format("签名耗时:%dms", elapsed);
    LogWarn(Severity_Low, Error_Unexpect, LOG_WARN_FILE_NOT_TRUSTED, (LPCTSTR)strMsg);
    delete buffer;
}

void ResourceWatcherFSM::VerifySignature(const CSimpleStringA& filePath)
{
    HANDLE hFind = NULL;
    WIN32_FIND_DATA fileInfo;
    DWORD64 dwSize = 0;
    hFind = FindFirstFile(filePath, &fileInfo);
    if (hFind == INVALID_HANDLE_VALUE)
        return;

    string strDirPath = filePath;
    do
    {
        if (fileInfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
        {
            if (!strcmp(fileInfo.cFileName, ".") || !strcmp(fileInfo.cFileName, ".."))
            {
                //Do nothing for "." and ".." folders
            }
            else
            {
                strDirPath.insert(strDirPath.find("*"), string(fileInfo.cFileName) + "\\");
                VerifySignature(strDirPath.c_str());
                strDirPath = filePath;
            }
        }
        else
        {
            CSimpleStringA fileName = fileInfo.cFileName;
            string strFileName = fileName;
            string strFilePath;

            if (strFileName.find(".dll") == string::npos && strFileName.find(".exe") == string::npos)
                continue;

            strFilePath = strDirPath;
            strFilePath.replace(strFilePath.find("*"), strFilePath.length(), string(fileInfo.cFileName));
            if (!RetrieveDigitalSignatureInfo(strFilePath.c_str()))
            {
                if (m_iNonSignedTotal < m_iNonSignedDisplay)
                {
                    m_nonSignedFiles.push_back(strFilePath.c_str());
                }
                m_iNonSignedTotal++;
            }
        }
    } while (FindNextFile(hFind, &fileInfo));
    FindClose(hFind);
}

CSimpleStringA ResourceWatcherFSM::GetFileName(const CSimpleStringA& filePath)
{
    CSimpleStringA tmp = filePath;
    auto arrPath = tmp.Split('\\');
    int size = arrPath.GetCount();
    return arrPath[size - 1];
}

bool ResourceWatcherFSM::RetrieveDigitalSignatureInfo(const char* pFilePath)
{
    HCERTSTORE hStore = NULL;
    HCRYPTMSG hMsg = NULL;

    WCHAR* wpFilePath = NULL;
    int len = ::MultiByteToWideChar(CP_ACP, 0, pFilePath, -1, NULL, 0);
    if (len > 0) {
        wpFilePath = new wchar_t[len + 1];
        std::memset(wpFilePath, 0, (len + 1) * sizeof(wchar_t));
        ::MultiByteToWideChar(CP_ACP, 0, pFilePath, -1, &wpFilePath[0], len);
    }

    if (CryptQueryObject(CERT_QUERY_OBJECT_FILE,
        wpFilePath,
        CERT_QUERY_CONTENT_FLAG_PKCS7_SIGNED_EMBED,
        CERT_QUERY_FORMAT_FLAG_BINARY,
        0,
        NULL,
        NULL,
        NULL,
        &hStore,
        &hMsg,
        NULL))
    {
        DWORD dwCountSigners = 0;
        DWORD dwcbSz = sizeof(dwCountSigners);
        if (CryptMsgGetParam(hMsg, CMSG_SIGNER_COUNT_PARAM, 0, &dwCountSigners, &dwcbSz))
        {
            if (dwCountSigners != 0)
            {
                dwcbSz = 0;
                CryptMsgGetParam(hMsg, CMSG_SIGNER_INFO_PARAM, 0, NULL, &dwcbSz);
                if (dwcbSz)
                {
                    PCMSG_SIGNER_INFO pSignerInfo = (PCMSG_SIGNER_INFO)new (std::nothrow) BYTE[dwcbSz];
                    if (pSignerInfo)
                    {
                        DWORD dwcbSz2 = dwcbSz;
                        if (CryptMsgGetParam(hMsg, CMSG_SIGNER_INFO_PARAM, 0, pSignerInfo, &dwcbSz) &&
                            dwcbSz == dwcbSz2)
                        {
                            if (VerifyFirstCertificate(hStore, pSignerInfo)
                                || VerifyOtherCertificate(pSignerInfo))
                                return true;
                        }

                        delete[] pSignerInfo;
                        pSignerInfo = NULL;
                    }
                }
            }
        }
    }

    if (hStore != NULL)
    {
        CertCloseStore(hStore, 0);
        hStore = NULL;
    }

    if (hMsg != NULL)
    {
        CryptMsgClose(hMsg);
        hMsg = NULL;
    }
    return false;
}

bool ResourceWatcherFSM::VerifyFirstCertificate(HCERTSTORE hStore, PCMSG_SIGNER_INFO pSignerInfo)
{
    CERT_INFO ci = { 0 };
    ci.Issuer = pSignerInfo->Issuer;
    ci.SerialNumber = pSignerInfo->SerialNumber;

    PCCERT_CONTEXT pCertContext = NULL;

    int c = 0;
    bool ret = false;
    for (;; c++)
    {
        pCertContext = CertFindCertificateInStore(hStore,
            ENCODING, 0, CERT_FIND_SUBJECT_CERT,
            (PVOID)&ci, pCertContext);

        if (!pCertContext)
        {
            break;
        }

        DWORD dwcbSz;
        char* pBuff;
        dwcbSz = CertGetNameString(pCertContext, CERT_NAME_SIMPLE_DISPLAY_TYPE, 0, NULL, NULL, 0);
        if (dwcbSz != 0)
        {
            pBuff = new (std::nothrow) char[dwcbSz];
            if (pBuff)
            {
                if (CertGetNameString(pCertContext, CERT_NAME_SIMPLE_DISPLAY_TYPE, 0, NULL, pBuff, dwcbSz) == dwcbSz)
                {
                    if (!strcmp(pBuff, "China Merchants Bank Co., Ltd") || !strcmp(pBuff, "Microsoft Corporation"))
                        ret = true;
                }

                delete[] pBuff;
                pBuff = NULL;
            }
        }
    }

    if (pCertContext)
    {
        CertFreeCertificateContext(pCertContext);
        pCertContext = NULL;
    }

    return ret;
}

bool ResourceWatcherFSM::VerifyOtherCertificate(PCMSG_SIGNER_INFO pSignerInfo)
{
    int ret = false;
    for (DWORD a = 0; a < pSignerInfo->UnauthAttrs.cAttr; a++)
    {
#ifndef szOID_NESTED_SIGNATURE
#define szOID_NESTED_SIGNATURE              "1.3.6.1.4.1.311.2.4.1"
#endif

        if (pSignerInfo->UnauthAttrs.rgAttr[a].pszObjId &&
            lstrcmpA(pSignerInfo->UnauthAttrs.rgAttr[a].pszObjId, szOID_NESTED_SIGNATURE) == 0)
        {
            HCRYPTMSG hMsg = ::CryptMsgOpenToDecode(X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, 0, 0, NULL, NULL, NULL);
            if (hMsg)
            {
                if (::CryptMsgUpdate(hMsg,
                    pSignerInfo->UnauthAttrs.rgAttr[a].rgValue->pbData,
                    pSignerInfo->UnauthAttrs.rgAttr[a].rgValue->cbData,
                    TRUE))
                {
                    DWORD dwSignerInfo = 0;
                    ::CryptMsgGetParam(hMsg, CMSG_SIGNER_INFO_PARAM, 0, NULL, &dwSignerInfo);
                    if (dwSignerInfo != 0)
                    {
                        PCMSG_SIGNER_INFO pSignerInfo2 = (PCMSG_SIGNER_INFO)new (std::nothrow) BYTE[dwSignerInfo];
                        if (pSignerInfo2)
                        {
                            if (::CryptMsgGetParam(hMsg, CMSG_SIGNER_INFO_PARAM,
                                0, (PVOID)pSignerInfo2, &dwSignerInfo))
                            {
                                CRYPT_DATA_BLOB c7Data;
                                c7Data.cbData = pSignerInfo->UnauthAttrs.rgAttr[a].rgValue->cbData;
                                c7Data.pbData = pSignerInfo->UnauthAttrs.rgAttr[a].rgValue->pbData;

                                //ret = FindAppropriateStoreAndVerifyFirstCertificate(pSignerInfo2, &c7Data);

                                HCERTSTORE hStore = NULL;

                                hStore = CertOpenStore(CERT_STORE_PROV_PKCS7, X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, NULL, 0, &c7Data);
                                ret = hStore && VerifyFirstCertificate(hStore, pSignerInfo2);

                                if (hStore)
                                {
                                    ::CertCloseStore(hStore, CERT_CLOSE_STORE_FORCE_FLAG);
                                    hStore = NULL;
                                }
                            }

                            delete[] pSignerInfo2;
                            pSignerInfo2 = NULL;
                        }
                    }
                }

                ::CryptMsgClose(hMsg);
            }
        }
    }
    return ret;
}

void ResourceWatcherFSM::ClearDumpFiles()
{
    int deleteSucCnt = 0;
    int deleteFailedCnt = 0;
    int fileCnt = 0;
    CSimpleStringA dmpPath;
    ErrorCodeEnum dmpError = GetEntityBase()->GetFunction()->GetPath("Temp", dmpPath);
    if (Error_Succeed != dmpError) {
        DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("get Dump path error");
        return;
    }

    dmpPath += CSimpleStringA::Format("\\..\\dmp");

    // =>=>  /*foundFileData.cFileName[0] != '.'*/ !!! be careful for backdate call for the function.
    char searchFilePath[MAX_PATH] = { 0 };
    char tempFilePath[MAX_PATH] = { 0 };
    char displayTime[MAX_PATH] = { 0 };

    WIN32_FIND_DATA foundFileData;
    HANDLE hFind;

    CSmartPointer<IConfigInfo> spCtSettingConfig;
    GetEntityBase()->GetFunction()->OpenConfig(Config_CenterSetting, spCtSettingConfig);
    int backDay = 0;
    ErrorCodeEnum re = spCtSettingConfig->ReadConfigValueInt("ResourceWatcher", "DumpClearBackDay", backDay);
    if (backDay < 7 || backDay >365 || re != Error_Succeed)
    {
        backDay = 7; //保留至少七天的dump文件
    }

    FILETIME ftRemoveTime;
    CalculateBackTime(&ftRemoveTime, backDay);
    GetTimeFormatStr(displayTime, MAX_PATH, &ftRemoveTime);
    DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("The date DUMPFILE backward to delete: %s", displayTime);

    string p;
    hFind = FindFirstFile(p.assign(string(dmpPath.GetData())).append("\\*").c_str(), &foundFileData);
    if (hFind != INVALID_HANDLE_VALUE) {
        do {
            if (CSimpleStringA::Format("%s", &foundFileData.cFileName) == "." || CSimpleStringA::Format("%s", &foundFileData.cFileName) == "..")
            {
                continue;
            }
            if (CompareFileTime(&ftRemoveTime, &foundFileData.ftLastWriteTime) >= 0)
            {
                GetTimeFormatStr(displayTime, MAX_PATH, &foundFileData.ftLastWriteTime);
                //strcpy_s(searchFilePath, (dmpPath + CSimpleStringA::Format("\\%s", &foundFileData.cFileName)).GetData());
                if (DeleteFile((dmpPath + CSimpleStringA::Format("\\%s", &foundFileData.cFileName)).GetData()) != 0)
                {
                    deleteSucCnt++;
                    DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Delete DUMPFILE matched %s(%s) suc.", foundFileData.cFileName, displayTime);
                }
                else
                {
                    deleteFailedCnt++;
                    DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Delete DUMPFILE matched %s(%s) failed(%d).", foundFileData.cFileName, displayTime, GetLastError());
                }
            }
            fileCnt++;
        } while (FindNextFile(hFind, &foundFileData));
        FindClose(hFind);
    }
    else
    {
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM) ("FindFirstFile failed (%u)", GetLastError());
        return;
    }

    DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Total [%d] dump files, delete suc[%d], failed[%d].", fileCnt, deleteSucCnt, deleteFailedCnt);
    return;
}

long long GetDirSizeFsm(string dirPath)
{
    long long fileLen = 0;
    long hFile = 0;
    //文件信息
    struct _finddata_t fileinfo;
    string p;
    if ((hFile = _findfirst(p.assign(dirPath).append("\\*").c_str(), &fileinfo)) != -1)
    {
        do
        {
            //如果是目录,迭代之
            //如果不是,加入列表
            if ((fileinfo.attrib & _A_SUBDIR))
            {
                if (strcmp(fileinfo.name, ".") != 0 && strcmp(fileinfo.name, "..") != 0)
                    fileLen += GetDirSizeFsm(p.assign(dirPath).append("\\").append(fileinfo.name));
            }
            else
            {
                fileLen += fileinfo.size;
            }
        } while (_findnext(hFile, &fileinfo) == 0);
        _findclose(hFile);
    }
    return fileLen;
}


struct CmpByValueFromBiggest //从最大的排起
{
    bool operator()(const pair<string, long>& l, const pair<string, long>& r) {
        return l.second > r.second;
    }
};

//unordered_map<string, long> fileSpace;
unordered_map<string, long> fileIncreasedSpace;
vector<pair<string, long>> sortFileIncreasedSpace;
unordered_map<string, long> fileSpace;
vector<pair<string, long>> sortFileSpace;

static bool spaceLock = false;

void ResourceWatcherFSM::CheckDiskFileSpace()
{
    if (spaceLock)
    {
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("当前已有硬盘扫描进行中，跳过。");
        return;
    }
    else
    {
        spaceLock = true; //加锁
    }



    CSmartPointer<IConfigInfo> spConfigRun;
    CSmartPointer<IConfigInfo> spCtSettingConfig;
    GetEntityBase()->GetFunction()->OpenConfig(Config_Run, spConfigRun);
    GetEntityBase()->GetFunction()->OpenConfig(Config_CenterSetting, spCtSettingConfig);

    int lastDiskUsed = 0;
    unsigned long long lastVer = 0;
    int spaceIncrease = 0; //硬盘增长阈值

    spConfigRun->ReadConfigValueHexInt("SpaceInfo", "OptVer", lastVer);
    spConfigRun->ReadConfigValueInt("SpaceInfo", "DiskTotalUsed(GB)", lastDiskUsed);
    spCtSettingConfig->ReadConfigValueInt(GetEntityBase()->GetEntityName(), "DiskUsedIncreaseInt(GB)", spaceIncrease);
    if (spaceIncrease == 0)
    {
        spaceIncrease = 5; //默认阈值5GB
    }

    if (!m_bNeedForceDiskCheck) //是否需要强制全盘扫描 - 硬盘使用过高是会强制
    {
        if (lastVer == m_RvcSysinfo.InstallVersion.GetVersion64())
        {
            if (lastDiskUsed != 0 && ((int)(GetDiskUsedByte() / (1024 * 1024 * 1024)) - lastDiskUsed) < spaceIncrease) //增长值判定
            {
                //DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("硬盘空间增长未超过阈值，无需扫描。");
                if (spaceLock)
                {
                    spaceLock = false; //释放锁
                }
                return;
            }
            else
            {
                //降低磁盘扫描频率
                SYSTEMTIME localTime;
                GetLocalTime(&localTime);
                if (m_diskLastWarnHour != localTime.wHour)
                {
                    m_diskLastWarnHour = localTime.wHour;
                    CSmartPointer<IConfigInfo> spConfigRun;
                    ErrorCodeEnum eErr = GetEntityBase()->GetFunction()->OpenConfig(Config_Run, spConfigRun);
                    if (eErr == Error_Succeed) {
                        spConfigRun->WriteConfigValueInt("WarnRecord", "disk", m_diskLastWarnHour);
                    }
                    DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("硬盘增长超过阈值，重点目录扫描！");
                }
                else
                {
                    //DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("磁盘增长最近1小时已扫描一次，暂不扫描。");
                    if (spaceLock)
                    {
                        spaceLock = false; //释放锁
                    }
                    return;
                }
            }
        }
        else
        {
            spConfigRun->WriteConfigValueHexInt("SpaceInfo", "OptVer", m_RvcSysinfo.InstallVersion.GetVersion64());
            DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("新版本，重点目录扫描");
        }
    }
    else
    {
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("强制扫描。");
    }

    CSystemStaticInfo sysInfo;
    string path("");
    GetEntityBase()->GetFunction()->GetSystemStaticInfo(sysInfo);
    if (sysInfo.strMachineType == "RVC.PAD")
    {
        path = "C:";
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("pad设备。扫描C盘。");
    }
    else
    {
        path = "D:";
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("非pad设备。扫描D盘。");
    }

    if (path.size() == 0)
    {
        if (spaceLock)
        {
            spaceLock = false; //释放锁
        }
        return;
    }

    long long fileLen = 0;
    long hFile = 0;
    //文件信息
    struct _finddata_t fileinfo;
    string p;
    if ((hFile = _findfirst(p.assign(path).append("\\*").c_str(), &fileinfo)) != -1)
    {
        do
        {
            //如果是目录,迭代之
            //如果不是,加入列表
            if ((fileinfo.attrib & _A_SUBDIR))
            {
                if (strcmp(fileinfo.name, ".") != 0 && strcmp(fileinfo.name, "..") != 0)
                    fileLen = GetDirSizeFsm(p.assign(path).append("\\").append(fileinfo.name));
                else
                {
                    continue;
                }
            }
            else
            {
                fileLen = fileinfo.size;
            }


            CSimpleStringA resLen = CSimpleStringA::Format("%lld B", fileLen);
            if (fileLen >= 1024 && fileLen < (1024 * 1024))
            {
                DOUBLE len = (DOUBLE)fileLen / 1024;
                resLen = CSimpleStringA::Format("%.2f KB", len);
            }
            else if (fileLen >= (1024 * 1024) && fileLen < (1024 * 1024 * 1024))
            {
                DOUBLE len = (DOUBLE)fileLen / (1024 * 1024);
                resLen = CSimpleStringA::Format("%.2f MB", len);
            }
            else if (fileLen >= (1024 * 1024 * 1024))
            {
                DOUBLE len = (DOUBLE)fileLen / (1024 * 1024 * 1024);
                resLen = CSimpleStringA::Format("%.2f GB", len);
            }


            CSimpleStringA oldLenStr("");
            long oldLen = 0;
            spConfigRun->ReadConfigValue("SpaceInfo",
                p.assign(path).append("\\").append(fileinfo.name).c_str(), oldLenStr);
            oldLen = atol(oldLenStr.GetData());

            fileIncreasedSpace[p.assign(path).append("\\").append(fileinfo.name)] = (long)(fileLen / (1024 * 1024)) - oldLen; //保存在unordered_map中
            fileSpace[p.assign(path).append("\\").append(fileinfo.name)] = (long)(fileLen / (1024 * 1024));
            DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("[%s] 大小为 [%s]",
                p.assign(path).append("\\").append(fileinfo.name).c_str(), resLen.GetData());

            if (lastVer != m_RvcSysinfo.InstallVersion.GetVersion64())
            {
                spConfigRun->WriteConfigValue("SpaceInfo", p.assign(path).append("\\").append(fileinfo.name).c_str(),
                    CSimpleStringA::Format("%ld MB", (long)(fileLen / (1024 * 1024))));
            }
        } while (_findnext(hFile, &fileinfo) == 0);
        _findclose(hFile);
    }


    //获取version目录下的文件夹大小	
    CSimpleStringA csPath;
    ErrorCodeEnum Error = m_pEntity->GetFunction()->GetPath("RootVer", csPath);   //获取当前版本路劲 例如：C:\Run

    fileLen = 0;
    hFile = 0;
    p = "";
    if ((hFile = _findfirst(p.assign(csPath.GetData()).append("\\*").c_str(), &fileinfo)) != -1)
    {
        do
        {
            //如果是目录,迭代之
            //如果不是,加入列表
            if ((fileinfo.attrib & _A_SUBDIR))
            {
                if (strcmp(fileinfo.name, ".") != 0 && strcmp(fileinfo.name, "..") != 0)
                    fileLen = GetDirSizeFsm(p.assign(csPath.GetData()).append("\\").append(fileinfo.name));
                else
                {
                    continue;
                }
            }
            else
            {
                fileLen = fileinfo.size;
            }


            CSimpleStringA resLen = CSimpleStringA::Format("%lld B", fileLen);
            if (fileLen >= 1024 && fileLen < (1024 * 1024))
            {
                DOUBLE len = (DOUBLE)fileLen / 1024;
                resLen = CSimpleStringA::Format("%.2f KB", len);
            }
            else if (fileLen >= (1024 * 1024) && fileLen < (1024 * 1024 * 1024))
            {
                DOUBLE len = (DOUBLE)fileLen / (1024 * 1024);
                resLen = CSimpleStringA::Format("%.2f MB", len);
            }
            else if (fileLen >= (1024 * 1024 * 1024))
            {
                DOUBLE len = (DOUBLE)fileLen / (1024 * 1024 * 1024);
                resLen = CSimpleStringA::Format("%.2f GB", len);
            }

            CSimpleStringA oldLenStr(""); //MB
            long oldLen = 0;
            spConfigRun->ReadConfigValue("SpaceInfo",
                p.assign(csPath.GetData()).append("\\").append(fileinfo.name).c_str(), oldLenStr);
            oldLen = atol(oldLenStr.GetData());
            fileIncreasedSpace[p.assign(csPath.GetData()).append("\\").append(fileinfo.name)] = (long)(fileLen / (1024 * 1024)) - oldLen; //保存在unordered_map中
            fileSpace[p.assign(csPath.GetData()).append("\\").append(fileinfo.name)] = (long)(fileLen / (1024 * 1024));

            DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("[%s] 大小为 [%s]",
                p.assign(csPath.GetData()).append("\\").append(fileinfo.name).c_str(), resLen.GetData());

            if (lastVer != m_RvcSysinfo.InstallVersion.GetVersion64())
            {
                spConfigRun->WriteConfigValue("SpaceInfo", p.assign(csPath.GetData()).append("\\").append(fileinfo.name).c_str(),
                    CSimpleStringA::Format("%ld MB", (long)(fileLen / (1024 * 1024))));
            }
        } while (_findnext(hFile, &fileinfo) == 0);
        _findclose(hFile);
    }


    //获取rvc目录下的文件夹大小	
    fileLen = 0;
    hFile = 0;
    p = "";
    if ((hFile = _findfirst(p.assign(path).append("\\rvc\\*").c_str(), &fileinfo)) != -1)
    {
        do
        {
            //如果是目录,迭代之
            //如果不是,加入列表
            if ((fileinfo.attrib & _A_SUBDIR))
            {
                if (strcmp(fileinfo.name, ".") != 0 && strcmp(fileinfo.name, "..") != 0)
                    fileLen = GetDirSizeFsm(p.assign(path).append("\\rvc\\").append(fileinfo.name));
                else
                {
                    continue;
                }
            }
            else
            {
                fileLen = fileinfo.size;
            }


            CSimpleStringA resLen = CSimpleStringA::Format("%lld B", fileLen);
            if (fileLen >= 1024 && fileLen < (1024 * 1024))
            {
                DOUBLE len = (DOUBLE)fileLen / 1024;
                resLen = CSimpleStringA::Format("%.2f KB", len);
            }
            else if (fileLen >= (1024 * 1024) && fileLen < (1024 * 1024 * 1024))
            {
                DOUBLE len = (DOUBLE)fileLen / (1024 * 1024);
                resLen = CSimpleStringA::Format("%.2f MB", len);
            }
            else if (fileLen >= (1024 * 1024 * 1024))
            {
                DOUBLE len = (DOUBLE)fileLen / (1024 * 1024 * 1024);
                resLen = CSimpleStringA::Format("%.2f GB", len);
            }

            CSimpleStringA oldLenStr("");
            long oldLen = 0;
            spConfigRun->ReadConfigValue("SpaceInfo",
                p.assign(path).append("\\rvc\\").append(fileinfo.name).c_str(), oldLenStr);
            oldLen = atol(oldLenStr.GetData());

            fileIncreasedSpace[p.assign(path).append("\\rvc\\").append(fileinfo.name)] = (long)(fileLen / (1024 * 1024)) - oldLen; //保存在unordered_map中
            fileSpace[p.assign(path).append("\\rvc\\").append(fileinfo.name)] = (long)(fileLen / (1024 * 1024));
            DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("[%s] 大小为 [%s]",
                p.assign(path).append("\\rvc\\").append(fileinfo.name).c_str(), resLen.GetData());

            if (lastVer != m_RvcSysinfo.InstallVersion.GetVersion64())
            {
                spConfigRun->WriteConfigValue("SpaceInfo", p.assign(path).append("\\rvc\\").append(fileinfo.name).c_str(),
                    CSimpleStringA::Format("%ld MB", (long)(fileLen / (1024 * 1024))));
            }
        } while (_findnext(hFile, &fileinfo) == 0);
        _findclose(hFile);
    }


    if (lastVer != m_RvcSysinfo.InstallVersion.GetVersion64())
    {
        //写入硬盘量
        spConfigRun->WriteConfigValueInt("SpaceInfo", "DiskTotalUsed(GB)", GetDiskUsedByte() / (1024 * 1024 * 1024));
        if (spaceLock)
        {
            spaceLock = false; //释放锁
        }
        return; //新版本无需上报文件信息，更新完运行时文件后即可结束
    }

    //获取增量最大的前十文件夹信息
    sortFileIncreasedSpace = vector<pair<string, long>>(fileIncreasedSpace.begin(), fileIncreasedSpace.end());
    sort(sortFileIncreasedSpace.begin(), sortFileIncreasedSpace.end(), CmpByValueFromBiggest());
    int topFileNum = sortFileIncreasedSpace.size();
    if (topFileNum > 10)
    {
        topFileNum = 10;
    }
    DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("变化最大的%d个文件夹信息。", topFileNum);

    fileLen = 0;
    for (int i = 0; i < topFileNum; i++)
    {
        fileLen = sortFileIncreasedSpace[i].second;
        if (fileLen == 0) break;
        CSimpleStringA warn1 = CSimpleStringA::Format("TOP %d: [%s], 增量[%ld]MB",
            i + 1, sortFileIncreasedSpace[i].first.c_str(), sortFileIncreasedSpace[i].second);
        LogWarn(Severity_Low, Error_Resource, LOG_RESOURCEWATCHER_FILE_TOPINCREASED_SPACE, warn1.GetData());
    }


    if (m_bNeedForceDiskCheck)
    {
        //获取空间占用最大前十文件夹信息
        sortFileSpace = vector<pair<string, long>>(fileSpace.begin(), fileSpace.end());
        sort(sortFileSpace.begin(), sortFileSpace.end(), CmpByValueFromBiggest());

        int topFileSize = sortFileSpace.size();
        if (topFileSize > 10)
        {
            topFileSize = 10;
        }
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("空间占用最大的%d个文件夹信息。", topFileSize);

        fileLen = 0;
        for (int i = 0; i < topFileSize; i++)
        {
            fileLen = sortFileSpace[i].second;
            if (fileLen == 0) break;
            CSimpleStringA warn2 = CSimpleStringA::Format("空间占用排名 %d: [%s], 大小[%ld]MB",
                i + 1, sortFileSpace[i].first.c_str(), sortFileSpace[i].second);
            LogWarn(Severity_Low, Error_Resource, LOG_RESOURCEWATCHER_FILE_TOPUSED_SPACE, warn2.GetData());
        }

        m_bNeedForceDiskCheck = false;
    }

    if (spaceLock)
    {
        spaceLock = false; //释放锁
    }
}


void ResourceWatcherFSM::GetSystemDiskStatus()
{
    if (m_diskHighPercent <= 0)
    {
        m_diskHighPercent = 90; //默认硬盘告警百分比90%
    }

    if (m_RvcSysinfo.strMachineType.Compare("RVC.PAD") != 0) //非pad设备扫描一下C盘
    {
        ULARGE_INTEGER ulAvailFreeTemp, ulTotalBytesTemp, ulTotalFreeTemp;
        BOOL retTemp = GetDiskFreeSpaceEx(TEXT("c:"), &ulAvailFreeTemp, &ulTotalBytesTemp, &ulTotalFreeTemp);
        if (retTemp == 0)
        {
            DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("GetSystemDiskStatus.GetDiskFreeSpaceEx failed(%d).", GetLastError());
            return;
        }

        DWORD dwAvFreeTemp = ulAvailFreeTemp.QuadPart / MILLION;
        DWORD dwTotalTemp = ulTotalBytesTemp.QuadPart / MILLION;
        DWORD dwTotalFreeTemp = ulTotalFreeTemp.QuadPart / MILLION;
        int ratioTemp = dwTotalFreeTemp * 100 / dwTotalTemp;

        if ((100 - ratioTemp) > m_diskHighPercent)
        {
            DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("The disk has %d MB(%d%%) available.\n", dwTotalFreeTemp, ratioTemp);
            char diskMessageTemp[1024];
            sprintf(diskMessageTemp, "{\"Disk\":\"C:\",\"total\":\"%0.2f GByte\",\"free ratio\":\"%d%%\"}",
                (double)dwTotalTemp / 1024, ratioTemp);

            LogWarn(Severity_Middle, Error_Resource, LOG_EVT_RESOURCE_HARDDISK_TOO_HIGH, diskMessageTemp);
        }
    }

    ULARGE_INTEGER ulAvailFree, ulTotalBytes, ulTotalFree;
    BOOL ret = GetDiskFreeSpaceEx(NULL, &ulAvailFree, &ulTotalBytes, &ulTotalFree);
    if (ret == 0)
    {
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("GetSystemDiskStatus.GetDiskFreeSpaceEx failed(%d).", GetLastError());
        return;
    }

    CSimpleStringA csBinPath;
    ErrorCodeEnum Error = m_pEntity->GetFunction()->GetPath("Bin", csBinPath);   //获取当前终端运行磁盘位置

    DWORD dwAvFree = ulAvailFree.QuadPart / MILLION;
    DWORD dwTotal = ulTotalBytes.QuadPart / MILLION;
    DWORD dwTotalFree = ulTotalFree.QuadPart / MILLION;
    int ratio = dwTotalFree * 100 / dwTotal;

    if ((100 - ratio) > m_diskHighPercent)
    {
        DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("The disk has %d MB(%d%%) available.\n", dwTotalFree, ratio);
        string test(csBinPath.GetData());
        char diskMessage[1024];
        sprintf(diskMessage, "{\"Disk\":\"%c:\",\"total\":\"%0.2f GByte\",\"free ratio\":\"%d%%\"}",
            csBinPath.GetData()[0], (double)dwTotal / 1024, ratio);

        //oilyang@20200526 根据wq建议，降低磁盘空间偏少的告警频率
        //SYSTEMTIME localTime;
        //GetLocalTime(&localTime);
        //if (m_diskLastWarnHour != localTime.wHour) //需要告警时才强制全盘扫描
        //{
        //	m_diskLastWarnHour = localTime.wHour;
        //	CSmartPointer<IConfigInfo> spConfigRun;
        //	ErrorCodeEnum eErr = GetEntityBase()->GetFunction()->OpenConfig(Config_Run, spConfigRun);
        //	if (eErr == Error_Succeed) {
        //		spConfigRun->WriteConfigValueInt("WarnRecord", "disk", m_diskLastWarnHour);
        //	}
        //	//LogWarn(Severity_Low, Error_Resource, LOG_EVT_SELFCHECK_HARDDISK_TOO_HIGH, "Harddisk free space is few.");
        //	LogWarn(Severity_Middle, Error_Resource, LOG_EVT_RESOURCE_HARDDISK_TOO_HIGH, diskMessage);

        //	m_bNeedForceDiskCheck = true;
        //}

        LogWarn(Severity_Middle, Error_Resource, LOG_EVT_RESOURCE_HARDDISK_TOO_HIGH, diskMessage);
        m_bNeedForceDiskCheck = true;
    }
    else
    {
        m_bNeedForceDiskCheck = false;
    }
    CheckDiskFileSpaceTask* task4 = new CheckDiskFileSpaceTask(this);
    GetEntityBase()->GetFunction()->PostThreadPoolTask(task4);

}

ULONGLONG ResourceWatcherFSM::GetDiskUsedByte()
{
    ULARGE_INTEGER ulAvailFree, ulTotalBytes, ulTotalFree;
    BOOL ret = GetDiskFreeSpaceEx(NULL, &ulAvailFree, &ulTotalBytes, &ulTotalFree);
    if (ret == 0)
    {
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("GetSystemDiskStatus.GetDiskFreeSpaceEx failed(%d).", GetLastError());
        return -1;
    }

    CSimpleStringA csBinPath;
    ErrorCodeEnum Error = m_pEntity->GetFunction()->GetPath("Bin", csBinPath);   //获取当前终端运行磁盘位置
    return ulTotalBytes.QuadPart - ulTotalFree.QuadPart;
}

__int64 Filetime2Int64(const FILETIME& ftime)
{
    LARGE_INTEGER li;
    li.LowPart = ftime.dwLowDateTime;
    li.HighPart = ftime.dwHighDateTime;
    return li.QuadPart;
}

__int64 CompareFileTime2(const FILETIME& preTime, const FILETIME& nowTime)
{
    return Filetime2Int64(nowTime) - Filetime2Int64(preTime);
}

unordered_map<int, long long> oldProcessTime;
unordered_map<int, long long> newProcessTime;
unordered_map<int, CSimpleStringA> processName;
unordered_map<int, double> processCpu;

bool cmp(const pair<int, double>& a, const pair<int, double>& b) {
    return a.second > b.second;
}

void ResourceWatcherFSM::GetSystemCPUStatus()
{

    FILETIME preIdleTime;
    FILETIME preKernelTime;
    FILETIME preUserTime;
    FILETIME preProcCreateTime;
    FILETIME preProcExitTime;
    FILETIME preProcKernelTime;
    FILETIME preProcUserTime;
    GetSystemTimes(&preIdleTime, &preKernelTime, &preUserTime);

    PROCESSENTRY32 pe32Old;
    pe32Old.dwSize = sizeof(pe32Old);
    //获得系统进程快照的句柄  
    HANDLE hProcessSnapOld = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (hProcessSnapOld == INVALID_HANDLE_VALUE)
    {
        DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM)("CreateToolhelp32Snapshot error.");
        return;
    }

    //首先获得第一个进程  
    BOOL bProcessOld = Process32First(hProcessSnapOld, &pe32Old);
    //循环获得所有进程  
    while (bProcessOld)
    {
        //进程名和进程ID  
        HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, false, pe32Old.th32ProcessID);
        GetProcessTimes(hProcess, &preProcCreateTime, &preProcExitTime, &preProcKernelTime, &preProcUserTime);
        oldProcessTime[pe32Old.th32ProcessID] = Filetime2Int64(preProcKernelTime) + Filetime2Int64(preProcUserTime);
        bProcessOld = Process32Next(hProcessSnapOld, &pe32Old);
    }
    CloseHandle(hProcessSnapOld);

    Sleep(1000);

    FILETIME idleTime;
    FILETIME kernelTime;
    FILETIME userTime;
    FILETIME ProcCreateTime;
    FILETIME ProcExitTime;
    FILETIME procKernelTime;
    FILETIME procUserTime;
    GetSystemTimes(&idleTime, &kernelTime, &userTime);
    PROCESSENTRY32 pe32New;
    pe32New.dwSize = sizeof(pe32New);
    //获得系统进程快照的句柄  
    HANDLE hProcessSnapNew = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (hProcessSnapNew == INVALID_HANDLE_VALUE)
    {
        DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM)("CreateToolhelp32Snapshot error.");
        return;
    }

    //首先获得第一个进程  
    BOOL bProcessNew = Process32First(hProcessSnapNew, &pe32New);
    //循环获得所有进程  
    while (bProcessNew)
    {
        //进程名和进程ID  
        HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, false, pe32New.th32ProcessID);
        GetProcessTimes(hProcess, &ProcCreateTime, &ProcExitTime, &procKernelTime, &procUserTime);
        newProcessTime[pe32New.th32ProcessID] = Filetime2Int64(procKernelTime) + Filetime2Int64(procUserTime);
        processName[pe32New.th32ProcessID] = CSimpleStringA(pe32New.szExeFile);
        bProcessNew = Process32Next(hProcessSnapNew, &pe32New);
    }
    CloseHandle(hProcessSnapNew);

    auto idle = CompareFileTime2(preIdleTime, idleTime);
    auto kernel = CompareFileTime2(preKernelTime, kernelTime);
    auto user = CompareFileTime2(preUserTime, userTime);

    if (kernel + user == 0)
        return;

    CSystemRunInfo runInfo = { 0 };
    GetEntityBase()->GetFunction()->GetSystemRunInfo(runInfo);
    for (int i = 0; i < runInfo.strRunningEntityNames.GetCount(); i++) //实体进程的名称默认全为sphost，需转换为对应实体名
    {
        runInfo.strRunningEntityNames[i];
        CEntityRunInfo entityInfo = { 0 };
        GetEntityBase()->GetFunction()->GetEntityRunInfo(runInfo.strRunningEntityNames[i].GetData(), entityInfo);
        processName[entityInfo.dwProcessID] = runInfo.strRunningEntityNames[i];
    }

    unordered_map<int, long long>::iterator it;
    for (it = newProcessTime.begin(); it != newProcessTime.end(); ++it)
    {
        int tPid = it->first;
        //进程的占用率 = 单位时间间隔里进程的CPU时间片占用 / 单位时间间隔里CPU的整体时间片
        if (oldProcessTime.find(tPid) == oldProcessTime.end())
        {
            continue;
        }

        double tRatio = 100.0 * (newProcessTime[tPid] - oldProcessTime[tPid]) / (kernel + user);
        if (tRatio > 0.0)
        {
            processCpu[tPid] = tRatio;
        }
    }

    vector<pair<int, double>> vec(processCpu.begin(), processCpu.end());
    sort(vec.begin(), vec.end(), cmp); //根据CPU使用率从大到小进行排序
    int len = min(10, vec.size());
    CSimpleStringA procWarn = "";
    for (int i = 0; i < len; ++i) //构建进程的CPU使用告警信息
    {
        procWarn = procWarn + ",\"" + processName[vec[i].first] + "\":\"" + CSimpleStringA::Format("%.2f", vec[i].second) + "%\"";
    }

    double cpuRatio = 100.0 * (kernel + user - idle) / (kernel + user);

    if (m_cpuHighPercent <= 0)
    {
        m_cpuHighPercent = 80; //默认告警百分比80%
    }

    if (cpuWarnThreshold <= 0)
    {
        cpuWarnThreshold = 10;  //默认满10次告一次警
    }

    if (cpuRatio > (double)m_cpuHighPercent)
    {
        cpuWarnTime = cpuWarnTime % cpuWarnThreshold;   
        if (cpuWarnTime == 0) //每达到一次阈值告警一次
        {
            CSimpleStringA warn = CSimpleStringA::Format("{\"type\":\"cpu\", \"total_used\":\" %.2f", cpuRatio);
            warn = warn + "%\"" + procWarn + "}";
            LogWarn(Severity_Middle, Error_Resource, LOG_EVT_RESOURCE_CPU_TOO_HIGH, warn.GetData());
            if (cpuRatio > 98) //cpu极端异常情况
            {
                LogWarn(Severity_Middle, Error_Resource, LOG_EVT_RESOURCE_CPU_ERROR, warn.GetData());
            }
        }
        cpuWarnTime++;
    }

}

unsigned long long convert_time_format(const FILETIME* ftime)
{
    LARGE_INTEGER li;

    li.LowPart = ftime->dwLowDateTime;
    li.HighPart = ftime->dwHighDateTime;
    return li.QuadPart;
}


/// 时间转换
static uint64_t file_time_2_utc(const FILETIME* ftime)
{
    LARGE_INTEGER li;

    li.LowPart = ftime->dwLowDateTime;
    li.HighPart = ftime->dwHighDateTime;
    return li.QuadPart;
}

/// 获得CPU的核数
static int get_processor_number()
{
    SYSTEM_INFO info;
    GetSystemInfo(&info);
    return (int)info.dwNumberOfProcessors;
}

int ResourceWatcherFSM::GetCpuUsageRatio(int pid)
{
    //cpu数量
    static int processor_count_ = -1;
    //上一次的时间
    static int64_t last_time_ = 0;
    static int64_t last_system_time_ = 0;

    FILETIME now;
    FILETIME creation_time;
    FILETIME exit_time;
    FILETIME kernel_time;
    FILETIME user_time;
    int64_t system_time;
    int64_t time;
    int64_t system_time_delta;
    int64_t time_delta;

    int cpu = -1;

    if (processor_count_ == -1)
    {
        processor_count_ = get_processor_number();
    }

    GetSystemTimeAsFileTime(&now);

    HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, false, pid);
    if (!GetProcessTimes(hProcess, &creation_time, &exit_time, &kernel_time, &user_time))
    {
        return -1;
    }
    system_time = (file_time_2_utc(&kernel_time) + file_time_2_utc(&user_time))
        / processor_count_;
    time = file_time_2_utc(&now);

    if ((last_system_time_ == 0) || (last_time_ == 0))
    {
        last_system_time_ = system_time;
        last_time_ = time;
        return -1;
    }

    system_time_delta = system_time - last_system_time_;
    time_delta = time - last_time_;

    if (time_delta == 0)
        return -1;

    cpu = (int)((system_time_delta * 100 + time_delta / 2) / time_delta);
    last_system_time_ = system_time;
    last_time_ = time;
    return cpu;

}

double GetMemoryUsageGB(int pid)
{
#ifdef WIN32
    DWORDLONG mem = 0, vmem = 0;
    PROCESS_MEMORY_COUNTERS pmc;
    // get process hanlde by pid
    HANDLE process = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
    if (GetProcessMemoryInfo(process, &pmc, sizeof(pmc)))
    {
        mem = pmc.WorkingSetSize;
        vmem = pmc.PagefileUsage;
    }
    CloseHandle(process);
    // use GetCurrentProcess() can get current process and no need to close handle

    // convert mem from B to GB
    double memGB = mem / (1024.0 * 1024.0 * 1024.0);
    return memGB;

#else
    char file_name[64] = { 0 };
    FILE* fd;
    char line_buff[512] = { 0 };
    sprintf(file_name, "/proc/%d/status", pid);

    fd = fopen(file_name, "r");
    if (nullptr == fd)
        return 0;

    char name[64];
    int vmrss = 0;
    for (int i = 0; i < VMRSS_LINE - 1; i++)
        fgets(line_buff, sizeof(line_buff), fd);

    fgets(line_buff, sizeof(line_buff), fd);
    sscanf(line_buff, "%s %d", name, &vmrss);
    fclose(fd);

    // cnvert VmRSS from KB to MB
    return vmrss / 1024.0;
#endif
}

unordered_map<int, double> processMem;
void ResourceWatcherFSM::GetSystemMemoryStatus()
{
    // Specify the width of the field in which to print the numbers. 
    // The asterisk in the format specifier "%*I64d" takes an integer 
    // argument and uses it to pad and right justify the number.
#define WIDTH 7

    MEMORYSTATUSEX statex;

    statex.dwLength = sizeof(statex);
    GlobalMemoryStatusEx(&statex);
    double totalMem = statex.ullTotalPhys / (1024.0 * 1024.0 * 1024.0); //GB

    unordered_map<int, CSimpleStringA>::iterator it;
    for (it = processName.begin(); it != processName.end(); ++it)
    {
        int tPid = it->first;
        double tmp = GetMemoryUsageGB(it->first);

        if (tmp > 0.0)
        {
            processMem[tPid] = 100 * (tmp / totalMem);
        }
    }
    //return;

    vector<pair<int, double>> vec(processMem.begin(), processMem.end());
    sort(vec.begin(), vec.end(), cmp); //根据CPU使用率从大到小进行排序
    int len = min(10, vec.size());
    CSimpleStringA procWarn = "";
    for (int i = 0; i < len; ++i) //构建进程的CPU使用告警信息
    {
        procWarn = procWarn + ",\"" + processName[vec[i].first] + "\":\"" + CSimpleStringA::Format("%.1f", vec[i].second) + "%\"";
    }

    if (m_memHighPercent <= 0)
    {
        m_memHighPercent = 80; //默认告警百分比80%
    }

    if (memWarnThreshold <= 0)
    {
        memWarnThreshold = 10; //默认告警阈值10次
    }

    if (statex.dwMemoryLoad > m_memHighPercent)
    {
        memWarnTime = memWarnTime % memWarnThreshold;
        if (memWarnTime == 0) //每达到阈值告警一次
        {
            CSimpleStringA warn = CSimpleStringA::Format("{\"type\":\"mem\", \"total\":\"%.1f GByte\",\"total_used\":\" %d%%\"", totalMem, statex.dwMemoryLoad);
            warn = warn + procWarn + "}";
            LogWarn(Severity_Middle, Error_Resource, LOG_EVT_RESOURCE_MEMORY_TOO_HIGH, warn.GetData());
        }
        memWarnTime++;
    }
}

int ResourceWatcherFSM::IsWifiConnected()
{
    DWORD service_ver;
    HANDLE handle = NULL;
    int result = -1;

    DWORD err = WlanOpenHandle(WLAN_API_VERSION, NULL, &service_ver, &handle);
    if (err != 0) {
        DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM)("open wlan handle failed %d", err);
        return result;
    }

    PWLAN_INTERFACE_INFO_LIST info_list = NULL;
    PWLAN_INTERFACE_INFO interface_info = NULL;
    err = WlanEnumInterfaces(handle, NULL, &info_list);
    if (err != ERROR_SUCCESS) {
        DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM)("Enum wlan interface failed %d", err);
        WlanCloseHandle(handle, NULL);
        return -1;
    }

    const int count = info_list->dwNumberOfItems;

    for (int i = 0; i < count; ++i) {
        interface_info = &info_list->InterfaceInfo[i];
        DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("wireless interface name:  %s", SP::Module::Util::W2S(interface_info->strInterfaceDescription).c_str());
        DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("state:  %d", interface_info->isState);
        if (interface_info->isState == wlan_interface_state_connected) {
            result = 1;
        }
        DWORD radio_state_info_size = sizeof(WLAN_RADIO_STATE);
        PWLAN_RADIO_STATE radio_state_info_ptr = NULL;
        WLAN_OPCODE_VALUE_TYPE op_code = wlan_opcode_value_type_invalid;
        err = WlanQueryInterface(handle, &interface_info->InterfaceGuid, wlan_intf_opcode_radio_state,
            NULL, &radio_state_info_size, (PVOID*)&radio_state_info_ptr, &op_code);
        if (err != ERROR_SUCCESS) {
            DbgWithLink(LOG_LEVEL_ERROR, LOG_TYPE_SYSTEM)("WlanQueryInterface failed %d", err);
        }
        else
        {
            const uint32_t count_of_phys = radio_state_info_ptr->dwNumberOfPhys;
            //DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("Number of valid PHYs: %d", count_of_phys);
            if (count_of_phys > 0 && result == -1) {
                if (dot11_radio_state_on == radio_state_info_ptr->PhyRadioState[0].dot11SoftwareRadioState) {
                    result = 0;
                }
                else
                {
                    /*
                    for (int j = 0; j < count_of_phys; ++j) {
                        DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("software radio state: %d, %d", j , radio_state_info_ptr->PhyRadioState[j].dot11SoftwareRadioState);
                        DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("hardware radio state: %d, %d", j, radio_state_info_ptr->PhyRadioState[j].dot11HardwareRadioState);
                        DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("**********************");
                    }
                    */
                }
            }
        }
    }
    if (info_list != NULL) {
        WlanFreeMemory(info_list);
    }
    WlanCloseHandle(handle, NULL);
    return result;
}

#endif // _MSC_VER end硬件资源监控相关系统功能 CPU、内存、硬盘、网络wifi

#ifdef RVC_OS_LINUX
static bool spaceLock = false;

void ResourceWatcherFSM::CheckDiskFileSpace()
{
    if (spaceLock)
    {
        DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("当前已有硬盘扫描进行中，跳过。");
        return;
    }
    else
    {
        spaceLock = true; //加锁
    }

    //获取opt文件夹下的文件占用信息
    FILE* fp = NULL;
    CSimpleStringA cmd = "du -h -s /opt/* | sort -rn | head";
    if ((fp = popen(cmd.GetData(), "r")) == NULL) {
        DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("popen failed:%d", GetLastError());
        return;
    }

    char buf[1024] = { 0 };
    CSimpleStringA warnMsg(true);
    while (fgets(buf, sizeof(buf), fp))
    {
        warnMsg = warnMsg + "|" + buf;
    }
    if (warnMsg.GetLength() > 0)
    {
        LogWarn(Severity_Low, Error_Resource, LOG_RESOURCEWATCHER_FILE_TOPUSED_SPACE, warnMsg.GetData()); //告警opt下的文件夹
    }
    pclose(fp);

    //获取opt/rvc文件夹下的文件占用信息
    FILE* fp2 = NULL;
    CSimpleStringA cmd2 = "du -h -s /opt/rvc/* | sort -rn | head";
    if ((fp2 = popen(cmd2.GetData(), "r")) == NULL) {
        DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("popen failed:%d", GetLastError());
        return;
    }

    CSimpleStringA warnMsg2(true);
    char buf2[1024] = { 0 };
    while (fgets(buf2, sizeof(buf2), fp2))
    {
        warnMsg2 = warnMsg2 + "|" + buf2;
    }
    if (warnMsg2.GetLength() > 0)
    {
        LogWarn(Severity_Low, Error_Resource, LOG_RESOURCEWATCHER_FILE_TOPUSED_SPACE, warnMsg2.GetData()); //告警opt/rvc下的文件夹
    }
    pclose(fp2);

    if (spaceLock)
    {
        spaceLock = false; //释放锁
    }
}
#endif // RVC_OS_LINUX


ErrorCodeEnum ResourceWatcherFSM::CatchSystemBasicInfo(SystemBasicInfo& info)
{
#if defined(RVC_OS_WIN)
    ///**TODO(Gifur@10/10/2023): 待实现 */
    return Error_NotImpl;
#else
    CSimpleStringA runCfgPath;
    ErrorCodeEnum errCode = GetEntityBase()->GetFunction()->GetPath("RunCfg", runCfgPath);
    if (runCfgPath.IsNullOrEmpty()) return Error_Null;
    CSimpleStringA storeFilePath = runCfgPath + SPLIT_SLASH_STR + "SMBIOSData.txt";

    if (!ExistsFileA(storeFilePath)) {
        RemoveFileA(storeFilePath);
    }

    std::string succStr, errStr;
    std::string runStr("dmidecode -t system > ");
    runStr += storeFilePath.GetData();
    if (!SP::Module::Util::ShellExecute(runStr, succStr, errStr)) {
        DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("execute '%s' failed!", runStr.c_str());
        if (!ExistsFileA(storeFilePath)) {
            RemoveFileA(storeFilePath);
        }
        return Error_Unexpect;
    }

    do {
        std::string succStr, errStr;
        std::string runStr("awk -F ':' '(NR>=7)&&(NR<=14)&&($0~\"Manufacturer\"){print$2}' ");
        runStr += storeFilePath.GetData();
        if (SP::Module::Util::ShellExecute(runStr, succStr, errStr)) {
            info.strManufacturer = SP::Utility::ToTrim(succStr).c_str();
        }
        else
        {
            succStr = "";
            DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("fetch 'Manufacturer' failed!");
        }
    } while (false);

    do {
        std::string succStr, errStr;
        std::string runStr("awk -F ':' '(NR>=7)&&(NR<=14)&&($0~\"Product Name\"){print$2}' ");
        runStr += storeFilePath.GetData();
        if (SP::Module::Util::ShellExecute(runStr, succStr, errStr)) {
            info.strProductName = SP::Utility::ToTrim(succStr).c_str();
        }
        else
        {
            succStr = "";
            DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("fetch 'Product Name' failed!");
        }
    } while (false);

    do {
        std::string succStr, errStr;
        std::string runStr("awk -F ':' '(NR>=7)&&(NR<=14)&&($0~\"Serial Number\"){print$2}' ");
        runStr += storeFilePath.GetData();
        if (SP::Module::Util::ShellExecute(runStr, succStr, errStr)) {
            info.strSerialNumber = SP::Utility::ToTrim(succStr).c_str();
        }
        else
        {
            succStr = "";
            DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("fetch 'Serial Number' failed!");
        }
    } while (false);

    if (!ExistsFileA(storeFilePath)) {
        RemoveFileA(storeFilePath);
    }
    return Error_Succeed;
#endif //RVC_OS_WIN


}

void ResourceWatcherFSM::AlarmSystemBasicInfo()
{
    SystemBasicInfo info;
    if (Error_Succeed == CatchSystemBasicInfo(info)) {
        CSimpleStringA strResult("{");
        if (!info.strManufacturer.IsNullOrEmpty()) {
            strResult += CSimpleStringA::Format("\"Manufacturer\":\"%s\"", info.strManufacturer.GetData());
        }
        if (!info.strProductName.IsNullOrEmpty()) {
            if (strResult.GetLength() > 1) {
                strResult += ", ";
            }
            strResult += CSimpleStringA::Format("\"Product Name\":\"%s\"", info.strProductName.GetData());
        }
        if (!info.strSerialNumber.IsNullOrEmpty()) {
            if (strResult.GetLength() > 1) {
                strResult += ", ";
            }
            strResult += CSimpleStringA::Format("\"Serial Number\":\"%s\"", info.strSerialNumber.GetData());
        }
        strResult += "}";
        LogWarn(Severity_Low, Error_Debug, LOG_INFO_DEVICE_SMBIOS_GET, strResult);
    }
}

BOOL ResourceWatcherFSM::DetectIsFirstRunAtBoot()
{
    CSystemRunInfo runInfo = { 0 };
    GetEntityBase()->GetFunction()->GetSystemRunInfo(runInfo);
    BOOL bSet = FALSE;
    CBootInfo bootInfo = { 0 };
    CSmallDateTime dateTime;
    DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("systemRunInfo time: %s", (LPCTSTR)runInfo.tmStart.ToTimeString());
    ErrorCodeEnum erroCode = GetEntityBase()->GetFunction()->GetRebootInfo(/*runInfo.tmStart*/dateTime, bootInfo);
    DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("bootInfor time: %s", (LPCTSTR)bootInfo.tmStart.ToTimeString());
    CSmallDateTime systemBootTime;
    BOOL bRet = GetSystemBootTime(systemBootTime);
    if (bRet && systemBootTime > bootInfo.tmStart) {
        ErrorCodeEnum eRet = GetEntityBase()->GetFunction()->SetSysVar(SYSVAR_FRAMEWORK_FIRST_BOOT, SYSVAR_FRAMEWORK_FIRST_BOOT_YES);
        if (eRet != Error_Succeed) {
            DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Set %s with %s failed: %d", SYSVAR_FRAMEWORK_FIRST_BOOT, SYSVAR_FRAMEWORK_FIRST_BOOT_YES, eRet);
        }
        bSet = TRUE;
        std::map<std::string, std::string> srcData;
        CSimpleStringA strData = CSimpleStringA::Format("{\"AppLastStartTime\":\"%s\",\"AppStartTime\":\"%s\",\"OSStartTime\":\"%s\"}"
            , (LPCTSTR)bootInfo.tmStart.ToTimeString(), (LPCTSTR)runInfo.tmStart.ToTimeString(), systemBootTime.ToTimeString().GetData());
        LogWarn(Severity_Low, Error_Debug, LOG_RESOURCEWATCHER_FIRST_RUN_AFTER_BOOT, strData.GetData());
    }
    else
    {
        GetEntityBase()->GetFunction()->SetSysVar(SYSVAR_FRAMEWORK_FIRST_BOOT, SYSVAR_FRAMEWORK_FIRST_BOOT_NO);
        bSet = FALSE;
    }
    return bSet;
}

#ifdef RVC_OS_LINUX
void ResourceWatcherFSM::UploadMonitorSettings()
{
    CSmartPointer<IConfigInfo> spCtSettingConfig;
    GetEntityBase()->GetFunction()->OpenConfig(Config_CenterSetting, spCtSettingConfig);
    int nSwitchOff(0);
    spCtSettingConfig->ReadConfigValueInt(GetEntityBase()->GetEntityName(), "MonitorListenOFF", nSwitchOff);
    if (!!nSwitchOff) {
        DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Cancel monitor change listen!");
        if (m_bFirstRunAfterBoot) {
            CSimpleStringA value(true);
            bool res = GetMonitorInfo(value);
            LogWarn(Severity_Low, Error_Debug, LOG_INFO_MONITOR_SETTINGS, value);
        }
    }
    else
    {

        int nInterval(10000);
        int nValue(0);
        spCtSettingConfig->ReadConfigValueInt(GetEntityBase()->GetEntityName(), "MonitorListenInterval", nValue);
        if (nValue >= 10000) {
            DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Update monitor listen interval from %d to %d", nInterval, nValue);
            nInterval = nValue;
        }

        CSimpleStringA strLastMonitor(true);
        bool readFromCfgFalg(true);
        CSmartPointer<IConfigInfo> spRunConfig;
        GetEntityBase()->GetFunction()->OpenConfig(Config_Run, spRunConfig);
        spRunConfig->ReadConfigValue("MonitorAttribute", "LastInfo", strLastMonitor);

        do
        {
            CSimpleStringA value(true);
            bool res = GetMonitorInfo(value);
            if (!value.IsNullOrEmpty() && (strLastMonitor.IsNullOrEmpty() || (strLastMonitor.Compare(value) != 0))) {
                LogWarn(Severity_Low, Error_Debug, LOG_INFO_MONITOR_SETTINGS, value);
                CSmartPointer<IConfigInfo> spRunConfig;
                GetEntityBase()->GetFunction()->OpenConfig(Config_Run, spRunConfig);
                spRunConfig->WriteConfigValue("MonitorAttribute", "LastInfo", value);
                strLastMonitor = value;
                if (readFromCfgFalg) {
                    readFromCfgFalg = false;
                }

            }
            else if (readFromCfgFalg && !strLastMonitor.IsNullOrEmpty() && strLastMonitor.Compare(value) == 0)
            {
                LogWarn(Severity_Low, Error_Debug, LOG_INFO_MONITOR_SETTINGS, value);
                readFromCfgFalg = false;
            }

            Sleep(nInterval);

        } while (true);
    }
}


void ResourceWatcherFSM::DetectSoftwareInstallStatus()
{
    CSmartPointer<IConfigInfo> spCtSettingConfig;
    GetEntityBase()->GetFunction()->OpenConfig(Config_CenterSetting, spCtSettingConfig);
    CSimpleStringA strSoftwaresNames[MAX_SOFTWARE_INSTALLED_DETECT_COUNT];
    CSimpleStringA strSoftwaresVers[MAX_SOFTWARE_INSTALLED_DETECT_COUNT];
    int nNameCounts = 0;
    for (int i = 0; i < MAX_SOFTWARE_INSTALLED_DETECT_COUNT; i++) {
        strSoftwaresNames[i] = "";
        strSoftwaresVers[i] = "";
        CSimpleStringA item = CSimpleStringA::Format("SoftwareInstallDetect%d", i);
        CSimpleStringA value(true);
        spCtSettingConfig->ReadConfigValue(GetEntityBase()->GetEntityName(), item, value);
        if (value.IsNullOrEmpty()) {
            break;
        }
        if (value.IndexOf("#") != -1) {
            CAutoArray<CSimpleStringA> items = value.Split('#');
            strSoftwaresNames[i] = items[0];
            strSoftwaresVers[i] = items[1];
        }
        else
        {
            strSoftwaresNames[i] = value;
        }
        DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("Detect SoftDetect from CentralSetting, %d: %s,%s,%s."
            , i, item.GetData(), strSoftwaresNames[i].GetData(), strSoftwaresVers[i].GetData());
        nNameCounts++;
    }

    if (nNameCounts > 0) {

        for (int i = 0; i < nNameCounts; ++i) {
            CSimpleStringA runItem = CSimpleStringA::Format("dpkg -l | grep %s | awk '{print $3}'", strSoftwaresNames[i].GetData());
            std::string additional("");
            std::string succStr, errStr;
            std::string runStr(runItem.GetData());
            if (SP::Module::Util::ShellExecute(runStr, succStr, errStr)) {
                if (succStr.empty()) {
                    LogWarn(Severity_Low, Error_Debug, LOG_WARN_SOFTWARE_DETECT_NOT_EXISTS_BASE + i,
                        CSimpleStringA::Format("{\"software_name\":\"%s\", \"version_status\":\"not installed\"}", strSoftwaresNames[i].GetData()));
                }
                else
                {
                    succStr = SP::Utility::ToTrim(succStr);
                    if (strSoftwaresVers[i].IsNullOrEmpty() || strSoftwaresVers[i].Compare(succStr.c_str()) == 0) {
                        LogWarn(Severity_Low, Error_Debug, LOG_WARN_SOFTWARE_DETECT_EXISTS_BASE + i,
                            CSimpleStringA::Format("{\"software_name\":\"%s\", \"version_status\":\"%s\"}"
                                , strSoftwaresNames[i].GetData(), succStr.c_str(), strSoftwaresVers[i].GetData()));
                    }
                    else
                    {
                        LogWarn(Severity_Low, Error_Debug, LOG_WARN_SOFTWARE_DETECT_NOT_EXISTS_BASE + i,
                            CSimpleStringA::Format("{\"software_name\":\"%s\", \"version_status\":\"%s\", \"expected\":\"%s\"}"
                                , strSoftwaresNames[i].GetData(), succStr.c_str(), strSoftwaresVers[i].GetData()));
                    }
                }
            }
            else
            {
                LogWarn(Severity_Low, Error_Debug, LOG_WARN_SOFTWARE_DETECT_EXISTS_STATUS_FAILED,
                    CSimpleStringA::Format("{\"software_name\":\"%s\", \"version_status\":\"detect failed\", \"expected\":\"%s\"}"
                        , strSoftwaresNames[i].GetData(), strSoftwaresVers[i].GetData()));
            }
        }
    }
}

UINT ResourceWatcherFSM::GetSystemDisplayVersion(CSimpleStringA& strVersion)
{
    UINT result = 0;

    const char filePath[] = "/etc/os-version";
    strVersion.Clear();
    char tmp[33];
    memset(tmp, 0, 33);
    inifile_read_str_s("Version", "MajorVersion", "unknown", tmp, 32, filePath);
    strVersion = tmp;
    strVersion += ".";
    memset(tmp, 0, 33);
    inifile_read_str_s("Version", "MinorVersion", "unknown", tmp, 32, filePath);
    strVersion += tmp;
    strVersion += ".";

    result = atoi(tmp);

    memset(tmp, 0, 33);
    inifile_read_str_s("Version", "OsBuild", "unknown", tmp, 32, filePath);
    strVersion += tmp;

    return result;
}

void ResourceWatcherFSM::UploadSysVersionInfo(UINT& ver)
{
    std::map<std::string, std::string> srcData;
    CSimpleStringA osver;
    ver = GetSystemDisplayVersion(osver);
    srcData.insert(std::make_pair("os-version", osver)); ////当前操作系统版本（系统信息）
    tk_utsname_t t;
    osutil_uname(&t);

    srcData.insert(std::make_pair("sysname", t.sysname)); ////当前操作系统名
    srcData.insert(std::make_pair("release", t.release)); ////当前发布级别
    srcData.insert(std::make_pair("version", t.version)); ////当前发布版本
    srcData.insert(std::make_pair("machine", t.machine)); ////当前硬件体系类型

    do {
        std::string sucContent, failedContent;
        std::string cmd("cat /proc/cpuinfo |grep \"model name\" | awk 'NR==1'");
        bool ret = SP::Module::Util::ShellExecute(cmd, sucContent, failedContent);
        DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("{%s}:{%s}{%s}", cmd.c_str(), sucContent.c_str(), failedContent.c_str());
        auto elems = SP::Utility::Split(sucContent, ':');
        if (elems.size() > 1) {
            sucContent = SP::Utility::ToTrim(elems[1]);
        }
        srcData.insert(std::make_pair("cpu-type", sucContent));
    } while (false);

    //#if defined(RVC_OS_LINUX)
    //    CSystemStaticInfo sysInfo;
    //    ErrorCodeEnum eErr = GetEntityBase()->GetFunction()->GetSystemStaticInfo(sysInfo);
    //    if (eErr == Error_Succeed) {
    //        termInfo["MachineMode"] = (LPCTSTR)sysInfo.strMachineModel;
    //        termInfo["MachineSN"] = (LPCTSTR)sysInfo.strMachineSN;
    //    }
    //#endif //RVC_OS_LINUX
    auto ret = generateJsonStr(srcData);
    LogWarn(Severity_Low, Error_Hardware, LOG_RESOURCEWATCHER_SYSTEMINFO, ret.second.c_str());
}


string ResourceWatcherFSM::MemoryProcessStatus()
{
    CSmartPointer<IEntityFunction> spFunction = this->GetEntityBase()->GetFunction();
    CSmartPointer<IConfigInfo> spConfig;
    ErrorCodeEnum erroCode = Error_Unexpect;
    ///*TODO: 不要每次都进来读取配置文件 (80374374@5/17/2023)*/
    spFunction->OpenConfig(Config_CenterSetting, spConfig);
    int memTop = 0;
    erroCode = spConfig->ReadConfigValueInt("TOPProcess", "mem", memTop);
    if (memTop == 0) {
        memTop = 10;
    }
    else if (memTop == -1)
    {
        return "";
    }

    map<string, string> nameProcess;
    CSystemRunInfo runInfo = { 0 };
    GetEntityBase()->GetFunction()->GetSystemRunInfo(runInfo);
    for (int i = 0; i < runInfo.strRunningEntityNames.GetCount(); i++)
    {
        string entityName = runInfo.strRunningEntityNames[i].GetData();
        CEntityRunInfo entityInfo = { 0 };
        GetEntityBase()->GetFunction()->GetEntityRunInfo(entityName.c_str(), entityInfo);
        nameProcess[to_string(entityInfo.dwProcessID)] = entityName;
    }

    FILE* fp;
    char buffer[2048];
    string cmd = "ps c -eo pid,%mem,rss,command | sort -k3 -rn | head -" + to_string(memTop);
    fp = popen(cmd.c_str(), "r");
    int i = 0;

    string s;
    string str[4];
    //mem
    DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("MEM TOP %d PROCESS!", memTop);
    string topMessage = "";
    while (i < memTop)
    {
        fgets(buffer, sizeof(buffer), fp);
        s = buffer;
        istringstream is(s);
        is >> str[0] >> str[1] >> str[2] >> str[3];
        double temp;
        stringstream ss1;
        ss1 << str[2];
        ss1 >> temp;
        temp = temp / (1024 * 1024);

        stringstream ss2;
        ss2 << std::setiosflags(std::ios::fixed) << std::setprecision(2) << temp;
        str[2] = ss2.str();

        if (nameProcess.find(str[0]) != nameProcess.end())
        {
            str[3] = nameProcess[str[0]];
        }

        topMessage = topMessage + "\"" + str[3] + "\"" + ":" + "\"" + str[1] + "%\"";

        if (i != memTop - 1)
        {
            topMessage += ",";
        }

        ++i;
    }
    topMessage += "}";
    pclose(fp);
    return topMessage;
}

long ResourceWatcherFSM::GetCPURunTime(CPUInfo* cpu) //获取CPU的当前信息，同时返回CPU使用时间
{
    FILE* fd;
    char buff[1024] = { 0 };
    CPUInfo* cpuInfo = cpu;

    fd = fopen("/proc/stat", "r");
    if (!fd) {
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Read CPU Info FAILED!");
        return -1;
    }

    fgets(buff, sizeof(buff), fd);
    char name[64] = { 0 };
    sscanf(buff, "%s %u %u %u %u %u %u %u",
        cpuInfo->name, &cpuInfo->user, &cpuInfo->nice, &cpuInfo->system, &cpuInfo->idle, &cpuInfo->lowait, &cpuInfo->irq, &cpuInfo->softirq);
    fclose(fd);

    return (cpuInfo->user + cpuInfo->nice + cpuInfo->system + cpuInfo->idle + cpuInfo->lowait + cpuInfo->irq + cpuInfo->softirq);
}


long ResourceWatcherFSM::ReadProcCPURunTime(DWORD pid, ProcCPUInfo* pInfo) { //根据pid读取进程占用的CPU时间

    char file_name[64] = { 0 };
    FILE* fd;
    char line_buff[1024] = { 0 };
    sprintf(file_name, "/proc/%d/stat", pid);

    fd = fopen(file_name, "r");
    if (nullptr == fd) {
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Read PROCESS[%d] CPU Info FAILED!", pid);
        return -1;
    }

    fgets(line_buff, sizeof(line_buff), fd);

    sscanf(line_buff, "%u %s", &pInfo->pid, pInfo->pname);
    const char* q = GetItems(line_buff, PROCESS_ITEM);
    sscanf(q, "%ld %ld %ld %ld", &pInfo->utime, &pInfo->stime, &pInfo->cutime, &pInfo->cstime);
    fclose(fd);

    return (pInfo->utime + pInfo->stime + pInfo->cutime + pInfo->cstime);
}


//获取第N项开始的指针
const char* ResourceWatcherFSM::GetItems(const char* buffer, unsigned int item) {

    const char* p = buffer;

    int len = strlen(buffer);
    int count = 0;

    for (int i = 0; i < len; i++) {
        if (' ' == *p) {
            count++;
            if (count == item - 1) {
                p++;
                break;
            }
        }
        p++;
    }

    return p;
}

bool cmp(const pair<DWORD, DOUBLE>& a, const pair<DWORD, DOUBLE>& b) {
    return a.second > b.second;
}

/* -----------------------
   根据先后两个时间的CPU信息，
   计算CPU的总占用量和各个进程的占用量
   -----------------------      */
void ResourceWatcherFSM::GetSystemCPUStatus()
{
    //int cpu_num = sysconf(_SC_NPROCESSORS_CONF);      //CPU核数

    CPUInfo* cpuOld = new CPUInfo;
    CPUInfo* cpuNew = new CPUInfo;

    const char* tPath = "/proc";
    map<DWORD, string> nameProcess;  // <pid, 进程名>
    map<DWORD, DOUBLE> usageProcess; // <pid, CPU占用率>

    long oldTotalTime = GetCPURunTime(cpuOld);  //旧CPU运行总时间
    if (oldTotalTime == -1)
    {
        return;
    }

    map<DWORD, long> oldProcCPUTime;  // <pid, 旧时刻进程的CPU占用时间>
    struct dirent* oldDirp;
    DIR* oldDp = opendir(tPath);
    if (oldDp != NULL) {
        while ((oldDirp = readdir(oldDp)) != NULL) {  //获取旧时刻 每一个进程的pid、CPU运行时间、进程名
            string fileName = oldDirp->d_name;
            BOOL isPid = TRUE;
            for (int i = 0; i < fileName.length(); ++i)  //判断进程id的文件夹 是否文件名是否纯数字
            {
                if (!isdigit(fileName[i]))
                {
                    isPid = FALSE;
                    break;
                }
            }
            if (!isPid) continue;

            DWORD pid;
            long oldTime;
            ProcCPUInfo* oldProcCPU = new ProcCPUInfo;
            sscanf(oldDirp->d_name, "%d", &pid);  //读取文件夹名
            oldTime = ReadProcCPURunTime(pid, oldProcCPU);
            if (oldTime == -1)
            {
                return;
            }

            oldProcCPUTime[pid] = oldTime;
            nameProcess[pid] = oldProcCPU->pname;

            delete oldProcCPU;
        }
        closedir(oldDp);
    }

    sleep(1);

    long newTotalTime = GetCPURunTime(cpuNew);  //新CPU运行总时间
    if (newTotalTime == -1)
    {
        return;
    }

    map<DWORD, long> newProcCPUTime; // <pid, 新时刻进程的CPU占用时间>
    struct dirent* newDirp;
    DIR* newDp = opendir(tPath);
    if (newDp != NULL) {
        while ((newDirp = readdir(newDp)) != NULL) {  //获取新时刻 每一个进程的pid、CPU运行时间、进程名

            string fileName = newDirp->d_name;
            BOOL isPid = TRUE;
            for (int i = 0; i < fileName.length(); ++i)  //判断进程id的文件夹 是否文件名是否纯数字
            {
                if (!isdigit(fileName[i]))
                {
                    isPid = FALSE;
                    break;
                }
            }
            if (!isPid) continue;

            DWORD pid;
            long newTime;
            ProcCPUInfo* newProcCPU = new ProcCPUInfo;
            sscanf(newDirp->d_name, "%d", &pid);  //读取文件夹名
            newTime = ReadProcCPURunTime(pid, newProcCPU);
            if (newTime == -1)
            {
                return;
            }

            newProcCPUTime[pid] = newTime;

            string tName = newProcCPU->pname;
            tName.erase(tName.begin());
            tName.erase(tName.begin() + (tName.length() - 1));

            nameProcess[pid] = tName;

            delete newProcCPU;
        }
        closedir(newDp);
    }

    map<DWORD, long>::iterator it;
    for (it = newProcCPUTime.begin(); it != newProcCPUTime.end(); ++it)
    {
        DWORD tPid = it->first;
        //进程的占用率 = 单位时间间隔里进程的CPU时间片占用 / 单位时间间隔里CPU的整体时间片
        DOUBLE tRatio = 100.0 * (newProcCPUTime[tPid] - oldProcCPUTime[tPid]) / (newTotalTime - oldTotalTime);
        usageProcess[tPid] = tRatio;
    }

    CSystemRunInfo runInfo = { 0 };
    GetEntityBase()->GetFunction()->GetSystemRunInfo(runInfo);

    for (int i = 0; i < runInfo.strRunningEntityNames.GetCount(); i++) //实体进程的名称默认全为sphost，需转换为对应实体名
    {
        string entityName = runInfo.strRunningEntityNames[i].GetData();
        CEntityRunInfo entityInfo = { 0 };
        GetEntityBase()->GetFunction()->GetEntityRunInfo(entityName.c_str(), entityInfo);
        nameProcess[entityInfo.dwProcessID] = entityName;
    }

    vector<pair<DWORD, DOUBLE>> vec(usageProcess.begin(), usageProcess.end());
    sort(vec.begin(), vec.end(), cmp); //根据CPU使用率从大到小进行排序

    int len = MIN(m_cpuTop, vec.size());
    string procWarn = "";
    for (int i = 0; i < len; ++i) //构建进程的CPU使用告警信息
    {
        char* tUsage = new char[20];
        sprintf(tUsage, "%.2lf", vec[i].second);
        procWarn = procWarn + ",\"" + nameProcess[vec[i].first] + "\":\"" + string(tUsage) + "%\"";

        delete tUsage;
    }

    unsigned long oldInfo, newInfo;
    double cUsedRate = 0;

    //第一次(用户+优先级+系统+空闲)的时间  
    //oldInfo = (unsigned long)(cpuOld->user + cpuOld->nice + cpuOld->system + cpuOld->idle + cpuOld->lowait + cpuOld->irq + cpuOld->softirq);
    //第二次(用户+优先级+系统+空闲)的时间
    //newInfo = (unsigned long)(cpuNew->user + cpuNew->nice + cpuNew->system + cpuNew->idle + cpuNew->lowait + cpuNew->irq + cpuNew->softirq);
    double totalTime = newTotalTime - oldTotalTime;
    double freeTime = cpuNew->idle - cpuOld->idle;
    cUsedRate = (totalTime - freeTime) / totalTime;

    if (m_cpuHighPercent <= 0)
    {
        m_cpuHighPercent = 80; //默认告警百分比80%
    }

    if (cpuWarnThreshold <= 0)
    {
        cpuWarnThreshold = 10;  //默认满10次告一次警
    }

    if ((cUsedRate * 100) > m_cpuHighPercent) 
    {
        cpuWarnTime = cpuWarnTime % cpuWarnThreshold;
        if (cpuWarnTime == 0) //每达到一次阈值告警一次
        {
            stringstream tss;
            tss << std::setiosflags(std::ios::fixed) << std::setprecision(2) << cUsedRate * 100;

            string warn = "{ \"total_used\":\"" + tss.str() + "%\"" + procWarn + "}";
            LogWarn(Severity_Middle, Error_Resource, LOG_EVT_RESOURCE_CPU_TOO_HIGH, CSimpleStringA::Format("%s", warn.c_str()));
        }
        cpuWarnTime++;
    }

    delete cpuNew;
    delete cpuOld;

}

void ResourceWatcherFSM::GetSystemMemoryStatus()
{
    MemInfo* memInfo = new MemInfo();

    FILE* fd;
    char buff[256];

    fd = fopen("/proc/meminfo", "r");
    if (!fd) {
        DbgWithLink(LOG_LEVEL_WARN, LOG_TYPE_SYSTEM)("Read Memory INFO FAILED!");
        return;
    }

    fgets(buff, sizeof(buff), fd);
    sscanf(buff, "%s %lu ", memInfo->infoName1, &memInfo->memTotal);
    fgets(buff, sizeof(buff), fd);
    sscanf(buff, "%s %lu ", memInfo->infoName2, &memInfo->memFree);
    fgets(buff, sizeof(buff), fd);
    sscanf(buff, "%s %lu ", memInfo->infoName3, &memInfo->memAvail);
    fclose(fd);

    double mUsedRate = 0;
    mUsedRate = (double)(memInfo->memTotal - memInfo->memAvail) / (double)memInfo->memTotal;

    char szResult[DEFAULT_OUTPUT_FORMAT_SIZE];
    char szResult2[DEFAULT_OUTPUT_FORMAT_SIZE];
    char szResult3[DEFAULT_OUTPUT_FORMAT_SIZE];

    ByteSprintf(szResult, (double)(memInfo->memTotal) * 1024, 'G'); // 内存信息在 /proc/meminfo 中的单位为 KB
    ByteSprintf(szResult2, (double)(memInfo->memFree) * 1024, 'G');
    ByteSprintf(szResult3, (double)(memInfo->memAvail) * 1024, 'G');

    if (m_memHighPercent <= 0)
    {
        m_memHighPercent = 80; //默认告警百分比80%
    }

    if (memWarnThreshold <= 0)
    {
        memWarnThreshold = 10; //默认告警阈值10次
    }

    if ((mUsedRate * 100) > m_memHighPercent) 
    {
        memWarnTime = memWarnTime % memWarnThreshold;
        if (memWarnTime == 0) //每达到阈值告警一次
        {
            char usedResult[DEFAULT_OUTPUT_FORMAT_SIZE];
            ByteSprintf(usedResult, (double)(memInfo->memTotal) * 1024 * mUsedRate, 'G');

            stringstream ss1;
            ss1 << std::setiosflags(std::ios::fixed) << std::setprecision(2) << mUsedRate * 100;

            string warn = "{ \"total\":\"" + string(szResult) + "\"," +
                "\"used\":\"" + ss1.str() + "%\"," + MemoryProcessStatus();
            LogWarn(Severity_Middle, Error_Resource, LOG_EVT_RESOURCE_MEMORY_TOO_HIGH, CSimpleStringA::Format("%s", warn.c_str()));
        }
        memWarnTime++;
    }
}

void ResourceWatcherFSM::GetDiskStatusFrom(LPCTSTR path)
{
    if (m_diskHighPercent <= 0)
    {
        m_diskHighPercent = 90; //默认硬盘告警百分比90%
    }

    unsigned long long uiTotalBytes;
    unsigned long long uiFreeDiskBytes;

    char szResult[DEFAULT_OUTPUT_FORMAT_SIZE];
    char szResult2[DEFAULT_OUTPUT_FORMAT_SIZE];

    BOOL readFlag = DiskInfo::GetDiskSpace(path, uiTotalBytes, uiFreeDiskBytes);
    double dUsedRate = 1 - (uiFreeDiskBytes * kConversion[3]) / (uiTotalBytes * kConversion[3]);

    ByteSprintf(szResult, (double)uiTotalBytes);
    ByteSprintf(szResult2, (double)uiFreeDiskBytes);

    if (readFlag && (dUsedRate * 100 < m_diskHighPercent)) {
        //DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("[Disk# %s] total: %s, free: %s, [Disk] used rate: %.1lf%%.", path, szResult, szResult2, dUsedRate * 100);
    }
    else
    {
        LogWarn(Severity_Middle, Error_Resource, LOG_EVT_RESOURCE_HARDDISK_TOO_HIGH,
            CSimpleStringA::Format("DISK TOO HIGH! -- [Disk# %s] total: %s, free: %s, [Disk] used rate: %.1lf%%.",
                path, szResult, szResult2, dUsedRate * 100));

        CheckDiskFileSpaceTask* task4 = new CheckDiskFileSpaceTask(this);
        GetEntityBase()->GetFunction()->PostThreadPoolTask(task4);
    }
}

void ResourceWatcherFSM::GetSystemDiskStatus()
{
    GetDiskStatusFrom("/");
}

void ResourceWatcherFSM::GetOperationDiskStatus()
{
    GetDiskStatusFrom(m_csUploadVideoPath);
}


void ResourceWatcherFSM::switchWindowsEffect(const char* cfgFilePath, bool enable)
{
    char tmp[33];
    memset(tmp, 0, 33);
    inifile_read_str_s("Compositing", "Enabled", "", tmp, 32, cfgFilePath);
    if (strlen(tmp) == 0 || stricmp(tmp, "false") == 0) {
        if (enable) {
            inifile_write_str(cfgFilePath, "Compositing", "Enabled", "true");
            LogWarn(Severity_Low, Error_InvalidState, LOG_RESOURCEWATCHER_COMPOSITING_CHANGE_ON, "to active window effect");
        }
    }
    else if (stricmp(tmp, "true") == 0) {
        if (!enable) {
            inifile_write_str(cfgFilePath, "Compositing", "Enabled", "false");
            LogWarn(Severity_Low, Error_InvalidState, LOG_RESOURCEWATCHER_COMPOSITING_CHANGE_OFF, "to inactive window effect");
        }
    }
}

void ResourceWatcherFSM::RecoverDDEClipboardEnable()
{
    const std::string clipboardPath = "/usr/bin/dde-clipboard";
    const std::string clipboardPathBak = "/usr/bin/dde-clipboard.bak";
    if (!ExistsFileA(clipboardPath.c_str()) && ExistsFileA(clipboardPathBak.c_str())) {
        fileutil_copy_file(clipboardPath.c_str(), clipboardPathBak.c_str());
        //fileutil_delete_file(clipboardPathBak.c_str());
        LogWarn(Severity_Low, Error_Debug, LOG_RESOURCEWATCHER_CLIPBOARD_RECOVER_ENABLE, "recover clipboard succ.");
    }
    else {
        DbgWithLink(LOG_LEVEL_INFO, LOG_TYPE_SYSTEM)("%s exists.", clipboardPath.c_str());
    }
}

void ResourceWatcherFSM::ConfirmDDEClipboardDisable()
{
    const std::string clipboardPath = "/usr/bin/dde-clipboard";
    const std::string clipboardPathBak = "/usr/bin/dde-clipboard.bak";
    char* clipboards[] = { "dde-clipboard", "dde-clipboardloader" };

    if (!ExistsFileA(clipboardPath.c_str())) {
        DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("There are no any %s files.", clipboardPath.c_str());
        if (ExistsFileA(clipboardPathBak.c_str())) {
            DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("%s exists.", clipboardPathBak.c_str());
        }
        return;
    }

    if (0 != fileutil_copy_file(clipboardPathBak.c_str(), clipboardPath.c_str())) {
        LogWarn(Severity_Low, Error_Unexpect, LOG_RESOURCEWATCHER_CLIPBOARD_REMOVE_FAILED, "remove clipboard failed");
    }
    else {
        fileutil_delete_file(clipboardPath.c_str());
        osutil_terminate_related_process(clipboards, array_size(clipboards));
        LogWarn(Severity_Low, Error_Process, LOG_RESOURCEWATCHER_CLIPBOARD_REMOVE_SUCC, "remove clipboard succ.");
    }
}

void ResourceWatcherFSM::ConfirmNotificationCenterDisable()
{
    const char* osd_file_path = "/usr/lib/deepin-daemon/dde-osd";
    const char* osd_bak_file_path = "/usr/lib/deepin-daemon/dde-osd.bak";

    CSmartPointer<IConfigInfo> spConfig;
    GetEntityBase()->GetFunction()->OpenConfig(Config_Cache, spConfig);
    int flag = 0;
    spConfig->ReadConfigValueInt("UOSFeatures", "NotifyCenterSupport", flag);
    if (flag == 1) {
        DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("allow the dde-osd process alive.");
        if (!ExistsFileA(osd_file_path) && ExistsFileA(osd_bak_file_path)) {
            fileutil_copy_file(osd_file_path, osd_bak_file_path);
            LogWarn(Severity_Low, Error_Debug, LOG_RESOURCEWATCHER_OSD_RECOVER_ENABLE, "recover dde osd succ.");
        }
    }
    else {
        if (ExistsFileA(osd_file_path) && !ExistsFileA(osd_bak_file_path)) {
            char* relates[] = { "dde-osd" };
            if (0 != fileutil_copy_file(osd_bak_file_path, osd_file_path)) {
                LogWarn(Severity_Low, Error_Unexpect, LOG_RESOURCEWATCHER_CLIPBOARD_REMOVE_FAILED, "remove dde osd failed");
            }
            else {
                osutil_terminate_related_process(relates, array_size(relates));
                fileutil_delete_file(osd_file_path);
                LogWarn(Severity_Low, Error_Process, LOG_RESOURCEWATCHER_OSD_REMOVE_SUCC, "remove dde osd succ.");
            }
        }
    }
}

void ResourceWatcherFSM::ConfirmWindowEffectHasBeenOpen()
{
    array_header_t* arr;
    arr = fileutil_get_sub_dirs_a("/home");
    if (arr) {
        int i;
        for (i = 0; i < arr->nelts; ++i) {
            char szDestSubDir[256] = { 0 };
            char* dir = ARRAY_IDX(arr, i, char*);
            DbgWithLink(LOG_LEVEL_DEBUG, LOG_TYPE_SYSTEM)("sub dir: %s", dir);
            strcpy(szDestSubDir, dir);
            strcat(szDestSubDir, SPLIT_SLASH_STR);
            strcat(szDestSubDir, ".config/kwinrc");
            if (ExistsFileA(szDestSubDir)) {
                switchWindowsEffect(szDestSubDir, true);
            }
        }
        toolkit_array_free2(arr);
    }
}
#endif // RVC_OS_LINUX