En esta página

QJniObject Class

Una envoltura práctica para la Interfaz Nativa de Java (JNI). Más información...

Encabezado: #include <QJniObject>
CMake: find_package(Qt6 REQUIRED COMPONENTS Core)
target_link_libraries(mytarget PRIVATE Qt6::Core)
qmake: QT += core
Desde: Qt 6.1

Funciones públicas

QJniObject()
QJniObject(const char *className)
QJniObject(jclass clazz)
QJniObject(jobject object)
(since 6.4) QJniObject(const char *className, Args &&... args)
(since 6.4) QJniObject(jclass clazz, Args &&... args)
QJniObject(const char *className, const char *signature, ...)
QJniObject(jclass clazz, const char *signature, ...)
QJniObject(const QJniObject &other)
QJniObject(QJniObject &&other)
~QJniObject()
(since 6.4) auto callMethod(const char *methodName, Args &&... args) const
(since 6.4) auto callMethod(const char *methodName, const char *signature, Args &&... args) const
(since 6.4) QJniObject callObjectMethod(const char *methodName, Args &&... args) const
QJniObject callObjectMethod(const char *methodName, const char *signature, ...) const
(since 6.2) QByteArray className() const
auto getField(const char *fieldName) const
QJniObject getObjectField(const char *fieldName) const
QJniObject getObjectField(const char *fieldName, const char *signature) const
bool isValid() const
jobject object() const
T object() const
(since 6.2) jclass objectClass() const
auto setField(const char *fieldName, Type value)
auto setField(const char *fieldName, const char *signature, Type value)
(since 6.8) void swap(QJniObject &other)
QString toString() const
QJniObject &operator=(QJniObject &&other)
QJniObject &operator=(T object)
QJniObject &operator=(const QJniObject &other)

Miembros públicos estáticos

(since 6.7) auto callStaticMethod(const char *methodName, Args &&... args)
(since 6.4) auto callStaticMethod(const char *className, const char *methodName, Args &&... args)
(since 6.4) auto callStaticMethod(jclass clazz, const char *methodName, Args &&... args)
(since 6.4) auto callStaticMethod(jclass clazz, jmethodID methodId, Args &&... args)
(since 6.4) auto callStaticMethod(const char *className, const char *methodName, const char *signature, Args &&... args)
auto callStaticMethod(jclass clazz, const char *methodName, const char *signature, Args &&... args)
(since 6.4) QJniObject callStaticObjectMethod(const char *className, const char *methodName, Args &&... args)
(since 6.4) QJniObject callStaticObjectMethod(jclass clazz, const char *methodName, Args &&... args)
QJniObject callStaticObjectMethod(jclass clazz, jmethodID methodId, ...)
QJniObject callStaticObjectMethod(const char *className, const char *methodName, const char *signature, ...)
QJniObject callStaticObjectMethod(jclass clazz, const char *methodName, const char *signature, ...)
(since 6.4) auto construct(Args &&... args)
QJniObject fromLocalRef(jobject localRef)
QJniObject fromString(const QString &string)
auto getStaticField(const char *fieldName)
auto getStaticField(const char *className, const char *fieldName)
auto getStaticField(jclass clazz, const char *fieldName)
QJniObject getStaticObjectField(const char *className, const char *fieldName)
QJniObject getStaticObjectField(jclass clazz, const char *fieldName)
QJniObject getStaticObjectField(const char *className, const char *fieldName, const char *signature)
QJniObject getStaticObjectField(jclass clazz, const char *fieldName, const char *signature)
bool isClassAvailable(const char *className)
auto setStaticField(const char *fieldName, Type value)
auto setStaticField(const char *className, const char *fieldName, Type value)
auto setStaticField(jclass clazz, const char *fieldName, Type value)
auto setStaticField(const char *className, const char *fieldName, const char *signature, Type value)
auto setStaticField(jclass clazz, const char *fieldName, const char *signature, Type value)
bool operator!=(const QJniObject &o1, const QJniObject &o2)
bool operator==(const QJniObject &o1, const QJniObject &o2)

Descripción detallada

La clase QJniObject envuelve una referencia a un objeto Java, lo que garantiza que no sea eliminado por el recolector de basura y proporciona acceso a la mayoría de las llamadas a métodos ( JNIEnv: de miembro y estáticos) y a los campos (setter y getter). Elimina gran parte del código repetitivo que normalmente sería necesario, con acceso directo a JNI, para cada operación. Las excepciones lanzadas por los métodos Java invocados se ignoran por defecto, pero, a partir de Qt 6.11, también pueden ser gestionadas por el llamante.

Nota: Esta API se ha diseñado y probado para su uso con Android. No se ha probado en otras plataformas.

Firmaturas de métodos

QJniObject proporciona funciones de conveniencia que utilizarán la firma correcta en función de los argumentos de plantilla proporcionados o deducidos.

jint x = QJniObject::callMethod<jint>("getSize");
QJniObject::callMethod<void>("touch");
jint ret = jString1.callMethod<jint>("compareToIgnoreCase", jString2.object<jstring>());

Estas funciones son plantillas variádicas, y el compilador deducirá la firma a partir de los tipos reales de los argumentos. Solo es necesario proporcionar explícitamente el tipo de retorno. QJniObject puede deducir la cadena de firma para funciones que toman ` JNI types`, así como para tipos que se hayan declarado con la asignación de tipos ` QtJniTypes `.

// Java class
package org.qtproject.qt;
class TestClass
{
    static TestClass create() { ... }
    static String fromNumber(int x) { ... }
    static String[] stringArray(String s1, String s2) { ... }
}
// C++ code
Q_DECLARE_JNI_CLASS(TestClass, "org/qtproject/qt/TestClass")

// ...
using namespace QtJniTypes;
TestClass testClass = TestClass::callStaticMethod<TestClass>("create");

Esto permite trabajar con tipos arbitrarios de Java y Android en código C++, sin tener que crear explícitamente cadenas de firma JNI.

Firmas JNI explícitas

Es posible proporcionar la firma uno mismo. En ese caso, es importante que la firma coincida con la función que se desea llamar.

  • Los nombres de las clases deben estar completamente calificados, por ejemplo: "java/lang/String".
  • Las firmas de los métodos se escriben como "(ArgumentsTypes)ReturnType"; consulta JNI Types.
  • Todos los tipos de objeto se devuelven como un QJniObject.

El siguiente ejemplo muestra cómo llamar a diferentes funciones estáticas:

La estructura de la firma es "(ArgumentsTypes)ReturnType". Los tipos de matriz en la firma deben llevar el prefijo [, y los nombres de tipo totalmente calificados Object deben llevar el prefijo L y el sufijo ;. La firma de la función create es "()Lorg/qtproject/qt/TestClass;. Las firmas de la segunda y tercera funciones son "(I)Ljava/lang/String;" y "(Ljava/lang/String;Ljava/lang/String;)[Ljava/lang/String;", respectivamente.

Podemos llamar a la función create() de esta manera:

// C++ code
QJniObject testClass = QJniObject::callStaticObjectMethod("org/qtproject/qt/TestClass",
                                                          "create",
                                                          "()Lorg/qtproject/qt/TestClass;");

Para la segunda y la tercera función, podemos recurrir a los métodos de plantilla de `QJniObject` para crear la cadena de firma implícita, pero también podemos pasar la cadena de firma de forma explícita:

// C++ code
QJniObject stringNumber = QJniObject::callStaticObjectMethod("org/qtproject/qt/TestClass",
                                                             "fromNumber",
                                                             "(I)Ljava/lang/String;", 10);

Para que la creación de la firma implícita funcione, debemos especificar el tipo de retorno de forma explícita:

// C++ code
QJniObject string1 = QJniObject::fromString("String1");
QJniObject string2 = QJniObject::fromString("String2");
QJniObject stringArray = QJniObject::callStaticObjectMethod<jobjectArray>(
                                                            "org/qtproject/qt/TestClass",
                                                            "stringArray",
                                                            string1.object<jstring>(),
                                                            string2.object<jstring>());

Ten en cuenta que, aunque el primer parámetro de plantilla especifica el tipo de retorno de la función Java, el método seguirá devolviendo un QJniObject.

Gestión de excepciones de Java

Tras llamar a funciones de Java que puedan lanzar excepciones, es importante comprobar, gestionar y eliminar cualquier excepción antes de continuar. Todas las funciones de QJniObject pueden gestionar excepciones internamente, notificándolas y eliminándolas. Esto incluye las excepciones de JNI, por ejemplo, al intentar llamar a un método que no existe o con parámetros incorrectos; y las excepciones lanzadas por el método como forma de notificar errores o devolver información de fallo.

A partir de Qt 6.11, el código cliente puede optar por gestionar las excepciones de forma explícita en cada llamada. Para ello, utiliza ` std::expected ` de C++ 23 como tipo de retorno, con el tipo de valor esperado y ` jthrowable ` como tipo de error. Por ejemplo, intentar leer el valor de una configuración mediante el tipo « android.provider.Settings.Secure » podría lanzar una excepción si dicha configuración no existe.

Q_DECLARE_JNI_CLASS(SettingsSecure, "android/provider/Settings$Secure")
using namespace QtJniTypes;

QString enabledInputMethods()
{
    ContentResolver resolver;
    SettingsSecure settings;

    auto defaultInputMethods = settings.callMethod<std::expected<QString, jthrowable>>(
        "getString", resolver, u"enabled_input_methods"_s
    );
    if (defaultInputMethods)
        return defaultInputMethods.value();
    QStringList stackTrace = QJniEnvironment::stackTrace(defaultInputMethods.error());
}

Se puede utilizar cualquier otro tipo que se comporte como ` std::expected`, por lo que es posible gestionar las excepciones de forma explícita sin necesidad de utilizar C++23. Los únicos requisitos son que el tipo declare tres tipos anidados (` value_type`, ` error_type` y ` unexpected_type`), que pueda construirse a partir del tipo de valor y de su ` unexpected_type `, que contenga un ` jthrowable`.

Nota: El usuario debe gestionar las excepciones manualmente al realizar llamadas JNI utilizando directamente ` JNIEnv `. No es seguro realizar otras llamadas JNI cuando hay excepciones pendientes. Para obtener más información, consulte ` QJniEnvironment::checkAndClearExceptions()`.

Métodos nativos de Java

Los métodos nativos de Java permiten llamar a código nativo desde Java; para ello, se crea una declaración de función en Java y se le antepone la palabra clave native. Antes de poder llamar a una función nativa desde Java, es necesario asignar la función nativa de Java a una función nativa en el código. La asignación de funciones se puede realizar llamando a QJniEnvironment::registerNativeMethods().

El siguiente ejemplo muestra cómo se puede hacer esto.

Implementación en Java:

class FooJavaClass
{
    public static void foo(int x)
    {
        if (x < 100)
            callNativeOne(x);
        else
            callNativeTwo(x);
    }

private static native void callNativeOne(int x);
private static native void callNativeTwo(int x);

}

Implementación en C++:

static void fromJavaOne(JNIEnv *env, jobject thiz, jint x)
{
    Q_UNUSED(env);
    Q_UNUSED(thiz);
    qDebug() << x << "< 100";
}

static void fromJavaTwo(JNIEnv *env, jobject thiz, jint x)
{
    Q_UNUSED(env);
    Q_UNUSED(thiz);
    qDebug() << x << ">= 100";
}

void foo()
{
    // registrar primero los métodos nativos; lo ideal es hacerlo al iniciar la aplicación
    const JNINativeMethod methods[] =
                {{"callNativeOne", "(I)V", reinterpret_cast<void *>(fromJavaOne)},
                 {"callNativeTwo", "(I)V", reinterpret_cast<void *>(fromJavaTwo)}};
    QJniEnvironment env;
    env.registerNativeMethods("my/java/project/FooJavaClass", methods, 2);

    // Llamar al método Java que, a su vez, llamará a las funciones de C++
    QJniObject::callStaticMethod<void>("my/java/project/FooJavaClass", "foo", "(I)V", 10);  // Salida: 10 < 100
    QJniObject::callStaticMethod<void>("my/java/project/FooJavaClass", "foo", "(I)V", 100); // Salida: 100 >= 100
}

El ciclo de vida de un objeto Java

La mayoría de las referencias objects recibidas desde Java serán referencias locales y solo permanecerán válidas hasta que se salga del método nativo. A partir de ese momento, el objeto pasa a ser susceptible de ser recogido por el recolector de basura. Si tu código crea muchas referencias locales en un bucle, debes eliminarlas manualmente en cada iteración; de lo contrario, podrías quedarte sin memoria. Para obtener más información, consulta «Descripción general del diseño de JNI: referencias globales y locales». Las referencias locales creadas fuera del ámbito de un método nativo deben eliminarse manualmente, ya que el recolector de basura no las liberará automáticamente debido a que estamos utilizando `AttachCurrentThread`. Para obtener más información, consulta «Consejos sobre JNI: referencias locales y globales».

Si quieres mantener vivo un objeto Java, debes crear una nueva referencia global al objeto y liberarla cuando hayas terminado, o bien crear un nuevo QJniObject y dejar que este gestione el ciclo de vida del objeto Java.

Nota: El QJniObject solo gestiona sus propias referencias; si se crea un QJniObject a partir de una referencia global o local, dicha referencia no será liberada por el QJniObject.

Tipos JNI

Tipos de objetos

TipoFirma
jobjectLjava/lang/Object;
jclassLjava/lang/Class;
jstringLjava/lang/String;
jthrowableLjava/lang/Throwable;
jobjectArray[Ljava/lang/Object;
jarray[<tipo>
jbooleanArray[Z
jbyteArray[B
jcharArray[C
jshortArray[S
jintArray[I
jlongArray[J
jfloatArray[F
jdoubleArray[D

Tipos primitivos

TipoFirma
jbooleanZ
jbyteB
jcharC
jshortS
jintI
jlongJ
jfloatF
jdoubleD

Otros

TipoFirma
nuloV
Tipo personalizadoL<nombre-plenamente-calificado>;

Para obtener más información sobre JNI, consulta la Especificación de la Interfaz Nativa de Java.

Véase también QJniEnvironment y object().

Documentación de las funciones miembro

QJniObject::QJniObject()

Crea un objeto JNI no válido.

Véase también isValid().

[explicit] QJniObject::QJniObject(const char *className)

Crea un nuevo objeto JNI llamando al constructor por defecto de ` className`.

QJniObject myJavaString("java/lang/String");

[explicit] QJniObject::QJniObject(jclass clazz)

Crea un nuevo objeto JNI llamando al constructor por defecto de ` clazz`.

Nota: El objeto ` QJniObject` creará una nueva referencia a la clase ` clazz ` y la liberará de nuevo cuando se destruya. Las referencias a la clase creadas fuera del objeto `QJniObject` deben ser gestionadas por el llamante.

QJniObject::QJniObject(jobject object)

Crea un nuevo objeto JNI en torno al objeto Java ` object`.

Nota: El objeto ` QJniObject` mantendrá una referencia al objeto Java ` object ` y la liberará cuando se destruya. Cualquier referencia al objeto Java ` object ` fuera de `QJniObject` debe ser gestionada por el llamante. En la mayoría de los casos, nunca se debe llamar a esta función con una referencia local, a menos que se tenga la intención de gestionar la referencia local por uno mismo. Consulte QJniObject::fromLocalRef() para convertir una referencia local en un QJniObject.

Véase también fromLocalRef().

[explicit, since 6.4] template <typename... Args> QJniObject::QJniObject(const char *className, Args &&... args)

Crea un nuevo objeto JNI llamando al constructor de ` className ` con los argumentos ` args`. Este constructor solo está disponible si se conocen todos los ` args ` JNI Types.

QJniEnvironment env;
char* str = "Hello";
jstring myJStringArg = env->NewStringUTF(str);
QJniObject myNewJavaString("java/lang/String", myJStringArg);

Esta función se introdujo en Qt 6.4.

[explicit, since 6.4] template <typename... Args> QJniObject::QJniObject(jclass clazz, Args &&... args)

Crea un nuevo objeto JNI a partir de « clazz » llamando al constructor con los argumentos « args ». Este constructor solo está disponible si se conocen todos los « args » JNI Types.

QJniEnvironment env;
jclass myClazz = env.findClass("org/qtproject/qt/TestClass");
QJniObject(myClazz, 3);

Esta función se introdujo en Qt 6.4.

[explicit] QJniObject::QJniObject(const char *className, const char *signature, ...)

Crea un nuevo objeto JNI llamando al constructor de className con signature, especificando los tipos de los argumentos posteriores.

QJniEnvironment env;
char* str = "Hello";
jstring myJStringArg = env->NewStringUTF(str);
QJniObject myNewJavaString("java/lang/String", "(Ljava/lang/String;)V", myJStringArg);

[explicit] QJniObject::QJniObject(jclass clazz, const char *signature, ...)

Crea un nuevo objeto JNI a partir de ` clazz ` llamando al constructor con ` signature ` y especificando los tipos de los argumentos posteriores.

QJniEnvironment env;
jclass myClazz = env.findClass("org/qtproject/qt/TestClass");
QJniObject(myClazz, "(I)V", 3);

[noexcept default] QJniObject::QJniObject(const QJniObject &other)

Crea una instancia de ` QJniObject` mediante copia.

[noexcept default] QJniObject::QJniObject(QJniObject &&other)

Crea una instancia de ` QJniObject` mediante la construcción «move».

[noexcept] QJniObject::~QJniObject()

Destruye el objeto JNI y libera cualquier referencia que este mantenga.

[since 6.4] template <typename ReturnType = void, typename... Args> auto QJniObject::callMethod(const char *methodName, Args &&... args) const

Llama al método « methodName » con los argumentos « args » y devuelve el valor (a menos que «Ret» sea de tipo « void »). Si «Ret» es de tipo «jobject», el valor devuelto será un « QJniObject ».

QJniObject myJavaString("org/qtproject/qt/TestClass");
jint size = myJavaString.callMethod<jint>("length");

La firma del método se deduce en tiempo de compilación a partir de Ret y de los tipos de args. Ret puede ser un tipo compatible con std::expected que devuelva un valor, o bien any Java exception thrown por el método llamado.

Esta función se introdujo en Qt 6.4.

[since 6.4] template <typename ReturnType = void, typename... Args> auto QJniObject::callMethod(const char *methodName, const char *signature, Args &&... args) const

Llama al método « methodName » del objeto con « signature », especificando los tipos de los argumentos posteriores « args », y devuelve el valor (a menos que «Ret» sea « void »). Si «Ret» es de tipo «jobject», el valor devuelto será un « QJniObject ».

QJniObject myJavaString("org/qtproject/qt/TestClass");
jint index = myJavaString.callMethod<jint>("indexOf", "(I)I", 0x0051);

Esta función se introdujo en Qt 6.4.

[since 6.4] template <typename Ret, typename... Args> QJniObject QJniObject::callObjectMethod(const char *methodName, Args &&... args) const

Llama al método « methodName » de los objetos Java con los argumentos « args » y devuelve un nuevo « QJniObject » para el objeto Java devuelto.

QJniObject myJavaString = QJniObject::fromString("Hello, Java");
QJniObject myJavaString2 = myJavaString1.callObjectMethod<jstring>("toString");

La firma del método se deduce en tiempo de compilación a partir de `Ret` y de los tipos de ` args`. `Ret` puede ser un tipo compatible con ` std::expected` que devuelva un valor, o bien ` any Java exception thrown ` según el método invocado.

Esta función se introdujo en Qt 6.4.

QJniObject QJniObject::callObjectMethod(const char *methodName, const char *signature, ...) const

Llama al método « methodName » del objeto Java con « signature », especificando los tipos de los argumentos posteriores.

QJniObject myJavaString = QJniObject::fromString("Hello, Java");
QJniObject mySubstring = myJavaString.callObjectMethod("substring",
                                                       "(II)Ljava/lang/String;", 7, 11);

[static, since 6.7] template < typename Klass, typename ReturnType = void, typename... Args > auto QJniObject::callStaticMethod(const char *methodName, Args &&... args)

Llama al método estático ` methodName ` de la clase ` Klass ` y devuelve el valor de tipo `Ret` (a menos que `Ret` sea ` void`). Si `Ret` es un tipo `jobject`, el valor devuelto será un ` QJniObject`.

La firma del método se deduce en tiempo de compilación a partir de `Ret` y de los tipos de ` args`. ` Klass ` debe ser un tipo de C++ con una asignación de tipos registrada que apunte a un tipo de Java. `Ret` puede ser un tipo compatible con ` std::expected` que devuelva un valor, o un ` any Java exception thrown ` por parte del método llamado.

Esta función se introdujo en Qt 6.7.

[static, since 6.4] template <typename ReturnType = void, typename... Args> auto QJniObject::callStaticMethod(const char *className, const char *methodName, Args &&... args)

Llama al método estático ` methodName ` de la clase ` className ` con los argumentos ` args`, y devuelve el valor de tipo `Ret` (a menos que `Ret` sea ` void`). Si `Ret` es un tipo `jobject`, el valor devuelto será un ` QJniObject`.

jint value = QJniObject::callStaticMethod<jint>("MyClass", "staticMethod");

La firma del método se deduce en tiempo de compilación a partir de Ret y de los tipos de args. Ret puede ser un tipo compatible con std::expected que devuelva un valor, o any Java exception thrown por el método llamado.

Esta función se introdujo en Qt 6.4.

[static, since 6.4] template <typename ReturnType = void, typename... Args> auto QJniObject::callStaticMethod(jclass clazz, const char *methodName, Args &&... args)

Llama al método estático ` methodName ` en ` clazz ` y devuelve el valor de tipo `Ret` (a menos que `Ret` sea ` void`). Si `Ret` es un tipo `jobject`, el valor devuelto será un ` QJniObject`.

QJniEnvironment env;
jclass javaMathClass = env.findClass("java/lang/Math");
jdouble randNr = QJniObject::callStaticMethod<jdouble>(javaMathClass, "random");

La firma del método se deduce en tiempo de compilación a partir de Ret y de los tipos de ` args`. Ret puede ser un tipo compatible con ` std::expected` que devuelva un valor, o ` any Java exception thrown ` por parte del método llamado.

Esta función se introdujo en Qt 6.4.

[static, since 6.4] template <typename ReturnType = void, typename... Args> auto QJniObject::callStaticMethod(jclass clazz, jmethodID methodId, Args &&... args)

Llama al método estático identificado por « methodId » de la clase « clazz » con los argumentos que le sigan, y devuelve el valor de tipo «Ret» (a menos que «Ret» sea « void »). Si «Ret» es un tipo «jobject», el valor devuelto será un « QJniObject ».

Resulta útil cuando clazz y methodId ya están almacenados en caché de operaciones anteriores.

QJniEnvironment env;
jclass javaMathClass = env.findClass("java/lang/Math");
jmethodID methodId = env.findStaticMethod(javaMathClass, "max", "(II)I");
if (methodId != 0) {
    jint a = 2;
    jint b = 4;
    jint max = QJniObject::callStaticMethod<jint>(javaMathClass, methodId, a, b);
}

Esta función se introdujo en Qt 6.4.

[static, since 6.4] template <typename Ret = void, typename... Args> auto QJniObject::callStaticMethod(const char *className, const char *methodName, const char *signature, Args &&... args)

Llama al método estático « methodName » de la clase « className », con « signature » especificando los tipos de cualquier argumento posterior « args ». Devuelve el resultado del método (a menos que «Ret» sea « void »). Si «Ret» es un tipo «jobject», el valor devuelto será un « QJniObject ».

jint a = 2;
jint b = 4;
jint max = QJniObject::callStaticMethod<jint>("java/lang/Math", "max", "(II)I", a, b);

Esta función se introdujo en Qt 6.4.

[static] template <typename Ret = void, typename... Args> auto QJniObject::callStaticMethod(jclass clazz, const char *methodName, const char *signature, Args &&... args)

Llama al método estático ` methodName ` de ` clazz ` con ` signature `, especificando los tipos de los argumentos posteriores. Devuelve el resultado del método (a menos que `Ret` sea de tipo ` void`). Si `Ret` es de tipo `jobject`, el valor devuelto será un ` QJniObject`.

QJniEnvironment env;
jclass javaMathClass = env.findClass("java/lang/Math");
jint a = 2;
jint b = 4;
jint max = QJniObject::callStaticMethod<jint>(javaMathClass, "max", "(II)I", a, b);

[static, since 6.4] template <typename Ret, typename... Args> QJniObject QJniObject::callStaticObjectMethod(const char *className, const char *methodName, Args &&... args)

Llama al método estático con ` methodName ` de la clase ` className`, pasando los argumentos ` args`, y devuelve un nuevo ` QJniObject ` para el objeto Java devuelto.

QJniObject string = QJniObject::callStaticObjectMethod<jstring>("CustomClass", "getClassName");

La firma del método se deduce en tiempo de compilación a partir de `Ret` y de los tipos de ` args`. `Ret` puede ser un tipo compatible con ` std::expected` que devuelva un valor, o bien ` any Java exception thrown ` según el método llamado.

Esta función se introdujo en Qt 6.4.

[static, since 6.4] template <typename Ret, typename... Args> QJniObject QJniObject::callStaticObjectMethod(jclass clazz, const char *methodName, Args &&... args)

Llama al método estático con ` methodName ` en ` clazz`, pasando los argumentos ` args`, y devuelve un nuevo ` QJniObject ` para el objeto Java devuelto.

Esta función se introdujo en Qt 6.4.

[static] QJniObject QJniObject::callStaticObjectMethod(jclass clazz, jmethodID methodId, ...)

Llama al método estático identificado por ` methodId ` de la clase ` clazz ` con los argumentos que le sigan. Resulta útil cuando ` clazz ` y ` methodId ` ya están almacenados en caché a partir de operaciones anteriores.

QJniEnvironment env;
jclass clazz = env.findClass("java/lang/String");
jmethodID methodId = env.findStaticMethod(clazz, "valueOf", "(I)Ljava/lang/String;");
if (methodId != 0)
    QJniObject str = QJniObject::callStaticObjectMethod(clazz, methodId, 10);

[static] QJniObject QJniObject::callStaticObjectMethod(const char *className, const char *methodName, const char *signature, ...)

Llama al método estático « methodName » de la clase « className », con « signature », especificando los tipos de los argumentos posteriores.

QJniObject thread = QJniObject::callStaticObjectMethod("java/lang/Thread", "currentThread",
                                                       "()Ljava/lang/Thread;");
QJniObject string = QJniObject::callStaticObjectMethod("java/lang/String", "valueOf",
                                                       "(I)Ljava/lang/String;", 10);

[static] QJniObject QJniObject::callStaticObjectMethod(jclass clazz, const char *methodName, const char *signature, ...)

Llama al método estático ` methodName ` de la clase ` clazz `, utilizando ` signature ` para especificar los tipos de los argumentos posteriores.

[since 6.2] QByteArray QJniObject::className() const

Devuelve el nombre del objeto de clase que contiene la clase « QJniObject » como un objeto de tipo « QByteArray ».

Esta función se introdujo en Qt 6.2.

[static, since 6.4] template <typename Class, typename... Args> auto QJniObject::construct(Args &&... args)

Crea una instancia de la clase Java equivalente a Class y devuelve un QJniObject que contiene el objeto JNI. Los argumentos de args se pasan al constructor de Java.

QJniObject javaString = QJniObject::construct<jstring>();

Esta función solo está disponible si se conocen todos los args JNI Types .

Esta función se introdujo en Qt 6.4.

[static] QJniObject QJniObject::fromLocalRef(jobject localRef)

Crea un objeto ` QJniObject ` a partir de la referencia JNI local ` localRef`. Esta función asume la propiedad de ` localRef ` y la libera antes de devolver el resultado.

Nota: Solo se debe llamar a esta función con una referencia JNI local. Por ejemplo, la mayoría de las llamadas JNI sin procesar, a través del entorno JNI, devuelven referencias locales a un objeto Java.

jobject localRef = env->GetObjectArrayElement(array, index);
QJniObject element = QJniObject::fromLocalRef(localRef);

[static] QJniObject QJniObject::fromString(const QString &string)

Crea una cadena Java a partir del objeto ` QString ` ` string ` y devuelve un objeto ` QJniObject ` que contiene dicha cadena.

QString myQString = "QString";
QJniObject myJavaString = QJniObject::fromString(myQString);

Véase también toString().

template <typename Type> auto QJniObject::getField(const char *fieldName) const

Recupera el valor del campo « fieldName ».

QJniObject volumeControl("org/qtproject/qt/TestClass");
jint fieldValue = volumeControl.getField<jint>("FIELD_NAME");

template <typename T> QJniObject QJniObject::getObjectField(const char *fieldName) const

Recupera un objeto JNI del campo « fieldName ».

QJniObject field = jniObject.getObjectField<jstring>("FIELD_NAME");

QJniObject QJniObject::getObjectField(const char *fieldName, const char *signature) const

Recupera un objeto JNI del campo « fieldName » mediante « signature ».

Nota: Esta función se puede utilizar sin un tipo de plantilla.

QJniObject field = jniObject.getObjectField("FIELD_NAME", "Ljava/lang/String;");

[static] template <typename Klass, typename T> auto QJniObject::getStaticField(const char *fieldName)

Recupera el valor del campo estático « fieldName » de la clase « Klass ».

Klass Debe ser un tipo de C++ con una asignación de tipos registrada a un tipo de Java.

[static] template <typename Type> auto QJniObject::getStaticField(const char *className, const char *fieldName)

Recupera el valor del campo estático « fieldName » de la clase « className ».

[static] template <typename Type> auto QJniObject::getStaticField(jclass clazz, const char *fieldName)

Recupera el valor del campo estático « fieldName » de clazz.

[static] template <typename T> QJniObject QJniObject::getStaticObjectField(const char *className, const char *fieldName)

Recupera el objeto del campo « fieldName » de la clase « className ».

QJniObject jobj = QJniObject::getStaticObjectField<jstring>("class/with/Fields", "FIELD_NAME");

[static] template <typename T> QJniObject QJniObject::getStaticObjectField(jclass clazz, const char *fieldName)

Recupera el objeto del campo « fieldName » en clazz.

QJniObject jobj = QJniObject::getStaticObjectField<jstring>(clazz, "FIELD_NAME");

[static] QJniObject QJniObject::getStaticObjectField(const char *className, const char *fieldName, const char *signature)

Recupera un objeto JNI del campo « fieldName » con « signature » de la clase « className ».

Nota: Esta función se puede utilizar sin un tipo de plantilla.

QJniObject jobj = QJniObject::getStaticObjectField("class/with/Fields", "FIELD_NAME",
                                                   "Ljava/lang/String;");

[static] QJniObject QJniObject::getStaticObjectField(jclass clazz, const char *fieldName, const char *signature)

Recupera un objeto JNI del campo fieldName con signature de la clase clazz.

Nota: Esta función se puede utilizar sin un tipo de plantilla.

QJniObject jobj = QJniObject::getStaticObjectField(clazz, "FIELD_NAME", "Ljava/lang/String;");

[static] bool QJniObject::isClassAvailable(const char *className)

Devuelve «true» si la clase de Java « className » está disponible.

if (QJniObject::isClassAvailable("java/lang/String")) {
    // condition statement
}

bool QJniObject::isValid() const

Devuelve «true» si esta instancia contiene un objeto Java válido.

QJniObject qjniObject;                        // ==> isValid() == false
QJniObject qjniObject(0)                      // ==> isValid() == false
QJniObject qjniObject("could/not/find/Class") // ==> isValid() == false

jobject QJniObject::object() const

template <typename T> T QJniObject::object() const

Devuelve el objeto que contiene ` QJniObject `, ya sea como `jobject` o como tipo `T`. `T` puede ser uno de los siguientes: ` JNI Object Types`.

QJniObject string = QJniObject::fromString("Hello, JNI");
jstring jstring = string.object<jstring>();

Nota: El objeto devuelto sigue manteniéndose activo gracias a este ` QJniObject`. Para mantener el objeto activo más allá del tiempo de vida de este ` QJniObject`, por ejemplo, para guardarlo para su uso posterior, lo más sencillo es almacenarlo en otro ` QJniObject ` con un tiempo de vida adecuado. Como alternativa, puedes crear una nueva referencia global al objeto y almacenarla, teniendo cuidado de liberarla cuando ya no la necesites.

void functionScope()
{
    QString helloString("Hello");
    jstring myJString = 0;
    {
        QJniObject string = QJniObject::fromString(helloString);
        myJString = string.object<jstring>();
    }

    // Ops! myJString is no longer valid.
    QString myQtString = QJniObject(myJString).toString();
}

[since 6.2] jclass QJniObject::objectClass() const

Devuelve el objeto de clase que contiene el ` QJniObject ` como un ` jclass`.

Nota: El objeto devuelto sigue manteniéndose activo gracias a este ` QJniObject`. Para mantener el objeto activo más allá del ciclo de vida de este ` QJniObject`, por ejemplo, para grabarlo y utilizarlo más adelante, lo más sencillo es almacenarlo en otro ` QJniObject ` con un ciclo de vida adecuado. Como alternativa, puedes crear una nueva referencia global al objeto y almacenarla, teniendo cuidado de liberarla cuando ya no la necesites.

Esta función se introdujo en Qt 6.2.

template <typename Ret = void, typename Type> auto QJniObject::setField(const char *fieldName, Type value)

Establece el valor de « fieldName » en « value ».

QJniObject obj;
obj.setField<jint>("AN_INT_FIELD", 10);
jstring myString = ...;
obj.setField<jstring>("A_STRING_FIELD", myString);

template <typename Ret = void, typename Type> auto QJniObject::setField(const char *fieldName, const char *signature, Type value)

Establece el valor de « fieldName » con « signature » en « value ».

QJniObject stringArray = ...;
QJniObject obj = ...;
obj.setObjectField<jobjectArray>("KEY_VALUES", "([Ljava/lang/String;)V",
                           stringArray.object<jobjectArray>())

[static] template < typename Klass, typename Ret = void, typename Type > auto QJniObject::setStaticField(const char *fieldName, Type value)

Establece el campo estático « fieldName » de la clase « Klass » en « value ».

Klass Debe ser un tipo de C++ con una asignación de tipos registrada a un tipo de Java.

[static] template <typename Ret = void, typename Type> auto QJniObject::setStaticField(const char *className, const char *fieldName, Type value)

Establece el campo estático « fieldName » de la clase « className » en « value ».

[static] template <typename Ret = void, typename Type> auto QJniObject::setStaticField(jclass clazz, const char *fieldName, Type value)

Establece el campo estático « fieldName » de la clase « clazz » en « value ».

[static] template <typename Ret = void, typename Type> auto QJniObject::setStaticField(const char *className, const char *fieldName, const char *signature, Type value)

Establece el campo estático « fieldName » de la clase « className » en « value » utilizando el método setter con « signature ».

[static] template <typename Ret = void, typename Type> auto QJniObject::setStaticField(jclass clazz, const char *fieldName, const char *signature, Type value)

Establece el campo estático « fieldName » de la clase « clazz » en « value » utilizando el método setter con « signature ».

[noexcept, since 6.8] void QJniObject::swap(QJniObject &other)

Intercambia este objeto con other. Esta operación es muy rápida y nunca falla.

Esta función se introdujo en Qt 6.8.

QString QJniObject::toString() const

Devuelve un objeto ` QString ` con una representación en forma de cadena del objeto Java. Llamar a esta función sobre un objeto `String` de Java es una forma práctica de obtener los datos reales de la cadena.

QJniObject string = ...; //  "Hello Java"
QString qstring = string.toString(); // "Hello Java"

Véase también fromString().

[noexcept default] QJniObject &QJniObject::operator=(QJniObject &&other)

Asigna « other » a esta instancia de « QJniObject ». .

template <typename T, std::enable_if_t<std::is_convertible_v<T, jobject>, bool> = true> QJniObject &QJniObject::operator=(T object)

Sustituye el objeto actual por object. El antiguo objeto Java se liberará.

[noexcept default] QJniObject &QJniObject::operator=(const QJniObject &other)

Asigna por copia other a esta instancia de QJniObject.

Elementos no miembros relacionados

bool operator!=(const QJniObject &o1, const QJniObject &o2)

Devuelve «true» si ` o1 ` contiene una referencia a un objeto distinto de ` o2`.

bool operator==(const QJniObject &o1, const QJniObject &o2)

Devuelve «true» si ambos objetos, o1 y o2, hacen referencia al mismo objeto Java, o si ambos son NULL. En cualquier otro caso, se devolverá «false».

© 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.