Merge lp:~cemil-azizoglu/mir/nested_lifecycle_events into lp:mir

[Cemil Azizoglu]

Listen to lifecycle events in nested server.

Nested server registers a callback for lifecycle events coming from the host. This is necessary for the nested server to receive lifecycle events so that its clients, in turn, can be notified.

To showcase, I have also added the ability to send lifecycle events to the focussed app upon hitting ctl-alt-L, to the example shell.

[Cemil Azizoglu (cemil-azizoglu)]

Since the nested tests don't work, I modified the demo_shell to test this MP.

https://code.launchpad.net/~cemil-azizoglu/mir/nested_lifecycle_events_test/+merge/224434

The test code needs some private headers exposed in the demo shell, and is not meant to be merged (thus, is marked as "disapprove").

[Alan Griffiths (alan-griffiths)]

21 + ${PROJECT_SOURCE_DIR}/include/server/mir/scene

Not needed: use the canonical include path "mir/scene/<whatever>"

22 + ${PROJECT_SOURCE_DIR}/src/server/scene

Not allowed (hence disapprove)

review: Disapprove

[Alan Griffiths (alan-griffiths)]

After our discussions on IRC I thought the intent was to provide a "hook" so that shells implemented using Mir could "hook" into these events and process them. As such I think that HostLifecycleEventListener should be in shell and not in scene.

~~~~

86 + mirnestedscene
...
193 +add_subdirectory(nested/)
...
203 +#include "nested/default_host_lifecycle_event_listener.h"

etc.

This new "scene/nested" library is not justified. All it contains is a default (null) implementation of an interface: scene::HostLifecycleEventListener. I see no reason not to put this in scene directly (or, in view of the above remarks: shell). (That's where you've put mir::DefaultServerConfiguration::the_host_lifecycle_event_listener() anyway).

~~~~

144 + std::static_pointer_cast<void>(host_lifecycle_event_listener).get());

No obvious need for the cast.

~~~~~

+void DefaultHostLifecycleEventListener::lifecycle_event_occured(MirLifecycleState state)
283 +{
284 + app_container->for_each(
285 + [&state](std::shared_ptr<Session> const& session)
286 + {
287 + session->set_lifecycle_state(state);
288 + });
289 +}

I think the default behavior should be to do nothing and let the implementing shell use this as a hook.

review: Needs Fixing

[Alan Griffiths (alan-griffiths)]

Getting closer. ;)

24 + /* Duplicate impl. Could move to a common library so Mir proper, and examples can share. */
25 + class NullHostLifecycleEventListener : public msh::HostLifecycleEventListener
26 + {
27 + public:
28 + virtual void lifecycle_event_occured(MirLifecycleState /*state*/) override
29 + {
30 + printf("This line must not be output\n");
31 + }
32 + };

Not needed as

57 + return host_lifecycle_event_listener(
58 + []()
59 + {
60 + return std::make_shared<NullHostLifecycleEventListener>();
61 + });
62 + }

Can be simply

  return mir::examples::ServerConfiguration::the_host_lifecycle_event_listener();

Although...

45 + auto nested = the_options()->is_set(options::host_socket_opt);
46 +
47 + if (nested)

Do we actually need two paths here? The function will only be called when a HostLifecycleEventListener is needed - i.e. in Nested mode. (And if it is called in other circumstances it is probably better to provide NestedLifecycleEventListener anyway.)

~~~~

362 + EXPECT_CALL(*this, lifecycle_event_occured(lifecycle_state)).Times(1);

Expectations should be set in the test body - as that should explain what is being checked. (And it would also be nice to see several notifications checked by InSequence.)

review: Needs Fixing

[Alan Griffiths (alan-griffiths)]

%s/occured/occurred/g

~~~~

347 + void TriggerLifecycleEvent(MirLifecycleState const lifecycle_state)

http://unity.ubuntu.com/mir/cppguide/index.html?showone=Function_Names#Function_Names

~~~~

387 + TriggerLifecycleEvent(mir_lifecycle_state_resumed);
388 + TriggerLifecycleEvent(mir_lifecycle_state_will_suspend);
389 +
390 + InSequence seq;
...

I'm surprised that sending the events before setting the expectations isn't racy.

~~~~

391 + EXPECT_CALL(*(static_cast<MockHostLifecycleEventListener*>(nested_config.the_host_lifecycle_event_listener().get())), lifecycle_event_occured(mir_lifecycle_state_resumed)).Times(1);
392 + EXPECT_CALL(*(static_cast<MockHostLifecycleEventListener*>(nested_config.the_host_lifecycle_event_listener().get())), lifecycle_event_occured(mir_lifecycle_state_will_suspend)).Times(1);

Excessively long lines.

I'd prefer to expose the MockHostLifecycleEventListener directly on MyServerConfiguration and use that to avoid the casts.

Something like:

TEST_F(NestedServer, receives_lifecycle_events_from_host)
{
    struct MyServerConfiguration : NestedServerConfiguration, MockHostLifecycleEventListener
    {
        using NestedServerConfiguration::NestedServerConfiguration;

        std::shared_ptr<msh::HostLifecycleEventListener> the_host_lifecycle_event_listener() override
        {
            return host_lifecycle_event_listener(
                [this]
                {
                    return mt::fake_shared<msh::HostLifecycleEventListener>(*this);
                });
        }
    };

    MyServerConfiguration nested_config{connection_string, the_graphics_platform()};

    NestedMirRunner nested_mir{nested_config};

    InSequence seq;
    EXPECT_CALL(nested_config, lifecycle_event_occured(mir_lifecycle_state_resumed)).Times(1);
    EXPECT_CALL(nested_config, lifecycle_event_occured(mir_lifecycle_state_will_suspend)).Times(1);

    trigger_lifecycle_event(mir_lifecycle_state_resumed);
    trigger_lifecycle_event(mir_lifecycle_state_will_suspend);
}

(Although that inheritance-for-convenience might earn a "Needs Fixing")

[Alan Griffiths (alan-griffiths)]

> 387 + TriggerLifecycleEvent(mir_lifecycle_state_resumed);
> 388 + TriggerLifecycleEvent(mir_lifecycle_state_will_suspend);
> 389 +
> 390 + InSequence seq;
> ...
>
> I'm surprised that sending the events before setting the expectations isn't
> racy.

Actually it is.

Sticking in...

    std::this_thread::sleep_for(std::chrono::seconds(1));

...shouldn't hurt but it does.

review: Needs Fixing

[Alan Griffiths (alan-griffiths)]

LGTM - although the example code sending the same event every time is a bit boring.

BTW does Jenkins not recognize you? It should be reviewing this.

review: Approve

[Andreas Pokorny (andreas-pokorny)]

toggling through life cycle would be cool.

All fine but a there is a C-Cast in 169, that should be a static_cast.

review: Needs Fixing

[Alexandros Frantzis (afrantzis)]

Looks good overall.

A couple of nits:

169 + msh::HostLifecycleEventListener *listener = (msh::HostLifecycleEventListener *) context;

The c-cast like mentioned by Andreas, and also '*' should go with the type (msh::HostLifecycleEventListener* listener = ...)

58 + if(app)

Space between if and '('.

review: Needs Fixing

[Cemil Azizoglu (cemil-azizoglu)]

Iterating through an enum is a bit painful and would make the code messy. So I'll leave the example boring, but hopefully to the point. (Other comments addressed.)

[Andreas Pokorny (andreas-pokorny)]

review: Approve

[Alexandros Frantzis (afrantzis)]

OK.

review: Approve

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:1790
http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-ci/2160/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-utopic-i386-build/952
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-utopic-amd64-build/958
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-utopic-touch/950
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-amd64-ci/681
        deb: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-amd64-ci/681/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-armhf-ci/679
        deb: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-armhf-ci/679/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/3162
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/3162/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/2084
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/9892

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/2160/rebuild

review: Approve (continuous-integration)

[Alan Griffiths (alan-griffiths)]

8 + . DefaultServerConfiguration: Lifecycle event listener for nested server.

Don't make changes to the cahngelog in "routine" MPs

These will all show at the same point and lead to spurious merge conflicts.

review: Needs Fixing

[Cemil Azizoglu (cemil-azizoglu)]

> 8 + . DefaultServerConfiguration: Lifecycle event listener for nested
> server.
>
> Don't make changes to the cahngelog in "routine" MPs
>
> These will all show at the same point and lead to spurious merge conflicts.

Fixed.

[PS Jenkins bot (ps-jenkins)]

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:1792
http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-ci/2169/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-utopic-i386-build/964
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-utopic-amd64-build/970
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-utopic-touch/959
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-amd64-ci/690
        deb: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-amd64-ci/690/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-armhf-ci/688
        deb: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-armhf-ci/688/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/3230
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/3230/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/2091
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/9945

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/2169/rebuild

review: Approve (continuous-integration)

=== modified file 'examples/demo-shell/demo_shell.cpp'
--- examples/demo-shell/demo_shell.cpp	2014-06-04 22:09:06 +0000
+++ examples/demo-shell/demo_shell.cpp	2014-07-16 15:59:57 +0000
@@ -29,6 +29,7 @@
 #include "mir/graphics/display.h"
 #include "mir/input/composite_event_filter.h"
 #include "mir/compositor/renderer_factory.h"
+#include "mir/shell/host_lifecycle_event_listener.h"
 
 #include <iostream>
 
@@ -38,6 +39,7 @@
 namespace mf = mir::frontend;
 namespace mi = mir::input;
 namespace mo = mir::options;
+namespace msh = mir::shell;
 
 namespace mir
 {
@@ -108,6 +110,24 @@
         return std::make_shared<DemoRendererFactory>(the_gl_program_factory());
     }
 
+    class NestedLifecycleEventListener : public msh::HostLifecycleEventListener
+    {
+    public:
+        virtual void lifecycle_event_occurred(MirLifecycleState state) override
+        {
+            printf("Lifecycle event occurred : state = %d\n", state);
+        }
+    };
+
+    std::shared_ptr<msh::HostLifecycleEventListener> the_host_lifecycle_event_listener() override
+    {
+       return host_lifecycle_event_listener(
+           []()
+           {
+               return std::make_shared<NestedLifecycleEventListener>();
+           });
+    }
+
 private:
     std::vector<std::shared_ptr<mi::EventFilter>> const filter_list;
 };

=== modified file 'examples/demo-shell/window_manager.cpp'
--- examples/demo-shell/window_manager.cpp	2014-06-10 14:40:23 +0000
+++ examples/demo-shell/window_manager.cpp	2014-07-16 15:59:57 +0000
@@ -163,6 +163,17 @@
             return true;
         }
         else if ((event.key.modifiers & mir_key_modifier_alt) &&
+                 (event.key.modifiers & mir_key_modifier_ctrl) &&
+                 (event.key.scan_code == KEY_L) &&
+                 focus_controller)
+        {
+            auto const app = focus_controller->focussed_application().lock();
+            if (app)
+            {
+                app->set_lifecycle_state(mir_lifecycle_state_will_suspend);
+            }
+        }
+        else if ((event.key.modifiers & mir_key_modifier_alt) &&
                  (event.key.modifiers & mir_key_modifier_ctrl))
         {
             MirOrientation orientation = mir_orientation_normal;

=== modified file 'include/server/mir/default_server_configuration.h'
--- include/server/mir/default_server_configuration.h	2014-07-09 10:48:47 +0000
+++ include/server/mir/default_server_configuration.h	2014-07-16 15:59:57 +0000
@@ -69,6 +69,7 @@
 class FocusSetter;
 class FocusController;
 class DisplayLayout;
+class HostLifecycleEventListener;
 }
 namespace time
 {
@@ -243,6 +244,8 @@
     virtual std::shared_ptr<shell::DisplayLayout>       the_shell_display_layout();
     virtual std::shared_ptr<scene::PromptSessionListener> the_prompt_session_listener();
     virtual std::shared_ptr<scene::PromptSessionManager>  the_prompt_session_manager();
+    virtual std::shared_ptr<shell::HostLifecycleEventListener> the_host_lifecycle_event_listener();
+
     /** @} */
 
     /** @name internal scene configuration
@@ -394,6 +397,7 @@
     CachedPtr<scene::PromptSessionManager> prompt_session_manager;
     CachedPtr<scene::SessionCoordinator> session_coordinator;
     CachedPtr<EmergencyCleanup> emergency_cleanup;
+    CachedPtr<shell::HostLifecycleEventListener> host_lifecycle_event_listener;
 
 private:
     std::shared_ptr<options::Configuration> const configuration_options;

=== added file 'include/server/mir/shell/host_lifecycle_event_listener.h'
--- include/server/mir/shell/host_lifecycle_event_listener.h	1970-01-01 00:00:00 +0000
+++ include/server/mir/shell/host_lifecycle_event_listener.h	2014-07-16 15:59:57 +0000
@@ -0,0 +1,44 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU 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 warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Cemil Azizoglu <[e-mail]>
+ */
+
+#ifndef MIR_HOST_LIFECYCLE_EVENT_LISTENER_H_
+#define MIR_HOST_LIFECYCLE_EVENT_LISTENER_H_
+
+#include "mir_toolkit/common.h"
+
+namespace mir
+{
+namespace shell
+{
+
+class HostLifecycleEventListener
+{
+public:
+    virtual void lifecycle_event_occurred(MirLifecycleState state) = 0;
+
+protected:
+    HostLifecycleEventListener() = default;
+    virtual ~HostLifecycleEventListener() = default;
+    HostLifecycleEventListener(HostLifecycleEventListener const&) = delete;
+    HostLifecycleEventListener& operator=(HostLifecycleEventListener const&) = delete;
+};
+
+}
+}
+
+#endif /* MIR_HOST_LIFECYCLE_EVENT_LISTENER_H_ */

=== modified file 'src/server/graphics/default_configuration.cpp'
--- src/server/graphics/default_configuration.cpp	2014-07-09 10:48:47 +0000
+++ src/server/graphics/default_configuration.cpp	2014-07-16 15:59:57 +0000
@@ -185,7 +185,8 @@
 
             return std::make_shared<graphics::nested::MirClientHostConnection>(
                 host_socket,
-                my_name);
+                my_name,
+                the_host_lifecycle_event_listener());
         });
 }
 

=== modified file 'src/server/graphics/nested/mir_client_host_connection.cpp'
--- src/server/graphics/nested/mir_client_host_connection.cpp	2014-04-17 11:04:41 +0000
+++ src/server/graphics/nested/mir_client_host_connection.cpp	2014-07-16 15:59:57 +0000
@@ -40,6 +40,12 @@
     (*static_cast<std::function<void()>*>(context))();
 }
 
+static void nested_lifecycle_event_callback_thunk(MirConnection* /*connection*/, MirLifecycleState state, void *context)
+{
+    msh::HostLifecycleEventListener* listener = static_cast<msh::HostLifecycleEventListener*>(context);
+    listener->lifecycle_event_occurred(state);
+}
+
 class MirClientHostSurface : public mgn::HostSurface
 {
 public:
@@ -80,9 +86,12 @@
 }
 
 mgn::MirClientHostConnection::MirClientHostConnection(
-    std::string const& host_socket, std::string const& name)
+    std::string const& host_socket,
+    std::string const& name,
+    std::shared_ptr<msh::HostLifecycleEventListener> const& host_lifecycle_event_listener)
     : mir_connection{mir_connect_sync(host_socket.c_str(), name.c_str())},
-      conf_change_callback{[]{}}
+      conf_change_callback{[]{}},
+      host_lifecycle_event_listener{host_lifecycle_event_listener}
 {
     if (!mir_connection_is_valid(mir_connection))
     {
@@ -92,6 +101,11 @@
 
         BOOST_THROW_EXCEPTION(std::runtime_error(msg));
     }
+
+    mir_connection_set_lifecycle_event_callback(
+        mir_connection,
+        nested_lifecycle_event_callback_thunk,
+        std::static_pointer_cast<void>(host_lifecycle_event_listener).get());
 }
 
 mgn::MirClientHostConnection::~MirClientHostConnection()

=== modified file 'src/server/graphics/nested/mir_client_host_connection.h'
--- src/server/graphics/nested/mir_client_host_connection.h	2014-04-17 11:04:41 +0000
+++ src/server/graphics/nested/mir_client_host_connection.h	2014-07-16 15:59:57 +0000
@@ -20,11 +20,14 @@
 #define MIR_GRAPHICS_NESTED_MIR_CLIENT_HOST_CONNECTION_H_
 
 #include "host_connection.h"
+#include "mir/shell/host_lifecycle_event_listener.h"
 
 #include <string>
 
 struct MirConnection;
 
+namespace msh = mir::shell;
+
 namespace mir
 {
 namespace graphics
@@ -35,7 +38,7 @@
 class MirClientHostConnection : public HostConnection
 {
 public:
-    MirClientHostConnection(std::string const& host_socket, std::string const& name);
+    MirClientHostConnection(std::string const& host_socket, std::string const& name, std::shared_ptr<msh::HostLifecycleEventListener> const& host_lifecycle_event_listener);
     ~MirClientHostConnection();
 
     std::vector<int> platform_fd_items() override;
@@ -51,6 +54,7 @@
 private:
     MirConnection* const mir_connection;
     std::function<void()> conf_change_callback;
+    std::shared_ptr<msh::HostLifecycleEventListener> const host_lifecycle_event_listener;
 };
 
 }

=== modified file 'src/server/shell/default_configuration.cpp'
--- src/server/shell/default_configuration.cpp	2014-04-15 05:31:19 +0000
+++ src/server/shell/default_configuration.cpp	2014-07-16 15:59:57 +0000
@@ -17,6 +17,8 @@
  */
 
 #include "mir/default_server_configuration.h"
+#include "null_host_lifecycle_event_listener.h"
+
 
 #include "consuming_placement_strategy.h"
 #include "default_focus_mechanism.h"
@@ -58,3 +60,13 @@
             return std::make_shared<msh::GraphicsDisplayLayout>(the_display());
         });
 }
+
+std::shared_ptr<msh::HostLifecycleEventListener>
+mir::DefaultServerConfiguration::the_host_lifecycle_event_listener()
+{
+    return host_lifecycle_event_listener(
+        []()
+        {
+            return std::make_shared<msh::NullHostLifecycleEventListener>();
+        });
+}

=== added file 'src/server/shell/null_host_lifecycle_event_listener.h'
--- src/server/shell/null_host_lifecycle_event_listener.h	1970-01-01 00:00:00 +0000
+++ src/server/shell/null_host_lifecycle_event_listener.h	2014-07-16 15:59:57 +0000
@@ -0,0 +1,38 @@
+/*
+ * Copyright © 2014 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU 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 warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Cemil Azizoglu <[e-mail]>
+ */
+
+#ifndef MIR_NULL_HOST_LIFECYCLE_EVENT_LISTENER_H_
+#define MIR_NULL_HOST_LIFECYCLE_EVENT_LISTENER_H_
+
+#include "mir/shell/host_lifecycle_event_listener.h"
+
+namespace mir
+{
+namespace shell
+{
+
+class NullHostLifecycleEventListener : public HostLifecycleEventListener
+{
+public:
+    virtual void lifecycle_event_occurred(MirLifecycleState /*state*/) override {}
+};
+
+}
+}
+
+#endif /* MIR_NULL_HOST_LIFECYCLE_EVENT_LISTENER_H_ */

=== modified file 'tests/acceptance-tests/test_nested_mir.cpp'
--- tests/acceptance-tests/test_nested_mir.cpp	2014-07-09 17:04:55 +0000
+++ tests/acceptance-tests/test_nested_mir.cpp	2014-07-16 15:59:57 +0000
@@ -22,6 +22,9 @@
 #include "mir/graphics/display_configuration.h"
 #include "mir/display_server.h"
 #include "mir/run_mir.h"
+#include "mir/shell/focus_controller.h"
+#include "mir/scene/session.h"
+#include "mir/shell/host_lifecycle_event_listener.h"
 
 #include "mir_test_framework/in_process_server.h"
 #include "mir_test_framework/stubbed_server_configuration.h"
@@ -39,6 +42,7 @@
 namespace mf = mir::frontend;
 namespace mg = mir::graphics;
 namespace mtf = mir_test_framework;
+namespace msh = mir::shell;
 using namespace testing;
 
 namespace
@@ -137,6 +141,19 @@
     std::shared_ptr<mg::Platform> const adaptee;
 };
 
+struct MockHostLifecycleEventListener : msh::HostLifecycleEventListener
+{
+    MockHostLifecycleEventListener(
+        std::shared_ptr<msh::HostLifecycleEventListener> const& wrapped) :
+        wrapped(wrapped)
+    {
+    }
+
+    MOCK_METHOD1(lifecycle_event_occurred, void (MirLifecycleState));
+
+    std::shared_ptr<msh::HostLifecycleEventListener> const wrapped;
+};
+
 struct NestedServerConfiguration : FakeCommandLine, public mir::DefaultServerConfiguration
 {
     NestedServerConfiguration(
@@ -262,6 +279,18 @@
         connection_string = new_connection();
     }
 
+    void trigger_lifecycle_event(MirLifecycleState const lifecycle_state)
+    {
+        auto const app = the_focus_controller()->focussed_application().lock();
+
+        EXPECT_TRUE(app != nullptr) << "Nested server not connected";
+
+        if (app)
+        {
+           app->set_lifecycle_state(lifecycle_state);
+        }
+    }
+
     std::string connection_string;
 };
 }
@@ -323,3 +352,44 @@
 
     EXPECT_FALSE(config.my_display.lock()) << "after run_mir() exits the display should be released";
 }
+
+TEST_F(NestedServer, receives_lifecycle_events_from_host)
+{
+    struct MyServerConfiguration : NestedServerConfiguration
+    {
+        using NestedServerConfiguration::NestedServerConfiguration;
+
+        std::shared_ptr<msh::HostLifecycleEventListener> the_host_lifecycle_event_listener() override
+        {
+            return host_lifecycle_event_listener([this]()
+               -> std::shared_ptr<msh::HostLifecycleEventListener>
+               {
+                   return the_mock_host_lifecycle_event_listener();
+               });
+        }
+
+        std::shared_ptr<MockHostLifecycleEventListener> the_mock_host_lifecycle_event_listener()
+        {
+            return mock_host_lifecycle_event_listener([this]
+                {
+                    return std::make_shared<MockHostLifecycleEventListener>(
+                        NestedServerConfiguration::the_host_lifecycle_event_listener());
+                });
+        }
+
+        mir::CachedPtr<MockHostLifecycleEventListener> mock_host_lifecycle_event_listener;
+    };
+
+    MyServerConfiguration nested_config{connection_string, the_graphics_platform()};
+
+    NestedMirRunner nested_mir{nested_config};
+
+    InSequence seq;
+    EXPECT_CALL(*(nested_config.the_mock_host_lifecycle_event_listener()),
+        lifecycle_event_occurred(mir_lifecycle_state_resumed)).Times(1);
+    EXPECT_CALL(*(nested_config.the_mock_host_lifecycle_event_listener()),
+        lifecycle_event_occurred(mir_lifecycle_state_will_suspend)).Times(1);
+
+    trigger_lifecycle_event(mir_lifecycle_state_resumed);
+    trigger_lifecycle_event(mir_lifecycle_state_will_suspend);
+}