qjnienvironment.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 "qjnienvironment.h"
#include "qjnihelpers_p.h"
 
#include <QtCore/QThread>
#include <QtCore/QThreadStorage>
 
QT_BEGIN_NAMESPACE
 
static const char qJniThreadName[] = "QtThread";
 
class QJniEnvironmentPrivate
{
public:
    JNIEnv *jniEnv = nullptr;
};
 
class QJniEnvironmentPrivateTLS
{
public:
    inline ~QJniEnvironmentPrivateTLS()
    {
        QtAndroidPrivate::javaVM()->DetachCurrentThread();
    }
};
 
struct QJniLocalRefDeleterPrivate
{
    static void cleanup(jobject obj)
    {
        if (!obj)
            return;
 
        QJniEnvironment env;
        env->DeleteLocalRef(obj);
    }
};
 
// To simplify this we only define it for jobjects.
typedef QScopedPointer<_jobject, QJniLocalRefDeleterPrivate> QJniScopedLocalRefPrivate;
 
 
Q_GLOBAL_STATIC(QThreadStorage<QJniEnvironmentPrivateTLS *>, jniEnvTLS)
 
 
 
 
QJniEnvironment::QJniEnvironment()
    : d(new QJniEnvironmentPrivate{})
{
    JavaVM *vm = QtAndroidPrivate::javaVM();
    const jint ret = vm->GetEnv((void**)&d->jniEnv, JNI_VERSION_1_6);
    if (ret == JNI_OK) // Already attached
        return;
 
    if (ret == JNI_EDETACHED) { // We need to (re-)attach
        JavaVMAttachArgs args = { JNI_VERSION_1_6, qJniThreadName, nullptr };
        if (vm->AttachCurrentThread(&d->jniEnv, &args) != JNI_OK)
            return;
 
        if (!jniEnvTLS->hasLocalData()) // If we attached the thread we own it.
            jniEnvTLS->setLocalData(new QJniEnvironmentPrivateTLS);
    }
}
 
QJniEnvironment::~QJniEnvironment()
{
    checkAndClearExceptions();
}
 
bool QJniEnvironment::isValid() const
{
    return d->jniEnv;
}
 
JNIEnv *QJniEnvironment::operator->() const
{
    return d->jniEnv;
}
 
JNIEnv &QJniEnvironment::operator*() const
{
    return *d->jniEnv;
}
 
JNIEnv *QJniEnvironment::jniEnv() const
{
    return d->jniEnv;
}
 
jclass QJniEnvironment::findClass(const char *className)
{
    return QtAndroidPrivate::findClass(className, d->jniEnv);
}
 
jmethodID QJniEnvironment::findMethod(jclass clazz, const char *methodName, const char *signature)
{
    if (clazz) {
        jmethodID id = d->jniEnv->GetMethodID(clazz, methodName, signature);
        if (!checkAndClearExceptions(d->jniEnv))
            return id;
    }
 
    return nullptr;
}
 
jmethodID QJniEnvironment::findStaticMethod(jclass clazz, const char *methodName, const char *signature)
{
    if (clazz) {
        jmethodID id = d->jniEnv->GetStaticMethodID(clazz, methodName, signature);
        if (!checkAndClearExceptions(d->jniEnv))
            return id;
    }
 
    return nullptr;
}
 
jfieldID QJniEnvironment::findField(jclass clazz, const char *fieldName, const char *signature)
{
    if (clazz) {
        jfieldID id = d->jniEnv->GetFieldID(clazz, fieldName, signature);
        if (!checkAndClearExceptions())
            return id;
    }
 
    return nullptr;
}
 
jfieldID QJniEnvironment::findStaticField(jclass clazz, const char *fieldName, const char *signature)
{
    if (clazz) {
        jfieldID id = d->jniEnv->GetStaticFieldID(clazz, fieldName, signature);
        if (!checkAndClearExceptions())
            return id;
    }
 
    return nullptr;
}
 
JavaVM *QJniEnvironment::javaVM()
{
    return QtAndroidPrivate::javaVM();
}
 
bool QJniEnvironment::registerNativeMethods(const char *className, const JNINativeMethod methods[],
                                            int size)
{
    const jclass clazz = findClass(className);
 
    if (!clazz)
        return false;
 
    return registerNativeMethods(clazz, methods, size);
}
#if QT_DEPRECATED_SINCE(6, 2)
bool QJniEnvironment::registerNativeMethods(const char *className, JNINativeMethod methods[],
                                            int size)
{
    return registerNativeMethods(className, const_cast<const JNINativeMethod*>(methods), size);
}
#endif
bool QJniEnvironment::registerNativeMethods(jclass clazz, const JNINativeMethod methods[],
                                            int size)
{
    if (d->jniEnv->RegisterNatives(clazz, methods, size) < 0) {
        checkAndClearExceptions();
        return false;
    }
    return true;
}
 
bool QJniEnvironment::checkAndClearExceptions(QJniEnvironment::OutputMode outputMode)
{
    return checkAndClearExceptions(d->jniEnv, outputMode);
}
 
namespace {
    // Any pending exception need to be cleared before calling this
    QString exceptionMessage(JNIEnv *env, const jthrowable &exception)
    {
        if (!exception)
            return {};
 
        auto logError = []() {
            qWarning() << "QJniEnvironment: a null object returned or an exception occurred while "
                          "fetching a prior exception message";
        };
 
        auto checkAndClear = [env]() {
            if (Q_UNLIKELY(env->ExceptionCheck())) {
                env->ExceptionClear();
                return true;
            }
            return false;
        };
 
        const jclass logClazz = env->FindClass("android/util/Log");
        if (checkAndClear() || !logClazz) {
            logError();
            return {};
        }
 
        const jmethodID methodId = env->GetStaticMethodID(logClazz, "getStackTraceString",
                                            "(Ljava/lang/Throwable;)Ljava/lang/String;");
        if (checkAndClear() || !methodId) {
            logError();
            return {};
        }
 
        jvalue value;
        value.l = static_cast<jobject>(exception);
        const jobject messageObj = env->CallStaticObjectMethodA(logClazz, methodId, &value);
        const jstring jmessage = static_cast<jstring>(messageObj);
        if (checkAndClear())
            return {};
 
        char const *utfMessage = env->GetStringUTFChars(jmessage, 0);
        const QString message = QString::fromUtf8(utfMessage);
 
        env->ReleaseStringUTFChars(jmessage, utfMessage);
 
        return message;
    }
} // end namespace
 
bool QJniEnvironment::checkAndClearExceptions(JNIEnv *env, QJniEnvironment::OutputMode outputMode)
{
    if (Q_UNLIKELY(env->ExceptionCheck())) {
        if (outputMode == OutputMode::Verbose) {
            if (jthrowable exception = env->ExceptionOccurred()) {
                env->ExceptionClear();
                const QString message = exceptionMessage(env, exception);
                // Print to QWARN since env->ExceptionDescribe() does the same
                if (!message.isEmpty())
                    qWarning().noquote() << message;
                env->DeleteLocalRef(exception);
            } else {
                // if the exception object is null for some reason just
                env->ExceptionDescribe();
                env->ExceptionClear();
            }
        } else {
            env->ExceptionClear();
        }
 
        return true;
    }
 
    return false;
}
 
QT_END_NAMESPACE