Merge lp:~albaguirre/unity-system-compositor/screen-power-state-handling into lp:unity-system-compositor

[Alberto Aguirre]

Migrate display power state handling from powerd to usc

Migrate display power state handling from powerd to usc

This is mainly an effort to remove all input event processing from powerd. Since the mir server already handles input and manages display power states - any screen power state or inactivity timer logic is better suited to reside in USC.

Depends on:
https://code.launchpad.net/~albaguirre/powerd/remove-input-inactivity-handling/+merge/219449

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:127
http://jenkins.qa.ubuntu.com/job/unity-system-compositor-ci/99/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-trusty-amd64-ci/51
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-trusty-armhf-ci/51

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

review: Approve (continuous-integration)

[Ricardo Salveti (rsalveti)]

MR that exports the dim value:
https://code.launchpad.net/~rsalveti/powerd/export_dim_brightness_value/+merge/216805

To land this MR, besides the need of another clean-up in powerd (to remove the screen states), we also need a clear way for the apps to request something similar to the powerd display state (probably just asking display to be on/off). Do you know if we already have a dbus interface for that?

We also need to coordinate and land changes for all apps that are currently using the powerd requestDisplayState dbus api, as that will be removed as well.

[Alberto Aguirre (albaguirre)]

"we also need a clear way for the apps to request something similar to the powerd display state (probably just asking display to be on/off). Do you know if we already have a dbus interface for that?"

This MR keeps the com.canonical.Unity.Screen setScreenPowerMode Dbus interface to turn on/off the display.

[lp:~albaguirre/unity-system-compositor/screen-power-state-handling]

128. By Alberto Aguirre on 2014-04-25

Use powerd's dim value now that is exposed

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:128
http://jenkins.qa.ubuntu.com/job/unity-system-compositor-ci/104/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-trusty-amd64-ci/56/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-trusty-armhf-ci/56/console

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

review: Needs Fixing (continuous-integration)

[Ricardo Mendoza (ricmm)]

As mentioned in the email, we need to sync with Unity8 regarding long-press for the power button, as this MR as-is would always turn off on power key up.

Also introduced conflict text in:

715 +<<<<<<< TREE
716 ("public-socket", po::value<bool>(), "Make the socket file publicly writable")
717 ("power-off-delay", po::value<int>(), "Delay in milliseconds before powering off screen [int]")
718 ("enable-hardware-cursor", po::value<bool>(), "Enable the hardware cursor (disabled by default)");
719 +=======
720 + ("power-off-timeout", po::value<int>(), "The time in seconds before the screen is turned off when there are no active sessions")
721 + ("dimmer-timeout", po::value<int>(), "The time in seconds before the screen is dimmed when there are no active sessions")
722 + ("public-socket", po::value<bool>(), "Make the socket file publicly writable");
723 +>>>>>>> MERGE-SOURCE

review: Needs Information

[lp:~albaguirre/unity-system-compositor/screen-power-state-handling]

129. By Alberto Aguirre on 2014-05-02

merge main branch

130. By Alberto Aguirre on 2014-05-02

merge main branch

131. By Alberto Aguirre on 2014-05-13

Use mir timer support

Cleanup ScreenStateHandler
Make ScreenStateHandler state changes thread safe
Add long power key press detection
Emit DBus signal during after detecting long power press

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:131
http://jenkins.qa.ubuntu.com/job/unity-system-compositor-ci/107/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-utopic-amd64-ci/3/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-utopic-armhf-ci/3/console

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

review: Needs Fixing (continuous-integration)

[Alberto Aguirre (albaguirre)]

> As mentioned in the email, we need to sync with Unity8 regarding long-press
> for the power button, as this MR as-is would always turn off on power key up.
>
> Also introduced conflict text in:
>

Fixed the conflicts and implemented the long-press detection.

[lp:~albaguirre/unity-system-compositor/screen-power-state-handling]

132. By Alberto Aguirre on 2014-05-21

Remove emitting signal on long press of power key
Change default timeout for long press detection of power key to 5secs
Initiate a system shutdown when detecting long press of power key
Emit and accept reasons for display power state changes

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:132
http://jenkins.qa.ubuntu.com/job/unity-system-compositor-ci/108/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-utopic-amd64-ci/4/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-utopic-armhf-ci/4/console

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

review: Needs Fixing (continuous-integration)

[lp:~albaguirre/unity-system-compositor/screen-power-state-handling]

133. By Alberto Aguirre on 2014-05-21

Reset backlight to normal brightness when screen is already on and a power on state change is requested

134. By Alberto Aguirre on 2014-05-21

Remove powerkey dbus conf install step

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:134
http://jenkins.qa.ubuntu.com/job/unity-system-compositor-ci/109/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-utopic-amd64-ci/5/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-utopic-armhf-ci/5/console

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

review: Needs Fixing (continuous-integration)

[lp:~albaguirre/unity-system-compositor/screen-power-state-handling]

135. By Alberto Aguirre on 2014-05-21

Remove power key dbus conf install from debin install rules

136. By Alberto Aguirre on 2014-05-21

Add headers to source list

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:135
http://jenkins.qa.ubuntu.com/job/unity-system-compositor-ci/110/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-utopic-amd64-ci/6/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-utopic-armhf-ci/6/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:136
http://jenkins.qa.ubuntu.com/job/unity-system-compositor-ci/111/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-utopic-amd64-ci/7/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-utopic-armhf-ci/7/console

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

review: Needs Fixing (continuous-integration)

[lp:~albaguirre/unity-system-compositor/screen-power-state-handling]

137. By Alberto Aguirre on 2014-05-28

Avoid turning off display when power key is held on a short time.

The shell may want to show a dialog under such conditions.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:137
http://jenkins.qa.ubuntu.com/job/unity-system-compositor-ci/112/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-utopic-amd64-ci/8/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-utopic-armhf-ci/8/console

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

review: Needs Fixing (continuous-integration)

[lp:~albaguirre/unity-system-compositor/screen-power-state-handling]

138. By Alberto Aguirre on 2014-05-30

Add support for keeping display on

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:138
http://jenkins.qa.ubuntu.com/job/unity-system-compositor-ci/113/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-utopic-amd64-ci/9/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-utopic-armhf-ci/9/console

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

review: Needs Fixing (continuous-integration)

[lp:~albaguirre/unity-system-compositor/screen-power-state-handling]

139. By Alberto Aguirre on 2014-06-16

merge trunk

140. By Alberto Aguirre on 2014-06-16

Add console dbus access policy as in powerd

141. By Alberto Aguirre on 2014-06-16

Add some logging

142. By Alberto Aguirre on 2014-06-17

Proxy brightness and auto brightness parameters.

143. By Alberto Aguirre on 2014-06-17

fix auto_brightness state machine

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:143
http://jenkins.qa.ubuntu.com/job/unity-system-compositor-ci/116/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-utopic-amd64-ci/12
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-utopic-armhf-ci/12

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

review: Approve (continuous-integration)

[lp:~albaguirre/unity-system-compositor/screen-power-state-handling]

144. By Alberto Aguirre on 2014-06-17

Change default inactivity timeouts

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:144
http://jenkins.qa.ubuntu.com/job/unity-system-compositor-ci/117/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-utopic-amd64-ci/13
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-utopic-armhf-ci/13/console

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

review: Needs Fixing (continuous-integration)

[lp:~albaguirre/unity-system-compositor/screen-power-state-handling]

145. By Alberto Aguirre on 2014-06-17

Refactor backlight state machine

146. By Alberto Aguirre on 2014-06-17

Turn on screen when a keepDisplayOn request is received

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:146
http://jenkins.qa.ubuntu.com/job/unity-system-compositor-ci/118/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-utopic-amd64-ci/14
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-utopic-armhf-ci/14/console

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

review: Needs Fixing (continuous-integration)

[lp:~albaguirre/unity-system-compositor/screen-power-state-handling]

147. By Alberto Aguirre on 2014-06-17

Reset timers when changing timeout values.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:147
http://jenkins.qa.ubuntu.com/job/unity-system-compositor-ci/119/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-utopic-amd64-ci/15
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-utopic-armhf-ci/15/console

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

review: Needs Fixing (continuous-integration)

[Ricardo Salveti (rsalveti)]

Comments inline.

review: Needs Information

[Alberto Aguirre (albaguirre)]

Responded to inline comment.

[lp:~albaguirre/unity-system-compositor/screen-power-state-handling]

148. By Alberto Aguirre on 2014-06-19

merge trunk

149. By Alberto Aguirre on 2014-06-19

Use new create_alarm api

150. By Alberto Aguirre on 2014-06-19

Only start compositor when turning on screen.

With the new swap unblock solution in mir, its no longer necessary to start the compositor while the screen is off.

151. By Alberto Aguirre on 2014-06-19

Add powerd to Recommends

[PS Jenkins bot (ps-jenkins)]

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

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

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:151
http://jenkins.qa.ubuntu.com/job/unity-system-compositor-ci/121/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-utopic-amd64-ci/17
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-utopic-armhf-ci/17

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

review: Approve (continuous-integration)

[lp:~albaguirre/unity-system-compositor/screen-power-state-handling]

152. By Alberto Aguirre on 2014-06-20

merge trunk - fix simple conflict

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:152
http://jenkins.qa.ubuntu.com/job/unity-system-compositor-ci/123/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-utopic-amd64-ci/19
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-utopic-armhf-ci/19

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

review: Approve (continuous-integration)

[lp:~albaguirre/unity-system-compositor/screen-power-state-handling]

153. By Alberto Aguirre on 2014-06-20

Update changelog

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:153
http://jenkins.qa.ubuntu.com/job/unity-system-compositor-ci/124/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-utopic-amd64-ci/20
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-utopic-armhf-ci/20

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

review: Approve (continuous-integration)

[lp:~albaguirre/unity-system-compositor/screen-power-state-handling]

154. By Alberto Aguirre on 2014-06-23

Turn off screen during clean shutdown

[PS Jenkins bot (ps-jenkins)]

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

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

review: Approve (continuous-integration)

[lp:~albaguirre/unity-system-compositor/screen-power-state-handling]

155. By Alberto Aguirre on 2014-06-24

Add dbus watcher to wait for powerd to become available if its DBus interface is not available when usc starts.

[PS Jenkins bot (ps-jenkins)]

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

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

review: Approve (continuous-integration)

[Ricardo Mendoza (ricmm)]

Looks fine for me so far, I dont see any obvious issues in the code. Works as expected on device.

review: Approve

[Michael Terry (mterry)]

I didn't test all the features, since this has already been reviewed. But I wanted to give a few cents, comments inline using this fancy new LP feature.

[lp:~albaguirre/unity-system-compositor/screen-power-state-handling]

156. By Alberto Aguirre on 2014-06-25

Rename is_invalid_reason to avoid double negatives.

157. By Alberto Aguirre on 2014-06-25

Always watch for powerd interface restart

[PS Jenkins bot (ps-jenkins)]

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

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

review: Approve (continuous-integration)

[Michael Terry (mterry)]

Looks good to me, thanks!

review: Approve

=== modified file 'debian/changelog'
--- debian/changelog	2014-06-19 22:23:50 +0000
+++ debian/changelog	2014-06-25 14:46:51 +0000
@@ -1,3 +1,9 @@
+unity-system-compositor (0.0.4) UNRELEASED; urgency=medium
+
+  * Bump version due to new dbus interfaces 
+
+ -- Alberto Aguirre <[e-mail]>  Fri, 20 Jun 2014 14:49:31 -0500
+
 unity-system-compositor (0.0.3+14.10.20140619-0ubuntu1) utopic; urgency=low
 
   [ Michael Terry ]

=== modified file 'debian/control'
--- debian/control	2014-06-13 16:08:51 +0000
+++ debian/control	2014-06-25 14:46:51 +0000
@@ -36,6 +36,7 @@
 Architecture: any
 Depends: ${misc:Depends},
          ${shlibs:Depends},
+Recommends: powerd,
 Description: System compositor for Ubuntu
  System compositor used by the Mir display server in Ubuntu. If the Unity
  System Compositor can't start, LightDM will fallback to plain Xorg display

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2014-06-02 19:33:25 +0000
+++ src/CMakeLists.txt	2014-06-25 14:46:51 +0000
@@ -18,10 +18,15 @@
   main.cpp
   dbus_screen.cpp
   dbus_screen.h
+  powerd_mediator.cpp
   dm_connection.cpp
   dm_connection.h
   system_compositor.cpp
   system_compositor.h
+  screen_state_handler.cpp
+  screen_state_handler.h
+  powerkey_handler.cpp
+  powerkey_handler.h
 )
 
 qt5_generate_dbus_interface(dbus_screen.h com.canonical.Unity.Screen.xml)

=== modified file 'src/com.canonical.Unity.Screen.conf'
--- src/com.canonical.Unity.Screen.conf	2013-10-31 22:24:37 +0000
+++ src/com.canonical.Unity.Screen.conf	2014-06-25 14:46:51 +0000
@@ -14,4 +14,8 @@
 		       send_interface="org.freedesktop.DBus.Introspectable"/>
 	</policy>
 
+	<policy at_console="true">
+		<allow send_destination="com.canonical.Unity.Screen"/>
+	</policy>
+
 </busconfig>

=== modified file 'src/dbus_screen.cpp'
--- src/dbus_screen.cpp	2014-04-08 13:22:31 +0000
+++ src/dbus_screen.cpp	2014-06-25 14:46:51 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2013 Canonical Ltd.
+ * Copyright © 2013-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
@@ -16,70 +16,67 @@
 
 #include "dbus_screen.h"
 #include "dbus_screen_adaptor.h"
-
-#include <mir/compositor/compositor.h>
-#include <mir/default_server_configuration.h>
-#include <mir/graphics/display.h>
-#include <mir/graphics/display_configuration.h>
-
+#include "dbus_screen_observer.h"
+#include "power_state_change_reason.h"
+
+#include <atomic>
+#include <memory>
+#include <iostream>
+
+#include <QDBusMessage>
 #include <QDBusConnection>
+#include <QDBusServiceWatcher>
 #include <QDebug>
 
-namespace mc = mir::compositor;
-namespace mg = mir::graphics;
-
-static void set_screen_power_mode(MirPowerMode mode, const std::shared_ptr<mir::DefaultServerConfiguration>& config)
+bool is_valid_reason(int raw_reason)
 {
-    std::shared_ptr<mg::Display> display = config->the_display();
-    std::shared_ptr<mg::DisplayConfiguration> displayConfig = display->configuration();
-    std::shared_ptr<mc::Compositor> compositor = config->the_compositor();
-
-    displayConfig->for_each_output(
-        [&](const mg::UserDisplayConfigurationOutput displayConfigOutput) {
-            displayConfigOutput.power_mode=mode;
-        }
-    );
-
-    compositor->stop();
-    display->configure(*displayConfig.get());
-    compositor->start();
+    auto reason = static_cast<PowerStateChangeReason>(raw_reason);
+    switch (reason)
+    {
+    case PowerStateChangeReason::unknown:
+    case PowerStateChangeReason::inactivity:
+    case PowerStateChangeReason::power_key:
+    case PowerStateChangeReason::proximity:
+        return true;
+    }
+    return false;
 }
 
-// Note: this class should be created only after when the Mir DisplayServer has started
-DBusScreen::DBusScreen(std::shared_ptr<mir::DefaultServerConfiguration> config,
-                       int off_delay, QObject *parent)
+
+DBusScreen::DBusScreen(DBusScreenObserver& observer, QObject *parent)
     : QObject(parent),
-      config(config),
-      power_off_timer(off_delay > 0 ? new QTimer(this) : nullptr),
-      power_off_mode(MirPowerMode::mir_power_mode_off),
-      power_off_delay(off_delay)
-
+      dbus_adaptor{new DBusScreenAdaptor(this)},
+      service_watcher{new QDBusServiceWatcher()},
+      observer{&observer}
 {
-    new DBusScreenAdaptor(this);
     QDBusConnection bus = QDBusConnection::systemBus();
     bus.registerObject("/com/canonical/Unity/Screen", this);
     bus.registerService("com.canonical.Unity.Screen");
 
-    if (power_off_timer != nullptr) {
-        power_off_timer->setSingleShot(true);
-        connect(power_off_timer, SIGNAL(timeout()), this, SLOT(power_off()));
-    }
-}
-
-DBusScreen::~DBusScreen()
-{
-    delete power_off_timer;
-}
-
-bool DBusScreen::setScreenPowerMode(const QString &mode)
-{
+    service_watcher->setConnection(bus);
+    service_watcher->setWatchMode(QDBusServiceWatcher::WatchForUnregistration);
+
+    connect(service_watcher.get(),
+            SIGNAL(serviceUnregistered(QString const&)),
+            this, SLOT(remove_display_on_requestor(QString const&)));
+
+    //QT's ~QObject will release this child object
+    //so release ownership from the unique_ptr
+    dbus_adaptor.release();
+}
+
+DBusScreen::~DBusScreen() = default;
+
+bool DBusScreen::setScreenPowerMode(const QString &mode, int reason)
+{
+    if (!is_valid_reason(reason))
+        return false;
+
     MirPowerMode newPowerMode;
+
     // Note: the "standby" and "suspend" modes are mostly unused
-
     if (mode == "on") {
         newPowerMode = MirPowerMode::mir_power_mode_on;
-        if (power_off_timer != nullptr && power_off_timer->isActive())
-            power_off_timer->stop();
     } else if (mode == "standby") {
         newPowerMode = MirPowerMode::mir_power_mode_standby; // higher power "off" mode (fastest resume)
     } else if (mode == "suspend") {
@@ -91,17 +88,81 @@
         return false;
     }
 
-    if ((newPowerMode != MirPowerMode::mir_power_mode_on) && (power_off_timer != nullptr)) {
-        power_off_mode = newPowerMode;
-        power_off_timer->start(power_off_delay);
-    } else {
-        set_screen_power_mode(newPowerMode, config);
-    }
+    observer->set_screen_power_mode(newPowerMode, static_cast<PowerStateChangeReason>(reason));
 
     return true;
 }
 
-void DBusScreen::power_off()
-{
-    set_screen_power_mode(power_off_mode, config);
+void DBusScreen::emit_power_state_change(MirPowerMode power_mode, PowerStateChangeReason reason)
+{
+    QDBusMessage message =  QDBusMessage::createSignal("/com/canonical/Unity/Screen",
+        "com.canonical.Unity.Screen", "DisplayPowerStateChange");
+
+    int power_state = (power_mode == MirPowerMode::mir_power_mode_off) ? 0 : 1;
+
+    QVariant state(power_state);
+    QList<QVariant> arguments;
+    arguments.append(state);
+    arguments.append(static_cast<int>(reason));
+    message.setArguments(arguments);
+
+    QDBusConnection bus = QDBusConnection::systemBus();
+    bus.send(message);
+}
+
+int DBusScreen::keepDisplayOn()
+{
+    static std::atomic<uint32_t> request_id{0};
+
+    int id = request_id.fetch_add(1);
+    observer->keep_display_on(true);
+
+    auto const& caller = message().service();
+    auto& caller_requests = display_requests[caller.toStdString()];
+
+    if (caller_requests.size() == 0)
+        service_watcher->addWatchedService(caller);
+
+    caller_requests.insert(id);
+    std::cerr << "keepDisplayOn request id:" << id;
+    std::cerr << " requested by \"" << caller.toStdString() << "\"" << std::endl;
+    return id;
+}
+
+void DBusScreen::removeDisplayOnRequest(int cookie)
+{
+    auto const& requestor = message().service();
+
+    auto it = display_requests.find(requestor.toStdString());
+    if (it == display_requests.end())
+        return;
+
+    std::cerr << "removeDisplayOnRequest id:" << cookie;
+    std::cerr << " requested by \"" << requestor.toStdString() << "\"" << std::endl;
+
+    auto caller_requests = it->second;
+    caller_requests.erase(cookie);
+    if (caller_requests.size() == 0)
+        remove_display_on_requestor(requestor);
+}
+
+void DBusScreen::remove_display_on_requestor(QString const& requestor)
+{
+    std::cerr << "remove_display_on_requestor \"" << requestor.toStdString() << "\"";
+    std::cerr << std::endl;
+
+    display_requests.erase(requestor.toStdString());
+    service_watcher->removeWatchedService(requestor);
+    if (display_requests.size() == 0)
+        observer->keep_display_on(false);
+}
+
+void DBusScreen::setUserBrightness(int brightness)
+{
+    observer->set_brightness(brightness);
+}
+
+void DBusScreen::userAutobrightnessEnable(bool enable)
+{
+    observer->enable_auto_brightness(enable);
 }

=== modified file 'src/dbus_screen.h'
--- src/dbus_screen.h	2014-02-26 06:23:05 +0000
+++ src/dbus_screen.h	2014-06-25 14:46:51 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2013 Canonical Ltd.
+ * Copyright © 2013-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
@@ -20,35 +20,47 @@
 #include <mir_toolkit/common.h>
 
 #include <memory>
+#include <unordered_map>
+#include <unordered_set>
+
 #include <QObject>
 #include <QtCore>
-
-namespace mir
-{
-    class DefaultServerConfiguration;
-}
-
-class DBusScreen : public QObject
+#include <QDBusContext>
+
+class DBusScreenAdaptor;
+class DBusScreenObserver;
+class QDBusInterface;
+class QDBusServiceWatcher;
+enum class PowerStateChangeReason;
+
+class DBusScreen : public QObject, protected QDBusContext
 {
     Q_OBJECT
     Q_CLASSINFO("D-Bus Interface", "com.canonical.Unity.Screen")
 
 public:
-    explicit DBusScreen(std::shared_ptr<mir::DefaultServerConfiguration> config,
-                        int off_delay, QObject *parent = 0);
+    explicit DBusScreen(DBusScreenObserver& observer, QObject *parent = 0);
     virtual ~DBusScreen();
 
+    void emit_power_state_change(MirPowerMode mode, PowerStateChangeReason reason);
+
 public Q_SLOTS:
-    bool setScreenPowerMode(const QString &mode);
+    bool setScreenPowerMode(const QString &mode, int reason);
+    int keepDisplayOn();
+    void removeDisplayOnRequest(int id);
+
+    //TODO: Expose same DBus powerd interface for now
+    void setUserBrightness(int brightness);
+    void userAutobrightnessEnable(bool enable);
 
 private Q_SLOTS:
-    void power_off();
+    void remove_display_on_requestor(QString const& requestor);
 
 private:
-    std::shared_ptr<mir::DefaultServerConfiguration> config;
-    QTimer *power_off_timer;
-    MirPowerMode power_off_mode;
-    int power_off_delay;
+    std::unique_ptr<DBusScreenAdaptor> dbus_adaptor;
+    std::unique_ptr<QDBusServiceWatcher> service_watcher;
+    std::unordered_map<std::string, std::unordered_set<int>> display_requests;
+    DBusScreenObserver* const observer;
 };
 
 #endif /* DBUS_SCREEN_H_ */

=== added file 'src/dbus_screen_observer.h'
--- src/dbus_screen_observer.h	1970-01-01 00:00:00 +0000
+++ src/dbus_screen_observer.h	2014-06-25 14:46:51 +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/>.
+ */
+
+#ifndef DBUS_SCREEN_OBSERVER_H_
+#define DBUS_SCREEN_OBSERVER_H_
+
+enum class PowerStateChangeReason;
+
+class DBusScreenObserver
+{
+public:
+    virtual ~DBusScreenObserver() = default;
+
+    virtual void set_screen_power_mode(MirPowerMode mode, PowerStateChangeReason reason) = 0;
+    virtual void keep_display_on(bool on) = 0;
+    virtual void set_brightness(int brightness) = 0;
+    virtual void enable_auto_brightness(bool enable) = 0;
+
+protected:
+    DBusScreenObserver() = default;
+    DBusScreenObserver(const DBusScreenObserver&) = delete;
+    DBusScreenObserver& operator=(const DBusScreenObserver&) = delete;
+};
+
+#endif

=== added file 'src/power_state_change_reason.h'
--- src/power_state_change_reason.h	1970-01-01 00:00:00 +0000
+++ src/power_state_change_reason.h	2014-06-25 14:46:51 +0000
@@ -0,0 +1,28 @@
+/*
+ * 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/>.
+ */
+
+#ifndef POWER_STATE_CHANGE_REASON_H_
+#define POWER_STATE_CHANGE_REASON_H_
+
+enum class PowerStateChangeReason
+{
+    unknown = 0,
+    inactivity = 1,
+    power_key = 2,
+    proximity = 3
+};
+
+#endif

=== added file 'src/powerd_mediator.cpp'
--- src/powerd_mediator.cpp	1970-01-01 00:00:00 +0000
+++ src/powerd_mediator.cpp	2014-06-25 14:46:51 +0000
@@ -0,0 +1,236 @@
+/*
+ * 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/>.
+ */
+
+#include "powerd_mediator.h"
+
+#include <QDBusConnection>
+#include <QDBusInterface>
+#include <QDBusReply>
+#include <QDBusMetaType>
+#include <QDBusArgument>
+#include <QDBusServiceWatcher>
+
+#include <iostream>
+
+/* Struct for reply to getBrightnessParams DBus call */
+struct BrightnessParams
+ {
+    int dim_brightness;
+    int min_brightness;
+    int max_brightness;
+    int default_brightness;
+    bool auto_brightness_supported;
+};
+Q_DECLARE_METATYPE(BrightnessParams);
+
+/* Not used but required by qDBusRegisterMetaType*/
+QDBusArgument &operator<<(QDBusArgument &argument, const BrightnessParams &mystruct)
+{
+    argument.beginStructure();
+    argument << mystruct.dim_brightness <<
+                mystruct.min_brightness <<
+                mystruct.max_brightness <<
+                mystruct.default_brightness <<
+                mystruct.auto_brightness_supported;
+    argument.endStructure();
+    return argument;
+}
+
+/* Needed to un-marshall powerd response */
+const QDBusArgument &operator>>(const QDBusArgument &argument, BrightnessParams &mystruct)
+{
+    argument.beginStructure();
+    argument >> mystruct.dim_brightness >>
+                mystruct.min_brightness >>
+                mystruct.max_brightness >>
+                mystruct.default_brightness >>
+                mystruct.auto_brightness_supported;
+    argument.endStructure();
+    return argument;
+}
+
+PowerdMediator::PowerdMediator()
+    : dim_brightness{10},
+      normal_brightness{102},
+      current_brightness{0},
+      min_brightness_{10},
+      max_brightness_{102},
+      auto_brightness_supported_{false},
+      auto_brightness_requested{false},
+      backlight_state{BacklightState::normal},
+      acquired_sys_state{false},
+      powerd_interface{new QDBusInterface("com.canonical.powerd",
+          "/com/canonical/powerd", "com.canonical.powerd", QDBusConnection::systemBus())},
+      service_watcher{new QDBusServiceWatcher("com.canonical.powerd",
+          QDBusConnection::systemBus(), QDBusServiceWatcher::WatchForRegistration)}
+{
+    qDBusRegisterMetaType<BrightnessParams>();
+
+    if (powerd_interface->isValid())
+    {
+        init_brightness_params();
+    }
+    //Powerd interface may not be available right now or it may restart in the future
+    //watch for changes so brightness params get initialized to the most recent values.
+    connect(service_watcher.get(),
+            SIGNAL(serviceRegistered(QString const&)),
+            this, SLOT(powerd_registered()));
+}
+
+PowerdMediator::~PowerdMediator() = default;
+
+void PowerdMediator::set_dim_backlight()
+{
+    change_backlight_state(BacklightState::dim);
+}
+
+void PowerdMediator::set_normal_backlight()
+{
+    if (auto_brightness_requested)
+        change_backlight_state(BacklightState::automatic);
+    else
+        change_backlight_state(BacklightState::normal);
+}
+
+void PowerdMediator::turn_off_backlight()
+{
+    change_backlight_state(BacklightState::off);
+}
+
+void PowerdMediator::change_backlight_values(int dim, int normal)
+{
+    if (normal >= min_brightness_ && normal <= max_brightness_)
+        normal_brightness = normal;
+    if (dim >= min_brightness_ && dim <= max_brightness_)
+        dim_brightness = dim;
+}
+
+void PowerdMediator::enable_auto_brightness(bool enable)
+{
+    auto_brightness_requested = enable;
+    if (auto_brightness_supported_ && enable)
+        change_backlight_state(BacklightState::automatic);
+    else
+        change_backlight_state(BacklightState::normal);
+}
+
+bool PowerdMediator::auto_brightness_supported()
+{
+    return auto_brightness_supported_;
+}
+
+int PowerdMediator::min_brightness()
+{
+    return min_brightness_;
+}
+
+int PowerdMediator::max_brightness()
+{
+    return max_brightness_;
+}
+
+void PowerdMediator::powerd_registered()
+{
+    init_brightness_params();
+}
+
+void PowerdMediator::set_brightness(int brightness)
+{
+    normal_brightness = brightness;
+
+    if (backlight_state != BacklightState::automatic)
+        powerd_interface->call("setUserBrightness", brightness);
+}
+
+void PowerdMediator::change_backlight_state(BacklightState new_state)
+{
+    if (backlight_state == new_state)
+        return;
+
+    if (new_state == BacklightState::automatic)
+    {
+        powerd_interface->call("userAutobrightnessEnable", true);
+        backlight_state = BacklightState::automatic;
+        return;
+    }
+
+    switch (new_state)
+    {
+        case BacklightState::normal:
+            current_brightness = normal_brightness;
+            break;
+        case BacklightState::off:
+            current_brightness = 0;
+            break;
+        case BacklightState::dim:
+            current_brightness = dim_brightness;
+            break;
+        default:
+            std::cerr << "unknown backlight state" << std::endl;
+            break;
+    }
+
+    powerd_interface->call("setUserBrightness", current_brightness);
+    backlight_state = new_state;
+}
+
+void PowerdMediator::set_sys_state_for(MirPowerMode mode)
+{
+    if (mode == MirPowerMode::mir_power_mode_off)
+        release_sys_state();
+    else
+        acquire_sys_state();
+}
+
+void PowerdMediator::release_sys_state()
+{
+    if (acquired_sys_state)
+        powerd_interface->call("clearSysState", sys_state_cookie);
+    acquired_sys_state = false;
+}
+
+void PowerdMediator::acquire_sys_state()
+{
+    if (!acquired_sys_state)
+    {
+        QDBusReply<QString> reply = powerd_interface->call("requestSysState", "com.canonical.Unity.Screen", 1);
+        if (reply.isValid())
+        {
+            sys_state_cookie = reply.value();
+            acquired_sys_state = true;
+        }
+    }
+}
+
+void PowerdMediator::init_brightness_params()
+{
+    QDBusReply<BrightnessParams> reply = powerd_interface->call("getBrightnessParams");
+    if (reply.isValid())
+    {
+        auto const& params = reply.value();
+        dim_brightness = params.dim_brightness;
+        normal_brightness = params.default_brightness;
+        min_brightness_ = params.min_brightness;
+        max_brightness_ = params.max_brightness;
+        auto_brightness_supported_ = params.auto_brightness_supported;
+        std::cerr << "initialized brightness parameters" << std::endl;
+    }
+    else
+    {
+        std::cerr << "getBrightnessParams call failed with: ";
+        std::cerr << reply.error().message().toStdString() << std::endl;
+    }
+}

=== added file 'src/powerd_mediator.h'
--- src/powerd_mediator.h	1970-01-01 00:00:00 +0000
+++ src/powerd_mediator.h	2014-06-25 14:46:51 +0000
@@ -0,0 +1,87 @@
+/*
+ * 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/>.
+ */
+
+#ifndef POWERD_MEDIATOR_
+#define POWERD_MEDIATOR_
+
+#include <mir_toolkit/common.h>
+
+#include <QString>
+#include <QObject>
+
+#include <memory>
+#include <mutex>
+
+class QDBusInterface;
+class QDBusServiceWatcher;
+
+/*
+ * A Proxy to powerd. Note this class is not thread-safe,
+ * synchronization should be done externally.
+ */
+class PowerdMediator : public QObject
+{
+    Q_OBJECT
+public:
+    PowerdMediator();
+    ~PowerdMediator();
+
+    void set_dim_backlight();
+    void set_normal_backlight();
+    void turn_off_backlight();
+    void set_sys_state_for(MirPowerMode mode);
+
+    void change_backlight_values(int dim_brightness, int normal_brightness);
+    void enable_auto_brightness(bool flag);
+
+    bool auto_brightness_supported();
+    int min_brightness();
+    int max_brightness();
+
+    void set_brightness(int brightness);
+
+private Q_SLOTS:
+    void powerd_registered();
+
+private:
+    enum BacklightState
+    {
+        off,
+        dim,
+        normal,
+        automatic
+    };
+    void change_backlight_state(BacklightState state);
+    void release_sys_state();
+    void acquire_sys_state();
+    void init_brightness_params();
+
+    int dim_brightness;
+    int normal_brightness;
+    int current_brightness;
+    int min_brightness_;
+    int max_brightness_;
+    bool auto_brightness_supported_;
+    bool auto_brightness_requested;
+    BacklightState backlight_state;
+
+    QString sys_state_cookie;
+    bool acquired_sys_state;
+
+    std::unique_ptr<QDBusInterface> powerd_interface;
+    std::unique_ptr<QDBusServiceWatcher> service_watcher;
+};
+#endif

=== added file 'src/powerkey_handler.cpp'
--- src/powerkey_handler.cpp	1970-01-01 00:00:00 +0000
+++ src/powerkey_handler.cpp	2014-06-25 14:46:51 +0000
@@ -0,0 +1,84 @@
+/*
+ * 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/>.
+ */
+
+#include "powerkey_handler.h"
+#include "screen_state_handler.h"
+#include "power_state_change_reason.h"
+
+#include <mir/time/timer.h>
+
+#include <cstdio>
+#include "dbus_screen.h"
+#include "powerd_mediator.h"
+
+namespace mi = mir::input;
+
+PowerKeyHandler::PowerKeyHandler(mir::time::Timer& timer,
+                                 std::chrono::milliseconds power_key_ignore_timeout,
+                                 std::chrono::milliseconds shutdown_timeout,
+                                 ScreenStateHandler& screen_state_handler)
+    : long_press_detected{false},
+      screen_state_handler{&screen_state_handler},
+      power_key_ignore_timeout{power_key_ignore_timeout},
+      shutdown_timeout{shutdown_timeout},
+      shutdown_alarm{timer.create_alarm([this]{ shutdown_alarm_notification(); })},
+      long_press_alarm{timer.create_alarm([this]{ long_press_detected = true; })}
+{
+}
+
+PowerKeyHandler::~PowerKeyHandler() = default;
+
+bool PowerKeyHandler::handle(MirEvent const& event)
+{
+    static const int32_t POWER_KEY_CODE = 26;
+
+    if (event.type == mir_event_type_key &&
+        event.key.key_code == POWER_KEY_CODE)
+    {
+        if (event.key.action == mir_key_action_down)
+            power_key_down();
+        else if (event.key.action == mir_key_action_up)
+            power_key_up();
+    }
+    return false;
+}
+
+void PowerKeyHandler::power_key_down()
+{
+    std::lock_guard<std::mutex> lock{guard};
+    screen_state_handler->enable_inactivity_timers(false);
+    long_press_detected = false;
+    long_press_alarm->reschedule_in(power_key_ignore_timeout);
+    shutdown_alarm->reschedule_in(shutdown_timeout);
+}
+
+void PowerKeyHandler::power_key_up()
+{
+    std::lock_guard<std::mutex> lock{guard};
+    shutdown_alarm->cancel();
+    long_press_alarm->cancel();
+    if (!long_press_detected)
+    {
+        screen_state_handler->toggle_screen_power_mode(PowerStateChangeReason::power_key);
+    }
+}
+
+void PowerKeyHandler::shutdown_alarm_notification()
+{
+    screen_state_handler->set_screen_power_mode(
+        MirPowerMode::mir_power_mode_off, PowerStateChangeReason::power_key);
+    system("shutdown -P now");
+}

=== added file 'src/powerkey_handler.h'
--- src/powerkey_handler.h	1970-01-01 00:00:00 +0000
+++ src/powerkey_handler.h	2014-06-25 14:46:51 +0000
@@ -0,0 +1,69 @@
+/*
+ * 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/>.
+ */
+
+#ifndef POWERKEY_HANDLER_H_
+#define POWERKEY_HANDLER_H_
+
+#include "mir/input/event_filter.h"
+
+#include <mutex>
+#include <memory>
+#include <atomic>
+#include <chrono>
+
+namespace mir
+{
+class DefaultServerConfiguration;
+namespace time
+{
+class Alarm;
+class Timer;
+}
+}
+
+class ScreenStateHandler;
+
+class PowerKeyHandler : public mir::input::EventFilter
+{
+public:
+    PowerKeyHandler(mir::time::Timer& timer,
+                    std::chrono::milliseconds power_key_ignore_timeout,
+                    std::chrono::milliseconds shutdown_timeout,
+                    ScreenStateHandler& screen_state_handler);
+
+    ~PowerKeyHandler();
+
+    bool handle(MirEvent const& event) override;
+
+private:
+    void power_key_up();
+    void power_key_down();
+    void shutdown_alarm_notification();
+
+    std::mutex guard;
+    std::atomic<bool> long_press_detected;
+
+    ScreenStateHandler* screen_state_handler;
+
+    std::chrono::milliseconds power_key_ignore_timeout;
+    std::chrono::milliseconds shutdown_timeout;
+
+    std::unique_ptr<mir::time::Alarm> shutdown_alarm;
+    std::unique_ptr<mir::time::Alarm> long_press_alarm;
+
+};
+
+#endif

=== added file 'src/screen_state_handler.cpp'
--- src/screen_state_handler.cpp	1970-01-01 00:00:00 +0000
+++ src/screen_state_handler.cpp	2014-06-25 14:46:51 +0000
@@ -0,0 +1,201 @@
+/*
+ * 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/>.
+ */
+
+#include "screen_state_handler.h"
+
+#include <mir/main_loop.h>
+#include <mir/time/timer.h>
+#include <mir/compositor/compositor.h>
+#include <mir/default_server_configuration.h>
+#include <mir/graphics/display.h>
+#include <mir/graphics/display_configuration.h>
+
+#include <cstdio>
+#include "dbus_screen.h"
+#include "dbus_screen_observer.h"
+#include "powerd_mediator.h"
+#include "power_state_change_reason.h"
+
+namespace mi = mir::input;
+namespace mc = mir::compositor;
+namespace mg = mir::graphics;
+
+ScreenStateHandler::ScreenStateHandler(std::shared_ptr<mir::DefaultServerConfiguration> const& config,
+                                       std::chrono::milliseconds power_off_timeout,
+                                       std::chrono::milliseconds dimmer_timeout)
+    : current_power_mode{MirPowerMode::mir_power_mode_on},
+      restart_timers{true},
+      power_off_timeout{power_off_timeout},
+      dimming_timeout{dimmer_timeout},
+      powerd_mediator{new PowerdMediator()},
+      config{config},
+      power_off_alarm{config->the_main_loop()->notify_in(power_off_timeout,
+          std::bind(&ScreenStateHandler::power_off_alarm_notification, this))},
+      dimmer_alarm{config->the_main_loop()->notify_in(dimming_timeout,
+          std::bind(&ScreenStateHandler::dimmer_alarm_notification, this))},
+      dbus_screen{new DBusScreen(*this)}
+{
+}
+
+ScreenStateHandler::~ScreenStateHandler() = default;
+
+bool ScreenStateHandler::handle(MirEvent const& event)
+{
+    if (event.type == mir_event_type_motion)
+    {
+        std::lock_guard<std::mutex> lock{guard};
+        reset_timers_l();
+        powerd_mediator->set_normal_backlight();
+    }
+    return false;
+}
+
+void ScreenStateHandler::set_timeouts(std::chrono::milliseconds the_power_off_timeout,
+                                      std::chrono::milliseconds the_dimming_timeout)
+{
+    std::lock_guard<std::mutex> lock{guard};
+    power_off_timeout = the_power_off_timeout;
+    dimming_timeout = the_dimming_timeout;
+    reset_timers_l();
+}
+
+void ScreenStateHandler::enable_inactivity_timers(bool enable)
+{
+    std::lock_guard<std::mutex> lock{guard};
+    enable_inactivity_timers_l(enable);
+}
+
+void ScreenStateHandler::toggle_screen_power_mode(PowerStateChangeReason reason)
+{
+    std::lock_guard<std::mutex> lock{guard};
+    MirPowerMode new_mode = (current_power_mode == MirPowerMode::mir_power_mode_on) ?
+            MirPowerMode::mir_power_mode_off : MirPowerMode::mir_power_mode_on;
+
+    set_screen_power_mode_l(new_mode, reason);
+}
+
+void ScreenStateHandler::set_screen_power_mode(MirPowerMode mode, PowerStateChangeReason reason)
+{
+    std::lock_guard<std::mutex> lock{guard};
+    set_screen_power_mode_l(mode, reason);
+}
+
+void ScreenStateHandler::keep_display_on(bool on)
+{
+    std::lock_guard<std::mutex> lock{guard};
+    restart_timers = !on;
+    enable_inactivity_timers_l(!on);
+
+    if (on)
+        set_screen_power_mode_l(MirPowerMode::mir_power_mode_on, PowerStateChangeReason::unknown);
+}
+
+void ScreenStateHandler::set_brightness(int brightness)
+{
+    std::lock_guard<std::mutex> lock{guard};
+    powerd_mediator->set_brightness(brightness);
+}
+
+void ScreenStateHandler::enable_auto_brightness(bool enable)
+{
+    std::lock_guard<std::mutex> lock{guard};
+    powerd_mediator->enable_auto_brightness(enable);
+}
+
+void ScreenStateHandler::set_screen_power_mode_l(MirPowerMode mode, PowerStateChangeReason reason)
+{
+    if (mode == MirPowerMode::mir_power_mode_on)
+    {
+        /* The screen may be dim, but on - make sure to reset backlight */
+        if (current_power_mode == MirPowerMode::mir_power_mode_on)
+            powerd_mediator->set_normal_backlight();
+        configure_display_l(mode, reason);
+        reset_timers_l();
+    }
+    else
+    {
+        cancel_timers_l();
+        configure_display_l(mode, reason);
+    }
+}
+
+void ScreenStateHandler::configure_display_l(MirPowerMode mode, PowerStateChangeReason reason)
+{
+    if (current_power_mode == mode)
+        return;
+
+    std::shared_ptr<mg::Display> display = config->the_display();
+    std::shared_ptr<mg::DisplayConfiguration> displayConfig = display->configuration();
+    std::shared_ptr<mc::Compositor> compositor = config->the_compositor();
+
+    displayConfig->for_each_output(
+        [&](const mg::UserDisplayConfigurationOutput displayConfigOutput) {
+            displayConfigOutput.power_mode = mode;
+        }
+    );
+
+    compositor->stop();
+    display->configure(*displayConfig.get());
+
+    if (mode == MirPowerMode::mir_power_mode_on)
+    {
+        compositor->start();
+        powerd_mediator->set_normal_backlight();
+    }
+    else
+    {
+        powerd_mediator->turn_off_backlight();
+    }
+
+    current_power_mode = mode;
+    powerd_mediator->set_sys_state_for(mode);
+    dbus_screen->emit_power_state_change(mode, reason);
+}
+
+void ScreenStateHandler::cancel_timers_l()
+{
+    power_off_alarm->cancel();
+    dimmer_alarm->cancel();
+}
+
+void ScreenStateHandler::reset_timers_l()
+{
+    if (restart_timers && current_power_mode != MirPowerMode::mir_power_mode_off)
+    {
+        power_off_alarm->reschedule_in(power_off_timeout);
+        dimmer_alarm->reschedule_in(dimming_timeout);
+    }
+}
+
+void ScreenStateHandler::enable_inactivity_timers_l(bool enable)
+{
+    if (enable)
+        reset_timers_l();
+    else
+        cancel_timers_l();
+}
+
+void ScreenStateHandler::power_off_alarm_notification()
+{
+    std::lock_guard<std::mutex> lock{guard};
+    configure_display_l(MirPowerMode::mir_power_mode_off, PowerStateChangeReason::inactivity);
+}
+
+void ScreenStateHandler::dimmer_alarm_notification()
+{
+    std::lock_guard<std::mutex> lock{guard};
+    powerd_mediator->set_dim_backlight();
+}

=== added file 'src/screen_state_handler.h'
--- src/screen_state_handler.h	1970-01-01 00:00:00 +0000
+++ src/screen_state_handler.h	2014-06-25 14:46:51 +0000
@@ -0,0 +1,92 @@
+/*
+ * 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/>.
+ */
+
+#ifndef SCREEN_STATE_HANDLER_
+#define SCREEN_STATE_HANDLER_
+
+#include "mir/input/event_filter.h"
+#include "dbus_screen_observer.h"
+
+#include <chrono>
+#include <memory>
+#include <mutex>
+
+class DBusScreen;
+class PowerdMediator;
+enum class PowerStateChangeReason;
+
+namespace mir
+{
+class DefaultServerConfiguration;
+namespace time
+{
+class Alarm;
+class Timer;
+}
+}
+
+class ScreenStateHandler: public mir::input::EventFilter, public DBusScreenObserver
+{
+public:
+    ScreenStateHandler(std::shared_ptr<mir::DefaultServerConfiguration> const& config,
+                       std::chrono::milliseconds power_off_timeout,
+                       std::chrono::milliseconds dimmer_timeout);
+    virtual ~ScreenStateHandler();
+
+    //from EventFilter
+    bool handle(MirEvent const& event) override;
+
+    void set_timeouts(std::chrono::milliseconds power_off_timeout,
+                      std::chrono::milliseconds dimmer_timeout);
+
+    void enable_inactivity_timers(bool enable);
+    void toggle_screen_power_mode(PowerStateChangeReason reason);
+
+    void set_screen_power_mode(MirPowerMode mode, PowerStateChangeReason reason) override;
+    void keep_display_on(bool on) override;
+    void set_brightness(int brightness) override;
+    void enable_auto_brightness(bool enable) override;
+
+private:
+    void set_screen_power_mode_l(MirPowerMode mode, PowerStateChangeReason reason);
+    void configure_display_l(MirPowerMode mode, PowerStateChangeReason reason);
+
+    void cancel_timers_l();
+    void reset_timers_l();
+    void enable_inactivity_timers_l(bool flag);
+
+    void power_off_alarm_notification();
+    void dimmer_alarm_notification();
+    void long_press_alarm_notification();
+
+    std::mutex guard;
+
+    MirPowerMode current_power_mode;
+    bool restart_timers;
+
+    std::chrono::milliseconds power_off_timeout;
+    std::chrono::milliseconds dimming_timeout;
+
+    std::unique_ptr<PowerdMediator> powerd_mediator;
+    std::shared_ptr<mir::DefaultServerConfiguration> config;
+
+    std::unique_ptr<mir::time::Alarm> power_off_alarm;
+    std::unique_ptr<mir::time::Alarm> dimmer_alarm;
+
+    std::unique_ptr<DBusScreen> dbus_screen;
+};
+
+#endif

=== modified file 'src/system_compositor.cpp'
--- src/system_compositor.cpp	2014-06-19 22:03:22 +0000
+++ src/system_compositor.cpp	2014-06-25 14:46:51 +0000
@@ -16,8 +16,15 @@
  * Authored by: Robert Ancell <[e-mail]>
  */
 
-#include "dbus_screen.h"
+
 #include "system_compositor.h"
+#include "screen_state_handler.h"
+#include "powerkey_handler.h"
+
+// Qt headers will introduce a #define of "signals"
+// but some mir headers use "signals" as a variable name in
+// method declarations
+#undef signals
 
 #include <mir/run_mir.h>
 #include <mir/abnormal_exit.h>
@@ -31,6 +38,8 @@
 #include <mir/server_status_listener.h>
 #include <mir/shell/focus_controller.h>
 #include <mir/input/cursor_listener.h>
+#include <mir/input/composite_event_filter.h>
+#include <mir/main_loop.h>
 
 #include <cerrno>
 #include <iostream>
@@ -499,11 +508,26 @@
         return the_options()->is_set("version");
     }
 
-    int power_off_delay()
-    {
-        return the_options()->get("power-off-delay", 0);
-    }
-    
+    int inactivity_display_off_timeout()
+    {
+       return the_options()->get("inactivity-display-off-timeout", 60);
+    }
+
+    int inactivity_display_dim_timeout()
+    {
+       return the_options()->get("inactivity-display-dim-timeout", 45);
+    }
+
+    int shutdown_timeout()
+    {
+       return the_options()->get("shutdown-timeout", 5000);
+    }
+
+    int power_key_ignore_timeout()
+    {
+       return the_options()->get("power-key-ignore-timeout", 1500);
+    }
+
     bool enable_hardware_cursor()
     {
         return the_options()->get("enable-hardware-cursor", false);
@@ -538,7 +562,7 @@
             {
             }
         };
-        
+
         // This is a workaround for u8 desktop preview in 14.04 for the lack of client cursor API.
         // We need to disable the cursor for XMir but leave it on for the desktop preview.
         // Luckily as it stands they run inside seperate instances of USC. ~racarr
@@ -633,8 +657,11 @@
             ("version", "Show version of Unity System Compositor")
             ("spinner", po::value<std::string>(), "Path to spinner executable")
             ("public-socket", po::value<bool>(), "Make the socket file publicly writable")
-            ("power-off-delay", po::value<int>(), "Delay in milliseconds before powering off screen [int]")
-            ("enable-hardware-cursor", po::value<bool>(), "Enable the hardware cursor (disabled by default)");
+            ("enable-hardware-cursor", po::value<bool>(), "Enable the hardware cursor (disabled by default)")
+            ("inactivity-display-off-timeout", po::value<int>(), "The time in seconds before the screen is turned off when there are no active sessions")
+            ("inactivity-display-dim-timeout", po::value<int>(), "The time in seconds before the screen is dimmed when there are no active sessions")
+            ("shutdown-timeout", po::value<int>(), "The time in milli-seconds the power key must be held to initiate a clean system shutdown")
+            ("power-key-ignore-timeout", po::value<int>(), "The time in milli-seconds the power key must be held to ignore - must be less than shutdown-timeout");
     }
 
     void parse_config_file(
@@ -794,7 +821,25 @@
 void SystemCompositor::qt_main(int argc, char **argv)
 {
     QCoreApplication app(argc, argv);
-    DBusScreen dbus_screen(config, config->power_off_delay());
+
+    std::chrono::seconds inactivity_display_off_timeout{config->inactivity_display_off_timeout()};
+    std::chrono::seconds inactivity_display_dim_timeout{config->inactivity_display_dim_timeout()};
+    std::chrono::milliseconds power_key_ignore_timeout{config->power_key_ignore_timeout()};
+    std::chrono::milliseconds shutdown_timeout{config->shutdown_timeout()};
+
+    screen_state_handler = std::make_shared<ScreenStateHandler>(config,
+        std::chrono::duration_cast<std::chrono::milliseconds>(inactivity_display_off_timeout),
+        std::chrono::duration_cast<std::chrono::milliseconds>(inactivity_display_dim_timeout));
+
+    power_key_handler = std::make_shared<PowerKeyHandler>(*(config->the_main_loop()),
+        power_key_ignore_timeout,
+        shutdown_timeout,
+        *screen_state_handler);
+
+    auto composite_filter = config->the_composite_event_filter();
+    composite_filter->append(screen_state_handler);
+    composite_filter->append(power_key_handler);
+
     ensure_spinner();
     app.exec();
 }

=== modified file 'src/system_compositor.h'
--- src/system_compositor.h	2014-06-19 22:03:22 +0000
+++ src/system_compositor.h	2014-06-25 14:46:51 +0000
@@ -26,6 +26,8 @@
 
 class SystemCompositorShell;
 class SystemCompositorServerConfiguration;
+class ScreenStateHandler;
+class PowerKeyHandler;
 
 class SystemCompositor : public DMMessageHandler
 {
@@ -42,6 +44,8 @@
     std::shared_ptr<SystemCompositorShell> shell;
     boost::asio::io_service io_service;
     std::shared_ptr<DMConnection> dm_connection;
+    std::shared_ptr<ScreenStateHandler> screen_state_handler;
+    std::shared_ptr<PowerKeyHandler> power_key_handler;
     QProcess spinner_process;
 
     void set_active_session(std::string client_name);