1 files changed, 86 insertions, 319 deletions

diff --git a/src/plugins/platforms/android/qandroidplatformscreen.cpp b/src/plugins/platforms/android/qandroidplatformscreen.cpp
index d11b7b197b..9e20b7ac4b 100644
--- a/src/plugins/platforms/android/qandroidplatformscreen.cpp
+++ b/src/plugins/platforms/android/qandroidplatformscreen.cpp
@@ -8,7 +8,6 @@
 #include <qpa/qwindowsysteminterface.h>
 
 #include "qandroidplatformscreen.h"
-#include "qandroidplatformbackingstore.h"
 #include "qandroidplatformintegration.h"
 #include "qandroidplatformwindow.h"
 #include "androidjnimain.h"
@@ -52,11 +51,22 @@ private:
 # define PROFILE_SCOPE
 #endif
 
-QAndroidPlatformScreen::QAndroidPlatformScreen()
+Q_DECLARE_JNI_CLASS(Display, "android/view/Display")
+Q_DECLARE_JNI_CLASS(DisplayMetrics, "android/util/DisplayMetrics")
+Q_DECLARE_JNI_CLASS(Resources, "android/content/res/Resources")
+Q_DECLARE_JNI_CLASS(Size, "android/util/Size")
+Q_DECLARE_JNI_CLASS(QtNative, "org/qtproject/qt/android/QtNative")
+Q_DECLARE_JNI_CLASS(QtDisplayManager, "org/qtproject/qt/android/QtDisplayManager")
+
+Q_DECLARE_JNI_CLASS(DisplayMode, "android/view/Display$Mode")
+
+QAndroidPlatformScreen::QAndroidPlatformScreen(const QJniObject &displayObject)
     : QObject(), QPlatformScreen()
 {
     m_availableGeometry = QAndroidPlatformIntegration::m_defaultAvailableGeometry;
     m_size = QAndroidPlatformIntegration::m_defaultScreenSize;
+    m_physicalSize = QAndroidPlatformIntegration::m_defaultPhysicalSize;
+
     // Raster only apps should set QT_ANDROID_RASTER_IMAGE_DEPTH to 16
     // is way much faster than 32
     if (qEnvironmentVariableIntValue("QT_ANDROID_RASTER_IMAGE_DEPTH") == 16) {
@@ -66,69 +76,72 @@ QAndroidPlatformScreen::QAndroidPlatformScreen()
         m_format = QImage::Format_ARGB32_Premultiplied;
         m_depth = 32;
     }
-    m_physicalSize = QAndroidPlatformIntegration::m_defaultPhysicalSize;
-    connect(qGuiApp, &QGuiApplication::applicationStateChanged, this, &QAndroidPlatformScreen::applicationStateChanged);
-
-    QJniObject activity(QtAndroid::activity());
-    if (!activity.isValid())
-        return;
-    QJniObject display;
-    if (QNativeInterface::QAndroidApplication::sdkVersion() < 30) {
-        display = activity.callObjectMethod("getWindowManager", "()Landroid/view/WindowManager;")
-                          .callObjectMethod("getDefaultDisplay", "()Landroid/view/Display;");
-    } else {
-        display = activity.callObjectMethod("getDisplay", "()Landroid/view/Display;");
-    }
-    if (!display.isValid())
-        return;
 
-    m_name = display.callObjectMethod("getName", "()Ljava/lang/String;").toString();
-    m_refreshRate = display.callMethod<jfloat>("getRefreshRate");
+    connect(qGuiApp, &QGuiApplication::applicationStateChanged, this,
+            &QAndroidPlatformScreen::applicationStateChanged);
 
-    if (QNativeInterface::QAndroidApplication::sdkVersion() < 23) {
-        m_modes << Mode { .size = m_physicalSize.toSize(), .refreshRate = m_refreshRate };
+    if (!displayObject.isValid())
         return;
-    }
 
-    QJniEnvironment env;
-    const jint currentMode = display.callObjectMethod("getMode", "()Landroid/view/Display$Mode;")
-                                    .callMethod<jint>("getModeId");
-    const auto modes = display.callObjectMethod("getSupportedModes",
-                                                "()[Landroid/view/Display$Mode;");
-    const auto modesArray = jobjectArray(modes.object());
-    const auto sz = env->GetArrayLength(modesArray);
-    for (jsize i = 0; i < sz; ++i) {
-        auto mode = QJniObject::fromLocalRef(env->GetObjectArrayElement(modesArray, i));
-        if (currentMode == mode.callMethod<jint>("getModeId"))
-            m_currentMode = m_modes.size();
-        m_modes << Mode { .size = QSize { mode.callMethod<jint>("getPhysicalHeight"),
-                                          mode.callMethod<jint>("getPhysicalWidth") },
-                          .refreshRate = mode.callMethod<jfloat>("getRefreshRate") };
+    m_name = displayObject.callObjectMethod<jstring>("getName").toString();
+    m_refreshRate = displayObject.callMethod<jfloat>("getRefreshRate");
+    m_displayId = displayObject.callMethod<jint>("getDisplayId");
+
+    const QJniObject context = QNativeInterface::QAndroidApplication::context();
+    const auto displayContext = context.callMethod<QtJniTypes::Context>("createDisplayContext",
+                                                displayObject.object<QtJniTypes::Display>());
+
+    const auto sizeObj = QtJniTypes::QtDisplayManager::callStaticMethod<QtJniTypes::Size>(
+                                    "getDisplaySize", displayContext,
+                                    displayObject.object<QtJniTypes::Display>());
+    m_size = QSize(sizeObj.callMethod<int>("getWidth"), sizeObj.callMethod<int>("getHeight"));
+
+    const auto resources = displayContext.callMethod<QtJniTypes::Resources>("getResources");
+    const auto metrics = resources.callMethod<QtJniTypes::DisplayMetrics>("getDisplayMetrics");
+    const float xdpi = metrics.getField<float>("xdpi");
+    const float ydpi = metrics.getField<float>("ydpi");
+
+    // Potentially densityDpi could be used instead of xpdi/ydpi to do the calculation,
+    // but the results are not consistent with devices specs.
+    // (https://issuetracker.google.com/issues/194120500)
+    m_physicalSize.setWidth(qRound(m_size.width() / xdpi * 25.4));
+    m_physicalSize.setHeight(qRound(m_size.height() / ydpi * 25.4));
+
+    if (QNativeInterface::QAndroidApplication::sdkVersion() >= 23) {
+        const QJniObject currentMode = displayObject.callObjectMethod<QtJniTypes::DisplayMode>("getMode");
+        m_currentMode = currentMode.callMethod<jint>("getModeId");
+
+        const QJniObject supportedModes = displayObject.callObjectMethod<QtJniTypes::DisplayMode[]>(
+            "getSupportedModes");
+        const auto modeArray = jobjectArray(supportedModes.object());
+
+        QJniEnvironment env;
+        const auto size = env->GetArrayLength(modeArray);
+        for (jsize i = 0; i < size; ++i) {
+            const auto mode = QJniObject::fromLocalRef(env->GetObjectArrayElement(modeArray, i));
+            m_modes << QPlatformScreen::Mode {
+                .size = QSize { mode.callMethod<jint>("getPhysicalWidth"),
+                                mode.callMethod<jint>("getPhysicalHeight") },
+                .refreshRate = mode.callMethod<jfloat>("getRefreshRate")
+            };
+        }
     }
-
-    if (m_modes.isEmpty())
-        m_modes << Mode { .size = m_physicalSize.toSize(), .refreshRate = m_refreshRate };
 }
 
 QAndroidPlatformScreen::~QAndroidPlatformScreen()
 {
-    if (m_id != -1) {
-        QtAndroid::destroySurface(m_id);
-        m_surfaceWaitCondition.wakeOne();
-        releaseSurface();
-    }
 }
 
-QWindow *QAndroidPlatformScreen::topWindow() const
+QWindow *QAndroidPlatformScreen::topVisibleWindow() const
 {
     for (QAndroidPlatformWindow *w : m_windowStack) {
-        if (w->window()->type() == Qt::Window ||
-                w->window()->type() == Qt::Popup ||
-                w->window()->type() == Qt::Dialog) {
+        Qt::WindowType type = w->window()->type();
+        if (w->window()->isVisible() &&
+                (type == Qt::Window || type == Qt::Popup || type == Qt::Dialog)) {
             return w->window();
         }
     }
-    return 0;
+    return nullptr;
 }
 
 QWindow *QAndroidPlatformScreen::topLevelAt(const QPoint &p) const
@@ -140,16 +153,6 @@ QWindow *QAndroidPlatformScreen::topLevelAt(const QPoint &p) const
     return 0;
 }
 
-bool QAndroidPlatformScreen::event(QEvent *event)
-{
-    if (event->type() == QEvent::UpdateRequest) {
-        doRedraw();
-        m_updatePending = false;
-        return true;
-    }
-    return QObject::event(event);
-}
-
 void QAndroidPlatformScreen::addWindow(QAndroidPlatformWindow *window)
 {
     if (window->parent() && window->isRaster())
@@ -159,83 +162,45 @@ void QAndroidPlatformScreen::addWindow(QAndroidPlatformWindow *window)
         return;
 
     m_windowStack.prepend(window);
-    if (window->isRaster()) {
-        m_rasterSurfaces.ref();
-        setDirty(window->geometry());
-    }
+    QtAndroid::qtActivityDelegate().callMethod<void>("addTopLevelWindow", window->nativeWindow());
 
-    QWindow *w = topWindow();
-    QWindowSystemInterface::handleWindowActivated(w, Qt::ActiveWindowFocusReason);
-    topWindowChanged(w);
+    if (window->window()->isVisible())
+        topVisibleWindowChanged();
 }
 
 void QAndroidPlatformScreen::removeWindow(QAndroidPlatformWindow *window)
 {
-    if (window->parent() && window->isRaster())
-        return;
-
     m_windowStack.removeOne(window);
 
     if (m_windowStack.contains(window))
         qWarning() << "Failed to remove window";
 
-    if (window->isRaster()) {
-        m_rasterSurfaces.deref();
-        setDirty(window->geometry());
-    }
+    QtAndroid::qtActivityDelegate().callMethod<void>("removeTopLevelWindow", window->nativeViewId());
 
-    QWindow *w = topWindow();
-    QWindowSystemInterface::handleWindowActivated(w, Qt::ActiveWindowFocusReason);
-    topWindowChanged(w);
+    topVisibleWindowChanged();
 }
 
 void QAndroidPlatformScreen::raise(QAndroidPlatformWindow *window)
 {
-    if (window->parent() && window->isRaster())
-        return;
-
     int index = m_windowStack.indexOf(window);
-    if (index <= 0)
+    if (index < 0)
         return;
-    m_windowStack.move(index, 0);
-    if (window->isRaster()) {
-        setDirty(window->geometry());
+    if (index > 0) {
+        m_windowStack.move(index, 0);
+        QtAndroid::qtActivityDelegate().callMethod<void>("bringChildToFront", window->nativeViewId());
     }
-    QWindow *w = topWindow();
-    QWindowSystemInterface::handleWindowActivated(w, Qt::ActiveWindowFocusReason);
-    topWindowChanged(w);
+    topVisibleWindowChanged();
 }
 
 void QAndroidPlatformScreen::lower(QAndroidPlatformWindow *window)
 {
-    if (window->parent() && window->isRaster())
-        return;
-
     int index = m_windowStack.indexOf(window);
     if (index == -1 || index == (m_windowStack.size() - 1))
         return;
     m_windowStack.move(index, m_windowStack.size() - 1);
-    if (window->isRaster()) {
-        setDirty(window->geometry());
-    }
-    QWindow *w = topWindow();
-    QWindowSystemInterface::handleWindowActivated(w, Qt::ActiveWindowFocusReason);
-    topWindowChanged(w);
-}
+    QtAndroid::qtActivityDelegate().callMethod<void>("bringChildToBack", window->nativeViewId());
 
-void QAndroidPlatformScreen::scheduleUpdate()
-{
-    if (!m_updatePending) {
-        m_updatePending = true;
-        QCoreApplication::postEvent(this, new QEvent(QEvent::UpdateRequest));
-    }
-}
-
-void QAndroidPlatformScreen::setDirty(const QRect &rect)
-{
-    QRect intersection = rect.intersected(m_availableGeometry);
-    m_dirtyRect |= intersection;
-    scheduleUpdate();
+    topVisibleWindowChanged();
 }
 
 void QAndroidPlatformScreen::setPhysicalSize(const QSize &size)
@@ -267,6 +232,11 @@ void QAndroidPlatformScreen::setSizeParameters(const QSize &physicalSize, const
     }
 }
 
+int QAndroidPlatformScreen::displayId() const
+{
+    return m_displayId;
+}
+
 void QAndroidPlatformScreen::setRefreshRate(qreal refreshRate)
 {
     if (refreshRate == m_refreshRate)
@@ -282,7 +252,6 @@ void QAndroidPlatformScreen::setOrientation(Qt::ScreenOrientation orientation)
 
 void QAndroidPlatformScreen::setAvailableGeometry(const QRect &rect)
 {
-    QMutexLocker lock(&m_surfaceMutex);
     if (m_availableGeometry == rect)
         return;
 
@@ -303,170 +272,31 @@ void QAndroidPlatformScreen::setAvailableGeometry(const QRect &rect)
             }
         }
     }
-
-    if (m_id != -1) {
-        releaseSurface();
-        QtAndroid::setSurfaceGeometry(m_id, rect);
-    }
 }
 
 void QAndroidPlatformScreen::applicationStateChanged(Qt::ApplicationState state)
 {
-    for (QAndroidPlatformWindow *w : qAsConst(m_windowStack))
+    for (QAndroidPlatformWindow *w : std::as_const(m_windowStack))
         w->applicationStateChanged(state);
-
-    if (state <=  Qt::ApplicationHidden) {
-        lockSurface();
-        QtAndroid::destroySurface(m_id);
-        m_id = -1;
-        releaseSurface();
-        unlockSurface();
-    }
 }
 
-void QAndroidPlatformScreen::topWindowChanged(QWindow *w)
+void QAndroidPlatformScreen::topVisibleWindowChanged()
 {
+    QWindow *w = topVisibleWindow();
+    QWindowSystemInterface::handleFocusWindowChanged(w, Qt::ActiveWindowFocusReason);
     QtAndroidMenu::setActiveTopLevelWindow(w);
-
-    if (w != 0) {
+    if (w && w->handle()) {
         QAndroidPlatformWindow *platformWindow = static_cast<QAndroidPlatformWindow *>(w->handle());
-        if (platformWindow != 0)
+        if (platformWindow)
             platformWindow->updateSystemUiVisibility();
     }
 }
 
-int QAndroidPlatformScreen::rasterSurfaces()
-{
-    return m_rasterSurfaces;
-}
-
-void QAndroidPlatformScreen::doRedraw(QImage* screenGrabImage)
-{
-    PROFILE_SCOPE;
-    if (!QtAndroid::activity())
-        return;
-
-    if (m_dirtyRect.isEmpty())
-        return;
-
-    // Stop if there are no visible raster windows. If we only have RasterGLSurface
-    // windows that have renderToTexture children (i.e. they need the OpenGL path) then
-    // we do not need an overlay surface.
-    bool hasVisibleRasterWindows = false;
-    for (QAndroidPlatformWindow *window : qAsConst(m_windowStack)) {
-        if (window->window()->isVisible() && window->isRaster() && !qt_window_private(window->window())->compositing) {
-            hasVisibleRasterWindows = true;
-            break;
-        }
-    }
-    if (!hasVisibleRasterWindows) {
-        lockSurface();
-        if (m_id != -1) {
-            QtAndroid::destroySurface(m_id);
-            releaseSurface();
-            m_id = -1;
-        }
-        unlockSurface();
-        return;
-    }
-    QMutexLocker lock(&m_surfaceMutex);
-    if (m_id == -1 && m_rasterSurfaces) {
-        m_id = QtAndroid::createSurface(this, geometry(), true, m_depth);
-        AndroidDeadlockProtector protector;
-        if (!protector.acquire())
-            return;
-        m_surfaceWaitCondition.wait(&m_surfaceMutex);
-    }
-
-    if (!m_nativeSurface)
-        return;
-
-    ANativeWindow_Buffer nativeWindowBuffer;
-    ARect nativeWindowRect;
-    nativeWindowRect.top = m_dirtyRect.top();
-    nativeWindowRect.left = m_dirtyRect.left();
-    nativeWindowRect.bottom = m_dirtyRect.bottom() + 1; // for some reason that I don't understand the QRect bottom needs to +1 to be the same with ARect bottom
-    nativeWindowRect.right = m_dirtyRect.right() + 1; // same for the right
-
-    int ret;
-    if ((ret = ANativeWindow_lock(m_nativeSurface, &nativeWindowBuffer, &nativeWindowRect)) < 0) {
-        qWarning() << "ANativeWindow_lock() failed! error=" << ret;
-        return;
-    }
-
-    int bpp = 4;
-    if (nativeWindowBuffer.format == WINDOW_FORMAT_RGB_565) {
-        bpp = 2;
-        m_pixelFormat = QImage::Format_RGB16;
-    }
-
-    QImage screenImage(reinterpret_cast<uchar *>(nativeWindowBuffer.bits)
-                       , nativeWindowBuffer.width, nativeWindowBuffer.height
-                       , nativeWindowBuffer.stride * bpp , m_pixelFormat);
-
-    QPainter compositePainter(&screenImage);
-    compositePainter.setCompositionMode(QPainter::CompositionMode_Source);
-
-    QRegion visibleRegion(m_dirtyRect);
-    for (QAndroidPlatformWindow *window : qAsConst(m_windowStack)) {
-        if (!window->window()->isVisible()
-                || qt_window_private(window->window())->compositing
-                || !window->isRaster())
-            continue;
-
-        for (const QRect &rect : std::vector<QRect>(visibleRegion.begin(), visibleRegion.end())) {
-            QRect targetRect = window->geometry();
-            targetRect &= rect;
-
-            if (targetRect.isNull())
-                continue;
-
-            visibleRegion -= targetRect;
-            QRect windowRect = targetRect.translated(-window->geometry().topLeft());
-            QAndroidPlatformBackingStore *backingStore = static_cast<QAndroidPlatformWindow *>(window)->backingStore();
-            if (backingStore)
-                compositePainter.drawImage(targetRect.topLeft(), backingStore->toImage(), windowRect);
-        }
-    }
-
-    for (const QRect &rect : visibleRegion)
-        compositePainter.fillRect(rect, QColor(Qt::transparent));
-
-    ret = ANativeWindow_unlockAndPost(m_nativeSurface);
-    if (ret >= 0)
-        m_dirtyRect = QRect();
-
-    if (screenGrabImage) {
-        if (screenGrabImage->size() != screenImage.size()) {
-            uchar* bytes = static_cast<uchar*>(malloc(screenImage.height() * screenImage.bytesPerLine()));
-            *screenGrabImage = QImage(bytes, screenImage.width(), screenImage.height(),
-                                      screenImage.bytesPerLine(), m_pixelFormat,
-                                      [](void* ptr){ if (ptr) free (ptr);});
-        }
-        memcpy(screenGrabImage->bits(),
-               screenImage.bits(),
-               screenImage.bytesPerLine() * screenImage.height());
-    }
-    m_repaintOccurred = true;
-}
-
-QPixmap QAndroidPlatformScreen::doScreenShot(QRect grabRect)
-{
-    if (!m_repaintOccurred)
-       return QPixmap::fromImage(m_lastScreenshot.copy(grabRect));
-    QRect tmp = m_dirtyRect;
-    m_dirtyRect = geometry();
-    doRedraw(&m_lastScreenshot);
-    m_dirtyRect = tmp;
-    m_repaintOccurred = false;
-    return QPixmap::fromImage(m_lastScreenshot.copy(grabRect));
-}
-
 static const int androidLogicalDpi = 72;
 
 QDpi QAndroidPlatformScreen::logicalDpi() const
 {
-    qreal lDpi = QtAndroid::scaledDensity() * androidLogicalDpi;
+    qreal lDpi = QtAndroid::pixelDensity() * androidLogicalDpi;
     return QDpi(lDpi, lDpi);
 }
 
@@ -484,67 +314,4 @@ Qt::ScreenOrientation QAndroidPlatformScreen::nativeOrientation() const
 {
     return QAndroidPlatformIntegration::m_nativeOrientation;
 }
-
-void QAndroidPlatformScreen::surfaceChanged(JNIEnv *env, jobject surface, int w, int h)
-{
-    lockSurface();
-    if (surface && w > 0  && h > 0) {
-        releaseSurface();
-        m_nativeSurface = ANativeWindow_fromSurface(env, surface);
-        QMetaObject::invokeMethod(this, "setDirty", Qt::QueuedConnection, Q_ARG(QRect, QRect(0, 0, w, h)));
-    } else {
-        releaseSurface();
-    }
-    unlockSurface();
-    m_surfaceWaitCondition.wakeOne();
-}
-
-void QAndroidPlatformScreen::releaseSurface()
-{
-    if (m_nativeSurface) {
-        ANativeWindow_release(m_nativeSurface);
-        m_nativeSurface = 0;
-    }
-}
-
-/*!
-    This function is called when Qt needs to be able to grab the content of a window.
-
-    Returns the content of the window specified with the WId handle within the boundaries of
-    QRect(x, y, width, height).
-*/
-QPixmap QAndroidPlatformScreen::grabWindow(WId window, int x, int y, int width, int height) const
-{
-    QRectF screenshotRect(x, y, width,  height);
-    QWindow* wnd = 0;
-    if (window)
-    {
-        const auto windowList = qApp->allWindows();
-        for (QWindow *w : windowList)
-            if (w->winId() == window) {
-                wnd = w;
-                break;
-            }
-    }
-    if (wnd) {
-        const qreal factor = logicalDpi().first / androidLogicalDpi; //HighDPI factor;
-        QRectF wndRect = wnd->geometry();
-        if (wnd->parent())
-            wndRect.moveTopLeft(wnd->parent()->mapToGlobal(wndRect.topLeft().toPoint()));
-        if (!qFuzzyCompare(factor, 1))
-            wndRect = QRectF(wndRect.left() * factor, wndRect.top() * factor,
-                            wndRect.width() * factor, wndRect.height() * factor);
-
-        if (!screenshotRect.isEmpty()) {
-            screenshotRect.moveTopLeft(wndRect.topLeft() + screenshotRect.topLeft());
-            screenshotRect = screenshotRect.intersected(wndRect);
-        } else {
-            screenshotRect = wndRect;
-        }
-    } else {
-        screenshotRect = screenshotRect.isValid() ? screenshotRect : geometry();
-    }
-    return const_cast<QAndroidPlatformScreen *>(this)->doScreenShot(screenshotRect.toRect());
-}
-
 QT_END_NAMESPACE