公眾號:Qt那些事兒

簡介

QFileSystemWatcher的作用是監視本地資料夾的變化以及檔案的變化。

概述

QFileSystemWatcher的實現類是QFileSystemWatcherPrivate。 其中QFileSystemWatcherPrivate中的關鍵成員變數QFileSystemWatcherEngine用於監視目錄以及檔案的變化，傳送訊號給QFileystemWatcher。其中QFileSystemWatcherEngine派生了三個類。

class QFileSystemWatcherEngine : public QThread

其派生的子類三種類型分別為

// 這個用於監控Dir的變化
class QDnotifyFileSystemWatcherEngine : public QFileSystemWatcherEngine

// 這個外部沒有暴露對應的變化介面，但是檢測其它型別的目錄變化時我們會用到
class QPollingFileSystemWatcherEngine : public QFileSystemWatcherEngine

// 這個用於檢測檔案型別的變化
class QInotifyFileSystemWatcherEngine : public QFileSystemWatcherEngine

QInotifyFileSystemWatcherEngine

QInotifyFileSystemWatcherEngine用於監視檔案的變化。

// 太長可以忽略，這是詳細實現

//media/zhangpf/workspace1/Qt4.8.7/qt-everywhere-opensource-src-4.8.7/src/corelib/io/qfilesystemwatcher_inotify_p.h

#include "qfilesystemwatcher_p.h"
#ifndef QT_NO_FILESYSTEMWATCHER
#include <qhash.h>
#include <qmutex.h>
QT_BEGIN_NAMESPACE
class QInotifyFileSystemWatcherEngine : public QFileSystemWatcherEngine
{
    Q_OBJECT
public:
    ~QInotifyFileSystemWatcherEngine();
    static QInotifyFileSystemWatcherEngine *create(); //單例模式
    void run();
    QStringList addPaths(const QStringList &paths, QStringList *files, QStringList *directories);
    QStringList removePaths(const QStringList &paths, QStringList *files, QStringList *directories);
    void stop();
private Q_SLOTS:
    void readFromInotify();
private:
    QInotifyFileSystemWatcherEngine(int fd);
    int inotifyFd;
    QMutex mutex;
    QHash<QString, int> pathToID;
    QHash<int, QString> idToPath;
};
QT_END_NAMESPACE
#endif // QT_NO_FILESYSTEMWATCHER
#endif // QFILESYSTEMWATCHER_INOTIFY_P_H

// cpp
#include <sys/inotify.h>
#endif
QT_BEGIN_NAMESPACE
QInotifyFileSystemWatcherEngine *QInotifyFileSystemWatcherEngine::create()
{
    int fd = -1;
#ifdef IN_CLOEXEC
    fd = inotify_init1(IN_CLOEXEC);
#endif
    if (fd == -1) {
        fd = inotify_init();
        if (fd == -1)
            return 0;
        ::fcntl(fd, F_SETFD, FD_CLOEXEC);
    }
    return new QInotifyFileSystemWatcherEngine(fd);
}
QInotifyFileSystemWatcherEngine::QInotifyFileSystemWatcherEngine(int fd)
    : inotifyFd(fd)
{
    fcntl(inotifyFd, F_SETFD, FD_CLOEXEC);
    moveToThread(this);
}
QInotifyFileSystemWatcherEngine::~QInotifyFileSystemWatcherEngine()
{
    foreach (int id, pathToID)
        inotify_rm_watch(inotifyFd, id < 0 ? -id : id);
    ::close(inotifyFd);
}
void QInotifyFileSystemWatcherEngine::run()
{
    QSocketNotifier sn(inotifyFd, QSocketNotifier::Read, this);   //通過socket來監視檔案的變化，替代thread一個很好的方式
    connect(&sn, SIGNAL(activated(int)), SLOT(readFromInotify()));
    (void) exec();
}
QStringList QInotifyFileSystemWatcherEngine::addPaths(const QStringList &paths,
                                                      QStringList *files,
                                                      QStringList *directories)
{
    QMutexLocker locker(&mutex);
    QStringList p = paths;
    QMutableListIterator<QString> it(p);
    while (it.hasNext()) {
        QString path = it.next();
        QFileInfo fi(path);
        bool isDir = fi.isDir();
        if (isDir) {
            if (directories->contains(path))
                continue;
        } else {
            if (files->contains(path))
                continue;
        }
        int wd = inotify_add_watch(inotifyFd,
                                   QFile::encodeName(path),
                                   (isDir
                                    ? (0
                                       | IN_ATTRIB
                                       | IN_MOVE
                                       | IN_CREATE
                                       | IN_DELETE
                                       | IN_DELETE_SELF
                                       )
                                    : (0
                                       | IN_ATTRIB
                                       | IN_MODIFY
                                       | IN_MOVE
                                       | IN_MOVE_SELF
                                       | IN_DELETE_SELF
                                       )));
        if (wd <= 0) {
            perror("QInotifyFileSystemWatcherEngine::addPaths: inotify_add_watch failed");
            continue;
        }
        it.remove();
        int id = isDir ? -wd : wd;
        if (id < 0) {
            directories->append(path);
        } else {
            files->append(path);
        }
        pathToID.insert(path, id);
        idToPath.insert(id, path);
    }
    start();
    return p;
}
QStringList QInotifyFileSystemWatcherEngine::removePaths(const QStringList &paths,
                                                         QStringList *files,
                                                         QStringList *directories)
{
    QMutexLocker locker(&mutex);
    QStringList p = paths;
    QMutableListIterator<QString> it(p);
    while (it.hasNext()) {
        QString path = it.next();
        int id = pathToID.take(path);
        QString x = idToPath.take(id);
        if (x.isEmpty() || x != path)
            continue;
        int wd = id < 0 ? -id : id;
        // qDebug() << "removing watch for path" << path << "wd" << wd;
        inotify_rm_watch(inotifyFd, wd);
        it.remove();
        if (id < 0) {
            directories->removeAll(path);
        } else {
            files->removeAll(path);
        }
    }
    return p;
}
void QInotifyFileSystemWatcherEngine::stop()
{
    quit();
}
void QInotifyFileSystemWatcherEngine::readFromInotify()
{
    //主要是通過unix庫函式來獲取檔案對應的詳細資訊。再跟addpath實現中快取下來的資訊做對比，來檢測檔案的變化。
    QMutexLocker locker(&mutex);
    // qDebug() << "QInotifyFileSystemWatcherEngine::readFromInotify";
    int buffSize = 0;
    ioctl(inotifyFd, FIONREAD, (char *) &buffSize);
    QVarLengthArray<char, 4096> buffer(buffSize);
    buffSize = read(inotifyFd, buffer.data(), buffSize);
    char *at = buffer.data();
    char * const end = at + buffSize;
    QHash<int, inotify_event *> eventForId;
    while (at < end) {
        inotify_event *event = reinterpret_cast<inotify_event *>(at);
        if (eventForId.contains(event->wd))
            eventForId[event->wd]->mask |= event->mask;
        else
            eventForId.insert(event->wd, event);
        at += sizeof(inotify_event) + event->len;
    }
    QHash<int, inotify_event *>::const_iterator it = eventForId.constBegin();
    while (it != eventForId.constEnd()) {
        const inotify_event &event = **it;
        ++it;
        // qDebug() << "inotify event, wd" << event.wd << "mask" << hex << event.mask;
        int id = event.wd;
        QString path = idToPath.value(id);
        if (path.isEmpty()) {
            // perhaps a directory?
            id = -id;
            path = idToPath.value(id);
            if (path.isEmpty())
                continue;
        }
        // qDebug() << "event for path" << path;
        if ((event.mask & (IN_DELETE_SELF | IN_MOVE_SELF | IN_UNMOUNT)) != 0) {
            pathToID.remove(path);
            idToPath.remove(id);
            inotify_rm_watch(inotifyFd, event.wd);
            if (id < 0)
                emit directoryChanged(path, true);
            else
                emit fileChanged(path, true);
        } else {
            if (id < 0)
                emit directoryChanged(path, false);
            else
                emit fileChanged(path, false);
        }
    }
}
QT_END_NAMESPACE
#endif // QT_NO_FILESYSTEMWATCHER
 

這是一個單例模式，裡邊的核心程式碼其實就是講的是Inotify相關的函式。其中的關鍵的點，我已經打上備註。這個類中的主要實現是Linux下的Inotify的使用相關。

Inotify

Inotify簡單的來講是在Linux下監視檔案與資料夾的相關機制，本來想自己寫這一部分教程的，可是有一篇文章寫的太好了，忍不住給大家分享了。
https://www.ibm.com/developerworks/cn/linux/l-inotify/ 看完這一篇文章之後我覺得你對Linux下如何監視檔案應該有了解了，甚至可以自己封裝一個類給大家用。

資料夾的檢測變化實現類 QDnotifyFileSystemWatcherEngine

class QDnotifyFileSystemWatcherEngine : public QFileSystemWatcherEngine
{
    Q_OBJECT
public:
    virtual ~QDnotifyFileSystemWatcherEngine();
    static QDnotifyFileSystemWatcherEngine *create();
    void run();
    QStringList addPaths(const QStringList &paths, QStringList *files, QStringList *directories);
    QStringList removePaths(const QStringList &paths, QStringList *files, QStringList *directories);
    void stop();
private Q_SLOTS:
    void refresh(int);
private:
    //這個結構體比較關鍵
    struct Directory {
        Directory() : fd(0), parentFd(0), isMonitored(false) {}
        Directory(const Directory &o) : path(o.path),
                                        fd(o.fd),
                                        parentFd(o.parentFd),
                                        isMonitored(o.isMonitored),
                                        files(o.files) {}
        QString path;
        int fd;
        int parentFd;
        bool isMonitored;
        //這個結構體也比較關鍵
        struct File {
            File() : ownerId(0u), groupId(0u), permissions(0u) { }
            File(const File &o) : path(o.path),
                                  ownerId(o.ownerId),
                                  groupId(o.groupId),
                                  permissions(o.permissions),
                                  lastWrite(o.lastWrite) {}
            QString path;
            bool updateInfo();
            uint ownerId;
            uint groupId;
            QFile::Permissions permissions;
            QDateTime lastWrite;
        };
        QList<File> files;
    };
    QDnotifyFileSystemWatcherEngine();
    QMutex mutex;
    QHash<QString, int> pathToFD;
    QHash<int, Directory> fdToDirectory;
    QHash<int, int> parentToFD;
};

//cpp
QDnotifySignalThread::QDnotifySignalThread()
: isExecing(false)
{
    moveToThread(this);
    qt_safe_pipe(qfswd_fileChanged_pipe, O_NONBLOCK);
    struct sigaction oldAction;
    struct sigaction action;
    memset(&action, 0, sizeof(action));
    action.sa_sigaction = qfswd_sigio_monitor;
    action.sa_flags = SA_SIGINFO;
    ::sigaction(SIGIO, &action, &oldAction);
    if (!(oldAction.sa_flags & SA_SIGINFO))
        qfswd_old_sigio_handler = oldAction.sa_handler;
    else
        qfswd_old_sigio_action = oldAction.sa_sigaction;
}
QDnotifySignalThread::~QDnotifySignalThread()
{
    if(isRunning()) {
        quit();
        QThread::wait();
    }
}
bool QDnotifySignalThread::event(QEvent *e)
{
    if(e->type() == QEvent::User) {
        QMutexLocker locker(&mutex);
        isExecing = true;
        wait.wakeAll();
        return true;
    } else {
        return QThread::event(e);
    }
}
void QDnotifySignalThread::startNotify()
{
    // Note: All this fancy waiting for the thread to enter its event
    // loop is to avoid nasty messages at app shutdown when the
    // QDnotifySignalThread singleton is deleted
    start();
    mutex.lock();
    while(!isExecing)
        wait.wait(&mutex);
    mutex.unlock();
}
void QDnotifySignalThread::run()
{
    QSocketNotifier sn(qfswd_fileChanged_pipe[0], QSocketNotifier::Read, this);
    connect(&sn, SIGNAL(activated(int)), SLOT(readFromDnotify()));
    QCoreApplication::instance()->postEvent(this, new QEvent(QEvent::User));
    (void) exec();
}
void QDnotifySignalThread::readFromDnotify()
{
    int fd;
    int readrv = qt_safe_read(qfswd_fileChanged_pipe[0], reinterpret_cast<char*>(&fd), sizeof(int));
    // Only expect EAGAIN or EINTR. Other errors are assumed to be impossible.
    if(readrv != -1) {
        Q_ASSERT(readrv == sizeof(int));
        Q_UNUSED(readrv);
        if(0 == fd)
            quit();
        else
            emit fdChanged(fd);
    }
}
QDnotifyFileSystemWatcherEngine::QDnotifyFileSystemWatcherEngine()
{
    QObject::connect(dnotifySignal(), SIGNAL(fdChanged(int)),
                     this, SLOT(refresh(int)), Qt::DirectConnection);
}
QDnotifyFileSystemWatcherEngine::~QDnotifyFileSystemWatcherEngine()
{
    QMutexLocker locker(&mutex);
    for(QHash<int, Directory>::ConstIterator iter = fdToDirectory.constBegin();
            iter != fdToDirectory.constEnd();
            ++iter) {
        qt_safe_close(iter->fd);
        if(iter->parentFd)
            qt_safe_close(iter->parentFd);
    }
}
QDnotifyFileSystemWatcherEngine *QDnotifyFileSystemWatcherEngine::create()
{
    return new QDnotifyFileSystemWatcherEngine();
}
void QDnotifyFileSystemWatcherEngine::run()
{
    qFatal("QDnotifyFileSystemWatcherEngine thread should not be run");
}
QStringList QDnotifyFileSystemWatcherEngine::addPaths(const QStringList &paths, QStringList *files, QStringList *directories)
{
    QMutexLocker locker(&mutex);
    QStringList p = paths;
    QMutableListIterator<QString> it(p);
    while (it.hasNext()) {
        QString path = it.next();
        QFileInfo fi(path);
        if(!fi.exists()) {
            continue;
        }
        bool isDir = fi.isDir();
        if (isDir && directories->contains(path)) {
            continue; // Skip monitored directories
        } else if(!isDir && files->contains(path)) {
            continue; // Skip monitored files
        }
        if(!isDir)
            path = fi.canonicalPath();
        // Locate the directory entry (creating if needed)
        int fd = pathToFD[path];
        if(fd == 0) {
            QT_DIR *d = QT_OPENDIR(path.toUtf8().constData());
            if(!d) continue; // Could not open directory
            QT_DIR *parent = 0;
            QDir parentDir(path);
            if(!parentDir.isRoot()) {
                parentDir.cdUp();
                parent = QT_OPENDIR(parentDir.path().toUtf8().constData());
                if(!parent) {
                    QT_CLOSEDIR(d);
                    continue;
                }
            }
            fd = qt_safe_dup(::dirfd(d));
            int parentFd = parent ? qt_safe_dup(::dirfd(parent)) : 0;
            QT_CLOSEDIR(d);
            if(parent) QT_CLOSEDIR(parent);
            Q_ASSERT(fd);
            if(::fcntl(fd, F_SETSIG, SIGIO) ||
               ::fcntl(fd, F_NOTIFY, DN_MODIFY | DN_CREATE | DN_DELETE |
                                     DN_RENAME | DN_ATTRIB | DN_MULTISHOT) ||
               (parent && ::fcntl(parentFd, F_SETSIG, SIGIO)) ||
               (parent && ::fcntl(parentFd, F_NOTIFY, DN_DELETE | DN_RENAME |
                                            DN_MULTISHOT))) {
                continue; // Could not set appropriate flags
            }
            Directory dir;
            dir.path = path;
            dir.fd = fd;
            dir.parentFd = parentFd;
            fdToDirectory.insert(fd, dir);
            pathToFD.insert(path, fd);
            if(parentFd)
                parentToFD.insert(parentFd, fd);
        }
        Directory &directory = fdToDirectory[fd];
        if(isDir) {
            directory.isMonitored = true;
        } else {
            Directory::File file;
            file.path = fi.filePath();
            file.lastWrite = fi.lastModified();
            directory.files.append(file);
            pathToFD.insert(fi.filePath(), fd);
        }
        it.remove();
        if(isDir) {
            directories->append(path);
        } else {
            files->append(fi.filePath());
        }
    }
    dnotifySignal()->startNotify();
    return p;
}
QStringList QDnotifyFileSystemWatcherEngine::removePaths(const QStringList &paths, QStringList *files, QStringList *directories)
{
    QMutexLocker locker(&mutex);
    QStringList p = paths;
    QMutableListIterator<QString> it(p);
    while (it.hasNext()) {
        QString path = it.next();
        int fd = pathToFD.take(path);
        if(!fd)
            continue;
        Directory &directory = fdToDirectory[fd];
        bool isDir = false;
        if(directory.path == path) {
            isDir = true;
            directory.isMonitored = false;
        } else {
            for(int ii = 0; ii < directory.files.count(); ++ii) {
                if(directory.files.at(ii).path == path) {
                    directory.files.removeAt(ii);
                    break;
                }
            }
        }
        if(!directory.isMonitored && directory.files.isEmpty()) {
            // No longer needed
            qt_safe_close(directory.fd);
            pathToFD.remove(directory.path);
            fdToDirectory.remove(fd);
        }
        if(isDir) {
            directories->removeAll(path);
        } else {
            files->removeAll(path);
        }
        it.remove();
    }
    return p;
}
void QDnotifyFileSystemWatcherEngine::refresh(int fd)
{
    QMutexLocker locker(&mutex);
    bool wasParent = false;
    QHash<int, Directory>::Iterator iter = fdToDirectory.find(fd);
    if(iter == fdToDirectory.end()) {
        QHash<int, int>::Iterator pIter = parentToFD.find(fd);
        if(pIter == parentToFD.end())
            return;
        iter = fdToDirectory.find(*pIter);
        if (iter == fdToDirectory.end())
            return;
        wasParent = true;
    }
    Directory &directory = *iter;
    if(!wasParent) {
        for(int ii = 0; ii < directory.files.count(); ++ii) {
            Directory::File &file = directory.files[ii];
            if(file.updateInfo()) {
                // Emit signal
                QString filePath = file.path;
                bool removed = !QFileInfo(filePath).exists();
                if(removed) {
                    directory.files.removeAt(ii);
                    --ii;
                }
                emit fileChanged(filePath, removed);
            }
        }
    }
    if(directory.isMonitored) {
        // Emit signal
        bool removed = !QFileInfo(directory.path).exists();
        QString path = directory.path;
        if(removed)
            directory.isMonitored = false;
        emit directoryChanged(path, removed);
    }
    if(!directory.isMonitored && directory.files.isEmpty()) {
        qt_safe_close(directory.fd);
        if(directory.parentFd) {
            qt_safe_close(directory.parentFd);
            parentToFD.remove(directory.parentFd);
        }
        fdToDirectory.erase(iter);
    }
}
void QDnotifyFileSystemWatcherEngine::stop()
{
}
bool QDnotifyFileSystemWatcherEngine::Directory::File::updateInfo()
{
    QFileInfo fi(path);
    QDateTime nLastWrite = fi.lastModified();
    uint nOwnerId = fi.ownerId();
    uint nGroupId = fi.groupId();
    QFile::Permissions nPermissions = fi.permissions();
    if(nLastWrite != lastWrite ||
       nOwnerId != ownerId ||
       nGroupId != groupId ||
       nPermissions != permissions) {
        ownerId = nOwnerId;
        groupId = nGroupId;
        permissions = nPermissions;
        lastWrite = nLastWrite;
        return true;
    } else {
        return false;
    }
}

Dnotify

Dnotify同理，也是使用的Linux的系統函式 /usr/include/unistd.h 主要是這個標頭檔案中的函式。有一些關於檔案描述符相關的函式

裡邊主要監控的是其內部類的相關的資訊

    struct Directory {
        Directory() : fd(0), parentFd(0), isMonitored(false) {}
        Directory(const Directory &o) : path(o.path),
                                        fd(o.fd),
                                        parentFd(o.parentFd),
                                        isMonitored(o.isMonitored),
                                        files(o.files) {}
        QString path;
        int fd;
        int parentFd;
        bool isMonitored;
        struct File {
            File() : ownerId(0u), groupId(0u), permissions(0u) { }
            File(const File &o) : path(o.path),
                                  ownerId(o.ownerId),
                                  groupId(o.groupId),
                                  permissions(o.permissions),
                                  lastWrite(o.lastWrite) {}
            QString path;
            bool updateInfo();
            uint ownerId;
            uint groupId;
            QFile::Permissions permissions;
            QDateTime lastWrite;

可以直接看這個結構D需要這四個描述資訊

        QString path;  //路徑
        int fd;  //檔案的描述符
        int parentFd;    //父親的描述符號
        bool isMonitored; //是否正在監控

其中這四個資訊都是通過Linux的庫函式與結構體來獲取的。 其中遍歷資料夾則是使用Qt的QFileInfo來遍歷新增paths的資訊，儲存到其類的成員變數中。

// Directory iteration
#define QT_DIR DIR
#define QT_OPENDIR ::opendir
#define QT_CLOSEDIR ::closedir

Dir下的file需要這些資訊

            QString path;
            uint ownerId;
            uint groupId;
            QFile::Permissions permissions;
            QDateTime lastWrite;

現在說一下關鍵程式碼

    ret = ::pipe(pipefd);
    if (ret == -1)
        return -1;
    ::fcntl(pipefd[0], F_SETFD, FD_CLOEXEC);
    ::fcntl(pipefd[1], F_SETFD, FD_CLOEXEC);
    // set non-block too?
    if (flags & O_NONBLOCK) {
        ::fcntl(pipefd[0], F_SETFL, ::fcntl(pipefd[0], F_GETFL) | O_NONBLOCK);
        ::fcntl(pipefd[1], F_SETFL, ::fcntl(pipefd[1], F_GETFL) | O_NONBLOCK);
    }

其中 pipefd[0]表示讀，pipefd[1]表示寫，實際上
關鍵程式碼在這裡。

void QDnotifySignalThread::run()
{
    QSocketNotifier sn(qfswd_fileChanged_pipe[0], QSocketNotifier::Read, this);
    connect(&sn, SIGNAL(activated(int)), SLOT(readFromDnotify()));
    QCoreApplication::instance()->postEvent(this, new QEvent(QEvent::User));
    (void) exec();
}

這段程式碼實際上是使用QSocketNotifier實時檢測出從pip管道中讀取有關於檔案資訊的變化，加到了Qt在Linux下的事件迴圈中（還記上以前有個老哥寫的那個u盤檢測工具麼？實際上原理跟這個一樣，都是通過socket來讀取檔案描述符的狀態來檢測其變化）。然後等待其訊息通知變化。這樣來實時監控資料夾與檔案的變化。其中QDnotify大量使用了Unix的庫函式，建議有興趣的可以多讀讀Unix高階環境程式設計這本書，可以當個字典來看。我也不一個個解釋了。實際上這個類，我讀起來也是有點吃力，因為大部分都是Linux的庫函式，還是得補補課去看看《Unix環境高階程式設計》了

總結

這兩個類的主要原理是先快取當前addpath的檔案or資料夾的資訊，然後再通過socket來實時檢測其變化。獲取當前的資訊與快取的資訊做對比，如果有變化，就傳送對應的訊號。這樣我們就可以檢測到檔案or資料夾的變化了。

公眾號:Qt那些事兒