Échange de langages Qt pour Android

package org.qtproject.example.androidlanguageexchange;

public class JavaExchanger
{
    private long mCppExchanger;

    private native void connectToCppExchanger(long cppExchanger);
    private native void fromOther(long cppExchanger, String str);

    public JavaExchanger(long cppExchanger) {
        mCppExchanger = cppExchanger;
        connectToCppExchanger(cppExchanger);
    }
    public void fromCpp(int type, String str) {
        if (type == OtherLanguageType.Java.getCode()) {
            String msg = str + " And hello back to you from\nJava!";
            fromOther(mCppExchanger, msg);
        }
    }
}

package org.qtproject.example.androidlanguageexchange;

class KotlinExchanger(private val cppExchanger: Long) {

    private external fun connectToCppExchanger(cppExchanger: Long)
    private external fun fromOther(cppExchanger: Long, str: String)

    init {
        connectToCppExchanger(cppExchanger)
    }

    fun fromCpp(type: Int, str: String) {
        if (type == OtherLanguageType.Kotlin.code) {
            val msg = "$str And hello back to you from\nKotlin!"
            fromOther(cppExchanger, msg)
        }
    }
}

// A simple data exchanger. All this class does is convey semi-abstract data
// back and forth. For the purposes of this example, treat it as an opaque
// and not necessarily modifiable engine object that just happens to have
// a signal that's directly consumable by the code in other languages. The
// rest of the glue is done in OtherLanguageHandler.
class DataExchanger : public QObject
{
    Q_OBJECT
public:
    explicit DataExchanger(QObject *parent = nullptr);

    enum OtherLanguageType {Java, Kotlin};
signals:
    void fromCpp(OtherLanguageType type, const QString& str);
    void fromOther(const QString& str);
};

// We provide this function so that the Java/Kotlin objects can register themselves
// as signal observers. The C++ code doesn't decide where and when that happens.
void connectToCppExchanger(JNIEnv* /*env*/, jobject thiz, jlong cppExchanger)
{
    DataExchanger* exchanger = reinterpret_cast<DataExchanger*>(cppExchanger);
    QJniObject androidExchanger(thiz);
    QObject::connect(exchanger, &DataExchanger::fromCpp, exchanger,
                     // Intentional, and important capture by value of the QJniObject.
                     // This keeps the underlying Java/Kotlin object alive until the call
                     // to it is performed.
                     [androidExchanger](DataExchanger::OtherLanguageType type, const QString& str) {
                         androidExchanger.callMethod("fromCpp",
                                                     static_cast<int>(type), str);
                     });
}

// The Java/Kotlin code calls this. The C++ code doesn't decide where and when
// it is called.
// Note that the function must be registered with the Qt native method
// registration facilities because it relies on the Qt wrapping that knows how to
// convert a jstring to a QString.
void fromOther(JNIEnv* /*env*/, jobject /*thiz*/,
                       jlong cppExchanger, const QString &str)
{
    DataExchanger* exchanger = reinterpret_cast<DataExchanger*>(cppExchanger);
    exchanger->fromOther(str);
}

    QObject::connect(&javaButton, &QPushButton::clicked, &javaButton, [&]() {
        dataExchanger.fromCpp(DataExchanger::Java, "Hello!");
    });

    QObject::connect(&kotlinButton, &QPushButton::clicked, &kotlinButton, [&]() {
        dataExchanger.fromCpp(DataExchanger::Kotlin, "Hello!");
    });
    QObject::connect(&dataExchanger, &DataExchanger::fromOther,
                     &dataExchanger, [&](const QString& str) {
        fromOtherLabel.setText(str);
    });