Merge lp:~gerboland/qtubuntu/active-decision-refactor into lp:qtubuntu

[Gerry Boland]

Move all App State management logic to dedicated controller, use Timer to compress active-inactive-active invocations

[Unity8 CI Bot (unity8-ci-bot)]

FAILED: Continuous integration, rev:350
https://unity8-jenkins.ubuntu.com/job/lp-qtubuntu-ci/144/
Executed test runs:

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtubuntu-ci/144/rebuild

review: Needs Fixing (continuous-integration)

[Gerry Boland (gerboland)]

To test, grab http://pastebin.ubuntu.com/23317914/

In your unity7 terminal, run:
mir_demo_server --x11-display=1000x740

and in another terminal, run:
QT_QPA_PLATFORM=ubuntumirclient qmlscene dual-window-active-test.qml

You'll get 2 windows, one red, one green. Clicking between them should not change the application active state. But starting another application and focusing its window should update the app active state.

[Nick Dedekind (nick-dedekind)]

Looks good

review: Approve

[Unity8 CI Bot (unity8-ci-bot)]

PASSED: Continuous integration, rev:
https://unity8-jenkins.ubuntu.com/job/lp-qtubuntu-ci/154/
Executed test runs:
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build/3195
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-0-fetch/3223
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=amd64,release=vivid+overlay/3079
        deb: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=amd64,release=vivid+overlay/3079/artifact/output/*zip*/output.zip
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=amd64,release=xenial+overlay/3079
        deb: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=amd64,release=xenial+overlay/3079/artifact/output/*zip*/output.zip
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=amd64,release=zesty/3079
        deb: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=amd64,release=zesty/3079/artifact/output/*zip*/output.zip
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=armhf,release=vivid+overlay/3079
        deb: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=armhf,release=vivid+overlay/3079/artifact/output/*zip*/output.zip
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=armhf,release=xenial+overlay/3079
        deb: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=armhf,release=xenial+overlay/3079/artifact/output/*zip*/output.zip
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=armhf,release=zesty/3079
        deb: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=armhf,release=zesty/3079/artifact/output/*zip*/output.zip
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=i386,release=vivid+overlay/3079
        deb: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=i386,release=vivid+overlay/3079/artifact/output/*zip*/output.zip
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=i386,release=xenial+overlay/3079
        deb: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=i386,release=xenial+overlay/3079/artifact/output/*zip*/output.zip
    SUCCESS: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=i386,release=zesty/3079
        deb: https://unity8-jenkins.ubuntu.com/job/build-2-binpkg/arch=i386,release=zesty/3079/artifact/output/*zip*/output.zip

Click here to trigger a rebuild:
https://unity8-jenkins.ubuntu.com/job/lp-qtubuntu-ci/154/rebuild

review: Approve (continuous-integration)

[lp:~gerboland/qtubuntu/active-decision-refactor]

351. By Gerry Boland on 2016-11-04

Merge trunk and resolve conflicts

=== added file 'src/ubuntumirclient/appstatecontroller.cpp'
--- src/ubuntumirclient/appstatecontroller.cpp	1970-01-01 00:00:00 +0000
+++ src/ubuntumirclient/appstatecontroller.cpp	2016-11-04 13:21:25 +0000
@@ -0,0 +1,78 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "appstatecontroller.h"
+
+#include <qpa/qwindowsysteminterface.h>
+
+/*
+ * UbuntuAppStateController - updates Qt's QApplication::applicationState property.
+ *
+ * Tries to avoid active-inactive-active invocations using a timer. The rapid state
+ * change can confuse some applications.
+ */
+
+UbuntuAppStateController::UbuntuAppStateController()
+    : m_suspended(false)
+    , m_lastActive(true)
+{
+    m_inactiveTimer.setSingleShot(true);
+    m_inactiveTimer.setInterval(10);
+    QObject::connect(&m_inactiveTimer, &QTimer::timeout, []()
+    {
+        QWindowSystemInterface::handleApplicationStateChanged(Qt::ApplicationInactive);
+    });
+}
+
+void UbuntuAppStateController::setSuspended()
+{
+    m_inactiveTimer.stop();
+    if (!m_suspended) {
+        m_suspended = true;
+
+        QWindowSystemInterface::handleApplicationStateChanged(Qt::ApplicationSuspended);
+    }
+}
+
+void UbuntuAppStateController::setResumed()
+{
+    m_inactiveTimer.stop();
+    if (m_suspended) {
+        m_suspended = false;
+
+        if (m_lastActive) {
+            QWindowSystemInterface::handleApplicationStateChanged(Qt::ApplicationActive);
+        } else {
+            QWindowSystemInterface::handleApplicationStateChanged(Qt::ApplicationInactive);
+        }
+    }
+}
+
+void UbuntuAppStateController::setWindowFocused(bool focused)
+{
+    if (m_suspended) {
+        return;
+    }
+
+    if (focused) {
+        m_inactiveTimer.stop();
+        QWindowSystemInterface::handleApplicationStateChanged(Qt::ApplicationActive);
+    } else {
+        m_inactiveTimer.start();
+    }
+
+    m_lastActive = focused;
+}

=== added file 'src/ubuntumirclient/appstatecontroller.h'
--- src/ubuntumirclient/appstatecontroller.h	1970-01-01 00:00:00 +0000
+++ src/ubuntumirclient/appstatecontroller.h	2016-11-04 13:21:25 +0000
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2016 Canonical, Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef UBUNTUAPPSTATECONTROLLER_H
+#define UBUNTUAPPSTATECONTROLLER_H
+
+#include <QTimer>
+
+class UbuntuAppStateController
+{
+public:
+    UbuntuAppStateController();
+
+    void setSuspended();
+    void setResumed();
+
+    void setWindowFocused(bool focused);
+
+private:
+    bool m_suspended;
+    bool m_lastActive;
+    QTimer m_inactiveTimer;
+};
+
+#endif // UBUNTUAPPSTATECONTROLLER_H

=== modified file 'src/ubuntumirclient/integration.cpp'
--- src/ubuntumirclient/integration.cpp	2016-10-04 16:20:07 +0000
+++ src/ubuntumirclient/integration.cpp	2016-11-04 13:21:25 +0000
@@ -47,30 +47,22 @@
 #include <ubuntu/application/id.h>
 #include <ubuntu/application/options.h>
 
-static void resumedCallback(const UApplicationOptions *options, void* context)
+static void resumedCallback(const UApplicationOptions */*options*/, void *context)
 {
-    Q_UNUSED(options)
-    Q_UNUSED(context)
-    Q_ASSERT(context != NULL);
-    if (qGuiApp->focusWindow()) {
-        QWindowSystemInterface::handleApplicationStateChanged(Qt::ApplicationActive);
-    } else {
-        QWindowSystemInterface::handleApplicationStateChanged(Qt::ApplicationInactive);
-    }
+    auto integration = static_cast<UbuntuClientIntegration*>(context);
+    integration->appStateController()->setResumed();
 }
 
-static void aboutToStopCallback(UApplicationArchive *archive, void* context)
+static void aboutToStopCallback(UApplicationArchive */*archive*/, void *context)
 {
-    Q_UNUSED(archive)
-    Q_ASSERT(context != NULL);
-    UbuntuClientIntegration* integration = static_cast<UbuntuClientIntegration*>(context);
-    QPlatformInputContext *inputContext = integration->inputContext();
+    auto integration = static_cast<UbuntuClientIntegration*>(context);
+    auto inputContext = integration->inputContext();
     if (inputContext) {
         inputContext->hideInputPanel();
     } else {
         qCWarning(ubuntumirclient) << "aboutToStopCallback(): no input context";
     }
-    QWindowSystemInterface::handleApplicationStateChanged(Qt::ApplicationSuspended);
+    integration->appStateController()->setSuspended();
 }
 
 
@@ -79,6 +71,7 @@
     , mNativeInterface(new UbuntuNativeInterface(this))
     , mFontDb(new QGenericUnixFontDatabase)
     , mServices(new UbuntuPlatformServices)
+    , mAppStateController(new UbuntuAppStateController)
     , mScaleFactor(1.0)
 {
     {
@@ -230,7 +223,8 @@
         // Desktop windows should not be backed up by a mir surface as they don't draw anything (nor should).
         return new UbuntuDesktopWindow(window);
     } else {
-        return new UbuntuWindow(window, mInput, mNativeInterface, mEglDisplay, mMirConnection, mDebugExtension.data());
+        return new UbuntuWindow(window, mInput, mNativeInterface, mAppStateController.data(),
+                                mEglDisplay, mMirConnection, mDebugExtension.data());
     }
 }
 

=== modified file 'src/ubuntumirclient/integration.h'
--- src/ubuntumirclient/integration.h	2016-09-22 19:45:30 +0000
+++ src/ubuntumirclient/integration.h	2016-11-04 13:21:25 +0000
@@ -20,6 +20,7 @@
 #include <qpa/qplatformintegration.h>
 #include <QSharedPointer>
 
+#include "appstatecontroller.h"
 #include "platformservices.h"
 #include "screenobserver.h"
 
@@ -64,6 +65,7 @@
     MirConnection *mirConnection() const { return mMirConnection; }
     EGLDisplay eglDisplay() const { return mEglDisplay; }
     EGLNativeDisplayType eglNativeDisplay() const { return mEglNativeDisplay; }
+    UbuntuAppStateController *appStateController() const { return mAppStateController.data(); }
     UbuntuScreenObserver *screenObserver() const { return mScreenObserver.data(); }
     UbuntuDebugExtension *debugExtension() const { return mDebugExtension.data(); }
 
@@ -85,6 +87,7 @@
     QPlatformInputContext* mInputContext;
     QScopedPointer<UbuntuDebugExtension> mDebugExtension;
     QScopedPointer<UbuntuScreenObserver> mScreenObserver;
+    QScopedPointer<UbuntuAppStateController> mAppStateController;
     qreal mScaleFactor;
 
     MirConnection *mMirConnection;

=== modified file 'src/ubuntumirclient/ubuntumirclient.pro'
--- src/ubuntumirclient/ubuntumirclient.pro	2016-10-04 16:20:07 +0000
+++ src/ubuntumirclient/ubuntumirclient.pro	2016-11-04 13:21:25 +0000
@@ -29,7 +29,8 @@
     screen.cpp \
     screenobserver.cpp \
     theme.cpp \
-    window.cpp
+    window.cpp \
+    appstatecontroller.cpp
 
 HEADERS = \
     backingstore.h \
@@ -48,7 +49,8 @@
     screenobserver.h \
     screen.h \
     theme.h \
-    window.h
+    window.h \
+    appstatecontroller.h
 
 # Installation path
 target.path +=  $$[QT_INSTALL_PLUGINS]/platforms

=== modified file 'src/ubuntumirclient/window.cpp'
--- src/ubuntumirclient/window.cpp	2016-10-24 11:32:31 +0000
+++ src/ubuntumirclient/window.cpp	2016-11-04 13:21:25 +0000
@@ -29,7 +29,6 @@
 #include <qpa/qwindowsysteminterface.h>
 #include <QMutexLocker>
 #include <QSize>
-#include <QAtomicInt>
 #include <QtMath>
 #include <private/qeglconvenience_p.h>
 #include <private/qguiapplication_p.h>
@@ -402,7 +401,6 @@
     QSurfaceFormat format() const { return mFormat; }
 
     bool mNeedsExposeCatchup;
-    QAtomicInt mPendingFocusGainedEvents;
 
     QString persistentSurfaceId();
 
@@ -567,14 +565,6 @@
         QMutexLocker lock(&mTargetSizeMutex);
         mTargetSize.rwidth() = width;
         mTargetSize.rheight() = height;
-    } else if (mir_event_type_surface == eventType) {
-        auto surfaceEvent = mir_event_get_surface_event(event);
-        if (mir_surface_attrib_focus == mir_surface_event_get_attribute(surfaceEvent)) {
-            const bool focused = mir_surface_event_get_attribute_value(surfaceEvent) == mir_surface_focused;
-            if (focused) {
-                mPendingFocusGainedEvents++;
-            }
-        }
     }
 
     mInput->postEvent(mPlatformWindow, event);
@@ -601,7 +591,8 @@
 }
 
 UbuntuWindow::UbuntuWindow(QWindow *w, UbuntuInput *input, UbuntuNativeInterface *native,
-                           EGLDisplay eglDisplay, MirConnection *mirConnection, UbuntuDebugExtension *debugExt)
+                           UbuntuAppStateController *appState, EGLDisplay eglDisplay,
+                           MirConnection *mirConnection, UbuntuDebugExtension *debugExt)
     : QObject(nullptr)
     , QPlatformWindow(w)
     , mId(makeId())
@@ -610,6 +601,7 @@
     , mWindowVisible(false)
     , mDebugExtention(debugExt)
     , mNativeInterface(native)
+    , mAppStateController(appState)
     , mSurface(new UbuntuSurface{this, eglDisplay, input, mirConnection})
     , mScale(1.0)
     , mFormFactor(mir_form_factor_unknown)
@@ -663,28 +655,14 @@
 
 void UbuntuWindow::handleSurfaceFocusChanged(bool focused)
 {
-    qCDebug(ubuntumirclient, "handleSurfaceFocusChanged(window=%p, focused=%d, pending=%d)", window(), focused, mSurface->mPendingFocusGainedEvents.load());
+    qCDebug(ubuntumirclient, "handleSurfaceFocusChanged(window=%p, focused=%d)", window(), focused);
 
-    // Mir may have sent a pair of focus lost/gained events, so we need to "peek" into the queue
-    // so that we don't deactivate windows prematurely.
     if (focused) {
-        mSurface->mPendingFocusGainedEvents--;
+        mAppStateController->setWindowFocused(true);
         QWindowSystemInterface::handleWindowActivated(window(), Qt::ActiveWindowFocusReason);
-
-        // NB: Since processing of system events is queued, never check qGuiApp->applicationState()
-        //     as it might be outdated. Always call handleApplicationStateChanged() with the latest
-        //     state regardless.
-        QWindowSystemInterface::handleApplicationStateChanged(Qt::ApplicationActive);
-
-        // Flush events so that we update QGuiApplicationPrivate::focus_window immediately
-        QWindowSystemInterface::flushWindowSystemEvents();
-
-    } else if (mSurface->mPendingFocusGainedEvents == 0 && window() == QGuiApplicationPrivate::focus_window) {
+    } else {
         QWindowSystemInterface::handleWindowActivated(nullptr, Qt::ActiveWindowFocusReason);
-        QWindowSystemInterface::handleApplicationStateChanged(Qt::ApplicationInactive);
-
-        // Flush events so that we update QGuiApplicationPrivate::focus_window immediately
-        QWindowSystemInterface::flushWindowSystemEvents();
+        mAppStateController->setWindowFocused(false);
     }
 }
 

=== modified file 'src/ubuntumirclient/window.h'
--- src/ubuntumirclient/window.h	2016-10-04 16:04:53 +0000
+++ src/ubuntumirclient/window.h	2016-11-04 13:21:25 +0000
@@ -27,6 +27,7 @@
 
 #include <EGL/egl.h>
 
+class UbuntuAppStateController;
 class UbuntuDebugExtension;
 class UbuntuNativeInterface;
 class UbuntuInput;
@@ -39,7 +40,8 @@
 {
     Q_OBJECT
 public:
-    UbuntuWindow(QWindow *w, UbuntuInput *input, UbuntuNativeInterface* native, EGLDisplay eglDisplay,
+    UbuntuWindow(QWindow *w, UbuntuInput *input, UbuntuNativeInterface *native,
+                 UbuntuAppStateController *appState, EGLDisplay eglDisplay,
                  MirConnection *mirConnection, UbuntuDebugExtension *debugExt);
     virtual ~UbuntuWindow();
 
@@ -83,6 +85,7 @@
     bool mWindowExposed;
     UbuntuDebugExtension *mDebugExtention;
     UbuntuNativeInterface *mNativeInterface;
+    UbuntuAppStateController *mAppStateController;
     std::unique_ptr<UbuntuSurface> mSurface;
     float mScale;
     MirFormFactor mFormFactor;