Merge lp:~mzanetti/unity-mir/screenshotting-focusing-api into lp:unity-mir

[Michael Zanetti]

Implement API changes for the screenshotting and focusing api

* Are there any related MPs required for this MP to build/function as expected? Please list.

https://code.launchpad.net/~mzanetti/unity-api/new-screenshot-and-focusing-api/+merge/199810
https://code.launchpad.net/~mzanetti/unity8/right-edge-2/+merge/204798

 * Did you perform an exploratory manual test run of your code change and any related functionality?

Yes

 * If you changed the packaging (debian), did you subscribe the ubuntu-unity team to this MP?

Yes

 * If you changed the UI, has there been a design review?

N/A

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:179
http://jenkins.qa.ubuntu.com/job/unity-mir-ci/275/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-amd64-ci/138/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/139/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-i386-ci/138/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-mir-ci/275/rebuild

review: Needs Fixing (continuous-integration)

[Gerry Boland (gerboland)]

=== removed file 'src/modules/Unity/Application/ApplicationImage.qml'
This will break SurfaceFlinger support. We good with that?

review: Needs Information

[Michael Zanetti (mzanetti)]

> === removed file 'src/modules/Unity/Application/ApplicationImage.qml'
> This will break SurfaceFlinger support. We good with that?

I asked around about that in January and answer from Kevin was yes. I'll get a confirmation that we're good to merge this now (effectively breaking SF support).

[Gerry Boland (gerboland)]

+void ApplicationManager::screenshotUpdated()
+ if (!m_nextFocusedAppId.isEmpty()) {
+ Q_EMIT focusRequested(m_nextFocusedAppId);
+ m_nextFocusedAppId.clear();
+ }
I don't follow this. Why emit a focusRequest after screenshot is updated? Is it just the best time to do it?

review: Needs Information

[Gerry Boland (gerboland)]

+ engine->addImageProvider(QLatin1String("application"), new ApplicationScreenshotProvider(appManager));

If I see a QUrl like "application://calculator-app" - is that a url for a url dispatcher? Or a url for that app's screenshot? I'm just a tad worried about duplicate purposes of urls of that form. Thought?

[lp:~mzanetti/unity-mir/screenshotting-focusing-api]

180. By Michael Zanetti on 2014-03-10

update according to latest changes in unity-api

[Michael Zanetti (mzanetti)]

> > === removed file 'src/modules/Unity/Application/ApplicationImage.qml'
> > This will break SurfaceFlinger support. We good with that?
>
> I asked around about that in January and answer from Kevin was yes. I'll get a
> confirmation that we're good to merge this now (effectively breaking SF
> support).

Confirmed. Good to go.

[Michael Zanetti (mzanetti)]

> +void ApplicationManager::screenshotUpdated()
> + if (!m_nextFocusedAppId.isEmpty()) {
> + Q_EMIT focusRequested(m_nextFocusedAppId);
> + m_nextFocusedAppId.clear();
> + }
> I don't follow this. Why emit a focusRequest after screenshot is updated? Is
> it just the best time to do it?

In order to make the QML code less complex, when someone calls requestFocusApplication() (formerly activateApplication()), I first update the screenshot, and then emit the requestFocus() signal. So the QML code has everything in place to start animating, instead of having to do the updateScreenshot() stuff from there.

[Michael Zanetti (mzanetti)]

> + engine->addImageProvider(QLatin1String("application"), new
> ApplicationScreenshotProvider(appManager));
>
> If I see a QUrl like "application://calculator-app" - is that a url for a url
> dispatcher? Or a url for that app's screenshot?

that's a url-dispatcher url :)

the imageprovider's url is

image://application/calculator-app/12345678

> I'm just a tad worried about
> duplicate purposes of urls of that form. Thought?

After clearing the confusion, does it still sound too similar to you?

[Gerry Boland (gerboland)]

> After clearing the confusion, does it still sound too similar to you?
/me idiot. You're right. Plz ignore

[Gerry Boland (gerboland)]

> > +void ApplicationManager::screenshotUpdated()
> > + if (!m_nextFocusedAppId.isEmpty()) {
> > + Q_EMIT focusRequested(m_nextFocusedAppId);
> > + m_nextFocusedAppId.clear();
> > + }
> > I don't follow this. Why emit a focusRequest after screenshot is updated? Is
> > it just the best time to do it?
>
> In order to make the QML code less complex, when someone calls
> requestFocusApplication() (formerly activateApplication()), I first update the
> screenshot, and then emit the requestFocus() signal. So the QML code has
> everything in place to start animating, instead of having to do the
> updateScreenshot() stuff from there.

Okay am understanding the why. But this method is strange to read, so it needs at least a comment justifying it. Might a second slot, connected to Application::screenshotChanged make the logic a little more obvious?

Also using "sender()" to get the signal originator always feels dangerous to me, I'm not definite if the pointer returned always exists, does it?

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:180
http://jenkins.qa.ubuntu.com/job/unity-mir-ci/286/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-amd64-ci/149/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/150/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-i386-ci/149/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-mir-ci/286/rebuild

review: Needs Fixing (continuous-integration)

[lp:~mzanetti/unity-mir/screenshotting-focusing-api]

181. By Michael Zanetti on 2014-03-10

improve comments, make sure we don't crash if the app disappears before the screenshotUpdated() signal is delivered

[Michael Zanetti (mzanetti)]

> Okay am understanding the why. But this method is strange to read, so it needs
> at least a comment justifying it. Might a second slot, connected to
> Application::screenshotChanged make the logic a little more obvious?
>
> Also using "sender()" to get the signal originator always feels dangerous to
> me, I'm not definite if the pointer returned always exists, does it?

I've added some comments describing why this happens here. You are right about the sender() thing. Thinking about it, it could happen that the Application is gone by the time this signal is delivered, given that the signal emission happens in a mir thread and hence the connection a queued one. - I've fixed it to make sure the we don't crash.

[Gerry Boland (gerboland)]

Ok, that'll do. I just need to test this with your unity8 work, before I can approve

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:181
http://jenkins.qa.ubuntu.com/job/unity-mir-ci/287/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-amd64-ci/150/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/151/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-i386-ci/150/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-mir-ci/287/rebuild

review: Needs Fixing (continuous-integration)

[lp:~mzanetti/unity-mir/screenshotting-focusing-api]

182. By Michael Zanetti on 2014-03-12

merge trunk

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:182
http://jenkins.qa.ubuntu.com/job/unity-mir-ci/291/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-amd64-ci/154/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/155/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-i386-ci/154/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-mir-ci/291/rebuild

review: Needs Fixing (continuous-integration)

[lp:~mzanetti/unity-mir/screenshotting-focusing-api]

183. By Michael Zanetti on 2014-03-12

make it compile again

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:183
http://jenkins.qa.ubuntu.com/job/unity-mir-ci/292/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-amd64-ci/155/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/156/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-i386-ci/155/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-mir-ci/292/rebuild

review: Needs Fixing (continuous-integration)

[Andreas Pokorny (andreas-pokorny)]

since I managed to break ApplicationManager easily in the past - it would be nice if you could add tests that cover suspend / resume and the changes to focusing..

[lp:~mzanetti/unity-mir/screenshotting-focusing-api]

184. By Michael Zanetti on 2014-03-13

ouch...

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:184
http://jenkins.qa.ubuntu.com/job/unity-mir-ci/293/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-amd64-ci/156/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/157/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-i386-ci/156/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-mir-ci/293/rebuild

review: Needs Fixing (continuous-integration)

[lp:~mzanetti/unity-mir/screenshotting-focusing-api]

185. By Michael Zanetti on 2014-03-14

add a test that checks if calling applicationManager.setSuspended(true) suspends the running app

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:185
http://jenkins.qa.ubuntu.com/job/unity-mir-ci/295/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-amd64-ci/158/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/159/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-i386-ci/158/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-mir-ci/295/rebuild

review: Needs Fixing (continuous-integration)

[Michael Zanetti (mzanetti)]

> since I managed to break ApplicationManager easily in the past - it would be
> nice if you could add tests that cover suspend / resume and the changes to
> focusing..

Absolutely. Test for the suspended added.

Btw. I noticed that the QtTests in there are not executed and broken/outdated. I tried to add a test for the requestFocus, but as we're using google test to test a Qt api instead of QtTest here I can't use QSignalSpy to verify it emits focusRequested.

[lp:~mzanetti/unity-mir/screenshotting-focusing-api]

186. By Michael Zanetti on 2014-03-19

merge trunk

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:186
http://jenkins.qa.ubuntu.com/job/unity-mir-ci/297/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-amd64-ci/160/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/161/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-i386-ci/160/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-mir-ci/297/rebuild

review: Needs Fixing (continuous-integration)

[Michał Sawicz (saviq)]

Bump?

[lp:~mzanetti/unity-mir/screenshotting-focusing-api]

187. By Michael Zanetti on 2014-03-25

depend on latest libunity-api-dev package

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:187
http://jenkins.qa.ubuntu.com/job/unity-mir-ci/299/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-amd64-ci/162/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/163/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-i386-ci/162/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-mir-ci/299/rebuild

review: Needs Fixing (continuous-integration)

[lp:~mzanetti/unity-mir/screenshotting-focusing-api]

188. By Michael Zanetti on 2014-03-25

added a test for focusRequested

[Michael Zanetti (mzanetti)]

turns out, QSignalSpy does work after all. No idea why I failed to get anything into it on my first attempt.

All the comments are fixed now. Good to go?

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:188
http://jenkins.qa.ubuntu.com/job/unity-mir-ci/300/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-amd64-ci/163/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-armhf-ci/164/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-mir-trusty-i386-ci/163/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-mir-ci/300/rebuild

review: Needs Fixing (continuous-integration)

[Gerry Boland (gerboland)]

LGTM

review: Approve

[Gerry Boland (gerboland)]

* Did you perform an exploratory manual test run of the code change and any related functionality?
Yes, works fine
* Did CI run pass? If not, please explain why.
MR depends on this landing first: https://code.launchpad.net/~mzanetti/unity-api/new-screenshot-and-focusing-api

[lp:~mzanetti/unity-mir/screenshotting-focusing-api]

189. By Michael Zanetti on 2014-03-28

update install dir for unity-application plugin

190. By Michael Zanetti on 2014-03-28

fix plugin installing

191. By Michael Zanetti on 2014-03-28

update install path

[Michał Sawicz (saviq)]

+1 on the plugin installation dirs.

review: Approve

[lp:~mzanetti/unity-mir/screenshotting-focusing-api]

192. By Michael Zanetti on 2014-03-31

also provide the virtual application-impl

=== modified file 'debian/control'
--- debian/control	2014-03-14 20:26:18 +0000
+++ debian/control	2014-03-31 15:12:36 +0000
@@ -12,7 +12,7 @@
                libmirserver-dev (>= 0.1.7),
                libmirclient-dev (>= 0.1.7),
                libprocess-cpp-dev,
-               libunity-api-dev,
+               libunity-api-dev (>= 7.80.6),
                libupstart-app-launch2-dev,
                qt5-default,
                qtbase5-dev,
@@ -34,6 +34,8 @@
 Replaces: unity-mir,
 Conflicts: unity-mir,
 Provides: unity-mir,
+          unity-application-impl,
+          unity-application-impl-2,
 Description: Qt plugins for Unity specific Mir APIs
  Unity-Mir provides Qt bindings for Mir features that are not exposed 
  through the QtUbuntu QPA plugins but needed for shell functionality.

=== modified file 'debian/libunity-mir1.install'
--- debian/libunity-mir1.install	2014-01-20 03:02:12 +0000
+++ debian/libunity-mir1.install	2014-03-31 15:12:36 +0000
@@ -1,2 +1,2 @@
 usr/lib/*/libunity-mir.so.*
-usr/lib/*/qt5/*
+usr/lib/*/unity8/qml/*

=== removed file 'src/modules/Unity/Application/ApplicationImage.qml'
--- src/modules/Unity/Application/ApplicationImage.qml	2014-02-21 11:22:51 +0000
+++ src/modules/Unity/Application/ApplicationImage.qml	1970-01-01 00:00:00 +0000
@@ -1,44 +0,0 @@
-/*
- * Copyright (C) 2013 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/>.
- */
-
-import QtQuick 2.0
-
-Item {
-    id: root
-    property var source: null
-    readonly property bool ready: source && (image.status == Image.Ready)
-    property alias sourceSize: image.sourceSize
-
-    function scheduleUpdate() {
-        image.source = "";
-        if (source) {
-            image.source = Qt.binding( function() {
-                return source ? "image://screenshot/" + source.appId : "";
-            });
-        }
-    }
-
-    function updateFromCache() {
-        scheduleUpdate();
-    }
-
-    Image {
-        id: image
-        anchors.fill: parent
-        source: (root.source) ? "image://screenshot/" + root.source.appId : ""
-        cache: false
-    }
-}

=== modified file 'src/modules/Unity/Application/CMakeLists.txt'
--- src/modules/Unity/Application/CMakeLists.txt	2014-03-11 01:24:36 +0000
+++ src/modules/Unity/Application/CMakeLists.txt	2014-03-31 15:12:36 +0000
@@ -83,16 +83,19 @@
   ubuntu_application_api_mirserver
 )
 
-# Ideally, we would read the plugin installation location from cmake
-# but this does not work currently.
-set(PLUGIN_INSTALL_LOCATION "${CMAKE_INSTALL_LIBDIR}/qt5/imports/Unity-Mir/Unity/Application")
 
-message(STATUS "Installing Qt5 Unity-Application plugin to: ${PLUGIN_INSTALL_LOCATION}")
+execute_process(COMMAND ${PKG_CONFIG_EXECUTABLE} --variable=plugindir_suffix unity-shell-api OUTPUT_VARIABLE SHELL_PLUGINDIR OUTPUT_STRIP_TRAILING_WHITESPACE)
+if(SHELL_PLUGINDIR STREQUAL "")
+    set(SHELL_PLUGINDIR ${CMAKE_INSTALL_LIBDIR}/unity8/qml)
+endif()
 
 install(
   TARGETS unityapplicationplugin
-  LIBRARY DESTINATION ${PLUGIN_INSTALL_LOCATION})
+  ARCHIVE DESTINATION ${SHELL_PLUGINDIR}/Unity/Application
+  LIBRARY DESTINATION ${SHELL_PLUGINDIR}/Unity/Application
+)
 
 install(
-  FILES qmldir ApplicationImage.qml OSKController.qml
-  DESTINATION ${PLUGIN_INSTALL_LOCATION})
+  FILES qmldir OSKController.qml
+  DESTINATION ${SHELL_PLUGINDIR}/Unity/Application
+)

=== modified file 'src/modules/Unity/Application/application.cpp'
--- src/modules/Unity/Application/application.cpp	2014-03-11 01:24:36 +0000
+++ src/modules/Unity/Application/application.cpp	2014-03-31 15:12:36 +0000
@@ -119,6 +119,11 @@
     return m_focused;
 }
 
+QUrl Application::screenshot() const
+{
+    return m_screenshot;
+}
+
 bool Application::fullscreen() const
 {
     return m_fullscreen;
@@ -172,6 +177,29 @@
     }
 }
 
+QImage Application::screenshotImage() const
+{
+    return m_screenshotImage;
+}
+
+void Application::updateScreenshot()
+{
+    session()->take_snapshot(
+        [&](mir::shell::Snapshot const& snapshot)
+        {
+            DLOG("ApplicationScreenshotProvider - Mir snapshot ready with size %d x %d",
+                 snapshot.size.height.as_int(), snapshot.size.width.as_int());
+
+            m_screenshotImage = QImage( (const uchar*)snapshot.pixels, // since we mirror, no need to offset starting position
+                            snapshot.size.width.as_int(),
+                            snapshot.size.height.as_int(),
+                            QImage::Format_ARGB32_Premultiplied).mirrored();
+
+            m_screenshot = QString("image://application/%1/%2").arg(m_desktopData->appId()).arg(QDateTime::currentMSecsSinceEpoch());
+            Q_EMIT screenshotChanged(m_screenshot);
+        });
+}
+
 void Application::setState(Application::State state)
 {
     DLOG("Application::setState (this=%p, state=%d)", this, static_cast<int>(state));

=== modified file 'src/modules/Unity/Application/application.h'
--- src/modules/Unity/Application/application.h	2014-03-11 01:24:36 +0000
+++ src/modules/Unity/Application/application.h	2014-03-31 15:12:36 +0000
@@ -61,12 +61,16 @@
     Stage stage() const override;
     State state() const override;
     bool focused() const override;
+    QUrl screenshot() const override;
 
     bool visible() const;
 
     void setStage(Stage stage);
     void setVisible(const bool);
 
+    QImage screenshotImage() const;
+    void updateScreenshot();
+
     bool isValid() const;
     QString desktopFile() const;
     QString exec() const;
@@ -98,6 +102,8 @@
     Stage m_stage;
     State m_state;
     bool m_focused;
+    QUrl m_screenshot;
+    QImage m_screenshotImage;
     bool m_fullscreen;
     bool m_visible; // duplicating internal Mir data :(
     std::shared_ptr<mir::shell::Session> m_session;

=== modified file 'src/modules/Unity/Application/application_manager.cpp'
--- src/modules/Unity/Application/application_manager.cpp	2014-03-17 17:44:24 +0000
+++ src/modules/Unity/Application/application_manager.cpp	2014-03-31 15:12:36 +0000
@@ -240,6 +240,8 @@
                 return QVariant::fromValue((int)application->state());
             case RoleFocused:
                 return QVariant::fromValue(application->focused());
+            case RoleScreenshot:
+                return QVariant::fromValue(application->screenshot());
             default:
                 return QVariant();
         }
@@ -250,6 +252,10 @@
 
 Application* ApplicationManager::get(int index) const
 {
+    DLOG("ApplicationManager::get (this=%p, index=%i, count=%i)", this, index, m_applications.count());
+    if (index < 0 || index >= m_applications.count()) {
+        return nullptr;
+    }
     return m_applications.at(index);
 }
 
@@ -263,6 +269,33 @@
     return nullptr;
 }
 
+bool ApplicationManager::requestFocusApplication(const QString &appId)
+{
+    DLOG("ApplicationManager::requestFocusApplication (this=%p, appId=%s)", this, qPrintable(appId));
+    Application *application = findApplication(appId);
+
+    if (!application) {
+        DLOG("No such running application '%s'", qPrintable(appId));
+        return false;
+    }
+
+    if (application == m_focusedApplication) {
+        DLOG("Application %s is already focused", qPrintable(appId));
+        return false;
+    }
+
+    // If there is a currently focused application, first update the screenshot
+    // for it and only emit focusRequested() when the screenshot is ready.
+    Application *currentlyFocusedApplication = findApplication(focusedApplicationId());
+    if (currentlyFocusedApplication) {
+        m_nextFocusedAppId = appId;
+        currentlyFocusedApplication->updateScreenshot();
+    } else {
+        Q_EMIT focusRequested(appId);
+    }
+    return true;
+}
+
 QString ApplicationManager::focusedApplicationId() const
 {
     if (m_focusedApplication) {
@@ -272,11 +305,35 @@
     }
 }
 
+bool ApplicationManager::suspended() const
+{
+    return m_suspended;
+}
+
+void ApplicationManager::setSuspended(bool suspended)
+{
+    if (suspended == m_suspended) {
+        return;
+    }
+    m_suspended = suspended;
+    Q_EMIT suspendedChanged();
+
+    if (m_suspended) {
+        suspendApplication(m_mainStageApplication);
+        suspendApplication(m_sideStageApplication);
+    } else {
+        resumeApplication(m_mainStageApplication);
+        resumeApplication(m_sideStageApplication);
+    }
+}
+
 void ApplicationManager::suspendApplication(Application *application)
 {
     if (application == nullptr)
         return;
 
+    updateScreenshot(application->appId());
+
     DLOG("ApplicationManager::suspend(this=%p, application(%p)->appId(%s) )",this, application, qPrintable(application->appId()));
     // Present in exceptions list, return.
     if (!m_lifecycleExceptions.filter(application->appId().section('_',0,0)).empty())
@@ -286,6 +343,15 @@
         application->setState(Application::Suspended);
 }
 
+void ApplicationManager::resumeApplication(Application *application)
+{
+    if (application == nullptr)
+        return;
+
+    if (application->state() != Application::Running)
+        application->setState(Application::Running);
+}
+
 bool ApplicationManager::focusApplication(const QString &appId)
 {
     Application *application = findApplication(appId);
@@ -311,8 +377,11 @@
         int from = m_applications.indexOf(application);
         move(from, m_applications.length()-1);
     } else {
-        if (application->session())
+        if (application->session()) {
             m_focusController->set_focus_to(application->session());
+            int from = m_applications.indexOf(application);
+            move(from, 0);
+        }
     }
 
     // FIXME(dandrader): lying here. The operation is async. So we will only know whether
@@ -436,6 +505,21 @@
     return result;
 }
 
+bool ApplicationManager::updateScreenshot(const QString &appId)
+{
+    Application *application = findApplication(appId);
+
+    if (!application) {
+        DLOG("No such running application '%s'", qPrintable(appId));
+        return false;
+    }
+
+    application->updateScreenshot();
+    QModelIndex appIndex = findIndex(application);
+    Q_EMIT dataChanged(appIndex, appIndex, QVector<int>() << RoleScreenshot);
+    return true;
+}
+
 void ApplicationManager::stopStartingApplication(const QString &appId)
 {
     Application *application = findApplication(appId);
@@ -512,6 +596,26 @@
     }
 }
 
+void ApplicationManager::screenshotUpdated()
+{
+    if (sender()) {
+        Application *application = static_cast<Application*>(sender());
+        QModelIndex appIndex = findIndex(application);
+        Q_EMIT dataChanged(appIndex, appIndex, QVector<int>() << RoleScreenshot);
+
+        DLOG("ApplicationManager::screenshotUpdated: Received new screenshot for %s", qPrintable(application->appId()));
+    } else {
+        DLOG("ApplicationManager::screenshotUpdated: Received screenshotUpdated signal but application has disappeard.");
+    }
+
+    // Now that the screenshot is ready, check if there
+    // is a pending app focusing request.
+    if (!m_nextFocusedAppId.isEmpty()) {
+        Q_EMIT focusRequested(m_nextFocusedAppId);
+        m_nextFocusedAppId.clear();
+    }
+}
+
 /************************************* Mir-side methods *************************************/
 
 void ApplicationManager::authorizeSession(const quint64 pid, bool &authorized)
@@ -765,6 +869,7 @@
     m_focusedApplication = application;
     m_focusedApplication->setFocused(true);
     m_focusedApplication->setState(Application::Running);
+    move(m_applications.indexOf(application), 0);
     Q_EMIT focusedApplicationIdChanged();
     m_dbusWindowStack->FocusedWindowChanged(0, application->appId(), application->stage());
 }
@@ -812,10 +917,13 @@
     DASSERT(application != nullptr);
     DLOG("ApplicationManager::add (this=%p, application='%s')", this, qPrintable(application->name()));
 
+    connect(application, &Application::screenshotChanged, this, &ApplicationManager::screenshotUpdated);
+
     beginInsertRows(QModelIndex(), m_applications.size(), m_applications.size());
     m_applications.append(application);
     endInsertRows();
     Q_EMIT countChanged();
+    Q_EMIT applicationAdded(application->appId());
 }
 
 void ApplicationManager::remove(Application *application)
@@ -833,6 +941,7 @@
         beginRemoveRows(QModelIndex(), i, i);
         m_applications.removeAt(i);
         endRemoveRows();
+        Q_EMIT applicationRemoved(application->appId());
         Q_EMIT countChanged();
     }
 }

=== modified file 'src/modules/Unity/Application/application_manager.h'
--- src/modules/Unity/Application/application_manager.h	2014-03-11 14:51:12 +0000
+++ src/modules/Unity/Application/application_manager.h	2014-03-31 15:12:36 +0000
@@ -84,12 +84,16 @@
 
     // ApplicationManagerInterface
     QString focusedApplicationId() const override;
+    bool suspended() const;
+    void setSuspended(bool suspended);
     Q_INVOKABLE unitymir::Application* get(int index) const override;
     Q_INVOKABLE unitymir::Application* findApplication(const QString &appId) const override;
+    Q_INVOKABLE bool requestFocusApplication(const QString &appId) override;
     Q_INVOKABLE bool focusApplication(const QString &appId) override;
     Q_INVOKABLE void unfocusCurrentApplication() override;
     Q_INVOKABLE unitymir::Application* startApplication(const QString &appId, const QStringList &arguments) override;
     Q_INVOKABLE bool stopApplication(const QString &appId) override;
+    Q_INVOKABLE bool updateScreenshot(const QString &appId);
 
     // QAbstractListModel
     int rowCount(const QModelIndex & parent = QModelIndex()) const override;
@@ -104,6 +108,7 @@
 
     // Internal helpers
     void suspendApplication(Application *application);
+    void resumeApplication(Application *application);
     int panelHeight();
     QSize displaySize() const { return m_displaySize; }
 
@@ -126,6 +131,9 @@
 Q_SIGNALS:
     void focusRequested(const QString &appId);
 
+private Q_SLOTS:
+    void screenshotUpdated();
+
 private:
     void setFocused(Application *application);
     void add(Application *application);
@@ -152,8 +160,10 @@
     QSharedPointer<ProcInfo> m_procInfo;
     int m_gridUnitPx;
     bool m_fenceNext;
+    QString m_nextFocusedAppId;
     QSize m_displaySize;
     int m_panelHeight;
+    bool m_suspended;
 
     friend class DBusWindowStack;
     friend class MirSurfaceManager;

=== modified file 'src/modules/Unity/Application/applicationscreenshotprovider.cpp'
--- src/modules/Unity/Application/applicationscreenshotprovider.cpp	2014-02-28 16:51:31 +0000
+++ src/modules/Unity/Application/applicationscreenshotprovider.cpp	2014-03-31 15:12:36 +0000
@@ -31,20 +31,18 @@
 ApplicationScreenshotProvider::ApplicationScreenshotProvider(ApplicationManager *appManager)
     : QQuickImageProvider(QQuickImageProvider::Image)
     , m_appManager(appManager)
-    , m_panelHeight(m_appManager->panelHeight())
-{
-}
-
-QQmlImageProviderBase::Flags ApplicationScreenshotProvider::flags() const
-{
-    // Force image fetching to always be async, prevent blocking main thread
-    return QQmlImageProviderBase::ForceAsynchronousImageLoading;
-}
-
-QImage ApplicationScreenshotProvider::requestImage(const QString &appId, QSize * size,
+{
+}
+
+QImage ApplicationScreenshotProvider::requestImage(const QString &imageId, QSize * size,
                                                      const QSize &requestedSize)
 {
-    DLOG("ApplicationScreenshotProvider::requestPixmap (this=%p, id=%s)", this, appId.toLatin1().constData());
+    // We ignore requestedSize here intentionally to avoid keeping scaled copies around
+    Q_UNUSED(requestedSize)
+
+    DLOG("ApplicationScreenshotProvider::requestImage (this=%p, id=%s)", this, imageId.toLatin1().constData());
+
+    QString appId = imageId.split('/').first();
 
     Application* app = static_cast<Application*>(m_appManager->findApplication(appId));
     if (app == NULL) {
@@ -55,44 +53,16 @@
     // TODO: if app not ready, return an app-provided splash image. If app has been stopped with saved state
     // return the screenshot that was saved to disk.
     if (!app->session() || !app->session()->default_surface()) {
-        LOG("ApplicationScreenshotProvider - app session not found - taking screenshot too early");
-        return QImage();
-    }
-
-    if (app->state() == Application::Stopped || app->state() == Application::Starting) {
-        LOG("ApplicationScreenshotProvider -  unable to take screenshot of stopped/not-ready applications");
-        return QImage();
-    }
-
-    QMutex mutex;
-    QWaitCondition wait;
-    mutex.lock();
-
-    QImage image;
-
-    app->session()->take_snapshot(
-        [&](mir::shell::Snapshot const& snapshot)
-        {
-            DLOG("ApplicationScreenshotProvider - Mir snapshot ready with size %d x %d",
-                 snapshot.size.height.as_int(), snapshot.size.width.as_int());
-
-            image = QImage( (const uchar*)snapshot.pixels, // since we mirror, no need to offset starting position
-                            snapshot.size.width.as_int(),
-                            snapshot.size.height.as_int(),
-                            QImage::Format_ARGB32_Premultiplied).mirrored();
-            wait.wakeOne();
-        });
-
-    wait.wait(&mutex, 5000);
+        LOG("ApplicationScreenshotProvider - app session not found - asking for screenshot too early");
+        return QImage();
+    }
+
+    QImage image = app->screenshotImage();
 
     DLOG("ApplicationScreenshotProvider - working with size %d x %d", image.width(), image.height());
     size->setWidth(image.width());
     size->setHeight(image.height());
 
-    if (requestedSize.isValid()) {
-        image = image.scaled(requestedSize);
-    }
-    mutex.unlock();
     return image;
 }
 

=== modified file 'src/modules/Unity/Application/applicationscreenshotprovider.h'
--- src/modules/Unity/Application/applicationscreenshotprovider.h	2014-02-28 16:51:31 +0000
+++ src/modules/Unity/Application/applicationscreenshotprovider.h	2014-03-31 15:12:36 +0000
@@ -28,12 +28,10 @@
 public:
     explicit ApplicationScreenshotProvider(ApplicationManager *appManager);
 
-    Flags flags() const override;
     QImage requestImage(const QString &appId, QSize *size, const QSize &requestedSize) override;
 
 private:
     ApplicationManager* m_appManager;
-    int m_panelHeight;
 };
 
 } // namespace unitymir

=== modified file 'src/modules/Unity/Application/plugin.cpp'
--- src/modules/Unity/Application/plugin.cpp	2014-02-28 16:51:31 +0000
+++ src/modules/Unity/Application/plugin.cpp	2014-03-31 15:12:36 +0000
@@ -81,7 +81,7 @@
 
         unitymir::ApplicationManager* appManager =
                 static_cast<unitymir::ApplicationManager*>(applicationManagerSingleton(engine, NULL));
-        engine->addImageProvider(QLatin1String("screenshot"),
+        engine->addImageProvider(QLatin1String("application"),
                                  new unitymir::ApplicationScreenshotProvider(appManager));
     }
 };

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2014-02-17 15:40:13 +0000
+++ tests/CMakeLists.txt	2014-03-31 15:12:36 +0000
@@ -21,6 +21,7 @@
   ${GMOCK_INCLUDE_DIR}
   ${GTEST_INCLUDE_DIR}
   ${MIRSERVER_INCLUDE_DIRS}
+  ${QT_TEST}
 )
 
 add_executable(
@@ -35,7 +36,7 @@
 
 # We should not need this line according to the Qt5/CMake docs.
 # However, when removing it, include paths are not set and linking to Qt5 fails.
-qt5_use_modules(application_manager_test Core Quick DBus)
+qt5_use_modules(application_manager_test Core Quick DBus Test)
 qt5_use_modules(taskcontroller_test Core Quick DBus)
 
 target_link_libraries(

=== modified file 'tests/application_manager_test.cpp'
--- tests/application_manager_test.cpp	2014-03-11 03:40:26 +0000
+++ tests/application_manager_test.cpp	2014-03-31 15:12:36 +0000
@@ -25,6 +25,7 @@
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
+#include <QSignalSpy>
 
 #include "mock_application_controller.h"
 #include "mock_desktop_file_reader.h"
@@ -327,3 +328,86 @@
     EXPECT_EQ(Application::Running, the_app->state());
     EXPECT_EQ(first_session, the_app->session());
 }
+
+TEST_F(ApplicationManagerTests,suspended_suspends_focused_app)
+{
+    using namespace ::testing;
+    quint64 a_procId = 5921;
+    const char an_app_id[] = "some_app";
+    QByteArray a_cmd( "/usr/bin/app1 --desktop_file_hint=some_app");
+    std::shared_ptr<mir::shell::Surface> aSurface(nullptr);
+
+    ON_CALL(procInfo,command_line(_)).WillByDefault(Return(a_cmd));
+
+    ON_CALL(appController,appIdHasProcessId(_,_)).WillByDefault(Return(false));
+
+    bool authed = true;
+
+    std::shared_ptr<mir::shell::Session> first_session = std::make_shared<MockSession>("Oo", a_procId);
+    std::shared_ptr<mir::shell::Session> second_session = std::make_shared<MockSession>("oO", a_procId);
+    applicationManager.authorizeSession(a_procId, authed);
+
+    applicationManager.onSessionStarting(first_session);
+    applicationManager.onSessionCreatedSurface(first_session.get(), aSurface);
+    applicationManager.onSessionStarting(second_session);
+
+    Application * the_app = applicationManager.findApplication(an_app_id);
+
+    EXPECT_EQ(Application::Running, the_app->state());
+
+    applicationManager.setSuspended(true);
+
+    EXPECT_EQ(Application::Suspended, the_app->state());
+
+    applicationManager.setSuspended(false);
+
+    EXPECT_EQ(Application::Running, the_app->state());
+
+}
+
+TEST_F(ApplicationManagerTests,requestFocusApplication)
+{
+    using namespace ::testing;
+    quint64 first_procId = 5921;
+    quint64 second_procId = 5922;
+    quint64 third_procId = 5923;
+    std::shared_ptr<mir::shell::Surface> aSurface(nullptr);
+    QByteArray first_cmdLine( "/usr/bin/app1 --desktop_file_hint=app1");
+    QByteArray second_cmdLine( "/usr/bin/app2--desktop_file_hint=app2");
+    QByteArray third_cmdLine( "/usr/bin/app3 --desktop_file_hint=app3");
+
+    EXPECT_CALL(procInfo,command_line(first_procId))
+        .Times(1)
+        .WillOnce(Return(first_cmdLine));
+
+    ON_CALL(appController,appIdHasProcessId(_,_)).WillByDefault(Return(false));
+
+    EXPECT_CALL(procInfo,command_line(second_procId))
+        .Times(1)
+        .WillOnce(Return(second_cmdLine));
+
+    EXPECT_CALL(procInfo,command_line(third_procId))
+        .Times(1)
+        .WillOnce(Return(third_cmdLine));
+
+    bool authed = true;
+
+    std::shared_ptr<mir::shell::Session> first_session = std::make_shared<MockSession>("Oo", first_procId);
+    std::shared_ptr<mir::shell::Session> second_session = std::make_shared<MockSession>("oO", second_procId);
+    std::shared_ptr<mir::shell::Session> third_session = std::make_shared<MockSession>("OO", third_procId);
+    applicationManager.authorizeSession(first_procId, authed);
+    applicationManager.authorizeSession(second_procId, authed);
+    applicationManager.authorizeSession(third_procId, authed);
+    applicationManager.onSessionStarting(first_session);
+    applicationManager.onSessionStarting(third_session);
+    applicationManager.onSessionStarting(second_session);
+
+    QSignalSpy spy(&applicationManager, SIGNAL(focusRequested(const QString &)));
+
+    applicationManager.requestFocusApplication("app3");
+
+    EXPECT_EQ(spy.count(), 1);
+
+    QList<QVariant> arguments = spy.takeFirst(); // take the first signal
+    EXPECT_EQ(arguments.at(0).toString(), "app3");
+}