With asynchronous commands we have typical commands from the Model View ViewModel world that return asynchronously.
Whenever that happens we want result reporting and progress reporting. We basically want something like this in QML:
Item {
id: container
property ViewModel viewModel: ViewModel {}
Connections {
target: viewModel.asyncHelloCommand
onExecuteProgressed: {
progressBar.value = value
progressBar.maximumValue = maximum
}
}
ProgressBar {
id: progressBar
}
Button {
enabled: viewModel.asyncHelloCommand.canExecute
onClicked: viewModel.asyncHelloCommand.execute()
}
}
How do we do this? First we start with defining a AbstractAsyncCommand (impl. of protected APIs here):
class AbstractAsyncCommand : public AbstractCommand {
Q_OBJECT
public:
AbstractAsyncCommand(QObject *parent=0);
Q_INVOKABLE virtual QFuture<void*> executeAsync() = 0;
virtual void execute() Q_DECL_OVERRIDE;
signals:
void executeFinished(void* result);
void executeProgressed(int value, int maximum);
protected:
QSharedPointer<QFutureInterface<void*>> start();
void progress(QSharedPointer<QFutureInterface<void*>> fut, int value, int total);
void finish(QSharedPointer<QFutureInterface<void*>> fut, void* result);
private:
QVector<QSharedPointer<QFutureInterface<void*>>> m_futures;
};
After that we provide an implementation:
#include <QThreadPool>
#include <QRunnable>
#include <MVVM/Commands/AbstractAsyncCommand.h>
class AsyncHelloCommand: public AbstractAsyncCommand
{
Q_OBJECT
public:
AsyncHelloCommand(QObject *parent=0);
bool canExecute() const Q_DECL_OVERRIDE { return true; }
QFuture<void*> executeAsync() Q_DECL_OVERRIDE;
private:
void* executeAsyncTaskFunc();
QSharedPointer<QFutureInterface<void*>> current;
QMutex mutex;
};
#include "asynchellocommand.h"
#include <QtConcurrent/QtConcurrent>
AsyncHelloCommand::AsyncHelloCommand(QObject* parent)
: AbstractAsyncCommand(parent) { }
void* AsyncHelloCommand::executeAsyncTaskFunc()
{
for (int i=0; i<10; i++) {
QThread::sleep(1);
qDebug() << "Hello Async!";
mutex.lock();
progress(current, i, 10);
mutex.unlock();
}
return nullptr;
}
QFuture<void*> AsyncHelloCommand::executeAsync()
{
mutex.lock();
current = start();
QFutureWatcher<void*>* watcher = new QFutureWatcher<void*>(this);
connect(watcher, &QFutureWatcher<void*>::progressValueChanged, this, [=]{
mutex.lock();
progress(current, watcher->progressValue(), watcher->progressMaximum());
mutex.unlock();
});
connect(watcher, &QFutureWatcher<void*>::finished, this, [=]{
void* result=watcher->result();
mutex.lock();
finish(current, result);
mutex.unlock();
watcher->deleteLater();
});
watcher->setFuture(QtConcurrent::run(this, &AsyncHelloCommand::executeAsyncTaskFunc));
QFuture<void*> future = current->future();
mutex.unlock();
return future;
}
You can find the complete working example here.
