filesystemwatcher/filesystemwatcher.cpp

#include "filesystemwatcher.h"
#include "ui_filesystemwatcher.h"

FileSystemWatcher::FileSystemWatcher(QString dirPath, QWidget *parent) :
    QMainWindow(parent),
    m_ui(new Ui::FileSystemWatcher),
    m_watcher(new QFileSystemWatcher()),
    m_listViewModel(new QStringListModel()),
    m_listView(new QListView()),
    m_timer(new QTimer(this)),
    m_dirPath(dirPath)
{
    // setup user interface
    m_ui->setupUi(this);

    // add main directory to monitor
    m_watcher->addPath(m_dirPath);

    // create the view
    m_listView->setModel(m_listViewModel);
    setCentralWidget(m_listView);

    // set title
    setWindowTitle("ChronoShare");

    // register signals (callback functions)
    connect(m_watcher, SIGNAL(directoryChanged(QString)), this, SLOT(watcherCallbackSlot(QString)));
    connect(m_timer, SIGNAL(timeout()), this, SLOT(timerCallbackSlot()));

    // bootstrap
    timerCallbackSlot();

    // start timer
    m_timer->start(300000);
}

FileSystemWatcher::~FileSystemWatcher()
{
    // clean up
    delete m_ui;
    delete m_watcher;
    delete m_listViewModel;
    delete m_listView;
    delete m_timer;
}

void FileSystemWatcher::watcherCallbackSlot(QString dirPath)
{
    // watcher specific steps
#if DEBUG
    qDebug() << endl << "[WATCHER] Triggered Path: " << dirPath;
#endif
    handleCallback(dirPath);
}

void FileSystemWatcher::timerCallbackSlot()
{
    // timer specific steps
#if DEBUG
    qDebug() << endl << "[TIMER] Triggered Path: " << m_dirPath;
#endif
    handleCallback(m_dirPath);
}

void FileSystemWatcher::handleCallback(QString dirPath)
{
    // scan directory and populate file list
    QHash<QString, qint64> currentState = scanDirectory(dirPath);

    // reconcile directory and report changes
    std::vector<sEventInfo> dirChanges = reconcileDirectory(currentState, dirPath);

    emit dirEventSignal(dirChanges);

#if DEBUG
    // DEBUG: Print Changes
    printChanges(dirChanges);
#endif
}

QHash<QString, qint64> FileSystemWatcher::scanDirectory(QString dirPath)
{   
    // list of files in directory
    QHash<QString, qint64> currentState;

    // directory iterator (recursive)
    QDirIterator dirIterator(dirPath, QDirIterator::Subdirectories |
                                        QDirIterator::FollowSymlinks);

    // iterate through directory recursively
    while(dirIterator.hasNext())
    {
        // Get Next File/Dir
        dirIterator.next();

        // Get FileInfo
        QFileInfo fileInfo = dirIterator.fileInfo();

        // if not this directory or previous directory
        if(fileInfo.absoluteFilePath() != ".." && fileInfo.absoluteFilePath() != ".")
        {
            QString absFilePath = fileInfo.absoluteFilePath();

            // if this is a directory
            if(fileInfo.isDir())
            {
                QStringList dirList = m_watcher->directories();

                // if the directory is not already being watched
                if (absFilePath.startsWith(m_dirPath) && !dirList.contains(absFilePath))
                {
                    // add this directory to the watch list
                    m_watcher->addPath(absFilePath);
                }
            }
            else
            {
                // add this file to the file list
                currentState.insert(absFilePath, fileInfo.created().toMSecsSinceEpoch());
            }
        }
    }

    return currentState;
}

std::vector<sEventInfo> FileSystemWatcher::reconcileDirectory(QHash<QString, qint64> currentState, QString dirPath)
{
    // list of files changed
    std::vector<sEventInfo> dirChanges;

    // compare result (database/stored snapshot) to fileList (current snapshot)
    QMutableHashIterator<QString, qint64> i(m_storedState);

    while(i.hasNext())
    {
        i.next();

        QString absFilePath = i.key();
        qint64 storedCreated = i.value();

        // if this file is in a level higher than
        // this directory, ignore
        if(!absFilePath.startsWith(dirPath))
        {
            continue;
        }

        // check file existence
        if(currentState.contains(absFilePath))
        {
            qint64 currentCreated = currentState.value(absFilePath);

            if(storedCreated != currentCreated)
            {
                // update stored state
                i.setValue(currentCreated);

                // this file has been modified
                sEventInfo eventInfo;
                eventInfo.event = MODIFIED;
                eventInfo.absFilePath = absFilePath.toStdString();
                dirChanges.push_back(eventInfo);
            }

            // delete this file from fileList we have processed it
            currentState.remove(absFilePath);
        }
        else
        {
            // delete from stored state
            i.remove();

            // this file has been deleted
            sEventInfo eventInfo;
            eventInfo.event = DELETED;
            eventInfo.absFilePath = absFilePath.toStdString();
            dirChanges.push_back(eventInfo);
        }
    }

    // any files left in fileList have been added
    for(QHash<QString, qint64>::iterator i = currentState.begin(); i != currentState.end(); ++i)
    {
        QString absFilePath = i.key();
        qint64 currentCreated = i.value();

        m_storedState.insert(absFilePath, currentCreated);

        // this file has been added
        sEventInfo eventInfo;
        eventInfo.event = ADDED;
        eventInfo.absFilePath = absFilePath.toStdString();
        dirChanges.push_back(eventInfo);
    }

    return dirChanges;
}

QByteArray FileSystemWatcher::calcChecksum(QString absFilePath)
{
    // initialize checksum
    QCryptographicHash crypto(QCryptographicHash::Md5);

    // open file
    QFile file(absFilePath);
    file.open(QFile::ReadOnly);

    // calculate checksum
    while(!file.atEnd())
    {
        crypto.addData(file.read(8192));
    }

    return crypto.result();
}

void FileSystemWatcher::printChanges(std::vector<sEventInfo> dirChanges)
{
    if(!dirChanges.empty())
    {
        QStringList dirChangesList;

        for(size_t i = 0; i < dirChanges.size(); i++)
        {
            QString tempString;

            eEvent event = dirChanges[i].event;
            QString absFilePath = QString::fromStdString(dirChanges[i].absFilePath);

            switch(event)
            {
            case ADDED:
                tempString.append("ADDED: ");
                break;
            case MODIFIED:
                tempString.append("MODIFIED: ");
                break;
            case DELETED:
                tempString.append("DELETED: ");
                break;
            }

            tempString.append(absFilePath);
#if DEBUG
            qDebug() << "\t" << tempString;
#endif
            dirChangesList.append(tempString);
        }

        m_listViewModel->setStringList(dirChangesList);
    }
    else
    {
#if DEBUG
        qDebug() << "\t[EMPTY]";
#endif
    }
}

#if WAF
#include "filesystemwatcher.moc"
#include "filesystemwatcher.cpp.moc"
#endif