qpluginloader.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// Copyright (C) 2018 Intel Corporation.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qpluginloader.h"
 
#include "qcoreapplication.h"
#include "qdebug.h"
#include "qdir.h"
#include "qfactoryloader_p.h"
#include "qfileinfo.h"
#include "qjsondocument.h"
 
#if QT_CONFIG(library)
#  include "qlibrary_p.h"
#endif
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
 
#if QT_CONFIG(library)
 
static constexpr QLibrary::LoadHints defaultLoadHints = QLibrary::PreventUnloadHint;
 
QPluginLoader::QPluginLoader(QObject *parent)
    : QObject(parent), d(nullptr), did_load(false)
{
}
 
QPluginLoader::QPluginLoader(const QString &fileName, QObject *parent)
    : QObject(parent), d(nullptr), did_load(false)
{
    setFileName(fileName);
    setLoadHints(defaultLoadHints);
}
 
QPluginLoader::~QPluginLoader()
{
    if (d)
        d->release();
}
 
QObject *QPluginLoader::instance()
{
    if (!isLoaded() && !load())
        return nullptr;
    return d->pluginInstance();
}
 
QJsonObject QPluginLoader::metaData() const
{
    if (!d)
        return QJsonObject();
    return d->metaData.toJson();
}
 
bool QPluginLoader::load()
{
    if (!d || d->fileName.isEmpty())
        return false;
    if (did_load)
        return d->pHnd && d->instanceFactory.loadAcquire();
    if (!d->isPlugin())
        return false;
    did_load = true;
    return d->loadPlugin();
}
 
bool QPluginLoader::unload()
{
    if (did_load) {
        did_load = false;
        return d->unload();
    }
    if (d) // Ouch
        d->errorString = tr("The plugin was not loaded.");
    return false;
}
 
bool QPluginLoader::isLoaded() const
{
    return d && d->pHnd && d->instanceFactory.loadRelaxed();
}
 
#if defined(QT_SHARED)
static QString locatePlugin(const QString& fileName)
{
    const bool isAbsolute = QDir::isAbsolutePath(fileName);
    if (isAbsolute) {
        QFileInfo fi(fileName);
        if (fi.isFile()) {
            return fi.canonicalFilePath();
        }
    }
    QStringList prefixes = QLibraryPrivate::prefixes_sys();
    prefixes.prepend(QString());
    QStringList suffixes = QLibraryPrivate::suffixes_sys(QString());
    suffixes.prepend(QString());
 
    // Split up "subdir/filename"
    const qsizetype slash = fileName.lastIndexOf(u'/');
    const auto baseName = QStringView{fileName}.mid(slash + 1);
    const auto basePath = isAbsolute ? QStringView() : QStringView{fileName}.left(slash + 1); // keep the '/'
 
    QStringList paths;
    if (isAbsolute) {
        paths.append(fileName.left(slash)); // don't include the '/'
    } else {
        paths = QCoreApplication::libraryPaths();
    }
 
    for (const QString &path : std::as_const(paths)) {
        for (const QString &prefix : std::as_const(prefixes)) {
            for (const QString &suffix : std::as_const(suffixes)) {
#ifdef Q_OS_ANDROID
                {
                    QString pluginPath = basePath + prefix + baseName + suffix;
                    const QString fn = path + "/lib"_L1 + pluginPath.replace(u'/', u'_');
                    qCDebug(qt_lcDebugPlugins) << "Trying..." << fn;
                    if (QFileInfo(fn).isFile())
                        return fn;
                }
#endif
                const QString fn = path + u'/' + basePath + prefix + baseName + suffix;
                qCDebug(qt_lcDebugPlugins) << "Trying..." << fn;
                if (QFileInfo(fn).isFile())
                    return fn;
            }
        }
    }
    qCDebug(qt_lcDebugPlugins) << fileName << "not found";
    return QString();
}
#endif
 
void QPluginLoader::setFileName(const QString &fileName)
{
#if defined(QT_SHARED)
    QLibrary::LoadHints lh = defaultLoadHints;
    if (d) {
        lh = d->loadHints();
        d->release();
        d = nullptr;
        did_load = false;
    }
 
    const QString fn = locatePlugin(fileName);
 
    d = QLibraryPrivate::findOrCreate(fn, QString(), lh);
    if (!fn.isEmpty())
        d->updatePluginState();
 
#else
    qCWarning(qt_lcDebugPlugins, "Cannot load '%ls' into a statically linked Qt library.",
              qUtf16Printable(fileName));
#endif
}
 
QString QPluginLoader::fileName() const
{
    if (d)
        return d->fileName;
    return QString();
}
 
QString QPluginLoader::errorString() const
{
    return (!d || d->errorString.isEmpty()) ? tr("Unknown error") : d->errorString;
}
 
void QPluginLoader::setLoadHints(QLibrary::LoadHints loadHints)
{
    if (!d) {
        d = QLibraryPrivate::findOrCreate({}, {}, loadHints); // ugly, but we need a d-ptr
        d->errorString.clear();
    } else {
        d->setLoadHints(loadHints);
    }
}
 
QLibrary::LoadHints QPluginLoader::loadHints() const
{
    // Not having a d-pointer means that the user hasn't called
    // setLoadHints() / setFileName() yet. In setFileName() we will
    // then force defaultLoadHints on loading, so we must return them
    // from here as well.
 
    return d ? d->loadHints() : defaultLoadHints;
}
 
#endif // QT_CONFIG(library)
 
typedef QList<QStaticPlugin> StaticPluginList;
Q_GLOBAL_STATIC(StaticPluginList, staticPluginList)
 
 
void Q_CORE_EXPORT qRegisterStaticPluginFunction(QStaticPlugin plugin)
{
    // using operator* because we shouldn't be registering plugins while
    // unloading the application!
    StaticPluginList &plugins = *staticPluginList;
 
    // insert the plugin in the list, sorted by address, so we can detect
    // duplicate registrations
    auto comparator = [=](const QStaticPlugin &p1, const QStaticPlugin &p2) {
        using Less = std::less<decltype(plugin.instance)>;
        return Less{}(p1.instance, p2.instance);
    };
    auto pos = std::lower_bound(plugins.constBegin(), plugins.constEnd(), plugin, comparator);
    if (pos == plugins.constEnd() || pos->instance != plugin.instance)
        plugins.insert(pos, plugin);
}
 
QObjectList QPluginLoader::staticInstances()
{
    QObjectList instances;
    if (staticPluginList.exists()) {
        const StaticPluginList &plugins = *staticPluginList;
        instances.reserve(plugins.size());
        for (QStaticPlugin plugin : plugins)
            instances += plugin.instance();
    }
    return instances;
}
 
QList<QStaticPlugin> QPluginLoader::staticPlugins()
{
    StaticPluginList *plugins = staticPluginList();
    if (plugins)
        return *plugins;
    return QList<QStaticPlugin>();
}
 
QJsonObject QStaticPlugin::metaData() const
{
    QByteArrayView data(static_cast<const char *>(rawMetaData), rawMetaDataSize);
    QPluginParsedMetaData parsed(data);
    Q_ASSERT(!parsed.isError());
    return parsed.toJson();
}
 
QT_END_NAMESPACE
 
#include "moc_qpluginloader.cpp"