soft_bus/mainwindow.cpp

#include "mainwindow.h"
#include "database_manager/databasemodule.h"
#include "daemon/daemon_client.h"
#include "daemon/daemon_connection_dialog.h"
#include "daemon/daemon_message_flow_widget.h"
#include "api/SoftBusAPI.h"
#include "settings/settings_dialog.h"
#include "toolbar/toolbar.h"
#include "view_serial/serialmodule.h"
#include "view_serial/serialdockpage.h"
#include "view_network/networkmodule.h"
#include "view_network/networkdockpage.h"
#include "view_task/TaskManagementPage.h"
#include "connect_signal/view_instance_manager.h"
#include "view_device_config/device_tree_widget.h"
#include "utils/logging.h"
#include <QAction>
#include <QApplication>
#include <QCloseEvent>
#include <QDockWidget>
#include <QHBoxLayout>
#include <QJsonDocument>
#include <QJsonObject>
#include <QLabel>
#include <QMenu>
#include <QMenuBar>
#include <QMessageBox>
#include <QSettings>
#include <QShortcut>
#include <QStackedWidget>
#include <QStatusBar>
#include <QToolBar>
#include <QVBoxLayout>

MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent) { createUI(); }

void MainWindow::createUI() {
    // 创建菜单栏
    createMenuBar();

    // 创建主布局
    QWidget *centralWidget = new QWidget(this);
    QVBoxLayout *mainLayout = new QVBoxLayout(centralWidget);
    // 界面设置
    setWindowTitle("软件总线");
    setWindowIcon(QIcon(":/qrc/icons/ads_icon.svg"));
    setUnifiedTitleAndToolBarOnMac(true);
    setDockNestingEnabled(true);
    setAnimated(true);
    setTabPosition(Qt::AllDockWidgetAreas, QTabWidget::North);
    setDockOptions(QMainWindow::AllowTabbedDocks | QMainWindow::AnimatedDocks |
                   QMainWindow::VerticalTabs);
    setStatusBar(new QStatusBar(this));
    setCorner(Qt::TopLeftCorner, Qt::LeftDockWidgetArea);
    setCorner(Qt::TopRightCorner, Qt::RightDockWidgetArea);
    setCorner(Qt::BottomLeftCorner, Qt::LeftDockWidgetArea);
    setCorner(Qt::BottomRightCorner, Qt::RightDockWidgetArea);
    setMinimumSize(800, 600);
    setMaximumSize(1600, 1200);

    // 创建页面堆栈
    m_pageStack = new QStackedWidget(this);
    mainLayout->addWidget(m_pageStack);
    centralWidget->setLayout(mainLayout);
    setCentralWidget(centralWidget);

    // 先设置守护进程状态（必须在创建模块之前，因为模块可能会初始化 API）
    setupDaemonStatus();

    // 创建工具栏和页面（在守护进程设置之后）
    createHomeToolbar();
    createSerialToolbar();
    createNetworkToolbar();
    createDatabaseToolbar();
    createTaskToolbar();
    createSettingsToolbar();
    createHelpToolbar();

    // 默认显示主界面
    switchToPage(1);
    // 设置快捷键
    setupShortcuts();
    // 链接信号槽
    connectSignals();
    // 创建状态栏
    this->statusBar()->showMessage("就绪");
}

void MainWindow::createMenuBar() {
    // 创建菜单栏
    QMenuBar *menuBar = new QMenuBar(this);
    setMenuBar(menuBar);
    // 视图菜单
    QMenu *viewMenu = menuBar->addMenu("视图");
    QAction *homeAction =
        viewMenu->addAction(QIcon(":/qrc/icons/home.png"), "主界面");
    QAction *serialAction =
        viewMenu->addAction(QIcon(":/qrc/icons/serial.png"), "串口");
    QAction *networkAction =
        viewMenu->addAction(QIcon(":/qrc/icons/network.png"), "网络");
    QAction *databaseAction =
        viewMenu->addAction(QIcon(":/qrc/icons/grid_on.svg"), "数据库");
    QAction *taskAction =
        viewMenu->addAction(QIcon(":/qrc/icons/task.png"), "任务管理");
    QAction *settingsAction =
        viewMenu->addAction(QIcon(":/qrc/icons/settings.png"), "设置");
    QAction *helpAction =
        viewMenu->addAction(QIcon(":/qrc/icons/help.png"), "帮助");
    // 连接视图菜单的切换功能
    connect(homeAction, &QAction::triggered, this, [this]() { switchToPage(0); });
    connect(serialAction, &QAction::triggered, this,
            [this]() { switchToPage(1); });
    connect(networkAction, &QAction::triggered, this,
            [this]() { switchToPage(2); });
    connect(databaseAction, &QAction::triggered, this,
            [this]() { switchToPage(3); });
    connect(taskAction, &QAction::triggered, this,
            [this]() { 
                if (m_taskPageIndex >= 0) {
                    switchToPage(m_taskPageIndex);
                }
            });
    connect(settingsAction, &QAction::triggered, this,
            [this]() { switchToPage(5); });
    connect(helpAction, &QAction::triggered, this, [this]() { switchToPage(6); });



    // 文件菜单
    QMenu *fileMenu = menuBar->addMenu("文件");
    QAction *newAction =
        fileMenu->addAction(QIcon(":/qrc/icons/new.png"), "新建");
    QAction *openAction =
        fileMenu->addAction(QIcon(":/qrc/icons/open.png"), "打开");
    QAction *saveAction =
        fileMenu->addAction(QIcon(":/qrc/icons/save.png"), "保存");
    fileMenu->addSeparator();
    QAction *exitAction =
        fileMenu->addAction(QIcon(":/qrc/icons/exit.png"), "退出");

    // 编辑菜单
    QMenu *editMenu = menuBar->addMenu("编辑");
    QAction *undoAction =
        editMenu->addAction(QIcon(":/qrc/icons/undo.png"), "撤销");
    QAction *redoAction =
        editMenu->addAction(QIcon(":/qrc/icons/redo.png"), "重做");
    editMenu->addSeparator();
    QAction *cutAction =
        editMenu->addAction(QIcon(":/qrc/icons/cut.png"), "剪切");
    QAction *copyAction =
        editMenu->addAction(QIcon(":/qrc/icons/copy.png"), "复制");
    QAction *pasteAction =
        editMenu->addAction(QIcon(":/qrc/icons/paste.png"), "粘贴");

    // 帮助菜单
    QMenu *helpMenu = menuBar->addMenu("帮助");
    QAction *helpDocAction =
        helpMenu->addAction(QIcon(":/qrc/icons/help.png"), "帮助文档");
    QAction *aboutAction =
        helpMenu->addAction(QIcon(":/qrc/icons/about.png"), "关于");
    QAction *updateAction =
        helpMenu->addAction(QIcon(":/qrc/icons/update.png"), "检查更新");

    connect(aboutAction, &QAction::triggered, this, &MainWindow::showAbout);
    
    // 连接退出菜单项，真正退出应用
    connect(exitAction, &QAction::triggered, qApp, &QApplication::quit);
}

void MainWindow::createHomeToolbar() {
    // 创建主界面工具栏
    Toolbar *homeToolbar = new Toolbar("主工具栏", this);
    addToolBar(Qt::TopToolBarArea, homeToolbar);
    homeToolbar->hide();

    // 添加按钮
    homeToolbar->addAction(QIcon(":/qrc/icons/new.png"), "新建");
    homeToolbar->addAction(QIcon(":/qrc/icons/open.png"), "打开");
    homeToolbar->addAction(QIcon(":/qrc/icons/save.png"), "保存");
    homeToolbar->addAction(QIcon(":/qrc/icons/print.png"), "打印");

    // 创建主界面页面
    QLabel *homePage = new QLabel("<center><h1>主界面</h1></center>", this);
    homePage->setAlignment(Qt::AlignCenter);

    // 添加到堆栈
    m_toolbars.append(homeToolbar);
    m_pageStack->addWidget(homePage);
}
void MainWindow::createSerialToolbar() {
    if (!m_serialModule) {
        m_serialModule = new SerialModule(this, this);
    }

    if (Toolbar *serialToolbar = m_serialModule->toolbar()) {
        addToolBar(Qt::TopToolBarArea, serialToolbar);
        serialToolbar->hide();
        m_toolbars.append(serialToolbar);
    }

    if (QWidget *serialPage = m_serialModule->pageWidget()) {
        m_serialPageIndex = m_pageStack->addWidget(serialPage);
    }
}

void MainWindow::createNetworkToolbar() {
    if (!m_networkModule) {
        m_networkModule = new NetworkModule(this, this);
    }

    if (Toolbar *networkToolbar = m_networkModule->toolbar()) {
        addToolBar(Qt::TopToolBarArea, networkToolbar);
        networkToolbar->hide();
        m_toolbars.append(networkToolbar);
    }

    if (QWidget *networkPage = m_networkModule->pageWidget()) {
        m_networkPageIndex = m_pageStack->addWidget(networkPage);
    }
}

void MainWindow::createDatabaseToolbar() {
    if (!m_databaseModule) {
        m_databaseModule = new DatabaseModule(this, this);
    }

    if (Toolbar *databaseToolbar = m_databaseModule->toolbar()) {
        addToolBar(Qt::TopToolBarArea, databaseToolbar);
        databaseToolbar->hide();
        m_toolbars.append(databaseToolbar);
    }

    if (QWidget *databasePage = m_databaseModule->pageWidget()) {
        m_databasePageIndex = m_pageStack->addWidget(databasePage);
    }
}

void MainWindow::createTaskToolbar() {
    // 创建任务管理页面
    if (!m_taskPage) {
        m_taskPage = new TaskManagementPage(this);
    }

    // 创建空工具栏以保持索引一致性（任务页面的工具栏已内置在页面中）
    Toolbar *taskToolbar = new Toolbar("任务管理工具栏", this);
    addToolBar(Qt::TopToolBarArea, taskToolbar);
    taskToolbar->hide();
    m_toolbars.append(taskToolbar);

    // 添加任务页面到堆栈
    m_taskPageIndex = m_pageStack->addWidget(m_taskPage);
}

void MainWindow::createSettingsToolbar() {
    // 创建设置界面工具栏
    Toolbar *settingsToolbar = new Toolbar("设置工具栏", this);
    addToolBar(Qt::TopToolBarArea, settingsToolbar);
    settingsToolbar->hide();

    // 添加按钮
    QAction *preferencesAction = settingsToolbar->addAction(QIcon(":/qrc/icons/preferences.png"), "首选项");
    connect(preferencesAction, &QAction::triggered, this, &MainWindow::showSettingsDialog);
    
    settingsToolbar->addAction(QIcon(":/qrc/icons/theme.png"), "主题");
    settingsToolbar->addAction(QIcon(":/qrc/icons/keyboard.png"), "快捷键");
    settingsToolbar->addAction(QIcon(":/qrc/icons/plugins.png"), "插件");

    // 创建设置界面页面
    QLabel *settingsPage = new QLabel("<center><h1>设置界面</h1><p>点击工具栏中的\"首选项\"按钮打开设置对话框</p></center>", this);
    settingsPage->setAlignment(Qt::AlignCenter);

    // 添加到堆栈
    m_toolbars.append(settingsToolbar);
    m_pageStack->addWidget(settingsPage);
}

void MainWindow::createHelpToolbar() {
    // 创建帮助界面工具栏
    Toolbar *helpToolbar = new Toolbar("帮助工具栏", this);
    addToolBar(Qt::TopToolBarArea, helpToolbar);
    helpToolbar->hide();

    // 添加按钮
    helpToolbar->addAction(QIcon(":/qrc/icons/help.png"), "帮助文档");
    helpToolbar->addAction(QIcon(":/qrc/icons/about.png"), "关于");
    helpToolbar->addAction(QIcon(":/qrc/icons/update.png"), "检查更新");

    // 创建帮助界面页面
    QLabel *helpPage = new QLabel("<center><h1>帮助界面</h1></center>", this);
    helpPage->setAlignment(Qt::AlignCenter);

    // 添加到堆栈
    m_toolbars.append(helpToolbar);
    m_pageStack->addWidget(helpPage);
}

/*
function:  返回指定索引的页面
@author:   flower
@date:     2025-10-23
    @param index 页面索引
    @return 无
*/
void MainWindow::switchToPage(int index) {
    // 隐藏所有工具栏
    for (Toolbar *toolbar : m_toolbars) {
        toolbar->hide();
    }

    // 显示当前工具栏
    if (index >= 0 && index < m_toolbars.size()) {
        m_toolbars[index]->show();
        m_pageStack->setCurrentIndex(index);
    }
}

/*
function:  设置快捷键
@author:   flower
@date:     2025-10-23
    @param
    @return 无
*/
void MainWindow::setupShortcuts() {
    // 创建快捷键
    QShortcut *homeShortcut = new QShortcut(QKeySequence("Ctrl+1"), this);
    QShortcut *serialShortcut = new QShortcut(QKeySequence("Ctrl+2"), this);
    QShortcut *networkShortcut = new QShortcut(QKeySequence("Ctrl+3"), this);
    QShortcut *databaseShortcut = new QShortcut(QKeySequence("Ctrl+4"), this);
    QShortcut *taskShortcut = new QShortcut(QKeySequence("Ctrl+5"), this);
    QShortcut *settingsShortcut = new QShortcut(QKeySequence("Ctrl+6"), this);
    QShortcut *helpShortcut = new QShortcut(QKeySequence("Ctrl+7"), this);

    // 连接快捷键信号
    connect(homeShortcut, &QShortcut::activated, this,
            [this]() { switchToPage(0); });
    connect(serialShortcut, &QShortcut::activated, this,
            [this]() { switchToPage(1); });
    connect(networkShortcut, &QShortcut::activated, this,
            [this]() { switchToPage(2); });
    connect(databaseShortcut, &QShortcut::activated, this,
            [this]() { switchToPage(3); });
    connect(taskShortcut, &QShortcut::activated, this,
            [this]() { 
                if (m_taskPageIndex >= 0) {
                    switchToPage(m_taskPageIndex);
                }
            });
    connect(settingsShortcut, &QShortcut::activated, this,
            [this]() { switchToPage(5); });
    connect(helpShortcut, &QShortcut::activated, this,
            [this]() { switchToPage(6); });
}
/*
function:  链接信号槽
@author:   flower
@date:     2021-10-23
    @param
    @return 无
*/
void MainWindow::connectSignals() {
    // 连接设备树选择信号到自动跳转槽函数
    // 现在有两个独立的设备树实例（串口页面和网络页面），都需要连接
    ViewInstanceManager* viewMgr = ViewInstanceManager::instance();
    if (viewMgr) {
        // 连接串口页面的设备树
        DeviceTreeWidget* serialDeviceTree = viewMgr->getSerialDeviceTreeWidget();
        if (serialDeviceTree) {
            connect(serialDeviceTree, &DeviceTreeWidget::deviceSelected,
                    this, &MainWindow::onDeviceSelectedForAutoSwitch);
            LOG_INFO() << "MainWindow: 串口页面设备树自动跳转信号已连接";
        }
        
        // 连接网络页面的设备树
        DeviceTreeWidget* networkDeviceTree = viewMgr->getNetworkDeviceTreeWidget();
        if (networkDeviceTree) {
            connect(networkDeviceTree, &DeviceTreeWidget::deviceSelected,
                    this, &MainWindow::onDeviceSelectedForAutoSwitch);
            LOG_INFO() << "MainWindow: 网络页面设备树自动跳转信号已连接";
        }
    }
}

void MainWindow::onDeviceSelectedForAutoSwitch(const QString &deviceType, const QString &deviceId) {
    // 根据设备类型自动跳转到相应页面
    if (deviceType == QStringLiteral("network")) {
        // 如果是网络设备，跳转到网络页面
        if (m_networkPageIndex >= 0) {
            switchToPage(m_networkPageIndex);
            LOG_INFO() << "MainWindow: 自动跳转到网络页面 - 设备=" << deviceId;
        }
    } else if (deviceType == QStringLiteral("serial")) {
        // 如果是串口设备，跳转到串口页面
        if (m_serialPageIndex >= 0) {
            switchToPage(m_serialPageIndex);
            LOG_INFO() << "MainWindow: 自动跳转到串口页面 - 设备=" << deviceId;
        }
    }
    // 其他设备类型（如CAN）可以在这里添加
}

void MainWindow::showAbout() {
    QMessageBox::about(this, "关于",
                       "<h2>基于DoDAF的多源数据融合系统总线</h2>"
                       "<p> </p>"
                       "<p>版本: 1.0.0</p>"
                       "<p>© flower </p>");
}

void MainWindow::setupDaemonStatus()
{
    // 创建守护进程客户端
    m_daemonClient = new DaemonClient(this);
    
    // 连接信号
    connect(m_daemonClient, &DaemonClient::daemonStatusChanged,
            this, &MainWindow::onDaemonStatusChanged);
    connect(m_daemonClient, &DaemonClient::loadInfoUpdated,
            this, &MainWindow::onLoadInfoUpdated);
    
    // 强制使用守护进程模式，先尝试连接守护进程（如果已存在则直接连接）
    LOG_INFO() << "强制使用守护进程模式，正在尝试连接守护进程服务...";
    bool connected = m_daemonClient->connectToDaemon();
    
    // 如果连接失败，再尝试启动守护进程
    if (!connected) {
        LOG_INFO() << "守护进程未运行，正在启动守护进程...";
        // 尝试启动守护进程（可能已经存在）
        m_daemonClient->startDaemon();
        // 无论启动是否成功，都尝试连接（守护进程可能已经通过其他方式启动）
        LOG_INFO() << "正在尝试连接守护进程...";
        connected = m_daemonClient->connectToDaemon();
        if (connected) {
            LOG_INFO() << "守护进程启动并连接成功";
        } else {
            LOG_WARNING() << "守护进程启动或连接失败";
        }
    } else {
        LOG_INFO() << "守护进程已存在，连接成功";
    }
    
    if (!connected) {
        LOG_WARNING() << "守护进程连接失败，弹出对话框询问用户";
        // 连接失败，弹出对话框询问是否重试
        DaemonConnectionDialog dialog(this);
        dialog.setErrorMessage(tr("守护进程服务未运行或无法访问。"));
        
        int result = dialog.exec();
        
        if (result == QDialog::Accepted) {
            if (dialog.switchToLocalMode()) {
                // 用户选择切换到本地模式（已废弃，但保留兼容性）
                QMessageBox::warning(this, 
                    tr("本地模式已移除"), 
                    tr("本地模式已移除，所有硬件操作必须通过守护进程进行。\n"
                       "请确保守护进程服务正常运行。"));
                // 尝试启动守护进程（可能已经存在）
                m_daemonClient->startDaemon();
                // 无论启动是否成功，都尝试连接（守护进程可能已经通过其他方式启动）
                connected = m_daemonClient->connectToDaemon();
            } else {
                // 用户选择重试，再次尝试启动和连接
                LOG_INFO() << "用户选择重试，正在重新启动守护进程...";
                // 尝试启动守护进程（可能已经存在）
                m_daemonClient->startDaemon();
                // 无论启动是否成功，都尝试连接（守护进程可能已经通过其他方式启动）
                connected = m_daemonClient->connectToDaemon();
                if (!connected) {
                    // 重试仍然失败
                    QMessageBox::critical(this, 
                        tr("连接失败"), 
                        tr("重试启动和连接守护进程仍然失败。\n"
                           "请检查守护进程服务是否正常运行。"));
                    LOG_CRITICAL() << "重试仍然失败，无法连接守护进程";
                } else {
                    // 重试成功
                    LOG_INFO() << "重试启动和连接守护进程成功";
                }
            }
        } else {
            // 用户取消
            QMessageBox::warning(this, 
                tr("警告"), 
                tr("未连接到守护进程，硬件操作将无法使用。"));
            LOG_WARNING() << "用户取消对话框，守护进程未连接";
        }
    } else {
        // 连接成功
        LOG_INFO() << "守护进程启动并连接成功";
    }
    
    // 初始化 API（现在强制使用守护进程模式）
    SoftBusAPI* api = SoftBusAPI::instance();
    if (!api) {
        LOG_CRITICAL() << "无法获取 SoftBusAPI 实例";
        return;
    }
    
    LOG_INFO() << "设置API模式: 守护进程模式（强制）";
    api->setUseDaemonMode(true);  // 强制使用守护进程模式
    
    // 初始化 API（会根据模式创建相应的 Manager）
    LOG_INFO() << "正在初始化 SoftBusAPI...";
    if (!api->initialize()) {
        LOG_WARNING() << "Failed to initialize SoftBusAPI";
        return;
    }
    LOG_INFO() << "SoftBusAPI 初始化成功";
    
    // 设置 DaemonClient 到 SoftBusAPI，让硬件操作通过守护进程
    LOG_INFO() << "设置 DaemonClient 到 SoftBusAPI";
    api->setDaemonClient(m_daemonClient);
    // 守护进程连接成功后，启动设备扫描（由守护进程负责扫描）
    // 注意：在守护进程模式下，设备扫描由守护进程负责，这里只是通知可以开始查询设备列表
    LOG_INFO() << "启动设备扫描（守护进程模式）";
    api->startDeviceDiscovery(5000);
    
    // 在状态栏添加状态标签
    QStatusBar* statusBar = this->statusBar();
    if (statusBar) {
        m_statusLabel = new QLabel("核心服务: 未连接", this);
        m_loadLabel = new QLabel("负载: --", this);
        
        statusBar->addPermanentWidget(m_statusLabel);
        statusBar->addPermanentWidget(m_loadLabel);
        
        // 初始更新
        updateDaemonStatus(false, QString());
    }
    
    // 创建信息流列表停靠窗口（在守护进程客户端创建之后）
    createMessageFlowDock();
    
    // 设置守护进程客户端到信息流组件
    if (m_daemonClient && m_messageFlowWidget) {
        m_messageFlowWidget->setDaemonClient(m_daemonClient);
    }
}

void MainWindow::onDaemonStatusChanged(bool running, const QString& statusJson)
{
    updateDaemonStatus(running, statusJson);
    
    // 信息流组件会自动处理状态更新（通过信号连接）
}

void MainWindow::onLoadInfoUpdated(const QString& loadInfoJson)
{
    updateLoadInfo(loadInfoJson);
    
    // 信息流组件会自动处理负载信息更新（通过信号连接）
}

void MainWindow::updateDaemonStatus(bool running, const QString& statusJson)
{
    if (!m_statusLabel) return;
    
    QString statusText;
    QString style;
    
    if (running) {
        statusText = "核心服务: 运行中";
        style = "color: green; font-weight: bold;";
        
        // 获取进程ID
        if (m_daemonClient) {
            qint64 pid = m_daemonClient->getPid();
            if (pid > 0) {
                statusText += QString(" (PID: %1)").arg(pid);
            }
        }
        
        // 解析状态 JSON 获取详细信息
        if (!statusJson.isEmpty()) {
            QJsonDocument doc = QJsonDocument::fromJson(statusJson.toUtf8());
            if (doc.isObject()) {
                QJsonObject obj = doc.object();
                int deviceCount = obj["deviceCount"].toInt(0);
                int onlineCount = obj["onlineDeviceCount"].toInt(0);
                statusText += QString(" | 设备: %1/%2").arg(onlineCount).arg(deviceCount);
            }
        }
    } else {
        statusText = "核心服务: 未运行";
        style = "color: red; font-weight: bold;";
    }
    
    m_statusLabel->setText(statusText);
    m_statusLabel->setStyleSheet(style);
}

void MainWindow::updateLoadInfo(const QString& loadInfoJson)
{
    if (!m_loadLabel) return;
    
    if (loadInfoJson.isEmpty()) {
        m_loadLabel->setText("负载: --");
        return;
    }
    
    QJsonDocument doc = QJsonDocument::fromJson(loadInfoJson.toUtf8());
    if (!doc.isObject()) {
        m_loadLabel->setText("负载: --");
        return;
    }
    
    QJsonObject obj = doc.object();
    double messageRate = obj["messageRate"].toDouble(0.0);
    qint64 totalMessages = obj["totalMessages"].toVariant().toLongLong();
    
    QString loadText = QString("消息速率: %1 msg/s | 总计: %2")
                       .arg(messageRate, 0, 'f', 1)
                       .arg(totalMessages);
    
    m_loadLabel->setText(loadText);
}

void MainWindow::createMessageFlowDock()
{
    // 创建信息流列表组件
    m_messageFlowWidget = new DaemonMessageFlowWidget(this);
    
    // 创建停靠窗口
    QDockWidget* dockWidget = new QDockWidget("守护进程信息流", this);
    dockWidget->setWidget(m_messageFlowWidget);
    dockWidget->setAllowedAreas(Qt::BottomDockWidgetArea | Qt::TopDockWidgetArea);
    dockWidget->setFeatures(QDockWidget::DockWidgetMovable | QDockWidget::DockWidgetFloatable);
    
    // 添加到主窗口
    addDockWidget(Qt::BottomDockWidgetArea, dockWidget);
    
    // 设置守护进程客户端
    if (m_daemonClient) {
        m_messageFlowWidget->setDaemonClient(m_daemonClient);
    }
    
    // 默认隐藏，可以通过视图菜单显示
    dockWidget->hide();
    
    // 添加到视图菜单
    QMenuBar* menuBar = this->menuBar();
    if (menuBar) {
        QMenu* viewMenu = nullptr;
        QList<QAction*> actions = menuBar->actions();
        for (QAction* action : actions) {
            if (action->text() == "视图") {
                viewMenu = qobject_cast<QMenu*>(action->menu());
                break;
            }
        }
        
        if (viewMenu) {
            QAction* flowAction = viewMenu->addAction("守护进程信息流");
            flowAction->setCheckable(true);
            flowAction->setChecked(false);
            connect(flowAction, &QAction::toggled, dockWidget, &QDockWidget::setVisible);
        }
    }
}

void MainWindow::loadSettings() {
    // 现在强制使用守护进程模式，不再从设置中读取
    // 保留此方法以保持接口兼容性
    SoftBusAPI* api = SoftBusAPI::instance();
    if (api) {
        api->setUseDaemonMode(true);  // 强制使用守护进程模式
        LOG_DEBUG() << "加载设置 - 守护进程模式: 启用（强制）";
    }
}

void MainWindow::showSettingsDialog() {
    if (!m_settingsDialog) {
        m_settingsDialog = new SettingsDialog(this);
        // 设置守护进程客户端，让设置对话框能检查守护进程状态
        m_settingsDialog->setDaemonClient(m_daemonClient);
    }
    
    // 加载当前设置
    m_settingsDialog->loadSettings();
    
    // 显示对话框
    if (m_settingsDialog->exec() == QDialog::Accepted) {
        // 用户点击了"确定"，应用设置
        // 注意：现在强制使用守护进程模式，设置对话框中的模式选项已无效
        SoftBusAPI* api = SoftBusAPI::instance();
        if (api) {
            api->setUseDaemonMode(true);  // 强制使用守护进程模式
            LOG_DEBUG() << "设置已更新 - 守护进程模式: 启用（强制）";
        }
    }
}

void MainWindow::closeEvent(QCloseEvent *event) {
    // 关闭窗口时清理 soft_bus 相关资源并退出应用程序
    LOG_INFO() << "主界面关闭，正在清理 soft_bus 相关资源并退出应用程序...";
    
    SoftBusAPI* api = SoftBusAPI::instance();
    if (api && api->isInitialized()) {
        // 关闭所有设备（串口、CAN设备等）并清理资源
        // shutdown() 会调用 cleanupManagers() 来关闭所有设备
        api->shutdown();
        LOG_INFO() << "soft_bus 资源清理完成";
    }
    
    // 断开 daemon 连接（删除对象会触发析构函数，自动注销客户端）
    if (m_daemonClient) {
        delete m_daemonClient;
        m_daemonClient = nullptr;
        LOG_INFO() << "已断开 daemon 连接";
    }
    
    // 接受关闭事件，退出应用程序
    // 应用程序退出时，main.cpp 中的 CoreService::shutdown() 会被调用
    event->accept();
    
    // 退出应用程序（这会触发 main.cpp 中的 CoreService::shutdown()）
    QApplication::quit();
}