qfilesystemwatcher.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qfilesystemwatcher.h"
#include "qfilesystemwatcher_p.h"
 
#include <qdatetime.h>
#include <qdir.h>
#include <qfileinfo.h>
#include <qloggingcategory.h>
#include <qset.h>
#include <qtimer.h>
 
#if (defined(Q_OS_LINUX) || defined(Q_OS_QNX)) && QT_CONFIG(inotify)
#define USE_INOTIFY
#endif
 
#include "qfilesystemwatcher_polling_p.h"
#if defined(Q_OS_WIN)
#  include "qfilesystemwatcher_win_p.h"
#elif defined(USE_INOTIFY)
#  include "qfilesystemwatcher_inotify_p.h"
#elif defined(Q_OS_FREEBSD) || defined(Q_OS_NETBSD) || defined(Q_OS_OPENBSD) || defined(QT_PLATFORM_UIKIT)
#  include "qfilesystemwatcher_kqueue_p.h"
#elif defined(Q_OS_MACOS)
#  include "qfilesystemwatcher_fsevents_p.h"
#endif
 
#include <algorithm>
#include <iterator>
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
 
Q_LOGGING_CATEGORY(lcWatcher, "qt.core.filesystemwatcher")
 
QFileSystemWatcherEngine *QFileSystemWatcherPrivate::createNativeEngine(QObject *parent)
{
#if defined(Q_OS_WIN)
    return new QWindowsFileSystemWatcherEngine(parent);
#elif defined(USE_INOTIFY)
    // there is a chance that inotify may fail on Linux pre-2.6.13 (August
    // 2005), so we can't just new inotify directly.
    return QInotifyFileSystemWatcherEngine::create(parent);
#elif defined(Q_OS_FREEBSD) || defined(Q_OS_NETBSD) || defined(Q_OS_OPENBSD) || defined(QT_PLATFORM_UIKIT)
    return QKqueueFileSystemWatcherEngine::create(parent);
#elif defined(Q_OS_MACOS)
    return QFseventsFileSystemWatcherEngine::create(parent);
#else
    Q_UNUSED(parent);
    return 0;
#endif
}
 
QFileSystemWatcherPrivate::QFileSystemWatcherPrivate()
    : native(nullptr), poller(nullptr)
{
}
 
void QFileSystemWatcherPrivate::init()
{
    Q_Q(QFileSystemWatcher);
    native = createNativeEngine(q);
    if (native) {
        QObject::connect(native,
                         SIGNAL(fileChanged(QString,bool)),
                         q,
                         SLOT(_q_fileChanged(QString,bool)));
        QObject::connect(native,
                         SIGNAL(directoryChanged(QString,bool)),
                         q,
                         SLOT(_q_directoryChanged(QString,bool)));
#if defined(Q_OS_WIN)
        QObject::connect(static_cast<QWindowsFileSystemWatcherEngine *>(native),
                         &QWindowsFileSystemWatcherEngine::driveLockForRemoval,
                         q, [this] (const QString &p) { _q_winDriveLockForRemoval(p); });
        QObject::connect(static_cast<QWindowsFileSystemWatcherEngine *>(native),
                         &QWindowsFileSystemWatcherEngine::driveLockForRemovalFailed,
                         q, [this] (const QString &p) { _q_winDriveLockForRemovalFailed(p); });
        QObject::connect(static_cast<QWindowsFileSystemWatcherEngine *>(native),
                         &QWindowsFileSystemWatcherEngine::driveRemoved,
                         q, [this] (const QString &p) { _q_winDriveRemoved(p); });
#endif  // Q_OS_WIN
    }
}
 
void QFileSystemWatcherPrivate::initPollerEngine()
{
    if (poller)
        return;
 
    Q_Q(QFileSystemWatcher);
    poller = new QPollingFileSystemWatcherEngine(q); // that was a mouthful
    QObject::connect(poller,
                     SIGNAL(fileChanged(QString,bool)),
                     q,
                     SLOT(_q_fileChanged(QString,bool)));
    QObject::connect(poller,
                     SIGNAL(directoryChanged(QString,bool)),
                     q,
                     SLOT(_q_directoryChanged(QString,bool)));
}
 
void QFileSystemWatcherPrivate::_q_fileChanged(const QString &path, bool removed)
{
    Q_Q(QFileSystemWatcher);
    qCDebug(lcWatcher) << "file changed" << path << "removed?" << removed << "watching?" << files.contains(path);
    if (!files.contains(path)) {
        // the path was removed after a change was detected, but before we delivered the signal
        return;
    }
    if (removed)
        files.removeAll(path);
    emit q->fileChanged(path, QFileSystemWatcher::QPrivateSignal());
}
 
void QFileSystemWatcherPrivate::_q_directoryChanged(const QString &path, bool removed)
{
    Q_Q(QFileSystemWatcher);
    qCDebug(lcWatcher) << "directory changed" << path << "removed?" << removed << "watching?" << directories.contains(path);
    if (!directories.contains(path)) {
        // perhaps the path was removed after a change was detected, but before we delivered the signal
        return;
    }
    if (removed)
        directories.removeAll(path);
    emit q->directoryChanged(path, QFileSystemWatcher::QPrivateSignal());
}
 
#if defined(Q_OS_WIN)
 
void QFileSystemWatcherPrivate::_q_winDriveLockForRemoval(const QString &path)
{
    // Windows: Request to lock a (removable/USB) drive for removal, release
    // its paths under watch, temporarily storing them should the lock fail.
    Q_Q(QFileSystemWatcher);
    QStringList pathsToBeRemoved;
    auto pred = [&path] (const QString &f) { return !f.startsWith(path, Qt::CaseInsensitive); };
    std::remove_copy_if(files.cbegin(), files.cend(),
                        std::back_inserter(pathsToBeRemoved), pred);
    std::remove_copy_if(directories.cbegin(), directories.cend(),
                        std::back_inserter(pathsToBeRemoved), pred);
    if (!pathsToBeRemoved.isEmpty()) {
        q->removePaths(pathsToBeRemoved);
        temporarilyRemovedPaths.insert(path.at(0), pathsToBeRemoved);
    }
}
 
void QFileSystemWatcherPrivate::_q_winDriveLockForRemovalFailed(const QString &path)
{
    // Windows: Request to lock a (removable/USB) drive failed (blocked by other
    // application), restore the watched paths.
    Q_Q(QFileSystemWatcher);
    if (!path.isEmpty()) {
        const auto it = temporarilyRemovedPaths.find(path.at(0));
        if (it != temporarilyRemovedPaths.end()) {
            q->addPaths(it.value());
            temporarilyRemovedPaths.erase(it);
        }
    }
}
 
void  QFileSystemWatcherPrivate::_q_winDriveRemoved(const QString &path)
{
    // Windows: Drive finally removed, clear out paths stored in lock request.
    if (!path.isEmpty())
        temporarilyRemovedPaths.remove(path.at(0));
}
#endif // Q_OS_WIN
 
QFileSystemWatcher::QFileSystemWatcher(QObject *parent)
    : QObject(*new QFileSystemWatcherPrivate, parent)
{
    d_func()->init();
}
 
QFileSystemWatcher::QFileSystemWatcher(const QStringList &paths, QObject *parent)
    : QObject(*new QFileSystemWatcherPrivate, parent)
{
    d_func()->init();
    addPaths(paths);
}
 
QFileSystemWatcher::~QFileSystemWatcher()
{ }
 
bool QFileSystemWatcher::addPath(const QString &path)
{
    if (path.isEmpty()) {
        qWarning("QFileSystemWatcher::addPath: path is empty");
        return true;
    }
 
    QStringList paths = addPaths(QStringList(path));
    return paths.isEmpty();
}
 
static QStringList empty_paths_pruned(const QStringList &paths)
{
    QStringList p;
    p.reserve(paths.size());
    const auto isEmpty = [](const QString &s) { return s.isEmpty(); };
    std::remove_copy_if(paths.begin(), paths.end(),
                        std::back_inserter(p),
                        isEmpty);
    return p;
}
 
QStringList QFileSystemWatcher::addPaths(const QStringList &paths)
{
    Q_D(QFileSystemWatcher);
 
    QStringList p = empty_paths_pruned(paths);
 
    if (p.isEmpty()) {
        qWarning("QFileSystemWatcher::addPaths: list is empty");
        return p;
    }
    qCDebug(lcWatcher) << "adding" << paths;
    const auto selectEngine = [this, d]() -> QFileSystemWatcherEngine* {
#ifdef QT_BUILD_INTERNAL
        const QString on = objectName();
 
        if (Q_UNLIKELY(on.startsWith("_qt_autotest_force_engine_"_L1))) {
            // Autotest override case - use the explicitly selected engine only
            const auto forceName = QStringView{on}.mid(26);
            if (forceName == "poller"_L1) {
                qCDebug(lcWatcher, "QFileSystemWatcher: skipping native engine, using only polling engine");
                d_func()->initPollerEngine();
                return d->poller;
            } else if (forceName == "native"_L1) {
                qCDebug(lcWatcher, "QFileSystemWatcher: skipping polling engine, using only native engine");
                return d->native;
            }
            return nullptr;
        }
#endif
        // Normal runtime case - search intelligently for best engine
        if (d->native) {
            return d->native;
        } else {
            d_func()->initPollerEngine();
            return d->poller;
        }
    };
 
    if (auto engine = selectEngine())
        p = engine->addPaths(p, &d->files, &d->directories);
 
    return p;
}
 
bool QFileSystemWatcher::removePath(const QString &path)
{
    if (path.isEmpty()) {
        qWarning("QFileSystemWatcher::removePath: path is empty");
        return true;
    }
 
    QStringList paths = removePaths(QStringList(path));
    return paths.isEmpty();
}
 
QStringList QFileSystemWatcher::removePaths(const QStringList &paths)
{
    Q_D(QFileSystemWatcher);
 
    QStringList p = empty_paths_pruned(paths);
 
    if (p.isEmpty()) {
        qWarning("QFileSystemWatcher::removePaths: list is empty");
        return p;
    }
    qCDebug(lcWatcher) << "removing" << paths;
 
    if (d->native)
        p = d->native->removePaths(p, &d->files, &d->directories);
    if (d->poller)
        p = d->poller->removePaths(p, &d->files, &d->directories);
 
    return p;
}
 
QStringList QFileSystemWatcher::directories() const
{
    Q_D(const QFileSystemWatcher);
    return d->directories;
}
 
QStringList QFileSystemWatcher::files() const
{
    Q_D(const QFileSystemWatcher);
    return d->files;
}
 
QT_END_NAMESPACE
 
#include "moc_qfilesystemwatcher.cpp"
#include "moc_qfilesystemwatcher_p.cpp"