Blocking operation in Qt Quick - c++

Question

I want to perform a long task when a button is clicked. I want this task to block the UI, because the application cannot function until the task is done. However, I want to indicate to the user that something is happening, so I have a BusyIndicator (that runs on the render thread) and is set to display before the operation begins. However, it never renders. Why?
main.cpp:
#include <QGuiApplication>
#include <QQmlApplicationEngine>
#include <QQmlContext>
#include <QDateTime>
#include <QDebug>
class Task : public QObject
{
Q_OBJECT
Q_PROPERTY(bool running READ running NOTIFY runningChanged)
public:
Task() : mRunning(false) {}
Q_INVOKABLE void run() {
qDebug() << "setting running property to true";
mRunning = true;
emit runningChanged();
// Try to ensure that the scene graph has time to begin the busy indicator
// animation on the render thread.
Q_ASSERT(QMetaObject::invokeMethod(this, "doRun", Qt::QueuedConnection));
}
bool running() const {
return mRunning;
}
signals:
void runningChanged();
private:
Q_INVOKABLE void doRun() {
qDebug() << "beginning long, blocking operation";
QDateTime start = QDateTime::currentDateTime();
while (start.secsTo(QDateTime::currentDateTime()) < 2) {
// Wait...
}
qDebug() << "finished long, blocking operation";
qDebug() << "setting running property to false";
mRunning = false;
emit runningChanged();
}
bool mRunning;
};
int main(int argc, char *argv[])
{
QGuiApplication app(argc, argv);
QQmlApplicationEngine engine;
Task task;
engine.rootContext()->setContextProperty("task", &task);
engine.load(QUrl(QStringLiteral("qrc:/main.qml")));
return app.exec();
}
#include "main.moc"
main.qml:
import QtQuick 2.6
import QtQuick.Window 2.2
import Qt.labs.controls 1.0
Window {
width: 600
height: 400
visible: true
Shortcut {
sequence: "Ctrl+Q"
onActivated: Qt.quit()
}
Column {
anchors.centerIn: parent
spacing: 20
Button {
text: task.running ? "Running task" : "Run task"
onClicked: task.run()
}
BusyIndicator {
anchors.horizontalCenter: parent.horizontalCenter
running: task.running
onRunningChanged: print("BusyIndicator running =", running)
}
}
}
The debugging output looks correct in terms of the order of events:
setting running property to true
qml: BusyIndicator running = true
beginning long, blocking operation
finished long, blocking operation
setting running property to false
qml: BusyIndicator running = false

Answer 1

Most animations in QML depends on properties managed in the main thread and are thus blocked when the main UI thread is blocked. Look into http://doc.qt.io/qt-5/qml-qtquick-animator.html for animations that can run when the main thread is blocked. If possible, I'd move the operation into another thread though, that's much simpler and also allows for e.g. cancellation of the operation from the UI.

Answer 2

Invoking a function with Qt::QueuedConnection doesn't guarantee that the BusyIndicator has had the chance to begin animating. It merely guarantees that:
The slot is invoked when control returns to the event loop of the receiver's thread.
Another solution that might sound promising is QTimer::singleShot():
QTimer::singleShot(0, this, SLOT(doRun()));
As a special case, a QTimer with a timeout of 0 will time out as soon as all the events in the window system's event queue have been processed. This can be used to do heavy work while providing a snappy user interface [...]
However, this also won't work. I'm not sure why. It could be that, internally, the rendering/animation is not done via a queued invocation, and so the timeout happens too early.
You could specify an arbitrary amount of time to wait:
QTimer::singleShot(10, this, SLOT(doRun()));
This will work, but it's not that nice; it's just guessing.
What you need is a reliable way of knowing when the scene graph has begun the animation.
main.cpp:
#include <QGuiApplication>
#include <QQmlApplicationEngine>
#include <QQmlContext>
#include <QDateTime>
#include <QDebug>
#include <QTimer>
#include <QQuickWindow>
class Task : public QObject
{
Q_OBJECT
Q_PROPERTY(bool running READ running NOTIFY runningChanged)
public:
Task(QObject *parent = 0) :
QObject(parent),
mRunning(false) {
}
signals:
void runningChanged();
public slots:
void run() {
qDebug() << "setting running property to true";
mRunning = true;
emit runningChanged();
QQmlApplicationEngine *engine = qobject_cast<QQmlApplicationEngine*>(parent());
QQuickWindow *window = qobject_cast<QQuickWindow*>(engine->rootObjects().first());
connect(window, SIGNAL(afterSynchronizing()), this, SLOT(doRun()));
}
bool running() const {
return mRunning;
}
private slots:
void doRun() {
qDebug() << "beginning long, blocking operation";
QDateTime start = QDateTime::currentDateTime();
while (start.secsTo(QDateTime::currentDateTime()) < 2) {
// Wait...
}
qDebug() << "finished long, blocking operation";
QQmlApplicationEngine *engine = qobject_cast<QQmlApplicationEngine*>(parent());
QQuickWindow *window = qobject_cast<QQuickWindow*>(engine->rootObjects().first());
disconnect(window, SIGNAL(afterSynchronizing()), this, SLOT(doRun()));
qDebug() << "setting running property to false";
mRunning = false;
emit runningChanged();
}
private:
bool mRunning;
};
int main(int argc, char *argv[])
{
QGuiApplication app(argc, argv);
QQmlApplicationEngine engine;
Task task(&engine);
engine.rootContext()->setContextProperty("task", &task);
engine.load(QUrl(QStringLiteral("qrc:/main.qml")));
return app.exec();
}
#include "main.moc"
main.qml:
import QtQuick 2.6
import QtQuick.Window 2.2
import Qt.labs.controls 1.0
Window {
width: 600
height: 400
visible: true
Shortcut {
sequence: "Ctrl+Q"
onActivated: Qt.quit()
}
Column {
anchors.centerIn: parent
spacing: 20
Button {
text: task.running ? "Running task" : "Run task"
onClicked: task.run()
}
BusyIndicator {
anchors.horizontalCenter: parent.horizontalCenter
running: task.running
onRunningChanged: print("BusyIndicator running =", running)
}
}
}
This solution relies on having access to the application window, which isn't that nice, but it eliminates any guesswork. Note that if we don't disconnect from the signal afterwards, it will continue to be called each time the scene graph has finished synchronising, so it's important to do this.
If you have several operations that will need this type of solution, consider creating a reusable class:
class BlockingTask : public QObject
{
Q_OBJECT
Q_PROPERTY(bool running READ running NOTIFY runningChanged)
public:
BlockingTask(QQmlApplicationEngine *engine) :
mEngine(engine),
mRunning(false) {
}
bool running() const {
return mRunning;
}
signals:
void runningChanged();
public slots:
void run() {
qDebug() << "setting running property to true";
mRunning = true;
emit runningChanged();
QQuickWindow *window = qobject_cast<QQuickWindow*>(mEngine->rootObjects().first());
connect(window, SIGNAL(afterSynchronizing()), this, SLOT(doRun()));
}
protected:
virtual void execute() = 0;
private slots:
void doRun() {
QQuickWindow *window = qobject_cast<QQuickWindow*>(mEngine->rootObjects().first());
disconnect(window, SIGNAL(afterSynchronizing()), this, SLOT(doRun()));
execute();
qDebug() << "setting running property to false";
mRunning = false;
emit runningChanged();
}
private:
QQmlApplicationEngine *mEngine;
bool mRunning;
};
Then, subclasses only have to worry about their logic:
class Task : public BlockingTask
{
Q_OBJECT
public:
Task(QQmlApplicationEngine *engine) :
BlockingTask(engine) {
}
protected:
void execute() Q_DECL_OVERRIDE {
qDebug() << "beginning long, blocking operation";
QDateTime start = QDateTime::currentDateTime();
while (start.secsTo(QDateTime::currentDateTime()) < 2) {
// Wait...
}
qDebug() << "finished long, blocking operation";
}
};