File indexing completed on 2023-05-30 11:30:45

 /**
  * Copyright (C) 2005, 2008 Michael Pyne <mpyne@kde.org>
  *
  * 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/>.
  */
 
 #include "covermanager.h"
 
 #include <QByteArray>
 #include <QDataStream>
 #include <QDir>
 #include <QFile>
 #include <QHash>
 #include <QMap>
 #include <QPixmap>
 #include <QPixmapCache>
 #include <QStandardPaths>
 #include <QString>
 #include <QTemporaryFile>
 #include <QTimer>
 #include <QUrl>
 
 #include <kio/job.h>
 
 #include "juk.h"
 #include "coverproxy.h"
 #include "juk_debug.h"
 
 // This is a dictionary to map the track path to their ID.  Otherwise we'd have
 // to store this info with each CollectionListItem, which would break the cache
 // of users who upgrade, and would just generally be a big mess.
 typedef QHash<QString, coverKey> TrackLookupMap;
 
 static const char dragMimetype[] = "application/x-juk-coverid";
 
 const coverKey CoverManager::NoMatch = 0;
 
 // Used to save and load CoverData from a QDataStream
 QDataStream &operator<<(QDataStream &out, const CoverData &data);
 QDataStream &operator>>(QDataStream &in, CoverData &data);
 
 //
 // Implementation of CoverSaveHelper class
 //
 
 CoverSaveHelper::CoverSaveHelper(QObject *parent) :
     QObject(parent),
     m_timer(new QTimer(this))
 {
     connect(m_timer, SIGNAL(timeout()), SLOT(commitChanges()));
 
     // Wait 5 seconds before committing to avoid lots of disk activity for
     // rapid changes.
 
     m_timer->setSingleShot(true);
     m_timer->setInterval(5000);
 }
 
 void CoverSaveHelper::saveCovers()
 {
     m_timer->start(); // Restarts if already triggered.
 }
 
 void CoverSaveHelper::commitChanges()
 {
     CoverManager::saveCovers();
 }
 
 //
 // Implementation of CoverData struct
 //
 
 QPixmap CoverData::pixmap() const
 {
     return CoverManager::coverFromData(*this, CoverManager::FullSize);
 }
 
 QPixmap CoverData::thumbnail() const
 {
     return CoverManager::coverFromData(*this, CoverManager::Thumbnail);
 }
 
 /**
  * This class is responsible for actually keeping track of the storage for the
  * different covers and such.  It holds the covers, and the map of path names
  * to cover ids, and has a few utility methods to load and save the data.
  *
  * @author Michael Pyne <mpyne@kde.org>
  * @see CoverManager
  */
 class CoverManagerPrivate
 {
 public:
 
     /// Maps coverKey id's to CoverData
     CoverDataMap covers;
 
     /// Maps file names to coverKey id's.
     TrackLookupMap tracks;
 
     /// A map of outstanding download KJobs to their coverKey
     QMap<KJob*, coverKey> downloadJobs;
 
     /// A static pixmap cache is maintained for covers, with key format of:
     /// 'f' followed by the pathname for FullSize covers, and
     /// 't' followed by the pathname for Thumbnail covers.
     /// However only thumbnails are currently cached.
 
     CoverManagerPrivate() : m_timer(new CoverSaveHelper(0)), m_coverProxy(0)
     {
         loadCovers();
     }
 
     ~CoverManagerPrivate()
     {
         delete m_timer;
         delete m_coverProxy;
         saveCovers();
     }
 
     void requestSave()
     {
         m_timer->saveCovers();
     }
 
     /**
      * Creates the data directory for the covers if it doesn't already exist.
      * Must be in this class for loadCovers() and saveCovers().
      */
     void createDataDir() const;
 
     /**
      * Returns the next available unused coverKey that can be used for
      * inserting new items.
      *
      * @return unused id that can be used for new CoverData
      */
     coverKey nextId() const;
 
     void saveCovers() const;
 
     CoverProxy *coverProxy() {
         if(!m_coverProxy)
             m_coverProxy = new CoverProxy;
         return m_coverProxy;
     }
 
     private:
     void loadCovers();
 
     /**
      * @return the full path and filename of the file storing the cover
      * lookup map and the translations between pathnames and ids.
      */
     QString coverLocation() const;
 
     CoverSaveHelper *m_timer;
 
     CoverProxy *m_coverProxy;
 };
 
 // This is responsible for making sure that the CoverManagerPrivate class
 // gets properly destructed on shutdown.
 Q_GLOBAL_STATIC(CoverManagerPrivate, sd)
 
 //
 // Implementation of CoverManagerPrivate methods.
 //
 void CoverManagerPrivate::createDataDir() const
 {
     QDir dir;
     QString dirPath(QDir::cleanPath(coverLocation() + "/.."));
     dir.mkpath(dirPath);
 }
 
 void CoverManagerPrivate::saveCovers() const
 {
     // Make sure the directory exists first.
     createDataDir();
 
     QFile file(coverLocation());
 
     qCDebug(JUK_LOG) << "Opening covers db: " << coverLocation();
 
     if(!file.open(QIODevice::WriteOnly)) {
         qCCritical(JUK_LOG) << "Unable to save covers to disk!\n";
         return;
     }
 
     QDataStream out(&file);
 
     // Write out the version and count
     out << quint32(0) << quint32(covers.size());
 
     qCDebug(JUK_LOG) << "Writing out" << covers.size() << "covers.";
 
     // Write out the data
     for(const auto &it : covers) {
         out << quint32(it.first);
         out << it.second;
     }
 
     // Now write out the track mapping.
     out << quint32(tracks.count());
 
     qCDebug(JUK_LOG) << "Writing out" << tracks.count() << "tracks.";
 
     TrackLookupMap::ConstIterator trackMapIt = tracks.constBegin();
     while(trackMapIt != tracks.constEnd()) {
         out << trackMapIt.key() << quint32(trackMapIt.value());
         ++trackMapIt;
     }
 }
 
 void CoverManagerPrivate::loadCovers()
 {
     QFile file(coverLocation());
 
     if(!file.open(QIODevice::ReadOnly)) {
         // Guess we don't have any covers yet.
         return;
     }
 
     QDataStream in(&file);
     quint32 count, version;
 
     // First thing we'll read in will be the version.
     // Only version 0 is defined for now.
     in >> version;
     if(version > 0) {
         qCCritical(JUK_LOG) << "Cover database was created by a higher version of JuK,\n";
         qCCritical(JUK_LOG) << "I don't know what to do with it.\n";
 
         return;
     }
 
     // Read in the count next, then the data.
     in >> count;
 
     qCDebug(JUK_LOG) << "Loading" << count << "covers.";
     for(quint32 i = 0; i < count; ++i) {
         // Read the id, and 3 QStrings for every 1 of the count.
         quint32 id;
         CoverData data;
 
         in >> id;
         in >> data;
         data.refCount = 0;
 
         covers[(coverKey) id] = data;
     }
 
     in >> count;
     qCDebug(JUK_LOG) << "Loading" << count << "tracks";
     for(quint32 i = 0; i < count; ++i) {
         QString path;
         quint32 id;
 
         in >> path >> id;
 
         // If we somehow already managed to load a cover id with this path,
         // don't do so again.  Possible due to a coding error during 3.5
         // development.
 
         if(Q_LIKELY(!tracks.contains(path))) {
             ++covers[(coverKey) id].refCount; // Another track using this.
             tracks.insert(path, id);
         }
     }
 
     qCDebug(JUK_LOG) << "Tracks hash table has" << tracks.size() << "entries.";
 }
 
 QString CoverManagerPrivate::coverLocation() const
 {
     return QStandardPaths::writableLocation(QStandardPaths::AppLocalDataLocation)
             + "coverdb/covers";
 }
 
 coverKey CoverManagerPrivate::nextId() const
 {
     // Start from 1...
     coverKey key = 1;
 
     while(covers.find(key) != covers.end())
         ++key;
 
     return key;
 }
 
 //
 // Implementation of CoverDrag
 //
 CoverDrag::CoverDrag(coverKey id) :
     QMimeData()
 {
     QPixmap cover = CoverManager::coverFromId(id);
     setImageData(cover.toImage());
     setData(dragMimetype, QByteArray::number(qulonglong(id), 10));
 }
 
 bool CoverDrag::isCover(const QMimeData *data)
 {
     return data->hasImage() || data->hasFormat(dragMimetype);
 }
 
 coverKey CoverDrag::idFromData(const QMimeData *data)
 {
     bool ok = false;
 
     if(!data->hasFormat(dragMimetype))
         return CoverManager::NoMatch;
 
     coverKey id = data->data(dragMimetype).toULong(&ok);
     if(!ok)
         return CoverManager::NoMatch;
 
     return id;
 }
 
 const char *CoverDrag::mimetype()
 {
     return dragMimetype;
 }
 
 //
 // Implementation of CoverManager methods.
 //
 coverKey CoverManager::idFromMetadata(const QString &artist, const QString &album)
 {
           CoverDataMap::const_iterator it    = begin();
     const CoverDataMap::const_iterator endIt = end();
 
     for(; it != endIt; ++it) {
         if(it->second.album == album.toLower() && it->second.artist == artist.toLower())
             return it->first;
     }
 
     return NoMatch;
 }
 
 QPixmap CoverManager::coverFromId(coverKey id, Size size)
 {
     const auto &info = data()->covers.find(id);
     if(info == data()->covers.end())
         return QPixmap();
 
     if(size == Thumbnail)
         return info->second.thumbnail();
 
     return info->second.pixmap();
 }
 
 QPixmap CoverManager::coverFromData(const CoverData &coverData, Size size)
 {
     QString path = coverData.path;
 
     // Prepend a tag to the path to separate in the cache between full size
     // and thumbnail pixmaps.  If we add a different kind of pixmap in the
     // future we also need to add a tag letter for it.
     if(size == FullSize)
         path.prepend('f');
     else
         path.prepend('t');
 
     // Check in cache for the pixmap.
 
     QPixmap pix;
     if(QPixmapCache::find(path, &pix))
         return pix;
 
     // Not in cache, load it and add it.
 
     if(!pix.load(coverData.path))
         return QPixmap();
 
     // Only thumbnails are cached to avoid depleting global cache.  Caching
     // full size pics is not really useful as they are infrequently shown.
 
     if(size == Thumbnail) {
         // Double scale is faster and 99% as accurate
         QSize newSize(pix.size());
         newSize.scale(80, 80, Qt::KeepAspectRatio);
         pix = pix.scaled(2 * newSize)
                  .scaled(newSize, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
         QPixmapCache::insert(path, pix);
     }
 
     return pix;
 }
 
 coverKey CoverManager::addCover(const QPixmap &large, const QString &artist, const QString &album)
 {
     qCDebug(JUK_LOG) << "Adding new pixmap to cover database.";
     if(large.isNull()) {
         qCDebug(JUK_LOG) << "The pixmap you're trying to add is NULL!";
         return NoMatch;
     }
 
     QTemporaryFile tempFile;
     if(!tempFile.open() || !large.save(tempFile.fileName(), "PNG")) {
         qCCritical(JUK_LOG) << "Unable to save pixmap to " << tempFile.fileName();
         return NoMatch;
     }
 
     return addCover(QUrl::fromLocalFile(tempFile.fileName()), artist, album);
 }
 
 coverKey CoverManager::addCover(const QUrl &path, const QString &artist, const QString &album)
 {
     coverKey id = data()->nextId();
     CoverData coverData;
 
     QString fileNameExt = path.fileName();
     int extPos = fileNameExt.lastIndexOf('.');
 
     fileNameExt = fileNameExt.mid(extPos);
     if(extPos == -1)
         fileNameExt = "";
 
     // Copy it to a local file first.
 
     QString ext = QString("/coverdb/coverID-%1%2").arg(id).arg(fileNameExt);
     coverData.path = QStandardPaths::writableLocation(QStandardPaths::AppLocalDataLocation)
             + ext;
     qCDebug(JUK_LOG) << "Saving pixmap to " << coverData.path;
     data()->createDataDir();
 
     coverData.artist = artist.toLower();
     coverData.album = album.toLower();
     coverData.refCount = 0;
 
     data()->covers.emplace(id, coverData);
 
     // Can't use NetAccess::download() since if path is already a local file
     // (which is possible) then that function will return without copying, since
     // it assumes we merely want the file on the hard disk somewhere.
 
     KIO::FileCopyJob *job = KIO::file_copy(
          path, QUrl::fromLocalFile(coverData.path),
          -1 /* perms */, KIO::HideProgressInfo | KIO::Overwrite
          );
     QObject::connect(job, SIGNAL(result(KJob*)),
                      data()->coverProxy(), SLOT(handleResult(KJob*)));
     data()->downloadJobs.insert(job, id);
 
     job->start();
 
     data()->requestSave(); // Save changes when possible.
 
     return id;
 }
 
 /**
  * This is called when our cover downloader has completed.  Typically there
  * should be no issues so we just need to ensure that the newly downloaded
  * cover is picked up by invalidating any cache entry for it.  If it didn't
  * download successfully we're in kind of a pickle as we've already assigned
  * a coverKey, which we need to go and erase.
  */
 void CoverManager::jobComplete(KJob *job, bool completedSatisfactory)
 {
     coverKey id = NoMatch;
     if(data()->downloadJobs.contains(job))
         id = data()->downloadJobs[job];
 
     if(id == NoMatch) {
         qCCritical(JUK_LOG) << "No information on what download job" << job << "is.";
         data()->downloadJobs.remove(job);
         return;
     }
 
     if(!completedSatisfactory) {
         qCCritical(JUK_LOG) << "Job" << job << "failed, but not handled yet.";
         removeCover(id);
         data()->downloadJobs.remove(job);
         JuK::JuKInstance()->coverDownloaded(QPixmap());
         return;
     }
 
     CoverData coverData = data()->covers[id];
 
     // Make sure the new cover isn't inadvertently cached.
     QPixmapCache::remove(QString("f%1").arg(coverData.path));
     QPixmapCache::remove(QString("t%1").arg(coverData.path));
 
     JuK::JuKInstance()->coverDownloaded(coverFromData(coverData, CoverManager::Thumbnail));
 }
 
 bool CoverManager::hasCover(coverKey id)
 {
     return data()->covers.find(id) != data()->covers.end();
 }
 
 bool CoverManager::removeCover(coverKey id)
 {
     if(!hasCover(id))
         return false;
 
     // Remove cover from cache.
     CoverData coverData = coverInfo(id);
     QPixmapCache::remove(QString("f%1").arg(coverData.path));
     QPixmapCache::remove(QString("t%1").arg(coverData.path));
 
     // Remove references to files that had that track ID.
     QList<QString> affectedFiles = data()->tracks.keys(id);
     foreach (const QString &file, affectedFiles) {
         data()->tracks.remove(file);
     }
 
     // Remove covers from disk.
     QFile::remove(coverData.path);
 
     // Finally, forget that we ever knew about this cover.
     data()->covers.erase(id);
     data()->requestSave();
 
     return true;
 }
 
 bool CoverManager::replaceCover(coverKey id, const QPixmap &large)
 {
     if(!hasCover(id))
         return false;
 
     CoverData coverData = coverInfo(id);
 
     // Empty old pixmaps from cache.
     QPixmapCache::remove(QString("t%1").arg(coverData.path));
     QPixmapCache::remove(QString("f%1").arg(coverData.path));
 
     large.save(coverData.path, "PNG");
 
     // No save is needed, as all that has changed is the on-disk cover data,
     // not the list of tracks or covers.
 
     return true;
 }
 
 CoverManagerPrivate *CoverManager::data()
 {
     return sd;
 }
 
 void CoverManager::saveCovers()
 {
     data()->saveCovers();
 }
 
 CoverDataMapIterator CoverManager::begin()
 {
     return data()->covers.begin();
 }
 
 CoverDataMapIterator CoverManager::end()
 {
     return data()->covers.end();
 }
 
 void CoverManager::setIdForTrack(const QString &path, coverKey id)
 {
     coverKey oldId = data()->tracks.value(path, NoMatch);
     if(data()->tracks.contains(path) && (id == oldId))
         return; // We're already done.
 
     if(oldId != NoMatch) {
         data()->covers[oldId].refCount--;
         data()->tracks.remove(path);
 
         if(data()->covers[oldId].refCount == 0) {
             qCDebug(JUK_LOG) << "Cover " << oldId << " is unused, removing.\n";
             removeCover(oldId);
         }
     }
 
     if(id != NoMatch) {
         data()->covers[id].refCount++;
         data()->tracks.insert(path, id);
     }
 
     data()->requestSave();
 }
 
 coverKey CoverManager::idForTrack(const QString &path)
 {
     return data()->tracks.value(path, NoMatch);
 }
 
 CoverData CoverManager::coverInfo(coverKey id)
 {
     if(hasCover(id))
         return data()->covers[id];
 
     // TODO throw new something or other
     return CoverData{};
 }
 
 /**
  * Write @p data out to @p out.
  *
  * @param out the data stream to write @p data out to.
  * @param data the CoverData to write out.
  * @return the data stream that the data was written to.
  */
 QDataStream &operator<<(QDataStream &out, const CoverData &data)
 {
     out << data.artist;
     out << data.album;
     out << data.path;
 
     return out;
 }
 
 /**
  * Read @p data from @p in.
  *
  * @param in the data stream to read from.
  * @param data the CoverData to read into.
  * @return the data stream read from.
  */
 QDataStream &operator>>(QDataStream &in, CoverData &data)
 {
     in >> data.artist;
     in >> data.album;
     in >> data.path;
 
     return in;
 }
 
 // vim: set et sw=4 tw=0 sta: