server1/SettingLibrary/setinfomanager.cpp

#include "setinfomanager.h"

#include <QLayout>

#include "LHLogInit.h"
#include "LHQLogAPI.h"

#include "FromWebAPI.h"

#include "SystemConfig.h"
#include "spdlog/spdlog.h"
#include "GlobalInfo.h"
#include "GlobalVariable.h"
#include "CompareItemData.h"
#include "setinfowidget.h"
#include "SoundCardData.h"


SetInfoManager::SetInfoManager(QObject *parent)
    : QObject(parent)
    , m_pWgtSet(nullptr)
{

}

SetInfoManager::~SetInfoManager()
{
    Release();
}

/* 初始化，初始化所有参数变量 */
int SetInfoManager::Init(const stInitData* pData)
{
    m_initData = *pData;
    initLog("ACAServerSetting", g_apiLhQLog);
    /* 初始化默认对比项参数 */
    setDefaultCompareItem();

    /* 初始化对比项数据管理器 */
    if(!CIData.init())
    {
        SPDLOG_ERROR("对比项数据初始化失败");
        return -1;
    }


    /* 初始化webAPI */
    if(!initWebAPI())
    {
        return -1;
    }

    /* 获取系统中的参数设置 */
    if(!getSystemConfig())
    {
        SPDLOG_ERROR("获取系统配置失败");
        return -1;
    }

    /* 从数据库中获取声卡信息 */
    if(!getSoundCardInfo())
    {
        SPDLOG_ERROR("获取声卡信息失败");
        return -1;
    }
    

    /* 从数据库获取对比项信息 */
    QList<CompareItemInfo_t> listItems;
    if(!m_fromWebAPI->getCompareItemInfo(listItems))
    {
        SPDLOG_ERROR("获取对比项信息失败");
    }
    CIData.setCompareItemList(listItems);


    return 0;
}

int SetInfoManager::CreateWindow(int nSkinType, QWidget* parent)
{
    // 设置皮肤
//    LHStyleManager::Instance()->SetSkinStyle(nSkinType);

    // 创建配置界面
    if(m_pWgtSet == nullptr)
    {
        m_pWgtSet = new SetInfoWidget(parent);
        if(parent->layout())
        {
            parent->layout()->addWidget(m_pWgtSet);
        }
        m_pWgtSet->setWebAPI(m_fromWebAPI);
        /* 获取最外层的window指针 */
        GInfo.setTopWindow(parent->window());
    }
    return 0;
}

int SetInfoManager::ShowWindow(int nSkinType, int nServiceID, bool bShowWindow)
{
    if(m_pWgtSet)
    {
        if(bShowWindow)
        {
            // 设置皮肤
//            LHStyleManager::Instance()->SetSkinStyle(nSkinType);
            m_pWgtSet->show();
        }
        else
        {
            m_pWgtSet->hide();
        }
    }
    return 0;
}


/* 获取数据是否改变了 */
QString SetInfoManager::GetChangedData()
{
    if(m_pWgtSet)
    {
        if(m_pWgtSet->dataChanged())
        {
            return "还未保存内容，是否保存！";
        }
    }
    return "";
}

/* 保存 */
int SetInfoManager::Save()
{
    if(m_pWgtSet)
    {
        if(!m_pWgtSet->saveData())
        {
            return -1;
        }
    }
    return 0;
}

/* 释放内存 */
int SetInfoManager::Release()
{
    if(m_pWgtSet)
    {
        m_pWgtSet->deleteLater();
        m_pWgtSet = nullptr;
    }

    if(m_fromWebAPI)
    {
        delete m_fromWebAPI;
        m_fromWebAPI = nullptr;
    }

    return 0;
}

/* 生成默认的对比项参数 */
void SetInfoManager::setDefaultCompareItem()
{
    CompareItemInfo_t defaultItem;
    /* 对比项名称不需要设置 */

    /* 是否启用该对比项 */
    defaultItem.isEnable = true;
    /* 设置主通道和第二通道信息 */
    CompareItemRoadInfo_t mainRoad;
    mainRoad.isEnableRecord = true; // 主通道默认开启录音
    mainRoad.nCompareRoadNum = 1; // 主通道编号为1
    mainRoad.strCompareRoadName = "主通道"; // 主通道名称
    // mainRoad.scRoadInfo.strSoundCardName = SC_System;
    // mainRoad.scRoadInfo.roadInfo.nRoadNum = 0; // 默认通道编号为0
    defaultItem.mapRoad.insert(mainRoad.nCompareRoadNum, mainRoad);

    CompareItemRoadInfo_t secondRoad;
    secondRoad.isEnableRecord = true; // 第二通道默认开启录音
    secondRoad.nCompareRoadNum = 2; // 第二通道编号为2
    secondRoad.strCompareRoadName = "第2通道"; // 第二通道名称
    // secondRoad.scRoadInfo.nSoundCardNum = 0; // 默认声卡编号为0
    // secondRoad.scRoadInfo.roadInfo.nRoadNum = 1; // 默认通道编号为1
    
    defaultItem.mapRoad.insert(secondRoad.nCompareRoadNum, secondRoad);

    /* 初始化静音、过载、反相参数 */
    defaultItem.paramMute.isEnable = true;              // 静音检测默认开启
    defaultItem.paramMute.threshold.nThreshold = 64;    // 静音检测默认阈值
    defaultItem.paramMute.nLen = 8;                     // 静音检测默认长度
    defaultItem.paramMute.nSensitivity = 80;            // 静音检测默认灵敏度

    defaultItem.paramOverload.isEnable = true;          // 过载检测默认开启
    defaultItem.paramOverload.threshold.nThreshold = 4; // 过载检测默认
    defaultItem.paramOverload.nLen = 30;                // 过载检测默认长度
    defaultItem.paramOverload.nSensitivity = 20;        // 过载检测

    defaultItem.paramPhase.isEnable = true;             // 反相检测默认开启
    defaultItem.paramPhase.threshold.dThreshold = 0.75; // 反相检测默认阈值
    defaultItem.paramPhase.nLen = 60;                   // 反相检测默认长度
    defaultItem.paramPhase.nSensitivity = 60;           // 反相检测默认灵敏度

    /* 设置全局默认对比项 */
    GInfo.setDefaultCompareItem(defaultItem);
}

/* 初始化WebAPI */
bool SetInfoManager::initWebAPI()
{
    if(m_fromWebAPI == nullptr)
    {
        m_fromWebAPI = new FromWebAPI();
        if(!m_fromWebAPI->initWebApi(m_initData.strWebAddr, m_initData.strDBID, "ACAWatch"))
        {
            SPDLOG_ERROR("WebAPI 初始化失败");
            delete m_fromWebAPI;
            m_fromWebAPI = nullptr;
            return false;
        }
    }
    return true;
}


/* 获取数据库中系统设置参数 */
bool SetInfoManager::getSystemConfig()
{
    if(m_fromWebAPI == nullptr)
    {
        SPDLOG_ERROR("WebAPI 未初始化");
        return false;
    }
    QMap<std::string, std::string> mapConfig;
    if(!m_fromWebAPI->getSystemConfig(mapConfig))
    {
        return false;
    }
    /* 将获取到的配置转换成结构体 */
    for(auto it = mapConfig.begin(); it != mapConfig.end(); ++it)
    {

        if(Config_Base == it.key())
        {
            if(!SysConfig.getBaseConfigFromJson(it.value()))
            {
                SPDLOG_ERROR("获取基础配置失败");
            }
        }
        else if(Config_CompareAI == it.key())
        {
            if(!SysConfig.getAICompareConfigFromJson(it.value()))
            {
                SPDLOG_ERROR("获取AI对比配置失败");
            }
        }
        else if(Config_NoiseBase == it.key())
        {
            if(!SysConfig.getNoiseDetectBaseConfigFromJson(it.value()))
            {
                SPDLOG_ERROR("获取噪音检测基础配置失败");
            }
        }
        else if(Config_NoiseParam == it.key())
        {
            if(!SysConfig.getNoiseDetectParamFromJson(it.value()))
            {
                SPDLOG_ERROR("获取噪音检测参数失败");
            }
        }
        else if(Config_Database == it.key())
        {
            if(!SysConfig.getDatabaseConfigFromJson(it.value()))
            {
                SPDLOG_ERROR("获取数据库设置失败");
            }
        }
        // else if(Config_SoundCardInfo == it.key())
        // {
        //     QMap<int, SoundCardInfo_t> soundCardInfo;
        //     if(!SysConfig.getSoundCardInfoFromJson(it.value(), soundCardInfo))
        //     {
        //         SPDLOG_ERROR("获取声卡信息失败");
        //     }
        //     SoundCards.setSoundCardInfo(soundCardInfo); // 设置声卡信息到全局管理器
        // } 
        else
        {
            SPDLOG_DEBUG("未知的系统配置项: {}", it.key());
        }
    }

    /* 检测时段单独获取 */
    QMap<int, DetectPeriodConfig_t> mapDetectConfig;
    if(!m_fromWebAPI->getDetectPeriodConfig(mapDetectConfig))
    {
        SPDLOG_ERROR("获取对比项检测时段配置失败");
        return false;
    }
    SysConfig.setDetectPeriodConfig(mapDetectConfig);

    return true;
}


/* 获取声卡信息 */
bool SetInfoManager::getSoundCardInfo()
{
    std::map<std::string, SoundCardPCMInfo_t> mapSoundCard;
    if(!m_fromWebAPI->getSoundCardInfo(mapSoundCard))
    {
        return false;
    }

    SoundCards.setSoundCardInfo(mapSoundCard); // 设置声卡信息到全局管理器
    
    return true;
}