diff options
Diffstat (limited to 'src')
-rw-r--r-- | src/platformsupport/jniconvenience/jniconvenience.pri | 9 | ||||
-rw-r--r-- | src/platformsupport/jniconvenience/qjnihelpers.cpp | 115 | ||||
-rw-r--r-- | src/platformsupport/jniconvenience/qjnihelpers_p.h | 191 | ||||
-rw-r--r-- | src/platformsupport/jniconvenience/qjniobject.cpp | 3098 | ||||
-rw-r--r-- | src/platformsupport/jniconvenience/qjniobject_p.h | 169 | ||||
-rw-r--r-- | src/platformsupport/platformsupport.pro | 1 |
6 files changed, 3583 insertions, 0 deletions
diff --git a/src/platformsupport/jniconvenience/jniconvenience.pri b/src/platformsupport/jniconvenience/jniconvenience.pri new file mode 100644 index 0000000000..991518e370 --- /dev/null +++ b/src/platformsupport/jniconvenience/jniconvenience.pri @@ -0,0 +1,9 @@ +android { + QT += gui-private + + HEADERS += $$PWD/qjnihelpers_p.h \ + $$PWD/qjniobject_p.h + + SOURCES += $$PWD/qjnihelpers.cpp \ + $$PWD/qjniobject.cpp +} diff --git a/src/platformsupport/jniconvenience/qjnihelpers.cpp b/src/platformsupport/jniconvenience/qjnihelpers.cpp new file mode 100644 index 0000000000..3f9b568368 --- /dev/null +++ b/src/platformsupport/jniconvenience/qjnihelpers.cpp @@ -0,0 +1,115 @@ +/**************************************************************************** +** +** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/legal +** +** This file is part of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and Digia. For licensing terms and +** conditions see http://qt.digia.com/licensing. For further information +** use the contact form at http://qt.digia.com/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Digia gives you certain additional +** rights. These rights are described in the Digia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qjnihelpers_p.h" + +#include <qpa/qplatformnativeinterface.h> +#include <qguiapplication.h> + +QT_BEGIN_NAMESPACE + +QString qt_convertJString(jstring string) +{ + QAttachedJNIEnv env; + int strLength = env->GetStringLength(string); + QString res; + res.resize(strLength); + env->GetStringRegion(string, 0, strLength, (jchar*)res.utf16()); + return res; +} + +QJNILocalRef<jstring> qt_toJString(const QString &string) +{ + QAttachedJNIEnv env; + return QJNILocalRef<jstring>(env->NewString(reinterpret_cast<const jchar*>(string.constData()), + string.length())); +} + + +static JavaVM *g_javaVM = 0; + +static JavaVM *getJavaVM() +{ + if (!g_javaVM){ + QPlatformNativeInterface *nativeInterface = QGuiApplication::platformNativeInterface(); + g_javaVM = static_cast<JavaVM*>(nativeInterface->nativeResourceForIntegration("JavaVM")); + } + return g_javaVM; +} + +QThreadStorage<int> QAttachedJNIEnv::m_refCount; + +QAttachedJNIEnv::QAttachedJNIEnv() +{ + JavaVM *vm = javaVM(); + if (vm->GetEnv((void**)&jniEnv, JNI_VERSION_1_6) == JNI_EDETACHED) { + if (vm->AttachCurrentThread(&jniEnv, 0) < 0) { + jniEnv = 0; + return; + } + } + + if (!m_refCount.hasLocalData()) + m_refCount.setLocalData(1); + else + m_refCount.setLocalData(m_refCount.localData() + 1); +} + +QAttachedJNIEnv::~QAttachedJNIEnv() +{ + if (!jniEnv) + return; + + int newRef = m_refCount.localData() - 1; + m_refCount.setLocalData(newRef); + + if (newRef == 0) + javaVM()->DetachCurrentThread(); + + jniEnv = 0; +} + +JavaVM *QAttachedJNIEnv::javaVM() +{ + return getJavaVM(); +} + +QT_END_NAMESPACE diff --git a/src/platformsupport/jniconvenience/qjnihelpers_p.h b/src/platformsupport/jniconvenience/qjnihelpers_p.h new file mode 100644 index 0000000000..fb44d156bd --- /dev/null +++ b/src/platformsupport/jniconvenience/qjnihelpers_p.h @@ -0,0 +1,191 @@ +/**************************************************************************** +** +** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/legal +** +** This file is part of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and Digia. For licensing terms and +** conditions see http://qt.digia.com/licensing. For further information +** use the contact form at http://qt.digia.com/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Digia gives you certain additional +** rights. These rights are described in the Digia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QJNIHELPERS_H +#define QJNIHELPERS_H + +#include <jni.h> +#include <qglobal.h> +#include <QString> +#include <QThreadStorage> + +QT_BEGIN_NAMESPACE + +template <typename T> +class QJNILocalRef; + +QString qt_convertJString(jstring string); +QJNILocalRef<jstring> qt_toJString(const QString &string); + + +struct QAttachedJNIEnv +{ + QAttachedJNIEnv(); + ~QAttachedJNIEnv(); + + static JavaVM *javaVM(); + + JNIEnv *operator->() + { + return jniEnv; + } + + operator JNIEnv*() const + { + return jniEnv; + } + + JNIEnv *jniEnv; + +private: + static QThreadStorage<int> m_refCount; +}; + + +template <typename T> +class QJNILocalRef +{ +public: + inline QJNILocalRef() : m_obj(0) { } + inline explicit QJNILocalRef(T o) : m_obj(o) { } + inline QJNILocalRef(const QJNILocalRef<T> &other) : m_obj(other.m_obj) + { + if (other.m_obj) + m_obj = static_cast<T>(m_env->NewLocalRef(other.m_obj)); + } + + template <typename X> + inline QJNILocalRef(const QJNILocalRef<X> &other) : m_obj(other.m_obj) + { + if (other.m_obj) + m_obj = static_cast<T>(m_env->NewLocalRef(other.m_obj)); + } + + inline ~QJNILocalRef() { release(); } + + inline QJNILocalRef<T> &operator=(const QJNILocalRef<T> &other) + { + release(); + m_obj = other.m_obj; // for type checking + if (other.m_obj) + m_obj = static_cast<T>(m_env->NewLocalRef(other.m_obj)); + return *this; + } + + template <typename X> + inline QJNILocalRef<T> &operator=(const QJNILocalRef<X> &other) + { + release(); + m_obj = other.m_obj; // for type checking + if (other.m_obj) + m_obj = static_cast<T>(m_env->NewLocalRef(other.m_obj)); + return *this; + } + + inline QJNILocalRef<T> &operator=(T o) + { + release(); + m_obj = o; + return *this; + } + + template <typename X> + inline QJNILocalRef<T> &operator=(X o) + { + release(); + m_obj = o; + return *this; + } + + inline bool operator !() const { return !m_obj; } + inline bool isNull() const { return !m_obj; } + inline T object() const { return m_obj; } + +private: + void release() + { + if (m_obj) { + m_env->DeleteLocalRef(m_obj); + m_obj = 0; + } + } + + QAttachedJNIEnv m_env; + T m_obj; + + template <class X> friend class QJNILocalRef; +}; + +template <class T, class X> +bool operator==(const QJNILocalRef<T> &ptr1, const QJNILocalRef<X> &ptr2) +{ + return ptr1.m_obj == ptr2.m_obj; +} +template <class T, class X> +bool operator!=(const QJNILocalRef<T> &ptr1, const QJNILocalRef<X> &ptr2) +{ + return ptr1.m_obj != ptr2.m_obj; +} + +template <class T, class X> +bool operator==(const QJNILocalRef<T> &ptr1, X ptr2) +{ + return ptr1.m_obj == ptr2; +} +template <class T, class X> +bool operator==(T ptr1, const QJNILocalRef<X> &ptr2) +{ + return ptr1 == ptr2.m_obj; +} +template <class T, class X> +bool operator!=(const QJNILocalRef<T> &ptr1, X ptr2) +{ + return !(ptr1 == ptr2); +} +template <class T, class X> +bool operator!=(const T *ptr1, const QJNILocalRef<X> &ptr2) +{ + return !(ptr2 == ptr1); +} + +QT_END_NAMESPACE + +#endif // QJNIHELPERS_H diff --git a/src/platformsupport/jniconvenience/qjniobject.cpp b/src/platformsupport/jniconvenience/qjniobject.cpp new file mode 100644 index 0000000000..515e82b2f0 --- /dev/null +++ b/src/platformsupport/jniconvenience/qjniobject.cpp @@ -0,0 +1,3098 @@ +/**************************************************************************** +** +** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/legal +** +** This file is part of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and Digia. For licensing terms and +** conditions see http://qt.digia.com/licensing. For further information +** use the contact form at http://qt.digia.com/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Digia gives you certain additional +** rights. These rights are described in the Digia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "qjniobject_p.h" + +#include "qjnihelpers_p.h" +#include <qhash.h> + +QT_BEGIN_NAMESPACE + +static QHash<QString, jclass> g_cachedClasses; + +static jclass getCachedClass(JNIEnv *env, const char *className) +{ + jclass clazz = 0; + QString key = QLatin1String(className); + QHash<QString, jclass>::iterator it = g_cachedClasses.find(key); + if (it == g_cachedClasses.end()) { + jclass c = env->FindClass(className); + if (env->ExceptionCheck()) { + c = 0; + env->ExceptionClear(); + } + if (c) + clazz = static_cast<jclass>(env->NewGlobalRef(c)); + g_cachedClasses.insert(key, clazz); + } else { + clazz = it.value(); + } + return clazz; +} + +static QHash<QString, jmethodID> g_cachedMethodIDs; +static QString g_keyBase(QLatin1String("%1%2%3")); + +static jmethodID getCachedMethodID(JNIEnv *env, + jclass clazz, + const char *name, + const char *sig, + bool isStatic = false) +{ + jmethodID id = 0; + QString key = g_keyBase.arg(size_t(clazz)).arg(QLatin1String(name)).arg(QLatin1String(sig)); + QHash<QString, jmethodID>::iterator it = g_cachedMethodIDs.find(key); + if (it == g_cachedMethodIDs.end()) { + if (isStatic) + id = env->GetStaticMethodID(clazz, name, sig); + else + id = env->GetMethodID(clazz, name, sig); + + if (env->ExceptionCheck()) { + id = 0; + env->ExceptionClear(); + } + + g_cachedMethodIDs.insert(key, id); + } else { + id = it.value(); + } + return id; +} + +static QHash<QString, jfieldID> g_cachedFieldIDs; + +static jfieldID getCachedFieldID(JNIEnv *env, + jclass clazz, + const char *name, + const char *sig, + bool isStatic = false) +{ + jfieldID id = 0; + QString key = g_keyBase.arg(size_t(clazz)).arg(QLatin1String(name)).arg(QLatin1String(sig)); + QHash<QString, jfieldID>::iterator it = g_cachedFieldIDs.find(key); + if (it == g_cachedFieldIDs.end()) { + if (isStatic) + id = env->GetStaticFieldID(clazz, name, sig); + else + id = env->GetFieldID(clazz, name, sig); + + if (env->ExceptionCheck()) { + id = 0; + env->ExceptionClear(); + } + + g_cachedFieldIDs.insert(key, id); + } else { + id = it.value(); + } + return id; +} + +QJNIObject::QJNIObject(const char *className) + : m_jobject(0) + , m_jclass(0) + , m_own_jclass(false) +{ + QAttachedJNIEnv env; + m_jclass = getCachedClass(env, className); + if (m_jclass) { + // get default constructor + jmethodID constructorId = getCachedMethodID(env, m_jclass, "<init>", "()V"); + if (constructorId) { + jobject obj = env->NewObject(m_jclass, constructorId); + if (obj) { + m_jobject = env->NewGlobalRef(obj); + env->DeleteLocalRef(obj); + } + } + } +} + +QJNIObject::QJNIObject(const char *className, const char *sig, ...) + : m_jobject(0) + , m_jclass(0) + , m_own_jclass(false) +{ + QAttachedJNIEnv env; + m_jclass = getCachedClass(env, className); + if (m_jclass) { + jmethodID constructorId = getCachedMethodID(env, m_jclass, "<init>", sig); + if (constructorId) { + va_list args; + va_start(args, sig); + jobject obj = env->NewObjectV(m_jclass, constructorId, args); + va_end(args); + if (obj) { + m_jobject = env->NewGlobalRef(obj); + env->DeleteLocalRef(obj); + } + } + } +} + +QJNIObject::QJNIObject(jclass clazz) + : m_jobject(0) + , m_jclass(0) + , m_own_jclass(true) +{ + QAttachedJNIEnv env; + m_jclass = static_cast<jclass>(env->NewGlobalRef(clazz)); + if (m_jclass) { + // get default constructor + jmethodID constructorId = getCachedMethodID(env, m_jclass, "<init>", "()V"); + if (constructorId) { + jobject obj = env->NewObject(m_jclass, constructorId); + if (obj) { + m_jobject = env->NewGlobalRef(obj); + env->DeleteLocalRef(obj); + } + } + } +} + +QJNIObject::QJNIObject(jclass clazz, const char *sig, ...) + : m_jobject(0) + , m_jclass(0) + , m_own_jclass(true) +{ + QAttachedJNIEnv env; + if (clazz) { + m_jclass = static_cast<jclass>(env->NewGlobalRef(clazz)); + if (m_jclass) { + jmethodID constructorId = getCachedMethodID(env, m_jclass, "<init>", sig); + if (constructorId) { + va_list args; + va_start(args, sig); + jobject obj = env->NewObjectV(m_jclass, constructorId, args); + va_end(args); + if (obj) { + m_jobject = env->NewGlobalRef(obj); + env->DeleteLocalRef(obj); + } + } + } + } +} + +QJNIObject::QJNIObject(jobject obj) + : m_jobject(0) + , m_jclass(0) + , m_own_jclass(true) +{ + QAttachedJNIEnv env; + m_jobject = env->NewGlobalRef(obj); + m_jclass = static_cast<jclass>(env->NewGlobalRef(env->GetObjectClass(m_jobject))); +} + +QJNIObject::~QJNIObject() +{ + QAttachedJNIEnv env; + if (m_jobject) + env->DeleteGlobalRef(m_jobject); + if (m_jclass && m_own_jclass) + env->DeleteGlobalRef(m_jclass); +} + +bool QJNIObject::isClassAvailable(const char *className) +{ + QAttachedJNIEnv env; + + if (!env.jniEnv) + return false; + + jclass clazz = getCachedClass(env, className); + + return (clazz != 0); +} + +template <> +void QJNIObject::callMethod<void>(const char *methodName, const char *sig, ...) +{ + QAttachedJNIEnv env; + jmethodID id = getCachedMethodID(env, m_jclass, methodName, sig); + if (id) { + va_list args; + va_start(args, sig); + env->CallVoidMethodV(m_jobject, id, args); + va_end(args); + } +} + +template <> +jboolean QJNIObject::callMethod<jboolean>(const char *methodName, const char *sig, ...) +{ + QAttachedJNIEnv env; + jboolean res = 0; + jmethodID id = getCachedMethodID(env, m_jclass, methodName, sig); + if (id) { + va_list args; + va_start(args, sig); + res = env->CallBooleanMethodV(m_jobject, id, args); + va_end(args); + } + return res; +} + +template <> +jbyte QJNIObject::callMethod<jbyte>(const char *methodName, const char *sig, ...) +{ + QAttachedJNIEnv env; + jbyte res = 0; + jmethodID id = getCachedMethodID(env, m_jclass, methodName, sig); + if (id) { + va_list args; + va_start(args, sig); + res = env->CallByteMethodV(m_jobject, id, args); + va_end(args); + } + return res; +} + +template <> +jchar QJNIObject::callMethod<jchar>(const char *methodName, const char *sig, ...) +{ + QAttachedJNIEnv env; + jchar res = 0; + jmethodID id = getCachedMethodID(env, m_jclass, methodName, sig); + if (id) { + va_list args; + va_start(args, sig); + res = env->CallCharMethodV(m_jobject, id, args); + va_end(args); + } + return res; +} + +template <> +jshort QJNIObject::callMethod<jshort>(const char *methodName, const char *sig, ...) +{ + QAttachedJNIEnv env; + jshort res = 0; + jmethodID id = getCachedMethodID(env, m_jclass, methodName, sig); + if (id) { + va_list args; + va_start(args, sig); + res = env->CallShortMethodV(m_jobject, id, args); + va_end(args); + } + return res; +} + +template <> +jint QJNIObject::callMethod<jint>(const char *methodName, const char *sig, ...) +{ + QAttachedJNIEnv env; + jint res = 0; + jmethodID id = getCachedMethodID(env, m_jclass, methodName, sig); + if (id) { + va_list args; + va_start(args, sig); + res = env->CallIntMethodV(m_jobject, id, args); + va_end(args); + } + return res; +} + +template <> +jlong QJNIObject::callMethod<jlong>(const char *methodName, const char *sig, ...) +{ + QAttachedJNIEnv env; + jlong res = 0; + jmethodID id = getCachedMethodID(env, m_jclass, methodName, sig); + if (id) { + va_list args; + va_start(args, sig); + res = env->CallLongMethodV(m_jobject, id, args); + va_end(args); + } + return res; +} + +template <> +jfloat QJNIObject::callMethod<jfloat>(const char *methodName, const char *sig, ...) +{ + QAttachedJNIEnv env; + jfloat res = 0.f; + jmethodID id = getCachedMethodID(env, m_jclass, methodName, sig); + if (id) { + va_list args; + va_start(args, sig); + res = env->CallFloatMethodV(m_jobject, id, args); + va_end(args); + } + return res; +} + +template <> +jdouble QJNIObject::callMethod<jdouble>(const char *methodName, const char *sig, ...) +{ + QAttachedJNIEnv env; + jdouble res = 0.; + jmethodID id = getCachedMethodID(env, m_jclass, methodName, sig); + if (id) { + va_list args; + va_start(args, sig); + res = env->CallDoubleMethodV(m_jobject, id, args); + va_end(args); + } + return res; +} + +template <> +QJNILocalRef<jobject> QJNIObject::callObjectMethod<jobject>(const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + jobject res = 0; + jmethodID id = getCachedMethodID(env, m_jclass, methodName, sig); + if (id) { + va_list args; + va_start(args, sig); + res = env->CallObjectMethodV(m_jobject, id, args); + va_end(args); + } + return QJNILocalRef<jobject>(res); +} + +template <> +QJNILocalRef<jstring> QJNIObject::callObjectMethod<jstring>(const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + jstring res = 0; + jmethodID id = getCachedMethodID(env, m_jclass, methodName, sig); + if (id) { + va_list args; + va_start(args, sig); + res = static_cast<jstring>(env->CallObjectMethodV(m_jobject, id, args)); + va_end(args); + } + return QJNILocalRef<jstring>(res); +} + +template <> +QJNILocalRef<jobjectArray> QJNIObject::callObjectMethod<jobjectArray>(const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + jobjectArray res = 0; + jmethodID id = getCachedMethodID(env, m_jclass, methodName, sig); + if (id) { + va_list args; + va_start(args, sig); + res = static_cast<jobjectArray>(env->CallObjectMethodV(m_jobject, id, args)); + va_end(args); + } + return QJNILocalRef<jobjectArray>(res); +} + +template <> +QJNILocalRef<jbooleanArray> QJNIObject::callObjectMethod<jbooleanArray>(const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + jbooleanArray res = 0; + jmethodID id = getCachedMethodID(env, m_jclass, methodName, sig); + if (id) { + va_list args; + va_start(args, sig); + res = static_cast<jbooleanArray>(env->CallObjectMethodV(m_jobject, id, args)); + va_end(args); + } + return QJNILocalRef<jbooleanArray>(res); +} + +template <> +QJNILocalRef<jbyteArray> QJNIObject::callObjectMethod<jbyteArray>(const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + jbyteArray res = 0; + jmethodID id = getCachedMethodID(env, m_jclass, methodName, sig); + if (id) { + va_list args; + va_start(args, sig); + res = static_cast<jbyteArray>(env->CallObjectMethodV(m_jobject, id, args)); + va_end(args); + } + return QJNILocalRef<jbyteArray>(res); +} + +template <> +QJNILocalRef<jcharArray> QJNIObject::callObjectMethod<jcharArray>(const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + jcharArray res = 0; + jmethodID id = getCachedMethodID(env, m_jclass, methodName, sig); + if (id) { + va_list args; + va_start(args, sig); + res = static_cast<jcharArray>(env->CallObjectMethodV(m_jobject, id, args)); + va_end(args); + } + return QJNILocalRef<jcharArray>(res); +} + +template <> +QJNILocalRef<jshortArray> QJNIObject::callObjectMethod<jshortArray>(const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + jshortArray res = 0; + jmethodID id = getCachedMethodID(env, m_jclass, methodName, sig); + if (id) { + va_list args; + va_start(args, sig); + res = static_cast<jshortArray>(env->CallObjectMethodV(m_jobject, id, args)); + va_end(args); + } + return QJNILocalRef<jshortArray>(res); +} + +template <> +QJNILocalRef<jintArray> QJNIObject::callObjectMethod<jintArray>(const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + jintArray res = 0; + jmethodID id = getCachedMethodID(env, m_jclass, methodName, sig); + if (id) { + va_list args; + va_start(args, sig); + res = static_cast<jintArray>(env->CallObjectMethodV(m_jobject, id, args)); + va_end(args); + } + return QJNILocalRef<jintArray>(res); +} + +template <> +QJNILocalRef<jlongArray> QJNIObject::callObjectMethod<jlongArray>(const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + jlongArray res = 0; + jmethodID id = getCachedMethodID(env, m_jclass, methodName, sig); + if (id) { + va_list args; + va_start(args, sig); + res = static_cast<jlongArray>(env->CallObjectMethodV(m_jobject, id, args)); + va_end(args); + } + return QJNILocalRef<jlongArray>(res); +} + +template <> +QJNILocalRef<jfloatArray> QJNIObject::callObjectMethod<jfloatArray>(const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + jfloatArray res = 0; + jmethodID id = getCachedMethodID(env, m_jclass, methodName, sig); + if (id) { + va_list args; + va_start(args, sig); + res = static_cast<jfloatArray>(env->CallObjectMethodV(m_jobject, id, args)); + va_end(args); + } + return QJNILocalRef<jfloatArray>(res); +} + +template <> +QJNILocalRef<jdoubleArray> QJNIObject::callObjectMethod<jdoubleArray>(const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + jdoubleArray res = 0; + jmethodID id = getCachedMethodID(env, m_jclass, methodName, sig); + if (id) { + va_list args; + va_start(args, sig); + res = static_cast<jdoubleArray>(env->CallObjectMethodV(m_jobject, id, args)); + va_end(args); + } + return QJNILocalRef<jdoubleArray>(res); +} + +template <> +void QJNIObject::callMethod<void>(const char *methodName) +{ + callMethod<void>(methodName, "()V"); +} + +template <> +jboolean QJNIObject::callMethod<jboolean>(const char *methodName) +{ + return callMethod<jboolean>(methodName, "()Z"); +} + +template <> +jbyte QJNIObject::callMethod<jbyte>(const char *methodName) +{ + return callMethod<jbyte>(methodName, "()B"); +} + +template <> +jchar QJNIObject::callMethod<jchar>(const char *methodName) +{ + return callMethod<jchar>(methodName, "()C"); +} + +template <> +jshort QJNIObject::callMethod<jshort>(const char *methodName) +{ + return callMethod<jshort>(methodName, "()S"); +} + +template <> +jint QJNIObject::callMethod<jint>(const char *methodName) +{ + return callMethod<jint>(methodName, "()I"); +} + +template <> +jlong QJNIObject::callMethod<jlong>(const char *methodName) +{ + return callMethod<jlong>(methodName, "()J"); +} + +template <> +jfloat QJNIObject::callMethod<jfloat>(const char *methodName) +{ + return callMethod<jfloat>(methodName, "()F"); +} + +template <> +jdouble QJNIObject::callMethod<jdouble>(const char *methodName) +{ + return callMethod<jdouble>(methodName, "()D"); +} + +template <> +QJNILocalRef<jstring> QJNIObject::callObjectMethod<jstring>(const char *methodName) +{ + return callObjectMethod<jstring>(methodName, "()Ljava/lang/String;"); +} + +template <> +QJNILocalRef<jbooleanArray> QJNIObject::callObjectMethod<jbooleanArray>(const char *methodName) +{ + return callObjectMethod<jbooleanArray>(methodName, "()[Z"); +} + +template <> +QJNILocalRef<jbyteArray> QJNIObject::callObjectMethod<jbyteArray>(const char *methodName) +{ + return callObjectMethod<jbyteArray>(methodName, "()[B"); +} + +template <> +QJNILocalRef<jshortArray> QJNIObject::callObjectMethod<jshortArray>(const char *methodName) +{ + return callObjectMethod<jshortArray>(methodName, "()[S"); +} + +template <> +QJNILocalRef<jintArray> QJNIObject::callObjectMethod<jintArray>(const char *methodName) +{ + return callObjectMethod<jintArray>(methodName, "()[I"); +} + +template <> +QJNILocalRef<jlongArray> QJNIObject::callObjectMethod<jlongArray>(const char *methodName) +{ + return callObjectMethod<jlongArray>(methodName, "()[J"); +} + +template <> +QJNILocalRef<jfloatArray> QJNIObject::callObjectMethod<jfloatArray>(const char *methodName) +{ + return callObjectMethod<jfloatArray>(methodName, "()[F"); +} + +template <> +QJNILocalRef<jdoubleArray> QJNIObject::callObjectMethod<jdoubleArray>(const char *methodName) +{ + return callObjectMethod<jdoubleArray>(methodName, "()[D"); +} + +template <> +void QJNIObject::callStaticMethod<void>(const char *className, + const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + jclass clazz = getCachedClass(env, className); + if (clazz) { + jmethodID id = getCachedMethodID(env, clazz, methodName, sig, true); + if (id) { + va_list args; + va_start(args, sig); + env->CallStaticVoidMethodV(clazz, id, args); + va_end(args); + } + } +} + +template <> +void QJNIObject::callStaticMethod<void>(jclass clazz, + const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + jmethodID id = getCachedMethodID(env, clazz, methodName, sig, true); + if (id) { + va_list args; + va_start(args, sig); + env->CallStaticVoidMethodV(clazz, id, args); + va_end(args); + } +} + +template <> +jboolean QJNIObject::callStaticMethod<jboolean>(const char *className, + const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + + jboolean res = 0; + + jclass clazz = getCachedClass(env, className); + if (clazz) { + jmethodID id = getCachedMethodID(env, clazz, methodName, sig, true); + if (id) { + va_list args; + va_start(args, sig); + res = env->CallStaticBooleanMethodV(clazz, id, args); + va_end(args); + } + } + + return res; +} + +template <> +jboolean QJNIObject::callStaticMethod<jboolean>(jclass clazz, + const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + + jboolean res = 0; + + jmethodID id = getCachedMethodID(env, clazz, methodName, sig, true); + if (id) { + va_list args; + va_start(args, sig); + res = env->CallStaticBooleanMethodV(clazz, id, args); + va_end(args); + } + + return res; +} + +template <> +jbyte QJNIObject::callStaticMethod<jbyte>(const char *className, + const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + + jbyte res = 0; + + jclass clazz = getCachedClass(env, className); + if (clazz) { + jmethodID id = getCachedMethodID(env, clazz, methodName, sig, true); + if (id) { + va_list args; + va_start(args, sig); + res = env->CallStaticByteMethodV(clazz, id, args); + va_end(args); + } + } + + return res; +} + +template <> +jbyte QJNIObject::callStaticMethod<jbyte>(jclass clazz, + const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + + jbyte res = 0; + + jmethodID id = getCachedMethodID(env, clazz, methodName, sig, true); + if (id) { + va_list args; + va_start(args, sig); + res = env->CallStaticByteMethodV(clazz, id, args); + va_end(args); + } + + return res; +} + +template <> +jchar QJNIObject::callStaticMethod<jchar>(const char *className, + const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + + jchar res = 0; + + jclass clazz = getCachedClass(env, className); + if (clazz) { + jmethodID id = getCachedMethodID(env, clazz, methodName, sig, true); + if (id) { + va_list args; + va_start(args, sig); + res = env->CallStaticCharMethodV(clazz, id, args); + va_end(args); + } + } + + return res; +} + +template <> +jchar QJNIObject::callStaticMethod<jchar>(jclass clazz, + const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + + jchar res = 0; + + jmethodID id = getCachedMethodID(env, clazz, methodName, sig, true); + if (id) { + va_list args; + va_start(args, sig); + res = env->CallStaticCharMethodV(clazz, id, args); + va_end(args); + } + + return res; +} + + +template <> +jshort QJNIObject::callStaticMethod<jshort>(const char *className, + const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + + jshort res = 0; + + jclass clazz = getCachedClass(env, className); + if (clazz) { + jmethodID id = getCachedMethodID(env, clazz, methodName, sig, true); + if (id) { + va_list args; + va_start(args, sig); + res = env->CallStaticShortMethodV(clazz, id, args); + va_end(args); + } + } + + return res; +} + +template <> +jshort QJNIObject::callStaticMethod<jshort>(jclass clazz, + const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + + jshort res = 0; + + jmethodID id = getCachedMethodID(env, clazz, methodName, sig, true); + if (id) { + va_list args; + va_start(args, sig); + res = env->CallStaticShortMethodV(clazz, id, args); + va_end(args); + } + + return res; +} + +template <> +jint QJNIObject::callStaticMethod<jint>(const char *className, + const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + + jint res = 0; + + jclass clazz = getCachedClass(env, className); + if (clazz) { + jmethodID id = getCachedMethodID(env, clazz, methodName, sig, true); + if (id) { + va_list args; + va_start(args, sig); + res = env->CallStaticIntMethodV(clazz, id, args); + va_end(args); + } + } + + return res; +} + +template <> +jint QJNIObject::callStaticMethod<jint>(jclass clazz, + const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + + jint res = 0; + + jmethodID id = getCachedMethodID(env, clazz, methodName, sig, true); + if (id) { + va_list args; + va_start(args, sig); + res = env->CallStaticIntMethodV(clazz, id, args); + va_end(args); + } + + return res; +} + +template <> +jlong QJNIObject::callStaticMethod<jlong>(const char *className, + const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + + jlong res = 0; + + jclass clazz = getCachedClass(env, className); + if (clazz) { + jmethodID id = getCachedMethodID(env, clazz, methodName, sig, true); + if (id) { + va_list args; + va_start(args, sig); + res = env->CallStaticLongMethodV(clazz, id, args); + va_end(args); + } + } + + return res; +} + +template <> +jlong QJNIObject::callStaticMethod<jlong>(jclass clazz, + const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + + jlong res = 0; + + jmethodID id = getCachedMethodID(env, clazz, methodName, sig, true); + if (id) { + va_list args; + va_start(args, sig); + res = env->CallStaticLongMethodV(clazz, id, args); + va_end(args); + } + + return res; +} + +template <> +jfloat QJNIObject::callStaticMethod<jfloat>(const char *className, + const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + + jfloat res = 0.f; + + jclass clazz = getCachedClass(env, className); + if (clazz) { + jmethodID id = getCachedMethodID(env, clazz, methodName, sig, true); + if (id) { + va_list args; + va_start(args, sig); + res = env->CallStaticFloatMethodV(clazz, id, args); + va_end(args); + } + } + + return res; +} + +template <> +jfloat QJNIObject::callStaticMethod<jfloat>(jclass clazz, + const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + + jfloat res = 0.f; + + jmethodID id = getCachedMethodID(env, clazz, methodName, sig, true); + if (id) { + va_list args; + va_start(args, sig); + res = env->CallStaticFloatMethodV(clazz, id, args); + va_end(args); + } + + return res; +} + +template <> +jdouble QJNIObject::callStaticMethod<jdouble>(const char *className, + const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + + jdouble res = 0.; + + jclass clazz = getCachedClass(env, className); + if (clazz) { + jmethodID id = getCachedMethodID(env, clazz, methodName, sig, true); + if (id) { + va_list args; + va_start(args, sig); + res = env->CallStaticDoubleMethodV(clazz, id, args); + va_end(args); + } + } + + return res; +} + +template <> +jdouble QJNIObject::callStaticMethod<jdouble>(jclass clazz, + const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + + jdouble res = 0.; + + jmethodID id = getCachedMethodID(env, clazz, methodName, sig, true); + if (id) { + va_list args; + va_start(args, sig); + res = env->CallStaticDoubleMethodV(clazz, id, args); + va_end(args); + } + + return res; +} + +template <> +QJNILocalRef<jobject> QJNIObject::callStaticObjectMethod<jobject>(const char *className, + const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + + jobject res = 0; + + jclass clazz = getCachedClass(env, className); + if (clazz) { + jmethodID id = getCachedMethodID(env, clazz, methodName, sig, true); + if (id) { + va_list args; + va_start(args, sig); + res = env->CallStaticObjectMethodV(clazz, id, args); + va_end(args); + } + } + + return QJNILocalRef<jobject>(res); +} + +template <> +QJNILocalRef<jobject> QJNIObject::callStaticObjectMethod<jobject>(jclass clazz, + const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + + jobject res = 0; + + jmethodID id = getCachedMethodID(env, clazz, methodName, sig, true); + if (id) { + va_list args; + va_start(args, sig); + res = env->CallStaticObjectMethodV(clazz, id, args); + va_end(args); + } + + return QJNILocalRef<jobject>(res); +} + +template <> +QJNILocalRef<jstring> QJNIObject::callStaticObjectMethod<jstring>(const char *className, + const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + + jstring res = 0; + + jclass clazz = getCachedClass(env, className); + if (clazz) { + jmethodID id = getCachedMethodID(env, clazz, methodName, sig, true); + if (id) { + va_list args; + va_start(args, sig); + res = static_cast<jstring>(env->CallStaticObjectMethodV(clazz, id, args)); + va_end(args); + } + } + + return QJNILocalRef<jstring>(res); +} + +template <> +QJNILocalRef<jstring> QJNIObject::callStaticObjectMethod<jstring>(jclass clazz, + const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + + jstring res = 0; + + jmethodID id = getCachedMethodID(env, clazz, methodName, sig, true); + if (id) { + va_list args; + va_start(args, sig); + res = static_cast<jstring>(env->CallStaticObjectMethodV(clazz, id, args)); + va_end(args); + } + + return QJNILocalRef<jstring>(res); +} + +template <> +QJNILocalRef<jobjectArray> QJNIObject::callStaticObjectMethod<jobjectArray>(const char *className, + const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + + jobjectArray res = 0; + + jclass clazz = getCachedClass(env, className); + if (clazz) { + jmethodID id = getCachedMethodID(env, clazz, methodName, sig, true); + if (id) { + va_list args; + va_start(args, sig); + res = static_cast<jobjectArray>(env->CallStaticObjectMethodV(clazz, id, args)); + va_end(args); + } + } + + return QJNILocalRef<jobjectArray>(res); +} + +template <> +QJNILocalRef<jobjectArray> QJNIObject::callStaticObjectMethod<jobjectArray>(jclass clazz, + const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + + jobjectArray res = 0; + + jmethodID id = getCachedMethodID(env, clazz, methodName, sig, true); + if (id) { + va_list args; + va_start(args, sig); + res = static_cast<jobjectArray>(env->CallStaticObjectMethodV(clazz, id, args)); + va_end(args); + } + + return QJNILocalRef<jobjectArray>(res); +} + +template <> +QJNILocalRef<jbooleanArray> QJNIObject::callStaticObjectMethod<jbooleanArray>(const char *className, + const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + + jbooleanArray res = 0; + + jclass clazz = getCachedClass(env, className); + if (clazz) { + jmethodID id = getCachedMethodID(env, clazz, methodName, sig, true); + if (id) { + va_list args; + va_start(args, sig); + res = static_cast<jbooleanArray>(env->CallStaticObjectMethodV(clazz, id, args)); + va_end(args); + } + } + + return QJNILocalRef<jbooleanArray>(res); +} + +template <> +QJNILocalRef<jbooleanArray> QJNIObject::callStaticObjectMethod<jbooleanArray>(jclass clazz, + const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + + jbooleanArray res = 0; + + jmethodID id = getCachedMethodID(env, clazz, methodName, sig, true); + if (id) { + va_list args; + va_start(args, sig); + res = static_cast<jbooleanArray>(env->CallStaticObjectMethodV(clazz, id, args)); + va_end(args); + } + + return QJNILocalRef<jbooleanArray>(res); +} + +template <> +QJNILocalRef<jbyteArray> QJNIObject::callStaticObjectMethod<jbyteArray>(const char *className, + const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + + jbyteArray res = 0; + + jclass clazz = getCachedClass(env, className); + if (clazz) { + jmethodID id = getCachedMethodID(env, clazz, methodName, sig, true); + if (id) { + va_list args; + va_start(args, sig); + res = static_cast<jbyteArray>(env->CallStaticObjectMethodV(clazz, id, args)); + va_end(args); + } + } + + return QJNILocalRef<jbyteArray>(res); +} + +template <> +QJNILocalRef<jbyteArray> QJNIObject::callStaticObjectMethod<jbyteArray>(jclass clazz, + const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + + jbyteArray res = 0; + + jmethodID id = getCachedMethodID(env, clazz, methodName, sig, true); + if (id) { + va_list args; + va_start(args, sig); + res = static_cast<jbyteArray>(env->CallStaticObjectMethodV(clazz, id, args)); + va_end(args); + } + + return QJNILocalRef<jbyteArray>(res); +} + +template <> +QJNILocalRef<jcharArray> QJNIObject::callStaticObjectMethod<jcharArray>(const char *className, + const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + + jcharArray res = 0; + + jclass clazz = getCachedClass(env, className); + if (clazz) { + jmethodID id = getCachedMethodID(env, clazz, methodName, sig, true); + if (id) { + va_list args; + va_start(args, sig); + res = static_cast<jcharArray>(env->CallStaticObjectMethodV(clazz, id, args)); + va_end(args); + } + } + + return QJNILocalRef<jcharArray>(res); +} + +template <> +QJNILocalRef<jcharArray> QJNIObject::callStaticObjectMethod<jcharArray>(jclass clazz, + const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + + jcharArray res = 0; + + jmethodID id = getCachedMethodID(env, clazz, methodName, sig, true); + if (id) { + va_list args; + va_start(args, sig); + res = static_cast<jcharArray>(env->CallStaticObjectMethodV(clazz, id, args)); + va_end(args); + } + + return QJNILocalRef<jcharArray>(res); +} + +template <> +QJNILocalRef<jshortArray> QJNIObject::callStaticObjectMethod<jshortArray>(const char *className, + const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + + jshortArray res = 0; + + jclass clazz = getCachedClass(env, className); + if (clazz) { + jmethodID id = getCachedMethodID(env, clazz, methodName, sig, true); + if (id) { + va_list args; + va_start(args, sig); + res = static_cast<jshortArray>(env->CallStaticObjectMethodV(clazz, id, args)); + va_end(args); + } + } + + return QJNILocalRef<jshortArray>(res); +} + +template <> +QJNILocalRef<jshortArray> QJNIObject::callStaticObjectMethod<jshortArray>(jclass clazz, + const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + + jshortArray res = 0; + + jmethodID id = getCachedMethodID(env, clazz, methodName, sig, true); + if (id) { + va_list args; + va_start(args, sig); + res = static_cast<jshortArray>(env->CallStaticObjectMethodV(clazz, id, args)); + va_end(args); + } + + return QJNILocalRef<jshortArray>(res); +} + +template <> +QJNILocalRef<jintArray> QJNIObject::callStaticObjectMethod<jintArray>(const char *className, + const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + + jintArray res = 0; + + jclass clazz = getCachedClass(env, className); + if (clazz) { + jmethodID id = getCachedMethodID(env, clazz, methodName, sig, true); + if (id) { + va_list args; + va_start(args, sig); + res = static_cast<jintArray>(env->CallStaticObjectMethodV(clazz, id, args)); + va_end(args); + } + } + + return QJNILocalRef<jintArray>(res); +} + +template <> +QJNILocalRef<jintArray> QJNIObject::callStaticObjectMethod<jintArray>(jclass clazz, + const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + + jintArray res = 0; + + jmethodID id = getCachedMethodID(env, clazz, methodName, sig, true); + if (id) { + va_list args; + va_start(args, sig); + res = static_cast<jintArray>(env->CallStaticObjectMethodV(clazz, id, args)); + va_end(args); + } + + return QJNILocalRef<jintArray>(res); +} + +template <> +QJNILocalRef<jlongArray> QJNIObject::callStaticObjectMethod<jlongArray>(const char *className, + const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + + jlongArray res = 0; + + jclass clazz = getCachedClass(env, className); + if (clazz) { + jmethodID id = getCachedMethodID(env, clazz, methodName, sig, true); + if (id) { + va_list args; + va_start(args, sig); + res = static_cast<jlongArray>(env->CallStaticObjectMethodV(clazz, id, args)); + va_end(args); + } + } + + return QJNILocalRef<jlongArray>(res); +} + +template <> +QJNILocalRef<jlongArray> QJNIObject::callStaticObjectMethod<jlongArray>(jclass clazz, + const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + + jlongArray res = 0; + + jmethodID id = getCachedMethodID(env, clazz, methodName, sig, true); + if (id) { + va_list args; + va_start(args, sig); + res = static_cast<jlongArray>(env->CallStaticObjectMethodV(clazz, id, args)); + va_end(args); + } + + return QJNILocalRef<jlongArray>(res); +} + +template <> +QJNILocalRef<jfloatArray> QJNIObject::callStaticObjectMethod<jfloatArray>(const char *className, + const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + + jfloatArray res = 0; + + jclass clazz = getCachedClass(env, className); + if (clazz) { + jmethodID id = getCachedMethodID(env, clazz, methodName, sig, true); + if (id) { + va_list args; + va_start(args, sig); + res = static_cast<jfloatArray>(env->CallStaticObjectMethodV(clazz, id, args)); + va_end(args); + } + } + + return QJNILocalRef<jfloatArray>(res); +} + +template <> +QJNILocalRef<jfloatArray> QJNIObject::callStaticObjectMethod<jfloatArray>(jclass clazz, + const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + + jfloatArray res = 0; + + jmethodID id = getCachedMethodID(env, clazz, methodName, sig, true); + if (id) { + va_list args; + va_start(args, sig); + res = static_cast<jfloatArray>(env->CallStaticObjectMethodV(clazz, id, args)); + va_end(args); + } + + return QJNILocalRef<jfloatArray>(res); +} + +template <> +QJNILocalRef<jdoubleArray> QJNIObject::callStaticObjectMethod<jdoubleArray>(const char *className, + const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + + jdoubleArray res = 0; + + jclass clazz = getCachedClass(env, className); + if (clazz) { + jmethodID id = getCachedMethodID(env, clazz, methodName, sig, true); + if (id) { + va_list args; + va_start(args, sig); + res = static_cast<jdoubleArray>(env->CallStaticObjectMethodV(clazz, id, args)); + va_end(args); + } + } + + return QJNILocalRef<jdoubleArray>(res); +} + +template <> +QJNILocalRef<jdoubleArray> QJNIObject::callStaticObjectMethod<jdoubleArray>(jclass clazz, + const char *methodName, + const char *sig, + ...) +{ + QAttachedJNIEnv env; + + jdoubleArray res = 0; + + jmethodID id = getCachedMethodID(env, clazz, methodName, sig, true); + if (id) { + va_list args; + va_start(args, sig); + res = static_cast<jdoubleArray>(env->CallStaticObjectMethodV(clazz, id, args)); + va_end(args); + } + + return QJNILocalRef<jdoubleArray>(res); +} + +template <> +void QJNIObject::callStaticMethod<void>(const char *className, const char *methodName) +{ + callStaticMethod<void>(className, methodName, "()V"); +} + +template <> +void QJNIObject::callStaticMethod<void>(jclass clazz, const char *methodName) +{ + callStaticMethod<void>(clazz, methodName, "()V"); +} + +template <> +jboolean QJNIObject::callStaticMethod<jboolean>(const char *className, const char *methodName) +{ + return callStaticMethod<jboolean>(className, methodName, "()Z"); +} + +template <> +jboolean QJNIObject::callStaticMethod<jboolean>(jclass clazz, const char *methodName) +{ + return callStaticMethod<jboolean>(clazz, methodName, "()Z"); +} + +template <> +jbyte QJNIObject::callStaticMethod<jbyte>(const char *className, const char *methodName) +{ + return callStaticMethod<jbyte>(className, methodName, "()B"); +} + +template <> +jbyte QJNIObject::callStaticMethod<jbyte>(jclass clazz, const char *methodName) +{ + return callStaticMethod<jbyte>(clazz, methodName, "()B"); +} + +template <> +jchar QJNIObject::callStaticMethod<jchar>(const char *className, const char *methodName) +{ + return callStaticMethod<jchar>(className, methodName, "()C"); +} + +template <> +jchar QJNIObject::callStaticMethod<jchar>(jclass clazz, const char *methodName) +{ + return callStaticMethod<jchar>(clazz, methodName, "()C"); +} + +template <> +jshort QJNIObject::callStaticMethod<jshort>(const char *className, const char *methodName) +{ + return callStaticMethod<jshort>(className, methodName, "()S"); +} + +template <> +jshort QJNIObject::callStaticMethod<jshort>(jclass clazz, const char *methodName) +{ + return callStaticMethod<jshort>(clazz, methodName, "()S"); +} + +template <> +jint QJNIObject::callStaticMethod<jint>(const char *className, const char *methodName) +{ + return callStaticMethod<jint>(className, methodName, "()I"); +} + +template <> +jint QJNIObject::callStaticMethod<jint>(jclass clazz, const char *methodName) +{ + return callStaticMethod<jint>(clazz, methodName, "()I"); +} + +template <> +jlong QJNIObject::callStaticMethod<jlong>(const char *className, const char *methodName) +{ + return callStaticMethod<jlong>(className, methodName, "()J"); +} + +template <> +jlong QJNIObject::callStaticMethod<jlong>(jclass clazz, const char *methodName) +{ + return callStaticMethod<jlong>(clazz, methodName, "()J"); +} + +template <> +jfloat QJNIObject::callStaticMethod<jfloat>(const char *className, const char *methodName) +{ + return callStaticMethod<jfloat>(className, methodName, "()F"); +} + +template <> +jfloat QJNIObject::callStaticMethod<jfloat>(jclass clazz, const char *methodName) +{ + return callStaticMethod<jfloat>(clazz, methodName, "()F"); +} + +template <> +jdouble QJNIObject::callStaticMethod<jdouble>(const char *className, const char *methodName) +{ + return callStaticMethod<jdouble>(className, methodName, "()D"); +} + +template <> +jdouble QJNIObject::callStaticMethod<jdouble>(jclass clazz, const char *methodName) +{ + return callStaticMethod<jdouble>(clazz, methodName, "()D"); +} + +template <> +QJNILocalRef<jstring> QJNIObject::callStaticObjectMethod<jstring>(const char *className, + const char *methodName) +{ + return callStaticObjectMethod<jstring>(className, methodName, "()Ljava/lang/String;"); +} + +template <> +QJNILocalRef<jstring> QJNIObject::callStaticObjectMethod<jstring>(jclass clazz, + const char *methodName) +{ + return callStaticObjectMethod<jstring>(clazz, methodName, "()Ljava/lang/String;"); +} + +template <> +QJNILocalRef<jbooleanArray> QJNIObject::callStaticObjectMethod<jbooleanArray>(const char *className, + const char *methodName) +{ + return callStaticObjectMethod<jbooleanArray>(className, methodName, "()[Z"); +} + +template <> +QJNILocalRef<jbooleanArray> QJNIObject::callStaticObjectMethod<jbooleanArray>(jclass clazz, + const char *methodName) +{ + return callStaticObjectMethod<jbooleanArray>(clazz, methodName, "()[Z"); +} + +template <> +QJNILocalRef<jbyteArray> QJNIObject::callStaticObjectMethod<jbyteArray>(const char *className, + const char *methodName) +{ + return callStaticObjectMethod<jbyteArray>(className, methodName, "()[B"); +} + +template <> +QJNILocalRef<jbyteArray> QJNIObject::callStaticObjectMethod<jbyteArray>(jclass clazz, + const char *methodName) +{ + return callStaticObjectMethod<jbyteArray>(clazz, methodName, "()[B"); +} + +template <> +QJNILocalRef<jcharArray> QJNIObject::callStaticObjectMethod<jcharArray>(const char *className, + const char *methodName) +{ + return callStaticObjectMethod<jcharArray>(className, methodName, "()[C"); +} + +template <> +QJNILocalRef<jcharArray> QJNIObject::callStaticObjectMethod<jcharArray>(jclass clazz, + const char *methodName) +{ + return callStaticObjectMethod<jcharArray>(clazz, methodName, "()[C"); +} + +template <> +QJNILocalRef<jshortArray> QJNIObject::callStaticObjectMethod<jshortArray>(const char *className, + const char *methodName) +{ + return callStaticObjectMethod<jshortArray>(className, methodName, "()[S"); +} + +template <> +QJNILocalRef<jshortArray> QJNIObject::callStaticObjectMethod<jshortArray>(jclass clazz, + const char *methodName) +{ + return callStaticObjectMethod<jshortArray>(clazz, methodName, "()[S"); +} + +template <> +QJNILocalRef<jintArray> QJNIObject::callStaticObjectMethod<jintArray>(const char *className, + const char *methodName) +{ + return callStaticObjectMethod<jintArray>(className, methodName, "()[I"); +} + +template <> +QJNILocalRef<jintArray> QJNIObject::callStaticObjectMethod<jintArray>(jclass clazz, + const char *methodName) +{ + return callStaticObjectMethod<jintArray>(clazz, methodName, "()[I"); +} + +template <> +QJNILocalRef<jlongArray> QJNIObject::callStaticObjectMethod<jlongArray>(const char *className, + const char *methodName) +{ + return callStaticObjectMethod<jlongArray>(className, methodName, "()[J"); +} + +template <> +QJNILocalRef<jlongArray> QJNIObject::callStaticObjectMethod<jlongArray>(jclass clazz, + const char *methodName) +{ + return callStaticObjectMethod<jlongArray>(clazz, methodName, "()[J"); +} + +template <> +QJNILocalRef<jfloatArray> QJNIObject::callStaticObjectMethod<jfloatArray>(const char *className, + const char *methodName) +{ + return callStaticObjectMethod<jfloatArray>(className, methodName, "()[F"); +} + +template <> +QJNILocalRef<jfloatArray> QJNIObject::callStaticObjectMethod<jfloatArray>(jclass clazz, + const char *methodName) +{ + return callStaticObjectMethod<jfloatArray>(clazz, methodName, "()[F"); +} + +template <> +QJNILocalRef<jdoubleArray> QJNIObject::callStaticObjectMethod<jdoubleArray>(const char *className, + const char *methodName) +{ + return callStaticObjectMethod<jdoubleArray>(className, methodName, "()[D"); +} + +template <> +QJNILocalRef<jdoubleArray> QJNIObject::callStaticObjectMethod<jdoubleArray>(jclass clazz, + const char *methodName) +{ + return callStaticObjectMethod<jdoubleArray>(clazz, methodName, "()[D"); +} + +template <> +jboolean QJNIObject::getField<jboolean>(const char *fieldName) +{ + QAttachedJNIEnv env; + jboolean res = 0; + jfieldID id = getCachedFieldID(env, m_jclass, fieldName, "Z"); + if (id) + res = env->GetBooleanField(m_jobject, id); + + return res; +} + +template <> +jbyte QJNIObject::getField<jbyte>(const char *fieldName) +{ + QAttachedJNIEnv env; + jbyte res = 0; + jfieldID id = getCachedFieldID(env, m_jclass, fieldName, "B"); + if (id) + res = env->GetByteField(m_jobject, id); + + return res; +} + +template <> +jchar QJNIObject::getField<jchar>(const char *fieldName) +{ + QAttachedJNIEnv env; + jchar res = 0; + jfieldID id = getCachedFieldID(env, m_jclass, fieldName, "C"); + if (id) + res = env->GetCharField(m_jobject, id); + + return res; +} + +template <> +jshort QJNIObject::getField<jshort>(const char *fieldName) +{ + QAttachedJNIEnv env; + jshort res = 0; + jfieldID id = getCachedFieldID(env, m_jclass, fieldName, "S"); + if (id) + res = env->GetShortField(m_jobject, id); + + return res; +} + +template <> +jint QJNIObject::getField<jint>(const char *fieldName) +{ + QAttachedJNIEnv env; + jint res = 0; + jfieldID id = getCachedFieldID(env, m_jclass, fieldName, "I"); + if (id) + res = env->GetIntField(m_jobject, id); + + return res; +} + +template <> +jlong QJNIObject::getField<jlong>(const char *fieldName) +{ + QAttachedJNIEnv env; + jlong res = 0; + jfieldID id = getCachedFieldID(env, m_jclass, fieldName, "J"); + if (id) + res = env->GetLongField(m_jobject, id); + + return res; +} + +template <> +jfloat QJNIObject::getField<jfloat>(const char *fieldName) +{ + QAttachedJNIEnv env; + jfloat res = 0.f; + jfieldID id = getCachedFieldID(env, m_jclass, fieldName, "F"); + if (id) + res = env->GetFloatField(m_jobject, id); + + return res; +} + +template <> +jdouble QJNIObject::getField<jdouble>(const char *fieldName) +{ + QAttachedJNIEnv env; + jdouble res = 0.; + jfieldID id = getCachedFieldID(env, m_jclass, fieldName, "D"); + if (id) + res = env->GetDoubleField(m_jobject, id); + + return res; +} + +template <> +QJNILocalRef<jobject> QJNIObject::getObjectField<jobject>(const char *fieldName, const char *sig) +{ + QAttachedJNIEnv env; + jobject res = 0; + jfieldID id = getCachedFieldID(env, m_jclass, fieldName, sig); + if (id) + res = env->GetObjectField(m_jobject, id); + + return QJNILocalRef<jobject>(res); +} + +template <> +QJNILocalRef<jbooleanArray> QJNIObject::getObjectField<jbooleanArray>(const char *fieldName) +{ + QAttachedJNIEnv env; + jbooleanArray res = 0; + jfieldID id = getCachedFieldID(env, m_jclass, fieldName, "[Z"); + if (id) + res = static_cast<jbooleanArray>(env->GetObjectField(m_jobject, id)); + + return QJNILocalRef<jbooleanArray>(res); +} + +template <> +QJNILocalRef<jbyteArray> QJNIObject::getObjectField<jbyteArray>(const char *fieldName) +{ + QAttachedJNIEnv env; + jbyteArray res = 0; + jfieldID id = getCachedFieldID(env, m_jclass, fieldName, "[B"); + if (id) + res = static_cast<jbyteArray>(env->GetObjectField(m_jobject, id)); + + return QJNILocalRef<jbyteArray>(res); +} + +template <> +QJNILocalRef<jcharArray> QJNIObject::getObjectField<jcharArray>(const char *fieldName) +{ + QAttachedJNIEnv env; + jcharArray res = 0; + jfieldID id = getCachedFieldID(env, m_jclass, fieldName, "[C"); + if (id) + res = static_cast<jcharArray>(env->GetObjectField(m_jobject, id)); + + return QJNILocalRef<jcharArray>(res); +} + +template <> +QJNILocalRef<jshortArray> QJNIObject::getObjectField<jshortArray>(const char *fieldName) +{ + QAttachedJNIEnv env; + jshortArray res = 0; + jfieldID id = getCachedFieldID(env, m_jclass, fieldName, "[S"); + if (id) + res = static_cast<jshortArray>(env->GetObjectField(m_jobject, id)); + + return QJNILocalRef<jshortArray>(res); +} + +template <> +QJNILocalRef<jintArray> QJNIObject::getObjectField<jintArray>(const char *fieldName) +{ + QAttachedJNIEnv env; + jintArray res = 0; + jfieldID id = getCachedFieldID(env, m_jclass, fieldName, "[I"); + if (id) + res = static_cast<jintArray>(env->GetObjectField(m_jobject, id)); + + return QJNILocalRef<jintArray>(res); +} + +template <> +QJNILocalRef<jlongArray> QJNIObject::getObjectField<jlongArray>(const char *fieldName) +{ + QAttachedJNIEnv env; + jlongArray res = 0; + jfieldID id = getCachedFieldID(env, m_jclass, fieldName, "[J"); + if (id) + res = static_cast<jlongArray>(env->GetObjectField(m_jobject, id)); + + return QJNILocalRef<jlongArray>(res); +} + +template <> +QJNILocalRef<jfloatArray> QJNIObject::getObjectField<jfloatArray>(const char *fieldName) +{ + QAttachedJNIEnv env; + jfloatArray res = 0; + jfieldID id = getCachedFieldID(env, m_jclass, fieldName, "[F"); + if (id) + res = static_cast<jfloatArray>(env->GetObjectField(m_jobject, id)); + + return QJNILocalRef<jfloatArray>(res); +} + +template <> +QJNILocalRef<jdoubleArray> QJNIObject::getObjectField<jdoubleArray>(const char *fieldName) +{ + QAttachedJNIEnv env; + jdoubleArray res = 0; + jfieldID id = getCachedFieldID(env, m_jclass, fieldName, "[D"); + if (id) + res = static_cast<jdoubleArray>(env->GetObjectField(m_jobject, id)); + + return QJNILocalRef<jdoubleArray>(res); +} + +template <> +QJNILocalRef<jstring> QJNIObject::getObjectField<jstring>(const char *fieldName) +{ + QAttachedJNIEnv env; + jstring res = 0; + jfieldID id = getCachedFieldID(env, m_jclass, fieldName, "Ljava/lang/String;"); + if (id) + res = static_cast<jstring>(env->GetObjectField(m_jobject, id)); + + return QJNILocalRef<jstring>(res); +} + +template <> +QJNILocalRef<jobjectArray> QJNIObject::getObjectField<jobjectArray>(const char *fieldName, + const char *sig) +{ + QAttachedJNIEnv env; + jobjectArray res = 0; + jfieldID id = getCachedFieldID(env, m_jclass, fieldName, sig); + if (id) + res = static_cast<jobjectArray>(env->GetObjectField(m_jobject, id)); + + return QJNILocalRef<jobjectArray>(res); +} + +template <> +void QJNIObject::setField<jboolean>(const char *fieldName, jboolean value) +{ + QAttachedJNIEnv env; + jfieldID id = getCachedFieldID(env, m_jclass, fieldName, "Z"); + if (id) + env->SetBooleanField(m_jobject, id, value); + +} + +template <> +void QJNIObject::setField<jbyte>(const char *fieldName, jbyte value) +{ + QAttachedJNIEnv env; + jfieldID id = getCachedFieldID(env, m_jclass, fieldName, "B"); + if (id) + env->SetByteField(m_jobject, id, value); + +} + +template <> +void QJNIObject::setField<jchar>(const char *fieldName, jchar value) +{ + QAttachedJNIEnv env; + jfieldID id = getCachedFieldID(env, m_jclass, fieldName, "C"); + if (id) + env->SetCharField(m_jobject, id, value); + +} + +template <> +void QJNIObject::setField<jshort>(const char *fieldName, jshort value) +{ + QAttachedJNIEnv env; + jfieldID id = getCachedFieldID(env, m_jclass, fieldName, "S"); + if (id) + env->SetShortField(m_jobject, id, value); + +} + +template <> +void QJNIObject::setField<jint>(const char *fieldName, jint value) +{ + QAttachedJNIEnv env; + jfieldID id = getCachedFieldID(env, m_jclass, fieldName, "I"); + if (id) + env->SetIntField(m_jobject, id, value); + +} + +template <> +void QJNIObject::setField<jlong>(const char *fieldName, jlong value) +{ + QAttachedJNIEnv env; + jfieldID id = getCachedFieldID(env, m_jclass, fieldName, "J"); + if (id) + env->SetLongField(m_jobject, id, value); + +} + +template <> +void QJNIObject::setField<jfloat>(const char *fieldName, jfloat value) +{ + QAttachedJNIEnv env; + jfieldID id = getCachedFieldID(env, m_jclass, fieldName, "F"); + if (id) + env->SetFloatField(m_jobject, id, value); + +} + +template <> +void QJNIObject::setField<jdouble>(const char *fieldName, jdouble value) +{ + QAttachedJNIEnv env; + jfieldID id = getCachedFieldID(env, m_jclass, fieldName, "D"); + if (id) + env->SetDoubleField(m_jobject, id, value); + +} + +template <> +void QJNIObject::setField<jbooleanArray>(const char *fieldName, jbooleanArray value) +{ + QAttachedJNIEnv env; + jfieldID id = getCachedFieldID(env, m_jclass, fieldName, "[Z"); + if (id) + env->SetObjectField(m_jobject, id, value); + +} + +template <> +void QJNIObject::setField<jbyteArray>(const char *fieldName, jbyteArray value) +{ + QAttachedJNIEnv env; + jfieldID id = getCachedFieldID(env, m_jclass, fieldName, "[B"); + if (id) + env->SetObjectField(m_jobject, id, value); + +} + +template <> +void QJNIObject::setField<jcharArray>(const char *fieldName, jcharArray value) +{ + QAttachedJNIEnv env; + jfieldID id = getCachedFieldID(env, m_jclass, fieldName, "[C"); + if (id) + env->SetObjectField(m_jobject, id, value); + +} + +template <> +void QJNIObject::setField<jshortArray>(const char *fieldName, jshortArray value) +{ + QAttachedJNIEnv env; + jfieldID id = getCachedFieldID(env, m_jclass, fieldName, "[S"); + if (id) + env->SetObjectField(m_jobject, id, value); + +} + +template <> +void QJNIObject::setField<jintArray>(const char *fieldName, jintArray value) +{ + QAttachedJNIEnv env; + jfieldID id = getCachedFieldID(env, m_jclass, fieldName, "[I"); + if (id) + env->SetObjectField(m_jobject, id, value); + +} + +template <> +void QJNIObject::setField<jlongArray>(const char *fieldName, jlongArray value) +{ + QAttachedJNIEnv env; + jfieldID id = getCachedFieldID(env, m_jclass, fieldName, "[J"); + if (id) + env->SetObjectField(m_jobject, id, value); + +} + +template <> +void QJNIObject::setField<jfloatArray>(const char *fieldName, jfloatArray value) +{ + QAttachedJNIEnv env; + jfieldID id = getCachedFieldID(env, m_jclass, fieldName, "[F"); + if (id) + env->SetObjectField(m_jobject, id, value); + +} + +template <> +void QJNIObject::setField<jdoubleArray>(const char *fieldName, jdoubleArray value) +{ + QAttachedJNIEnv env; + jfieldID id = getCachedFieldID(env, m_jclass, fieldName, "[D"); + if (id) + env->SetObjectField(m_jobject, id, value); + +} + +template <> +void QJNIObject::setField<jstring>(const char *fieldName, jstring value) +{ + QAttachedJNIEnv env; + jfieldID id = getCachedFieldID(env, m_jclass, fieldName, "Ljava/lang/String;"); + if (id) + env->SetObjectField(m_jobject, id, value); + +} + +template <> +void QJNIObject::setField<jobject>(const char *fieldName, const char *sig, jobject value) +{ + QAttachedJNIEnv env; + jfieldID id = getCachedFieldID(env, m_jclass, fieldName, sig); + if (id) + env->SetObjectField(m_jobject, id, value); + +} + +template <> +void QJNIObject::setField<jobjectArray>(const char *fieldName, + const char *sig, + jobjectArray value) +{ + QAttachedJNIEnv env; + jfieldID id = getCachedFieldID(env, m_jclass, fieldName, sig); + if (id) + env->SetObjectField(m_jobject, id, value); + +} + +template <> +jboolean QJNIObject::getStaticField<jboolean>(jclass clazz, const char *fieldName) +{ + QAttachedJNIEnv env; + + jboolean res = 0; + + jfieldID id = getCachedFieldID(env, clazz, fieldName, "Z", true); + if (id) + res = env->GetStaticBooleanField(clazz, id); + + return res; +} + +template <> +jboolean QJNIObject::getStaticField<jboolean>(const char *className, const char *fieldName) +{ + QAttachedJNIEnv env; + + jboolean res = 0; + + jclass clazz = getCachedClass(env, className); + if (clazz) + res = getStaticField<jboolean>(clazz, fieldName); + + return res; +} + +template <> +jbyte QJNIObject::getStaticField<jbyte>(jclass clazz, const char *fieldName) +{ + QAttachedJNIEnv env; + + jbyte res = 0; + + jfieldID id = getCachedFieldID(env, clazz, fieldName, "B", true); + if (id) + res = env->GetStaticByteField(clazz, id); + + return res; +} + +template <> +jbyte QJNIObject::getStaticField<jbyte>(const char *className, const char *fieldName) +{ + QAttachedJNIEnv env; + + jbyte res = 0; + + jclass clazz = getCachedClass(env, className); + if (clazz) + res = getStaticField<jbyte>(clazz, fieldName); + + return res; +} + +template <> +jchar QJNIObject::getStaticField<jchar>(jclass clazz, const char *fieldName) +{ + QAttachedJNIEnv env; + + jchar res = 0; + + jfieldID id = getCachedFieldID(env, clazz, fieldName, "C", true); + if (id) + res = env->GetStaticCharField(clazz, id); + + return res; +} + +template <> +jchar QJNIObject::getStaticField<jchar>(const char *className, const char *fieldName) +{ + QAttachedJNIEnv env; + + jchar res = 0; + + jclass clazz = getCachedClass(env, className); + if (clazz) + res = getStaticField<jchar>(clazz, fieldName); + + return res; +} + +template <> +jshort QJNIObject::getStaticField<jshort>(jclass clazz, const char *fieldName) +{ + QAttachedJNIEnv env; + + jshort res = 0; + + jfieldID id = getCachedFieldID(env, clazz, fieldName, "S", true); + if (id) + res = env->GetStaticShortField(clazz, id); + + return res; +} + +template <> +jshort QJNIObject::getStaticField<jshort>(const char *className, const char *fieldName) +{ + QAttachedJNIEnv env; + + jshort res = 0; + + jclass clazz = getCachedClass(env, className); + if (clazz) + res = getStaticField<jshort>(clazz, fieldName); + + return res; +} + +template <> +jint QJNIObject::getStaticField<jint>(jclass clazz, const char *fieldName) +{ + QAttachedJNIEnv env; + + jint res = 0; + + jfieldID id = getCachedFieldID(env, clazz, fieldName, "I", true); + if (id) + res = env->GetStaticIntField(clazz, id); + + return res; +} + +template <> +jint QJNIObject::getStaticField<jint>(const char *className, const char *fieldName) +{ + QAttachedJNIEnv env; + + jint res = 0; + + jclass clazz = getCachedClass(env, className); + if (clazz) + res = getStaticField<jint>(clazz, fieldName); + + return res; +} + +template <> +jlong QJNIObject::getStaticField<jlong>(jclass clazz, const char *fieldName) +{ + QAttachedJNIEnv env; + + jlong res = 0; + + jfieldID id = getCachedFieldID(env, clazz, fieldName, "J", true); + if (id) + res = env->GetStaticLongField(clazz, id); + + return res; +} + +template <> +jlong QJNIObject::getStaticField<jlong>(const char *className, const char *fieldName) +{ + QAttachedJNIEnv env; + + jlong res = 0; + + jclass clazz = getCachedClass(env, className); + if (clazz) + res = getStaticField<jlong>(clazz, fieldName); + + return res; +} + +template <> +jfloat QJNIObject::getStaticField<jfloat>(jclass clazz, const char *fieldName) +{ + QAttachedJNIEnv env; + + jfloat res = 0.f; + + jfieldID id = getCachedFieldID(env, clazz, fieldName, "F", true); + if (id) + res = env->GetStaticFloatField(clazz, id); + + return res; +} + +template <> +jfloat QJNIObject::getStaticField<jfloat>(const char *className, const char *fieldName) +{ + QAttachedJNIEnv env; + + jfloat res = 0.f; + + jclass clazz = getCachedClass(env, className); + if (clazz) + res = getStaticField<jfloat>(clazz, fieldName); + + return res; +} + +template <> +jdouble QJNIObject::getStaticField<jdouble>(jclass clazz, const char *fieldName) +{ + QAttachedJNIEnv env; + + jdouble res = 0.; + + jfieldID id = getCachedFieldID(env, clazz, fieldName, "D", true); + if (id) + res = env->GetStaticDoubleField(clazz, id); + + return res; +} + +template <> +jdouble QJNIObject::getStaticField<jdouble>(const char *className, const char *fieldName) +{ + QAttachedJNIEnv env; + + jdouble res = 0.; + + jclass clazz = getCachedClass(env, className); + if (clazz) + res = getStaticField<jdouble>(clazz, fieldName); + + return res; +} + +template <> +QJNILocalRef<jobject> QJNIObject::getStaticObjectField<jobject>(jclass clazz, + const char *fieldName, + const char *sig) +{ + QAttachedJNIEnv env; + + jobject res = 0; + + jfieldID id = getCachedFieldID(env, clazz, fieldName, sig, true); + if (id) + res = env->GetStaticObjectField(clazz, id); + + return QJNILocalRef<jobject>(res); +} + +template <> +QJNILocalRef<jobject> QJNIObject::getStaticObjectField<jobject>(const char *className, + const char *fieldName, + const char *sig) +{ + QAttachedJNIEnv env; + + QJNILocalRef<jobject> res; + + jclass clazz = getCachedClass(env, className); + if (clazz) + res = getStaticObjectField<jobject>(clazz, fieldName, sig); + + return res; +} + +template <> +QJNILocalRef<jstring> QJNIObject::getStaticObjectField<jstring>(jclass clazz, + const char *fieldName) +{ + QAttachedJNIEnv env; + + jstring res = 0; + + jfieldID id = getCachedFieldID(env, clazz, fieldName, "Ljava/lang/String;", true); + if (id) + res = static_cast<jstring>(env->GetStaticObjectField(clazz, id)); + + return QJNILocalRef<jstring>(res); +} + +template <> +QJNILocalRef<jstring> QJNIObject::getStaticObjectField<jstring>(const char *className, + const char *fieldName) +{ + QAttachedJNIEnv env; + + QJNILocalRef<jstring> res; + + jclass clazz = getCachedClass(env, className); + if (clazz) + res = getStaticObjectField<jstring>(clazz, fieldName); + + return res; +} + +template <> +QJNILocalRef<jbooleanArray> QJNIObject::getStaticObjectField<jbooleanArray>(jclass clazz, + const char *fieldName) +{ + QAttachedJNIEnv env; + + jbooleanArray res = 0; + + jfieldID id = getCachedFieldID(env, clazz, fieldName, "[Z", true); + if (id) + res = static_cast<jbooleanArray>(env->GetStaticObjectField(clazz, id)); + + return QJNILocalRef<jbooleanArray>(res); +} + +template <> +QJNILocalRef<jbooleanArray> QJNIObject::getStaticObjectField<jbooleanArray>(const char *className, + const char *fieldName) +{ + QAttachedJNIEnv env; + + QJNILocalRef<jbooleanArray> res; + + jclass clazz = getCachedClass(env, className); + if (clazz) + res = getStaticObjectField<jbooleanArray>(clazz, fieldName); + + return res; +} + +template <> +QJNILocalRef<jbyteArray> QJNIObject::getStaticObjectField<jbyteArray>(jclass clazz, + const char *fieldName) +{ + QAttachedJNIEnv env; + + jbyteArray res = 0; + + jfieldID id = getCachedFieldID(env, clazz, fieldName, "[B", true); + if (id) + res = static_cast<jbyteArray>(env->GetStaticObjectField(clazz, id)); + + return QJNILocalRef<jbyteArray>(res); +} + +template <> +QJNILocalRef<jbyteArray> QJNIObject::getStaticObjectField<jbyteArray>(const char *className, + const char *fieldName) +{ + QAttachedJNIEnv env; + + QJNILocalRef<jbyteArray> res; + + jclass clazz = getCachedClass(env, className); + if (clazz) + res = getStaticObjectField<jbyteArray>(clazz, fieldName); + + return res; +} + +template <> +QJNILocalRef<jcharArray> QJNIObject::getStaticObjectField<jcharArray>(jclass clazz, + const char *fieldName) +{ + QAttachedJNIEnv env; + + jcharArray res = 0; + + jfieldID id = getCachedFieldID(env, clazz, fieldName, "[C", true); + if (id) + res = static_cast<jcharArray>(env->GetStaticObjectField(clazz, id)); + + return QJNILocalRef<jcharArray>(res); +} + +template <> +QJNILocalRef<jcharArray> QJNIObject::getStaticObjectField<jcharArray>(const char *className, + const char *fieldName) +{ + QAttachedJNIEnv env; + + QJNILocalRef<jcharArray> res; + + jclass clazz = getCachedClass(env, className); + if (clazz) + res = getStaticObjectField<jcharArray>(clazz, fieldName); + + return res; +} + +template <> +QJNILocalRef<jshortArray> QJNIObject::getStaticObjectField<jshortArray>(jclass clazz, + const char *fieldName) +{ + QAttachedJNIEnv env; + + jshortArray res = 0; + + jfieldID id = getCachedFieldID(env, clazz, fieldName, "[S", true); + if (id) + res = static_cast<jshortArray>(env->GetStaticObjectField(clazz, id)); + + return QJNILocalRef<jshortArray>(res); +} + +template <> +QJNILocalRef<jshortArray> QJNIObject::getStaticObjectField<jshortArray>(const char *className, + const char *fieldName) +{ + QAttachedJNIEnv env; + + QJNILocalRef<jshortArray> res; + + jclass clazz = getCachedClass(env, className); + if (clazz) + res = getStaticObjectField<jshortArray>(clazz, fieldName); + + return res; +} + +template <> +QJNILocalRef<jintArray> QJNIObject::getStaticObjectField<jintArray>(jclass clazz, + const char *fieldName) +{ + QAttachedJNIEnv env; + + jintArray res = 0; + + jfieldID id = getCachedFieldID(env, clazz, fieldName, "[I", true); + if (id) + res = static_cast<jintArray>(env->GetStaticObjectField(clazz, id)); + + return QJNILocalRef<jintArray>(res); +} + +template <> +QJNILocalRef<jintArray> QJNIObject::getStaticObjectField<jintArray>(const char *className, + const char *fieldName) +{ + QAttachedJNIEnv env; + + QJNILocalRef<jintArray> res; + + jclass clazz = getCachedClass(env, className); + if (clazz) + res = getStaticObjectField<jintArray>(clazz, fieldName); + + return res; +} + +template <> +QJNILocalRef<jlongArray> QJNIObject::getStaticObjectField<jlongArray>(jclass clazz, + const char *fieldName) +{ + QAttachedJNIEnv env; + + jlongArray res = 0; + + jfieldID id = getCachedFieldID(env, clazz, fieldName, "[J", true); + if (id) + res = static_cast<jlongArray>(env->GetStaticObjectField(clazz, id)); + + return QJNILocalRef<jlongArray>(res); +} + +template <> +QJNILocalRef<jlongArray> QJNIObject::getStaticObjectField<jlongArray>(const char *className, + const char *fieldName) +{ + QAttachedJNIEnv env; + + QJNILocalRef<jlongArray> res; + + jclass clazz = getCachedClass(env, className); + if (clazz) + res = getStaticObjectField<jlongArray>(clazz, fieldName); + + return res; +} + +template <> +QJNILocalRef<jfloatArray> QJNIObject::getStaticObjectField<jfloatArray>(jclass clazz, + const char *fieldName) +{ + QAttachedJNIEnv env; + + jfloatArray res = 0; + + jfieldID id = getCachedFieldID(env, clazz, fieldName, "[F", true); + if (id) + res = static_cast<jfloatArray>(env->GetStaticObjectField(clazz, id)); + + return QJNILocalRef<jfloatArray>(res); +} + +template <> +QJNILocalRef<jfloatArray> QJNIObject::getStaticObjectField<jfloatArray>(const char *className, + const char *fieldName) +{ + QAttachedJNIEnv env; + + QJNILocalRef<jfloatArray> res; + + jclass clazz = getCachedClass(env, className); + if (clazz) + res = getStaticObjectField<jfloatArray>(clazz, fieldName); + + return res; +} + +template <> +QJNILocalRef<jdoubleArray> QJNIObject::getStaticObjectField<jdoubleArray>(jclass clazz, + const char *fieldName) +{ + QAttachedJNIEnv env; + + jdoubleArray res = 0; + + jfieldID id = getCachedFieldID(env, clazz, fieldName, "[D", true); + if (id) + res = static_cast<jdoubleArray>(env->GetStaticObjectField(clazz, id)); + + return QJNILocalRef<jdoubleArray>(res); +} + +template <> +QJNILocalRef<jdoubleArray> QJNIObject::getStaticObjectField<jdoubleArray>(const char *className, + const char *fieldName) +{ + QAttachedJNIEnv env; + + QJNILocalRef<jdoubleArray> res; + + jclass clazz = getCachedClass(env, className); + if (clazz) + res = getStaticObjectField<jdoubleArray>(clazz, fieldName); + + return res; +} + +template <> +QJNILocalRef<jobjectArray> QJNIObject::getStaticObjectField<jobjectArray>(jclass clazz, + const char *fieldName, + const char *sig) +{ + QAttachedJNIEnv env; + + jobjectArray res = 0; + + jfieldID id = getCachedFieldID(env, clazz, fieldName, sig, true); + if (id) + res = static_cast<jobjectArray>(env->GetStaticObjectField(clazz, id)); + + return QJNILocalRef<jobjectArray>(res); +} + +template <> +QJNILocalRef<jobjectArray> QJNIObject::getStaticObjectField<jobjectArray>(const char *className, + const char *fieldName, + const char *sig) +{ + QAttachedJNIEnv env; + + QJNILocalRef<jobjectArray> res; + + jclass clazz = getCachedClass(env, className); + if (clazz) + res = getStaticObjectField<jobjectArray>(clazz, fieldName, sig); + + return res; +} + +template <> +void QJNIObject::setStaticField<jboolean>(jclass clazz, const char *fieldName, jboolean value) +{ + QAttachedJNIEnv env; + jfieldID id = getCachedFieldID(env, clazz, fieldName, "Z", true); + if (id) + env->SetStaticBooleanField(clazz, id, value); +} + +template <> +void QJNIObject::setStaticField<jboolean>(const char *className, + const char *fieldName, + jboolean value) +{ + QAttachedJNIEnv env; + jclass clazz = getCachedClass(env, className); + if (clazz) + setStaticField<jboolean>(clazz, fieldName, value); +} + +template <> +void QJNIObject::setStaticField<jbyte>(jclass clazz, const char *fieldName, jbyte value) +{ + QAttachedJNIEnv env; + jfieldID id = getCachedFieldID(env, clazz, fieldName, "B", true); + if (id) + env->SetStaticByteField(clazz, id, value); +} + +template <> +void QJNIObject::setStaticField<jbyte>(const char *className, + const char *fieldName, + jbyte value) +{ + QAttachedJNIEnv env; + jclass clazz = getCachedClass(env, className); + if (clazz) + setStaticField<jbyte>(clazz, fieldName, value); +} + +template <> +void QJNIObject::setStaticField<jchar>(jclass clazz, const char *fieldName, jchar value) +{ + QAttachedJNIEnv env; + jfieldID id = getCachedFieldID(env, clazz, fieldName, "C", true); + if (id) + env->SetStaticCharField(clazz, id, value); +} + +template <> +void QJNIObject::setStaticField<jchar>(const char *className, + const char *fieldName, + jchar value) +{ + QAttachedJNIEnv env; + jclass clazz = getCachedClass(env, className); + if (clazz) + setStaticField<jchar>(clazz, fieldName, value); +} + +template <> +void QJNIObject::setStaticField<jshort>(jclass clazz, const char *fieldName, jshort value) +{ + QAttachedJNIEnv env; + jfieldID id = getCachedFieldID(env, clazz, fieldName, "S", true); + if (id) + env->SetStaticShortField(clazz, id, value); +} + +template <> +void QJNIObject::setStaticField<jshort>(const char *className, + const char *fieldName, + jshort value) +{ + QAttachedJNIEnv env; + jclass clazz = getCachedClass(env, className); + if (clazz) + setStaticField<jshort>(clazz, fieldName, value); +} + +template <> +void QJNIObject::setStaticField<jint>(jclass clazz, const char *fieldName, jint value) +{ + QAttachedJNIEnv env; + jfieldID id = getCachedFieldID(env, clazz, fieldName, "I", true); + if (id) + env->SetStaticIntField(clazz, id, value); +} + +template <> +void QJNIObject::setStaticField<jint>(const char *className, const char *fieldName, jint value) +{ + QAttachedJNIEnv env; + jclass clazz = getCachedClass(env, className); + if (clazz) + setStaticField<jint>(clazz, fieldName, value); +} + +template <> +void QJNIObject::setStaticField<jlong>(jclass clazz, const char *fieldName, jlong value) +{ + QAttachedJNIEnv env; + jfieldID id = getCachedFieldID(env, clazz, fieldName, "J", true); + if (id) + env->SetStaticLongField(clazz, id, value); +} + +template <> +void QJNIObject::setStaticField<jlong>(const char *className, + const char *fieldName, + jlong value) +{ + QAttachedJNIEnv env; + jclass clazz = getCachedClass(env, className); + if (clazz) + setStaticField<jlong>(clazz, fieldName, value); +} + +template <> +void QJNIObject::setStaticField<jfloat>(jclass clazz, const char *fieldName, jfloat value) +{ + QAttachedJNIEnv env; + jfieldID id = getCachedFieldID(env, clazz, fieldName, "F", true); + if (id) + env->SetStaticFloatField(clazz, id, value); +} + +template <> +void QJNIObject::setStaticField<jfloat>(const char *className, + const char *fieldName, + jfloat value) +{ + QAttachedJNIEnv env; + jclass clazz = getCachedClass(env, className); + if (clazz) + setStaticField<jfloat>(clazz, fieldName, value); +} + +template <> +void QJNIObject::setStaticField<jdouble>(jclass clazz, const char *fieldName, jdouble value) +{ + QAttachedJNIEnv env; + jfieldID id = getCachedFieldID(env, clazz, fieldName, "D", true); + if (id) + env->SetStaticDoubleField(clazz, id, value); +} + +template <> +void QJNIObject::setStaticField<jdouble>(const char *className, + const char *fieldName, + jdouble value) +{ + QAttachedJNIEnv env; + jclass clazz = getCachedClass(env, className); + if (clazz) + setStaticField<jdouble>(clazz, fieldName, value); +} + +template <> +void QJNIObject::setStaticField<jobject>(jclass clazz, + const char *fieldName, + const char *sig, + jobject value) +{ + QAttachedJNIEnv env; + jfieldID id = getCachedFieldID(env, clazz, fieldName, sig, true); + if (id) + env->SetStaticObjectField(clazz, id, value); +} + +template <> +void QJNIObject::setStaticField<jobject>(const char *className, + const char *fieldName, + const char *sig, + jobject value) +{ + QAttachedJNIEnv env; + jclass clazz = getCachedClass(env, className); + if (clazz) + setStaticField<jobject>(clazz, fieldName, sig, value); +} + +template <> +void QJNIObject::setStaticField<jstring>(const char *className, + const char *fieldName, + jstring value) +{ + setStaticField<jobject>(className, fieldName, "Ljava/lang/String;", value); +} + +template <> +void QJNIObject::setStaticField<jstring>(jclass clazz, const char *fieldName, jstring value) +{ + setStaticField<jobject>(clazz, fieldName, "Ljava/lang/String;", value); +} + +template <> +void QJNIObject::setStaticField<jbooleanArray>(const char *className, + const char *fieldName, + jbooleanArray value) +{ + setStaticField<jobject>(className, fieldName, "[Z", value); +} + +template <> +void QJNIObject::setStaticField<jbooleanArray>(jclass clazz, + const char *fieldName, + jbooleanArray value) +{ + setStaticField<jobject>(clazz, fieldName, "[Z", value); +} + +template <> +void QJNIObject::setStaticField<jbyteArray>(const char *className, + const char *fieldName, + jbyteArray value) +{ + setStaticField<jobject>(className, fieldName, "[B", value); +} + +template <> +void QJNIObject::setStaticField<jbyteArray>(jclass clazz, + const char *fieldName, + jbyteArray value) +{ + setStaticField<jobject>(clazz, fieldName, "[B", value); +} + +template <> +void QJNIObject::setStaticField<jcharArray>(const char *className, + const char *fieldName, + jcharArray value) +{ + setStaticField<jobject>(className, fieldName, "[C", value); +} + +template <> +void QJNIObject::setStaticField<jcharArray>(jclass clazz, + const char *fieldName, + jcharArray value) +{ + setStaticField<jobject>(clazz, fieldName, "[C", value); +} + +template <> +void QJNIObject::setStaticField<jshortArray>(const char *className, + const char *fieldName, + jshortArray value) +{ + setStaticField<jobject>(className, fieldName, "[S", value); +} + +template <> +void QJNIObject::setStaticField<jshortArray>(jclass clazz, + const char *fieldName, + jshortArray value) +{ + setStaticField<jobject>(clazz, fieldName, "[S", value); +} + +template <> +void QJNIObject::setStaticField<jintArray>(const char *className, + const char *fieldName, + jintArray value) +{ + setStaticField<jobject>(className, fieldName, "[I", value); +} + +template <> +void QJNIObject::setStaticField<jintArray>(jclass clazz, + const char *fieldName, + jintArray value) +{ + setStaticField<jobject>(clazz, fieldName, "[I", value); +} + +template <> +void QJNIObject::setStaticField<jlongArray>(const char *className, + const char *fieldName, + jlongArray value) +{ + setStaticField<jobject>(className, fieldName, "[J", value); +} + +template <> +void QJNIObject::setStaticField<jlongArray>(jclass clazz, + const char *fieldName, + jlongArray value) +{ + setStaticField<jobject>(clazz, fieldName, "[J", value); +} + +template <> +void QJNIObject::setStaticField<jfloatArray>(const char *className, + const char *fieldName, + jfloatArray value) +{ + setStaticField<jobject>(className, fieldName, "[F", value); +} + +template <> +void QJNIObject::setStaticField<jfloatArray>(jclass clazz, + const char *fieldName, + jfloatArray value) +{ + setStaticField<jobject>(clazz, fieldName, "[F", value); +} + +template <> +void QJNIObject::setStaticField<jdoubleArray>(const char *className, + const char *fieldName, + jdoubleArray value) +{ + setStaticField<jobject>(className, fieldName, "[D", value); +} + +template <> +void QJNIObject::setStaticField<jdoubleArray>(jclass clazz, + const char *fieldName, + jdoubleArray value) +{ + setStaticField<jobject>(clazz, fieldName, "[D", value); +} + + +QT_END_NAMESPACE diff --git a/src/platformsupport/jniconvenience/qjniobject_p.h b/src/platformsupport/jniconvenience/qjniobject_p.h new file mode 100644 index 0000000000..6874765f06 --- /dev/null +++ b/src/platformsupport/jniconvenience/qjniobject_p.h @@ -0,0 +1,169 @@ +/**************************************************************************** +** +** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/legal +** +** This file is part of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:LGPL$ +** Commercial License Usage +** Licensees holding valid commercial Qt licenses may use this file in +** accordance with the commercial license agreement provided with the +** Software or, alternatively, in accordance with the terms contained in +** a written agreement between you and Digia. For licensing terms and +** conditions see http://qt.digia.com/licensing. For further information +** use the contact form at http://qt.digia.com/contact-us. +** +** GNU Lesser General Public License Usage +** Alternatively, this file may be used under the terms of the GNU Lesser +** General Public License version 2.1 as published by the Free Software +** Foundation and appearing in the file LICENSE.LGPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU Lesser General Public License version 2.1 requirements +** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. +** +** In addition, as a special exception, Digia gives you certain additional +** rights. These rights are described in the Digia Qt LGPL Exception +** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. +** +** GNU General Public License Usage +** Alternatively, this file may be used under the terms of the GNU +** General Public License version 3.0 as published by the Free Software +** Foundation and appearing in the file LICENSE.GPL included in the +** packaging of this file. Please review the following information to +** ensure the GNU General Public License version 3.0 requirements will be +** met: http://www.gnu.org/copyleft/gpl.html. +** +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef QJNIOBJECT_H +#define QJNIOBJECT_H + +#include <qglobal.h> +#include <jni.h> + +QT_BEGIN_NAMESPACE + +template <typename T> +class QJNILocalRef; + +/** + * Allows to wrap any Java class and partially hide some of the jni calls. + * + * Usage example: + * + * QJNIObject javaString("java/lang/String"); + * jchar char = javaString.callMethod<jchar>("charAt", "(I)C", 0); + * + * ---- + * + * jstring string = QJNIObject::callStaticMethod<jstring>("java/lang/String", + * "valueOf", + * "(I)Ljava/lang/String;", 2); + * + * ---- + * + * // Constructor with argument + * jstring someString; + * QJNIObject someObject("java/some/Class", "(Ljava/lang/String;)V", someString); + * someObject.setField<jint>("fieldName", 10); + * someObject.callMethod<void>("doStuff"); + */ +class QJNIObject +{ +public: + QJNIObject(const char *className); + QJNIObject(const char *className, const char *sig, ...); + QJNIObject(jclass clazz); + QJNIObject(jclass clazz, const char *sig, ...); + QJNIObject(jobject obj); + virtual ~QJNIObject(); + + static bool isClassAvailable(const char *className); + + bool isValid() const { return m_jobject != 0; } + jobject object() const { return m_jobject; } + + template <typename T> + T callMethod(const char *methodName); + template <typename T> + T callMethod(const char *methodName, const char *sig, ...); + template <typename T> + QJNILocalRef<T> callObjectMethod(const char *methodName); + template <typename T> + QJNILocalRef<T> callObjectMethod(const char *methodName, const char *sig, ...); + + template <typename T> + static T callStaticMethod(const char *className, const char *methodName); + template <typename T> + static T callStaticMethod(const char *className, const char *methodName, const char *sig, ...); + template <typename T> + static QJNILocalRef<T> callStaticObjectMethod(const char *className, const char *methodName); + template <typename T> + static QJNILocalRef<T> callStaticObjectMethod(const char *className, + const char *methodName, + const char *sig, ...); + template <typename T> + static T callStaticMethod(jclass clazz, const char *methodName); + template <typename T> + static T callStaticMethod(jclass clazz, const char *methodName, const char *sig, ...); + template <typename T> + static QJNILocalRef<T> callStaticObjectMethod(jclass clazz, const char *methodName); + template <typename T> + static QJNILocalRef<T> callStaticObjectMethod(jclass clazz, + const char *methodName, + const char *sig, ...); + + template <typename T> + T getField(const char *fieldName); + template <typename T> + T getField(const char *fieldName, const char *sig); + template <typename T> + QJNILocalRef<T> getObjectField(const char *fieldName); + template <typename T> + QJNILocalRef<T> getObjectField(const char *fieldName, const char *sig); + + template <typename T> + void setField(const char *fieldName, T value); + template <typename T> + void setField(const char *fieldName, const char *sig, T value); + + template <typename T> + static QJNILocalRef<T> getStaticObjectField(const char *className, const char *fieldName); + template <typename T> + static QJNILocalRef<T> getStaticObjectField(const char *className, + const char *fieldName, + const char *sig); + template <typename T> + static T getStaticField(const char *className, const char *fieldName); + template <typename T> + static QJNILocalRef<T> getStaticObjectField(jclass clazz, const char *fieldName); + template <typename T> + static QJNILocalRef<T> getStaticObjectField(jclass clazz, const char *fieldName, const char *sig); + template <typename T> + static T getStaticField(jclass clazz, const char *fieldName); + + template <typename T> + static void setStaticField(const char *className, + const char *fieldName, + const char *sig, + T value); + template <typename T> + static void setStaticField(const char *className, const char *fieldName, T value); + template <typename T> + static void setStaticField(jclass clazz, const char *fieldName, const char *sig, T value); + template <typename T> + static void setStaticField(jclass clazz, const char *fieldName, T value); + +protected: + jobject m_jobject; + jclass m_jclass; + bool m_own_jclass; +}; + +QT_END_NAMESPACE + +#endif // QJNIOBJECT_H diff --git a/src/platformsupport/platformsupport.pro b/src/platformsupport/platformsupport.pro index 8e0f396993..0566e9d3ec 100644 --- a/src/platformsupport/platformsupport.pro +++ b/src/platformsupport/platformsupport.pro @@ -22,3 +22,4 @@ include(devicediscovery/devicediscovery.pri) include(services/services.pri) include(themes/themes.pri) include(linuxaccessibility/linuxaccessibility.pri) +include(jniconvenience/jniconvenience.pri) |