Merge lp:unity-system-compositor/0.3 into lp:unity-system-compositor/ubuntu

[Alexandros Frantzis]

Release 0.3.1

Release 0.3.1

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2015-12-01 13:53:20 +0000
+++ CMakeLists.txt	2016-01-21 17:48:37 +0000
@@ -16,8 +16,8 @@
 
 project(UnitySystemCompositor)
 set(USC_VERSION_MAJOR 0)
-set(USC_VERSION_MINOR 2)
-set(USC_VERSION_PATCH 0)
+set(USC_VERSION_MINOR 3)
+set(USC_VERSION_PATCH 1)
 set(USC_VERSION "${USC_VERSION_MAJOR}.${USC_VERSION_MINOR}.${USC_VERSION_PATCH}")
 
 cmake_minimum_required(VERSION 2.8)
@@ -57,6 +57,7 @@
 
 if (MIR_ENABLE_TESTS)
   find_package(Gtest REQUIRED)
+  include_directories(${MIRCLIENT_INCLUDE_DIRS} )
   include_directories(${GMOCK_INCLUDE_DIR} ${GTEST_INCLUDE_DIR})
   add_subdirectory(tests/)
 endif ()

=== modified file 'debian/changelog'
--- debian/changelog	2015-12-16 22:44:39 +0000
+++ debian/changelog	2016-01-21 17:48:37 +0000
@@ -1,3 +1,34 @@
+unity-system-compositor (0.3.1+16.04.20160121-0ubuntu1) xenial; urgency=medium
+
+  [ Alexandros Frantzis ]
+  * Unblank the screen when a pointer or key event arrives. (LP: #1488413)
+
+  [ Andreas Pokorny ]
+  * Implement a DBus interface for setting pointer speed/acceleration.
+    (LP: #1536383)
+
+ -- Alexandros Frantzis <[e-mail]>  Thu, 21 Jan 2016 19:27:33 +0200
+
+unity-system-compositor (0.2.0+16.04.20151222.1-0ubuntu1) xenial; urgency=medium
+
+  [ Alexandros Frantzis ]
+  * tests: Fix build failure with gcc-4.9
+
+  [ Andrea Cimitan ]
+  * Updated wallpaper for spinner from unity8.
+
+  [ Andreas Pokorny ]
+  * Add clone method to StubdisplayConfigurations
+  * Change keyboard handling to scan codes. (LP: #1514059, #1520422)
+  * do not premultiply RGB images
+  * follow the deprecation warning and use tobytes instead of tostring.
+
+  [ Kevin DuBois ]
+  * Accommodate RGB images (LP: #1528279)
+  * Accommodate RGB images (LP: #1528279)
+
+ -- Kevin DuBois <[e-mail]>  Tue, 22 Dec 2015 19:09:40 +0000
+
 unity-system-compositor (0.2.0+16.04.20151216.1-0ubuntu1) xenial; urgency=medium
 
   [ Alexandros Frantzis ]

=== modified file 'spinner/eglspinner.cpp'
--- spinner/eglspinner.cpp	2015-06-30 12:04:53 +0000
+++ spinner/eglspinner.cpp	2016-01-21 17:48:37 +0000
@@ -150,14 +150,17 @@
 void uploadTexture (GLuint id, Image& image)
 {
     glBindTexture(GL_TEXTURE_2D, id);
+    GLint format = GL_RGBA;
+    if (image.bytes_per_pixel == 3)
+        format = GL_RGB;
 
     glTexImage2D(GL_TEXTURE_2D,
                  0,
-                 GL_RGBA,
+                 format,
                  image.width,
                  image.height,
                  0,
-                 GL_RGBA,
+                 format,
                  GL_UNSIGNED_BYTE,
                  image.pixel_data);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2015-08-29 14:38:35 +0000
+++ src/CMakeLists.txt	2016-01-21 17:48:37 +0000
@@ -72,6 +72,7 @@
   ${Boost_INCLUDE_DIRS}
   ${GLESv2_INCLUDE_DIRS}
   ${MIRSERVER_INCLUDE_DIRS}
+  ${MIRCLIENT_INCLUDE_DIRS}
   ${DBUS_INCLUDE_DIRS}
 )
 add_definitions(

=== modified file 'src/dbus_connection_handle.cpp'
--- src/dbus_connection_handle.cpp	2015-03-18 12:20:58 +0000
+++ src/dbus_connection_handle.cpp	2016-01-21 17:48:37 +0000
@@ -22,12 +22,12 @@
 #include <stdexcept>
 #include <boost/throw_exception.hpp>
 
-usc::DBusConnectionHandle::DBusConnectionHandle(const char* address)
+usc::DBusConnectionHandle::DBusConnectionHandle(std::string const& address)
 {
     dbus_threads_init_default();
     ScopedDBusError error;
 
-    connection = dbus_connection_open_private(address, &error);
+    connection = dbus_connection_open_private(address.c_str(), &error);
     if (!connection || error)
     {
         BOOST_THROW_EXCEPTION(

=== modified file 'src/dbus_connection_handle.h'
--- src/dbus_connection_handle.h	2015-03-17 18:17:14 +0000
+++ src/dbus_connection_handle.h	2016-01-21 17:48:37 +0000
@@ -21,13 +21,15 @@
 
 #include <dbus/dbus.h>
 
+#include <string>
+
 namespace usc
 {
 
 class DBusConnectionHandle
 {
 public:
-    DBusConnectionHandle(char const* address);
+    DBusConnectionHandle(std::string const& address);
     ~DBusConnectionHandle();
 
     void request_name(char const* name) const;

=== modified file 'src/dbus_connection_thread.cpp'
--- src/dbus_connection_thread.cpp	2015-08-25 14:27:23 +0000
+++ src/dbus_connection_thread.cpp	2016-01-21 17:48:37 +0000
@@ -17,11 +17,10 @@
  */
 
 #include "dbus_connection_thread.h"
+#include "dbus_event_loop.h"
 #include "thread_name.h"
 
-usc::DBusConnectionThread::DBusConnectionThread(std::string const& address)
-    : dbus_connection{address.c_str()},
-      dbus_event_loop{dbus_connection}
+usc::DBusConnectionThread::DBusConnectionThread(std::shared_ptr<DBusEventLoop> const& loop) : dbus_event_loop(loop)
 {
     std::promise<void> event_loop_started;
     auto event_loop_started_future = event_loop_started.get_future();
@@ -30,7 +29,7 @@
         [this,&event_loop_started]
         {
             usc::set_thread_name("USC/DBus");
-            dbus_event_loop.run(event_loop_started);
+            dbus_event_loop->run(event_loop_started);
         });
 
     event_loop_started_future.wait();
@@ -38,16 +37,11 @@
 
 usc::DBusConnectionThread::~DBusConnectionThread()
 {
-    dbus_event_loop.stop();
+    dbus_event_loop->stop();
     dbus_loop_thread.join();
 }
 
-usc::DBusConnectionHandle const& usc::DBusConnectionThread::connection() const
-{
-    return dbus_connection;
-}
-
 usc::DBusEventLoop & usc::DBusConnectionThread::loop()
 {
-    return dbus_event_loop;
+    return *dbus_event_loop;
 }

=== modified file 'src/dbus_connection_thread.h'
--- src/dbus_connection_thread.h	2015-08-25 14:27:23 +0000
+++ src/dbus_connection_thread.h	2016-01-21 17:48:37 +0000
@@ -19,25 +19,21 @@
 #ifndef USC_DBUS_CONNECTION_THREAD_H_
 #define USC_DBUS_CONNECTION_THREAD_H_
 
-#include "dbus_connection_handle.h"
-#include "dbus_event_loop.h"
-
 #include <thread>
 
 namespace usc
 {
 
+class DBusEventLoop;
 class DBusConnectionThread
 {
 public:
-    DBusConnectionThread(std::string const& address);
+    DBusConnectionThread(std::shared_ptr<DBusEventLoop> const& thread);
     ~DBusConnectionThread();
-    DBusConnectionHandle const& connection() const;
     DBusEventLoop & loop();
 
 private:
-    DBusConnectionHandle dbus_connection;
-    DBusEventLoop dbus_event_loop;
+    std::shared_ptr<DBusEventLoop> dbus_event_loop;
     std::thread dbus_loop_thread;
 };
 

=== modified file 'src/dbus_event_loop.cpp'
--- src/dbus_event_loop.cpp	2015-03-18 12:20:58 +0000
+++ src/dbus_event_loop.cpp	2016-01-21 17:48:37 +0000
@@ -21,6 +21,7 @@
 #endif
 
 #include "dbus_event_loop.h"
+#include "dbus_connection_handle.h"
 
 #include <algorithm>
 
@@ -78,9 +79,8 @@
 
 }
 
-usc::DBusEventLoop::DBusEventLoop(DBusConnection* connection)
-    : connection{connection},
-      running{false},
+usc::DBusEventLoop::DBusEventLoop()
+    : running{false},
       epoll_fd{epoll_create1(EPOLL_CLOEXEC)}
 {
     if (epoll_fd == -1)
@@ -109,9 +109,17 @@
         BOOST_THROW_EXCEPTION(
             std::system_error(errno, std::system_category(), "epoll_ctl"));
     }
+}
+
+void usc::DBusEventLoop::add_connection(std::shared_ptr<DBusConnectionHandle> const& connection)
+{
+    if (running)
+        BOOST_THROW_EXCEPTION(std::logic_error("Connection added after dbus event loop started"));
+
+    connections.push_back(connection);
 
     dbus_connection_set_watch_functions(
-        connection,
+        *connection,
         DBusEventLoop::static_add_watch,
         DBusEventLoop::static_remove_watch,
         DBusEventLoop::static_toggle_watch,
@@ -119,7 +127,7 @@
         nullptr);
 
     dbus_connection_set_timeout_functions(
-        connection,
+        *connection,
         DBusEventLoop::static_add_timeout,
         DBusEventLoop::static_remove_timeout,
         DBusEventLoop::static_toggle_timeout,
@@ -127,7 +135,7 @@
         nullptr);
 
     dbus_connection_set_wakeup_main_function(
-        connection,
+        *connection,
         DBusEventLoop::static_wake_up_loop,
         this, nullptr);
 }
@@ -136,14 +144,17 @@
 {
     stop();
 
-    dbus_connection_set_watch_functions(
-        connection, nullptr, nullptr, nullptr, nullptr, nullptr);
-
-    dbus_connection_set_timeout_functions(
-        connection, nullptr, nullptr, nullptr, nullptr, nullptr);
-
-    dbus_connection_set_wakeup_main_function(
-        connection, nullptr, nullptr, nullptr);
+    for(auto connection : connections)
+    {
+        dbus_connection_set_watch_functions(
+            *connection, nullptr, nullptr, nullptr, nullptr, nullptr);
+
+        dbus_connection_set_timeout_functions(
+            *connection, nullptr, nullptr, nullptr, nullptr, nullptr);
+
+        dbus_connection_set_wakeup_main_function(
+            *connection, nullptr, nullptr, nullptr);
+    }
 }
 
 void usc::DBusEventLoop::run(std::promise<void>& started)
@@ -187,14 +198,17 @@
 
         dispatch_actions();
 
-        dbus_connection_flush(connection);
+        for (auto connection : connections)
+        {
+            dbus_connection_flush(*connection);
 
-        while (dbus_connection_dispatch(connection) == DBUS_DISPATCH_DATA_REMAINS)
-            continue;
+            while (dbus_connection_dispatch(*connection) == DBUS_DISPATCH_DATA_REMAINS);
+        }
     }
 
     // Flush any remaining outgoing messages
-    dbus_connection_flush(connection);
+    for (auto connection : connections)
+        dbus_connection_flush(*connection);
 }
 
 void usc::DBusEventLoop::stop()

=== modified file 'src/dbus_event_loop.h'
--- src/dbus_event_loop.h	2015-03-18 11:56:28 +0000
+++ src/dbus_event_loop.h	2016-01-21 17:48:37 +0000
@@ -30,13 +30,15 @@
 
 namespace usc
 {
+class DBusConnectionHandle;
 
 class DBusEventLoop
 {
 public:
-    DBusEventLoop(DBusConnection* connection);
+    DBusEventLoop();
     ~DBusEventLoop();
 
+    void add_connection(std::shared_ptr<DBusConnectionHandle> const& connection);
     void run(std::promise<void>& started);
     void stop();
 
@@ -70,10 +72,10 @@
     static void static_toggle_timeout(DBusTimeout* timeout, void* data);
     static void static_wake_up_loop(void* data);
 
-    DBusConnection* const connection;
     std::atomic<bool> running;
 
     std::mutex mutex;
+    std::vector<std::shared_ptr<DBusConnectionHandle>> connections;
     std::vector<DBusWatch*> watches;
     std::vector<std::pair<DBusTimeout*,mir::Fd>> timeouts;
     std::vector<std::function<void(void)>> actions;

=== modified file 'src/mir_input_configuration.cpp'
--- src/mir_input_configuration.cpp	2015-08-26 08:26:35 +0000
+++ src/mir_input_configuration.cpp	2016-01-21 17:48:37 +0000
@@ -15,58 +15,173 @@
  */
 
 #include "mir_input_configuration.h"
-
-// just a stub at the moment, this implementation will be supposed to
-// observe available input devices and apply settings to it.
-
+#include "mir/input/input_device_observer.h"
+#include "mir/input/input_device_hub.h"
+#include "mir/input/pointer_configuration.h"
+#include "mir/input/touchpad_configuration.h"
+#include "mir/input/device.h"
+
+namespace mi = mir::input;
+
+namespace
+{
+struct DeviceObserver : mi::InputDeviceObserver
+{
+    usc::MirInputConfiguration* conf;
+    DeviceObserver(usc::MirInputConfiguration* conf)
+        : conf{conf}
+    {
+    }
+
+    void device_added(std::shared_ptr<mi::Device> const& device) override
+    {
+        conf->device_added(device);
+    }
+
+    void device_changed(std::shared_ptr<mi::Device> const&) override
+    {
+    }
+
+    void device_removed(std::shared_ptr<mi::Device> const&device) override
+    {
+        conf->device_removed(device);
+    }
+
+    void changes_complete() override
+    {
+    }
+};
+}
+
+
+usc::MirInputConfiguration::MirInputConfiguration(std::shared_ptr<mi::InputDeviceHub> const& device_hub) :
+    observer{std::make_shared<DeviceObserver>(this)}
+{
+    device_hub->add_observer(observer);
+}
+
+void usc::MirInputConfiguration::device_removed(std::shared_ptr<mi::Device> const& dev)
+{
+    std::lock_guard<decltype(devices_lock)> lock(devices_lock);
+    touchpads.erase(dev);
+    mice.erase(dev);
+}
+
+void usc::MirInputConfiguration::configure_mouse(mi::Device& dev)
+{
+    dev.apply_pointer_configuration(mouse_pointer_config);
+}
+
+void usc::MirInputConfiguration::configure_touchpad(mi::Device& dev)
+{
+    dev.apply_pointer_configuration(touchpad_pointer_config);
+    dev.apply_touchpad_configuration(touchpad_config);
+}
+
+void usc::MirInputConfiguration::device_added(std::shared_ptr<mi::Device> const& dev)
+{
+    std::lock_guard<decltype(devices_lock)> lock(devices_lock);
+
+    if (contains(dev->capabilities(), mi::DeviceCapability::touchpad))
+    {
+        touchpads.insert(dev);
+        configure_touchpad(*dev);
+    }
+    else if (contains(dev->capabilities(), mi::DeviceCapability::pointer))
+    {
+        mice.insert(dev);
+        configure_mouse(*dev);
+    }
+}
+
+void usc::MirInputConfiguration::update_touchpads()
+{
+    for (auto const& touchpad : touchpads)
+        configure_touchpad(*touchpad);
+}
+
+void usc::MirInputConfiguration::update_mice()
+{
+    for (auto const& mouse : mice)
+        configure_mouse(*mouse);
+}
 
 void usc::MirInputConfiguration::set_mouse_primary_button(int32_t button)
 {
-    mouse_primary_button = button;
+    mouse_pointer_config.handedness = button == 0 ?
+        mir_pointer_handedness_right :
+        mir_pointer_handedness_left;
+    update_mice();
 }
 
 void usc::MirInputConfiguration::set_mouse_cursor_speed(double speed)
 {
-    mouse_cursor_speed = speed;
+    double clamped = speed;
+    if (clamped < 0.0)
+        clamped = 0.0;
+    if (clamped > 1.0)
+        clamped = 1.0;
+    mouse_pointer_config.cursor_acceleration_bias = clamped * 2.0 - 1.0;
+    update_mice();
 }
 
 void usc::MirInputConfiguration::set_mouse_scroll_speed(double speed)
 {
-    mouse_scroll_speed = speed;
+    mouse_pointer_config.horizontal_scroll_scale = speed;
+    mouse_pointer_config.vertical_scroll_scale = speed;
+    update_mice();
 }
 
 void usc::MirInputConfiguration::set_touchpad_primary_button(int32_t button)
 {
-    touchpad_primary_button = button;
+    touchpad_pointer_config.handedness = button == 0?mir_pointer_handedness_right:mir_pointer_handedness_left;
+    update_touchpads();
 }
 
 void usc::MirInputConfiguration::set_touchpad_cursor_speed(double speed)
 {
-    touchpad_cursor_speed = speed;
+    double clamped = speed;
+    if (clamped < 0.0)
+        clamped = 0.0;
+    if (clamped > 1.0)
+        clamped = 1.0;
+    touchpad_pointer_config.cursor_acceleration_bias = clamped * 2.0 - 1.0;
+    update_touchpads();
 }
 
 void usc::MirInputConfiguration::set_touchpad_scroll_speed(double speed)
 {
-    touchpad_scroll_speed = speed;
+    touchpad_pointer_config.horizontal_scroll_scale = speed;
+    touchpad_pointer_config.vertical_scroll_scale = speed;
+    update_touchpads();
 }
 
 void usc::MirInputConfiguration::set_two_finger_scroll(bool enable)
 {
-    two_finger_scroll = enable;
+    MirTouchpadScrollModes current = touchpad_config.scroll_mode;
+    if (enable)
+        current |= mir_touchpad_scroll_mode_two_finger_scroll;
+    else
+        current &= ~mir_touchpad_scroll_mode_two_finger_scroll;
+    touchpad_config.scroll_mode = current;
+    update_touchpads();
 }
 
 void usc::MirInputConfiguration::set_tap_to_click(bool enable)
 {
-    tap_to_click = enable;
+    touchpad_config.tap_to_click = enable;
+    update_touchpads();
 }
 
 void usc::MirInputConfiguration::set_disable_touchpad_while_typing(bool enable)
 {
-    disable_while_typing = enable;
+    touchpad_config.disable_while_typing = enable;
+    update_touchpads();
 }
 
 void usc::MirInputConfiguration::set_disable_touchpad_with_mouse(bool enable)
 {
-    disable_with_mouse = enable;
+    touchpad_config.disable_with_mouse = enable;
+    update_touchpads();
 }
 

=== modified file 'src/mir_input_configuration.h'
--- src/mir_input_configuration.h	2015-08-26 08:26:35 +0000
+++ src/mir_input_configuration.h	2016-01-21 17:48:37 +0000
@@ -14,18 +14,36 @@
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-
 #ifndef USC_MIR_INPUT_CONFIGRATION_H_
 #define USC_MIR_INPUT_CONFIGRATION_H_
 
 #include "input_configuration.h"
 
+#include "mir/input/touchpad_configuration.h"
+#include "mir/input/pointer_configuration.h"
+
+#include <memory>
+#include <thread>
+#include <mutex>
+#include <unordered_set>
+
+namespace mir
+{
+namespace input
+{
+class InputDeviceHub;
+class Device;
+class InputDeviceObserver;
+}
+}
+
 namespace usc
 {
 
 struct MirInputConfiguration : InputConfiguration
 {
 public:
+    MirInputConfiguration(std::shared_ptr<mir::input::InputDeviceHub> const& device_hub);
     void set_mouse_primary_button(int32_t button) override;
     void set_mouse_cursor_speed(double speed) override;
     void set_mouse_scroll_speed(double speed) override;
@@ -36,17 +54,22 @@
     void set_tap_to_click(bool enable) override;
     void set_disable_touchpad_while_typing(bool enable) override;
     void set_disable_touchpad_with_mouse(bool enable) override;
+
+    void device_added(std::shared_ptr<mir::input::Device> const& device);
+    void device_removed(std::shared_ptr<mir::input::Device> const& device);
 private:
-    int32_t mouse_primary_button{0};
-    double mouse_cursor_speed{0.5};
-    double mouse_scroll_speed{0.5};
-    int32_t touchpad_primary_button{0};
-    double touchpad_cursor_speed{0.5};
-    double touchpad_scroll_speed{0.5};
-    bool two_finger_scroll{false};
-    bool tap_to_click{false};
-    bool disable_while_typing{false};
-    bool disable_with_mouse{true};
+    void configure_mouse(mir::input::Device& dev);
+    void configure_touchpad(mir::input::Device& dev);
+    void update_touchpads();
+    void update_mice();
+
+    std::shared_ptr<mir::input::InputDeviceObserver> const observer;
+    std::mutex devices_lock;
+    std::unordered_set<std::shared_ptr<mir::input::Device>> touchpads;
+    std::unordered_set<std::shared_ptr<mir::input::Device>> mice;
+    mir::input::PointerConfiguration mouse_pointer_config;
+    mir::input::PointerConfiguration touchpad_pointer_config;
+    mir::input::TouchpadConfiguration touchpad_config;
 };
 
 }

=== modified file 'src/powerd_mediator.cpp'
--- src/powerd_mediator.cpp	2015-07-17 12:43:46 +0000
+++ src/powerd_mediator.cpp	2016-01-21 17:48:37 +0000
@@ -45,8 +45,7 @@
 }
 
 usc::PowerdMediator::PowerdMediator(std::string const& bus_addr)
-    : connection{bus_addr.c_str()},
-      dbus_event_loop{connection},
+    : connection{std::make_shared<DBusConnectionHandle>(bus_addr.c_str())},
       pending_suspend_block_request{false},
       dim_brightness_{10},
       min_brightness_{0},
@@ -59,17 +58,18 @@
       proximity_enabled{false},
       sys_state{SysState::unknown}
 {
-    connection.add_match(
+    dbus_event_loop.add_connection(connection);
+    connection->add_match(
         "type='signal',"
         "sender='com.canonical.powerd',"
         "interface='com.canonical.powerd',"
         "member='SysPowerStateChange'");
-    connection.add_match(
+    connection->add_match(
         "type='signal',"
         "sender='org.freedesktop.DBus',"
         "interface='org.freedesktop.DBus',"
         "member='NameOwnerChanged'");
-    connection.add_filter(handle_dbus_message_thunk, this);
+    connection->add_filter(handle_dbus_message_thunk, this);
 
     std::promise<void> event_loop_started;
     auto event_loop_started_future = event_loop_started.get_future();
@@ -477,7 +477,7 @@
         [this, &msg, &reply_promise]
         {
             auto const reply = dbus_connection_send_with_reply_and_block(
-                connection, msg, DBUS_TIMEOUT_USE_DEFAULT, nullptr);
+                *connection, msg, DBUS_TIMEOUT_USE_DEFAULT, nullptr);
 
             reply_promise.set_value(reply);
         };

=== modified file 'src/powerd_mediator.h'
--- src/powerd_mediator.h	2015-07-17 12:43:46 +0000
+++ src/powerd_mediator.h	2016-01-21 17:48:37 +0000
@@ -88,7 +88,7 @@
     void invoke(char const* method, int first_arg_type, ...);
     usc::DBusMessageHandle invoke_with_reply(char const* method, int first_arg_type, ...);
 
-    usc::DBusConnectionHandle connection;
+    std::shared_ptr<usc::DBusConnectionHandle> connection;
     usc::DBusEventLoop dbus_event_loop;
     std::thread dbus_loop_thread;
 

=== modified file 'src/screen_event_handler.cpp'
--- src/screen_event_handler.cpp	2015-11-07 13:29:29 +0000
+++ src/screen_event_handler.cpp	2016-01-21 17:48:37 +0000
@@ -71,16 +71,20 @@
         }
         else
         {
-            std::lock_guard<std::mutex> lock{guard};
-            screen->keep_display_on_temporarily();
+            keep_or_turn_screen_on();
         }
     }
-    else if (input_event_type == mir_input_event_type_touch ||
-             input_event_type == mir_input_event_type_pointer)
+    else if (input_event_type == mir_input_event_type_touch)
     {
         std::lock_guard<std::mutex> lock{guard};
         screen->keep_display_on_temporarily();
     }
+    else if (input_event_type == mir_input_event_type_pointer)
+    {
+        bool const filter_out_event = screen->get_screen_power_mode() != mir_power_mode_on;
+        keep_or_turn_screen_on();
+        return filter_out_event;
+    }
 
     return false;
 }
@@ -138,3 +142,18 @@
         MirPowerMode::mir_power_mode_on, PowerStateChangeReason::power_key);
     long_press_detected = true;
 }
+
+void usc::ScreenEventHandler::keep_or_turn_screen_on()
+{
+    std::lock_guard<std::mutex> lock{guard};
+
+    if (screen->get_screen_power_mode() == mir_power_mode_off)
+    {
+        screen->set_screen_power_mode(
+            MirPowerMode::mir_power_mode_on, PowerStateChangeReason::unknown);
+    }
+    else
+    {
+        screen->keep_display_on_temporarily();
+    }
+}

=== modified file 'src/screen_event_handler.h'
--- src/screen_event_handler.h	2015-04-29 14:39:19 +0000
+++ src/screen_event_handler.h	2016-01-21 17:48:37 +0000
@@ -56,6 +56,7 @@
     void power_key_down();
     void shutdown_alarm_notification();
     void long_press_notification();
+    void keep_or_turn_screen_on();
 
     std::mutex guard;
     std::shared_ptr<Screen> const screen;

=== modified file 'src/server.cpp'
--- src/server.cpp	2015-09-30 10:53:54 +0000
+++ src/server.cpp	2016-01-21 17:48:37 +0000
@@ -28,6 +28,7 @@
 #include "unity_screen_service.h"
 #include "unity_input_service.h"
 #include "dbus_connection_thread.h"
+#include "dbus_event_loop.h"
 #include "display_configuration_policy.h"
 #include "steady_clock.h"
 
@@ -241,7 +242,7 @@
     return input_configuration(
         [this]
         {
-            return std::make_shared<MirInputConfiguration>();
+            return std::make_shared<MirInputConfiguration>(the_input_device_hub());
         });
 }
 
@@ -292,12 +293,22 @@
         });
 }
 
+std::shared_ptr<usc::DBusEventLoop> usc::Server::the_dbus_event_loop()
+{
+    return dbus_loop(
+        [this]
+        {
+            return std::make_shared<DBusEventLoop>();
+        });
+
+}
+
 std::shared_ptr<usc::DBusConnectionThread> usc::Server::the_dbus_connection_thread()
 {
     return dbus_thread(
         [this]
         {
-            return std::make_shared<DBusConnectionThread>(dbus_bus_address());
+            return std::make_shared<DBusConnectionThread>(the_dbus_event_loop());
         });
 }
 
@@ -307,7 +318,8 @@
         [this]
         {
             return std::make_shared<UnityScreenService>(
-                    the_dbus_connection_thread(),
+                    the_dbus_event_loop(),
+                    dbus_bus_address(),
                     the_screen());
         });
 }
@@ -318,7 +330,8 @@
         [this]
         {
             return std::make_shared<UnityInputService>(
-                    the_dbus_connection_thread(),
+                    the_dbus_event_loop(),
+                    dbus_bus_address(),
                     the_input_configuration());
         });
 }

=== modified file 'src/server.h'
--- src/server.h	2015-09-30 10:53:54 +0000
+++ src/server.h	2016-01-21 17:48:37 +0000
@@ -45,6 +45,7 @@
 class InputConfiguration;
 class UnityInputService;
 class DBusConnectionThread;
+class DBusEventLoop;
 class Clock;
 
 class Server : private mir::Server
@@ -69,6 +70,7 @@
     virtual std::shared_ptr<ScreenHardware> the_screen_hardware();
     virtual std::shared_ptr<UnityScreenService> the_unity_screen_service();
     virtual std::shared_ptr<UnityInputService> the_unity_input_service();
+    virtual std::shared_ptr<DBusEventLoop> the_dbus_event_loop();
     virtual std::shared_ptr<DBusConnectionThread> the_dbus_connection_thread();
     virtual std::shared_ptr<Clock> the_clock();
 
@@ -182,6 +184,7 @@
     mir::CachedPtr<mir::input::EventFilter> screen_event_handler;
     mir::CachedPtr<ScreenHardware> screen_hardware;
     mir::CachedPtr<DBusConnectionThread> dbus_thread;
+    mir::CachedPtr<DBusEventLoop> dbus_loop;
     mir::CachedPtr<UnityScreenService> unity_screen_service;
     mir::CachedPtr<UnityInputService> unity_input_service;
     mir::CachedPtr<Clock> clock;

=== modified file 'src/system_compositor.cpp'
--- src/system_compositor.cpp	2015-08-26 08:26:35 +0000
+++ src/system_compositor.cpp	2016-01-21 17:48:37 +0000
@@ -22,6 +22,7 @@
 #include "dm_connection.h"
 
 #include <mir/input/composite_event_filter.h>
+#include <mir/input/input_device_hub.h>
 #include <mir/abnormal_exit.h>
 
 #include <cerrno>
@@ -123,6 +124,7 @@
 
                 unity_screen_service = server->the_unity_screen_service();
                 unity_input_service = server->the_unity_input_service();
+                dbus_service_thread = server->the_dbus_connection_thread();
             }
         });
 

=== modified file 'src/system_compositor.h'
--- src/system_compositor.h	2015-08-26 08:26:35 +0000
+++ src/system_compositor.h	2016-01-21 17:48:37 +0000
@@ -40,6 +40,7 @@
 class Screen;
 class UnityScreenService;
 class UnityInputService;
+class DBusConnectionThread;
 
 class SystemCompositor
 {
@@ -55,6 +56,7 @@
     std::shared_ptr<mir::input::EventFilter> screen_event_handler;
     std::shared_ptr<UnityScreenService> unity_screen_service;
     std::shared_ptr<UnityInputService> unity_input_service;
+    std::shared_ptr<DBusConnectionThread> dbus_service_thread;
 };
 
 }

=== modified file 'src/unity_input_service.cpp'
--- src/unity_input_service.cpp	2015-08-28 15:57:25 +0000
+++ src/unity_input_service.cpp	2016-01-21 17:48:37 +0000
@@ -19,7 +19,7 @@
 #include "unity_input_service.h"
 #include "input_configuration.h"
 #include "dbus_message_handle.h"
-#include "dbus_connection_thread.h"
+#include "dbus_event_loop.h"
 #include "scoped_dbus_error.h"
 
 #include "unity_input_service_introspection.h" // autogenerated
@@ -33,15 +33,14 @@
 
 }
 
-usc::UnityInputService::UnityInputService(
-    std::shared_ptr<usc::DBusConnectionThread> const& dbus,
-    std::shared_ptr<usc::InputConfiguration> const& input_config)
-    : dbus{dbus},
-      input_config{input_config}
+usc::UnityInputService::UnityInputService(std::shared_ptr<usc::DBusEventLoop> const& loop,
+                                          std::string const& address,
+                                          std::shared_ptr<usc::InputConfiguration> const& input_config)
+    : loop{loop}, connection{std::make_shared<DBusConnectionHandle>(address.c_str())}, input_config{input_config}
 {
-    auto const& connection = dbus->connection();
-    connection.request_name(dbus_input_service_name);
-    connection.add_filter(handle_dbus_message_thunk, this);
+    loop->add_connection(connection);
+    connection->request_name(dbus_input_service_name);
+    connection->add_filter(handle_dbus_message_thunk, this);
 }
 
 ::DBusHandlerResult usc::UnityInputService::handle_dbus_message_thunk(
@@ -63,7 +62,7 @@
         (input_config.get()->*method)(flag);
 
         DBusMessageHandle reply{dbus_message_new_method_return(message)};
-        dbus_connection_send(dbus->connection(), reply, nullptr);
+        dbus_connection_send(*connection, reply, nullptr);
     }
 }
 
@@ -79,7 +78,7 @@
         (input_config.get()->*method)(value);
 
         DBusMessageHandle reply{dbus_message_new_method_return(message)};
-        dbus_connection_send(dbus->connection(), reply, nullptr);
+        dbus_connection_send(*connection, reply, nullptr);
     }
 }
 
@@ -95,7 +94,7 @@
         (input_config.get()->*method)(value);
 
         DBusMessageHandle reply{dbus_message_new_method_return(message)};
-        dbus_connection_send(dbus->connection(), reply, nullptr);
+        dbus_connection_send(*connection, reply, nullptr);
     }
 }
 
@@ -151,4 +150,3 @@
 
     return DBUS_HANDLER_RESULT_HANDLED;
 }
-

=== modified file 'src/unity_input_service.h'
--- src/unity_input_service.h	2015-08-26 08:00:27 +0000
+++ src/unity_input_service.h	2016-01-21 17:48:37 +0000
@@ -20,18 +20,20 @@
 #define USC_UNITY_INPUT_SERVICE_H_
 
 #include <dbus/dbus.h>
+#include "dbus_connection_handle.h"
 #include <memory>
 
 namespace usc
 {
-class DBusConnectionThread;
+class DBusEventLoop;
 class InputConfiguration;
 
 class UnityInputService
 {
 public:
     UnityInputService(
-        std::shared_ptr<usc::DBusConnectionThread> const& dbus_thread,
+        std::shared_ptr<usc::DBusEventLoop> const& loop,
+        std::string const& address,
         std::shared_ptr<usc::InputConfiguration> const& input_config);
 
 private:
@@ -44,7 +46,8 @@
     void handle_message(DBusMessage* message, void (usc::InputConfiguration::* method)(int32_t));
     void handle_message(DBusMessage* message, void (usc::InputConfiguration::* method)(double));
 
-    std::shared_ptr<usc::DBusConnectionThread> const dbus;
+    std::shared_ptr<usc::DBusEventLoop> const loop;
+    std::shared_ptr<usc::DBusConnectionHandle> connection;
     std::shared_ptr<usc::InputConfiguration> const input_config;
 };
 

=== modified file 'src/unity_screen_service.cpp'
--- src/unity_screen_service.cpp	2015-08-25 14:35:20 +0000
+++ src/unity_screen_service.cpp	2016-01-21 17:48:37 +0000
@@ -19,7 +19,7 @@
 #include "unity_screen_service.h"
 #include "screen.h"
 #include "dbus_message_handle.h"
-#include "dbus_connection_thread.h"
+#include "dbus_event_loop.h"
 #include "dbus_connection_handle.h"
 #include "scoped_dbus_error.h"
 
@@ -35,20 +35,22 @@
 }
 
 usc::UnityScreenService::UnityScreenService(
-    std::shared_ptr<usc::DBusConnectionThread> const& dbus,
+    std::shared_ptr<usc::DBusEventLoop> const& loop,
+    std::string const& address,
     std::shared_ptr<usc::Screen> const& screen)
     : screen{screen},
-      dbus{dbus},
+      loop{loop},
+      connection{std::make_shared<DBusConnectionHandle>(address.c_str())},
       request_id{0}
 {
-    auto const& connection = dbus->connection();
-    connection.request_name(dbus_screen_service_name);
-    connection.add_match(
+    loop->add_connection(connection);
+    connection->request_name(dbus_screen_service_name);
+    connection->add_match(
         "type='signal',"
         "sender='org.freedesktop.DBus',"
         "interface='org.freedesktop.DBus',"
         "member='NameOwnerChanged'");
-    connection.add_filter(handle_dbus_message_thunk, this);
+    connection->add_filter(handle_dbus_message_thunk, this);
 
     screen->register_power_state_change_handler(
         [this](MirPowerMode mode, PowerStateChangeReason reason)
@@ -332,7 +334,7 @@
     int32_t const power_state = (power_mode == MirPowerMode::mir_power_mode_off) ? 0 : 1;
     int32_t const reason_int = static_cast<int32_t>(reason);
 
-    dbus->loop().enqueue(
+    loop->enqueue(
         [this, power_state, reason_int]
         {
             DBusMessageHandle signal{
@@ -344,6 +346,6 @@
                 DBUS_TYPE_INT32, &reason_int,
                 DBUS_TYPE_INVALID};
 
-            dbus_connection_send(dbus->connection(), signal, nullptr);
+            dbus_connection_send(*connection, signal, nullptr);
         });
 }

=== modified file 'src/unity_screen_service.h'
--- src/unity_screen_service.h	2015-08-25 14:32:32 +0000
+++ src/unity_screen_service.h	2016-01-21 17:48:37 +0000
@@ -34,13 +34,14 @@
 namespace usc
 {
 class Screen;
-class DBusConnectionThread;
+class DBusEventLoop;
 
 class UnityScreenService
 {
 public:
     UnityScreenService(
-        std::shared_ptr<usc::DBusConnectionThread> const& connection,
+        std::shared_ptr<usc::DBusEventLoop> const& loop,
+        std::string const& address,
         std::shared_ptr<usc::Screen> const& screen);
 
 private:
@@ -64,7 +65,8 @@
         MirPowerMode power_mode, PowerStateChangeReason reason);
 
     std::shared_ptr<usc::Screen> const screen;
-    std::shared_ptr<DBusConnectionThread> const dbus;
+    std::shared_ptr<DBusEventLoop> const loop;
+    std::shared_ptr<DBusConnectionHandle> connection;
 
     std::mutex keep_display_on_mutex;
     std::unordered_multimap<std::string,int32_t> keep_display_on_ids;

=== added file 'tests/include/usc/test/mock_input_configuration.h'
--- tests/include/usc/test/mock_input_configuration.h	1970-01-01 00:00:00 +0000
+++ tests/include/usc/test/mock_input_configuration.h	2016-01-21 17:48:37 +0000
@@ -0,0 +1,48 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Andreas Pokorny <[e-mail]>
+ */
+
+#ifndef USC_TEST_MOCK_INPUT_CONFIGURATION_H_
+#define USC_TEST_MOCK_INPUT_CONFIGURATION_H_
+
+#include "src/input_configuration.h"
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+namespace usc
+{
+namespace test
+{
+struct MockInputConfiguration : usc::InputConfiguration
+{
+public:
+    MOCK_METHOD1(set_mouse_primary_button, void(int32_t));
+    MOCK_METHOD1(set_mouse_cursor_speed, void(double));
+    MOCK_METHOD1(set_mouse_scroll_speed, void(double));
+    MOCK_METHOD1(set_touchpad_primary_button, void(int32_t));
+    MOCK_METHOD1(set_touchpad_cursor_speed, void(double));
+    MOCK_METHOD1(set_touchpad_scroll_speed, void(double));
+    MOCK_METHOD1(set_two_finger_scroll, void(bool));
+    MOCK_METHOD1(set_tap_to_click, void(bool));
+    MOCK_METHOD1(set_disable_touchpad_with_mouse, void(bool));
+    MOCK_METHOD1(set_disable_touchpad_while_typing, void(bool));
+};
+}
+}
+
+#endif

=== added file 'tests/include/usc/test/mock_screen.h'
--- tests/include/usc/test/mock_screen.h	1970-01-01 00:00:00 +0000
+++ tests/include/usc/test/mock_screen.h	2016-01-21 17:48:37 +0000
@@ -0,0 +1,57 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Andreas Pokorny <[e-mail]>
+ */
+
+#ifndef USC_TEST_MOCK_SCREEN_H_
+#define USC_TEST_MOCK_SCREEN_H_
+
+#include "src/screen.h"
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+namespace usc
+{
+namespace test
+{
+
+struct MockScreen : usc::Screen
+{
+    MOCK_METHOD1(enable_inactivity_timers, void(bool enable));
+    MOCK_METHOD0(keep_display_on_temporarily, void());
+
+    MOCK_METHOD0(get_screen_power_mode, MirPowerMode());
+    MOCK_METHOD2(set_screen_power_mode, void(MirPowerMode mode, PowerStateChangeReason reason));
+    MOCK_METHOD1(keep_display_on, void(bool on));
+    MOCK_METHOD1(set_brightness, void(int brightness));
+    MOCK_METHOD1(enable_auto_brightness, void(bool enable));
+    MOCK_METHOD2(set_inactivity_timeouts, void(int power_off_timeout, int dimmer_timeout));
+
+    MOCK_METHOD1(set_touch_visualization_enabled, void(bool enabled));
+
+    void register_power_state_change_handler(
+        usc::PowerStateChangeHandler const& handler)
+    {
+        power_state_change_handler = handler;
+    }
+
+    usc::PowerStateChangeHandler power_state_change_handler;
+};
+
+}
+}
+
+#endif

=== modified file 'tests/integration-tests/CMakeLists.txt'
--- tests/integration-tests/CMakeLists.txt	2015-09-22 16:17:40 +0000
+++ tests/integration-tests/CMakeLists.txt	2016-01-21 17:48:37 +0000
@@ -33,9 +33,12 @@
   dbus_bus.cpp
   dbus_client.cpp
   spin_wait.cpp
+  unity_screen_dbus_client.cpp
+  unity_input_dbus_client.cpp
   test_dbus_event_loop.cpp
   test_unity_screen_service.cpp
   test_unity_input_service.cpp
+  test_unity_services.cpp
   test_external_spinner.cpp
   test_powerd_mediator.cpp
   test_deadlock_lp1491566.cpp

=== modified file 'tests/integration-tests/test_dbus_event_loop.cpp'
--- tests/integration-tests/test_dbus_event_loop.cpp	2015-05-27 09:42:40 +0000
+++ tests/integration-tests/test_dbus_event_loop.cpp	2016-01-21 17:48:37 +0000
@@ -79,8 +79,9 @@
 {
     ADBusEventLoop()
     {
-        connection.request_name(test_service_name);
-        connection.add_filter(handle_dbus_message_thunk, this);
+        dbus_event_loop.add_connection(connection);
+        connection->request_name(test_service_name);
+        connection->add_filter(handle_dbus_message_thunk, this);
 
         std::promise<void> event_loop_started;
         auto event_loop_started_future = event_loop_started.get_future();
@@ -102,8 +103,7 @@
     }
 
     static ::DBusHandlerResult handle_dbus_message_thunk(
-        ::DBusConnection* connection, DBusMessage* message, void* user_data)
-    {
+        ::DBusConnection* connection, DBusMessage* message, void* user_data) {
         auto const a_dbus_event_loop = static_cast<ADBusEventLoop*>(user_data);
         return a_dbus_event_loop->handle_dbus_message(connection, message, user_data);
     }
@@ -142,8 +142,8 @@
 
     ut::DBusBus bus;
 
-    usc::DBusConnectionHandle connection{bus.address().c_str()};
-    usc::DBusEventLoop dbus_event_loop{connection};
+    std::shared_ptr<usc::DBusConnectionHandle> connection{std::make_shared<usc::DBusConnectionHandle>(bus.address())};
+    usc::DBusEventLoop dbus_event_loop{};
     std::thread dbus_loop_thread;
     TestDBusClient client{bus.address()};
 };
@@ -173,7 +173,7 @@
                     test_service_interface,
                     "signal")};
 
-            dbus_connection_send(connection, msg, nullptr);
+            dbus_connection_send(*connection, msg, nullptr);
         });
 
     auto const reply = client.listen_for_signal();
@@ -214,7 +214,7 @@
 
             DBusPendingCall* pending{nullptr};
             dbus_connection_send_with_reply(
-                connection, msg, &pending, timeout_ms);
+                *connection, msg, &pending, timeout_ms);
             dbus_pending_call_set_notify(
                 pending, &pending_complete, &pending_promise, nullptr);
         });

=== modified file 'tests/integration-tests/test_powerd_mediator.cpp'
--- tests/integration-tests/test_powerd_mediator.cpp	2015-07-17 12:43:46 +0000
+++ tests/integration-tests/test_powerd_mediator.cpp	2016-01-21 17:48:37 +0000
@@ -41,9 +41,10 @@
         dbus_bool_t auto_brightness_supported,
         StartNow start_now)
         : auto_brightness_supported{auto_brightness_supported},
-          connection{address.c_str()},
-          dbus_event_loop{connection}
+          connection{std::make_shared<usc::DBusConnectionHandle>(address)},
+          dbus_event_loop{}
     {
+        dbus_event_loop.add_connection(connection);
         if (start_now == StartNow::yes)
             start();
     }
@@ -60,8 +61,8 @@
         ON_CALL(*this, dbus_setUserBrightness(normal_brightness))
             .WillByDefault(WakeUp(&initial_setup_done));
 
-        connection.request_name(powerd_service_name);
-        connection.add_filter(handle_dbus_message_thunk, this);
+        connection->request_name(powerd_service_name);
+        connection->add_filter(handle_dbus_message_thunk, this);
 
         std::promise<void> event_loop_started;
         auto event_loop_started_future = event_loop_started.get_future();
@@ -104,7 +105,7 @@
             DBUS_TYPE_INT32, &state,
             DBUS_TYPE_INVALID};
 
-        dbus_connection_send(connection, signal, nullptr);
+        dbus_connection_send(*connection, signal, nullptr);
     }
 
 private:
@@ -230,7 +231,7 @@
 
     ut::WaitCondition initial_setup_done;
 
-    usc::DBusConnectionHandle connection;
+    std::shared_ptr<usc::DBusConnectionHandle> connection;
     usc::DBusEventLoop dbus_event_loop;
     std::thread dbus_loop_thread;
 };

=== modified file 'tests/integration-tests/test_unity_input_service.cpp'
--- tests/integration-tests/test_unity_input_service.cpp	2015-08-28 15:57:25 +0000
+++ tests/integration-tests/test_unity_input_service.cpp	2016-01-21 17:48:37 +0000
@@ -19,15 +19,16 @@
 #include "src/unity_input_service.h"
 #include "src/dbus_connection_handle.h"
 #include "src/dbus_connection_thread.h"
+#include "src/dbus_event_loop.h"
 #include "src/dbus_message_handle.h"
-#include "src/input_configuration.h"
 #include "src/unity_input_service_introspection.h"
+
 #include "wait_condition.h"
 #include "dbus_bus.h"
 #include "dbus_client.h"
+#include "unity_input_dbus_client.h"
 
-#include <gtest/gtest.h>
-#include <gmock/gmock.h>
+#include "usc/test/mock_input_configuration.h"
 
 #include <stdexcept>
 #include <memory>
@@ -37,128 +38,19 @@
 namespace
 {
 
-struct MockInputConfiguration : usc::InputConfiguration
-{
-public:
-    MOCK_METHOD1(set_mouse_primary_button, void(int32_t));
-    MOCK_METHOD1(set_mouse_cursor_speed, void(double));
-    MOCK_METHOD1(set_mouse_scroll_speed, void(double));
-    MOCK_METHOD1(set_touchpad_primary_button, void(int32_t));
-    MOCK_METHOD1(set_touchpad_cursor_speed, void(double));
-    MOCK_METHOD1(set_touchpad_scroll_speed, void(double));
-    MOCK_METHOD1(set_two_finger_scroll, void(bool));
-    MOCK_METHOD1(set_tap_to_click, void(bool));
-    MOCK_METHOD1(set_disable_touchpad_with_mouse, void(bool));
-    MOCK_METHOD1(set_disable_touchpad_while_typing, void(bool));
-};
-
-class UnityInputDBusClient : public ut::DBusClient
-{
-public:
-    UnityInputDBusClient(std::string const& address)
-        : ut::DBusClient{
-            address,
-            "com.canonical.Unity.Input",
-            "/com/canonical/Unity/Input"}
-    {
-    }
-
-    ut::DBusAsyncReplyString request_introspection()
-    {
-        return invoke_with_reply<ut::DBusAsyncReplyString>(
-            "org.freedesktop.DBus.Introspectable", "Introspect",
-            DBUS_TYPE_INVALID);
-    }
-
-    ut::DBusAsyncReplyVoid request(char const* requestName, int32_t value)
-    {
-        return invoke_with_reply<ut::DBusAsyncReplyVoid>(
-            unity_input_interface, requestName,
-            DBUS_TYPE_INT32, &value,
-            DBUS_TYPE_INVALID);
-    }
-
-    ut::DBusAsyncReplyVoid request_set_mouse_primary_button(int32_t button)
-    {
-        return request("setMousePrimaryButton", button);
-    }
-
-    ut::DBusAsyncReplyVoid request_set_touchpad_primary_button(int32_t button)
-    {
-        return request("setTouchpadPrimaryButton", button);
-    }
-
-    ut::DBusAsyncReplyVoid request(char const* requestName, double value)
-    {
-        return invoke_with_reply<ut::DBusAsyncReplyVoid>(
-            unity_input_interface, requestName,
-            DBUS_TYPE_DOUBLE, &value,
-            DBUS_TYPE_INVALID);
-    }
-
-    ut::DBusAsyncReplyVoid request_set_mouse_cursor_speed(double speed)
-    {
-        return request("setMouseCursorSpeed", speed);
-    }
-
-    ut::DBusAsyncReplyVoid request_set_mouse_scroll_speed(double speed)
-    {
-        return request("setMouseScrollSpeed", speed);
-    }
-
-    ut::DBusAsyncReplyVoid request_set_touchpad_cursor_speed(double speed)
-    {
-        return request("setTouchpadCursorSpeed", speed);
-    }
-
-    ut::DBusAsyncReplyVoid request_set_touchpad_scroll_speed(double speed)
-    {
-        return request("setTouchpadScrollSpeed", speed);
-    }
-
-    ut::DBusAsyncReplyVoid request(char const* requestName, bool value)
-    {
-        dbus_bool_t copied = value;
-        return invoke_with_reply<ut::DBusAsyncReplyVoid>(
-            unity_input_interface, requestName,
-            DBUS_TYPE_BOOLEAN, &copied,
-            DBUS_TYPE_INVALID);
-    }
-
-    ut::DBusAsyncReplyVoid request_set_touchpad_two_finger_scroll(bool enabled)
-    {
-        return request("setTouchpadTwoFingerScroll", enabled);
-    }
-
-    ut::DBusAsyncReplyVoid request_set_touchpad_tap_to_click(bool enabled)
-    {
-        return request("setTouchpadTapToClick", enabled);
-    }
-
-    ut::DBusAsyncReplyVoid request_set_touchpad_disable_with_mouse(bool enabled)
-    {
-        return request("setTouchpadDisableWithMouse", enabled);
-    }
-
-    ut::DBusAsyncReplyVoid request_set_touchpad_disable_while_typing(bool enabled)
-    {
-        return request("setTouchpadDisableWhileTyping", enabled);
-    }
-
-    char const* const unity_input_interface = "com.canonical.Unity.Input";
-};
-
 struct AUnityInputService : testing::Test
 {
     std::chrono::seconds const default_timeout{3};
     ut::DBusBus bus;
 
-    std::shared_ptr<MockInputConfiguration> const mock_input_configuration =
-        std::make_shared<testing::NiceMock<MockInputConfiguration>>();
-    UnityInputDBusClient client{bus.address()};
+    std::shared_ptr<ut::MockInputConfiguration> const mock_input_configuration =
+        std::make_shared<testing::NiceMock<ut::MockInputConfiguration>>();
+    ut::UnityInputDBusClient client{bus.address()};
+    std::shared_ptr<usc::DBusEventLoop> const dbus_loop=
+        std::make_shared<usc::DBusEventLoop>();
+    usc::UnityInputService service{dbus_loop, bus.address(), mock_input_configuration};
     std::shared_ptr<usc::DBusConnectionThread> const dbus_thread =
-        std::make_shared<usc::DBusConnectionThread>(bus.address());
-    usc::UnityInputService service{dbus_thread, mock_input_configuration};
+        std::make_shared<usc::DBusConnectionThread>(dbus_loop);
 };
 
 }

=== modified file 'tests/integration-tests/test_unity_screen_service.cpp'
--- tests/integration-tests/test_unity_screen_service.cpp	2015-08-25 14:27:23 +0000
+++ tests/integration-tests/test_unity_screen_service.cpp	2016-01-21 17:48:37 +0000
@@ -19,14 +19,16 @@
 #include "src/unity_screen_service.h"
 #include "src/dbus_connection_handle.h"
 #include "src/dbus_connection_thread.h"
+#include "src/dbus_event_loop.h"
 #include "src/dbus_message_handle.h"
 #include "src/screen.h"
 #include "src/power_state_change_reason.h"
 #include "src/unity_screen_service_introspection.h"
 #include "wait_condition.h"
 #include "dbus_bus.h"
-#include "dbus_client.h"
+#include "unity_screen_dbus_client.h"
 
+#include "usc/test/mock_screen.h"
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
 
@@ -38,157 +40,20 @@
 namespace
 {
 
-struct MockScreen : usc::Screen
-{
-    MOCK_METHOD1(enable_inactivity_timers, void(bool enable));
-    MOCK_METHOD0(keep_display_on_temporarily, void());
-
-    MOCK_METHOD0(get_screen_power_mode, MirPowerMode());
-    MOCK_METHOD2(set_screen_power_mode, void(MirPowerMode mode, PowerStateChangeReason reason));
-    MOCK_METHOD1(keep_display_on, void(bool on));
-    MOCK_METHOD1(set_brightness, void(int brightness));
-    MOCK_METHOD1(enable_auto_brightness, void(bool enable));
-    MOCK_METHOD2(set_inactivity_timeouts, void(int power_off_timeout, int dimmer_timeout));
-
-    MOCK_METHOD1(set_touch_visualization_enabled, void(bool enabled));
-
-    void register_power_state_change_handler(
-        usc::PowerStateChangeHandler const& handler)
-    {
-        power_state_change_handler = handler;
-    }
-
-    usc::PowerStateChangeHandler power_state_change_handler;
-};
-
-class UnityScreenDBusClient : public ut::DBusClient
-{
-public:
-    UnityScreenDBusClient(std::string const& address)
-        : ut::DBusClient{
-            address,
-            "com.canonical.Unity.Screen",
-            "/com/canonical/Unity/Screen"}
-    {
-        connection.add_match(
-            "type='signal',"
-            "interface='com.canonical.Unity.Screen',"
-            "member='DisplayPowerStateChange'");
-    }
-
-    ut::DBusAsyncReplyString request_introspection()
-    {
-        return invoke_with_reply<ut::DBusAsyncReplyString>(
-            "org.freedesktop.DBus.Introspectable", "Introspect",
-            DBUS_TYPE_INVALID);
-    }
-
-    ut::DBusAsyncReplyVoid request_set_user_brightness(int32_t brightness)
-    {
-        return invoke_with_reply<ut::DBusAsyncReplyVoid>(
-            unity_screen_interface, "setUserBrightness",
-            DBUS_TYPE_INT32, &brightness,
-            DBUS_TYPE_INVALID);
-    }
-
-    ut::DBusAsyncReplyVoid request_user_auto_brightness_enable(bool enabled)
-    {
-        dbus_bool_t const e = enabled ? TRUE : FALSE;
-        return invoke_with_reply<ut::DBusAsyncReplyVoid>(
-            unity_screen_interface, "userAutobrightnessEnable",
-            DBUS_TYPE_BOOLEAN, &e,
-            DBUS_TYPE_INVALID);
-    }
-
-    ut::DBusAsyncReplyVoid request_set_inactivity_timeouts(
-        int32_t poweroff_timeout, int32_t dimmer_timeout)
-    {
-        return invoke_with_reply<ut::DBusAsyncReplyVoid>(
-            unity_screen_interface, "setInactivityTimeouts",
-            DBUS_TYPE_INT32, &poweroff_timeout,
-            DBUS_TYPE_INT32, &dimmer_timeout,
-            DBUS_TYPE_INVALID);
-    }
-
-    ut::DBusAsyncReplyVoid request_set_touch_visualization_enabled(bool enabled)
-    {
-        dbus_bool_t const e = enabled ? TRUE : FALSE;
-        return invoke_with_reply<ut::DBusAsyncReplyVoid>(
-            unity_screen_interface, "setTouchVisualizationEnabled",
-            DBUS_TYPE_BOOLEAN, &e,
-            DBUS_TYPE_INVALID);
-    }
-
-    ut::DBusAsyncReplyBool request_set_screen_power_mode(
-        std::string const& mode, int reason)
-    {
-        auto mode_cstr = mode.c_str();
-        return invoke_with_reply<ut::DBusAsyncReplyBool>(
-            unity_screen_interface, "setScreenPowerMode",
-            DBUS_TYPE_STRING, &mode_cstr,
-            DBUS_TYPE_INT32, &reason,
-            DBUS_TYPE_INVALID);
-    }
-
-    ut::DBusAsyncReplyInt request_keep_display_on()
-    {
-        return invoke_with_reply<ut::DBusAsyncReplyInt>(
-            unity_screen_interface, "keepDisplayOn",
-            DBUS_TYPE_INVALID);
-    }
-
-    ut::DBusAsyncReplyVoid request_remove_display_on_request(int id)
-    {
-        return invoke_with_reply<ut::DBusAsyncReplyVoid>(
-            unity_screen_interface, "removeDisplayOnRequest",
-            DBUS_TYPE_INT32, &id,
-            DBUS_TYPE_INVALID);
-    }
-
-    ut::DBusAsyncReply request_invalid_method()
-    {
-        return invoke_with_reply<ut::DBusAsyncReply>(
-            unity_screen_interface, "invalidMethod",
-            DBUS_TYPE_INVALID);
-    }
-
-    ut::DBusAsyncReply request_method_with_invalid_arguments()
-    {
-        char const* const str = "abcd";
-        return invoke_with_reply<ut::DBusAsyncReply>(
-            unity_screen_interface, "setUserBrightness",
-            DBUS_TYPE_STRING, &str,
-            DBUS_TYPE_INVALID);
-    }
-
-    usc::DBusMessageHandle listen_for_power_state_change_signal()
-    {
-        while (true)
-        {
-            dbus_connection_read_write(connection, 1);
-            auto msg = usc::DBusMessageHandle{dbus_connection_pop_message(connection)};
-
-            if (msg && dbus_message_is_signal(msg, "com.canonical.Unity.Screen", "DisplayPowerStateChange"))
-            {
-                return msg;
-            }
-        }
-    }
-
-    char const* const unity_screen_interface = "com.canonical.Unity.Screen";
-};
-
 struct AUnityScreenService : testing::Test
 {
     std::chrono::seconds const default_timeout{3};
     ut::DBusBus bus;
 
-    std::shared_ptr<MockScreen> const mock_screen =
-        std::make_shared<testing::NiceMock<MockScreen>>();
-    UnityScreenDBusClient client{bus.address()};
+    std::shared_ptr<ut::MockScreen> const mock_screen =
+        std::make_shared<testing::NiceMock<ut::MockScreen>>();
+    ut::UnityScreenDBusClient client{bus.address()};
+    std::shared_ptr<usc::DBusEventLoop> const dbus_loop=
+        std::make_shared<usc::DBusEventLoop>();
+    usc::UnityScreenService service{dbus_loop, bus.address(), mock_screen};
     std::shared_ptr<usc::DBusConnectionThread> const dbus_thread =
-        std::make_shared<usc::DBusConnectionThread>(bus.address());
-    usc::UnityScreenService service{dbus_thread, mock_screen};
+        std::make_shared<usc::DBusConnectionThread>(dbus_loop);
+
 };
 
 }
@@ -340,7 +205,7 @@
 {
     using namespace testing;
 
-    UnityScreenDBusClient other_client{bus.address()};
+    ut::UnityScreenDBusClient other_client{bus.address()};
 
     EXPECT_CALL(*mock_screen, keep_display_on(true)).Times(4);
     EXPECT_CALL(*mock_screen, keep_display_on(false)).Times(0);

=== added file 'tests/integration-tests/test_unity_services.cpp'
--- tests/integration-tests/test_unity_services.cpp	1970-01-01 00:00:00 +0000
+++ tests/integration-tests/test_unity_services.cpp	2016-01-21 17:48:37 +0000
@@ -0,0 +1,82 @@
+/*
+ * Copyright © 2016 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Andreas Pokorny <[e-mail]>
+ */
+#include "src/unity_input_service.h"
+#include "src/dbus_connection_handle.h"
+#include "src/dbus_connection_thread.h"
+#include "src/dbus_event_loop.h"
+#include "src/dbus_message_handle.h"
+#include "src/unity_screen_service.h"
+#include "src/unity_input_service_introspection.h"
+#include "src/unity_screen_service_introspection.h"
+
+#include "wait_condition.h"
+#include "dbus_bus.h"
+#include "dbus_client.h"
+#include "unity_input_dbus_client.h"
+#include "unity_screen_dbus_client.h"
+
+#include "usc/test/mock_input_configuration.h"
+#include "usc/test/mock_screen.h"
+
+namespace ut = usc::test;
+using namespace testing;
+
+namespace
+{
+
+struct UnityServices : testing::Test
+{
+    std::chrono::seconds const default_timeout{3};
+    ut::DBusBus bus;
+
+    ut::UnityScreenDBusClient screen_client{bus.address()};
+    ut::UnityInputDBusClient input_client{bus.address()};
+    std::shared_ptr<ut::MockScreen> const mock_screen =
+        std::make_shared<testing::NiceMock<ut::MockScreen>>();
+    std::shared_ptr<ut::MockInputConfiguration> const mock_input_configuration =
+        std::make_shared<testing::NiceMock<ut::MockInputConfiguration>>();
+    std::shared_ptr<usc::DBusEventLoop> const dbus_loop=
+        std::make_shared<usc::DBusEventLoop>();
+    usc::UnityScreenService screen_service{dbus_loop, bus.address(), mock_screen};
+    usc::UnityInputService input_service{dbus_loop, bus.address(), mock_input_configuration};
+    std::shared_ptr<usc::DBusConnectionThread> const dbus_thread =
+        std::make_shared<usc::DBusConnectionThread>(dbus_loop);
+};
+
+}
+
+TEST_F(UnityServices, offer_screen_introspection)
+{
+    auto reply = screen_client.request_introspection();
+    EXPECT_THAT(reply.get(), Eq(unity_screen_service_introspection));
+}
+
+TEST_F(UnityServices, offer_input_introspection)
+{
+    auto reply = input_client.request_introspection();
+    EXPECT_THAT(reply.get(), Eq(unity_input_service_introspection));
+}
+
+TEST_F(UnityServices, provides_access_to_input_methods)
+{
+    double const speed = 8.0;
+
+    EXPECT_CALL(*mock_input_configuration, set_mouse_scroll_speed(speed));
+
+    input_client.request_set_mouse_scroll_speed(speed);
+}

=== added file 'tests/integration-tests/unity_input_dbus_client.cpp'
--- tests/integration-tests/unity_input_dbus_client.cpp	1970-01-01 00:00:00 +0000
+++ tests/integration-tests/unity_input_dbus_client.cpp	2016-01-21 17:48:37 +0000
@@ -0,0 +1,113 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Andreas Pokorny <[e-mail]>
+ */
+
+#include "unity_input_dbus_client.h"
+
+namespace ut = usc::test;
+
+ut::UnityInputDBusClient::UnityInputDBusClient(std::string const& address)
+    : ut::DBusClient{
+        address,
+        "com.canonical.Unity.Input",
+        "/com/canonical/Unity/Input"}
+{
+}
+
+ut::DBusAsyncReplyString ut::UnityInputDBusClient::request_introspection()
+{
+    return invoke_with_reply<ut::DBusAsyncReplyString>(
+        "org.freedesktop.DBus.Introspectable", "Introspect",
+        DBUS_TYPE_INVALID);
+}
+
+ut::DBusAsyncReplyVoid ut::UnityInputDBusClient::request(char const* requestName, int32_t value)
+{
+    return invoke_with_reply<ut::DBusAsyncReplyVoid>(
+        unity_input_interface, requestName,
+        DBUS_TYPE_INT32, &value,
+        DBUS_TYPE_INVALID);
+}
+
+ut::DBusAsyncReplyVoid ut::UnityInputDBusClient::request_set_mouse_primary_button(int32_t button)
+{
+    return request("setMousePrimaryButton", button);
+}
+
+ut::DBusAsyncReplyVoid ut::UnityInputDBusClient::request_set_touchpad_primary_button(int32_t button)
+{
+    return request("setTouchpadPrimaryButton", button);
+}
+
+ut::DBusAsyncReplyVoid ut::UnityInputDBusClient::request(char const* requestName, double value)
+{
+    return invoke_with_reply<ut::DBusAsyncReplyVoid>(
+        unity_input_interface, requestName,
+        DBUS_TYPE_DOUBLE, &value,
+        DBUS_TYPE_INVALID);
+}
+
+ut::DBusAsyncReplyVoid ut::UnityInputDBusClient::request_set_mouse_cursor_speed(double speed)
+{
+    return request("setMouseCursorSpeed", speed);
+}
+
+ut::DBusAsyncReplyVoid ut::UnityInputDBusClient::request_set_mouse_scroll_speed(double speed)
+{
+    return request("setMouseScrollSpeed", speed);
+}
+
+ut::DBusAsyncReplyVoid ut::UnityInputDBusClient::request_set_touchpad_cursor_speed(double speed)
+{
+    return request("setTouchpadCursorSpeed", speed);
+}
+
+ut::DBusAsyncReplyVoid ut::UnityInputDBusClient::request_set_touchpad_scroll_speed(double speed)
+{
+    return request("setTouchpadScrollSpeed", speed);
+}
+
+ut::DBusAsyncReplyVoid ut::UnityInputDBusClient::request(char const* requestName, bool value)
+{
+    dbus_bool_t copied = value;
+    return invoke_with_reply<ut::DBusAsyncReplyVoid>(
+        unity_input_interface, requestName,
+        DBUS_TYPE_BOOLEAN, &copied,
+        DBUS_TYPE_INVALID);
+}
+
+ut::DBusAsyncReplyVoid ut::UnityInputDBusClient::request_set_touchpad_two_finger_scroll(bool enabled)
+{
+    return request("setTouchpadTwoFingerScroll", enabled);
+}
+
+ut::DBusAsyncReplyVoid ut::UnityInputDBusClient::request_set_touchpad_tap_to_click(bool enabled)
+{
+    return request("setTouchpadTapToClick", enabled);
+}
+
+ut::DBusAsyncReplyVoid ut::UnityInputDBusClient::request_set_touchpad_disable_with_mouse(bool enabled)
+{
+    return request("setTouchpadDisableWithMouse", enabled);
+}
+
+ut::DBusAsyncReplyVoid ut::UnityInputDBusClient::request_set_touchpad_disable_while_typing(bool enabled)
+{
+    return request("setTouchpadDisableWhileTyping", enabled);
+}
+
+

=== added file 'tests/integration-tests/unity_input_dbus_client.h'
--- tests/integration-tests/unity_input_dbus_client.h	1970-01-01 00:00:00 +0000
+++ tests/integration-tests/unity_input_dbus_client.h	2016-01-21 17:48:37 +0000
@@ -0,0 +1,52 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Andreas Pokorny <[e-mail]>
+ */
+
+#ifndef USC_TEST_UNITY_INPUT_DBUS_CLIENT_H_
+#define USC_TEST_UNITY_INPUT_DBUS_CLIENT_H_
+
+#include "dbus_client.h"
+
+namespace usc
+{
+namespace test
+{
+class UnityInputDBusClient : public DBusClient
+{
+public:
+    UnityInputDBusClient(std::string const& address);
+    DBusAsyncReplyString request_introspection();
+    DBusAsyncReplyVoid request(char const* requestName, int32_t value);
+    DBusAsyncReplyVoid request_set_mouse_primary_button(int32_t button);
+    DBusAsyncReplyVoid request_set_touchpad_primary_button(int32_t button);
+    DBusAsyncReplyVoid request(char const* requestName, double value);
+    DBusAsyncReplyVoid request_set_mouse_cursor_speed(double speed);
+    DBusAsyncReplyVoid request_set_mouse_scroll_speed(double speed);
+    DBusAsyncReplyVoid request_set_touchpad_cursor_speed(double speed);
+    DBusAsyncReplyVoid request_set_touchpad_scroll_speed(double speed);
+    DBusAsyncReplyVoid request(char const* requestName, bool value);
+    DBusAsyncReplyVoid request_set_touchpad_two_finger_scroll(bool enabled);
+    DBusAsyncReplyVoid request_set_touchpad_tap_to_click(bool enabled);
+    DBusAsyncReplyVoid request_set_touchpad_disable_with_mouse(bool enabled);
+    DBusAsyncReplyVoid request_set_touchpad_disable_while_typing(bool enabled);
+    char const* const unity_input_interface = "com.canonical.Unity.Input";
+};
+
+}
+}
+
+#endif

=== added file 'tests/integration-tests/unity_screen_dbus_client.cpp'
--- tests/integration-tests/unity_screen_dbus_client.cpp	1970-01-01 00:00:00 +0000
+++ tests/integration-tests/unity_screen_dbus_client.cpp	2016-01-21 17:48:37 +0000
@@ -0,0 +1,112 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Andreas Pokorny <[e-mail]>
+ */
+
+#include "unity_screen_dbus_client.h"
+#include "src/dbus_message_handle.h"
+
+namespace ut = usc::test;
+
+ut::UnityScreenDBusClient::UnityScreenDBusClient(std::string const& address)
+    : ut::DBusClient{
+        address,
+        "com.canonical.Unity.Screen",
+        "/com/canonical/Unity/Screen"}
+{
+    connection.add_match(
+        "type='signal',"
+        "interface='com.canonical.Unity.Screen',"
+        "member='DisplayPowerStateChange'");
+}
+
+ut::DBusAsyncReplyString ut::UnityScreenDBusClient::request_introspection()
+{
+    return invoke_with_reply<ut::DBusAsyncReplyString>("org.freedesktop.DBus.Introspectable", "Introspect",
+                                                       DBUS_TYPE_INVALID);
+}
+
+ut::DBusAsyncReplyVoid ut::UnityScreenDBusClient::request_set_user_brightness(int32_t brightness)
+{
+    return invoke_with_reply<ut::DBusAsyncReplyVoid>(unity_screen_interface, "setUserBrightness", DBUS_TYPE_INT32,
+                                                     &brightness, DBUS_TYPE_INVALID);
+}
+
+ut::DBusAsyncReplyVoid ut::UnityScreenDBusClient::request_user_auto_brightness_enable(bool enabled)
+{
+    dbus_bool_t const e = enabled ? TRUE : FALSE;
+    return invoke_with_reply<ut::DBusAsyncReplyVoid>(unity_screen_interface, "userAutobrightnessEnable",
+                                                     DBUS_TYPE_BOOLEAN, &e, DBUS_TYPE_INVALID);
+}
+
+ut::DBusAsyncReplyVoid ut::UnityScreenDBusClient::request_set_inactivity_timeouts(int32_t poweroff_timeout,
+                                                                                  int32_t dimmer_timeout)
+{
+    return invoke_with_reply<ut::DBusAsyncReplyVoid>(unity_screen_interface, "setInactivityTimeouts", DBUS_TYPE_INT32,
+                                                     &poweroff_timeout, DBUS_TYPE_INT32, &dimmer_timeout,
+                                                     DBUS_TYPE_INVALID);
+}
+
+ut::DBusAsyncReplyVoid ut::UnityScreenDBusClient::request_set_touch_visualization_enabled(bool enabled)
+{
+    dbus_bool_t const e = enabled ? TRUE : FALSE;
+    return invoke_with_reply<ut::DBusAsyncReplyVoid>(unity_screen_interface, "setTouchVisualizationEnabled",
+                                                     DBUS_TYPE_BOOLEAN, &e, DBUS_TYPE_INVALID);
+}
+
+ut::DBusAsyncReplyBool ut::UnityScreenDBusClient::request_set_screen_power_mode(std::string const& mode, int reason)
+{
+    auto mode_cstr = mode.c_str();
+    return invoke_with_reply<ut::DBusAsyncReplyBool>(unity_screen_interface, "setScreenPowerMode", DBUS_TYPE_STRING,
+                                                     &mode_cstr, DBUS_TYPE_INT32, &reason, DBUS_TYPE_INVALID);
+}
+
+ut::DBusAsyncReplyInt ut::UnityScreenDBusClient::request_keep_display_on()
+{
+    return invoke_with_reply<ut::DBusAsyncReplyInt>(unity_screen_interface, "keepDisplayOn", DBUS_TYPE_INVALID);
+}
+
+ut::DBusAsyncReplyVoid ut::UnityScreenDBusClient::request_remove_display_on_request(int id)
+{
+    return invoke_with_reply<ut::DBusAsyncReplyVoid>(unity_screen_interface, "removeDisplayOnRequest", DBUS_TYPE_INT32,
+                                                     &id, DBUS_TYPE_INVALID);
+}
+
+ut::DBusAsyncReply ut::UnityScreenDBusClient::request_invalid_method()
+{
+    return invoke_with_reply<ut::DBusAsyncReply>(unity_screen_interface, "invalidMethod", DBUS_TYPE_INVALID);
+}
+
+ut::DBusAsyncReply ut::UnityScreenDBusClient::request_method_with_invalid_arguments()
+{
+    char const* const str = "abcd";
+    return invoke_with_reply<ut::DBusAsyncReply>(unity_screen_interface, "setUserBrightness", DBUS_TYPE_STRING, &str,
+                                                 DBUS_TYPE_INVALID);
+}
+
+usc::DBusMessageHandle ut::UnityScreenDBusClient::listen_for_power_state_change_signal()
+{
+    while (true)
+    {
+        dbus_connection_read_write(connection, 1);
+        auto msg = usc::DBusMessageHandle{dbus_connection_pop_message(connection)};
+
+        if (msg && dbus_message_is_signal(msg, "com.canonical.Unity.Screen", "DisplayPowerStateChange"))
+        {
+            return msg;
+        }
+    }
+}

=== added file 'tests/integration-tests/unity_screen_dbus_client.h'
--- tests/integration-tests/unity_screen_dbus_client.h	1970-01-01 00:00:00 +0000
+++ tests/integration-tests/unity_screen_dbus_client.h	2016-01-21 17:48:37 +0000
@@ -0,0 +1,54 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Andreas Pokorny <[e-mail]>
+ */
+
+#ifndef USC_TEST_UNITY_SCREEN_DBUS_CLIENT_H_
+#define USC_TEST_UNITY_SCREEN_DBUS_CLIENT_H_
+
+#include "dbus_client.h"
+
+namespace usc
+{
+namespace test
+{
+
+class UnityScreenDBusClient : public DBusClient
+{
+public:
+    UnityScreenDBusClient(std::string const& address);
+
+    DBusAsyncReplyString request_introspection();
+    DBusAsyncReplyVoid request_set_user_brightness(int32_t brightness);
+    DBusAsyncReplyVoid request_user_auto_brightness_enable(bool enabled);
+    DBusAsyncReplyVoid request_set_inactivity_timeouts(
+        int32_t poweroff_timeout, int32_t dimmer_timeout);
+    DBusAsyncReplyVoid request_set_touch_visualization_enabled(bool enabled);
+    DBusAsyncReplyBool request_set_screen_power_mode(
+        std::string const& mode, int reason);
+
+    DBusAsyncReplyInt request_keep_display_on();
+    DBusAsyncReplyVoid request_remove_display_on_request(int id);
+    DBusAsyncReply request_invalid_method();
+    DBusAsyncReply request_method_with_invalid_arguments();
+    usc::DBusMessageHandle listen_for_power_state_change_signal();
+    char const* const unity_screen_interface = "com.canonical.Unity.Screen";
+};
+
+}
+}
+
+#endif

=== modified file 'tests/unit-tests/CMakeLists.txt'
--- tests/unit-tests/CMakeLists.txt	2015-02-18 14:40:29 +0000
+++ tests/unit-tests/CMakeLists.txt	2016-01-21 17:48:37 +0000
@@ -25,6 +25,7 @@
   test_session_switcher.cpp
   test_screen_event_handler.cpp
   test_mir_screen.cpp
+  test_mir_input_configuration.cpp
 
   advanceable_timer.cpp
 )

=== added file 'tests/unit-tests/test_mir_input_configuration.cpp'
--- tests/unit-tests/test_mir_input_configuration.cpp	1970-01-01 00:00:00 +0000
+++ tests/unit-tests/test_mir_input_configuration.cpp	2016-01-21 17:48:37 +0000
@@ -0,0 +1,114 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Andreas Pokorny <[e-mail]>
+ */
+
+
+#include "src/mir_input_configuration.h"
+#include "mir/input/input_device_hub.h"
+#include "mir/input/device_capability.h"
+#include "mir/input/input_device_observer.h"
+#include "mir/input/device.h"
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+namespace mi = mir::input;
+
+using namespace ::testing;
+
+namespace
+{
+struct MockDevice : mi::Device
+{
+    MOCK_CONST_METHOD0(id, MirInputDeviceId());
+    MOCK_CONST_METHOD0(capabilities, mi::DeviceCapabilities());
+    MOCK_CONST_METHOD0(name, std::string());
+    MOCK_CONST_METHOD0(unique_id, std::string());
+    MOCK_CONST_METHOD0(pointer_configuration, mir::optional_value<mi::PointerConfiguration>());
+    MOCK_METHOD1(apply_pointer_configuration, void(mi::PointerConfiguration const&));
+    MOCK_CONST_METHOD0(touchpad_configuration, mir::optional_value<mi::TouchpadConfiguration> ());
+    MOCK_METHOD1(apply_touchpad_configuration, void(mi::TouchpadConfiguration const&));
+
+    MockDevice(mi::DeviceCapabilities caps)
+        : caps(caps)
+    {
+        ON_CALL(*this, capabilities()).WillByDefault(Return(this->caps));
+    }
+
+    mi::DeviceCapabilities caps;
+};
+
+struct MockInputDeviceHub : mi::InputDeviceHub
+{
+    MOCK_METHOD1(add_observer,void(std::shared_ptr<mi::InputDeviceObserver> const&));
+    MOCK_METHOD1(remove_observer,void(std::weak_ptr<mi::InputDeviceObserver> const&));
+};
+
+struct MirInputConfiguration : ::testing::Test
+{
+    template<typename T>
+    using shared_mock = std::shared_ptr<::testing::NiceMock<T>>;
+    shared_mock<MockInputDeviceHub> mock_hub{std::make_shared<::testing::NiceMock<MockInputDeviceHub>>()};
+    shared_mock<MockDevice> mock_mouse{
+        std::make_shared<::testing::NiceMock<MockDevice>>(mi::DeviceCapability::pointer)};
+    shared_mock<MockDevice> mock_touchpad{std::make_shared<::testing::NiceMock<MockDevice>>(
+        mi::DeviceCapability::pointer | mi::DeviceCapability::touchpad)};
+    shared_mock<MockDevice> mock_keyboard{std::make_shared<::testing::NiceMock<MockDevice>>(
+        mi::DeviceCapability::keyboard | mi::DeviceCapability::alpha_numeric)};
+
+    std::shared_ptr<mi::InputDeviceObserver> obs;
+
+    MirInputConfiguration()
+    {
+        ON_CALL(*mock_hub, add_observer(_)).WillByDefault(SaveArg<0>(&obs));
+    }
+};
+}
+
+TEST_F(MirInputConfiguration, registers_something_as_device_observer)
+{
+    EXPECT_CALL(*mock_hub, add_observer(_));
+
+    usc::MirInputConfiguration config(mock_hub);
+}
+
+TEST_F(MirInputConfiguration, configures_device_on_add)
+{
+    usc::MirInputConfiguration config(mock_hub);
+
+    EXPECT_CALL(*mock_touchpad, apply_pointer_configuration(_));
+    EXPECT_CALL(*mock_touchpad, apply_touchpad_configuration(_));
+    obs->device_added(mock_touchpad);
+}
+
+TEST_F(MirInputConfiguration, configures_mouse_on_add)
+{
+    usc::MirInputConfiguration config(mock_hub);
+
+    EXPECT_CALL(*mock_mouse, apply_pointer_configuration(_));
+    obs->device_added(mock_mouse);
+}
+
+TEST_F(MirInputConfiguration, ignores_keyboard_when_added)
+{
+    usc::MirInputConfiguration config(mock_hub);
+
+    EXPECT_CALL(*mock_keyboard, apply_touchpad_configuration(_)).Times(0);
+    EXPECT_CALL(*mock_keyboard, apply_pointer_configuration(_)).Times(0);
+    obs->device_added(mock_keyboard);
+}
+

=== modified file 'tests/unit-tests/test_screen_event_handler.cpp'
--- tests/unit-tests/test_screen_event_handler.cpp	2015-12-01 13:53:20 +0000
+++ tests/unit-tests/test_screen_event_handler.cpp	2016-01-21 17:48:37 +0000
@@ -203,23 +203,50 @@
     touch_screen();
 }
 
-TEST_F(AScreenEventHandler, keeps_display_on_temporarily_on_pointer_event)
-{
+TEST_F(AScreenEventHandler, turns_on_screen_and_filters_first_pointer_event_when_screen_is_off)
+{
+    mock_screen.mock_mode = MirPowerMode::mir_power_mode_off;
+    EXPECT_CALL(mock_screen,
+                set_screen_power_mode(MirPowerMode::mir_power_mode_on,
+                                      PowerStateChangeReason::unknown));
+
+    auto const event_filtered = screen_event_handler.handle(*pointer_event);
+    EXPECT_TRUE(event_filtered);
+}
+
+TEST_F(AScreenEventHandler, turns_on_screen_and_propagates_keys_when_screen_is_off)
+{
+    mock_screen.mock_mode = MirPowerMode::mir_power_mode_off;
+    EXPECT_CALL(mock_screen,
+                set_screen_power_mode(MirPowerMode::mir_power_mode_on,
+                                      PowerStateChangeReason::unknown));
+
+    auto const event_filtered = screen_event_handler.handle(*another_key_down_event);
+    EXPECT_FALSE(event_filtered);
+}
+
+TEST_F(AScreenEventHandler, keeps_display_on_temporarily_for_pointer_event_when_screen_is_on)
+{
+    mock_screen.mock_mode = MirPowerMode::mir_power_mode_on;
     EXPECT_CALL(mock_screen, keep_display_on_temporarily());
 
     move_pointer();
 }
 
-TEST_F(AScreenEventHandler, keeps_display_on_temporarily_on_other_keys)
+TEST_F(AScreenEventHandler, keeps_display_on_temporarily_key_event_when_screen_is_on)
 {
+    mock_screen.mock_mode = MirPowerMode::mir_power_mode_on;
     EXPECT_CALL(mock_screen, keep_display_on_temporarily());
 
     press_a_key();
 }
 
-TEST_F(AScreenEventHandler, does_not_keep_display_on_for_volume_keys)
+TEST_F(AScreenEventHandler, does_not_affect_screen_state_for_volume_keys)
 {
+    using namespace testing;
+
     EXPECT_CALL(mock_screen, keep_display_on_temporarily()).Times(0);
+    EXPECT_CALL(mock_screen, set_screen_power_mode(_,_)).Times(0);
 
     press_volume_keys();
 }
@@ -255,10 +282,12 @@
     release_power_key();
 }
 
-TEST_F(AScreenEventHandler, passes_through_all_handled_events)
+TEST_F(AScreenEventHandler, passes_through_all_handled_events_when_screen_is_on)
 {
     using namespace testing;
 
+    mock_screen.mock_mode = MirPowerMode::mir_power_mode_on;
+
     EXPECT_FALSE(screen_event_handler.handle(*power_key_down_event));
     EXPECT_FALSE(screen_event_handler.handle(*power_key_up_event));
     EXPECT_FALSE(screen_event_handler.handle(*touch_event));