C++ Qt 客户端架构设计#

// AsyncTaskExecutor.h — 整个实现都在头文件中
#pragma once
#include <QObject>
#include <QtConcurrent>

namespace RyB
{
class AsyncTaskExecutor : public QObject
{
    // 模板方法必须在头文件实现
    template<typename ResultType>
    static ResultType execute(std::function<ResultType()> task, ...);
};
} // namespace RyB

// qt/ToolBox/src/App/ToolPage.h
class ToolPage : public QWidget
{
    Q_OBJECT

public:
    explicit ToolPage(QWidget* parent = nullptr) : QWidget(parent) {}
    ~ToolPage() override = default;

    virtual QString name() const = 0;    // 页面名称（显示在导航栏）
    virtual QIcon icon() const = 0;      // 页面图标
    virtual void onActivate() {}          // 页面被切换到时调用
    virtual void onDeactivate() {}        // 页面被切走时调用
};

class VideoPlayerPage : public ToolPage
{
    void onActivate() override
    {
        // 页面切入：恢复播放
        m_player->resume();
    }

    void onDeactivate() override
    {
        // 页面切出：暂停播放，释放 GPU 资源
        m_player->pause();
    }
};

// qt/ToolBox/src/App/MainWindow.cpp
void MainWindow::setupUi()
{
    // 左侧导航栏
    m_navBar = new NavBar(this);
    m_navBar->setFixedWidth(256);

    // 右侧页面栈
    m_stackedWidget = new QStackedWidget(this);

    // 导航栏点击 → 切换页面栈
    connect(m_navBar, &NavBar::itemClicked,
            this, &MainWindow::onNavItemClicked);
}

void MainWindow::addToolPage(ToolPage* page)
{
    m_pages.append(page);
    m_stackedWidget->addWidget(page);        // 加入页面栈
    m_navBar->addItem(page->icon(), page->name());  // 加入导航栏

    if (m_pages.size() == 1)
    {
        onNavItemClicked(0);  // 默认选中第一个页面
    }
}

void MainWindow::onNavItemClicked(int index)
{
    // 通知旧页面失活
    if (m_currentIndex >= 0)
        m_pages[m_currentIndex]->onDeactivate();

    // 切换页面栈
    m_currentIndex = index;
    m_stackedWidget->setCurrentIndex(index);

    // 通知新页面激活
    m_pages[index]->onActivate();
    m_navBar->setCurrentIndex(index);
}

// qt/ToolBox/src/main.cpp
int main(int argc, char* argv[])
{
    QApplication app(argc, argv);
    app.setApplicationName("RyBOS ToolBox");
    app.setOrganizationName("RyB");

    MainWindow window;
    window.addToolPage(new MapLoaderPage(&window));
    window.addToolPage(new GisCoordinatePage(&window));
    window.addToolPage(new TilesViewerPage(&window));
    window.addToolPage(new PointCloudConvertPage(PointCloudConvertPage::ConvertType::Las, &window));
    window.addToolPage(new OsgbConvertPage(OsgbConvertPage::ConvertMode::Legacy, &window));
    window.addToolPage(new ImageWebpConvertPage(&window));
    window.addToolPage(new VideoPlayerPage(&window));
    window.addToolPage(new SerialDebugPage(&window));
    window.addToolPage(new CryptoToolPage(&window));
    window.show();

    return app.exec();
}

// 核心原理
template<typename ResultType>
static ResultType execute(std::function<ResultType()> task, ...)
{
    // 1. 后台线程执行任务
    QFuture<ResultType> future = QtConcurrent::run(task);

    // 2. 局部事件循环等待（界面不卡！）
    QEventLoop loop;
    QFutureWatcher<ResultType> watcher;
    QObject::connect(&watcher, &QFutureWatcher<ResultType>::finished,
                     &loop, &QEventLoop::quit);
    watcher.setFuture(future);
    loop.exec();  // ← 这里阻塞但处理 UI 事件

    // 3. 返回结果
    return future.result();
}

int result = AsyncTaskExecutor::executeWithProgress<int>(
    [](std::function<void(int)> progress) -> int {
        for (int i = 0; i <= 100; i += 10)
        {
            progress(i);  // 在后台线程调用
            QThread::msleep(200);
        }
        return 100;
    },
    [this](int progress) {
        // 在主线程中执行，可以安全更新 UI
        m_progressBar->setValue(progress);
    }
);

QtThreadPool pool(QThread::idealThreadCount());  // 根据 CPU 核数自动设置

pool.submit([]() {
    // 在后台线程执行
    processLargeFile("data.las");
});

class ConfigManager : public QObject
{
    Q_OBJECT

public:
    // 单例模式
    static ConfigManager& instance();

    // 初始化
    bool initialize(const QString& configFilePath = QString());

    // 类型安全的 get/set
    QString get(const QString& group, const QString& key,
                const QString& defaultValue = QString()) const;
    int getInt(const QString& group, const QString& key,
               int defaultValue = 0) const;
    double getDouble(const QString& group, const QString& key,
                     double defaultValue = 0.0) const;
    bool getBool(const QString& group, const QString& key,
                 bool defaultValue = false) const;

    // 设置值（线程安全，自动保存）
    bool set(const QString& group, const QString& key, const QVariant& value);

    // 配置变更通知
    // emit valueChanged(group, key, oldValue, newValue)

private:
    QSettings* m_settings;      // Qt 配置读写
    QMutex m_mutex;             // 线程安全
    bool m_autoSave;            // 自动保存
};

// 方式1：单例（全局配置）
ConfigManager& config = ConfigManager::instance();
config.initialize("config.ini");
QString host = config.get("network", "host", "localhost");

// 方式2：实例（模块独立配置）
ConfigManager moduleConfig("module.ini");
moduleConfig.set("app", "debug", true);

// 配置变化时自动通知
connect(&ConfigManager::instance(), &ConfigManager::valueChanged,
        this, [](const QString& group, const QString& key,
                 const QVariant& oldVal, const QVariant& newVal) {
    if (group == "network" && key == "host")
    {
        reconnectToServer(newVal.toString());
    }
});

class LogManager
{
public:
    static LogManager* getInstance();

    // 初始化：创建本次启动的日志目录
    bool initialize(const QString& baseLogDir = "logs",
                    int maxKeepCount = 10);

    // 每次启动创建编号目录：logs/00001/, logs/00002/, ...
    // 自动清理旧目录，只保留最新 10 个

    QString getCurrentLogDirectory() const;  // logs/00003/
    QString getCurrentLogNumber() const;     // "00003"

    // 添加日志类别
    void addLogCategory(const QString& category, const QString& filename);
    // 例：addLogCategory("network", "network.log")
    //     addLogCategory("serial", "serial.log")

    // 设置日志模式
    void setLogMode(const QString& mode);  // "debug" 或 "release"
};

// 不同模块用不同 TAG 输出日志
LOG_TAG("Network", "连接到服务器 %s:%d", host, port);
LOG_TAG("Serial",  "发送数据: %s", hexData);
LOG_TAG("Crypto",  "AES 加密完成, 密文长度: %d", cipherLen);

// debug 模式：所有日志都记录
// release 模式：DEBUG 级别日志不记录
LogManager::getInstance()->setLogMode("release");

// 后台线程 emit 信号 → 主线程 slot 执行（自动排队连接）
class Worker : public QObject
{
    Q_OBJECT
signals:
    void progressUpdated(int percent);
    void taskFinished(QString result);

public slots:
    void doWork()
    {
        for (int i = 0; i <= 100; i += 10)
        {
            emit progressUpdated(i);  // 后台线程 emit
            QThread::msleep(500);
        }
        emit taskFinished("完成");
    }
};

// 主线程连接
QThread* thread = new QThread;
Worker* worker = new Worker;
worker->moveToThread(thread);
connect(thread, &QThread::started, worker, &Worker::doWork);
connect(worker, &Worker::progressUpdated, this, &MainWindow::onProgress);
connect(worker, &Worker::taskFinished, this, &MainWindow::onFinished);
thread->start();

class LoginDialog : public QDialog
{
    Q_OBJECT

public:
    explicit LoginDialog(QWidget* pParent = nullptr);

private slots:
    void onLoginClicked();

private:
    void initData();       // 创建控件、加载用户配置
    void initLayout();     // 垂直布局
    void initStyle();      // 窗口属性、密码模式
    void initConnection(); // 信号槽连接

    bool loadUsers(const QString& filePath);     // 从 JSON 加载用户
    bool validateUser(const QString& username,
                      const QString& password) const;

    QLineEdit* m_pUsernameEdit;
    QLineEdit* m_pPasswordEdit;
    QPushButton* m_pLoginButton;
    QLabel* m_pStatusLabel;
    QJsonArray m_users;
};

LoginDialog::LoginDialog(QWidget* pParent)
    : QDialog(pParent)
    , m_pUsernameEdit(nullptr)
    , m_pPasswordEdit(nullptr)
{
    initData();      // 1. 创建控件、加载数据
    initLayout();    // 2. 摆放控件
    initStyle();     // 3. 设置外观
    initConnection(); // 4. 连接信号槽
}

int main(int argc, char* argv[])
{
    QApplication app(argc, argv);

    // 登录
    RyB::LoginDialog loginDialog;
    if (loginDialog.exec() != QDialog::Accepted)
    {
        return 0;  // 用户取消登录，退出程序
    }

    // 登录成功，显示主窗口
    MainWindow window;
    window.show();

    return app.exec();
}

// 所有通信模块都通过信号通知结果
connect(&tcpClient, &TcpClient::dataReceived, this, &Page::onDataReceived);
connect(&tcpClient, &TcpClient::disconnected, this, &Page::onDisconnected);

// UDP 心跳
RyB::UdpHeartbeat heartbeat;
heartbeat.setTarget("192.168.1.100", 8888);
heartbeat.setInterval(1000);  // 每秒一次
heartbeat.setHeartbeatData("PING");
heartbeat.start();

// Windows: MiniDump
// Linux: core dump + signal handler
DumpManager::instance().initialize(
    "crashdumps",  // dump 文件目录
    true           // 自动重启
);

try
{
    QString result = AsyncTaskExecutor::execute<QString>([]() -> QString {
        // 后台线程中的异常会被捕获并传播到主线程
        if (someError)
            throw std::runtime_error("处理失败");
        return "成功";
    });
}
catch (const std::exception& e)
{
    QMessageBox::critical(this, "错误", e.what());
}

// Qt 模块用 Q_OS_WIN / Q_OS_LINUX
#ifdef Q_OS_WIN
    #include <windows.h>
    // Windows 特定代码
#endif

// 纯 C++ 模块用 _WIN32
#ifdef _WIN32
    #define WIN32_LEAN_AND_MEAN
    #define NOMINMAX
    #include <windows.h>
#endif

/**
 * @file MainWindow.h
 * @brief 主窗口
 * @author RyB
 * @version 1.0.0
 *
 * 【模块概述】
 * ToolBox 主窗口，管理导航栏和页面栈。
 *
 * 【使用示例】
 * @code
 *   MainWindow window;
 *   window.addToolPage(new MapLoaderPage(&window));
 *   window.show();
 * @endcode
 */

// ============================================================================
// 【MainWindow - 主窗口】
// ============================================================================

// ---------------------------------------------------------------------------
// 初始化
// ---------------------------------------------------------------------------