File indexing completed on 2024-05-05 04:48:50

 /****************************************************************************************
  * Copyright (c) 2007 Maximilian Kossick <maximilian.kossick@googlemail.com>            *
  * Copyright (c) 2008 Seb Ruiz <ruiz@kde.org>                                           *
  * Copyright (c) 2009-2010 Jeff Mitchell <mitchell@kde.org>                             *
  * Copyright (c) 2013 Ralf Engels <ralf-engels@gmx.de>                                  *
  *                                                                                      *
  * This program is free software; you can redistribute it and/or modify it under        *
  * the terms of the GNU General Public License as published by the Free Software        *
  * Foundation; either version 2 of the License, or (at your option) any later           *
  * version.                                                                             *
  *                                                                                      *
  * This program is distributed in the hope that it will be useful, but WITHOUT ANY      *
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A      *
  * PARTICULAR PURPOSE. See the GNU General Public License for more details.             *
  *                                                                                      *
  * You should have received a copy of the GNU General Public License along with         *
  * this program.  If not, see <http://www.gnu.org/licenses/>.                           *
  ****************************************************************************************/
 
 #define DEBUG_PREFIX "AbstractScanResultProcessor"
 
 #include "AbstractScanResultProcessor.h"
 
 #include "collectionscanner/Album.h"
 #include "collectionscanner/Directory.h"
 #include "collectionscanner/Playlist.h"
 #include "collectionscanner/Track.h"
 #include "core/logger/Logger.h"
 #include "core/support/Debug.h"
 #include "core/support/Components.h"
 #include "core-impl/collections/support/ArtistHelper.h"
 #include "playlistmanager/PlaylistManager.h"
 #include "scanner/GenericScanManager.h"
 
 AbstractScanResultProcessor::AbstractScanResultProcessor( GenericScanManager* manager, QObject* parent )
     : QObject( parent )
     , m_manager( manager )
     , m_type( GenericScanManager::PartialUpdateScan )
 {
     connect( manager, &GenericScanManager::started,
              this, &AbstractScanResultProcessor::scanStarted );
     connect( manager, &GenericScanManager::directoryCount,
              this, &AbstractScanResultProcessor::scanDirectoryCount );
     connect( manager, &GenericScanManager::directoryScanned,
              this, &AbstractScanResultProcessor::scanDirectoryScanned );
     connect( manager, &GenericScanManager::succeeded,
              this, &AbstractScanResultProcessor::scanSucceeded );
     connect( manager, &GenericScanManager::failed,
              this, &AbstractScanResultProcessor::scanFailed );
 }
 
 AbstractScanResultProcessor::~AbstractScanResultProcessor()
 {
     cleanupMembers();
 }
 
 void
 AbstractScanResultProcessor::scanStarted( GenericScanManager::ScanType type )
 {
     DEBUG_BLOCK;
 
     m_type = type;
 
     // -- show the progress operation for the job
     Amarok::Logger::newProgressOperation( this,
                                           i18n( "Scanning music" ),
                                           100,
                                           this,
                                           &AbstractScanResultProcessor::abort );
 
 }
 
 void
 AbstractScanResultProcessor::scanDirectoryCount( int count )
 {
     // message( i18np("Found one directory", "Found %1 directories", count ) );
     debug() << "got" << count << "directories";
     Q_EMIT totalSteps( count * 2 );
 }
 
 void
 AbstractScanResultProcessor::scanDirectoryScanned( QSharedPointer<CollectionScanner::Directory> dir )
 {
     m_directories.append( dir );
     Q_EMIT incrementProgress();
 }
 
 void
 AbstractScanResultProcessor::scanSucceeded()
 {
     DEBUG_BLOCK;
 
     // the default for albums with several artists is that it's a compilation
     // however, some album names are unlikely to be a compilation
     static QStringList nonCompilationAlbumNames;
     if( nonCompilationAlbumNames.isEmpty() )
     {
         nonCompilationAlbumNames
             << QLatin1String("") // don't throw together albums without name. At least not here
             << QStringLiteral("Best Of")
             << QStringLiteral("Anthology")
             << QStringLiteral("Hit collection")
             << QStringLiteral("Greatest Hits")
             << QStringLiteral("All Time Greatest Hits")
             << QStringLiteral("Live");
     }
 
     // -- commit the directories
     foreach( QSharedPointer<CollectionScanner::Directory> dir, m_directories )
     {
         commitDirectory( dir );
 
         // -- sort the tracks into albums
         QSet<CollectionScanner::Album*> dirAlbums;
         QSet<QString> dirAlbumNames;
         QList<CollectionScanner::Track*> tracks = dir->tracks();
 
         // check what album names we have
         foreach( CollectionScanner::Track* track, dir->tracks() )
         {
             if( !track->album().isEmpty() )
                 dirAlbumNames.insert( track->album() );
         }
 
         // use the directory name as album name
         QString fallbackAlbumName = ( dirAlbumNames.isEmpty() ?
                                       QDir( dir->path() ).dirName() :
                                       QString() );
 
         foreach( CollectionScanner::Track* track, dir->tracks() )
         {
             CollectionScanner::Album *album = sortTrack( track, fallbackAlbumName );
 
             dirAlbums.insert( album );
             dirAlbumNames.insert( track->album() );
         }
 
         // if all the tracks from this directory end up in one album
         // (or they have at least the same name) then it's likely that an image
         // from this directory could be a cover
         if( dirAlbumNames.count() == 1 )
             (*dirAlbums.begin())->setCovers( dir->covers() );
     }
 
     // --- add all albums
     QList<QString> keys = m_albumNames.uniqueKeys();
     Q_EMIT totalSteps( m_directories.count() + keys.count() ); // update progress bar
     foreach( const QString &key, keys )
     {
         // --- commit the albums as compilation or normal album
 
         QList<CollectionScanner::Album*> albums = m_albumNames.values( key );
 
         // if we have multiple albums with the same name, check if it
         // might be a compilation
         for( int i = albums.count() - 1; i >= 0; --i )
         {
             CollectionScanner::Album *album = albums.at( i );
             // commit all albums with a track with the noCompilation flag
             if( album->isNoCompilation() ||
                 nonCompilationAlbumNames.contains( album->name(), Qt::CaseInsensitive ) )
                 commitAlbum( albums.takeAt( i ) );
         }
 
         // only one album left. (that either means all have the same album artist tag
         // or none has one. In the last case we try to guess an album artist)
         if( albums.count() == 1 )
         {
             CollectionScanner::Album *album = albums.takeFirst();
 
             // look if all the tracks have the same (guessed) artist.
             // It's no compilation.
             bool isCompilation = false;
             bool firstTrack = true;
             QString albumArtist;
             foreach( CollectionScanner::Track *track, album->tracks() )
             {
                 QString trackAlbumArtist =
                     ArtistHelper::bestGuessAlbumArtist( track->albumArtist(),
                                                         track->artist(),
                                                         track->genre(),
                                                         track->composer() );
                 if( firstTrack )
                     albumArtist = trackAlbumArtist;
                 firstTrack = false;
 
                 if( trackAlbumArtist.isEmpty() || track->isCompilation() ||
                     albumArtist != trackAlbumArtist )
                     isCompilation = true;
             }
 
             if( !isCompilation )
                 album->setArtist( albumArtist );
             commitAlbum( album );
         }
 
         // several albums with different album artist.
         else if( albums.count() > 1 )
         {
             while( !albums.isEmpty() )
                 commitAlbum( albums.takeFirst() );
         }
 
         Q_EMIT incrementProgress();
     }
 
     // -- now check if some of the tracks are not longer used and also not moved to another directory
     foreach( QSharedPointer<CollectionScanner::Directory> dir, m_directories )
         if( !dir->isSkipped() )
             deleteDeletedTracksAndSubdirs( dir );
 
     // -- delete all not-found directories (special handling for PartialUpdateScan):
     deleteDeletedDirectories();
 
     cleanupMembers();
     Q_EMIT endProgressOperation( this );
 }
 
 void
 AbstractScanResultProcessor::scanFailed( const QString& text )
 {
     message( text );
 
     cleanupMembers();
     Q_EMIT endProgressOperation( this );
 }
 
 void
 AbstractScanResultProcessor::abort()
 {
     m_manager->abort();
 }
 
 void
 AbstractScanResultProcessor::commitDirectory( QSharedPointer<CollectionScanner::Directory> dir )
 {
     if( dir->path().isEmpty() )
     {
         warning() << "got directory with no path from the scanner, not adding";
         return;
     }
 
     // --- add all playlists
     foreach( const CollectionScanner::Playlist &playlist, dir->playlists() )
         commitPlaylist( playlist );
 }
 
 void
 AbstractScanResultProcessor::commitPlaylist( const CollectionScanner::Playlist &playlist )
 {
     // debug() << "commitPlaylist on " << playlist->path();
 
     if( The::playlistManager() )
         The::playlistManager()->import( QUrl::fromLocalFile( playlist.path() ) );
 }
 
 CollectionScanner::Album*
 AbstractScanResultProcessor::sortTrack( CollectionScanner::Track *track, const QString &dirName )
 {
     QString albumName = track->album();
 
     // we allow albums with empty name and nonempty artist, see bug 272471
     QString albumArtist = track->albumArtist();
     if( track->isCompilation() )
         albumArtist.clear();  // no album artist denotes a compilation
     if( track->isNoCompilation() && albumArtist.isEmpty() )
         albumArtist = ArtistHelper::bestGuessAlbumArtist( track->albumArtist(),
                                                           track->artist(),
                                                           track->genre(),
                                                           track->composer() );
 
     if( albumName.isEmpty() && albumArtist.isEmpty() ) // try harder to set at least one
         albumName = dirName;
 
     AlbumKey key( albumName, albumArtist );
 
     CollectionScanner::Album *album;
     if( m_albums.contains( key ) )
         album = m_albums.value( key );
     else
     {
         album = new CollectionScanner::Album( albumName, albumArtist );
         m_albums.insert( key, album );
         m_albumNames.insert( albumName, album );
     }
 
     album->addTrack( track );
     return album;
 }
 
 void
 AbstractScanResultProcessor::cleanupMembers()
 {
     // note: qt had problems with CLEAN_ALL macro
     QHash<QString, CollectionScanner::Album*>::const_iterator i = m_albumNames.constBegin();
     while (i != m_albumNames.constEnd()) {
         delete i.value();
         ++i;
     }
     m_albumNames.clear();
     m_albums.clear();
     m_directories.clear();
 }