QJniObject Class

Dokumentation zu den Mitgliedsfunktionen

QJniObject::QJniObject()

Erstellt ein ungültiges JNI-Objekt.

Siehe auch ` isValid()`.

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

Erstellt ein neues JNI-Objekt, indem der Standardkonstruktor von ` className` aufgerufen wird.

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

[explicit] QJniObject::QJniObject(jclass clazz)

Erstellt ein neues JNI-Objekt durch Aufruf des Standardkonstruktors von ` clazz`.

QJniObject::QJniObject(jobject object)

Erstellt ein neues JNI-Objekt, das das Java-Objekt „ object “ umschließt.

Siehe auch fromLocalRef().

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

Erstellt ein neues JNI-Objekt, indem der Konstruktor von ` className ` mit den Argumenten ` args` aufgerufen wird. Dieser Konstruktor ist nur verfügbar, wenn alle ` args ` bekannt sind JNI Types.

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

Diese Funktion wurde in Qt 6.4 eingeführt.

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

Erstellt ein neues JNI-Objekt aus „ clazz “, indem der Konstruktor mit den Argumenten „ args “ aufgerufen wird. Dieser Konstruktor ist nur verfügbar, wenn alle „ args “ bekannt sind: „ JNI Types “.

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

Diese Funktion wurde in Qt 6.4 eingeführt.

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

Erstellt ein neues JNI-Objekt, indem der Konstruktor von ` className ` aufgerufen wird, wobei ` signature ` die Typen aller nachfolgenden Argumente angibt.

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, ...)

Erstellt ein neues JNI-Objekt aus ` clazz `, indem der Konstruktor mit ` signature ` aufgerufen wird, wobei die Typen aller nachfolgenden Argumente angegeben werden.

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

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

Erstellt eine Kopie einer Instanz von ` QJniObject`.

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

Erstellt eine Instanz von ` QJniObject` mithilfe von `move`.

[noexcept] QJniObject::~QJniObject()

Löscht das JNI-Objekt und gibt alle vom JNI-Objekt gehaltenen Verweise frei.

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

Ruft die Methode „ methodName “ mit den Argumenten „ args “ auf und gibt den Wert zurück (es sei denn, „Ret“ ist vom Typ „ void “). Ist „Ret“ vom Typ „jobject“, so ist der zurückgegebene Wert ein „ QJniObject “.

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

Die Methodensignatur wird zur Kompilierungszeit aus `Ret` und den Typen von ` args` abgeleitet. `Ret` kann ein mit ` std::expected` kompatibler Typ sein, der einen Wert zurückgibt, oder ` any Java exception thrown ` durch die aufgerufene Methode.

Diese Funktion wurde in Qt 6.4 eingeführt.

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

Ruft die Methode „ methodName “ des Objekts auf, wobei „ signature “ die Typen aller nachfolgenden Argumente „ args “ angibt, und gibt den Wert zurück (es sei denn, „Ret“ ist „ void “). Ist „Ret“ vom Typ „jobject“, so ist der zurückgegebene Wert ein „ QJniObject “.

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

Diese Funktion wurde in Qt 6.4 eingeführt.

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

Ruft die Methode „ methodName “ des Java-Objekts mit den Argumenten „ args “ auf und gibt ein neues „ QJniObject “ für das zurückgegebene Java-Objekt zurück.

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

Die Methodensignatur wird zur Kompilierungszeit aus `Ret` und den Typen von ` args` abgeleitet. `Ret` kann ein mit ` std::expected` kompatibler Typ sein, der einen Wert zurückgibt, oder ` any Java exception thrown ` durch die aufgerufene Methode.

Diese Funktion wurde in Qt 6.4 eingeführt.

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

Ruft die Methode „ methodName “ des Java-Objekts auf, wobei „ signature “ die Typen aller nachfolgenden Argumente angibt.

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)

Ruft die statische Methode „ methodName “ der Klasse „ Klass “ auf und gibt den Wert vom Typ „Ret“ zurück (es sei denn, „Ret“ ist vom Typ „ void “). Ist „Ret“ ein „jobject“-Typ, ist der zurückgegebene Wert ein „ QJniObject “.

Die Methodensignatur wird zur Kompilierungszeit aus „Ret“ und den Typen von „ args “ abgeleitet. „ Klass “ muss ein C++-Typ sein, für den eine Typzuordnung zu einem Java-Typ registriert ist. „Ret“ kann ein mit „ std::expected “ kompatibler Typ sein, der einen Wert zurückgibt, oder ein „ any Java exception thrown “, der von der aufgerufenen Methode zurückgegeben wird.

Diese Funktion wurde in Qt 6.7 eingeführt.

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

Ruft die statische Methode ` methodName ` der Klasse ` className ` mit den Argumenten ` args` auf und gibt den Wert vom Typ `Ret` zurück (es sei denn, `Ret` ist ` void`). Ist `Ret` ein `jobject`-Typ, so ist der zurückgegebene Wert ein ` QJniObject`.

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

Die Methodensignatur wird zur Kompilierungszeit aus `Ret` und den Typen von ` args` abgeleitet. `Ret` kann ein mit ` std::expected` kompatibler Typ sein, der einen Wert zurückgibt, oder ` any Java exception thrown ` durch die aufgerufene Methode.

Diese Funktion wurde in Qt 6.4 eingeführt.

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

Ruft die statische Methode „ methodName “ auf „ clazz “ auf und gibt den Wert vom Typ „Ret“ zurück (es sei denn, „Ret“ ist „ void “). Ist „Ret“ ein „jobject“-Typ, so ist der zurückgegebene Wert ein „ QJniObject “.

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

Die Methodensignatur wird zur Kompilierungszeit aus „Ret“ und den Typen von „ args “ abgeleitet. „Ret“ kann ein mit „ std::expected “ kompatibler Typ sein, der einen Wert zurückgibt, oder „ any Java exception thrown “ durch die aufgerufene Methode.

Diese Funktion wurde in Qt 6.4 eingeführt.

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

Ruft die durch methodId identifizierte statische Methode aus der Klasse clazz mit allen nachfolgenden Argumenten auf und gibt den Wert vom Typ Ret zurück (es sei denn, Ret ist vom Typ void). Ist Ret ein jobject-Typ, so ist der zurückgegebene Wert ein QJniObject.

Dies ist nützlich, wenn ` clazz ` und ` methodId ` bereits aus früheren Operationen zwischengespeichert sind.

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

Diese Funktion wurde in Qt 6.4 eingeführt.

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

Ruft die statische Methode „ methodName “ aus der Klasse „ className “ auf, wobei „ signature “ die Typen aller nachfolgenden Argumente angibt: „ args “. Gibt das Ergebnis der Methode zurück (es sei denn, „Ret“ ist „ void “). Ist „Ret“ ein „jobject“-Typ, so ist der zurückgegebene Wert ein „ QJniObject “.

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

Diese Funktion wurde in Qt 6.4 eingeführt.

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

Ruft die statische Methode „ methodName “ aus „ clazz “ mit „ signature “ auf, wobei die Typen aller nachfolgenden Argumente angegeben werden. Gibt das Ergebnis der Methode zurück (es sei denn, „Ret“ ist vom Typ „ void “). Ist „Ret“ vom Typ „jobject“, so ist der zurückgegebene Wert ein „ 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)

Ruft die statische Methode mit ` methodName ` der Klasse ` className` auf, übergibt die Argumente ` args` und gibt ein neues ` QJniObject ` für das zurückgegebene Java-Objekt zurück.

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

Die Methodensignatur wird zur Kompilierungszeit aus `Ret` und den Typen von ` args` abgeleitet. `Ret` kann ein mit ` std::expected` kompatibler Typ sein, der einen Wert zurückgibt, oder ` any Java exception thrown ` durch die aufgerufene Methode.

Diese Funktion wurde in Qt 6.4 eingeführt.

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

Ruft die statische Methode mit „ methodName “ auf „ clazz “ auf, übergibt dabei die Argumente „ args “ und gibt ein neues „ QJniObject “ für das zurückgegebene Java-Objekt zurück.

Diese Funktion wurde in Qt 6.4 eingeführt.

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

Ruft die durch „ methodId “ bezeichnete statische Methode aus der Klasse „ clazz “ mit den nachfolgenden Argumenten auf. Dies ist nützlich, wenn „ clazz “ und „ methodId “ bereits aus früheren Vorgängen zwischengespeichert sind.

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, ...)

Ruft die statische Methode ` methodName ` aus der Klasse ` className ` auf, wobei ` signature ` die Typen aller nachfolgenden Argumente angibt.

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, ...)

Ruft die statische Methode „ methodName “ aus der Klasse „ clazz “ auf, wobei „ signature “ die Typen aller nachfolgenden Argumente angibt.

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

Gibt den Namen des Klassenobjekts zurück, das von der ` QJniObject ` als ` QByteArray` gehalten wird.

Diese Funktion wurde in Qt 6.2 eingeführt.

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

Erstellt eine Instanz der Java-Klasse, die dem „ Class “ entspricht, und gibt ein „ QJniObject “ zurück, das das JNI-Objekt enthält. Die Argumente in „ args “ werden an den Java-Konstruktor übergeben.

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

Diese Funktion ist nur verfügbar, wenn alle „ args “ als „ JNI Types “ bekannt sind.

Diese Funktion wurde in Qt 6.4 eingeführt.

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

Erstellt ein ` QJniObject ` aus der lokalen JNI-Referenz ` localRef`. Diese Funktion übernimmt die Verantwortung für ` localRef ` und gibt es vor der Rückgabe frei.

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

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

Erstellt eine Java-Zeichenkette aus dem ` QString ` ` string ` und gibt ein ` QJniObject ` zurück, das diese Zeichenkette enthält.

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

Siehe auch toString().

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

Ruft den Wert des Feldes „ fieldName “ ab.

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

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

Ruft ein JNI-Objekt aus dem Feld „ fieldName “ ab.

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

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

Ruft ein JNI-Objekt aus dem Feld „ fieldName “ mit „ signature “ ab.

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

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

Ruft den Wert aus dem statischen Feld „ fieldName “ der Klasse „ Klass “ ab.

Klass Es muss sich um einen C++-Typ handeln, für den eine Typzuordnung zu einem Java-Typ registriert ist.

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

Ruft den Wert aus dem statischen Feld „ fieldName “ der Klasse „ className “ ab.

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

Ruft den Wert aus dem statischen Feld „ fieldName “ unter clazz ab.

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

Ruft das Objekt aus dem Feld „ fieldName “ der Klasse „ className “ ab.

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

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

Ruft das Objekt aus dem Feld „ fieldName “ unter clazz ab.

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

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

Ruft ein JNI-Objekt aus dem Feld „ fieldName “ mit dem Wert „ signature “ aus der Klasse „ className “ ab.

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

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

Ruft ein JNI-Objekt aus dem Feld „ fieldName “ mit dem Wert „ signature “ aus der Klasse „ clazz “ ab.

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

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

Gibt „true“ zurück, wenn die Java-Klasse „ className “ verfügbar ist.

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

bool QJniObject::isValid() const

Gibt „true“ zurück, wenn diese Instanz ein gültiges Java-Objekt enthält.

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

Gibt das von der QJniObject verwaltete Objekt entweder als `jobject` oder als Typ `T` zurück. `T` kann einer der folgenden Typen sein: ` JNI Object Types`.

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

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

Gibt das von QJniObject verwaltete Klassenobjekt als jclass zurück.

Diese Funktion wurde in Qt 6.2 eingeführt.

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

Setzt den Wert von „ fieldName “ auf „ 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)

Setzt den Wert von „ fieldName “ mit „ signature “ auf „ 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)

Setzt das statische Feld „ fieldName “ der Klasse „ Klass “ auf „ value “.

Klass Muss ein C++-Typ sein, dessen registrierte Typzuordnung einem Java-Typ entspricht.

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

Setzt das statische Feld „ fieldName “ der Klasse „ className “ auf „ value “.

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

Setzt das statische Feld „ fieldName “ der Klasse „ clazz “ auf „ value “.

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

Setzt das statische Feld „ fieldName “ der Klasse „ className “ mithilfe des Setters mit „ signature “ auf „ value “.

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

Setzt das statische Feld „ fieldName “ der Klasse „ clazz “ mithilfe des Setters mit „ signature “ auf „ value “.

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

Tauscht dieses Objekt mit „ other “ aus. Dieser Vorgang ist sehr schnell und schlägt niemals fehl.

Diese Funktion wurde in Qt 6.8 eingeführt.

QString QJniObject::toString() const

Gibt ein ` QString ` mit einer Zeichenfolgenrepräsentation des Java-Objekts zurück. Der Aufruf dieser Funktion für ein Java-String-Objekt ist eine bequeme Möglichkeit, die eigentlichen Zeichenfolgendaten abzurufen.

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

Siehe auch ` fromString()`.

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

Weist „ other “ dieser „ QJniObject “-Instanz zu.

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

Ersetzen Sie das aktuelle Objekt durch object. Das alte Java-Objekt wird freigegeben.

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

other Weist dieser „ QJniObject “-Instanz den Wert „ “ zu.