484 lines
18 KiB
C++
484 lines
18 KiB
C++
/****************************************************************************
|
|
**
|
|
** Copyright (C) 2012 BogDan Vatra <bogdan@kde.org>
|
|
** Contact: https://www.qt.io/licensing/
|
|
**
|
|
** This file is part of the plugins of the Qt Toolkit.
|
|
**
|
|
** $QT_BEGIN_LICENSE:LGPL$
|
|
** Commercial License Usage
|
|
** Licensees holding valid commercial Qt licenses may use this file in
|
|
** accordance with the commercial license agreement provided with the
|
|
** Software or, alternatively, in accordance with the terms contained in
|
|
** a written agreement between you and The Qt Company. For licensing terms
|
|
** and conditions see https://www.qt.io/terms-conditions. For further
|
|
** information use the contact form at https://www.qt.io/contact-us.
|
|
**
|
|
** GNU Lesser General Public License Usage
|
|
** Alternatively, this file may be used under the terms of the GNU Lesser
|
|
** General Public License version 3 as published by the Free Software
|
|
** Foundation and appearing in the file LICENSE.LGPL3 included in the
|
|
** packaging of this file. Please review the following information to
|
|
** ensure the GNU Lesser General Public License version 3 requirements
|
|
** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
|
|
**
|
|
** GNU General Public License Usage
|
|
** Alternatively, this file may be used under the terms of the GNU
|
|
** General Public License version 2.0 or (at your option) the GNU General
|
|
** Public license version 3 or any later version approved by the KDE Free
|
|
** Qt Foundation. The licenses are as published by the Free Software
|
|
** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
|
|
** included in the packaging of this file. Please review the following
|
|
** information to ensure the GNU General Public License requirements will
|
|
** be met: https://www.gnu.org/licenses/gpl-2.0.html and
|
|
** https://www.gnu.org/licenses/gpl-3.0.html.
|
|
**
|
|
** $QT_END_LICENSE$
|
|
**
|
|
****************************************************************************/
|
|
|
|
#include "qandroidplatformintegration.h"
|
|
|
|
#include <QtCore/private/qjni_p.h>
|
|
#include <QtGui/private/qguiapplication_p.h>
|
|
#include <QGuiApplication>
|
|
#include <QOpenGLContext>
|
|
#include <QThread>
|
|
#include <QOffscreenSurface>
|
|
|
|
#include <QtEglSupport/private/qeglpbuffer_p.h>
|
|
#include <qpa/qwindowsysteminterface.h>
|
|
#include <qpa/qplatformwindow.h>
|
|
#include <qpa/qplatformoffscreensurface.h>
|
|
|
|
#include "androidjnimain.h"
|
|
#include "qabstracteventdispatcher.h"
|
|
#include "qandroideventdispatcher.h"
|
|
#include "qandroidplatformbackingstore.h"
|
|
#include "qandroidplatformaccessibility.h"
|
|
#include "qandroidplatformclipboard.h"
|
|
#include "qandroidplatformforeignwindow.h"
|
|
#include "qandroidplatformfontdatabase.h"
|
|
#include "qandroidplatformopenglcontext.h"
|
|
#include "qandroidplatformopenglwindow.h"
|
|
#include "qandroidplatformscreen.h"
|
|
#include "qandroidplatformservices.h"
|
|
#include "qandroidplatformtheme.h"
|
|
#include "qandroidsystemlocale.h"
|
|
#include "qandroidplatformoffscreensurface.h"
|
|
|
|
#include <QtPlatformHeaders/QEGLNativeContext>
|
|
|
|
#if QT_CONFIG(vulkan)
|
|
#include "qandroidplatformvulkanwindow.h"
|
|
#include "qandroidplatformvulkaninstance.h"
|
|
#endif
|
|
|
|
QT_BEGIN_NAMESPACE
|
|
|
|
int QAndroidPlatformIntegration::m_defaultGeometryWidth = 320;
|
|
int QAndroidPlatformIntegration::m_defaultGeometryHeight = 455;
|
|
int QAndroidPlatformIntegration::m_defaultScreenWidth = 320;
|
|
int QAndroidPlatformIntegration::m_defaultScreenHeight = 455;
|
|
int QAndroidPlatformIntegration::m_defaultPhysicalSizeWidth = 50;
|
|
int QAndroidPlatformIntegration::m_defaultPhysicalSizeHeight = 71;
|
|
|
|
Qt::ScreenOrientation QAndroidPlatformIntegration::m_orientation = Qt::PrimaryOrientation;
|
|
Qt::ScreenOrientation QAndroidPlatformIntegration::m_nativeOrientation = Qt::PrimaryOrientation;
|
|
|
|
bool QAndroidPlatformIntegration::m_showPasswordEnabled = false;
|
|
|
|
void *QAndroidPlatformNativeInterface::nativeResourceForIntegration(const QByteArray &resource)
|
|
{
|
|
if (resource=="JavaVM")
|
|
return QtAndroid::javaVM();
|
|
if (resource == "QtActivity")
|
|
return QtAndroid::activity();
|
|
if (resource == "QtService")
|
|
return QtAndroid::service();
|
|
if (resource == "AndroidStyleData") {
|
|
if (m_androidStyle) {
|
|
if (m_androidStyle->m_styleData.isEmpty())
|
|
m_androidStyle->m_styleData = AndroidStyle::loadStyleData();
|
|
return &m_androidStyle->m_styleData;
|
|
}
|
|
else
|
|
return nullptr;
|
|
}
|
|
if (resource == "AndroidStandardPalette") {
|
|
if (m_androidStyle)
|
|
return &m_androidStyle->m_standardPalette;
|
|
else
|
|
return nullptr;
|
|
}
|
|
if (resource == "AndroidQWidgetFonts") {
|
|
if (m_androidStyle)
|
|
return &m_androidStyle->m_QWidgetsFonts;
|
|
else
|
|
return nullptr;
|
|
}
|
|
if (resource == "AndroidDeviceName") {
|
|
static QString deviceName = QtAndroid::deviceName();
|
|
return &deviceName;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void *QAndroidPlatformNativeInterface::nativeResourceForWindow(const QByteArray &resource, QWindow *window)
|
|
{
|
|
#if QT_CONFIG(vulkan)
|
|
if (resource == "vkSurface") {
|
|
if (window->surfaceType() == QSurface::VulkanSurface) {
|
|
QAndroidPlatformVulkanWindow *w = static_cast<QAndroidPlatformVulkanWindow *>(window->handle());
|
|
// return a pointer to the VkSurfaceKHR, not the value
|
|
return w ? w->vkSurface() : nullptr;
|
|
}
|
|
}
|
|
#else
|
|
Q_UNUSED(resource);
|
|
Q_UNUSED(window);
|
|
#endif
|
|
return nullptr;
|
|
}
|
|
|
|
void QAndroidPlatformNativeInterface::customEvent(QEvent *event)
|
|
{
|
|
if (event->type() != QEvent::User)
|
|
return;
|
|
|
|
QMutexLocker lock(QtAndroid::platformInterfaceMutex());
|
|
QAndroidPlatformIntegration *api = static_cast<QAndroidPlatformIntegration *>(QGuiApplicationPrivate::platformIntegration());
|
|
QtAndroid::setAndroidPlatformIntegration(api);
|
|
api->flushPendingUpdates();
|
|
}
|
|
|
|
QAndroidPlatformIntegration::QAndroidPlatformIntegration(const QStringList ¶mList)
|
|
: m_touchDevice(nullptr)
|
|
#ifndef QT_NO_ACCESSIBILITY
|
|
, m_accessibility(nullptr)
|
|
#endif
|
|
{
|
|
Q_UNUSED(paramList);
|
|
m_androidPlatformNativeInterface = new QAndroidPlatformNativeInterface();
|
|
|
|
m_eglDisplay = eglGetDisplay(EGL_DEFAULT_DISPLAY);
|
|
if (Q_UNLIKELY(m_eglDisplay == EGL_NO_DISPLAY))
|
|
qFatal("Could not open egl display");
|
|
|
|
EGLint major, minor;
|
|
if (Q_UNLIKELY(!eglInitialize(m_eglDisplay, &major, &minor)))
|
|
qFatal("Could not initialize egl display");
|
|
|
|
if (Q_UNLIKELY(!eglBindAPI(EGL_OPENGL_ES_API)))
|
|
qFatal("Could not bind GL_ES API");
|
|
|
|
m_primaryScreen = new QAndroidPlatformScreen();
|
|
QWindowSystemInterface::handleScreenAdded(m_primaryScreen);
|
|
m_primaryScreen->setPhysicalSize(QSize(m_defaultPhysicalSizeWidth, m_defaultPhysicalSizeHeight));
|
|
m_primaryScreen->setSize(QSize(m_defaultScreenWidth, m_defaultScreenHeight));
|
|
m_primaryScreen->setAvailableGeometry(QRect(0, 0, m_defaultGeometryWidth, m_defaultGeometryHeight));
|
|
|
|
m_mainThread = QThread::currentThread();
|
|
|
|
m_androidFDB = new QAndroidPlatformFontDatabase();
|
|
m_androidPlatformServices = new QAndroidPlatformServices();
|
|
|
|
#ifndef QT_NO_CLIPBOARD
|
|
m_androidPlatformClipboard = new QAndroidPlatformClipboard();
|
|
#endif
|
|
|
|
m_androidSystemLocale = new QAndroidSystemLocale;
|
|
|
|
#ifndef QT_NO_ACCESSIBILITY
|
|
m_accessibility = new QAndroidPlatformAccessibility();
|
|
#endif // QT_NO_ACCESSIBILITY
|
|
|
|
QJNIObjectPrivate javaActivity(QtAndroid::activity());
|
|
if (!javaActivity.isValid())
|
|
javaActivity = QtAndroid::service();
|
|
|
|
if (javaActivity.isValid()) {
|
|
QJNIObjectPrivate resources = javaActivity.callObjectMethod("getResources", "()Landroid/content/res/Resources;");
|
|
QJNIObjectPrivate configuration = resources.callObjectMethod("getConfiguration", "()Landroid/content/res/Configuration;");
|
|
|
|
int touchScreen = configuration.getField<jint>("touchscreen");
|
|
if (touchScreen == QJNIObjectPrivate::getStaticField<jint>("android/content/res/Configuration", "TOUCHSCREEN_FINGER")
|
|
|| touchScreen == QJNIObjectPrivate::getStaticField<jint>("android/content/res/Configuration", "TOUCHSCREEN_STYLUS"))
|
|
{
|
|
m_touchDevice = new QTouchDevice;
|
|
m_touchDevice->setType(QTouchDevice::TouchScreen);
|
|
m_touchDevice->setCapabilities(QTouchDevice::Position
|
|
| QTouchDevice::Area
|
|
| QTouchDevice::Pressure
|
|
| QTouchDevice::NormalizedPosition);
|
|
|
|
QJNIObjectPrivate pm = javaActivity.callObjectMethod("getPackageManager", "()Landroid/content/pm/PackageManager;");
|
|
Q_ASSERT(pm.isValid());
|
|
if (pm.callMethod<jboolean>("hasSystemFeature","(Ljava/lang/String;)Z",
|
|
QJNIObjectPrivate::getStaticObjectField("android/content/pm/PackageManager", "FEATURE_TOUCHSCREEN_MULTITOUCH_JAZZHAND", "Ljava/lang/String;").object())) {
|
|
m_touchDevice->setMaximumTouchPoints(10);
|
|
} else if (pm.callMethod<jboolean>("hasSystemFeature","(Ljava/lang/String;)Z",
|
|
QJNIObjectPrivate::getStaticObjectField("android/content/pm/PackageManager", "FEATURE_TOUCHSCREEN_MULTITOUCH_DISTINCT", "Ljava/lang/String;").object())) {
|
|
m_touchDevice->setMaximumTouchPoints(4);
|
|
} else if (pm.callMethod<jboolean>("hasSystemFeature","(Ljava/lang/String;)Z",
|
|
QJNIObjectPrivate::getStaticObjectField("android/content/pm/PackageManager", "FEATURE_TOUCHSCREEN_MULTITOUCH", "Ljava/lang/String;").object())) {
|
|
m_touchDevice->setMaximumTouchPoints(2);
|
|
}
|
|
QWindowSystemInterface::registerTouchDevice(m_touchDevice);
|
|
}
|
|
|
|
auto contentResolver = javaActivity.callObjectMethod("getContentResolver", "()Landroid/content/ContentResolver;");
|
|
Q_ASSERT(contentResolver.isValid());
|
|
QJNIObjectPrivate txtShowPassValue = QJNIObjectPrivate::callStaticObjectMethod("android/provider/Settings$System",
|
|
"getString",
|
|
"(Landroid/content/ContentResolver;Ljava/lang/String;)Ljava/lang/String;",
|
|
contentResolver.object(),
|
|
QJNIObjectPrivate::getStaticObjectField("android/provider/Settings$System", "TEXT_SHOW_PASSWORD", "Ljava/lang/String;").object());
|
|
if (txtShowPassValue.isValid()) {
|
|
bool ok = false;
|
|
const int txtShowPass = txtShowPassValue.toString().toInt(&ok);
|
|
m_showPasswordEnabled = ok ? (txtShowPass == 1) : false;
|
|
}
|
|
}
|
|
|
|
// We can't safely notify the jni bridge that we're up and running just yet, so let's postpone
|
|
// it for now.
|
|
QCoreApplication::postEvent(m_androidPlatformNativeInterface, new QEvent(QEvent::User));
|
|
}
|
|
|
|
static bool needsBasicRenderloopWorkaround()
|
|
{
|
|
static bool needsWorkaround =
|
|
QtAndroid::deviceName().compare(QLatin1String("samsung SM-T211"), Qt::CaseInsensitive) == 0
|
|
|| QtAndroid::deviceName().compare(QLatin1String("samsung SM-T210"), Qt::CaseInsensitive) == 0
|
|
|| QtAndroid::deviceName().compare(QLatin1String("samsung SM-T215"), Qt::CaseInsensitive) == 0;
|
|
return needsWorkaround;
|
|
}
|
|
|
|
bool QAndroidPlatformIntegration::hasCapability(Capability cap) const
|
|
{
|
|
switch (cap) {
|
|
case ApplicationState: return true;
|
|
case ThreadedPixmaps: return true;
|
|
case NativeWidgets: return QtAndroid::activity();
|
|
case OpenGL: return QtAndroid::activity();
|
|
case ForeignWindows: return QtAndroid::activity();
|
|
case ThreadedOpenGL: return !needsBasicRenderloopWorkaround() && QtAndroid::activity();
|
|
case RasterGLSurface: return QtAndroid::activity();
|
|
case TopStackedNativeChildWindows: return false;
|
|
default:
|
|
return QPlatformIntegration::hasCapability(cap);
|
|
}
|
|
}
|
|
|
|
QPlatformBackingStore *QAndroidPlatformIntegration::createPlatformBackingStore(QWindow *window) const
|
|
{
|
|
if (!QtAndroid::activity())
|
|
return nullptr;
|
|
return new QAndroidPlatformBackingStore(window);
|
|
}
|
|
|
|
QPlatformOpenGLContext *QAndroidPlatformIntegration::createPlatformOpenGLContext(QOpenGLContext *context) const
|
|
{
|
|
if (!QtAndroid::activity())
|
|
return nullptr;
|
|
QSurfaceFormat format(context->format());
|
|
format.setAlphaBufferSize(8);
|
|
format.setRedBufferSize(8);
|
|
format.setGreenBufferSize(8);
|
|
format.setBlueBufferSize(8);
|
|
auto ctx = new QAndroidPlatformOpenGLContext(format, context->shareHandle(), m_eglDisplay, context->nativeHandle());
|
|
context->setNativeHandle(QVariant::fromValue<QEGLNativeContext>(QEGLNativeContext(ctx->eglContext(), m_eglDisplay)));
|
|
return ctx;
|
|
}
|
|
|
|
QPlatformOffscreenSurface *QAndroidPlatformIntegration::createPlatformOffscreenSurface(QOffscreenSurface *surface) const
|
|
{
|
|
if (!QtAndroid::activity())
|
|
return nullptr;
|
|
|
|
QSurfaceFormat format(surface->requestedFormat());
|
|
format.setAlphaBufferSize(8);
|
|
format.setRedBufferSize(8);
|
|
format.setGreenBufferSize(8);
|
|
format.setBlueBufferSize(8);
|
|
|
|
if (surface->nativeHandle()) {
|
|
// Adopt existing offscreen Surface
|
|
// The expectation is that nativeHandle is an ANativeWindow* representing
|
|
// an android.view.Surface
|
|
return new QAndroidPlatformOffscreenSurface(m_eglDisplay, format, surface);
|
|
}
|
|
|
|
return new QEGLPbuffer(m_eglDisplay, format, surface);
|
|
}
|
|
|
|
QPlatformWindow *QAndroidPlatformIntegration::createPlatformWindow(QWindow *window) const
|
|
{
|
|
if (!QtAndroid::activity())
|
|
return nullptr;
|
|
|
|
#if QT_CONFIG(vulkan)
|
|
if (window->surfaceType() == QSurface::VulkanSurface)
|
|
return new QAndroidPlatformVulkanWindow(window);
|
|
#endif
|
|
|
|
return new QAndroidPlatformOpenGLWindow(window, m_eglDisplay);
|
|
}
|
|
|
|
QPlatformWindow *QAndroidPlatformIntegration::createForeignWindow(QWindow *window, WId nativeHandle) const
|
|
{
|
|
return new QAndroidPlatformForeignWindow(window, nativeHandle);
|
|
}
|
|
|
|
QAbstractEventDispatcher *QAndroidPlatformIntegration::createEventDispatcher() const
|
|
{
|
|
return new QAndroidEventDispatcher;
|
|
}
|
|
|
|
QAndroidPlatformIntegration::~QAndroidPlatformIntegration()
|
|
{
|
|
if (m_eglDisplay != EGL_NO_DISPLAY)
|
|
eglTerminate(m_eglDisplay);
|
|
|
|
delete m_androidPlatformNativeInterface;
|
|
delete m_androidFDB;
|
|
delete m_androidSystemLocale;
|
|
|
|
#ifndef QT_NO_CLIPBOARD
|
|
delete m_androidPlatformClipboard;
|
|
#endif
|
|
|
|
QtAndroid::setAndroidPlatformIntegration(NULL);
|
|
}
|
|
|
|
QPlatformFontDatabase *QAndroidPlatformIntegration::fontDatabase() const
|
|
{
|
|
return m_androidFDB;
|
|
}
|
|
|
|
#ifndef QT_NO_CLIPBOARD
|
|
QPlatformClipboard *QAndroidPlatformIntegration::clipboard() const
|
|
{
|
|
return m_androidPlatformClipboard;
|
|
}
|
|
#endif
|
|
|
|
QPlatformInputContext *QAndroidPlatformIntegration::inputContext() const
|
|
{
|
|
return &m_platformInputContext;
|
|
}
|
|
|
|
QPlatformNativeInterface *QAndroidPlatformIntegration::nativeInterface() const
|
|
{
|
|
return m_androidPlatformNativeInterface;
|
|
}
|
|
|
|
QPlatformServices *QAndroidPlatformIntegration::services() const
|
|
{
|
|
return m_androidPlatformServices;
|
|
}
|
|
|
|
QVariant QAndroidPlatformIntegration::styleHint(StyleHint hint) const
|
|
{
|
|
switch (hint) {
|
|
case PasswordMaskDelay:
|
|
// this number is from a hard-coded value in Android code (cf. PasswordTransformationMethod)
|
|
return m_showPasswordEnabled ? 1500 : 0;
|
|
case ShowIsMaximized:
|
|
return true;
|
|
default:
|
|
return QPlatformIntegration::styleHint(hint);
|
|
}
|
|
}
|
|
|
|
Qt::WindowState QAndroidPlatformIntegration::defaultWindowState(Qt::WindowFlags flags) const
|
|
{
|
|
// Don't maximize dialogs on Android
|
|
if (flags & Qt::Dialog & ~Qt::Window)
|
|
return Qt::WindowNoState;
|
|
|
|
return QPlatformIntegration::defaultWindowState(flags);
|
|
}
|
|
|
|
static const QLatin1String androidThemeName("android");
|
|
QStringList QAndroidPlatformIntegration::themeNames() const
|
|
{
|
|
return QStringList(QString(androidThemeName));
|
|
}
|
|
|
|
QPlatformTheme *QAndroidPlatformIntegration::createPlatformTheme(const QString &name) const
|
|
{
|
|
if (androidThemeName == name)
|
|
return new QAndroidPlatformTheme(m_androidPlatformNativeInterface);
|
|
|
|
return 0;
|
|
}
|
|
|
|
void QAndroidPlatformIntegration::setDefaultDisplayMetrics(int gw, int gh, int sw, int sh, int screenWidth, int screenHeight)
|
|
{
|
|
m_defaultGeometryWidth = gw;
|
|
m_defaultGeometryHeight = gh;
|
|
m_defaultPhysicalSizeWidth = sw;
|
|
m_defaultPhysicalSizeHeight = sh;
|
|
m_defaultScreenWidth = screenWidth;
|
|
m_defaultScreenHeight = screenHeight;
|
|
}
|
|
|
|
void QAndroidPlatformIntegration::setDefaultDesktopSize(int gw, int gh)
|
|
{
|
|
m_defaultGeometryWidth = gw;
|
|
m_defaultGeometryHeight = gh;
|
|
}
|
|
|
|
void QAndroidPlatformIntegration::setScreenOrientation(Qt::ScreenOrientation currentOrientation,
|
|
Qt::ScreenOrientation nativeOrientation)
|
|
{
|
|
m_orientation = currentOrientation;
|
|
m_nativeOrientation = nativeOrientation;
|
|
}
|
|
|
|
void QAndroidPlatformIntegration::flushPendingUpdates()
|
|
{
|
|
m_primaryScreen->setPhysicalSize(QSize(m_defaultPhysicalSizeWidth,
|
|
m_defaultPhysicalSizeHeight));
|
|
m_primaryScreen->setSize(QSize(m_defaultScreenWidth, m_defaultScreenHeight));
|
|
m_primaryScreen->setAvailableGeometry(QRect(0, 0, m_defaultGeometryWidth, m_defaultGeometryHeight));
|
|
}
|
|
|
|
#ifndef QT_NO_ACCESSIBILITY
|
|
QPlatformAccessibility *QAndroidPlatformIntegration::accessibility() const
|
|
{
|
|
return m_accessibility;
|
|
}
|
|
#endif
|
|
|
|
void QAndroidPlatformIntegration::setDesktopSize(int width, int height)
|
|
{
|
|
if (m_primaryScreen)
|
|
QMetaObject::invokeMethod(m_primaryScreen, "setAvailableGeometry", Qt::AutoConnection, Q_ARG(QRect, QRect(0,0,width, height)));
|
|
}
|
|
|
|
void QAndroidPlatformIntegration::setDisplayMetrics(int width, int height)
|
|
{
|
|
if (m_primaryScreen)
|
|
QMetaObject::invokeMethod(m_primaryScreen, "setPhysicalSize", Qt::AutoConnection, Q_ARG(QSize, QSize(width, height)));
|
|
}
|
|
|
|
void QAndroidPlatformIntegration::setScreenSize(int width, int height)
|
|
{
|
|
if (m_primaryScreen)
|
|
QMetaObject::invokeMethod(m_primaryScreen, "setSize", Qt::AutoConnection, Q_ARG(QSize, QSize(width, height)));
|
|
}
|
|
|
|
#if QT_CONFIG(vulkan)
|
|
|
|
QPlatformVulkanInstance *QAndroidPlatformIntegration::createPlatformVulkanInstance(QVulkanInstance *instance) const
|
|
{
|
|
return new QAndroidPlatformVulkanInstance(instance);
|
|
}
|
|
|
|
#endif // QT_CONFIG(vulkan)
|
|
|
|
QT_END_NAMESPACE
|