File indexing completed on 2024-09-29 07:24:44

 // SPDX-FileCopyrightText: 2018-2019 Black Hat <bhat@encom.eu.org>
 // SPDX-FileCopyrightText: 2019 Kitsune Ral <kitsune-ral@users.sf.net>
 // SPDX-License-Identifier: GPL-3.0-only
 
 #include "matriximageprovider.h"
 
 #include <QDebug>
 #include <QDir>
 #include <QFileInfo>
 #include <QStandardPaths>
 #include <QThread>
 
 #include <KLocalizedString>
 
 #include "neochatconnection.h"
 
 #include <Quotient/connection.h>
 
 using namespace Quotient;
 
 ThumbnailResponse::ThumbnailResponse(QString id, QSize size, NeoChatConnection *connection)
     : mediaId(std::move(id))
     , requestedSize(size)
     , localFile(QStringLiteral("%1/image_provider/%2-%3x%4.png")
                     .arg(QStandardPaths::writableLocation(QStandardPaths::CacheLocation),
                          mediaId,
                          QString::number(requestedSize.width()),
                          QString::number(requestedSize.height())))
     , m_connection(connection)
     , errorStr("Image request hasn't started"_ls)
 {
     if (requestedSize.isEmpty()) {
         requestedSize.setHeight(100);
         requestedSize.setWidth(100);
     }
     if (mediaId.count(QLatin1Char('/')) != 1) {
         if (mediaId.startsWith(QLatin1Char('/'))) {
             mediaId = mediaId.mid(1);
         } else {
             errorStr = i18n("Media id '%1' doesn't follow server/mediaId pattern", mediaId);
             Q_EMIT finished();
             return;
         }
     }
 
     mediaId = mediaId.split(QLatin1Char('?'))[0];
 
     QImage cachedImage;
     if (cachedImage.load(localFile)) {
         image = cachedImage;
         errorStr.clear();
         Q_EMIT finished();
         return;
     }
 
     if (!m_connection) {
         qWarning() << "Current connection is null";
         return;
     }
 
     // Execute a request on the main thread asynchronously
     moveToThread(m_connection->thread());
     QMetaObject::invokeMethod(this, &ThumbnailResponse::startRequest, Qt::QueuedConnection);
 }
 
 void ThumbnailResponse::startRequest()
 {
     if (!m_connection) {
         return;
     }
     // Runs in the main thread, not QML thread
     Q_ASSERT(QThread::currentThread() == m_connection->thread());
     job = m_connection->getThumbnail(mediaId, requestedSize);
     // Connect to any possible outcome including abandonment
     // to make sure the QML thread is not left stuck forever.
     connect(job, &BaseJob::finished, this, &ThumbnailResponse::prepareResult);
 }
 
 void ThumbnailResponse::prepareResult()
 {
     Q_ASSERT(QThread::currentThread() == job->thread());
     Q_ASSERT(job->error() != BaseJob::Pending);
     {
         QWriteLocker _(&lock);
         if (job->error() == BaseJob::Success) {
             image = job->thumbnail();
 
             QString localPath = QFileInfo(localFile).absolutePath();
             QDir dir;
             if (!dir.exists(localPath)) {
                 dir.mkpath(localPath);
             }
 
             image.save(localFile);
 
             errorStr.clear();
         } else if (job->error() == BaseJob::Abandoned) {
             errorStr = i18n("Image request has been cancelled");
             // qDebug() << "ThumbnailResponse: cancelled for" << mediaId;
         } else {
             errorStr = job->errorString();
             qWarning() << "ThumbnailResponse: no valid image for" << mediaId << "-" << errorStr;
         }
         job = nullptr;
     }
     Q_EMIT finished();
 }
 
 QQuickTextureFactory *ThumbnailResponse::textureFactory() const
 {
     QReadLocker _(&lock);
     return QQuickTextureFactory::textureFactoryForImage(image);
 }
 
 QString ThumbnailResponse::errorString() const
 {
     QReadLocker _(&lock);
     return errorStr;
 }
 
 QQuickImageResponse *MatrixImageProvider::requestImageResponse(const QString &id, const QSize &requestedSize)
 {
     return new ThumbnailResponse(id, requestedSize, m_connection);
 }
 
 #include "moc_matriximageprovider.cpp"