qjnihelpers.cpp

Go to the documentation of this file.

// Copyright (C) 2022 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
// Qt-Security score:significant reason:default
 
#include "qjnihelpers_p.h"
 
#include "qjnienvironment.h"
#include "qjniobject.h"
#include "qlist.h"
#include "qmutex.h"
#include "qsemaphore.h"
#include "qreadwritelock.h"
#include <QtCore/private/qcoreapplication_p.h>
#include <QtCore/private/qlocking_p.h>
 
#if QT_CONFIG(regularexpression)
#include <QtCore/qregularexpression.h>
#endif
 
#include <android/log.h>
#include <deque>
#include <memory>
 
QT_BEGIN_NAMESPACE
 
Q_DECLARE_JNI_CLASS(QtLoader, "org/qtproject/qt/android/QtLoader")
Q_DECLARE_JNI_CLASS(QtInputDelegate, "org/qtproject/qt/android/QtInputDelegate");
Q_DECLARE_JNI_CLASS(MotionEvent, "android/view/MotionEvent");
Q_DECLARE_JNI_CLASS(KeyEvent, "android/view/KeyEvent");
 
using namespace Qt::StringLiterals;
 
namespace QtAndroidPrivate {
    // *Listener virtual function implementations.
    // Defined out-of-line to pin the vtable/type_info.
    ActivityResultListener::~ActivityResultListener() {}
    NewIntentListener::~NewIntentListener() {}
    ResumePauseListener::~ResumePauseListener() {}
    void ResumePauseListener::handlePause() {}
    void ResumePauseListener::handleResume() {}
}
 
static JavaVM *g_javaVM = nullptr;
static jobject g_jActivity = nullptr;
static jobject g_jService = nullptr;
static jobject g_jClassLoader = nullptr;
 
Q_CONSTINIT static QtAndroidPrivate::OnBindListener *g_onBindListener;
Q_CONSTINIT static QBasicMutex g_onBindListenerMutex;
Q_GLOBAL_STATIC(QSemaphore, g_waitForServiceSetupSemaphore);
Q_CONSTINIT static QBasicAtomicInt g_serviceSetupLockers = Q_BASIC_ATOMIC_INITIALIZER(0);
 
Q_GLOBAL_STATIC(QReadWriteLock, g_updateMutex);
 
static jboolean updateNativeActivity(JNIEnv *env, jclass = nullptr)
{
 
    jclass jQtNative = env->FindClass("org/qtproject/qt/android/QtNative");
    if (QJniEnvironment::checkAndClearExceptions(env))
        return JNI_FALSE;
 
    jmethodID activityMethodID =
            env->GetStaticMethodID(jQtNative, "activity", "()Landroid/app/Activity;");
    if (QJniEnvironment::checkAndClearExceptions(env))
        return JNI_FALSE;
 
    jobject activity = env->CallStaticObjectMethod(jQtNative, activityMethodID);
    if (QJniEnvironment::checkAndClearExceptions(env))
        return JNI_FALSE;
 
    QWriteLocker locker(g_updateMutex());
 
    if (g_jActivity) {
        env->DeleteGlobalRef(g_jActivity);
        g_jActivity = nullptr;
    }
 
    if (activity) {
        g_jActivity = env->NewGlobalRef(activity);
        env->DeleteLocalRef(activity);
    }
 
    env->DeleteLocalRef(jQtNative);
    if (QJniEnvironment::checkAndClearExceptions(env))
        return JNI_FALSE;
 
    return JNI_TRUE;
}
 
namespace {
    class ActivityResultListeners
    {
    public:
        QMutex mutex;
        QList<QtAndroidPrivate::ActivityResultListener *> listeners;
    };
}
 
Q_GLOBAL_STATIC(ActivityResultListeners, g_activityResultListeners)
 
void QtAndroidPrivate::registerActivityResultListener(ActivityResultListener *listener)
{
    QMutexLocker locker(&g_activityResultListeners()->mutex);
    g_activityResultListeners()->listeners.append(listener);
}
 
void QtAndroidPrivate::unregisterActivityResultListener(ActivityResultListener *listener)
{
    QMutexLocker locker(&g_activityResultListeners()->mutex);
    g_activityResultListeners()->listeners.removeAll(listener);
}
 
void QtAndroidPrivate::handleActivityResult(jint requestCode, jint resultCode, jobject data)
{
    QMutexLocker locker(&g_activityResultListeners()->mutex);
    const QList<QtAndroidPrivate::ActivityResultListener *> &listeners = g_activityResultListeners()->listeners;
    for (int i=0; i<listeners.size(); ++i) {
        if (listeners.at(i)->handleActivityResult(requestCode, resultCode, data))
            break;
    }
}
 
namespace {
    class NewIntentListeners
    {
    public:
        QMutex mutex;
        QList<QtAndroidPrivate::NewIntentListener *> listeners;
    };
}
 
Q_GLOBAL_STATIC(NewIntentListeners, g_newIntentListeners)
 
void QtAndroidPrivate::registerNewIntentListener(NewIntentListener *listener)
{
    QMutexLocker locker(&g_newIntentListeners()->mutex);
    g_newIntentListeners()->listeners.append(listener);
}
 
void QtAndroidPrivate::unregisterNewIntentListener(NewIntentListener *listener)
{
    QMutexLocker locker(&g_newIntentListeners()->mutex);
    g_newIntentListeners()->listeners.removeAll(listener);
}
 
void QtAndroidPrivate::handleNewIntent(JNIEnv *env, jobject intent)
{
    QMutexLocker locker(&g_newIntentListeners()->mutex);
    const QList<QtAndroidPrivate::NewIntentListener *> &listeners = g_newIntentListeners()->listeners;
    for (int i=0; i<listeners.size(); ++i) {
        if (listeners.at(i)->handleNewIntent(env, intent))
            break;
    }
}
 
QtAndroidPrivate::GenericMotionEventListener::~GenericMotionEventListener() {}
namespace {
struct GenericMotionEventListeners {
    QMutex mutex;
    QList<QtAndroidPrivate::GenericMotionEventListener *> listeners;
};
}
Q_GLOBAL_STATIC(GenericMotionEventListeners, g_genericMotionEventListeners)
 
static jboolean dispatchGenericMotionEvent(JNIEnv *, jclass, QtJniTypes::MotionEvent event)
{
    jboolean ret = JNI_FALSE;
    QMutexLocker locker(&g_genericMotionEventListeners()->mutex);
    for (auto *listener : std::as_const(g_genericMotionEventListeners()->listeners))
        ret |= listener->handleGenericMotionEvent(event.object());
    return ret;
}
Q_DECLARE_JNI_NATIVE_METHOD(dispatchGenericMotionEvent);
 
QtAndroidPrivate::KeyEventListener::~KeyEventListener() {}
namespace {
struct KeyEventListeners {
    QMutex mutex;
    QList<QtAndroidPrivate::KeyEventListener *> listeners;
};
}
Q_GLOBAL_STATIC(KeyEventListeners, g_keyEventListeners)
 
static jboolean dispatchKeyEvent(JNIEnv *, jclass, QtJniTypes::KeyEvent event)
{
    jboolean ret = JNI_FALSE;
    QMutexLocker locker(&g_keyEventListeners()->mutex);
    for (auto *listener : std::as_const(g_keyEventListeners()->listeners))
        ret |= listener->handleKeyEvent(event.object());
    return ret;
}
Q_DECLARE_JNI_NATIVE_METHOD(dispatchKeyEvent);
 
void QtAndroidPrivate::registerGenericMotionEventListener(QtAndroidPrivate::GenericMotionEventListener *listener)
{
    QMutexLocker locker(&g_genericMotionEventListeners()->mutex);
    g_genericMotionEventListeners()->listeners.push_back(listener);
}
 
void QtAndroidPrivate::unregisterGenericMotionEventListener(QtAndroidPrivate::GenericMotionEventListener *listener)
{
    QMutexLocker locker(&g_genericMotionEventListeners()->mutex);
    g_genericMotionEventListeners()->listeners.removeOne(listener);
}
 
void QtAndroidPrivate::registerKeyEventListener(QtAndroidPrivate::KeyEventListener *listener)
{
    QMutexLocker locker(&g_keyEventListeners()->mutex);
    g_keyEventListeners()->listeners.push_back(listener);
}
 
void QtAndroidPrivate::unregisterKeyEventListener(QtAndroidPrivate::KeyEventListener *listener)
{
    QMutexLocker locker(&g_keyEventListeners()->mutex);
    g_keyEventListeners()->listeners.removeOne(listener);
}
 
namespace {
    class ResumePauseListeners
    {
    public:
        QMutex mutex;
        QList<QtAndroidPrivate::ResumePauseListener *> listeners;
    };
}
 
Q_GLOBAL_STATIC(ResumePauseListeners, g_resumePauseListeners)
 
void QtAndroidPrivate::registerResumePauseListener(ResumePauseListener *listener)
{
    QMutexLocker locker(&g_resumePauseListeners()->mutex);
    g_resumePauseListeners()->listeners.append(listener);
}
 
void QtAndroidPrivate::unregisterResumePauseListener(ResumePauseListener *listener)
{
    QMutexLocker locker(&g_resumePauseListeners()->mutex);
    g_resumePauseListeners()->listeners.removeAll(listener);
}
 
void QtAndroidPrivate::handlePause()
{
    QMutexLocker locker(&g_resumePauseListeners()->mutex);
    const QList<QtAndroidPrivate::ResumePauseListener *> &listeners = g_resumePauseListeners()->listeners;
    for (int i=0; i<listeners.size(); ++i)
        listeners.at(i)->handlePause();
}
 
void QtAndroidPrivate::handleResume()
{
    QMutexLocker locker(&g_resumePauseListeners()->mutex);
    const QList<QtAndroidPrivate::ResumePauseListener *> &listeners = g_resumePauseListeners()->listeners;
    for (int i=0; i<listeners.size(); ++i)
        listeners.at(i)->handleResume();
}
 
bool QtAndroidPrivate::isUncompressedNativeLibs()
{
    const static bool isUncompressed = QtJniTypes::QtLoader::callStaticMethod<bool>(
                "isUncompressedNativeLibs");
    return isUncompressed;
}
 
QString QtAndroidPrivate::resolveApkPath(const QString &fileName)
{
#if QT_CONFIG(regularexpression)
    const static QRegularExpression inApkRegex("(.+\\.apk)!\\/.+"_L1);
    auto match = inApkRegex.matchView(fileName);
    if (match.hasMatch())
        return match.captured(1);
#else
    if (int index = fileName.lastIndexOf(u".apk!/"); index > 0)
        return fileName.mid(0, index + 4);
#endif
 
    return {};
}
 
jint QtAndroidPrivate::initJNI(JavaVM *vm, JNIEnv *env)
{
    g_javaVM = vm;
 
    jclass jQtNative = env->FindClass("org/qtproject/qt/android/QtNative");
 
    if (QJniEnvironment::checkAndClearExceptions(env))
        return JNI_ERR;
 
    jmethodID activityMethodID = env->GetStaticMethodID(jQtNative,
                                                        "activity",
                                                        "()Landroid/app/Activity;");
 
    if (QJniEnvironment::checkAndClearExceptions(env))
        return JNI_ERR;
 
    jobject activity = env->CallStaticObjectMethod(jQtNative, activityMethodID);
 
    if (QJniEnvironment::checkAndClearExceptions(env))
        return JNI_ERR;
 
    jmethodID serviceMethodID = env->GetStaticMethodID(jQtNative,
                                                       "service",
                                                       "()Landroid/app/Service;");
 
    if (QJniEnvironment::checkAndClearExceptions(env))
        return JNI_ERR;
 
    jobject service = env->CallStaticObjectMethod(jQtNative, serviceMethodID);
 
    if (QJniEnvironment::checkAndClearExceptions(env))
        return JNI_ERR;
 
    jmethodID classLoaderMethodID = env->GetStaticMethodID(jQtNative,
                                                           "classLoader",
                                                           "()Ljava/lang/ClassLoader;");
 
    if (QJniEnvironment::checkAndClearExceptions(env))
        return JNI_ERR;
 
    jobject classLoader = env->CallStaticObjectMethod(jQtNative, classLoaderMethodID);
    if (QJniEnvironment::checkAndClearExceptions(env))
        return JNI_ERR;
 
    g_jClassLoader = env->NewGlobalRef(classLoader);
    env->DeleteLocalRef(classLoader);
    if (activity) {
        g_jActivity = env->NewGlobalRef(activity);
        env->DeleteLocalRef(activity);
    }
    if (service) {
        g_jService = env->NewGlobalRef(service);
        env->DeleteLocalRef(service);
    }
 
    static const JNINativeMethod methods[] = {
        {"updateNativeActivity", "()Z", reinterpret_cast<void *>(updateNativeActivity) },
    };
 
    const bool regOk = (env->RegisterNatives(jQtNative, methods, sizeof(methods) / sizeof(methods[0])) == JNI_OK);
    env->DeleteLocalRef(jQtNative);
    if (!regOk && QJniEnvironment::checkAndClearExceptions(env))
        return JNI_ERR;
 
    QJniEnvironment qJniEnv;
    using namespace QtJniTypes;
    if (!QtInputDelegate::registerNativeMethods(
                { Q_JNI_NATIVE_METHOD(dispatchGenericMotionEvent),
                  Q_JNI_NATIVE_METHOD(dispatchKeyEvent) })) {
        qCritical() << "Failed to register natives methods for"
                    << Traits<QtInputDelegate>::className();
        return JNI_ERR;
    }
 
#if QT_CONFIG(permissions)
    if (!registerPermissionNatives(qJniEnv))
        return JNI_ERR;
#endif
 
    if (!registerNativeInterfaceNatives(qJniEnv))
        return JNI_ERR;
 
    if (!registerExtrasNatives(qJniEnv))
        return JNI_ERR;
 
    return JNI_OK;
}
 
Q_CORE_EXPORT jobject qt_androidActivity()
{
    QReadLocker locker(g_updateMutex());
    return g_jActivity;
}
 
 
QtJniTypes::Activity QtAndroidPrivate::activity()
{
    QReadLocker locker(g_updateMutex());
    return g_jActivity;
}
 
Q_CORE_EXPORT jobject qt_androidService()
{
    return g_jService;
}
 
QtJniTypes::Service QtAndroidPrivate::service()
{
    return g_jService;
}
 
QtJniTypes::Context QtAndroidPrivate::context()
{
    QReadLocker locker(g_updateMutex());
    if (g_jActivity)
        return g_jActivity;
    if (g_jService)
        return g_jService;
 
    return nullptr;
}
 
JavaVM *QtAndroidPrivate::javaVM()
{
    return g_javaVM;
}
 
jobject QtAndroidPrivate::classLoader()
{
    return g_jClassLoader;
}
 
jint QtAndroidPrivate::androidSdkVersion()
{
    static jint sdkVersion = 0;
    if (!sdkVersion)
        sdkVersion = QJniObject::getStaticField<jint>("android/os/Build$VERSION", "SDK_INT");
    return sdkVersion;
}
 
void QtAndroidPrivate::waitForServiceSetup()
{
    g_waitForServiceSetupSemaphore->acquire();
}
 
int QtAndroidPrivate::acuqireServiceSetup(int flags)
{
    g_serviceSetupLockers.ref();
    return flags;
}
 
void QtAndroidPrivate::setOnBindListener(QtAndroidPrivate::OnBindListener *listener)
{
    const auto lock = qt_scoped_lock(g_onBindListenerMutex);
    g_onBindListener = listener;
    if (!g_serviceSetupLockers.deref())
        g_waitForServiceSetupSemaphore->release();
}
 
jobject QtAndroidPrivate::callOnBindListener(jobject intent)
{
    const auto lock = qt_scoped_lock(g_onBindListenerMutex);
    if (g_onBindListener)
        return g_onBindListener->onBind(intent);
    return nullptr;
}
 
Q_CONSTINIT static QBasicAtomicInt g_androidDeadlockProtector = Q_BASIC_ATOMIC_INITIALIZER(0);
 
bool QtAndroidPrivate::acquireAndroidDeadlockProtector()
{
    return g_androidDeadlockProtector.testAndSetAcquire(0, 1);
}
 
void QtAndroidPrivate::releaseAndroidDeadlockProtector()
{
    g_androidDeadlockProtector.storeRelease(0);
}
 
QtAndroidPrivate::AndroidDeadlockProtector::AndroidDeadlockProtector(const QString &lockedBy)
    : m_lockedBy(lockedBy)
{ }
 
QtAndroidPrivate::AndroidDeadlockProtector::~AndroidDeadlockProtector() {
    if (m_acquired) {
        QtAndroidPrivate::releaseAndroidDeadlockProtector();
        s_lockers.removeOne(m_lockedBy);
    }
}
 
bool QtAndroidPrivate::AndroidDeadlockProtector::acquire() {
    m_acquired = QtAndroidPrivate::acquireAndroidDeadlockProtector();
    if (m_acquired) {
        s_lockers.append(m_lockedBy);
    } else {
        qWarning("Failed to acquire deadlock protector for '%s' while already locked by '%s'.",
                 qPrintable(m_lockedBy), qPrintable(s_lockers.join(u',')));
    }
    return m_acquired;
}
 
QT_END_NAMESPACE
 
extern "C" JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *reserved)
{
    Q_UNUSED(reserved);
 
    static const char logTag[] = "QtCore";
    static bool initialized = false;
    if (initialized)
        return JNI_VERSION_1_6;
    initialized = true;
 
    typedef union {
        JNIEnv *nenv;
        void *venv;
    } _JNIEnv;
 
    __android_log_print(ANDROID_LOG_INFO, logTag, "Start");
 
    _JNIEnv uenv;
    uenv.venv = nullptr;
 
    if (vm->GetEnv(&uenv.venv, JNI_VERSION_1_6) != JNI_OK) {
        __android_log_print(ANDROID_LOG_FATAL, logTag, "GetEnv failed");
        return JNI_ERR;
    }
 
    JNIEnv *env = uenv.nenv;
    const jint ret = QT_PREPEND_NAMESPACE(QtAndroidPrivate::initJNI(vm, env));
    if (ret != 0) {
        __android_log_print(ANDROID_LOG_FATAL, logTag, "initJNI failed");
        return ret;
    }
 
    return JNI_VERSION_1_6;
}