Remove old Android code that have now has alternative public APIs

* Remove the old qjni private APIs.
* Remove the Android permission private APIs.
* Remove runOnAndroidThread().

Pick-to: 6.2
Change-Id: I37ba8b4cb87a099f067e2e0b6744b8d01a0f9bbc
Reviewed-by: Tor Arne Vestbø <tor.arne.vestbo@qt.io>

1 files changed, 3 insertions, 201 deletions

diff --git a/src/corelib/kernel/qjnihelpers.cpp b/src/corelib/kernel/qjnihelpers.cpp
index 46143d4c2c..b2a5dc7441 100644
--- a/src/corelib/kernel/qjnihelpers.cpp
+++ b/src/corelib/kernel/qjnihelpers.cpp
@@ -37,18 +37,14 @@
 **
 ****************************************************************************/
 
-#include "qcoreapplication.h"
-#include "qjnienvironment.h"
 #include "qjnihelpers_p.h"
+
+#include "qjnienvironment.h"
 #include "qjniobject.h"
 #include "qlist.h"
 #include "qmutex.h"
 #include "qsemaphore.h"
-#include "qsharedpointer.h"
-#include "qthread.h"
-
 #include <QtCore/private/qcoreapplication_p.h>
-#include <QtCore/qrunnable.h>
 
 #include <android/log.h>
 #include <deque>
@@ -72,91 +68,20 @@ static JavaVM *g_javaVM = nullptr;
 static jobject g_jActivity = nullptr;
 static jobject g_jService = nullptr;
 static jobject g_jClassLoader = nullptr;
-static jclass g_jNativeClass = nullptr;
-static jmethodID g_runPendingCppRunnablesMethodID = nullptr;
-Q_GLOBAL_STATIC(std::deque<QtAndroidPrivate::Runnable>, g_pendingRunnables);
-static QBasicMutex g_pendingRunnablesMutex;
 
 Q_GLOBAL_STATIC_WITH_ARGS(QtAndroidPrivate::OnBindListener*, g_onBindListener, (nullptr));
 Q_GLOBAL_STATIC(QMutex, g_onBindListenerMutex);
 Q_GLOBAL_STATIC(QSemaphore, g_waitForServiceSetupSemaphore);
 Q_GLOBAL_STATIC(QAtomicInt, g_serviceSetupLockers);
 
-class PermissionsResultClass : public QObject
-{
-    Q_OBJECT
-public:
-    PermissionsResultClass(const QtAndroidPrivate::PermissionsResultFunc &func) : m_func(func) {}
-    Q_INVOKABLE void sendResult(const QtAndroidPrivate::PermissionsHash &result) { m_func(result); delete this;}
-
-private:
-    QtAndroidPrivate::PermissionsResultFunc m_func;
-};
-
-typedef QHash<int, PermissionsResultClass*> PendingPermissionRequestsHash;
-Q_GLOBAL_STATIC(PendingPermissionRequestsHash, g_pendingPermissionRequests);
-static QBasicMutex g_pendingPermissionRequestsMutex;
-static int nextRequestCode()
-{
-    static QBasicAtomicInt counter = Q_BASIC_ATOMIC_INITIALIZER(0);
-    return counter.fetchAndAddRelaxed(1);
-}
-
-// function called from Java from Android UI thread
-static void runPendingCppRunnables(JNIEnv */*env*/, jobject /*obj*/)
-{
-    for (;;) { // run all posted runnables
-        QMutexLocker locker(&g_pendingRunnablesMutex);
-        if (g_pendingRunnables->empty()) {
-            break;
-        }
-        QtAndroidPrivate::Runnable runnable(std::move(g_pendingRunnables->front()));
-        g_pendingRunnables->pop_front();
-        locker.unlock();
-        runnable(); // run it outside the sync block!
-    }
-}
-
 namespace {
     struct GenericMotionEventListeners {
         QMutex mutex;
         QList<QtAndroidPrivate::GenericMotionEventListener *> listeners;
     };
-
-    enum {
-        PERMISSION_GRANTED = 0
-    };
 }
 Q_GLOBAL_STATIC(GenericMotionEventListeners, g_genericMotionEventListeners)
 
-static void sendRequestPermissionsResult(JNIEnv *env, jobject /*obj*/, jint requestCode,
-                                         jobjectArray permissions, jintArray grantResults)
-{
-    QMutexLocker locker(&g_pendingPermissionRequestsMutex);
-    auto it = g_pendingPermissionRequests->find(requestCode);
-    if (it == g_pendingPermissionRequests->end()) {
-        // show an error or something ?
-        return;
-    }
-    auto request = *it;
-    g_pendingPermissionRequests->erase(it);
-    locker.unlock();
-
-    Qt::ConnectionType connection = QThread::currentThread() == request->thread() ? Qt::DirectConnection : Qt::QueuedConnection;
-    QtAndroidPrivate::PermissionsHash hash;
-    const int size = env->GetArrayLength(permissions);
-    std::unique_ptr<jint[]> results(new jint[size]);
-    env->GetIntArrayRegion(grantResults, 0, size, results.get());
-    for (int i = 0 ; i < size; ++i) {
-        const auto &permission = QJniObject(env->GetObjectArrayElement(permissions, i)).toString();
-        auto value = results[i] == PERMISSION_GRANTED ?
-                            QtAndroidPrivate::PermissionsResult::Granted :
-                            QtAndroidPrivate::PermissionsResult::Denied;
-        hash[permission] = value;
-    }
-    QMetaObject::invokeMethod(request, "sendResult", connection, Q_ARG(QtAndroidPrivate::PermissionsHash, hash));
-}
-
 static jboolean dispatchGenericMotionEvent(JNIEnv *, jclass, jobject event)
 {
     jboolean ret = JNI_FALSE;
@@ -344,14 +269,12 @@ jint QtAndroidPrivate::initJNI(JavaVM *vm, JNIEnv *env)
     }
 
     static const JNINativeMethod methods[] = {
-        {"runPendingCppRunnables", "()V",  reinterpret_cast<void *>(runPendingCppRunnables)},
         {"dispatchGenericMotionEvent", "(Landroid/view/MotionEvent;)Z", reinterpret_cast<void *>(dispatchGenericMotionEvent)},
         {"dispatchKeyEvent", "(Landroid/view/KeyEvent;)Z", reinterpret_cast<void *>(dispatchKeyEvent)},
-        {"sendRequestPermissionsResult", "(I[Ljava/lang/String;[I)V", reinterpret_cast<void *>(sendRequestPermissionsResult)},
     };
 
     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;
 
@@ -361,17 +284,9 @@ jint QtAndroidPrivate::initJNI(JavaVM *vm, JNIEnv *env)
     if (!registerNativeInterfaceNatives())
         return JNI_ERR;
 
-    g_runPendingCppRunnablesMethodID = env->GetStaticMethodID(jQtNative,
-                                                       "runPendingCppRunnablesOnAndroidThread",
-                                                       "()V");
-    g_jNativeClass = static_cast<jclass>(env->NewGlobalRef(jQtNative));
-    env->DeleteLocalRef(jQtNative);
-
-    qRegisterMetaType<QtAndroidPrivate::PermissionsHash>();
     return JNI_OK;
 }
 
-
 jobject QtAndroidPrivate::activity()
 {
     return g_jActivity;
@@ -410,110 +325,6 @@ jint QtAndroidPrivate::androidSdkVersion()
     return sdkVersion;
 }
 
-void QtAndroidPrivate::runOnAndroidThread(const QtAndroidPrivate::Runnable &runnable, JNIEnv *env)
-{
-    QMutexLocker locker(&g_pendingRunnablesMutex);
-    const bool triggerRun = g_pendingRunnables->empty();
-    g_pendingRunnables->push_back(runnable);
-    locker.unlock();
-    if (triggerRun)
-        env->CallStaticVoidMethod(g_jNativeClass, g_runPendingCppRunnablesMethodID);
-}
-
-static bool waitForSemaphore(int timeoutMs, QSharedPointer<QSemaphore> sem)
-{
-    while (timeoutMs > 0) {
-        if (sem->tryAcquire(1, 10))
-            return true;
-        timeoutMs -= 10;
-        QCoreApplication::processEvents();
-    }
-    return false;
-}
-
-void QtAndroidPrivate::runOnAndroidThreadSync(const QtAndroidPrivate::Runnable &runnable, JNIEnv *env, int timeoutMs)
-{
-    QSharedPointer<QSemaphore> sem(new QSemaphore);
-    runOnAndroidThread([&runnable, sem]{
-        runnable();
-        sem->release();
-    }, env);
-    waitForSemaphore(timeoutMs, sem);
-}
-
-void QtAndroidPrivate::requestPermissions(JNIEnv *env,
-                                          const QStringList &permissions,
-                                          const QtAndroidPrivate::PermissionsResultFunc &callbackFunc,
-                                          bool directCall)
-{
-    if (androidSdkVersion() < 23 || !activity()) {
-        QHash<QString, QtAndroidPrivate::PermissionsResult> res;
-        for (const auto &perm : permissions)
-            res[perm] = checkPermission(perm);
-        callbackFunc(res);
-        return;
-    }
-    // Check API 23+ permissions
-    const int requestCode = nextRequestCode();
-    if (!directCall) {
-        QMutexLocker locker(&g_pendingPermissionRequestsMutex);
-        (*g_pendingPermissionRequests)[requestCode] = new PermissionsResultClass(callbackFunc);
-    }
-
-    runOnAndroidThread([permissions, callbackFunc, requestCode, directCall] {
-        if (directCall) {
-            QMutexLocker locker(&g_pendingPermissionRequestsMutex);
-            (*g_pendingPermissionRequests)[requestCode] = new PermissionsResultClass(callbackFunc);
-        }
-
-        QJniEnvironment env;
-        jclass clazz = env->FindClass("java/lang/String");
-
-        if (env.checkAndClearExceptions())
-            return;
-
-        auto array = env->NewObjectArray(permissions.size(), clazz, nullptr);
-        int index = 0;
-        for (const auto &perm : permissions)
-            env->SetObjectArrayElement(array, index++, QJniObject::fromString(perm).object());
-        QJniObject(activity()).callMethod<void>("requestPermissions", "([Ljava/lang/String;I)V", array, requestCode);
-        env->DeleteLocalRef(array);
-    }, env);
-}
-
-QtAndroidPrivate::PermissionsHash QtAndroidPrivate::requestPermissionsSync(JNIEnv *env, const QStringList &permissions, int timeoutMs)
-{
-    QSharedPointer<QHash<QString, QtAndroidPrivate::PermissionsResult>> res(new QHash<QString, QtAndroidPrivate::PermissionsResult>());
-    QSharedPointer<QSemaphore> sem(new QSemaphore);
-    requestPermissions(env, permissions, [sem, res](const QHash<QString, PermissionsResult> &result){
-        *res = result;
-        sem->release();
-    }, true);
-    if (waitForSemaphore(timeoutMs, sem))
-        return std::move(*res);
-    else // mustn't touch *res
-        return QHash<QString, QtAndroidPrivate::PermissionsResult>();
-}
-
-QtAndroidPrivate::PermissionsResult QtAndroidPrivate::checkPermission(const QString &permission)
-{
-    const auto res = QJniObject::callStaticMethod<jint>("org/qtproject/qt/android/QtNative",
-                                                        "checkSelfPermission",
-                                                        "(Ljava/lang/String;)I",
-                                                        QJniObject::fromString(permission).object());
-    return res == PERMISSION_GRANTED ? PermissionsResult::Granted : PermissionsResult::Denied;
-}
-
-bool QtAndroidPrivate::shouldShowRequestPermissionRationale(const QString &permission)
-{
-    if (androidSdkVersion() < 23 || !activity())
-        return false;
-
-    return QJniObject(activity()).callMethod<jboolean>("shouldShowRequestPermissionRationale",
-                                                       "(Ljava/lang/String;)Z",
-                                                       QJniObject::fromString(permission).object());
-}
-
 void QtAndroidPrivate::registerGenericMotionEventListener(QtAndroidPrivate::GenericMotionEventListener *listener)
 {
     QMutexLocker locker(&g_genericMotionEventListeners()->mutex);
@@ -538,13 +349,6 @@ void QtAndroidPrivate::unregisterKeyEventListener(QtAndroidPrivate::KeyEventList
     g_keyEventListeners()->listeners.removeOne(listener);
 }
 
-void QtAndroidPrivate::hideSplashScreen(JNIEnv *env, int duration)
-{
-    Q_UNUSED(env)
-    QJniObject::callStaticMethod<void>("org/qtproject/qt/android/QtNative",
-                                       "hideSplashScreen", "(I)V", duration);
-}
-
 void QtAndroidPrivate::waitForServiceSetup()
 {
     g_waitForServiceSetupSemaphore->acquire();
@@ -608,5 +412,3 @@ Q_CORE_EXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *reserved)
 
     return JNI_VERSION_1_6;
 }
-
-#include "qjnihelpers.moc"