Revision control
Copy as Markdown
// 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;
}