QJniObject Class

 jint x = QJniObject::callMethod<jint>("getSize");
 QJniObject::callMethod<void>("touch");

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

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

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

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

 }

 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()
 {
     // register the native methods first, ideally it better be done with the app start
     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);

     // Call the java method which will calls back to the C++ functions
     QJniObject::callStaticMethod<void>("my/java/project/FooJavaClass", "foo", "(I)V", 10);  // Output: 10 < 100
     QJniObject::callStaticMethod<void>("my/java/project/FooJavaClass", "foo", "(I)V", 100); // Output: 100 >= 100
 }

Member Function Documentation

QJniObject::QJniObject(jobject object)

Constructs a new JNI object around the Java object object.

Note: The QJniObject will hold a reference to the Java object object and release it when destroyed. Any references to the Java object object outside QJniObject needs to be managed by the caller. In most cases you should never call this function with a local reference unless you intend to manage the local reference yourself. See QJniObject::fromLocalRef() for converting a local reference to a QJniObject.

See also fromLocalRef().

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

Constructs a new JNI object from clazz by calling the constructor with signature specifying the types of any subsequent arguments.

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

QJniObject::QJniObject(jclass clazz)

Constructs a new JNI object by calling the default constructor of clazz.

Note: The QJniObject will create a new reference to the class clazz and releases it again when it is destroyed. References to the class created outside the QJniObject need to be managed by the caller.

QJniObject::QJniObject(const char *className, const char *signature, ...)

Constructs a new JNI object by calling the constructor of className with signature specifying the types of any subsequent arguments.

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

QJniObject::QJniObject(const char *className)

Constructs a new JNI object by calling the default constructor of className.

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

QJniObject::QJniObject()

Constructs an invalid JNI object.

See also isValid().

QJniObject::~QJniObject()

Destroys the JNI object and releases any references held by the JNI object.

template <typename T> T QJniObject::callMethod(const char *methodName, const char *signature, ...) const

Calls the object's method methodName with signature specifying the types of any subsequent arguments.

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

template <typename T> T QJniObject::callMethod(const char *methodName) const

Calls the method methodName and returns the value.

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

template <typename T> QJniObject QJniObject::callObjectMethod(const char *methodName) const

Calls the Java objects method methodName and returns a new QJniObject for the returned Java object.

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

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

Calls the Java object's method methodName with signature specifying the types of any subsequent arguments.

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

[static] template <typename T> T QJniObject::callStaticMethod(const char *className, const char *methodName, const char *signature, ...)

Calls the static method methodName from class className with signature specifying the types of any subsequent arguments.

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

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

Calls the static method methodName on class className and returns the value.

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

[static] template <typename T> T QJniObject::callStaticMethod(jclass clazz, const char *methodName, const char *signature, ...)

Calls the static method methodName from clazz with signature specifying the types of any subsequent arguments.

 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] template <typename T> T QJniObject::callStaticMethod(jclass clazz, jmethodID methodId, ...)

Calls the static method identified by methodId from the class clazz with any subsequent arguments. Useful when clazz and methodId are already cached from previous operations.

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

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

Calls the static method methodName on clazz and returns the value.

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

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

Calls the static method with methodName on the class className.

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

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

Calls the static method methodName from the class className with signature specifying the types of any subsequent arguments.

 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] template <typename T> QJniObject QJniObject::callStaticObjectMethod(jclass clazz, const char *methodName)

Calls the static method with methodName on clazz.

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

Calls the static method methodName from class clazz with signature specifying the types of any subsequent arguments.

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

Calls the static method identified by methodId from the class clazz with any subsequent arguments. Useful when clazz and methodId are already cached from previous operations.

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

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

Returns the name of the class object held by the QJniObject as a QByteArray.

This function was introduced in Qt 6.2.

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

Creates a QJniObject from the local JNI reference localRef. This function takes ownership of localRef and frees it before returning.

Note: Only call this function with a local JNI reference. For example, most raw JNI calls, through the JNI environment, return local references to a java object.

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

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

Creates a Java string from the QString string and returns a QJniObject holding that string.

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

See also toString().

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

Retrieves the value of the field fieldName.

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

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

Retrieves a JNI object from the field fieldName.

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

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

Retrieves a JNI object from the field fieldName with signature.

Note: This function can be used without a template type.

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

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

Retrieves the value from the static field fieldName on the class className.

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

Retrieves the value from the static field fieldName on clazz.

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

Retrieves the object from the field fieldName on the class className.

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

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

Retrieves a JNI object from the field fieldName with signature from class className.

Note: This function can be used without a template type.

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

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

Retrieves the object from the field fieldName on clazz.

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

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

Retrieves a JNI object from the field fieldName with signature from class clazz.

Note: This function can be used without a template type.

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

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

Returns true if the Java class className is available.

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

bool QJniObject::isValid() const

Returns true if this instance holds a valid Java object.

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

jobject QJniObject::object() const

Returns the object held by the QJniObject either as jobject or as type T. T can be one of JNI Object Types.

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

Note: The returned object is still kept alive by this QJniObject. To keep the object alive beyond the lifetime of this QJniObject, for example to record it for later use, the easiest approach is to store it in another QJniObject with a suitable lifetime. Alternatively, you may create a new global reference to the object and store it, taking care to free it when you are done with it.

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

    // Ops! myJString is no longer valid.
 }

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

Returns the class object held by the QJniObject as a jclass.

Note: The returned object is still kept alive by this QJniObject. To keep the object alive beyond the lifetime of this QJniObject, for example to record it for later use, the easiest approach is to store it in another QJniObject with a suitable lifetime. Alternatively, you may create a new global reference to the object and store it, taking care to free it when you are done with it.

This function was introduced in Qt 6.2.

template <typename T> void QJniObject::setField(const char *fieldName, T value)

Sets the value of fieldName to value.

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

template <typename T> void QJniObject::setField(const char *fieldName, const char *signature, T value)

Sets the value of fieldName with signature to value.

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

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

Sets the static field fieldName of the class className to value.

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

Sets the static field fieldName on the class className to value using the setter with signature.

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

Sets the static field fieldName on the class clazz to value using the setter with signature.

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

Sets the static field fieldName of the class clazz to value.

QString QJniObject::toString() const

Returns a QString with a string representation of the java object. Calling this function on a Java String object is a convenient way of getting the actual string data.

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

See also fromString().

template <typename T> QJniObject &QJniObject::operator=(T object)

Replace the current object with object. The old Java object will be released.