Initial commit

Code/Tools/AssetProcessor/native/FileWatcher/FileWatcher.cpp

@@ -0,0 +1,197 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+#include "FileWatcher.h"
+#include <native/assetprocessor.h>
+
+//////////////////////////////////////////////////////////////////////////////
+/// FolderWatchRoot
+void FolderRootWatch::ProcessNewFileEvent(const QString& file)
+{
+    FileChangeInfo info;
+    info.m_action = FileAction::FileAction_Added;
+    info.m_filePath = file;
+    const bool invoked = QMetaObject::invokeMethod(m_fileWatcher, "AnyFileChange", Qt::QueuedConnection, Q_ARG(FileChangeInfo, info));
+    Q_ASSERT(invoked);
+}
+
+void FolderRootWatch::ProcessDeleteFileEvent(const QString& file)
+{
+    FileChangeInfo info;
+    info.m_action = FileAction::FileAction_Removed;
+    info.m_filePath = file;
+    const bool invoked = QMetaObject::invokeMethod(m_fileWatcher, "AnyFileChange", Qt::QueuedConnection, Q_ARG(FileChangeInfo, info));
+    Q_ASSERT(invoked);
+}
+
+void FolderRootWatch::ProcessModifyFileEvent(const QString& file)
+{
+    FileChangeInfo info;
+    info.m_action = FileAction::FileAction_Modified;
+    info.m_filePath = file;
+    const bool invoked = QMetaObject::invokeMethod(m_fileWatcher, "AnyFileChange", Qt::QueuedConnection, Q_ARG(FileChangeInfo, info));
+    Q_ASSERT(invoked);
+}
+
+//////////////////////////////////////////////////////////////////////////
+/// FileWatcher
+FileWatcher::FileWatcher()
+    : m_nextHandle(0)
+{
+    qRegisterMetaType<FileChangeInfo>("FileChangeInfo");
+}
+
+FileWatcher::~FileWatcher()
+{
+}
+
+int FileWatcher::AddFolderWatch(FolderWatchBase* pFolderWatch)
+{
+    if (!pFolderWatch)
+    {
+        return -1;
+    }
+
+    FolderRootWatch* pFolderRootWatch = nullptr;
+
+    //see if this a sub folder of an already watched root
+    for (auto rootsIter = m_folderWatchRoots.begin(); !pFolderRootWatch && rootsIter != m_folderWatchRoots.end(); ++rootsIter)
+    {
+        if (FolderWatchBase::IsSubfolder(pFolderWatch->m_folder, (*rootsIter)->m_root))
+        {
+            pFolderRootWatch = *rootsIter;
+        }
+    }
+
+    bool bCreatedNewRoot = false;
+    //if its not a sub folder
+    if (!pFolderRootWatch)
+    {
+        //create a new root and start listening for changes
+        pFolderRootWatch = new FolderRootWatch(pFolderWatch->m_folder);
+
+        //make sure the folder watcher(s) get deleted before this
+        pFolderRootWatch->setParent(this);
+        bCreatedNewRoot = true;
+    }
+
+    pFolderRootWatch->m_fileWatcher = this;
+    QObject::connect(this, &FileWatcher::AnyFileChange, pFolderWatch, &FolderWatchBase::OnAnyFileChange);
+
+    if (bCreatedNewRoot)
+    {
+        if (m_startedWatching)
+        {
+            pFolderRootWatch->Start();
+        }
+
+        //since we created a new root, see if the new root is a super folder
+        //of other roots, if it is then then fold those roots into the new super root
+        for (auto rootsIter = m_folderWatchRoots.begin(); rootsIter != m_folderWatchRoots.end(); )
+        {
+            if (FolderWatchBase::IsSubfolder((*rootsIter)->m_root, pFolderWatch->m_folder))
+            {
+                //union the sub folder map over to the new root
+                pFolderRootWatch->m_subFolderWatchesMap.insert((*rootsIter)->m_subFolderWatchesMap);
+
+                //clear the old root sub folders map so they don't get deleted when we
+                //delete the old root as they are now pointed to by the new root
+                (*rootsIter)->m_subFolderWatchesMap.clear();
+
+                //delete the empty old root, deleting a root will call Stop()
+                //automatically which kills the thread
+                delete *rootsIter;
+
+                //remove the old root pointer form the watched list
+                rootsIter = m_folderWatchRoots.erase(rootsIter);
+            }
+            else
+            {
+                ++rootsIter;
+            }
+        }
+
+        //add the new root to the watched roots
+        m_folderWatchRoots.push_back(pFolderRootWatch);
+    }
+
+    //add to the root
+    pFolderRootWatch->m_subFolderWatchesMap.insert(m_nextHandle, pFolderWatch);
+
+    m_nextHandle++;
+
+    return m_nextHandle - 1;
+}
+
+void FileWatcher::RemoveFolderWatch(int handle)
+{
+    for (auto rootsIter = m_folderWatchRoots.begin(); rootsIter != m_folderWatchRoots.end(); )
+    {
+        //find an element by the handle
+        auto foundIter = (*rootsIter)->m_subFolderWatchesMap.find(handle);
+        if (foundIter != (*rootsIter)->m_subFolderWatchesMap.end())
+        {
+            //remove the element
+            (*rootsIter)->m_subFolderWatchesMap.erase(foundIter);
+
+            //we removed a folder watch, if it's empty then there is no reason to keep watching it.
+            if ((*rootsIter)->m_subFolderWatchesMap.empty())
+            {
+                delete(*rootsIter);
+                rootsIter = m_folderWatchRoots.erase(rootsIter);
+            }
+            else
+            {
+                ++rootsIter;
+            }
+        }
+        else
+        {
+            ++rootsIter;
+        }
+    }
+}
+
+void FileWatcher::StartWatching()
+{
+    if (m_startedWatching)
+    {
+        AZ_Warning("FileWatcher", false, "StartWatching() called when already watching for file changes.");
+        return;
+    }
+
+    for (FolderRootWatch* root : m_folderWatchRoots)
+    {
+        root->Start();
+    }
+
+    AZ_TracePrintf(AssetProcessor::ConsoleChannel, "File Change Monitoring started.\n");
+    m_startedWatching = true;
+}
+
+void FileWatcher::StopWatching()
+{
+    if (!m_startedWatching)
+    {
+        AZ_Warning("FileWatcher", false, "StartWatching() called when is not watching for file changes.");
+        return;
+    }
+
+    for (FolderRootWatch* root : m_folderWatchRoots)
+    {
+        root->Stop();
+    }
+
+    m_startedWatching = false;
+}
+
+#include "native/FileWatcher/moc_FileWatcher.cpp"
+#include "native/FileWatcher/moc_FileWatcherAPI.cpp"

Code/Tools/AssetProcessor/native/FileWatcher/FileWatcher.h

@@ -0,0 +1,99 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+#ifndef FILEWATCHER_COMPONENT_H
+#define FILEWATCHER_COMPONENT_H
+//////////////////////////////////////////////////////////////////////////
+
+#if !defined(Q_MOC_RUN)
+#include "FileWatcherAPI.h"
+
+#include <AzCore/std/containers/vector.h>
+#include <QMap>
+#include <QVector>
+#include <QString>
+
+#include <thread>
+#endif
+
+class FileWatcher;
+
+//////////////////////////////////////////////////////////////////////////
+//! FolderRootWatch
+/*! Class used for holding a point in the files system from which file changes are tracked.
+ * */
+class FolderRootWatch
+    : public QObject
+{
+    Q_OBJECT
+
+    friend class FileWatcher;
+public:
+    FolderRootWatch(const QString rootFolder);
+    virtual ~FolderRootWatch();
+
+    void ProcessNewFileEvent(const QString& file);
+    void ProcessDeleteFileEvent(const QString& file);
+    void ProcessModifyFileEvent(const QString& file);
+    void ProcessRenameFileEvent(const QString& fileOld, const QString& fileNew);
+
+public Q_SLOTS:
+    bool Start();
+    void Stop();
+
+private:
+    void WatchFolderLoop();
+
+private:
+    std::thread m_thread;
+    QString m_root;
+    QMap<int, FolderWatchBase*> m_subFolderWatchesMap;
+    volatile bool m_shutdownThreadSignal;
+    FileWatcher* m_fileWatcher;
+
+    // Can't use unique_ptr because this is a QObject and Qt's magic sauce is
+    // unable to determine the size of the unique_ptr and so fails to compile
+    struct PlatformImplementation;
+    PlatformImplementation* m_platformImpl;
+};
+
+//////////////////////////////////////////////////////////////////////////
+//! FileWatcher
+/*! Class that handles creation and deletion of FolderRootWatches based on
+ *! the given FolderWatches, and forwards file change signals to them.
+ * */
+class FileWatcher
+    : public QObject
+{
+    Q_OBJECT
+
+public:
+    FileWatcher();
+    virtual ~FileWatcher();
+
+    //////////////////////////////////////////////////////////////////////////
+    virtual int AddFolderWatch(FolderWatchBase* pFolderWatch);
+    virtual void RemoveFolderWatch(int handle);
+    //////////////////////////////////////////////////////////////////////////
+    
+    void StartWatching();
+    void StopWatching();
+
+Q_SIGNALS:
+    void AnyFileChange(FileChangeInfo info);
+
+private:
+    int m_nextHandle;
+    AZStd::vector<FolderRootWatch*> m_folderWatchRoots;
+    bool m_startedWatching = false;
+};
+
+#endif//FILEWATCHER_COMPONENT_H

Code/Tools/AssetProcessor/native/FileWatcher/FileWatcherAPI.h

@@ -0,0 +1,226 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+#ifndef FILEWATCHERAPI_H
+#define FILEWATCHERAPI_H
+
+#include <QString>
+#include <QObject>
+#include <QDir>
+
+//////////////////////////////////////////////////////////////////////////
+//! FileAction
+/*! Enum for which file changes are tracked.
+ * */
+enum FileAction
+{
+    FileAction_None = 0x00,
+    FileAction_Added = 0x01,
+    FileAction_Removed = 0x02,
+    FileAction_Modified = 0x04,
+    FileAction_Any = 0xFF,
+};
+inline FileAction operator | (FileAction a, FileAction b)
+{
+    return static_cast<FileAction>(static_cast<int>(a) | static_cast<int>(b));
+}
+inline FileAction operator & (FileAction a, FileAction b)
+{
+    return static_cast<FileAction>(static_cast<int>(a) & static_cast<int>(b));
+}
+
+//////////////////////////////////////////////////////////////////////////
+//! FileChangeInfo
+/*! Struct for passing along information about file changes.
+ * */
+struct FileChangeInfo
+{
+    FileChangeInfo()
+        : m_action(FileAction::FileAction_None)
+    {}
+    FileChangeInfo(const FileChangeInfo& rhs)
+        : m_action(rhs.m_action)
+        , m_filePath(rhs.m_filePath)
+        , m_filePathOld(rhs.m_filePathOld)
+    {
+    }
+
+    FileAction m_action;
+    QString m_filePath;
+    QString m_filePathOld;
+};
+
+Q_DECLARE_METATYPE(FileChangeInfo)
+
+//////////////////////////////////////////////////////////////////////////
+//! FolderWatchBase
+/*! Class for filtering file changes generated from a root watch. Define your own
+ *! custom filtering by deriving from this base class and implement your own
+ *! custom code for what to do when receiving a file change notification.
+ * */
+class FolderWatchBase
+    : public QObject
+{
+    Q_OBJECT
+
+public:
+    FolderWatchBase(const QString strFolder, bool bWatchSubtree = true, FileAction fileAction = FileAction::FileAction_Any)
+        : m_folder(strFolder)
+        , m_watchSubtree(bWatchSubtree)
+        , m_fileAction(fileAction)
+    {
+        m_folder = QDir::toNativeSeparators(QDir::cleanPath(m_folder) + "/");
+    }
+
+    //! IsSubfolder(folderA, folderB)
+    //! returns whether folderA is a subfolder of folderB
+    //! assumptions: absolute paths, case insensitive
+    static bool IsSubfolder(const QString& folderA, const QString& folderB)
+    {
+        // lets avoid allocating or messing with memory - this is a MAJOR hotspot as it is called for any file change even in the cache!
+        int sizeB = folderB.length();
+        int sizeA = folderA.length();
+
+        if (sizeA <= sizeB)
+        {
+            return false;
+        }
+
+        QChar slash1 = QChar('\\');
+        QChar slash2 = QChar('/');
+        int posA = 0;
+
+        // A is going to be the longer one, so use B:
+        for (int idx = 0; idx < sizeB; ++idx)
+        {
+            QChar charAtA = folderA.at(posA);
+            QChar charAtB = folderB.at(idx);
+
+            if ((charAtB == slash1) || (charAtB == slash2))
+            {
+                if ((charAtA != slash1) && (charAtA != slash2))
+                {
+                    return false;
+                }
+                ++posA;
+            }
+            else
+            {
+                if (charAtA.toLower() != charAtB.toLower())
+                {
+                    return false;
+                }
+                ++posA;
+            }
+        }
+        return true;
+    }
+
+    QString m_folder;
+    bool m_watchSubtree;
+    FileAction m_fileAction;
+
+public Q_SLOTS:
+    void OnAnyFileChange(FileChangeInfo info)
+    {
+        //if they set a file action then respect it by rejecting non matching file actions
+        if (info.m_action & m_fileAction)
+        {
+            //is the file is in the folder or subtree (if specified) then call OnFileChange
+
+            if (FolderWatchBase::IsSubfolder(info.m_filePath, m_folder))
+            {
+                OnFileChange(info);
+            }
+        }
+    }
+
+    virtual void OnFileChange(const FileChangeInfo& info) = 0;
+};
+
+//////////////////////////////////////////////////////////////////////////
+//! FolderWatchCallbackEx
+/*! Class implements a more complex filtering that can optionally filter for file
+ *! extension and call different callback for different kinds of file changes
+ *! generated from a root watch.
+ *! Notes:
+ *!  - empty extension "" catches all file changes
+ *!  - extension should not include the leading "."
+ * */
+class FolderWatchCallbackEx
+    : public FolderWatchBase
+{
+    Q_OBJECT
+
+public:
+    FolderWatchCallbackEx(const QString strFolder, const QString extension, bool bWatchSubtree)
+        : FolderWatchBase(strFolder, bWatchSubtree)
+        , m_extension(extension)
+    {
+    }
+
+    QString m_extension;
+
+    //on file change call the change callback if passes extension then route
+    //to specific file action type callback
+    virtual void OnFileChange(const FileChangeInfo& info)
+    {
+        //if they set an extension to watch for only let matching extensions through
+        QFileInfo fileInfo(info.m_filePath);
+
+        if (!m_watchSubtree)
+        {
+            // filter out subtrees too.
+            QStringRef subRef = info.m_filePath.rightRef(info.m_filePath.length() - m_folder.length());
+            if ((subRef.indexOf('/') != -1) || (subRef.indexOf('\\') != -1))
+            {
+                return; // filter this out.
+            }
+
+            // we don't care about subdirs.  IsDir is more expensive so we do it after the above filter.
+            if (fileInfo.isDir())
+            {
+                return;
+            }
+        }
+
+        if (m_extension.isEmpty() || fileInfo.completeSuffix().compare(m_extension, Qt::CaseInsensitive) == 0)
+        {
+            if (info.m_action & FileAction::FileAction_Any)
+            {
+                Q_EMIT fileChange(info);
+            }
+
+            if (info.m_action & FileAction::FileAction_Added)
+            {
+                Q_EMIT fileAdded(info.m_filePath);
+            }
+
+            if (info.m_action & FileAction::FileAction_Removed)
+            {
+                Q_EMIT fileRemoved(info.m_filePath);
+            }
+
+            if (info.m_action & FileAction::FileAction_Modified)
+            {
+                Q_EMIT fileModified(info.m_filePath);
+            }
+        }
+    }
+
+Q_SIGNALS:
+    void fileChange(FileChangeInfo info);
+    void fileAdded(QString filePath);
+    void fileRemoved(QString filePath);
+    void fileModified(QString filePath);
+};
+
+#endif//FILEWATCHERAPI_H