Best reviewed without whitespace changes.

Why do you want to keep an instance of the InitExecutor in the GUI thread?

• moveToThread is usually not called within the object;
• we don't need to hold on to the thread, we just need to call initialize and shutdown asynchronously, so we could also improve that;
• in QML it's not possible to connect/bind to objects in other threads, see Expose init executor instance gui-qml#37;

Concept ACK.

Sorry, I meant dropping __func__ part only, while keeping debugging messages that seem useful (at least for me).

No worries, done!

Code review ACK

Code review ACK 03a5fe0. Having InitExecutor associated with the GUI thread seems to be necessary in order to be able to write Connections { target: initExecutor ... } in QML.

But this seems like an overly complicated design because now instead of InitExecutor just being an QObject/QThread couple it is QObject/QThread/nested QObject throuple with two QObjects (this and this->m_context) each QObject connected to different thread.

It seems like a mistake here is letting QML code be aware of the InitExecutor object at all. Probably QML could should just be sending / receiving init events to and from a node or application object. QML code should not care about how init code executes or whether or not there is an executor. QML code should just be saying "hey bitcoin application, please start initializing and send the initialization result to this place", not "hey bitcoin application, give me your init executor, and init exector, please start initializing and send the result to this place".

@ryanofsky thanks for taking a look.

But this seems like an overly complicated design because now instead of InitExecutor just being an QObject/QThread couple it is QObject/QThread/nested QObject throuple with two QObjects (this and this->m_context) each QObject connected to different thread.

Implementation can change - how it runs async code. Personally, I don't think holding the thread makes sense, it's not used while the app runs.

It seems like a mistake here is letting QML code be aware of the InitExecutor object at all. Probably QML could should just be sending / receiving init events to and from a node or application object. QML code should not care about how init code executes or whether or not there is an executor. QML code should just be saying "hey bitcoin application, please start initializing and send the initialization result to this place", not "hey bitcoin application, give me your init executor, and init exector, please start initializing and send the result to this place".

We need one or some objects to bind to but I don't think the application is the best candidate. We could have some fat object with all properties and signals and just expose it. Later we could split that fat object into multiple objects and expose them.

In fact, QML allows different approaches. What you and @hebasto suggest seems to be https://doc.qt.io/archives/qt-5.9/qtqml-cppintegration-contextproperties.html. On the other hand, I'd prefer to follow https://doc.qt.io/archives/qt-5.9/qtqml-cppintegration-definetypes.html.

Following the example you mention, I was thinking something like:

InitExecutor {
    id: executor
}

Loader {
    active: executor.ready
    sourceComponent: MySuperInterface {
    }
}

Button {
    text: "start"
    onClicked: executor.initialize()
}

This seems preferable for multiple reasons:

• no dependencies from context variables or the application
• stuff is constructed when needed, with property bindings to/from relevant places
• simplifies testing because it could mock InitExecutor

I don't think this violates any principle. In this case, we still have the init/shutdown logic implemented in C++ and the UI in QML.

But I'm fine with any approach, I'm just expressing my preference. Regardless of how we structure the work in QML, I think InitExecutor still needs to be improved.

I've linked to this discussion from bitcoin-core/gui-qml#37, and suggesting to continue it there.