fix(dconfig): cache configuration objects for the compositor lifetime

src/CMakeLists.txt

@@ -137,6 +137,8 @@ qt_add_qml_module(libtreeland
         core/imcandidatepanelmanager.h
         core/shellhandler.cpp
         core/shellhandler.h
+        core/systemdconfigmanager.cpp
+        core/systemdconfigmanager.h
         core/treeland.cpp
         core/treeland.h
         core/windowpicker.cpp

src/core/systemdconfigmanager.cpp

@@ -0,0 +1,159 @@
+// Copyright (C) 2026 UnionTech Software Technology Co., Ltd.
+// SPDX-License-Identifier: Apache-2.0 OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#include "systemdconfigmanager.h"
+
+#include "appconfig.hpp"
+#include "outputconfig.hpp"
+#include "seatuserconfig.hpp"
+#include "treelandconfig.hpp"
+#include "treelanduserconfig.hpp"
+
+#include <DConfig>
+
+namespace {
+
+QString configSubpath(const QString &name)
+{
+    return QStringLiteral("/") + name;
+}
+
+}
+
+SystemDConfigManager *SystemDConfigManager::s_instance = nullptr;
+
+SystemDConfigManager::SystemDConfigManager(QObject *parent)
+    : QObject(parent)
+{
+    Q_ASSERT(!s_instance);
+    s_instance = this;
+
+    m_globalConfig = TreelandConfig::create(QStringLiteral("org.deepin.dde.treeland"),
+                                             QString(),
+                                             this);
+    Q_ASSERT(m_globalConfig);
+
+    connect(m_globalConfig,
+            &TreelandConfig::configInitializeSucceed,
+            this,
+            [this](DTK_CORE_NAMESPACE::DConfig *) { Q_EMIT InitializeSucceed(); },
+            Qt::SingleShotConnection);
+    connect(m_globalConfig,
+            &TreelandConfig::configInitializeFailed,
+            this,
+            [this] { Q_EMIT InitializeFailed(); },
+            Qt::SingleShotConnection);
+}
+
+SystemDConfigManager::~SystemDConfigManager()
+{
+    if (s_instance == this) {
+        s_instance = nullptr;
+    }
+}
+
+SystemDConfigManager *SystemDConfigManager::instance()
+{
+    return s_instance;
+}
+
+bool SystemDConfigManager::isInitializeSucceeded() const
+{
+    return m_globalConfig && m_globalConfig->isInitializeSucceeded();
+}
+
+bool SystemDConfigManager::isInitializeFailed() const
+{
+    return !m_globalConfig || m_globalConfig->isInitializeFailed();
+}
+
+TreelandConfig *SystemDConfigManager::globalConfig() const
+{
+    return m_globalConfig;
+}
+
+TreelandUserConfig *SystemDConfigManager::userConfig(const QString &userName)
+{
+    if (userName.isEmpty()) {
+        return nullptr;
+    }
+
+    if (auto *config = m_userConfigs.value(userName)) {
+        return config;
+    }
+
+    auto *config = TreelandUserConfig::createByName(QStringLiteral("org.deepin.dde.treeland.user"),
+                                                    QStringLiteral("org.deepin.dde.treeland"),
+                                                    configSubpath(userName),
+                                                    this);
+    m_userConfigs.insert(userName, config);
+    return config;
+}
+
+SeatUserDConfig *SystemDConfigManager::seatUserConfig(const QString &userName)
+{
+    if (userName.isEmpty()) {
+        return nullptr;
+    }
+
+    if (auto *config = m_seatUserConfigs.value(userName)) {
+        return config;
+    }
+
+    auto *config = SeatUserDConfig::createByName(
+        QStringLiteral("org.deepin.dde.treeland.user.seat"),
+        QStringLiteral("org.deepin.dde.treeland"),
+        configSubpath(userName),
+        this);
+    m_seatUserConfigs.insert(userName, config);
+    return config;
+}
+
+OutputConfig *SystemDConfigManager::outputConfig(const QString &outputName)
+{
+    if (outputName.isEmpty()) {
+        return nullptr;
+    }
+
+    if (auto *config = m_outputConfigs.value(outputName)) {
+        return config;
+    }
+
+    auto *config = OutputConfig::createByName(QStringLiteral("org.deepin.dde.treeland.output"),
+                                              QStringLiteral("org.deepin.dde.treeland"),
+                                              configSubpath(outputName),
+                                              this);
+    m_outputConfigs.insert(outputName, config);
+    return config;
+}
+
+AppConfig *SystemDConfigManager::appConfig(const QString &appId)
+{
+    if (appId.isEmpty()) {
+        return nullptr;
+    }
+
+    if (auto *config = m_appConfigs.value(appId)) {
+        return config;
+    }
+
+    auto *config = AppConfig::create(QStringLiteral("org.deepin.dde.treeland"),
+                                     configSubpath(appId),
+                                     this);
+    m_appConfigs.insert(appId, config);
+    return config;
+}
+
+bool SystemDConfigManager::initializeUserConfigs(const QString &userName)
+{
+    m_initialUserConfig = userConfig(userName);
+    const auto *seatConfig = seatUserConfig(userName);
+    return m_initialUserConfig && seatConfig
+        && m_initialUserConfig->isInitializeSucceeded()
+        && seatConfig->isInitializeSucceeded();
+}
+
+TreelandUserConfig *SystemDConfigManager::initialUserConfig() const
+{
+    return m_initialUserConfig;
+}

src/core/systemdconfigmanager.h

@@ -0,0 +1,54 @@
+// Copyright (C) 2026 UnionTech Software Technology Co., Ltd.
+// SPDX-License-Identifier: Apache-2.0 OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
+
+#pragma once
+
+#include <QHash>
+#include <QObject>
+#include <QString>
+
+class AppConfig;
+class OutputConfig;
+class SeatUserDConfig;
+class TreelandConfig;
+class TreelandUserConfig;
+
+class SystemDConfigManager : public QObject
+{
+    Q_OBJECT
+
+public:
+    explicit SystemDConfigManager(QObject *parent = nullptr);
+    ~SystemDConfigManager() override;
+
+    static SystemDConfigManager *instance();
+
+    bool isInitializeSucceeded() const;
+    bool isInitializeFailed() const;
+
+    TreelandConfig *globalConfig() const;
+    TreelandUserConfig *userConfig(const QString &userName);
+    SeatUserDConfig *seatUserConfig(const QString &userName);
+    OutputConfig *outputConfig(const QString &outputName);
+    AppConfig *appConfig(const QString &appId);
+
+    // Creates and caches the initial user's configs. Returns true only when both
+    // configs have already finished successfully; callers should listen for
+    // their initialization signals when this returns false.
+    bool initializeUserConfigs(const QString &userName);
+    TreelandUserConfig *initialUserConfig() const;
+
+Q_SIGNALS:
+    void InitializeSucceed();
+    void InitializeFailed();
+
+private:
+    static SystemDConfigManager *s_instance;
+
+    TreelandConfig *m_globalConfig = nullptr;
+    QHash<QString, TreelandUserConfig *> m_userConfigs;
+    QHash<QString, SeatUserDConfig *> m_seatUserConfigs;
+    QHash<QString, OutputConfig *> m_outputConfigs;
+    QHash<QString, AppConfig *> m_appConfigs;
+    TreelandUserConfig *m_initialUserConfig = nullptr;
+};

src/core/treeland.cpp

@@ -4,11 +4,14 @@
 #include "treeland.h"
 
 #include "core/qmlengine.h"
+#include "core/systemdconfigmanager.h"
 #include "greeter/usermodel.h"
 #include "interfaces/multitaskviewinterface.h"
 #include "interfaces/plugininterface.h"
 #include "seat/helper.h"
+#include "seatuserconfig.hpp"
 #include "session/session.h"
+#include "treelanduserconfig.hpp"
 #include "utils/cmdline.h"
 #include "common/treelandlogging.h"
 #include "common/constants.h"
@@ -33,6 +36,7 @@
 #include <QMetaMethod>
 #include <QTranslator>
 
+#include <functional>
 #include <memory>
 #include <pwd.h>
 #include <sys/socket.h>
@@ -56,7 +60,7 @@ class TreelandPrivate : public QObject
     {
     }
 
-    void init()
+    void init(std::function<void()> onInitialized)
     {
         qmlEngine = new QmlEngine(this);
         qmlEngine->addImportPath(QString("%1/qt/qml").arg(QCoreApplication::applicationDirPath()));
@@ -70,23 +74,97 @@ class TreelandPrivate : public QObject
         // assert(wlroots: assert(wl_list_empty(&cur->events.button.listener_list)))
         // failed during quit(If the quit call is from the cursor's button press/release event)
         connect(qmlEngine, &QQmlEngine::quit, q, &Treeland::quit, Qt::QueuedConnection);
-        helper = qmlEngine->singletonInstance<Helper *>("Treeland", "Helper");
-        connect(helper, &Helper::requestQuit, q, &Treeland::quit, Qt::QueuedConnection);
-
-        qputenv("WLR_XWAYLAND", QByteArray(LIBEXEC_DIR) + "/treeland-xwayland");
-        helper->init(q);
 
 #ifndef DISABLE_DDM
         auto userModel = qmlEngine->singletonInstance<UserModel *>("Treeland", "UserModel");
+        const QString initialUserName = userModel ? userModel->currentUserName()
+                                                   : QStringLiteral("dde");
+#else
+        const QString initialUserName = QStringLiteral("dde");
+#endif
+        auto initializeTreeland = [this, q, onInitialized = std::move(onInitialized)
+#ifndef DISABLE_DDM
+                                   , userModel
+#endif
+        ] {
+            helper = qmlEngine->singletonInstance<Helper *>("Treeland", "Helper");
+            connect(helper, &Helper::requestQuit, q, &Treeland::quit, Qt::QueuedConnection);
 
-        auto updateUser = [this, userModel] {
-            auto user = userModel->currentUser();
-            onCurrentChanged(user ? user->UID() : getuid());
-        };
+            qputenv("WLR_XWAYLAND", QByteArray(LIBEXEC_DIR) + "/treeland-xwayland");
+            helper->init(q);
+
+#ifndef DISABLE_DDM
+            auto updateUser = [this, userModel] {
+                auto user = userModel->currentUser();
+                onCurrentChanged(user ? user->UID() : getuid());
+            };
 
-        connect(userModel, &UserModel::currentUserNameChanged, this, updateUser);
-        updateUser();
+            connect(userModel, &UserModel::currentUserNameChanged, this, updateUser);
+            updateUser();
 #endif
+            onInitialized();
+        };
+
+        auto *configManager = SystemDConfigManager::instance();
+        if (!configManager || configManager->initializeUserConfigs(initialUserName)) {
+            initializeTreeland();
+            return;
+        }
+
+        auto *userConfig = configManager->initialUserConfig();
+        auto *seatConfig = configManager->seatUserConfig(initialUserName);
+        auto initialized = std::make_shared<bool>(false);
+        auto initializeWhenReady = [initializeTreeland,
+                                    userConfig,
+                                    seatConfig,
+                                    initialized] {
+            if (*initialized) {
+                return;
+            }
+
+            const bool userSucceeded = userConfig && userConfig->isInitializeSucceeded();
+            const bool seatSucceeded = seatConfig && seatConfig->isInitializeSucceeded();
+            const bool userFinished = !userConfig || userSucceeded
+                || userConfig->isInitializeFailed();
+            const bool seatFinished = !seatConfig || seatSucceeded
+                || seatConfig->isInitializeFailed();
+            if (!userFinished || !seatFinished) {
+                return;
+            }
+
+            *initialized = true;
+            if (!userSucceeded || !seatSucceeded) {
+                qCWarning(lcTlCore)
+                    << "Initial user DConfig initialization failed; Treeland will continue with generated defaults.";
+            }
+            initializeTreeland();
+        };
+
+        if (userConfig) {
+            connect(userConfig,
+                    &TreelandUserConfig::configInitializeSucceed,
+                    this,
+                    initializeWhenReady,
+                    Qt::SingleShotConnection);
+            connect(userConfig,
+                    &TreelandUserConfig::configInitializeFailed,
+                    this,
+                    initializeWhenReady,
+                    Qt::SingleShotConnection);
+        }
+        if (seatConfig) {
+            connect(seatConfig,
+                    &SeatUserDConfig::configInitializeSucceed,
+                    this,
+                    initializeWhenReady,
+                    Qt::SingleShotConnection);
+            connect(seatConfig,
+                    &SeatUserDConfig::configInitializeFailed,
+                    this,
+                    initializeWhenReady,
+                    Qt::SingleShotConnection);
+        }
+        initializeWhenReady();
     }
 
     ~TreelandPrivate()
@@ -311,7 +389,12 @@ Treeland::Treeland()
 
     qmlRegisterModule("Treeland.Protocols", 1, 0);
 
-    d->init();
+    d->init([this] { initialize(); });
+}
+
+void Treeland::initialize()
+{
+    Q_D(Treeland);
 
     auto globalSession = d->helper->sessionManager()->globalSession();
     Q_ASSERT(globalSession);

src/core/treeland.h

@@ -50,6 +50,7 @@ public Q_SLOTS:
     void XWaylandName();
 
 private:
+    void initialize();
     void quit();
 
     std::unique_ptr<TreelandPrivate> d_ptr;