server1/Server/ACAServer.cpp

#include "ACAServer.h"


#include "GlobalInfo/GlobalInfo.h"
#include "commonDefine.h"
#include "SoundCards.h"
#include "SystemConfig.h"
#include "ThreadPool.h"
#include "ThreadManager.h"
#include "ThreadWriteDBManager.h"
#include "RtpServer.h"
#include "LHLogInit.h"


#include <QFile>
#include <QString>
#include <QCoreApplication>
#include <QSettings>




ACAServer::ACAServer()
{
    m_logger = spdlog::get("ACAServer");
    if(m_logger == nullptr)
    {
        fmt::print("ACAServer logger is nullptr");
        return;
    }

    connect(&m_fromMQTT, &FromMQTT::signal_recvMessage, this, &ACAServer::do_receiveMQTTMessage);
}

ACAServer::~ACAServer()
{
    if(m_rtpServer != nullptr)
    {
        m_rtpServer->thread_stop_block();
        delete m_rtpServer;
        m_rtpServer = nullptr;
    }
}




/**
 * @brief 初始化基础信息
 *        返回值说明：
 *              这里返回false会直接退出服务，因此不是必须项即使失败也不返回false
 *
 * @return true 
 * @return false 
 */
bool ACAServer::initGlobalInfo()
{
    /*------------------------------------------------------------------------------------*/
    /* 读取配置文件 */
    if(!readConfigFile()) {
        SPDLOG_ERROR("读取配置文件失败");
        return false;
    }


    /* 设置MQTT服务器信息 */
    GInfo.setMqttInfo(m_mqttIP, m_mqttPort);

    /* 连接MQTT */
    m_fromMQTT.setIPAndPort(m_mqttIP, m_mqttPort);
    m_fromMQTT.addSubcribe(m_webapiTopic, 0); // 订阅WebAPI主题
    m_fromMQTT.connectToServer();

    /* 等待mqtt回复webapi信息 */
    if(!waitForWebAPIReply()) 
    {
        return false;
    }
    SPDLOG_INFO("WebAPI URL: {}", m_webAPIUrl.toStdString());
    SPDLOG_INFO("WebAPI DBID: {}", m_webAPIID.toStdString());

    /* 设置WebAPI信息 */
    // m_webAPIID = "cf6b57fa3d9841e22c3c897e6b8e66b8";
    GInfo.setWebAPIInfo(m_webAPIUrl, m_webAPIID);

    /* 登录webapi */
    if(!m_fromWebAPI.initWebApi(m_webAPIUrl, m_webAPIID, m_appType))
    {
        return false;
    }

    /*------------------------------------------------------------------------------------*/
    /* 获取系统声卡信息 */
    if(!SoundCards.InitData())
    {
        return false;
    }
    /* 清空数据库声卡PCM数据 */
    if(!m_fromWebAPI.clearSoundCardInfo())
    {
        SPDLOG_LOGGER_ERROR(m_logger, "清空声卡信息失败");
        return false;
    }

    auto soundCardsInfo = SoundCards.getSoundCardInfo();
    /* 将声卡信息写入数据库 */
    if(!m_fromWebAPI.insertPCMChannelInfo(soundCardsInfo))
    {
        SPDLOG_LOGGER_WARN(m_logger, "更新声卡信息到WebAPI失败");
    }

    /*------------------------------------------------------------------------------------*/
    /* 更新SysConfig */
    QMap<std::string, std::string> mapSysConfig;
    if(!m_fromWebAPI.getSystemConfig(mapSysConfig))
    {
        SPDLOG_LOGGER_ERROR(m_logger, "获取系统配置失败");
        return false;
    }
    SysConfig.parseConfigFromDatabase(mapSysConfig);

    /* 设置录音文件目录 */
    QString recordFilePath = SysConfig.getDatabaseConfig().strRecordFilePath;
    if(recordFilePath.isEmpty())
    {
        SPDLOG_LOGGER_ERROR(m_logger, "录音文件路径未设置");
        return false;
    }
    GInfo.setRootPath(recordFilePath);

    /*------------------------------------------------------------------------------------*/
    /* 初始化全局数据信息，主要是为了初始化文件夹 */
    GInfo.init();
    /* 判断是否需要清空文件夹 */
    const auto& baseConfig = SysConfig.getBaseConfigSrc();
    if(baseConfig.isClearDirSystemOn)
    {
        GInfo.clearHistoryDirectories();
        /* 将数据库中所有的录音文件状态设置为已删除 */
        if(!m_fromWebAPI.deleteAllRecordFileInfo())
        {
            SPDLOG_LOGGER_ERROR(m_logger, "删除所有录音文件信息失败");
            return false;
        }
    }


    /*------------------------------------------------------------------------------------*/
    /* 应用一些配置选项 */
#if defined(C_RELEASE)
    bool isDebug = SysConfig.getBaseConfigSrc().isEnableDebugLog;
    if(isDebug)
    {
        changeLogLevel(ELogLevel::Log_Debug);
    } else {
        changeLogLevel(ELogLevel::Log_Info);
    }
#endif

    /*------------------------------------------------------------------------------------*/
    /* 发送服务信息到MQTT中，设置为保留信息 */
    sendServerInfoToMQTT();

    /*------------------------------------------------------------------------------------*/
    printACAServerConfig();

    return true;
}


/* 开启服务 */
bool ACAServer::startService()
{
    // m_threadCompareItemManager = new ThreadCompareItemManager();
    // if(m_threadCompareItemManager == nullptr) 
    // {
    //     SPDLOG_LOGGER_ERROR(m_logger, "创建对比项管理线程失败");
    //     return false;
    // }
    /* 开启对比项管理线程 */
    CPPTP.add_task(&ThreadCompareItemManager::thread_CompareItemManager, &CompareItemManager);
    /* 开启录音通道销毁线程 */
    // CPPTP.add_task(&ACAServer::thread_deleteRecordThread, this);
    CPPTP.add_task(&ThreadManager::thread_destroyeRecordThread, &ThreadMan);
    /* 开启处理报警信息的线程 */
    CPPTP.add_task(&ThreadWriteDBManager::thread_task, &WriteDB);
    /* 开启RTP监听服务线程 */
    CPPTP.add_task(&ACAServer::thread_RTPServer, this);

    return true;
}

/* 线程函数，定时删除录音线程的实例 */
// void ACAServer::thread_deleteRecordThread()
// {
//     while(m_isRunning)
//     {
//         std::this_thread::sleep_for(std::chrono::seconds(5));
//         /* 销毁录音线程 */
//         ThreadMan.destroyeRecordThread();
//     }
// }

/* 线程函数，开启RTP监听服务，一个壳 */
void ACAServer::thread_RTPServer()
{
    m_rtpServer = new RTPServer();
    const auto dbConfig = SysConfig.getDatabaseConfig();
    int port = 8808;
    if(dbConfig.nListenPort != 0)
    {
        port = dbConfig.nListenPort;
    }
    /* 线程任务，会一直阻塞到这里 */
    m_rtpServer->thread_task(port);

}



/* 读取配置文件 */
bool ACAServer::readConfigFile()
{
    QString configPath = QCoreApplication::applicationDirPath() + "/config/BaseConfig.ini";
    QFile file(configPath);
    if(!file.exists()) {
        spdlog::error("配置文件 {} 不存在", configPath.toStdString());
        return false;
    }

    QSettings settings(configPath, QSettings::IniFormat);
    settings.beginGroup("MQTT");
    m_mqttIP = settings.value("MQTT_IP", "").toString();
    m_mqttPort = settings.value("MQTT_PORT", 1883).toInt();
    settings.endGroup();

    settings.beginGroup("Audio");
    int sampleRate = settings.value("SampleRate", 48000).toInt();
    int channelCount = settings.value("ChannelCount", 1).toInt();
    int bitDepth = settings.value("BitDepth", 16).toInt();
    settings.endGroup();
    GInfo.m_sampleRate = sampleRate;
    GInfo.m_numChannels = channelCount;
    GInfo.m_bitsPerSample = bitDepth;

    return true;
}

/* 等待webapi回复信息 */
bool ACAServer::waitForWebAPIReply()
{
    int timeout = 5000; // 等待5秒
    int elapsed = 0;
    while(!m_isGetWebInfoSuccess.load() && elapsed < timeout) 
    {
        QCoreApplication::processEvents();
        std::this_thread::sleep_for(std::chrono::milliseconds(10)); // 每10毫秒检查一次
        elapsed += 10;
    }

    if(!m_isGetWebInfoSuccess.load()) 
    {
        SPDLOG_LOGGER_ERROR(m_logger, "等待MQTT消息超时，未能获取WebAPI信息");
        return false;
    }

    return true;
}


/* 等待一些必选项设置成功，不成功会一直等待 */
bool ACAServer::waitForRequiredOptions()
{

    return true;
}


/* 发送服务信息到MQTT中 */
bool ACAServer::sendServerInfoToMQTT()
{
    const QString& mqttPubTopicServerInfo = GInfo.mqttPubTopicServerInfo();
    nJson serverInfo;
    serverInfo["server_ip"] = SysConfig.getBaseConfigSrc().strServerIP.toStdString();
    serverInfo["server_rtp_port"] = SysConfig.getDatabaseConfig().nListenPort;
    /* 录音相关的参数 */
    serverInfo["sample_rate"] = GInfo.sampleRate();
    serverInfo["channel_count"] = GInfo.numChannels();
    serverInfo["bit_depth"] = GInfo.bitsPerSample();

    QByteArray payload = QString::fromStdString(serverInfo.dump()).toUtf8();

    if(!m_fromMQTT.sendMessage(mqttPubTopicServerInfo, payload, 0, true))
    {
        SPDLOG_LOGGER_ERROR(m_logger, "发送服务信息到MQTT失败");
        return false;
    }

    return true;
}







/* 打印ACA服务一些基础配置参数 */
void ACAServer::printACAServerConfig()
{
    const auto& baseConfig = SysConfig.getBaseConfigSrc();
    const auto& dbConfig = SysConfig.getDatabaseConfig();
    SPDLOG_LOGGER_INFO(m_logger, "=========================================================================================");
    SPDLOG_LOGGER_INFO(m_logger," ");
    /* 打印一些基础参数 */
    SPDLOG_LOGGER_INFO(m_logger, "MQTT服务器地址: {}, 端口: {}", m_mqttIP.toStdString(), m_mqttPort);
    SPDLOG_LOGGER_INFO(m_logger, "WebAPI地址: {}, ID: {}", m_webAPIUrl.toStdString(), m_webAPIID.toStdString());
    SPDLOG_LOGGER_INFO(m_logger, "ACA服务地址: {}, RTP服务TCP监听端口: {}", baseConfig.strServerIP.toStdString(), dbConfig.nListenPort);
    SPDLOG_LOGGER_INFO(m_logger, "MQTT订阅: ");
    SPDLOG_LOGGER_INFO(m_logger, "      服务信息订阅: {}", GInfo.mqttPubTopicServerInfo().toStdString());
    SPDLOG_LOGGER_INFO(m_logger, "      对比项信息订阅: {}", GInfo.mqttPubTopicCompareItem().toStdString());
    SPDLOG_LOGGER_INFO(m_logger, "录音参数: ");
    SPDLOG_LOGGER_INFO(m_logger, "      采样率: {}, 通道数: {}, 位深: {}", GInfo.m_sampleRate, GInfo.m_numChannels, GInfo.m_bitsPerSample);
    SPDLOG_LOGGER_INFO(m_logger, "录音文件路径: {}", SysConfig.getDatabaseConfig().strRecordFilePath.toStdString());

    // SPDLOG_LOGGER_INFO(m_logger, "-----------------------------------------------------------------------------------------");


    SPDLOG_LOGGER_INFO(m_logger, "=========================================================================================");
}


/* 处理MQTT消息 */
void ACAServer::do_receiveMQTTMessage(const QMQTT::Message& message)
{
    SPDLOG_LOGGER_TRACE(m_logger, "接收到MQTT消息: {}", message.payload().toStdString());
    if(message.topic() == m_webapiTopic) 
    {
        /* 处理WebAPI消息 */
        QString payload = QString::fromUtf8(message.payload());
        try 
        {
            nJson jsonMsg = nJson::parse(payload.toStdString());
            m_webAPIUrl = jsonMsg["webaddr"].is_null() ? "" : jsonMsg["webaddr"].get<std::string>().c_str();
            m_webAPIID = jsonMsg["serverid"].is_null() ? "" : jsonMsg["serverid"].get<std::string>().c_str();

        }nJsonCatchNoReturn
        m_isGetWebInfoSuccess.store(true);
        SPDLOG_LOGGER_TRACE(m_logger, "WebAPI信息获取成功: URL = {}, ID = {}", m_webAPIUrl.toStdString(), m_webAPIID.toStdString());
    }
}