summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorYoann Lopes <yoann.lopes@digia.com>2013-03-01 18:32:49 +0100
committerThe Qt Project <gerrit-noreply@qt-project.org>2013-03-05 18:41:30 +0100
commit0666975d6c276139788001cdd4cb686c7073f50c (patch)
treee7999a34d0a6c5fe0d1dd5efe4a24fdce2d9b45a
parentd28f454a677d3f0a168b80aadfc97a20aeaa70ea (diff)
Added JNI convenience classes in QtPlatformSupport.
This is used for Android. Change-Id: I049138c140a472b1721390cf4ec2bd88bbe9c471 Reviewed-by: Eskil Abrahamsen Blomfeldt <eskil.abrahamsen-blomfeldt@digia.com> Reviewed-by: Oswald Buddenhagen <oswald.buddenhagen@digia.com> Reviewed-by: Paul Olav Tvete <paul.tvete@digia.com>
-rw-r--r--src/platformsupport/jniconvenience/jniconvenience.pri9
-rw-r--r--src/platformsupport/jniconvenience/qjnihelpers.cpp115
-rw-r--r--src/platformsupport/jniconvenience/qjnihelpers_p.h191
-rw-r--r--src/platformsupport/jniconvenience/qjniobject.cpp3098
-rw-r--r--src/platformsupport/jniconvenience/qjniobject_p.h169
-rw-r--r--src/platformsupport/platformsupport.pro1
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)