File indexing completed on 2024-11-10 04:40:43

 /*  -*- c++ -*-
     SPDX-FileCopyrightText: 2008 Tobias Koenig <tokoe@kde.org>
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include "akonadicore_debug.h"
 #include "pluginloader_p.h"
 #include "private/standarddirs_p.h"
 #include <KConfig>
 #include <KConfigGroup>
 #include <KLocalizedString>
 #include <QDir>
 #include <QPluginLoader>
 #include <QStandardPaths>
 
 using namespace Akonadi;
 
 PluginMetaData::PluginMetaData()
     : loaded(false)
 {
 }
 
 PluginMetaData::PluginMetaData(const QString &lib, const QString &name, const QString &comment, const QString &cname)
     : library(lib)
     , nameLabel(name)
     , descriptionLabel(comment)
     , className(cname)
     , loaded(false)
 {
 }
 
 PluginLoader *PluginLoader::mSelf = nullptr;
 
 PluginLoader::PluginLoader()
 {
     scan();
 }
 
 PluginLoader::~PluginLoader()
 {
     qDeleteAll(mPluginLoaders);
     mPluginLoaders.clear();
 }
 
 PluginLoader *PluginLoader::self()
 {
     if (!mSelf) {
         mSelf = new PluginLoader();
     }
 
     return mSelf;
 }
 
 QStringList PluginLoader::names() const
 {
     return mPluginInfos.keys();
 }
 
 QObject *PluginLoader::createForName(const QString &name)
 {
     if (!mPluginInfos.contains(name)) {
         qCWarning(AKONADICORE_LOG) << "plugin name \"" << name << "\" is unknown to the plugin loader.";
         return nullptr;
     }
 
     PluginMetaData &info = mPluginInfos[name];
 
     // First try to load it statically
     const auto instances = QPluginLoader::staticInstances();
     for (auto plugin : instances) {
         if (QLatin1StringView(plugin->metaObject()->className()) == info.className) {
             info.loaded = true;
             return plugin;
         }
     }
 
     if (!info.loaded) {
         auto loader = new QPluginLoader(info.library);
         if (loader->fileName().isEmpty()) {
             qCWarning(AKONADICORE_LOG) << "Error loading" << info.library << ":" << loader->errorString();
             delete loader;
             return nullptr;
         }
 
         mPluginLoaders.insert(name, loader);
         info.loaded = true;
     }
 
     QPluginLoader *loader = mPluginLoaders.value(name);
     Q_ASSERT(loader);
 
     QObject *object = loader->instance();
     if (!object) {
         qCWarning(AKONADICORE_LOG) << "unable to load plugin" << info.library << "for plugin name" << name << ".";
         qCWarning(AKONADICORE_LOG) << "Error was:\"" << loader->errorString() << "\".";
         return nullptr;
     }
 
     return object;
 }
 
 PluginMetaData PluginLoader::infoForName(const QString &name) const
 {
     return mPluginInfos.value(name, PluginMetaData());
 }
 
 void PluginLoader::scan()
 {
     const auto dirs = StandardDirs::locateAllResourceDirs(QStringLiteral("akonadi/plugins/serializer/"));
     for (const QString &dir : dirs) {
         const QStringList fileNames = QDir(dir).entryList(QStringList() << QStringLiteral("*.desktop"));
         for (const QString &file : fileNames) {
             const QString entry = dir + QLatin1Char('/') + file;
             KConfig config(entry, KConfig::SimpleConfig);
             if (config.hasGroup(QLatin1StringView("Misc")) && config.hasGroup(QLatin1StringView("Plugin"))) {
                 KConfigGroup group(&config, QStringLiteral("Plugin"));
 
                 const QString type = group.readEntry("Type").toLower();
                 if (type.isEmpty()) {
                     qCWarning(AKONADICORE_LOG) << "missing or empty [Plugin]Type value in" << entry << "- skipping";
                     continue;
                 }
 
                 // read Class entry as a list so that types like QPair<A,B> are
                 // properly escaped and don't end up being split into QPair<A
                 // and B>.
                 const QStringList classes = group.readXdgListEntry("X-Akonadi-Class");
                 if (classes.isEmpty()) {
                     qCWarning(AKONADICORE_LOG) << "missing or empty [Plugin]X-Akonadi-Class value in" << entry << "- skipping";
                     continue;
                 }
 
                 const QString library = group.readEntry("X-KDE-Library");
                 if (library.isEmpty()) {
                     qCWarning(AKONADICORE_LOG) << "missing or empty [Plugin]X-KDE-Library value in" << entry << "- skipping";
                     continue;
                 }
 
                 KConfigGroup group2(&config, QStringLiteral("Misc"));
 
                 QString name = group2.readEntry("Name");
                 if (name.isEmpty()) {
                     qCWarning(AKONADICORE_LOG) << "missing or empty [Misc]Name value in \"" << entry << "\" - inserting default name";
                     name = i18n("Unnamed plugin");
                 }
 
                 QString comment = group2.readEntry("Comment");
                 if (comment.isEmpty()) {
                     qCWarning(AKONADICORE_LOG) << "missing or empty [Misc]Comment value in \"" << entry << "\" - inserting default name";
                     comment = i18n("No description available");
                 }
 
                 QString cname = group.readEntry("X-KDE-ClassName");
                 if (cname.isEmpty()) {
                     qCWarning(AKONADICORE_LOG) << "missing or empty X-KDE-ClassName value in \"" << entry << "\"";
                 }
 
                 const QStringList mimeTypes = type.split(QLatin1Char(','), Qt::SkipEmptyParts);
 
                 qCDebug(AKONADICORE_LOG) << "registering Desktop file" << entry << "for" << mimeTypes << '@' << classes;
                 for (const QString &mimeType : mimeTypes) {
                     for (const QString &classType : classes) {
                         mPluginInfos.insert(mimeType + QLatin1Char('@') + classType, PluginMetaData(library, name, comment, cname));
                     }
                 }
 
             } else {
                 qCWarning(AKONADICORE_LOG) << "Desktop file \"" << entry << "\" doesn't seem to describe a plugin "
                                            << "(misses Misc and/or Plugin group)";
             }
         }
     }
 }