Merge lp:~afrantzis/unity-system-compositor/voice-call-proximity-over-0.1 into lp:unity-system-compositor/ubuntu

[Alexandros Frantzis]

Screen blanking/proximity handling improvements for voice calls.

Screen blanking/proximity handling improvements for voice calls.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:253
http://jenkins.qa.ubuntu.com/job/unity-system-compositor-ubuntu-ci/18/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-ubuntu-wily-amd64-ci/16
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-ubuntu-wily-armhf-ci/16

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

review: Approve (continuous-integration)

[kevin gunn (kgunn72)]

so after testing, i get proximity blanking for the text messages.
but i do not get proximity blanking for the incoming voice call notification.
is that what i'm supposed to see ?
i'm on arale.

[Alexandros Frantzis (afrantzis)]

> so after testing, i get proximity blanking for the text messages.
> but i do not get proximity blanking for the incoming voice call notification.
> is that what i'm supposed to see ?
> i'm on arale.

No, you should also get proximity blanking for voice call notifications. This used to work, so I figured something must have changed outside USC/powerd.

After some investigation I found that the problem is the new notification handling logic in Unity8. With the new logic Unity8 sends a "turn screen on" message with reason "unknown" when a snap decision prompt is shown. This confuses USC because it has already got a "call" notification from powerd.

Once again our distributed and uncoordinated power-management logic is making our lives difficult and is a constant source of bugs and fragility.

I need to think a bit more about how to solve this particular problem. Stay tuned.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:254
http://jenkins.qa.ubuntu.com/job/unity-system-compositor-ubuntu-ci/23/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-ubuntu-wily-amd64-ci/21
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-ubuntu-wily-armhf-ci/21

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

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:255
http://jenkins.qa.ubuntu.com/job/unity-system-compositor-ubuntu-ci/24/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-ubuntu-wily-amd64-ci/22
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-ubuntu-wily-armhf-ci/22

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

review: Approve (continuous-integration)

[kevin gunn (kgunn72)]

retested with https://code.launchpad.net/~afrantzis/unity8/power-state-change-reason-snap-decision
it matched what i expected, I hammered on this pretty good.
I found only 2 cosmetic issues, and 1 issue that should likely be addressed (unless it's already a bug)

cosmetic issue 1: if a text or call occurs, screen is lit, no interaction it will dim. getting a call or text at that moment will not brighten the screen.

cosmetic issue 2: incoming call, cover and uncover proximity sensor quickly/rapidly and every now and then you will hear the audio stutter only very slightly

issue to fix: if you are on an active call and hit power button to blank screen, generate a second incoming call - as a user you have no idea this has occured, there is no vibra nor does the screen light. At least with a text the vibra will activate, but no lighting screen. The screen should probably light up in both these instances.

[kevin gunn (kgunn72)]

cosmetic issues mentioned above should not prevent landing

[kevin gunn (kgunn72)]

sorry for comments galore, i meant to also add if the last issue is already a bug, then I wouldn't consider it a blocker for landing this as this is a huge improvement.

[Alexandros Frantzis (afrantzis)]

> retested with https://code.launchpad.net/~afrantzis/unity8/power-state-change-
> reason-snap-decision
> it matched what i expected, I hammered on this pretty good.

Thanks for testing!

> I found only 2 cosmetic issues, and 1 issue that should likely be addressed
> (unless it's already a bug)

> cosmetic issue 1: if a text or call occurs, screen is lit, no interaction it
> will dim. getting a call or text at that moment will not brighten the screen.

From a quick look at the related USC code, this should be easily fixable (Famous last words? Let's see... :) )

> cosmetic issue 2: incoming call, cover and uncover proximity sensor
> quickly/rapidly and every now and then you will hear the audio stutter only
> very slightly

Covering/uncovering the proximity sensor is an intensive task that involves cross process communication and the teardown and setup of our input and graphics subsystems in USC/Mir. I can't really see anything simple (i.e. as a bugfix) we can do to improve this on the USC side.

> issue to fix: if you are on an active call and hit power button to blank
> screen, generate a second incoming call - as a user you have no idea this has
> occured, there is no vibra nor does the screen light. At least with a text the
> vibra will activate, but no lighting screen. The screen should probably light
> up in both these instances.

This is indeed a regression. With the new code, when a call arrives, USC enables proximity handling and expects a proximity event with the initial proximity state. This is done in order to avoid turning on the screen for a moment if the proximity is "near". However, if proximity handling is already enabled (in this case because the dialer-app has enabled it) USC won't receive a proximity event with the initial state and won't turn on the screen. I am confident there is a way to improve this within our current architecture, but it will probably involve more communication between powerd and USC and more state keeping. I will experiment with a few approaches.

Note that when a second call arrives the users get a beeping noise in the call audio output, so they do get some notification.

Stay tuned!

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:257
http://jenkins.qa.ubuntu.com/job/unity-system-compositor-ubuntu-ci/25/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-ubuntu-wily-amd64-ci/23
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-ubuntu-wily-armhf-ci/23

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

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:257
http://jenkins.qa.ubuntu.com/job/unity-system-compositor-ubuntu-ci/26/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-ubuntu-wily-amd64-ci/24
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-ubuntu-wily-armhf-ci/24

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

review: Approve (continuous-integration)

[Alexandros Frantzis (afrantzis)]

Silo 14 now contains fixes for "cosmetic issue 1" and "issue to fix". Let me know how the changes work for you.

Unmerged revisions

257. By Alexandros Frantzis on 2015-09-25

Sync with lp:mir/0.1

256. By Alexandros Frantzis on 2015-09-25

Set normal backlight when call or notifications arrive while the screen is on

255. By Alexandros Frantzis on 2015-09-24

Sync with lp:mir/0.1

254. By Alexandros Frantzis on 2015-09-24

Rename PowerStateChangeReason::call to PowerStateChangeReason::snap_decision

253. By Alexandros Frantzis on 2015-09-11

Update files for 0.1.2 release

252. By Alexandros Frantzis on 2015-09-09

Introduce a separate, fixed timeout pair for reason 'call'

251. By Alexandros Frantzis on 2015-09-04

Improve proximity handling during voice calls

=== modified file 'debian/changelog'
--- debian/changelog	2015-09-22 16:44:54 +0000
+++ debian/changelog	2015-09-25 12:02:53 +0000
@@ -1,6 +1,19 @@
-unity-system-compositor (0.1.2+15.10.20150922-0ubuntu1) wily; urgency=medium
-
-  [ Cemil Azizoglu ]
+<<<<<<< TREE
+unity-system-compositor (0.1.2+15.10.20150922-0ubuntu1) wily; urgency=medium
+
+  [ Cemil Azizoglu ]
+=======
+unity-system-compositor (0.1.3) UNRELEASED; urgency=medium
+
+  * Introduce reasons 'snap_decision' and 'call_done' for turning on
+    the screen when a call arrives and finishes, respectively (LP: #1291455)
+
+ -- Alexandros Frantzis <[e-mail]>  Fri, 11 Sep 2015 11:38:31 +0300
+
+unity-system-compositor (0.1.2+15.10.20150922-0ubuntu1) wily; urgency=medium
+
+  [ Cemil Azizoglu ]
+>>>>>>> MERGE-SOURCE
   * Rebuild for Mir 0.16
 
   [ CI Train Bot ]

=== modified file 'src/mir_screen.cpp'
--- src/mir_screen.cpp	2015-08-24 18:14:36 +0000
+++ src/mir_screen.cpp	2015-09-25 12:02:53 +0000
@@ -40,7 +40,8 @@
     std::shared_ptr<mir::time::AlarmFactory> const& alarm_factory,
     std::shared_ptr<usc::Clock> const& clock,
     Timeouts inactivity_timeouts,
-    Timeouts notification_timeouts)
+    Timeouts notification_timeouts,
+    Timeouts call_timeouts)
     : screen_hardware{screen_hardware},
       compositor{compositor},
       display{display},
@@ -53,10 +54,12 @@
               std::bind(&usc::MirScreen::dimmer_alarm_notification, this))},
       inactivity_timeouts(inactivity_timeouts),
       notification_timeouts(notification_timeouts),
+      call_timeouts(call_timeouts),
       current_power_mode{MirPowerMode::mir_power_mode_on},
       restart_timers{true},
       power_state_change_handler{[](MirPowerMode,PowerStateChangeReason){}},
-      allow_proximity_to_turn_on_screen{false}
+      allow_proximity_to_turn_on_screen{false},
+      turned_on_by_user{true}
 {
     /*
      * Make sure the compositor is running as certain conditions can
@@ -144,14 +147,30 @@
 
     // Notifications don't turn on the screen directly, they rely on proximity events
     if (mode == MirPowerMode::mir_power_mode_on &&
-        reason == PowerStateChangeReason::notification)
+        (reason == PowerStateChangeReason::notification ||
+         reason == PowerStateChangeReason::snap_decision ||
+         reason == PowerStateChangeReason::call_done))
     {
         if (current_power_mode != MirPowerMode::mir_power_mode_on)
         {
             allow_proximity_to_turn_on_screen = true;
             screen_hardware->enable_proximity(true);
         }
-        reset_timers_ignoring_power_mode_l(reason);
+        else
+        {
+            screen_hardware->set_normal_backlight();
+        }
+
+        if (reason == PowerStateChangeReason::call_done &&
+            !turned_on_by_user)
+        {
+            reset_timers_ignoring_power_mode_l(reason, ForceResetTimers::yes);
+        }
+        else
+        {
+            reset_timers_ignoring_power_mode_l(reason, ForceResetTimers::no);
+        }
+
         return;
     }
 
@@ -185,6 +204,12 @@
         mode == mir_power_mode_off &&
         reason != PowerStateChangeReason::power_key;
 
+    if (mode == mir_power_mode_on)
+    {
+        turned_on_by_user = 
+            reason == PowerStateChangeReason::power_key;
+    }
+
     std::shared_ptr<mg::DisplayConfiguration> displayConfig = display->configuration();
 
     displayConfig->for_each_output(
@@ -241,10 +266,11 @@
 void usc::MirScreen::reset_timers_l(PowerStateChangeReason reason)
 {
     if (current_power_mode != MirPowerMode::mir_power_mode_off)
-        reset_timers_ignoring_power_mode_l(reason);
+        reset_timers_ignoring_power_mode_l(reason, ForceResetTimers::no);
 }
 
-void usc::MirScreen::reset_timers_ignoring_power_mode_l(PowerStateChangeReason reason)
+void usc::MirScreen::reset_timers_ignoring_power_mode_l(
+    PowerStateChangeReason reason, ForceResetTimers force)
 {
     if (!restart_timers)
         return;
@@ -255,7 +281,7 @@
     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)
+        if (new_next_power_off > next_power_off || force == ForceResetTimers::yes)
         {
             power_off_alarm->reschedule_in(timeouts.power_off_timeout);
             next_power_off = new_next_power_off;
@@ -270,7 +296,7 @@
     if (timeouts.dimming_timeout.count() > 0)
     {
         auto const new_next_dimming = now + timeouts.dimming_timeout;
-        if (new_next_dimming > next_dimming)
+        if (new_next_dimming > next_dimming || force == ForceResetTimers::yes)
         {
             dimmer_alarm->reschedule_in(timeouts.dimming_timeout);
             next_dimming = new_next_dimming;
@@ -293,10 +319,20 @@
 
 usc::MirScreen::Timeouts usc::MirScreen::timeouts_for(PowerStateChangeReason reason)
 {
-    if (reason == PowerStateChangeReason::notification || reason == PowerStateChangeReason::proximity)
+    if (reason == PowerStateChangeReason::notification ||
+        reason == PowerStateChangeReason::proximity ||
+        reason == PowerStateChangeReason::call_done)
+    {
         return notification_timeouts;
+    }
+    else if (reason == PowerStateChangeReason::snap_decision)
+    {
+        return call_timeouts;
+    }
     else
+    {
         return inactivity_timeouts;
+    }
 }
 
 bool usc::MirScreen::is_screen_change_allowed(MirPowerMode mode, PowerStateChangeReason reason)
@@ -321,7 +357,8 @@
 void usc::MirScreen::dimmer_alarm_notification()
 {
     std::lock_guard<std::mutex> lock{guard};
-    screen_hardware->set_dim_backlight();
+    if (current_power_mode != MirPowerMode::mir_power_mode_off)
+        screen_hardware->set_dim_backlight();
     next_dimming = {};
 }
 

=== modified file 'src/mir_screen.h'
--- src/mir_screen.h	2015-07-17 12:43:46 +0000
+++ src/mir_screen.h	2015-09-25 12:02:53 +0000
@@ -56,7 +56,8 @@
               std::shared_ptr<mir::time::AlarmFactory> const& alarm_factory,
               std::shared_ptr<usc::Clock> const& clock,
               Timeouts inactivity_timeouts,
-              Timeouts notification_timeouts);
+              Timeouts notification_timeouts,
+              Timeouts call_timeouts);
     ~MirScreen();
 
     void enable_inactivity_timers(bool enable) override;
@@ -74,12 +75,13 @@
             PowerStateChangeHandler const& power_state_change_handler) override;
 
 private:
+    enum class ForceResetTimers { no, yes };
     void set_screen_power_mode_l(MirPowerMode mode, PowerStateChangeReason reason);
     void configure_display_l(MirPowerMode mode, PowerStateChangeReason reason);
 
     void cancel_timers_l(PowerStateChangeReason reason);
     void reset_timers_l(PowerStateChangeReason reason);
-    void reset_timers_ignoring_power_mode_l(PowerStateChangeReason reason);
+    void reset_timers_ignoring_power_mode_l(PowerStateChangeReason reason, ForceResetTimers force);
     void enable_inactivity_timers_l(bool flag);
     Timeouts timeouts_for(PowerStateChangeReason reason);
     bool is_screen_change_allowed(MirPowerMode mode, PowerStateChangeReason reason);
@@ -100,12 +102,14 @@
     std::mutex guard;
     Timeouts inactivity_timeouts;
     Timeouts notification_timeouts;
+    Timeouts call_timeouts;
     mir::time::Timestamp next_power_off{};
     mir::time::Timestamp next_dimming{};
     MirPowerMode current_power_mode;
     bool restart_timers;
     PowerStateChangeHandler power_state_change_handler;
     bool allow_proximity_to_turn_on_screen;
+    bool turned_on_by_user;
 };
 
 }

=== modified file 'src/power_state_change_reason.h'
--- src/power_state_change_reason.h	2015-07-15 13:48:29 +0000
+++ src/power_state_change_reason.h	2015-09-25 12:02:53 +0000
@@ -23,7 +23,9 @@
     inactivity = 1,
     power_key = 2,
     proximity = 3,
-    notification = 4
+    notification = 4,
+    snap_decision = 5,
+    call_done = 6
 };
 
 #endif

=== modified file 'src/server.cpp'
--- src/server.cpp	2015-08-28 09:56:00 +0000
+++ src/server.cpp	2015-09-25 12:02:53 +0000
@@ -125,6 +125,8 @@
     add_display_configuration_options_to(*this);
     add_configuration_option("notification-display-off-timeout", "The time in seconds before the screen is turned off after a notification arrives",  mir::OptionType::integer);
     add_configuration_option("notification-display-dim-timeout", "The time in seconds before the screen is dimmed after a notification arrives",  mir::OptionType::integer);
+    add_configuration_option("call-display-off-timeout", "The time in seconds before the screen is turned off during a call",  mir::OptionType::integer);
+    add_configuration_option("call-display-dim-timeout", "The time in seconds before the screen is dimmed during a call",  mir::OptionType::integer);
 
     set_command_line(argc, const_cast<char const **>(argv));
 
@@ -260,7 +262,10 @@
                     inactivity_display_dim_timeout()},
                 MirScreen::Timeouts{
                     notification_display_off_timeout(),
-                    notification_display_dim_timeout()});
+                    notification_display_dim_timeout()},
+                MirScreen::Timeouts{
+                    call_display_off_timeout(),
+                    call_display_dim_timeout()});
         });
 }
 

=== modified file 'src/server.h'
--- src/server.h	2015-08-26 08:26:35 +0000
+++ src/server.h	2015-09-25 12:02:53 +0000
@@ -132,6 +132,20 @@
             seconds{the_options()->get("notification-display-dim-timeout", 12)});
     }
 
+    std::chrono::milliseconds call_display_off_timeout()
+    {
+        using namespace std::chrono;
+        return duration_cast<milliseconds>(
+            seconds{the_options()->get("call-display-off-timeout", 60)});
+    }
+
+    std::chrono::milliseconds call_display_dim_timeout()
+    {
+        using namespace std::chrono;
+        return duration_cast<milliseconds>(
+            seconds{the_options()->get("call-display-dim-timeout", 50)});
+    }
+
     std::chrono::milliseconds shutdown_timeout()
     {
         return std::chrono::milliseconds{

=== modified file 'tests/unit-tests/test_mir_screen.cpp'
--- tests/unit-tests/test_mir_screen.cpp	2015-08-24 18:18:21 +0000
+++ tests/unit-tests/test_mir_screen.cpp	2015-09-25 12:02:53 +0000
@@ -182,6 +182,8 @@
     std::chrono::seconds const dimmer_timeout{50};
     std::chrono::seconds const notification_power_off_timeout{15};
     std::chrono::seconds const notification_dimmer_timeout{12};
+    std::chrono::seconds const call_power_off_timeout{30};
+    std::chrono::seconds const call_dimmer_timeout{25};
 
     std::chrono::seconds const five_seconds{5};
     std::chrono::seconds const ten_seconds{10};
@@ -224,6 +226,45 @@
         EXPECT_CALL(*screen_hardware, set_dim_backlight()).Times(0);
     }
 
+    void verify_proximity_enabled()
+    {
+        verify_and_clear_expectations();
+
+        if (screen_hardware->current_proximity == MockScreenHardware::Proximity::far)
+        {
+            expect_screen_is_turned_off();
+            cover_screen();
+            verify_and_clear_expectations();
+
+            expect_screen_is_turned_on();
+            uncover_screen();
+            verify_and_clear_expectations();
+        }
+
+        if (screen_hardware->current_proximity == MockScreenHardware::Proximity::near)
+        {
+            expect_screen_is_turned_on();
+            uncover_screen();
+            verify_and_clear_expectations();
+
+            expect_screen_is_turned_off();
+            cover_screen();
+            verify_and_clear_expectations();
+        }
+    }
+
+    void verify_proximity_disabled()
+    {
+        verify_and_clear_expectations();
+
+        expect_no_reconfiguration();
+        uncover_screen();
+        cover_screen();
+        uncover_screen();
+
+        verify_and_clear_expectations();
+    }
+
     void turn_screen_off()
     {
         using namespace testing;
@@ -234,6 +275,16 @@
         verify_and_clear_expectations();
     }
 
+    void turn_screen_on()
+    {
+        using namespace testing;
+        mir_screen.set_screen_power_mode(
+            MirPowerMode::mir_power_mode_on,
+            PowerStateChangeReason::power_key);
+
+        verify_and_clear_expectations();
+    }
+
     void receive_notification()
     {
         mir_screen.set_screen_power_mode(
@@ -242,6 +293,22 @@
         process_deferred_actions();
     }
 
+    void receive_call()
+    {
+        mir_screen.set_screen_power_mode(
+            MirPowerMode::mir_power_mode_on,
+            PowerStateChangeReason::snap_decision);
+        process_deferred_actions();
+    }
+
+    void receive_call_done()
+    {
+        mir_screen.set_screen_power_mode(
+            MirPowerMode::mir_power_mode_on,
+            PowerStateChangeReason::call_done);
+        process_deferred_actions();
+    }
+
     void cover_screen()
     {
         screen_hardware->set_proximity(MockScreenHardware::Proximity::near);
@@ -281,7 +348,8 @@
         timer,
         timer,
         {power_off_timeout, dimmer_timeout},
-        {notification_power_off_timeout, notification_dimmer_timeout}};
+        {notification_power_off_timeout, notification_dimmer_timeout},
+        {call_power_off_timeout, call_dimmer_timeout}};
 };
 
 }
@@ -848,3 +916,204 @@
                                      PowerStateChangeReason::proximity);
 
 }
+
+TEST_F(AMirScreen, turns_screen_off_after_call_timeout)
+{
+    turn_screen_off();
+
+    expect_screen_is_turned_on();
+    receive_call();
+    verify_and_clear_expectations();
+
+    expect_screen_is_turned_off();
+    timer->advance_by(call_power_off_timeout);
+}
+
+TEST_F(AMirScreen, keep_display_on_temporarily_overrides_call_timeout)
+{
+    turn_screen_off();
+
+    expect_screen_is_turned_on();
+    receive_call();
+    verify_and_clear_expectations();
+
+    // At T=20 we request a temporary keep display on (e.g. user has touched
+    // the screen)
+    timer->advance_by(ten_seconds);
+    timer->advance_by(ten_seconds);
+    mir_screen.keep_display_on_temporarily();
+
+    // At T=30 nothing should happen since keep display on temporarily
+    // has reset the timers (so the call timeout is overriden).
+    expect_no_reconfiguration();
+    timer->advance_by(ten_seconds);
+    verify_and_clear_expectations();
+
+    // At T=110 (50 + 60) the screen should turn off due to the normal
+    // inactivity timeout
+    expect_screen_is_turned_off();
+    timer->advance_by(fifty_seconds);
+}
+
+TEST_F(AMirScreen, does_not_turn_on_screen_when_call_arrives_with_phone_covered)
+{
+    turn_screen_off();
+    cover_screen();
+
+    expect_no_reconfiguration();
+    receive_call();
+}
+
+TEST_F(AMirScreen, enables_proximity_when_call_arrives)
+{
+    turn_screen_off();
+    cover_screen();
+
+    expect_no_reconfiguration();
+    receive_call();
+    verify_and_clear_expectations();
+
+    verify_proximity_enabled();
+}
+
+TEST_F(AMirScreen, cancels_proximity_handling_when_screen_is_turned_off_by_call_timeout)
+{
+    turn_screen_off();
+    cover_screen();
+
+    receive_call();
+    timer->advance_by(call_power_off_timeout);
+
+    verify_proximity_disabled();
+}
+
+TEST_F(AMirScreen, cancels_proximity_handling_when_screen_is_touched_after_call)
+{
+    turn_screen_off();
+
+    receive_call();
+    mir_screen.keep_display_on_temporarily();
+
+    verify_proximity_disabled();
+}
+
+TEST_F(AMirScreen, does_not_enable_proximity_handling_for_call_when_screen_is_already_on)
+{
+    expect_no_reconfiguration();
+    receive_call();
+    verify_and_clear_expectations();
+
+    verify_proximity_disabled();
+}
+
+TEST_F(AMirScreen, retains_proximity_handling_when_call_done_arrives_when_screen_is_off_after_call)
+{
+    turn_screen_off();
+    cover_screen();
+    receive_call();
+    receive_call_done();
+
+    verify_proximity_enabled();
+}
+
+TEST_F(AMirScreen,
+       turns_off_screen_and_proximity_soon_after_call_when_screen_not_covered)
+{
+    turn_screen_off();
+
+    // Call
+    receive_call();
+    timer->advance_by(ten_seconds);
+    receive_call_done();
+
+    verify_and_clear_expectations();
+
+    // After the notification timeout the screen should be off
+    // and proximity should be disabled
+    expect_screen_is_turned_off();
+    timer->advance_by(notification_power_off_timeout);
+
+    verify_proximity_disabled();
+}
+
+TEST_F(AMirScreen,
+       turns_proximity_off_soon_after_call_when_screen_covered)
+{
+    turn_screen_off();
+    cover_screen();
+
+    expect_no_reconfiguration();
+
+    // call
+    receive_call();
+    timer->advance_by(ten_seconds);
+    receive_call_done();
+    timer->advance_by(notification_power_off_timeout);
+
+    verify_and_clear_expectations();
+
+    verify_proximity_disabled();
+}
+
+TEST_F(AMirScreen,
+       turns_off_screen_and_proximity_soon_after_call_when_screen_uncovered_after_call_is_received)
+{
+    turn_screen_off();
+    cover_screen();
+
+    // Uncover screen while in call
+    receive_call();
+    timer->advance_by(five_seconds);
+    uncover_screen();
+    timer->advance_by(five_seconds);
+    receive_call_done();
+
+    verify_and_clear_expectations();
+
+    // After the notification timeout the screen should be off
+    // and proximity should be disabled
+    expect_screen_is_turned_off();
+    timer->advance_by(notification_power_off_timeout);
+
+    verify_proximity_disabled();
+}
+
+TEST_F(AMirScreen,
+      keeps_screen_on_for_full_timeout_after_call_received_when_screen_was_turned_on_manually)
+{
+    // Turn screen on manually (i.e. with power key)
+    turn_screen_off();
+    turn_screen_on();
+
+    expect_no_reconfiguration();
+
+    // call
+    receive_call();
+    timer->advance_by(ten_seconds);
+    receive_call_done();
+    // Call done notification timeout should be ignored since
+    // user had turned on the screen manually
+    timer->advance_by(notification_power_off_timeout);
+
+    verify_and_clear_expectations();
+
+    verify_proximity_disabled();
+}
+
+TEST_F(AMirScreen,
+       sets_normal_backlight_when_notification_arrives_while_screen_already_on)
+{
+    turn_screen_on();
+
+    EXPECT_CALL(*screen_hardware, set_normal_backlight());
+    receive_notification();
+}
+
+TEST_F(AMirScreen,
+       sets_normal_backlight_when_call_arrives_while_screen_already_on)
+{
+    turn_screen_on();
+
+    EXPECT_CALL(*screen_hardware, set_normal_backlight());
+    receive_call();
+}