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>
 
QT_BEGIN_NAMESPACE
 
using namespace Qt::StringLiterals;
 
class QJniObjectPrivate
{
public:
    QJniObjectPrivate() = default;
    ~QJniObjectPrivate() {
        QJniEnvironment env;
        if (m_jobject)
            env->DeleteGlobalRef(m_jobject);
        if (m_jclass && m_own_jclass)
            env->DeleteGlobalRef(m_jclass);
    }
 
    friend jclass QtAndroidPrivate::findClass(const char *className, JNIEnv *env);
    static jclass loadClass(const QByteArray &className, JNIEnv *env, bool binEncoded = false)
    {
        return QJniObject::loadClass(className, env, binEncoded);
    }
 
    static QByteArray toBinaryEncClassName(const QByteArray &className)
    {
        return QJniObject::toBinaryEncClassName(className);
    }
 
    jobject m_jobject = nullptr;
    jclass m_jclass = nullptr;
    bool m_own_jclass = true;
    QByteArray m_className;
};
 
static inline QLatin1StringView keyBase()
{
    return "%1%2:%3"_L1;
}
 
static QString qt_convertJString(jstring string)
{
    QJniEnvironment env;
    int strLength = env->GetStringLength(string);
    QString res(strLength, Qt::Uninitialized);
    env->GetStringRegion(string, 0, strLength, reinterpret_cast<jchar *>(res.data()));
    return res;
}
 
typedef QHash<QString, jclass> JClassHash;
Q_GLOBAL_STATIC(JClassHash, cachedClasses)
Q_GLOBAL_STATIC(QReadWriteLock, cachedClassesLock)
 
static jclass getCachedClass(const QByteArray &classBinEnc, bool *isCached = nullptr)
{
    QReadLocker locker(cachedClassesLock);
    const QHash<QString, jclass>::const_iterator &it = cachedClasses->constFind(QString::fromLatin1(classBinEnc));
    const bool found = (it != cachedClasses->constEnd());
 
    if (isCached)
        *isCached = found;
 
    return found ? it.value() : 0;
}
 
QByteArray QJniObject::toBinaryEncClassName(const QByteArray &className)
{
    return QByteArray(className).replace('/', '.');
}
 
jclass QJniObject::loadClass(const QByteArray &className, JNIEnv *env, bool binEncoded)
{
    const QByteArray &binEncClassName = binEncoded ? className : QJniObject::toBinaryEncClassName(className);
 
    bool isCached = false;
    jclass clazz = getCachedClass(binEncClassName, &isCached);
    if (clazz || isCached)
        return clazz;
 
    QJniObject classLoader(QtAndroidPrivate::classLoader());
    if (!classLoader.isValid())
        return nullptr;
 
    QWriteLocker locker(cachedClassesLock);
    // did we lose the race?
    const QLatin1StringView key(binEncClassName);
    const QHash<QString, jclass>::const_iterator &it = cachedClasses->constFind(key);
    if (it != cachedClasses->constEnd())
        return it.value();
 
    QJniObject stringName = QJniObject::fromString(key);
    QJniObject classObject = classLoader.callObjectMethod("loadClass",
                                                          "(Ljava/lang/String;)Ljava/lang/Class;",
                                                          stringName.object());
 
    if (!QJniEnvironment::checkAndClearExceptions(env) && classObject.isValid())
        clazz = static_cast<jclass>(env->NewGlobalRef(classObject.object()));
 
    cachedClasses->insert(key, clazz);
    return clazz;
}
 
typedef QHash<QString, 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);
    callVoidMethodV(env, id, args);
    va_end(args);
}
 
void QJniObject::callVoidMethodV(JNIEnv *env, jmethodID id, va_list args) const
{
    env->CallVoidMethodV(d->m_jobject, id, 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 QString key = keyBase().arg(QLatin1StringView(className),
                                      QLatin1StringView(name),
                                      QLatin1StringView(signature));
    QHash<QString, 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<QString, 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 QString key = keyBase().arg(QLatin1StringView(className),
                                      QLatin1StringView(name),
                                      QLatin1StringView(signature));
    QHash<QString, 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);
}
 
jclass QtAndroidPrivate::findClass(const char *className, JNIEnv *env)
{
    const QByteArray &classDotEnc = QJniObjectPrivate::toBinaryEncClassName(className);
    bool isCached = false;
    jclass clazz = getCachedClass(classDotEnc, &isCached);
 
    if (clazz || isCached)
        return clazz;
 
    const QLatin1StringView key(classDotEnc);
    if (env) { // We got an env. pointer (We expect this to be the right env. and call FindClass())
        QWriteLocker locker(cachedClassesLock);
        const QHash<QString, jclass>::const_iterator &it = cachedClasses->constFind(key);
        // Did we lose the race?
        if (it != cachedClasses->constEnd())
            return it.value();
 
        jclass fclazz = env->FindClass(className);
        if (!QJniEnvironment::checkAndClearExceptions(env)) {
            clazz = static_cast<jclass>(env->NewGlobalRef(fclazz));
            env->DeleteLocalRef(fclazz);
        }
 
        if (clazz)
            cachedClasses->insert(key, clazz);
    }
 
    if (!clazz) // We didn't get an env. pointer or we got one with the WRONG class loader...
        clazz = QJniObjectPrivate::loadClass(classDotEnc, QJniEnvironment().jniEnv(), true);
 
    return clazz;
}
 
QJniObject::QJniObject()
    : d(new QJniObjectPrivate())
{
}
 
QJniObject::QJniObject(const char *className)
    : d(new QJniObjectPrivate())
{
    QJniEnvironment env;
    d->m_className = toBinaryEncClassName(className);
    d->m_jclass = loadClass(d->m_className, env.jniEnv(), true);
    d->m_own_jclass = false;
    if (d->m_jclass) {
        // get default constructor
        jmethodID constructorId = getCachedMethodID(env.jniEnv(), "<init>", "()V");
        if (constructorId) {
            jobject obj = env->NewObject(d->m_jclass, constructorId);
            if (obj) {
                d->m_jobject = env->NewGlobalRef(obj);
                env->DeleteLocalRef(obj);
            }
        }
    }
}
 
QJniObject::QJniObject(const char *className, const char *signature, ...)
    : d(new QJniObjectPrivate())
{
    QJniEnvironment env;
    d->m_className = toBinaryEncClassName(className);
    d->m_jclass = loadClass(d->m_className, env.jniEnv(), true);
    d->m_own_jclass = false;
    if (d->m_jclass) {
        jmethodID constructorId = getCachedMethodID(env.jniEnv(), "<init>", signature);
        if (constructorId) {
            va_list args;
            va_start(args, signature);
            jobject obj = env->NewObjectV(d->m_jclass, constructorId, args);
            va_end(args);
            if (obj) {
                d->m_jobject = env->NewGlobalRef(obj);
                env->DeleteLocalRef(obj);
            }
        }
    }
}
 
QJniObject::QJniObject(const char *className, const char *signature, const QVaListPrivate &args)
    : d(new QJniObjectPrivate())
{
    QJniEnvironment env;
    d->m_className = toBinaryEncClassName(className);
    d->m_jclass = loadClass(d->m_className, env.jniEnv(), true);
    d->m_own_jclass = false;
    if (d->m_jclass) {
        jmethodID constructorId = getCachedMethodID(env.jniEnv(), "<init>", signature);
        if (constructorId) {
            jobject obj = env->NewObjectV(d->m_jclass, constructorId, args);
            if (obj) {
                d->m_jobject = env->NewGlobalRef(obj);
                env->DeleteLocalRef(obj);
            }
        }
    }
}
 
QJniObject::QJniObject(jclass clazz, const char *signature, ...)
    : d(new QJniObjectPrivate())
{
    QJniEnvironment env;
    if (clazz) {
        d->m_jclass = static_cast<jclass>(env->NewGlobalRef(clazz));
        if (d->m_jclass) {
            jmethodID constructorId = getMethodID(env.jniEnv(), d->m_jclass, "<init>", signature);
            if (constructorId) {
                va_list args;
                va_start(args, signature);
                jobject obj = env->NewObjectV(d->m_jclass, constructorId, args);
                va_end(args);
                if (obj) {
                    d->m_jobject = env->NewGlobalRef(obj);
                    env->DeleteLocalRef(obj);
                }
            }
        }
    }
}
 
QJniObject::QJniObject(jclass clazz)
    : d(new QJniObjectPrivate())
{
    QJniEnvironment env;
    d->m_jclass = static_cast<jclass>(env->NewGlobalRef(clazz));
    if (d->m_jclass) {
        // get default constructor
        jmethodID constructorId = getMethodID(env.jniEnv(), d->m_jclass, "<init>", "()V");
        if (constructorId) {
            jobject obj = env->NewObject(d->m_jclass, constructorId);
            if (obj) {
                d->m_jobject = env->NewGlobalRef(obj);
                env->DeleteLocalRef(obj);
            }
        }
    }
}
 
QJniObject::QJniObject(jclass clazz, const char *signature, const QVaListPrivate &args)
    : d(new QJniObjectPrivate())
{
    QJniEnvironment env;
    if (clazz) {
        d->m_jclass = static_cast<jclass>(env->NewGlobalRef(clazz));
        if (d->m_jclass) {
            jmethodID constructorId = getMethodID(env.jniEnv(), d->m_jclass, "<init>", signature);
            if (constructorId) {
                jobject obj = env->NewObjectV(d->m_jclass, constructorId, args);
                if (obj) {
                    d->m_jobject = env->NewGlobalRef(obj);
                    env->DeleteLocalRef(obj);
                }
            }
        }
    }
}
 
QJniObject::QJniObject(jobject object)
    : d(new QJniObjectPrivate())
{
    if (!object)
        return;
 
    QJniEnvironment env;
    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::getCleanJniObject(jobject object)
{
    if (!object)
        return QJniObject();
 
    QJniEnvironment env;
    if (env.checkAndClearExceptions()) {
        env->DeleteLocalRef(object);
        return QJniObject();
    }
 
    QJniObject res(object);
    env->DeleteLocalRef(object);
    return res;
}
 
QJniObject::~QJniObject()
{}
 
jobject QJniObject::object() const
{
    return javaObject();
}
 
jclass QJniObject::objectClass() const
{
    return d->m_jclass;
}
 
QByteArray QJniObject::className() const
{
    return d->m_className;
}
 
QJniObject QJniObject::callObjectMethodV(const char *methodName,
                                         const char *signature,
                                         va_list args) const
{
    QJniEnvironment env;
    jobject res = nullptr;
    jmethodID id = getCachedMethodID(env.jniEnv(), methodName, signature);
    if (id) {
        res = env->CallObjectMethodV(d->m_jobject, id, args);
        if (env.checkAndClearExceptions()) {
            env->DeleteLocalRef(res);
            res = nullptr;
        }
    }
 
    QJniObject obj(res);
    env->DeleteLocalRef(res);
    return obj;
}
 
QJniObject QJniObject::callStaticObjectMethodV(const char *className,
                                               const char *methodName,
                                               const char *signature,
                                               va_list args)
{
    QJniEnvironment env;
    jobject res = nullptr;
    jclass clazz = loadClass(className, env.jniEnv());
    if (clazz) {
        jmethodID id = QJniObject::getCachedMethodID(env.jniEnv(), clazz, toBinaryEncClassName(className),
                                         methodName, signature, true);
        if (id) {
            res = env->CallStaticObjectMethodV(clazz, id, args);
            if (env.checkAndClearExceptions()) {
                env->DeleteLocalRef(res);
                res = nullptr;
            }
        }
    }
 
    QJniObject obj(res);
    env->DeleteLocalRef(res);
    return obj;
}
 
QJniObject QJniObject::callStaticObjectMethodV(jclass clazz,
                                               const char *methodName,
                                               const char *signature,
                                               va_list args)
{
    QJniEnvironment env;
    jmethodID id = getMethodID(env.jniEnv(), clazz, methodName, signature, true);
    if (!id)
        return QJniObject();
 
    return getCleanJniObject(env->CallStaticObjectMethodV(clazz, id, args));
}
 
QJniObject QJniObject::callObjectMethod(const char *methodName, const char *signature, ...) const
{
    QJniEnvironment env;
    jmethodID id = getCachedMethodID(env.jniEnv(), methodName, signature);
    if (id) {
        va_list args;
        va_start(args, signature);
        QJniObject res = getCleanJniObject(env->CallObjectMethodV(d->m_jobject, id, args));
        va_end(args);
        return res;
    }
 
    return QJniObject();
}
 
QJniObject QJniObject::callStaticObjectMethod(const char *className, const char *methodName,
                                              const char *signature, ...)
{
    QJniEnvironment env;
    jclass clazz = QJniObject::loadClass(className, env.jniEnv());
    if (clazz) {
        jmethodID id = QJniObject::getCachedMethodID(env.jniEnv(), clazz,
                                         QJniObject::toBinaryEncClassName(className),
                                         methodName, signature, true);
        if (id) {
            va_list args;
            va_start(args, signature);
            QJniObject res = getCleanJniObject(env->CallStaticObjectMethodV(clazz, id, args));
            va_end(args);
            return res;
        }
    }
 
    return QJniObject();
}
 
QJniObject QJniObject::callStaticObjectMethod(jclass clazz, const char *methodName,
                                              const char *signature, ...)
{
    QJniEnvironment env;
    if (clazz) {
        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));
            va_end(args);
            return res;
        }
    }
 
    return QJniObject();
}
 
QJniObject QJniObject::callStaticObjectMethod(jclass clazz, jmethodID methodId, ...)
{
    QJniEnvironment env;
    if (clazz && methodId) {
        va_list args;
        va_start(args, methodId);
        QJniObject res = getCleanJniObject(env->CallStaticObjectMethodV(clazz, methodId, args));
        va_end(args);
        return res;
    }
 
    return QJniObject();
}
 
QJniObject QJniObject::getStaticObjectField(const char *className,
                                            const char *fieldName,
                                            const char *signature)
{
    QJniEnvironment env;
    jclass clazz = QJniObject::loadClass(className, env.jniEnv());
    if (!clazz)
        return QJniObject();
    jfieldID id = QJniObject::getCachedFieldID(env.jniEnv(), clazz,
                                   QJniObject::toBinaryEncClassName(className),
                                   fieldName,
                                   signature, true);
    if (!id)
        return QJniObject();
 
    return getCleanJniObject(env->GetStaticObjectField(clazz, id));
}
 
QJniObject QJniObject::getStaticObjectField(jclass clazz, const char *fieldName,
                                            const char *signature)
{
    QJniEnvironment env;
    jfieldID id = getFieldID(env.jniEnv(), clazz, fieldName, signature, true);
    if (!id)
        return QJniObject();
 
    return getCleanJniObject(env->GetStaticObjectField(clazz, id));
}
 
QJniObject QJniObject::getObjectField(const char *fieldName, const char *signature) const
{
    QJniEnvironment env;
    jfieldID id = getCachedFieldID(env.jniEnv(), fieldName, signature);
    if (!id)
        return QJniObject();
 
    return getCleanJniObject(env->GetObjectField(d->m_jobject, id));
}
 
QJniObject QJniObject::fromString(const QString &string)
{
    QJniEnvironment env;
    return getCleanJniObject(env->NewString(reinterpret_cast<const jchar*>(string.constData()),
                                                                           string.length()));
}
 
QString QJniObject::toString() const
{
    if (!isValid())
        return QString();
 
    QJniObject string = callObjectMethod<jstring>("toString");
    return qt_convertJString(static_cast<jstring>(string.object()));
}
 
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);
    QJniEnvironment()->DeleteLocalRef(lref);
    return obj;
}
 
bool QJniObject::isSameObject(jobject obj) const
{
    return QJniEnvironment()->IsSameObject(d->m_jobject, obj);
}
 
bool QJniObject::isSameObject(const QJniObject &other) const
{
    return isSameObject(other.d->m_jobject);
}
 
void QJniObject::assign(jobject obj)
{
    if (isSameObject(obj))
        return;
 
    jobject jobj = static_cast<jobject>(obj);
    d = QSharedPointer<QJniObjectPrivate>::create();
    if (obj) {
        QJniEnvironment env;
        d->m_jobject = env->NewGlobalRef(jobj);
        jclass objectClass = env->GetObjectClass(jobj);
        d->m_jclass = static_cast<jclass>(env->NewGlobalRef(objectClass));
        env->DeleteLocalRef(objectClass);
    }
}
 
jobject QJniObject::javaObject() const
{
    return d->m_jobject;
}
 
QT_END_NAMESPACE