qandroidnativeinterface.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 <QtCore/qcoreapplication_platform.h>
 
#include <QtCore/private/qnativeinterface_p.h>
#include <QtCore/private/qjnihelpers_p.h>
#include <QtCore/qjniobject.h>
#if QT_CONFIG(future) && !defined(QT_NO_QOBJECT)
#include <QtCore/qfuture.h>
#include <QtCore/qfuturewatcher.h>
#include <QtCore/qpromise.h>
#include <QtCore/qtimer.h>
#include <QtCore/qthreadpool.h>
#include <deque>
#include <memory>
#endif
 
QT_BEGIN_NAMESPACE
 
#if QT_CONFIG(future) && !defined(QT_NO_QOBJECT)
static const char qtNativeClassName[] = "org/qtproject/qt/android/QtNative";
 
struct PendingRunnable {
    std::function<QVariant()> function;
    std::shared_ptr<QPromise<QVariant>> promise;
};
 
using PendingRunnables = std::deque<PendingRunnable>;
Q_GLOBAL_STATIC(PendingRunnables, g_pendingRunnables);
Q_CONSTINIT static QBasicMutex g_pendingRunnablesMutex;
#endif
 
QT_DEFINE_NATIVE_INTERFACE(QAndroidApplication);
 
QtJniTypes::Context QNativeInterface::QAndroidApplication::context()
{
    return QtAndroidPrivate::context();
}
 
bool QNativeInterface::QAndroidApplication::isActivityContext()
{
    return QtAndroidPrivate::activity().isValid();
}
 
int QNativeInterface::QAndroidApplication::sdkVersion()
{
    return QtAndroidPrivate::androidSdkVersion();
}
 
void QNativeInterface::QAndroidApplication::hideSplashScreen(int duration)
{
    QtAndroidPrivate::activity().callMethod<void>("hideSplashScreen", duration);
}
 
#if QT_CONFIG(future) && !defined(QT_NO_QOBJECT)
QFuture<QVariant> QNativeInterface::QAndroidApplication::runOnAndroidMainThread(
                                                    const std::function<QVariant()> &runnable,
                                                    const QDeadlineTimer timeout)
{
    auto promise = std::make_shared<QPromise<QVariant>>();
    QFuture<QVariant> future = promise->future();
    promise->start();
 
    if (!timeout.isForever()) {
        QThreadPool::globalInstance()->start([=]() mutable {
            QEventLoop loop;
            QTimer::singleShot(timeout.remainingTime(), &loop, [&]() {
                future.cancel();
                promise->finish();
                loop.quit();
            });
 
            QFutureWatcher<QVariant> watcher;
            QObject::connect(&watcher, &QFutureWatcher<QVariant>::finished, &loop, [&]() {
                loop.quit();
            });
            QObject::connect(&watcher, &QFutureWatcher<QVariant>::canceled, &loop, [&]() {
                loop.quit();
            });
            watcher.setFuture(future);
 
            // we're going to sleep, make sure we don't block
            // QThreadPool::globalInstance():
 
            QThreadPool::globalInstance()->releaseThread();
            const auto sg = qScopeGuard([] {
               QThreadPool::globalInstance()->reserveThread();
            });
            loop.exec();
        });
    }
 
    QMutexLocker locker(&g_pendingRunnablesMutex);
#ifdef __cpp_aggregate_paren_init
    g_pendingRunnables->emplace_back(runnable, std::move(promise));
#else
    g_pendingRunnables->push_back({runnable, std::move(promise)});
#endif
    locker.unlock();
 
    QJniObject::callStaticMethod<void>(qtNativeClassName,
                                       "runPendingCppRunnablesOnAndroidThread",
                                       "()V");
    return future;
}
 
// function called from Java from Android UI thread
static void runPendingCppRunnables(JNIEnv */*env*/, jobject /*obj*/)
{
    // run all posted runnables
    for (;;) {
        QMutexLocker locker(&g_pendingRunnablesMutex);
        if (g_pendingRunnables->empty())
            break;
 
        PendingRunnable r = std::move(g_pendingRunnables->front());
        g_pendingRunnables->pop_front();
        locker.unlock();
 
        // run the runnable outside the sync block!
        if (!r.promise->isCanceled())
            r.promise->addResult(r.function());
        r.promise->finish();
    }
}
#endif
 
bool QtAndroidPrivate::registerNativeInterfaceNatives(QJniEnvironment &env)
{
#if QT_CONFIG(future) && !defined(QT_NO_QOBJECT)
    const JNINativeMethod methods = {"runPendingCppRunnables", "()V", (void *)runPendingCppRunnables};
    return env.registerNativeMethods(qtNativeClassName, &methods, 1);
#else
    return true;
#endif
}
 
QT_END_NAMESPACE