Merge lp:~afrantzis/unity-system-compositor/proximity into lp:unity-system-compositor

[Alexandros Frantzis]

Enable and handle proximity events properly

Enable and handle proximity events properly

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:231
http://jenkins.qa.ubuntu.com/job/unity-system-compositor-ci/247/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-wily-amd64-ci/35
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-wily-armhf-ci/35
        deb: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-wily-armhf-ci/35/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-wily-i386-ci/35

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-system-compositor-ci/247/rebuild

review: Approve (continuous-integration)

[Kevin DuBois (kdub)]

240 +void usc::PowerdMediator::enable_proximity_l
I think this would be a bit more understandable if a force_proximity_l() function was split out, but other than that lgtm

review: Approve

=== modified file 'src/mir_screen.cpp'
--- src/mir_screen.cpp	2015-07-17 12:45:10 +0000
+++ src/mir_screen.cpp	2015-07-17 12:45:10 +0000
@@ -55,7 +55,8 @@
       notification_timeouts(notification_timeouts),
       current_power_mode{MirPowerMode::mir_power_mode_on},
       restart_timers{true},
-      power_state_change_handler{[](MirPowerMode,PowerStateChangeReason){}}
+      power_state_change_handler{[](MirPowerMode,PowerStateChangeReason){}},
+      allow_proximity_to_turn_on_screen{false}
 {
     /*
      * Make sure the compositor is running as certain conditions can
@@ -73,7 +74,10 @@
     std::lock_guard<std::mutex> lock{guard};
     reset_timers_l(PowerStateChangeReason::inactivity);
     if (current_power_mode == MirPowerMode::mir_power_mode_on)
+    {
         screen_hardware->set_normal_backlight();
+        screen_hardware->enable_proximity(false);
+    }
 }
 
 void usc::MirScreen::enable_inactivity_timers(bool enable)
@@ -129,12 +133,25 @@
     if (raw_dimmer_timeout >= 0)
         inactivity_timeouts.dimming_timeout = std::chrono::duration_cast<std::chrono::milliseconds>(the_dimming_timeout);
 
-    cancel_timers_l();
+    cancel_timers_l(PowerStateChangeReason::inactivity);
     reset_timers_l(PowerStateChangeReason::inactivity);
 }
 
 void usc::MirScreen::set_screen_power_mode_l(MirPowerMode mode, PowerStateChangeReason reason)
 {
+    if (!is_screen_change_allowed(mode, reason))
+        return;
+
+    // Notifications don't turn on the screen directly, they rely on proximity events
+    if (mode == MirPowerMode::mir_power_mode_on &&
+        reason == PowerStateChangeReason::notification)
+    {
+        allow_proximity_to_turn_on_screen = true;
+        screen_hardware->enable_proximity(true);
+        reset_timers_ignoring_power_mode_l(reason);
+        return;
+    }
+
     if (mode == MirPowerMode::mir_power_mode_on)
     {
         /* The screen may be dim, but on - make sure to reset backlight */
@@ -145,16 +162,26 @@
     }
     else
     {
-        cancel_timers_l();
+        cancel_timers_l(reason);
         configure_display_l(mode, reason);
     }
 }
 
 void usc::MirScreen::configure_display_l(MirPowerMode mode, PowerStateChangeReason reason)
 {
+    if (reason != PowerStateChangeReason::proximity)
+    {
+        screen_hardware->enable_proximity(false);
+        allow_proximity_to_turn_on_screen = false;
+    }
+
     if (current_power_mode == mode)
         return;
 
+    allow_proximity_to_turn_on_screen =
+        mode == mir_power_mode_off &&
+        reason == PowerStateChangeReason::proximity;
+
     std::shared_ptr<mg::DisplayConfiguration> displayConfig = display->configuration();
 
     displayConfig->for_each_output(
@@ -193,8 +220,11 @@
         screen_hardware->allow_suspend();
 }
 
-void usc::MirScreen::cancel_timers_l()
+void usc::MirScreen::cancel_timers_l(PowerStateChangeReason reason)
 {
+    if (reason == PowerStateChangeReason::proximity)
+        return;
+
     power_off_alarm->cancel();
     dimmer_alarm->cancel();
     next_power_off = {};
@@ -203,29 +233,35 @@
 
 void usc::MirScreen::reset_timers_l(PowerStateChangeReason reason)
 {
-    if (restart_timers && current_power_mode != MirPowerMode::mir_power_mode_off)
+    if (current_power_mode != MirPowerMode::mir_power_mode_off)
+        reset_timers_ignoring_power_mode_l(reason);
+}
+
+void usc::MirScreen::reset_timers_ignoring_power_mode_l(PowerStateChangeReason reason)
+{
+    if (!restart_timers || reason == PowerStateChangeReason::proximity)
+        return;
+
+    auto const timeouts = timeouts_for(reason);
+    auto const now = clock->now();
+
+    if (timeouts.power_off_timeout.count() > 0)
     {
-        auto const timeouts = timeouts_for(reason);
-        auto const now = clock->now();
-
-        if (timeouts.power_off_timeout.count() > 0)
+        auto const new_next_power_off = now + timeouts.power_off_timeout;
+        if (new_next_power_off > next_power_off)
         {
-            auto const new_next_power_off = now + timeouts.power_off_timeout;
-            if (new_next_power_off > next_power_off)
-            {
-                power_off_alarm->reschedule_in(timeouts.power_off_timeout);
-                next_power_off = new_next_power_off;
-            }
+            power_off_alarm->reschedule_in(timeouts.power_off_timeout);
+            next_power_off = new_next_power_off;
         }
+    }
 
-        if (timeouts.dimming_timeout.count() > 0)
+    if (timeouts.dimming_timeout.count() > 0)
+    {
+        auto const new_next_dimming = now + timeouts.dimming_timeout;
+        if (new_next_dimming > next_dimming)
         {
-            auto const new_next_dimming = now + timeouts.dimming_timeout;
-            if (new_next_dimming > next_dimming)
-            {
-                dimmer_alarm->reschedule_in(timeouts.dimming_timeout);
-                next_dimming = new_next_dimming;
-            }
+            dimmer_alarm->reschedule_in(timeouts.dimming_timeout);
+            next_dimming = new_next_dimming;
         }
     }
 }
@@ -235,7 +271,7 @@
     if (enable)
         reset_timers_l(PowerStateChangeReason::inactivity);
     else
-        cancel_timers_l();
+        cancel_timers_l(PowerStateChangeReason::inactivity);
 }
 
 usc::MirScreen::Timeouts usc::MirScreen::timeouts_for(PowerStateChangeReason reason)
@@ -246,6 +282,18 @@
         return inactivity_timeouts;
 }
 
+bool usc::MirScreen::is_screen_change_allowed(MirPowerMode mode, PowerStateChangeReason reason)
+{
+    if (mode == MirPowerMode::mir_power_mode_on &&
+        reason == PowerStateChangeReason::proximity &&
+        !allow_proximity_to_turn_on_screen)
+    {
+        return false;
+    }
+
+    return true;
+}
+
 void usc::MirScreen::power_off_alarm_notification()
 {
     std::lock_guard<std::mutex> lock{guard};

=== modified file 'src/mir_screen.h'
--- src/mir_screen.h	2015-07-17 12:45:10 +0000
+++ src/mir_screen.h	2015-07-17 12:45:10 +0000
@@ -77,10 +77,12 @@
     void set_screen_power_mode_l(MirPowerMode mode, PowerStateChangeReason reason);
     void configure_display_l(MirPowerMode mode, PowerStateChangeReason reason);
 
-    void cancel_timers_l();
+    void cancel_timers_l(PowerStateChangeReason reason);
     void reset_timers_l(PowerStateChangeReason reason);
+    void reset_timers_ignoring_power_mode_l(PowerStateChangeReason reason);
     void enable_inactivity_timers_l(bool flag);
     Timeouts timeouts_for(PowerStateChangeReason reason);
+    bool is_screen_change_allowed(MirPowerMode mode, PowerStateChangeReason reason);
 
     void power_off_alarm_notification();
     void dimmer_alarm_notification();
@@ -103,6 +105,7 @@
     MirPowerMode current_power_mode;
     bool restart_timers;
     PowerStateChangeHandler power_state_change_handler;
+    bool allow_proximity_to_turn_on_screen;
 };
 
 }

=== modified file 'src/powerd_mediator.cpp'
--- src/powerd_mediator.cpp	2015-04-24 14:40:28 +0000
+++ src/powerd_mediator.cpp	2015-07-17 12:45:10 +0000
@@ -56,6 +56,7 @@
       backlight_state{BacklightState::normal},
       auto_brightness_supported_{false},
       auto_brightness_requested{false},
+      proximity_enabled{false},
       sys_state{SysState::unknown}
 {
     connection.add_match(
@@ -197,6 +198,13 @@
     return max_brightness_;
 }
 
+void usc::PowerdMediator::enable_proximity(bool enable)
+{
+    std::lock_guard<decltype(mutex)> lock{mutex};
+
+    enable_proximity_l(enable, ForceProximity::no);
+}
+
 bool usc::PowerdMediator::is_system_suspended()
 {
     std::lock_guard<decltype(mutex)> lock{mutex};
@@ -290,6 +298,8 @@
 
     // Powerd may have restarted, re-apply backlight settings
     change_backlight_state(backlight_state, ForceBacklightState::yes);
+
+    enable_proximity_l(false, ForceProximity::yes);
 }
 
 void usc::PowerdMediator::init_brightness_params()
@@ -362,6 +372,22 @@
     }
 }
 
+void usc::PowerdMediator::enable_proximity_l(
+    bool enable, ForceProximity force_proximity)
+{
+    if (proximity_enabled == enable && force_proximity == ForceProximity::no)
+        return;
+
+    auto const name = "unity-system-compositor";
+    auto const request = enable ? "enableProximityHandling" :
+                                  "disableProximityHandling";
+    invoke_with_reply(request,
+                      DBUS_TYPE_STRING, &name,
+                      DBUS_TYPE_INVALID);
+
+    proximity_enabled = enable;
+}
+
 bool usc::PowerdMediator::is_valid_brightness(int brightness)
 {
     return brightness >= min_brightness_ && brightness <= max_brightness_;

=== modified file 'src/powerd_mediator.h'
--- src/powerd_mediator.h	2015-04-07 13:36:48 +0000
+++ src/powerd_mediator.h	2015-07-17 12:45:10 +0000
@@ -46,6 +46,8 @@
     int min_brightness() override;
     int max_brightness() override;
 
+    void enable_proximity(bool enable) override;
+
     bool is_system_suspended();
 
 private:
@@ -66,6 +68,7 @@
 
     enum class ForceDisableSuspend { no, yes };
     enum class ForceBacklightState { no, yes };
+    enum class ForceProximity { no, yes };
 
     static ::DBusHandlerResult handle_dbus_message_thunk(
         ::DBusConnection* connection, ::DBusMessage* message, void* user_data);
@@ -76,6 +79,7 @@
     void init_brightness_params();
     void change_backlight_state(
         BacklightState new_state, ForceBacklightState force_backlight_state);
+    void enable_proximity_l(bool enable, ForceProximity force_proximity);
     bool is_valid_brightness(int brightness);
     bool request_suspend_block();
     void wait_for_sys_state(SysState state);
@@ -98,6 +102,7 @@
     BacklightState backlight_state;
     bool auto_brightness_supported_;
     bool auto_brightness_requested;
+    bool proximity_enabled;
     std::string suspend_block_cookie;
     std::mutex sys_state_mutex;
     SysState sys_state;

=== modified file 'src/screen_hardware.h'
--- src/screen_hardware.h	2015-02-18 14:40:29 +0000
+++ src/screen_hardware.h	2015-07-17 12:45:10 +0000
@@ -39,6 +39,8 @@
     virtual int min_brightness() = 0;
     virtual int max_brightness() = 0;
 
+    virtual void enable_proximity(bool enable) = 0;
+
 protected:
     ScreenHardware() = default;
     ScreenHardware(ScreenHardware const&) = delete;

=== modified file 'tests/integration-tests/test_powerd_mediator.cpp'
--- tests/integration-tests/test_powerd_mediator.cpp	2015-04-07 13:36:48 +0000
+++ tests/integration-tests/test_powerd_mediator.cpp	2015-07-17 12:45:10 +0000
@@ -84,6 +84,8 @@
     MOCK_METHOD1(dbus_userAutobrightnessEnable, void(dbus_bool_t enable));
     MOCK_METHOD2(dbus_requestSysState, std::string(char const* name, int state));
     MOCK_METHOD1(dbus_clearSysState, void(char const* cookie));
+    MOCK_METHOD1(dbus_enableProximityHandling, void(char const* name));
+    MOCK_METHOD1(dbus_disableProximityHandling, void(char const* name));
 
     int32_t const dim_brightness = 13;
     int32_t const min_brightness = 5;
@@ -192,6 +194,32 @@
 
             emit_SysPowerStateChange(0);
         }
+        else if (dbus_message_is_method_call(message, powerd_service_name, "enableProximityHandling"))
+        {
+            char const* name{nullptr};
+            dbus_message_get_args(
+                message, nullptr,
+                DBUS_TYPE_STRING, &name,
+                DBUS_TYPE_INVALID);
+
+            dbus_enableProximityHandling(name);
+
+            usc::DBusMessageHandle reply{dbus_message_new_method_return(message)};
+            dbus_connection_send(connection, reply, nullptr);
+        }
+        else if (dbus_message_is_method_call(message, powerd_service_name, "disableProximityHandling"))
+        {
+            char const* name{nullptr};
+            dbus_message_get_args(
+                message, nullptr,
+                DBUS_TYPE_STRING, &name,
+                DBUS_TYPE_INVALID);
+
+            dbus_disableProximityHandling(name);
+
+            usc::DBusMessageHandle reply{dbus_message_new_method_return(message)};
+            dbus_connection_send(connection, reply, nullptr);
+        }
 
         return DBUS_HANDLER_RESULT_HANDLED;
     }
@@ -462,6 +490,41 @@
     mediator->allow_suspend();
 }
 
+TEST_F(APowerdMediator, enables_and_disables_proximity_handling)
+{
+    using namespace testing;
+    auto const proximity_name = "unity-system-compositor";
+
+    InSequence s;
+    EXPECT_CALL(powerd_service, dbus_enableProximityHandling(StrEq(proximity_name)));
+    EXPECT_CALL(powerd_service, dbus_disableProximityHandling(StrEq(proximity_name)));
+
+    mediator->enable_proximity(true);
+    mediator->enable_proximity(false);
+}
+
+TEST_F(APowerdMediator, ignores_requests_for_redundant_proximity_handling)
+{
+    using namespace testing;
+
+    auto const proximity_name = "unity-system-compositor";
+
+    InSequence s;
+    EXPECT_CALL(powerd_service, dbus_enableProximityHandling(StrEq(proximity_name)));
+    EXPECT_CALL(powerd_service, dbus_disableProximityHandling(StrEq(proximity_name)));
+
+    // Should be ignore, proximity already disabled
+    mediator->enable_proximity(false);
+
+    // Should be handled only once
+    mediator->enable_proximity(true);
+    mediator->enable_proximity(true);
+
+    // Should be handled only once
+    mediator->enable_proximity(false);
+    mediator->enable_proximity(false);
+}
+
 namespace
 {
 
@@ -637,6 +700,24 @@
     EXPECT_CALL(powerd_service, dbus_setUserBrightness(0)).Times(AtMost(1));
 }
 
+TEST(APowerdMediatorAtStartup, disables_proximity_handling)
+{
+    using namespace testing;
+
+    dbus_bool_t const auto_brightness_supported{TRUE};
+
+    ut::DBusBus bus;
+    NiceMock<PowerdService> powerd_service{
+        bus.address(), auto_brightness_supported, PowerdService::StartNow::yes};
+
+    EXPECT_CALL(powerd_service, dbus_disableProximityHandling(_));
+
+    usc::PowerdMediator mediator{bus.address()};
+    powerd_service.wait_for_initial_setup();
+
+    Mock::VerifyAndClearExpectations(&powerd_service);
+}
+
 TEST(APowerdMediatorAtShutdown, turns_off_backlight)
 {
     using namespace testing;

=== modified file 'tests/unit-tests/test_mir_screen.cpp'
--- tests/unit-tests/test_mir_screen.cpp	2015-07-17 12:45:10 +0000
+++ tests/unit-tests/test_mir_screen.cpp	2015-07-17 12:45:10 +0000
@@ -116,6 +116,25 @@
     MOCK_METHOD1(set_brightness, void(int));
     int min_brightness() override { return 100; }
     int max_brightness() override { return 0; }
+
+    enum class Proximity {near, far};
+
+    void enable_proximity(bool enable) override
+    {
+        proximity_enabled = enable;
+        set_proximity(current_proximity);
+    }
+
+    void set_proximity(Proximity proximity)
+    {
+        current_proximity = proximity;
+        if (proximity_enabled)
+            on_proximity_changed(current_proximity);
+    }
+
+    std::function<void(Proximity)> on_proximity_changed = [](Proximity){};
+    Proximity current_proximity{Proximity::far};
+    bool proximity_enabled{false};
 };
 
 struct MockTouchVisualizer : mir::input::TouchVisualizer
@@ -129,6 +148,36 @@
 
 struct AMirScreen : testing::Test
 {
+    AMirScreen()
+    {
+        using namespace testing;
+
+        screen_hardware->on_proximity_changed =
+            [this] (MockScreenHardware::Proximity p) { defer_proximity_event(p); };
+    }
+
+    void defer_proximity_event(MockScreenHardware::Proximity proximity)
+    {
+        deferred_actions.push_back(
+            [this, proximity]
+            {
+                mir_screen.set_screen_power_mode(
+                        proximity == MockScreenHardware::Proximity::far ?
+                            MirPowerMode::mir_power_mode_on :
+                            MirPowerMode::mir_power_mode_off,
+                        PowerStateChangeReason::proximity);
+            });
+    }
+
+    void process_deferred_actions()
+    {
+        for (auto const& a : deferred_actions)
+            a();
+        deferred_actions.clear();
+    }
+
+    std::vector<std::function<void(void)>> deferred_actions;
+
     std::chrono::seconds const power_off_timeout{60};
     std::chrono::seconds const dimmer_timeout{50};
     std::chrono::seconds const notification_power_off_timeout{15};
@@ -185,6 +234,26 @@
         verify_and_clear_expectations();
     }
 
+    void receive_notification()
+    {
+        mir_screen.set_screen_power_mode(
+            MirPowerMode::mir_power_mode_on,
+            PowerStateChangeReason::notification);
+        process_deferred_actions();
+    }
+
+    void cover_screen()
+    {
+        screen_hardware->set_proximity(MockScreenHardware::Proximity::near);
+        process_deferred_actions();
+    }
+
+    void uncover_screen()
+    {
+        screen_hardware->set_proximity(MockScreenHardware::Proximity::far);
+        process_deferred_actions();
+    }
+
     void verify_and_clear_expectations()
     {
         using namespace testing;
@@ -378,13 +447,12 @@
     EXPECT_THAT(handler_mode, Eq(MirPowerMode::mir_power_mode_off));
 }
 
-TEST_F(AMirScreen, turns_screen_off_after_15s_for_notification)
+TEST_F(AMirScreen, turns_screen_off_after_notification_timeout)
 {
     turn_screen_off();
 
     expect_screen_is_turned_on();
-    mir_screen.set_screen_power_mode(MirPowerMode::mir_power_mode_on,
-                                     PowerStateChangeReason::notification);
+    receive_notification();
     verify_and_clear_expectations();
 
     expect_screen_is_turned_off();
@@ -396,8 +464,7 @@
     turn_screen_off();
 
     expect_screen_is_turned_on();
-    mir_screen.set_screen_power_mode(MirPowerMode::mir_power_mode_on,
-                                     PowerStateChangeReason::notification);
+    receive_notification();
     verify_and_clear_expectations();
 
     // At T=10 we request a temporary keep display on (e.g. user has touched
@@ -426,8 +493,7 @@
 
     // At T=50 we get a notification
     timer->advance_by(fifty_seconds);
-    mir_screen.set_screen_power_mode(MirPowerMode::mir_power_mode_on,
-                                     PowerStateChangeReason::notification);
+    receive_notification();
     verify_and_clear_expectations();
 
     // At T=60 the screen should still be active because the notification
@@ -452,8 +518,7 @@
 
     // At T=30 we get a notification
     timer->advance_by(thirty_seconds);
-    mir_screen.set_screen_power_mode(MirPowerMode::mir_power_mode_on,
-                                     PowerStateChangeReason::notification);
+    receive_notification();
     verify_and_clear_expectations();
 
     // At T=45 the screen should still be active because the notification
@@ -485,8 +550,7 @@
 
     // At T=40 we get a notification
     timer->advance_by(fourty_seconds);
-    mir_screen.set_screen_power_mode(MirPowerMode::mir_power_mode_on,
-                                     PowerStateChangeReason::notification);
+    receive_notification();
     verify_and_clear_expectations();
 
     // At T=50 nothing should happen since the notification has
@@ -506,3 +570,152 @@
     expect_screen_is_turned_off();
     timer->advance_by(eight_seconds);
 }
+
+TEST_F(AMirScreen, proximity_requests_affect_screen_state)
+{
+    expect_screen_is_turned_off();
+    mir_screen.set_screen_power_mode(MirPowerMode::mir_power_mode_off,
+                                     PowerStateChangeReason::proximity);
+    verify_and_clear_expectations();
+
+    expect_screen_is_turned_on();
+    mir_screen.set_screen_power_mode(MirPowerMode::mir_power_mode_on,
+                                     PowerStateChangeReason::proximity);
+    verify_and_clear_expectations();
+}
+
+TEST_F(AMirScreen, proximity_requests_do_not_reset_timeouts)
+{
+    // At T=0 we turn the screen on, and normal inactivity timeouts
+    // are reset
+    mir_screen.set_screen_power_mode(MirPowerMode::mir_power_mode_on,
+                                     PowerStateChangeReason::power_key);
+
+    // At T=30 we get a screen off request due to proximity
+    timer->advance_by(thirty_seconds);
+    mir_screen.set_screen_power_mode(MirPowerMode::mir_power_mode_off,
+                                     PowerStateChangeReason::proximity);
+
+    // At T=40 we get a screen on request due to proximity
+    timer->advance_by(ten_seconds);
+    mir_screen.set_screen_power_mode(MirPowerMode::mir_power_mode_on,
+                                     PowerStateChangeReason::proximity);
+
+    verify_and_clear_expectations();
+
+    // At T=50 screen should be dimmed due to the inactivity
+    // dimming timeout
+    expect_screen_is_turned_dim();
+    timer->advance_by(ten_seconds);
+    verify_and_clear_expectations();
+
+    // At T=60 the screen should turn off due to the normal
+    // inactivity timeout
+    expect_screen_is_turned_off();
+    timer->advance_by(ten_seconds);
+}
+
+TEST_F(AMirScreen, does_not_turn_on_screen_when_notification_arrives_with_phone_covered)
+{
+    turn_screen_off();
+    cover_screen();
+
+    expect_no_reconfiguration();
+    receive_notification();
+}
+
+TEST_F(AMirScreen, turns_screen_on_when_phone_is_uncovered_after_notification_arrives)
+{
+    turn_screen_off();
+    cover_screen();
+
+    expect_no_reconfiguration();
+    receive_notification();
+    verify_and_clear_expectations();
+
+    expect_screen_is_turned_on();
+    uncover_screen();
+}
+
+TEST_F(AMirScreen, cancels_proximity_handling_when_phone_is_turned_off_after_notification)
+{
+    turn_screen_off();
+    cover_screen();
+
+    receive_notification();
+    timer->advance_by(notification_power_off_timeout);
+    verify_and_clear_expectations();
+
+    expect_no_reconfiguration();
+    uncover_screen();
+    cover_screen();
+}
+
+TEST_F(AMirScreen, cancels_proximity_handling_when_screen_is_touched_after_notification)
+{
+    turn_screen_off();
+
+    receive_notification();
+    mir_screen.keep_display_on_temporarily();
+    verify_and_clear_expectations();
+
+    expect_no_reconfiguration();
+    cover_screen();
+    uncover_screen();
+}
+
+TEST_F(AMirScreen, does_not_allow_proximity_to_turn_on_screen_not_turned_off_by_proximity)
+{
+    turn_screen_off();
+
+    expect_no_reconfiguration();
+    mir_screen.set_screen_power_mode(
+        MirPowerMode::mir_power_mode_on,
+        PowerStateChangeReason::proximity);
+    verify_and_clear_expectations();
+
+    expect_no_reconfiguration();
+    mir_screen.set_screen_power_mode(
+        MirPowerMode::mir_power_mode_off,
+        PowerStateChangeReason::proximity);
+    verify_and_clear_expectations();
+
+    expect_no_reconfiguration();
+    mir_screen.set_screen_power_mode(
+        MirPowerMode::mir_power_mode_on,
+        PowerStateChangeReason::proximity);
+}
+
+TEST_F(AMirScreen, does_not_allow_proximity_to_turn_on_screen_not_turned_off_by_proximity_2)
+{
+    mir_screen.set_screen_power_mode(
+        MirPowerMode::mir_power_mode_off,
+        PowerStateChangeReason::proximity);
+
+    mir_screen.set_screen_power_mode(
+        MirPowerMode::mir_power_mode_off,
+        PowerStateChangeReason::power_key);
+
+    verify_and_clear_expectations();
+
+    expect_no_reconfiguration();
+    mir_screen.set_screen_power_mode(
+        MirPowerMode::mir_power_mode_on,
+        PowerStateChangeReason::proximity);
+}
+
+TEST_F(AMirScreen, proximity_can_affect_screen_after_keep_display_on)
+{
+    mir_screen.keep_display_on(true);
+
+    expect_screen_is_turned_off();
+    mir_screen.set_screen_power_mode(
+        MirPowerMode::mir_power_mode_off,
+        PowerStateChangeReason::proximity);
+    verify_and_clear_expectations();
+
+    expect_screen_is_turned_on();
+    mir_screen.set_screen_power_mode(
+        MirPowerMode::mir_power_mode_on,
+        PowerStateChangeReason::proximity);
+}