qjniobject.cpp

Go to the documentation of this file.

// Copyright (C) 2021 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qjniobject.h"
 
#include "qjnihelpers_p.h"
 
#include <QtCore/qbytearray.h>
#include <QtCore/qhash.h>
#include <QtCore/qreadwritelock.h>
#include <QtCore/qloggingcategory.h>
 
 
QT_BEGIN_NAMESPACE
 
Q_LOGGING_CATEGORY(lcJniThreadCheck, "qt.core.jni.threadcheck")
 
using namespace Qt::StringLiterals;
 
class QJniObjectPrivate
{
public:
    QJniObjectPrivate()
    {
    }
    ~QJniObjectPrivate() {
        JNIEnv *env = QJniEnvironment::getJniEnv();
        if (m_jobject)
            env->DeleteGlobalRef(m_jobject);
        if (m_jclass && m_own_jclass)
            env->DeleteGlobalRef(m_jclass);
    }
 
    template <typename ...Args>
    void construct(const char *signature = nullptr, Args &&...args)
    {
        if (m_jclass) {
            JNIEnv *env = QJniEnvironment::getJniEnv();
            // get default constructor
            jmethodID constructorId = QJniObject::getCachedMethodID(env, m_jclass, m_className, "<init>",
                                                                    signature ? signature : "()V");
            if (constructorId) {
                jobject obj = nullptr;
                if constexpr (sizeof...(Args) == 0)
                    obj = env->NewObject(m_jclass, constructorId);
                else
                    obj = env->NewObjectV(m_jclass, constructorId, std::forward<Args>(args)...);
                if (obj) {
                    m_jobject = env->NewGlobalRef(obj);
                    env->DeleteLocalRef(obj);
                }
            }
        }
    }
 
    QByteArray m_className;
    jobject m_jobject = nullptr;
    jclass m_jclass = nullptr;
    bool m_own_jclass = true;
};
 
template <typename ...Args>
static inline QByteArray cacheKey(Args &&...args)
{
    return (QByteArrayView(":") + ... + QByteArrayView(args));
}
 
typedef QHash<QByteArray, jclass> JClassHash;
Q_GLOBAL_STATIC(JClassHash, cachedClasses)
Q_GLOBAL_STATIC(QReadWriteLock, cachedClassesLock)
 
static jclass getCachedClass(const QByteArray &className)
{
    QReadLocker locker(cachedClassesLock);
    const auto &it = cachedClasses->constFind(className);
    return it != cachedClasses->constEnd() ? it.value() : nullptr;
}
 
static QJniObject getCleanJniObject(jobject object, JNIEnv *env)
{
    if (QJniEnvironment::checkAndClearExceptions(env) || !object) {
        if (object)
            env->DeleteLocalRef(object);
        return QJniObject();
    }
 
    QJniObject res(object);
    env->DeleteLocalRef(object);
    return res;
}
 
jclass QtAndroidPrivate::findClass(const char *className, JNIEnv *env)
{
    Q_ASSERT(env);
    QByteArray classNameArray(className);
#ifdef QT_DEBUG
    if (classNameArray.contains('.')) {
        qWarning("QtAndroidPrivate::findClass: className '%s' should use slash separators!",
                 className);
    }
#endif
    classNameArray.replace('.', '/');
    jclass clazz = getCachedClass(classNameArray);
    if (clazz)
        return clazz;
 
    QWriteLocker locker(cachedClassesLock);
    // Check again; another thread might have added the class to the cache after
    // our call to getCachedClass and before we acquired the lock.
    const auto &it = cachedClasses->constFind(classNameArray);
    if (it != cachedClasses->constEnd())
        return it.value();
 
    // JNIEnv::FindClass wants "a fully-qualified class name or an array type signature"
    // which is a slash-separated class name.
    jclass localClazz = env->FindClass(classNameArray.constData());
    if (localClazz) {
        clazz = static_cast<jclass>(env->NewGlobalRef(localClazz));
        env->DeleteLocalRef(localClazz);
    } else {
        // Clear the exception silently; we are going to try the ClassLoader next,
        // so no need for warning unless that fails as well.
        env->ExceptionClear();
    }
 
    if (!clazz) {
        // Wrong class loader, try our own
        QJniObject classLoader(QtAndroidPrivate::classLoader());
        if (!classLoader.isValid())
            return nullptr;
 
        // ClassLoader::loadClass on the other hand wants the binary name of the class,
        // e.g. dot-separated. In testing it works also with /, but better to stick to
        // the specification.
        const QString binaryClassName = QString::fromLatin1(className).replace(u'/', u'.');
        jstring classNameObject = env->NewString(reinterpret_cast<const jchar*>(binaryClassName.constData()),
                                                                                binaryClassName.length());
        QJniObject classObject = classLoader.callMethod<jclass>("loadClass", classNameObject);
        env->DeleteLocalRef(classNameObject);
 
        if (!QJniEnvironment::checkAndClearExceptions(env) && classObject.isValid())
            clazz = static_cast<jclass>(env->NewGlobalRef(classObject.object()));
    }
 
    if (clazz)
        cachedClasses->insert(classNameArray, clazz);
 
    return clazz;
}
 
jclass QJniObject::loadClass(const QByteArray &className, JNIEnv *env)
{
    return QtAndroidPrivate::findClass(className, env);
}
 
typedef QHash<QByteArray, jmethodID> JMethodIDHash;
Q_GLOBAL_STATIC(JMethodIDHash, cachedMethodID)
Q_GLOBAL_STATIC(QReadWriteLock, cachedMethodIDLock)
 
jmethodID QJniObject::getMethodID(JNIEnv *env,
                                    jclass clazz,
                                    const char *name,
                                    const char *signature,
                                    bool isStatic)
{
    jmethodID id = isStatic ? env->GetStaticMethodID(clazz, name, signature)
                            : env->GetMethodID(clazz, name, signature);
 
    if (QJniEnvironment::checkAndClearExceptions(env))
        return nullptr;
 
    return id;
}
 
void QJniObject::callVoidMethodV(JNIEnv *env, jmethodID id, ...) const
{
    va_list args;
    va_start(args, id);
    env->CallVoidMethodV(d->m_jobject, id, args);
    va_end(args);
}
 
jmethodID QJniObject::getCachedMethodID(JNIEnv *env,
                                        jclass clazz,
                                        const QByteArray &className,
                                        const char *name,
                                        const char *signature,
                                        bool isStatic)
{
    if (className.isEmpty())
        return getMethodID(env, clazz, name, signature, isStatic);
 
    const QByteArray key = cacheKey(className, name, signature);
    QHash<QByteArray, jmethodID>::const_iterator it;
 
    {
        QReadLocker locker(cachedMethodIDLock);
        it = cachedMethodID->constFind(key);
        if (it != cachedMethodID->constEnd())
            return it.value();
    }
 
    {
        QWriteLocker locker(cachedMethodIDLock);
        it = cachedMethodID->constFind(key);
        if (it != cachedMethodID->constEnd())
            return it.value();
 
        jmethodID id = getMethodID(env, clazz, name, signature, isStatic);
 
        cachedMethodID->insert(key, id);
        return id;
    }
}
 
jmethodID QJniObject::getCachedMethodID(JNIEnv *env, const char *name,
                                        const char *signature, bool isStatic) const
{
    return QJniObject::getCachedMethodID(env, d->m_jclass, d->m_className, name, signature, isStatic);
}
 
typedef QHash<QByteArray, jfieldID> JFieldIDHash;
Q_GLOBAL_STATIC(JFieldIDHash, cachedFieldID)
Q_GLOBAL_STATIC(QReadWriteLock, cachedFieldIDLock)
 
jfieldID QJniObject::getFieldID(JNIEnv *env,
                                jclass clazz,
                                const char *name,
                                const char *signature,
                                bool isStatic)
{
    jfieldID id = isStatic ? env->GetStaticFieldID(clazz, name, signature)
                           : env->GetFieldID(clazz, name, signature);
 
    if (QJniEnvironment::checkAndClearExceptions(env))
        return nullptr;
 
    return id;
}
 
jfieldID QJniObject::getCachedFieldID(JNIEnv *env,
                                      jclass clazz,
                                      const QByteArray &className,
                                      const char *name,
                                      const char *signature,
                                      bool isStatic)
{
    if (className.isNull())
        return getFieldID(env, clazz, name, signature, isStatic);
 
    const QByteArray key = cacheKey(className, name, signature);
    QHash<QByteArray, jfieldID>::const_iterator it;
 
    {
        QReadLocker locker(cachedFieldIDLock);
        it = cachedFieldID->constFind(key);
        if (it != cachedFieldID->constEnd())
            return it.value();
    }
 
    {
        QWriteLocker locker(cachedFieldIDLock);
        it = cachedFieldID->constFind(key);
        if (it != cachedFieldID->constEnd())
            return it.value();
 
        jfieldID id = getFieldID(env, clazz, name, signature, isStatic);
 
        cachedFieldID->insert(key, id);
        return id;
    }
}
 
jfieldID QJniObject::getCachedFieldID(JNIEnv *env,
                                      const char *name,
                                      const char *signature,
                                      bool isStatic) const
{
    return QJniObject::getCachedFieldID(env, d->m_jclass, d->m_className, name, signature, isStatic);
}
 
QJniObject::QJniObject()
    : d(new QJniObjectPrivate())
{
}
 
QJniObject::QJniObject(const char *className)
    : d(new QJniObjectPrivate())
{
    d->m_className = className;
    d->m_jclass = loadClass(d->m_className, jniEnv());
    d->m_own_jclass = false;
 
    d->construct();
}
 
QJniObject::QJniObject(const char *className, const char *signature, ...)
    : d(new QJniObjectPrivate())
{
    d->m_className = className;
    d->m_jclass = loadClass(d->m_className, jniEnv());
    d->m_own_jclass = false;
 
    va_list args;
    va_start(args, signature);
    d->construct(signature, args);
    va_end(args);
}
 
QJniObject::QJniObject(jclass clazz, const char *signature, ...)
    : d(new QJniObjectPrivate())
{
    if (clazz) {
        d->m_jclass = static_cast<jclass>(jniEnv()->NewGlobalRef(clazz));
        va_list args;
        va_start(args, signature);
        d->construct(signature, args);
        va_end(args);
    }
}
 
QJniObject::QJniObject(jclass clazz)
    : QJniObject(clazz, "()V")
{
}
 
QJniObject::QJniObject(jobject object)
    : d(new QJniObjectPrivate())
{
    if (!object)
        return;
 
    JNIEnv *env = QJniEnvironment::getJniEnv();
    d->m_jobject = env->NewGlobalRef(object);
    jclass cls = env->GetObjectClass(object);
    d->m_jclass = static_cast<jclass>(env->NewGlobalRef(cls));
    env->DeleteLocalRef(cls);
}
 
QJniObject::~QJniObject()
{}
 
namespace {
QByteArray getClassNameHelper(JNIEnv *env, const QJniObjectPrivate *d)
{
    if (env->PushLocalFrame(3) != JNI_OK) // JVM out of memory
        return QByteArray();
 
    jmethodID mid = env->GetMethodID(d->m_jclass, "getClass", "()Ljava/lang/Class;");
    jobject classObject = env->CallObjectMethod(d->m_jobject, mid);
    jclass classObjectClass = env->GetObjectClass(classObject);
    mid = env->GetMethodID(classObjectClass, "getName", "()Ljava/lang/String;");
    jstring stringObject = static_cast<jstring>(env->CallObjectMethod(classObject, mid));
    const jsize length = env->GetStringUTFLength(stringObject);
    const char* nameString = env->GetStringUTFChars(stringObject, NULL);
    const QByteArray result = QByteArray::fromRawData(nameString, length).replace('.', '/');
    env->ReleaseStringUTFChars(stringObject, nameString);
    env->PopLocalFrame(nullptr);
    return result;
}
}
 
JNIEnv *QJniObject::jniEnv() const noexcept
{
    return QJniEnvironment::getJniEnv();
}
 
jobject QJniObject::object() const
{
    return javaObject();
}
 
jclass QJniObject::objectClass() const
{
    return d->m_jclass;
}
 
QByteArray QJniObject::className() const
{
    if (d->m_className.isEmpty() && d->m_jclass && d->m_jobject) {
        JNIEnv *env = jniEnv();
        d->m_className = getClassNameHelper(env, d.get());
    }
    return d->m_className;
}
 
QJniObject QJniObject::callObjectMethod(const char *methodName, const char *signature, ...) const
{
    jmethodID id = getCachedMethodID(jniEnv(), methodName, signature);
    if (id) {
        va_list args;
        va_start(args, signature);
        QJniObject res = getCleanJniObject(jniEnv()->CallObjectMethodV(d->m_jobject, id, args), jniEnv());
        va_end(args);
        return res;
    }
 
    return QJniObject();
}
 
QJniObject QJniObject::callStaticObjectMethod(const char *className, const char *methodName,
                                              const char *signature, ...)
{
    JNIEnv *env = QJniEnvironment::getJniEnv();
    jclass clazz = QJniObject::loadClass(className, env);
    if (clazz) {
        jmethodID id = QJniObject::getCachedMethodID(env, clazz,
                                         className,
                                         methodName, signature, true);
        if (id) {
            va_list args;
            va_start(args, signature);
            QJniObject res = getCleanJniObject(env->CallStaticObjectMethodV(clazz, id, args), env);
            va_end(args);
            return res;
        }
    }
 
    return QJniObject();
}
 
QJniObject QJniObject::callStaticObjectMethod(jclass clazz, const char *methodName,
                                              const char *signature, ...)
{
    if (clazz) {
        QJniEnvironment env;
        jmethodID id = getMethodID(env.jniEnv(), clazz, methodName, signature, true);
        if (id) {
            va_list args;
            va_start(args, signature);
            QJniObject res = getCleanJniObject(env->CallStaticObjectMethodV(clazz, id, args), env.jniEnv());
            va_end(args);
            return res;
        }
    }
 
    return QJniObject();
}
 
QJniObject QJniObject::callStaticObjectMethod(jclass clazz, jmethodID methodId, ...)
{
    if (clazz && methodId) {
        QJniEnvironment env;
        va_list args;
        va_start(args, methodId);
        QJniObject res = getCleanJniObject(env->CallStaticObjectMethodV(clazz, methodId, args), env.jniEnv());
        va_end(args);
        return res;
    }
 
    return QJniObject();
}
 
QJniObject QJniObject::getStaticObjectField(const char *className,
                                            const char *fieldName,
                                            const char *signature)
{
    JNIEnv *env = QJniEnvironment::getJniEnv();
    jclass clazz = QJniObject::loadClass(className, env);
    if (!clazz)
        return QJniObject();
    jfieldID id = QJniObject::getCachedFieldID(env, clazz,
                                   className,
                                   fieldName,
                                   signature, true);
    if (!id)
        return QJniObject();
 
    return getCleanJniObject(env->GetStaticObjectField(clazz, id), env);
}
 
QJniObject QJniObject::getStaticObjectField(jclass clazz, const char *fieldName,
                                            const char *signature)
{
    JNIEnv *env = QJniEnvironment::getJniEnv();
    jfieldID id = getFieldID(env, clazz, fieldName, signature, true);
    return getCleanJniObject(env->GetStaticObjectField(clazz, id), env);
}
 
QJniObject QJniObject::getObjectField(const char *fieldName, const char *signature) const
{
    jfieldID id = getCachedFieldID(jniEnv(), fieldName, signature);
    if (!id)
        return QJniObject();
 
    return getCleanJniObject(jniEnv()->GetObjectField(d->m_jobject, id), jniEnv());
}
 
QJniObject QJniObject::fromString(const QString &string)
{
    QJniEnvironment env;
    jstring stringRef = env->NewString(reinterpret_cast<const jchar*>(string.constData()),
                                                                      string.length());
    QJniObject stringObject = getCleanJniObject(stringRef, env.jniEnv());
    stringObject.d->m_className = "java/lang/String";
    return stringObject;
}
 
QString QJniObject::toString() const
{
    if (!isValid())
        return QString();
 
    QJniObject string = callObjectMethod<jstring>("toString");
    const int strLength = string.jniEnv()->GetStringLength(string.object<jstring>());
    QString res(strLength, Qt::Uninitialized);
    string.jniEnv()->GetStringRegion(string.object<jstring>(), 0, strLength, reinterpret_cast<jchar *>(res.data()));
    return res;
}
 
bool QJniObject::isClassAvailable(const char *className)
{
    QJniEnvironment env;
 
    if (!env.jniEnv())
        return false;
 
    return loadClass(className, env.jniEnv());
}
 
bool QJniObject::isValid() const
{
    return d->m_jobject;
}
 
QJniObject QJniObject::fromLocalRef(jobject lref)
{
    QJniObject obj(lref);
    obj.jniEnv()->DeleteLocalRef(lref);
    return obj;
}
 
bool QJniObject::isSameObject(jobject obj) const
{
    if (d->m_jobject == obj)
        return true;
    if (!d->m_jobject || !obj)
        return false;
    return jniEnv()->IsSameObject(d->m_jobject, obj);
}
 
bool QJniObject::isSameObject(const QJniObject &other) const
{
    return isSameObject(other.d->m_jobject);
}
 
void QJniObject::assign(jobject obj)
{
    if (d && isSameObject(obj))
        return;
 
    d = QSharedPointer<QJniObjectPrivate>::create();
    if (obj) {
        JNIEnv *env = QJniEnvironment::getJniEnv();
        d->m_jobject = env->NewGlobalRef(obj);
        jclass objectClass = env->GetObjectClass(obj);
        d->m_jclass = static_cast<jclass>(env->NewGlobalRef(objectClass));
        env->DeleteLocalRef(objectClass);
    }
}
 
jobject QJniObject::javaObject() const
{
    return d->m_jobject;
}
 
QT_END_NAMESPACE