blame: src/thumbnailcache.cpp

#include "thumbnailcache.h"

#include <QCryptographicHash>

#include <QDir>

#include <QFile>

#include <QFileInfo>

#include <QMimeDatabase>

#include <QStandardPaths>

#include <QTemporaryFile>

#include <QUrl>

namespace

{

constexpr const char *kSoftware = "SagoImageBrowser";

QFile::Permissions filePerms()

{

    return QFile::ReadOwner | QFile::WriteOwner;

}

QFile::Permissions dirPerms()

{

    return QFile::ReadOwner | QFile::WriteOwner | QFile::ExeOwner;

}

} // namespace

QString ThumbnailCache::cacheRoot()

{

    QString base = QStandardPaths::writableLocation(QStandardPaths::GenericCacheLocation);

    if (base.isEmpty())

        base = QDir::homePath() + "/.cache";

    return base + "/thumbnails";

}

QString ThumbnailCache::subdirFor(Size size)

{

    const char *name = (size == Size::Large) ? "large" : "normal";

    return cacheRoot() + "/" + name;

}

QString ThumbnailCache::canonicalUri(const QString &absPath)

{

    // Per the spec, use the absolute file URI (percent-encoded).

    return QUrl::fromLocalFile(absPath).toString(QUrl::FullyEncoded);

}

QString ThumbnailCache::hashedName(const QString &canonicalUri)

{

    QByteArray hash = QCryptographicHash::hash(canonicalUri.toUtf8(),

                                               QCryptographicHash::Md5)

                          .toHex();

    return QString::fromLatin1(hash) + ".png";

}

bool ThumbnailCache::isInsideCache(const QString &absPath)

{

    QString abs = QFileInfo(absPath).absoluteFilePath();

    QString root = QFileInfo(cacheRoot()).absoluteFilePath();

    if (root.isEmpty())

        return false;

    return abs.startsWith(root + "/") || abs == root;

}

QImage ThumbnailCache::load(const QString &sourcePath, Size size)

{

    QFileInfo info(sourcePath);

    if (!info.exists() || !info.isFile())

        return {};

    const QString uri = canonicalUri(info.absoluteFilePath());

    const QString cachePath = subdirFor(size) + "/" + hashedName(uri);

    QImage img;

    if (!img.load(cachePath, "PNG"))

        return {};

    const qint64 mtime = info.lastModified().toSecsSinceEpoch();

    bool ok = false;

    const qint64 cachedMTime = img.text("Thumb::MTime").toLongLong(&ok);

    if (!ok || cachedMTime != mtime)

        return {};

    return img;

}

void ThumbnailCache::save(const QString &sourcePath, Size size, const QImage &thumbImage)

{

    if (thumbImage.isNull())

        return;

    QFileInfo info(sourcePath);

    if (!info.exists() || !info.isFile())

        return;

    const QString uri = canonicalUri(info.absoluteFilePath());

    const QString subdir = subdirFor(size);

    const QString finalPath = subdir + "/" + hashedName(uri);

    QDir dir;

    if (!dir.mkpath(subdir))

        return;

    QFile::setPermissions(subdir, dirPerms());

    QFile::setPermissions(cacheRoot(), dirPerms());

    QImage tagged = thumbImage;

    tagged.setText("Thumb::URI", uri);

    tagged.setText("Thumb::MTime",

                   QString::number(info.lastModified().toSecsSinceEpoch()));

    tagged.setText("Thumb::Size", QString::number(info.size()));

    QMimeDatabase mimeDb;

    QString mime = mimeDb.mimeTypeForFile(info).name();

    if (!mime.isEmpty())

        tagged.setText("Thumb::Mimetype", mime);

    tagged.setText("Thumb::Image::Width", QString::number(thumbImage.width()));

    tagged.setText("Thumb::Image::Height", QString::number(thumbImage.height()));

    tagged.setText("Software", QString::fromLatin1(kSoftware));

    QTemporaryFile tmp(subdir + "/tmp_XXXXXX.png");

    tmp.setAutoRemove(false);

    if (!tmp.open())

        return;

    const QString tmpPath = tmp.fileName();

    tmp.close();

    if (!tagged.save(tmpPath, "PNG"))

    {

        QFile::remove(tmpPath);

        return;

    }

    QFile::setPermissions(tmpPath, filePerms());

    // Atomic replace: remove existing target then rename.

    QFile::remove(finalPath);

    if (!QFile::rename(tmpPath, finalPath))

        QFile::remove(tmpPath);

}