refactor: modernize codebase with Qt 6.8 APIs and coding conventions

- Use Qt 6.8 string literals (u""_s) and QStringView for zero-copy operations
- Change constants to constexpr static auto& references
- Introduce fromStaticRaw() helper for static string handling
- Replace QScopedPointer with std::unique_ptr
- Add Q_LOGGING_CATEGORY for structured logging
- Use qTokenize for efficient string splitting
- Format code to match project conventions

Signed-off-by: ComixHe <heyuming@deepin.org>

Author: ComixHe

apps/app-identifier/src/main.cpp

@@ -48,8 +48,11 @@ int main(int argc, char *argv[])
             return;
         }
 
-        auto msg = QDBusMessage::createMethodCall(
-            DDEApplicationManager1ServiceName, DDEApplicationManager1ObjectPath, ApplicationManager1Interface, "Identify");
+        using namespace Qt::StringLiterals;
+        auto msg = QDBusMessage::createMethodCall(fromStaticRaw(DDEApplicationManager1ServiceName),
+                                                  fromStaticRaw(DDEApplicationManager1ObjectPath),
+                                                  fromStaticRaw(ApplicationManager1Interface),
+                                                  u"Identify"_s);
         msg.setArguments({QVariant::fromValue(QDBusUnixFileDescriptor{pidfd})});
         // see QDBusUnixFileDescriptor: The original file descriptor is not touched and must be closed by the user.
         close(pidfd);

apps/dde-am/src/commandexecutor.cpp

@@ -78,10 +78,13 @@ void CommandExecutor::setEnvironmentVariables(const QStringList &envVars)
 
 DExpected<void> CommandExecutor::execute()
 {
+    using namespace Qt::StringLiterals;
     registerComplexDbusType();
     auto con = QDBusConnection::sessionBus();
-    auto msg = QDBusMessage::createMethodCall(
-        DDEApplicationManager1ServiceName, DDEApplicationManager1ObjectPath, ApplicationManager1Interface, "executeCommand");
+    auto msg = QDBusMessage::createMethodCall(fromStaticRaw(DDEApplicationManager1ServiceName),
+                                              fromStaticRaw(DDEApplicationManager1ObjectPath),
+                                              fromStaticRaw(ApplicationManager1Interface),
+                                              u"executeCommand"_s);
 
     QStringMap envMap;
     for (const auto &env : std::as_const(m_environmentVariables)) {

apps/dde-am/src/launcher.cpp

@@ -40,8 +40,11 @@ ObjectMap getManagedObjects()
 {
     registerComplexDbusType();
 
-    auto msg = QDBusMessage::createMethodCall(
-        DDEApplicationManager1ServiceName, DDEApplicationManager1ObjectPath, ObjectManagerInterface, "GetManagedObjects");
+    using namespace Qt::StringLiterals;
+    auto msg = QDBusMessage::createMethodCall(fromStaticRaw(DDEApplicationManager1ServiceName),
+                                              fromStaticRaw(DDEApplicationManager1ObjectPath),
+                                              fromStaticRaw(ObjectManagerInterface),
+                                              u"GetManagedObjects"_s);
 
     auto reply = QDBusConnection::sessionBus().call(msg);
 
@@ -114,18 +117,20 @@ DExpected<void> Launcher::run()
 
 DExpected<void> Launcher::launch() noexcept
 {
+    using namespace Qt::StringLiterals;
     // Build options map
     QVariantMap options;
     if (!m_environmentVariables.isEmpty()) {
-        options.insert("env", m_environmentVariables);
+        options.insert(u"env"_s, m_environmentVariables);
     }
 
     // Mark autostart launches so AM can suppress splash
     if (m_autostart) {
-        options.insert("_autostart", true);
+        options.insert(u"_autostart"_s, true);
     }
 
-    auto msg = QDBusMessage::createMethodCall(DDEApplicationManager1ServiceName, m_path, ApplicationInterface, "Launch");
+    auto msg = QDBusMessage::createMethodCall(
+        fromStaticRaw(DDEApplicationManager1ServiceName), m_path, fromStaticRaw(ApplicationInterface), u"Launch"_s);
     msg.setArguments({m_action, QStringList{}, options});
     auto reply = QDBusConnection::sessionBus().call(msg);
 
@@ -140,10 +145,8 @@ DExpected<void> Launcher::launch() noexcept
 
 DExpected<void> Launcher::updateLaunchedTimes() noexcept
 {
-    std::unique_ptr<DConfig> config(DConfig::create(
-        // use QString::fromRawData(const char16_t*, size) if Qt version >= 6.10
-        QString::fromRawData(reinterpret_cast<const QChar *>(ApplicationServiceID), std::size(ApplicationServiceID) - 1),
-        ApplicationManagerToolsConfig));
+    std::unique_ptr<DConfig> config(
+        DConfig::create(fromStaticRaw(ApplicationServiceID), fromStaticRaw(ApplicationManagerToolsConfig)));
     if (!config->isValid()) {
         return DUnexpected{emplace_tag::USE_EMPLACE, -1, "DConfig is invalid when updating launched times."};
     }
@@ -173,9 +176,11 @@ QString Launcher::appId() const noexcept
         return {};
     }
 
-    const auto startIndex = QString(DDEApplicationManager1ObjectPath).size();
-    auto endIndex = m_path.indexOf("/", startIndex + 1);
-    const auto id = endIndex <= -1 ? m_path.mid(startIndex + 1) : m_path.sliced(startIndex + 1, endIndex - (startIndex + 1));
+    const QStringView pathView{m_path};
+    const qsizetype startIndex = std::size(DDEApplicationManager1ObjectPath) - 1;
+    const auto endIndex = pathView.indexOf(u'/', startIndex + 1);
+    const auto id =
+        endIndex <= -1 ? pathView.sliced(startIndex + 1) : pathView.sliced(startIndex + 1, endIndex - (startIndex + 1));
     return unescapeFromObjectPath(id);
 }
 

apps/dde-am/src/main.cpp

@@ -144,10 +144,10 @@ int handleLaunchApp(const QCommandLineParser &parser,
     QString appPath;
     if (!appId.isEmpty()) {
         // 解析出 appId，说明输入是 appId 或 desktop 文件
-        appPath = QString("%1/%2").arg(DDEApplicationManager1ObjectPath, escapeToObjectPath(appId));
-    } else if (!inputArg.isEmpty() && !inputArg.startsWith("/")) {
+        appPath = fromStaticRaw(DDEApplicationManager1ObjectPath) % u'/' % escapeToObjectPath(appId);
+    } else if (!inputArg.isEmpty() && !inputArg.startsWith(u'/')) {
         // 既不是绝对路径，也不是 desktop 文件等，视为 appId
-        appPath = QString("%1/%2").arg(DDEApplicationManager1ObjectPath, escapeToObjectPath(inputArg));
+        appPath = fromStaticRaw(DDEApplicationManager1ObjectPath) % escapeToObjectPath(inputArg);
     } else {
         // 绝对路径或特殊用法
         qWarning() << "unknown input: " << inputArg << ", just use it as path.";

apps/dde-application-manager/src/main.cpp

@@ -34,23 +34,23 @@ void registerComplexDbusType()
 
 int main(int argc, char *argv[])
 {
-    setenv("DSG_APP_ID", ApplicationManagerConfig, 0);
+    using namespace Qt::StringLiterals;
+    setenv("DSG_APP_ID", fromStaticRaw(ApplicationManagerConfig).toUtf8().constData(), 0);
 #ifdef PROFILING_MODE
     auto start = std::chrono::high_resolution_clock::now();
 #endif
-    QGuiApplication app{argc, argv};
+    const QGuiApplication app{argc, argv};
 
     auto &bus = ApplicationManager1DBus::instance();
     bus.initGlobalServerBus(DBusType::Session);
     bus.setDestBus();
-    auto &AMBus = bus.globalServerBus();
 
     registerComplexDbusType();
-    auto storageDir = getXDGDataHome() + QDir::separator() + "deepin" + QDir::separator() + "ApplicationManager";
+    auto storageDir = getXDGDataHome() % u"/deepin/ApplicationManager"_s;
     auto storage = ApplicationManager1Storage::createApplicationManager1Storage(storageDir);
 
     ApplicationManager1Service AMService{std::make_unique<CGroupsIdentifier>(), storage};
-    AMService.initService(AMBus);
+    AMService.initService(bus.globalServerBus());
 
 #ifdef PROFILING_MODE
     auto end = std::chrono::high_resolution_clock::now();

src/applicationchecker.cpp

@@ -45,7 +45,7 @@ bool hasDesktopIntersection(QStringView rawValue, const QStringList &currentDesk
 bool ApplicationFilter::hiddenCheck(const DesktopEntry &entry) noexcept
 {
     bool hidden{false};
-    auto hiddenVal = entry.value(DesktopFileEntryKey, DesktopEntryHidden);
+    auto hiddenVal = entry.value(fromStaticRaw(DesktopFileEntryKey), fromStaticRaw(DesktopEntryHidden));
 
     if (hiddenVal.has_value()) {
         bool ok{false};
@@ -60,7 +60,7 @@ bool ApplicationFilter::hiddenCheck(const DesktopEntry &entry) noexcept
 
 bool ApplicationFilter::tryExecCheck(const DesktopEntry &entry) noexcept
 {
-    auto tryExecVal = entry.value(DesktopFileEntryKey, u"TryExec"_s);
+    auto tryExecVal = entry.value(fromStaticRaw(DesktopFileEntryKey), u"TryExec"_s);
     if (tryExecVal.has_value()) {
         auto executable = toString(tryExecVal.value());
         if (executable.isEmpty()) {
@@ -86,12 +86,12 @@ bool ApplicationFilter::showInCheck(const DesktopEntry &entry) noexcept
     }
 
     bool showInCurrentDE{true};
-    if (auto val = entry.value(DesktopFileEntryKey, u"OnlyShowIn"_s); val.has_value()) {
+    if (auto val = entry.value(fromStaticRaw(DesktopFileEntryKey), u"OnlyShowIn"_s); val.has_value()) {
         showInCurrentDE = hasDesktopIntersection(toString(val.value()), desktops);
     }
 
     bool notShowInCurrentDE{false};
-    if (auto val = entry.value(DesktopFileEntryKey, u"NotShowIn"_s); val.has_value()) {
+    if (auto val = entry.value(fromStaticRaw(DesktopFileEntryKey), u"NotShowIn"_s); val.has_value()) {
         notShowInCurrentDE = hasDesktopIntersection(toString(val.value()), desktops);
     }
 

src/applicationmanagerstorage.cpp

@@ -12,14 +12,12 @@
 std::shared_ptr<ApplicationManager1Storage>
 ApplicationManager1Storage::createApplicationManager1Storage(const QString &storageDir) noexcept
 {
-    QDir dir;
-    auto dirPath = QDir::cleanPath(storageDir);
-    if (!dir.mkpath(dirPath)) {
+    const QDir dir{QDir::cleanPath(storageDir)};
+    if (!dir.mkpath(".")) {
         qCritical() << "can't create directory";
         return nullptr;
     }
 
-    dir.setPath(dirPath);
     auto storagePath = dir.filePath("storage.json");
     auto obj = std::shared_ptr<ApplicationManager1Storage>(new (std::nothrow) ApplicationManager1Storage{storagePath});
 

src/applicationmanagerstorage.h

@@ -9,7 +9,7 @@
 #include <QJsonObject>
 #include <QFile>
 
-enum class ModifyMode { Create, Update };
+enum class ModifyMode : uint8_t { Create, Update };
 
 class ApplicationManager1Storage
 {

src/compatibilitymanager.cpp

@@ -4,14 +4,15 @@
 
 #include "compatibilitymanager.h"
 #include "constant.h"
+#include "global.h"
 #include <QJsonDocument>
 #include <QJsonObject>
 #include <QJsonArray>
 
-std::optional<CompatibilityDesktopEntry::Entry> CompatibilityDesktopEntry::group(const QString &key)  const noexcept
+std::optional<CompatibilityDesktopEntry::Entry> CompatibilityDesktopEntry::group(const QString &key) const noexcept
 {
     auto iter = m_entrys.find(key);
-    if(iter == m_entrys.end()){
+    if (iter == m_entrys.end()) {
         return std::nullopt;
     }
 
@@ -21,15 +22,15 @@ std::optional<CompatibilityDesktopEntry::Entry> CompatibilityDesktopEntry::group
 std::any CompatibilityDesktopEntry::value(const QString &key, const CompatibilityDesktopEntry::ValueKey &valueKey) const noexcept
 {
     auto iter = m_entrys.find(key);
-    if(iter == m_entrys.end()){
+    if (iter == m_entrys.end()) {
         return std::nullopt;
     }
 
-    if(valueKey == CompatibilityDesktopEntry::Exec){
+    if (valueKey == CompatibilityDesktopEntry::Exec) {
         return get<0>(*iter);
     }
 
-    if(valueKey == CompatibilityDesktopEntry::Env){
+    if (valueKey == CompatibilityDesktopEntry::Env) {
         return get<1>(*iter);
     }
 
@@ -39,36 +40,36 @@ std::any CompatibilityDesktopEntry::value(const QString &key, const Compatibilit
 void CompatibilityDesktopEntry::insert(const QString &groupKey, const Entry &entry) noexcept
 {
     auto iter = m_entrys.find(groupKey);
-    if(iter == m_entrys.end()){
-        m_entrys.insert(groupKey,entry);
-    }else{
-        qWarning()<<"insert : "<<groupKey<<"fail";
+    if (iter == m_entrys.end()) {
+        m_entrys.insert(groupKey, entry);
+    } else {
+        qWarning() << "insert : " << groupKey << "fail";
     }
 }
 
 CompatibilityManager::CompatibilityManager()
 {
     connect(&m_watcher, &QFileSystemWatcher::fileChanged, this, &CompatibilityManager::loadCompatibilityConfig);
 
-    if(!m_watcher.addPath(CompatibilityConfigFilePath)){
-        qWarning() << "add path : "<< CompatibilityConfigFilePath << "to watch fail";
+    if (!m_watcher.addPath(fromStaticRaw(CompatibilityConfigFilePath))) {
+        qWarning() << "add path : " << QStringView{CompatibilityConfigFilePath} << "to watch fail";
     }
     loadCompatibilityConfig();
 }
 
 std::optional<QString> CompatibilityManager::getExec(const QString &desktopId, const QString &groupId)
 {
     auto iter = m_compatibilityConfig.find(desktopId);
-    if(iter == m_compatibilityConfig.end()){
+    if (iter == m_compatibilityConfig.end()) {
         return std::nullopt;
     }
 
     auto value = iter->value(groupId, CompatibilityDesktopEntry::Exec);
-    if(!value.has_value()){
+    if (!value.has_value()) {
         return std::nullopt;
     }
 
-    if (value.type() != typeid(QString)){
+    if (value.type() != typeid(QString)) {
         return std::nullopt;
     }
 
@@ -78,34 +79,36 @@ std::optional<QString> CompatibilityManager::getExec(const QString &desktopId, c
 QStringList CompatibilityManager::getEnv(const QString &desktopId, const QString &groupId)
 {
     auto iter = m_compatibilityConfig.find(desktopId);
-    if(iter == m_compatibilityConfig.end()){
+    if (iter == m_compatibilityConfig.end()) {
         return QStringList();
     }
 
     auto value = iter->value(groupId, CompatibilityDesktopEntry::Env);
-    if(!value.has_value()){
+    if (!value.has_value()) {
         return QStringList();
     }
 
-    if (value.type() != typeid(QStringList)){
+    if (value.type() != typeid(QStringList)) {
         return QStringList();
     }
 
     return std::any_cast<QStringList>(value);
 }
 
-void CompatibilityManager::loadCompatibilityConfig(){
+void CompatibilityManager::loadCompatibilityConfig()
+{
     qInfo() << "loadCompatibilityConfig";
     m_compatibilityConfig.clear();
-    QFile file{CompatibilityConfigFilePath};
+    QFile file{fromStaticRaw(CompatibilityConfigFilePath)};
 
     auto err = parse(file);
     if (err != ParserError::NoError) {
         qWarning() << "parse file :" << file.fileName() << ", err";
     }
 }
 
-ParserError CompatibilityManager::parse(QFile &file) noexcept{
+ParserError CompatibilityManager::parse(QFile &file) noexcept
+{
     if (!file.open(QFile::Text | QFile::ReadOnly | QFile::ExistingOnly)) {
         qWarning() << "open file:" << file.fileName() << "failed:" << file.errorString() << ", skip.";
         return ParserError::NotFound;
@@ -119,26 +122,26 @@ ParserError CompatibilityManager::parse(QFile &file) noexcept{
         return ParserError::MissingInfo;
     }
     if (json.isEmpty()) {
-        qWarning() << "file : "<<file.fileName()<<" empty";
+        qWarning() << "file : " << file.fileName() << " empty";
         return ParserError::MissingInfo;
     }
 
     auto obj = json.object();
     for (auto it = obj.constBegin(); it != obj.constEnd(); ++it) {
         const auto &desktopId = it.key();
         auto existDesktopId = m_compatibilityConfig.constFind(desktopId);
-        if(existDesktopId != m_compatibilityConfig.cend()){
-            qWarning() << "the desktop id : "<< it.key() <<"exist skip";
+        if (existDesktopId != m_compatibilityConfig.cend()) {
+            qWarning() << "the desktop id : " << it.key() << "exist skip";
             continue;
         }
         auto desktopEntry = obj[desktopId].toObject();
 
         // 处理 Desktop Entry
         CompatibilityDesktopEntry compatibilityEntry;
-        const auto& keys = desktopEntry.keys();
-        for(const auto &entryId : std::as_const(keys)){
-            if(!entryId.startsWith(DesktopFileEntryKey) && !entryId.startsWith(DesktopFileActionKey)){
-                qWarning() << "parse entry : "<<entryId<<" fail";
+        const auto &keys = desktopEntry.keys();
+        for (const auto &entryId : std::as_const(keys)) {
+            if (!entryId.startsWith(DesktopFileEntryKey) && !entryId.startsWith(DesktopFileActionKey)) {
+                qWarning() << "parse entry : " << entryId << " fail";
                 return ParserError::MissingInfo;
             }
 
@@ -151,13 +154,13 @@ ParserError CompatibilityManager::parse(QFile &file) noexcept{
                 env.push_back(envJson.toString());
             }
 
-            //auto tub = std::make_tuple(exec,std::move(env.join("; ") + ";"));
-            auto tub = std::make_tuple(exec,env);
-            compatibilityEntry.insert(entryId,tub);
-            qInfo()<<"insert desktop id : " << entryId <<", with Exec : "<< exec << "and Env : "<<env;
+            // auto tub = std::make_tuple(exec,std::move(env.join("; ") + ";"));
+            auto tub = std::make_tuple(exec, env);
+            compatibilityEntry.insert(entryId, tub);
+            qInfo() << "insert desktop id : " << entryId << ", with Exec : " << exec << "and Env : " << env;
         }
 
-        m_compatibilityConfig.insert(desktopId,compatibilityEntry);
+        m_compatibilityConfig.insert(desktopId, compatibilityEntry);
     }
 
     return ParserError::NoError;