En esta página

Intercambio de lenguajes de Qt para Android

Muestra cómo llamar a código Java y Kotlin desde Qt, y a código Qt desde Java y Kotlin, en una aplicación para Android.

Aplicación para Android que muestra un mensaje y dos botones con los textos «¡Hola, Kotlin!» y «¡Hola, Java!».

Haz clic en uno de los botones para enviar una cadena a las clases de Java y Kotlin y recibir una cadena modificada a cambio.

Dos capturas de pantalla una al lado de la otra que muestran la respuesta de la aplicación a los botones «Hello Kotlin» y «Hello Java»

Este ejemplo muestra cómo añadir una clase Java personalizada y una clase Kotlin personalizada a una aplicación de Android, y cómo invocarlas utilizando las API de conveniencia de JNI en Qt. En sentido contrario, las clases Java y Kotlin invocan funciones de Qt.

Ejecución del ejemplo

Puedes ejecutar el ejemplo desde:

Nota: Este ejemplo solo se puede ejecutar en dispositivos Android.

Intercambio de datos entre C++ y Java/Kotlin mediante señales de Qt

Definimos una clase Java personalizada llamada « JavaExchanger » en el archivo JavaExchanger.java:

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);
        }
    }
}

Definimos una clase Kotlin personalizada llamada « KotlinExchanger » en el archivo « KotlinExchanger.kt »:

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)
        }
    }
}

Ambas clases aceptan un entero largo que no es más que un « QObject* » convertido a «long», y cuando se invocan las funciones « fromCpp » como resultado de llamar a la función « connectToCppExchanger », modifican la cadena entrante y la devuelven a « fromOther » junto con el entero largo.

En el archivo de cabecera de la clase DataExchanger de C++, dataexchanger.h, declaramos una sencilla API de C++ para intercambiar datos entre C++ y Kotlin/Java. Consta de ` QObject `, con una señal ` fromCpp ` que se envía desde el código C++ como respuesta a los botones, y una señal ` fromOther ` que el código Java/Kotlin utiliza para enviar una cadena al código C++, tal y como se ha descrito anteriormente.

// 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);
};

La llamada al método Java utiliza ` QJniObject `, que se basa en las API de la Interfaz Nativa de Java (JNI) para comunicarse con Java/Kotlin. El argumento de tipo entero largo se convierte de nuevo al tipo ` DataExchanger `, y la señal ` fromCpp ` se conecta entonces a una lambda que llama a la función ` fromCpp ` de Java/Kotlin.

// 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);
                     });
}

La llamada a un método nativo de la clase Java/Kotlin se reenvía a la clase DataExchanger, convirtiendo de nuevo el entero largo a DataExchanger y llamando a continuación a la señal fromOther de ese tipo.

// 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);
}

Para asegurarnos de que nuestros botones hacen lo que se supone que deben hacer, añadimos el siguiente código para activar el envío de una cadena a Java/Kotlin y recibir de vuelta la cadena modificada:

    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);
    });

Proyecto de ejemplo en code.qt.io

Véase también Qt para Android.

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.