[Qt6] TrackAnalysisScheduler: Remove dependency on Library

src/analyzer/analyzerwaveform.cpp

@@ -3,7 +3,6 @@
 #include "engine/engineobject.h"
 #include "engine/filters/enginefilterbessel4.h"
 #include "engine/filters/enginefilterbutterworth8.h"
-#include "library/trackcollection.h"
 #include "track/track.h"
 #include "util/logger.h"
 #include "waveform/waveformfactory.h"

src/analyzer/trackanalysisscheduler.cpp

@@ -1,8 +1,8 @@
 #include "analyzer/trackanalysisscheduler.h"
 
-#include "library/library.h"
-#include "library/trackcollectionmanager.h"
+#include "library/dao/trackdao.h"
 #include "moc_trackanalysisscheduler.cpp"
+#include "track/track.h"
 #include "util/logger.h"
 
 namespace {
@@ -31,24 +31,27 @@ TrackAnalysisScheduler::NullPointer::NullPointer()
 
 //static
 TrackAnalysisScheduler::Pointer TrackAnalysisScheduler::createInstance(
-        Library* library,
+        const TrackDAO* pTrackDao,
         int numWorkerThreads,
+        const mixxx::DbConnectionPoolPtr& pDbConnectionPool,
         const UserSettingsPointer& pConfig,
         AnalyzerModeFlags modeFlags) {
     return Pointer(new TrackAnalysisScheduler(
-            library,
-            numWorkerThreads,
-            pConfig,
-            modeFlags),
+                           pTrackDao,
+                           numWorkerThreads,
+                           pDbConnectionPool,
+                           pConfig,
+                           modeFlags),
             deleteTrackAnalysisScheduler);
 }
 
 TrackAnalysisScheduler::TrackAnalysisScheduler(
-        Library* library,
+        const TrackDAO* pTrackDao,
         int numWorkerThreads,
+        const mixxx::DbConnectionPoolPtr& pDbConnectionPool,
         const UserSettingsPointer& pConfig,
         AnalyzerModeFlags modeFlags)
-        : m_library(library),
+        : m_pTrackDao(pTrackDao),
           m_currentTrackProgress(kAnalyzerProgressUnknown),
           m_currentTrackNumber(0),
           m_dequeuedTracksCount(0),
@@ -70,11 +73,13 @@ TrackAnalysisScheduler::TrackAnalysisScheduler(
     for (int threadId = 0; threadId < numWorkerThreads; ++threadId) {
         m_workers.emplace_back(AnalyzerThread::createInstance(
                 threadId,
-                library->dbConnectionPool(),
+                pDbConnectionPool,
                 pConfig,
                 modeFlags));
-        connect(m_workers.back().thread(), &AnalyzerThread::progress,
-            this, &TrackAnalysisScheduler::onWorkerThreadProgress);
+        connect(m_workers.back().thread(),
+                &AnalyzerThread::progress,
+                this,
+                &TrackAnalysisScheduler::onWorkerThreadProgress);
     }
     // 2nd pass: Start worker threads in a suspended state
     for (const auto& worker: m_workers) {
@@ -270,12 +275,17 @@ void TrackAnalysisScheduler::resume() {
 
 bool TrackAnalysisScheduler::submitNextTrack(Worker* worker) {
     DEBUG_ASSERT(worker);
+    const auto* const pTrackDao = m_pTrackDao.data();
+    VERIFY_OR_DEBUG_ASSERT(pTrackDao) {
+        kLogger.critical() << "TrackDAO pointer is dangling";
+        return false;
+    }
     while (!m_queuedTrackIds.empty()) {
         TrackId nextTrackId = m_queuedTrackIds.front();
         DEBUG_ASSERT(nextTrackId.isValid());
         if (nextTrackId.isValid()) {
             TrackPointer nextTrack =
-                    m_library->trackCollectionManager()->getTrackById(nextTrackId);
+                    pTrackDao->getTrackById(nextTrackId);
             if (nextTrack) {
                 if (m_pendingTrackIds.insert(nextTrackId).second) {
                     if (worker->submitNextTrack(std::move(nextTrack))) {
@@ -327,18 +337,3 @@ void TrackAnalysisScheduler::stop() {
     m_pendingTrackIds.clear();
     DEBUG_ASSERT((allTracksFinished()));
 }
-
-QList<TrackId> TrackAnalysisScheduler::stopAndCollectScheduledTrackIds() {
-    QList<TrackId> scheduledTrackIds;
-    scheduledTrackIds.reserve(static_cast<int>(m_queuedTrackIds.size() + m_pendingTrackIds.size()));
-    for (auto queuedTrackId: m_queuedTrackIds) {
-        scheduledTrackIds.append(std::move(queuedTrackId));
-    }
-    for (auto pendingTrackId: m_pendingTrackIds) {
-        scheduledTrackIds.append(std::move(pendingTrackId));
-    }
-    // Stopping the scheduler will clear all queued and pending tracks,
-    // so we need to do this after we have collected all scheduled tracks!
-    stop();
-    return scheduledTrackIds;
-}

src/analyzer/trackanalysisscheduler.h

@@ -1,18 +1,17 @@
 #pragma once
 
 #include <QList>
-
 #include <deque>
+#include <memory>
 #include <set>
 #include <vector>
 
 #include "analyzer/analyzerthread.h"
-
-#include "util/memory.h"
-
+#include "util/db/dbconnectionpool.h"
+#include "util/qt.h"
 
 // forward declaration(s)
-class Library;
+class TrackDAO;
 
 class TrackAnalysisScheduler : public QObject {
     Q_OBJECT
@@ -26,14 +25,16 @@ class TrackAnalysisScheduler : public QObject {
     };
 
     static Pointer createInstance(
-            Library* library,
+            const TrackDAO* pTrackDao,
             int numWorkerThreads,
+            const mixxx::DbConnectionPoolPtr& pDbConnectionPool,
             const UserSettingsPointer& pConfig,
             AnalyzerModeFlags modeFlags);
 
     /*private*/ TrackAnalysisScheduler(
-            Library* library,
+            const TrackDAO* pTrackDao,
             int numWorkerThreads,
+            const mixxx::DbConnectionPoolPtr& pDbConnectionPool,
             const UserSettingsPointer& pConfig,
             AnalyzerModeFlags modeFlags);
     ~TrackAnalysisScheduler() override;
@@ -43,14 +44,6 @@ class TrackAnalysisScheduler : public QObject {
     bool scheduleTrackById(TrackId trackId);
     int scheduleTracksById(const QList<TrackId>& trackIds);
 
-    // Returns the scheduled tracks that have not yet been analyzed.
-    // Includes both queued tracks as well as pending tracks that are
-    // currently being analyzed. The result may contain duplicates.
-    // TODO(XXX): Use this function for implementing the feature
-    // "Suspend and resume batch analysis"
-    // https://bugs.launchpad.net/mixxx/+bug/1443181
-    QList<TrackId> stopAndCollectScheduledTrackIds();
-
   public slots:
     void suspend();
 
@@ -146,7 +139,7 @@ class TrackAnalysisScheduler : public QObject {
                 m_pendingTrackIds.empty();
     }
 
-    Library* m_library;
+    const mixxx::SafeQPointer<const TrackDAO> m_pTrackDao;
 
     std::vector<Worker> m_workers;
 

src/library/analysisfeature.cpp

@@ -137,10 +137,8 @@ void AnalysisFeature::analyzeTracks(const QList<TrackId>& trackIds) {
                 << "Starting analysis using"
                 << numAnalyzerThreads
                 << "analyzer threads";
-        m_pTrackAnalysisScheduler = TrackAnalysisScheduler::createInstance(
-                m_pLibrary,
+        m_pTrackAnalysisScheduler = m_pLibrary->createTrackAnalysisScheduler(
                 numAnalyzerThreads,
-                m_pConfig,
                 getAnalyzerModeFlags(m_pConfig));
 
         connect(m_pTrackAnalysisScheduler.get(),

src/library/dao/trackdao.h

@@ -131,6 +131,7 @@ class TrackDAO : public QObject, public virtual DAO, public virtual GlobalTrackC
   private:
     friend class LibraryScanner;
     friend class TrackCollection;
+    friend class TrackAnalysisScheduler;
 
     TrackId getTrackIdByLocation(
             const QString& location) const;

src/library/library.cpp

@@ -254,15 +254,24 @@ Library::Library(
             kEditMetadataSelectedClickDefault);
 }
 
-Library::~Library() {
-    // Empty but required due to forward declarations in header file!
-}
+Library::~Library() = default;
 
 TrackCollectionManager* Library::trackCollectionManager() const {
     // Cannot be implemented inline due to forward declarations
     return m_pTrackCollectionManager;
 }
 
+TrackAnalysisScheduler::Pointer Library::createTrackAnalysisScheduler(
+        int numWorkerThreads,
+        AnalyzerModeFlags modeFlags) const {
+    return TrackAnalysisScheduler::createInstance(
+            &m_pTrackCollectionManager->internalCollection()->getTrackDAO(),
+            numWorkerThreads,
+            m_pDbConnectionPool,
+            m_pConfig,
+            modeFlags);
+}
+
 void Library::stopPendingTasks() {
     if (m_pAnalysisFeature) {
         m_pAnalysisFeature->stopAnalysis();

src/library/library.h

@@ -6,7 +6,7 @@
 #include <QObject>
 #include <QPointer>
 
-#include "analyzer/analyzerprogress.h"
+#include "analyzer/trackanalysisscheduler.h"
 #include "library/library_decl.h"
 #ifdef __ENGINEPRIME__
 #include "library/trackset/crate/crateid.h"
@@ -66,6 +66,10 @@ class Library: public QObject {
 
     TrackCollectionManager* trackCollectionManager() const;
 
+    TrackAnalysisScheduler::Pointer createTrackAnalysisScheduler(
+            int numWorkerThreads,
+            AnalyzerModeFlags modeFlags) const;
+
     void bindSearchboxWidget(WSearchLineEdit* pSearchboxWidget);
     void bindSidebarWidget(WLibrarySidebar* sidebarWidget);
     void bindLibraryWidget(WLibrary* libraryWidget,

src/mixer/playermanager.cpp

@@ -153,10 +153,8 @@ void PlayerManager::bindToLibrary(Library* pLibrary) {
             &Library::slotLoadLocationToPlayer);
 
     DEBUG_ASSERT(!m_pTrackAnalysisScheduler);
-    m_pTrackAnalysisScheduler = TrackAnalysisScheduler::createInstance(
-            pLibrary,
+    m_pTrackAnalysisScheduler = pLibrary->createTrackAnalysisScheduler(
             kNumberOfAnalyzerThreads,
-            m_pConfig,
             AnalyzerModeFlags::WithWaveform);
 
     connect(m_pTrackAnalysisScheduler.get(), &TrackAnalysisScheduler::trackProgress,