Waiting for a signal within a Qquickimageprovider

Question

I’m creating an application using QML and the Qt 5.2. In her a ListView displays multiple items, each with an image and associated text. The image is built based on data uploaded from a server by HTTP. Simply put, I have the following code:

MyProvider::MyProvider() :
    QQuickImageProvider(QQmlImageProviderBase::Image,
                        QQmlImageProviderBase::ForceAsynchronousImageLoading)
{ }

QImage MyProvider::requestImage(const QString& id, QSize* size, const QSize& requestedSize)
{
    // Obter dados JSON que me explicam como montar a imagem
    QNetworkAccessManager manager;
    QNetworkRequest request(QUrl("http://myserver.com/api/imagedata/" + id));
    request.setRawHeader("Accept", "application/json");
    QNetworkReply* reply = manager.get(request);

    // Aguardar pela resposta. Aqui está o problema
    QEventLoop loop;
    QObject::connect(reply, SIGNAL(finished()), &loop, SLOT(quit()));
    loop.exec();

    // Ler a resposta e montar uma imagem com ela
    QImage img = produceImageFromJsonData(reply->readAll());
    delete reply;

    // Ajustar para o tamanho requisitado
    if (requestedSize.isValid())
        img = img.scaled(requestedSize, Qt::KeepAspectRatio, Qt::SmoothTransformation);
    *size = img.size();
    return img;
}

The MyProvider is then recorded and used in QML as source of each Image from the list. The problem with this code is that there is a race condition in it. The requestImage is executed in a thread different from the rest of the application. At the moment I create a QEventLoop and run it, I’m allowing my thread to receive and process any event occurring. Since there can be more than one thread running this loop, two events can be sent to the same object at the same time by different threads. I get a crash difficult to reproduce (it happened for the first time today, after almost a month of development).

The problem can also be reproduced with this smaller code, showing that the simple existence of a QEventLoop triggers the crash:

MyProvider::MyProvider() :
    QQuickImageProvider(QQmlImageProviderBase::Image,
                        QQmlImageProviderBase::ForceAsynchronousImageLoading)
{ }

QImage MyProvider::requestImage(const QString& id, QSize* size, const QSize& requestedSize)
{
    QEventLoop loop;
    loop.exec();
    return QImage();
}

I found a bugreport what date of the Qt 4.7.1 where the following is said:

The problem is that the QEventLoop that is created in the imageprovider causes Events to be Delivered to the image Reader which shares the thread. It receives These Events while still Processing a Previous Event. [...] It is not Valid to run an Event loop in the image Provider.

In short, I cannot use the QEventLoop in my role. So how can I wait for the QNetworkReply and only return from the function when the answer arrives?

Answer 1

I don’t know how to wait for the signal there. It is also not possible to make the thread sleep in a loop by checking if the data arrived manually because the QNetworkReply depends on the Event loop to be notified of receipt of the reply.

---

So I went to a different implementation of the same idea. Instead of creating an image provider and letting the engine take care of everything in place, I chose to do it more manually.

Previous interface:

Image {
  id: avatar
  source: "image://myimageprovider/" + avatarImageId
}

New interface:

Image {
  id: avatar
}

MyImageLoader {
  sourceId: avatarImageId
  target: avatar
}

My goal has become to implement the component MyImageLoader so that I did the desired operation. Follow my implementation:

myimageloader.hpp:

class MyImageLoader : public QObject {
    Q_OBJECT
    Q_PROPERTY(QString sourceId READ sourceId WRITE setSourceId)
    Q_PROPERTY(QObject* target READ target WRITE setTarget)

public:
    MyImageLoader(QObject* parent = 0) : QObject(parent) {}

    QString sourceId() const { return _sourceId; }
    void setSourceId(const QString& sourceId) { _sourceId = sourceId; beginDownload(); }

    QObject* target() const { return _target; }
    void setTarget(QObject* target) {_target = target; setTargetSource(); }

private:
    void beginDownload();
    void endDownload();
    void setTargetSource();
    QString cacheFile();

    QNetworkAccessManager _manager;
    QNetworkReply* _reply = nullptr;
    QString _sourceId;
    QObject* _target = nullptr;
};

myimageloader.cpp:

void MyImageLoader::beginDownload() {
    if (QFile::exists(cacheFile()))
        return setTargetSource();

    delete _reply;
    QNetworkRequest request(QUrl("http://myserver.com/api/imagedata/" + _sourceId));
    request.setRawHeader("Accept", "application/json");
    _reply = _manager.get(request);
    connect(_reply, &QNetworkReply::finished, this, &MyImageLoader::endDownload);
}

void MyImageLoader::endDownload() {
    QImage img = produceImageFromJsonData(_reply->readAll());
    delete _reply;
    img.save(cacheFile());
    setTargetSource();
}

void MyImageLoader::setTargetSource() {
    if (!_target) return;

    QString file = cacheFile();
    _target->setProperty("source", QFile::exists(file) ? "file:///" + file : "");
}

QString MyImageLoader::cacheFile() {
    return QDir::temp().filePath(_sourceId + ".png");
}

The big difference is that I’m not using threads. It all takes place in a single thread (the same one that renders the scene). There is no locking of the interface while loading on account of the signals. All these functions return immediately and do not lock.

The downside is that I’m forced to save the image in a file. It’s not a problem for me, since I planned to cache the data anyway.

That doesn’t answer the question itself, but it solves my problem.