Merge lp:~robertcarr/mir/improve-input-manager-testing into lp:~mir-team/mir/trunk

[Robert Carr]

Extract dependencies of mia::InputManager in to mia::InputConfiguration interface (with mia::DefaultInputConfiguration implementation).

This branch improves the testability of the InputManager wrt to the Input stack by isolating input components through an InputConfiguration object (Input input input input!).

New test is tests/unit-tests/input/android/test_android_input_manager.cpp

This is a lot of refactoring for a pretty trivial test at the moment but important when the interaction with the dispatcher becomes more complex (i.e. setInputWindows for client side input).

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:483
http://jenkins.qa.ubuntu.com/job/mir-ci/1145/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-ci/./build=pbuilder,distribution=quantal,flavor=amd64/1145/console

Click here to trigger a rebuild:
http://jenkins.qa.ubuntu.com/job/mir-ci/1145//rebuild/?

review: Approve (continuous-integration)

[Alexandros Frantzis (afrantzis)]

827 + fake_event_hub = dynamic_cast<mia::FakeEventHub *>(configuration->the_event_hub().get()); // For convenience
890 + fake_event_hub = dynamic_cast<mia::FakeEventHub *>(configuration->the_event_hub().get()); // For convenience

It would be cleaner to have a mia::FakeEventHub& FakeEventHubInputConfiguration::the_fake_event_hub() method, and use it to access the underlying fake object.

376 std::shared_ptr<mi::InputManager> mi::create_input_manager(

Would it make sense for mi::create_input_manager() to accept a mi::InputConfiguration object, so that it could be configured externally, or is the input configuration just an internal convenience/testability enhancement?

1057 +#include "mir/input/cursor_listener.h"
1084 +static const std::shared_ptr<mi::CursorListener> null_cursor_listener{};
1085 +static std::initializer_list<std::shared_ptr<mi::EventFilter> const> empty_event_filters{};

Are these used somewhere?

1086 +static const geom::Rectangle default_view_area =

Is this useful outside the test fixture construction?

review: Needs Fixing

[Robert Carr (robertcarr)]

>> It would be cleaner to have a mia::FakeEventHub& FakeEventHubInputConfiguration::the_fake_event_hub()
>> method, and use it to access the underlying fake object.

Yes. Had to use mia::FakeEventHub* due to deleted assignment on android::RefBase however.

376 std::shared_ptr<mi::InputManager> mi::create_input_manager(
I don't think so I think it accepts parameters to create the configuration and the configuration is an internal object. Maybe this will change when we have input options.

>> 1057 +#include "mir/input/cursor_listener.h"
>> 1084 +static const std::shared_ptr<mi::CursorListener> null_cursor_listener{};
>> 1085 +static std::initializer_list<std::shared_ptr<mi::EventFilter> const> empty_event_filters{};
Gone!

>> 1086 +static const geom::Rectangle default_view_area =

Moved!

[Alan Griffiths (alan-griffiths)]

123 + mir::CachedPtr<frontend::Communicator> communicator;
...

Adding "mir::" is pointless noise.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:486
http://jenkins.qa.ubuntu.com/job/mir-ci/1150/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-ci/./build=pbuilder,distribution=quantal,flavor=amd64/1150/console

Click here to trigger a rebuild:
http://jenkins.qa.ubuntu.com/job/mir-ci/1150//rebuild/?

review: Approve (continuous-integration)

[Robert Carr (robertcarr)]

>> Adding "mir::" is pointless noise.

Removed

[Alan Griffiths (alan-griffiths)]

include/mir/cached_ptr.h etc.

copyright header should be LGPL

review: Needs Fixing

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:487
http://jenkins.qa.ubuntu.com/job/mir-ci/1151/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-ci/./build=pbuilder,distribution=quantal,flavor=amd64/1151/console

Click here to trigger a rebuild:
http://jenkins.qa.ubuntu.com/job/mir-ci/1151//rebuild/?

review: Approve (continuous-integration)

[Robert Carr (robertcarr)]

Fixed copyright headers

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:488
http://jenkins.qa.ubuntu.com/job/mir-ci/1154/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-ci/./build=pbuilder,distribution=quantal,flavor=amd64/1154/console

Click here to trigger a rebuild:
http://jenkins.qa.ubuntu.com/job/mir-ci/1154//rebuild/?

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:489
http://jenkins.qa.ubuntu.com/job/mir-ci/1156/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-ci/./build=pbuilder,distribution=quantal,flavor=amd64/1156/console

Click here to trigger a rebuild:
http://jenkins.qa.ubuntu.com/job/mir-ci/1156//rebuild/?

review: Approve (continuous-integration)

[Alan Griffiths (alan-griffiths)]

LGTM

review: Approve

[Alexandros Frantzis (afrantzis)]

Looks good.

review: Approve

[PS Jenkins bot (ps-jenkins)]

review: Approve (continuous-integration)

=== modified file '3rd_party/android-deps/std/Vector.h'
--- 3rd_party/android-deps/std/Vector.h	2013-03-04 16:23:13 +0000
+++ 3rd_party/android-deps/std/Vector.h	2013-03-06 17:03:21 +0000
@@ -56,7 +56,7 @@
     * Constructors and destructors
     */
     Vector() = default;
-    Vector(const Vector<ValueType>& rhs) = default;
+    Vector(const Vector<ValueType>& /* rhs */) = default;
 //  explicit Vector(const SortedVector<ValueType>& rhs);
     virtual ~Vector() {}
 

=== added file 'include/mir/cached_ptr.h'
--- include/mir/cached_ptr.h	1970-01-01 00:00:00 +0000
+++ include/mir/cached_ptr.h	2013-03-06 17:03:21 +0000
@@ -0,0 +1,48 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser 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 Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Robert Carr <[e-mail]>
+ */
+
+#ifndef MIR_CACHED_PTR_H_
+#define MIR_CACHED_PTR_H_
+
+#include <functional>
+#include <memory>
+
+namespace mir
+{
+template<typename Type>
+class CachedPtr
+{
+    std::weak_ptr<Type> cache;
+    CachedPtr(CachedPtr const&) = delete;
+    CachedPtr& operator=(CachedPtr const&) = delete;
+public:
+    CachedPtr() = default;
+
+    std::shared_ptr<Type> operator()(std::function<std::shared_ptr<Type>()> make)
+    {
+        auto result = cache.lock();
+        if (!result)
+        {
+                cache = result = make();
+        }
+        return result;
+    }
+};
+} // namespace mir
+
+#endif // MIR_CACHED_PTR_H_

=== modified file 'include/mir/default_server_configuration.h'
--- include/mir/default_server_configuration.h	2013-03-05 18:29:19 +0000
+++ include/mir/default_server_configuration.h	2013-03-06 17:03:21 +0000
@@ -18,6 +18,7 @@
 #ifndef MIR_DEFAULT_SERVER_CONFIGURATION_H_
 #define MIR_DEFAULT_SERVER_CONFIGURATION_H_
 
+#include "mir/cached_ptr.h"
 #include "mir/server_configuration.h"
 #include "mir/options/program_option.h"
 
@@ -108,29 +109,6 @@
 protected:
     virtual std::shared_ptr<options::Option> the_options() const;
 
-    template<typename Type>
-    class CachedPtr
-    {
-        std::weak_ptr<Type> cache;
-
-        CachedPtr(CachedPtr const&) = delete;
-        CachedPtr& operator=(CachedPtr const&) = delete;
-    public:
-        CachedPtr() = default;
-
-        std::shared_ptr<Type> operator()(std::function<std::shared_ptr<Type>()> make)
-        {
-            auto result = cache.lock();
-            if (!result)
-            {
-                cache = result = make();
-            }
-
-            return result;
-
-        }
-    };
-
     CachedPtr<frontend::Communicator> communicator;
     CachedPtr<sessions::SessionStore> session_store;
     CachedPtr<input::InputManager>    input_manager;

=== added file 'include/mir_test/fake_event_hub_input_configuration.h'
--- include/mir_test/fake_event_hub_input_configuration.h	1970-01-01 00:00:00 +0000
+++ include/mir_test/fake_event_hub_input_configuration.h	2013-03-06 17:03:21 +0000
@@ -0,0 +1,80 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser 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 Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Author: Robert Carr <[e-mail]>
+ */
+
+#ifndef MIR_TEST_DOUBLES_FAKE_EVENT_HUB_INPUT_CONFIGURATION_H_
+#define MIR_TEST_DOUBLES_FAKE_EVENT_HUB_INPUT_CONFIGURATION_H_
+
+#include "src/input/android/default_android_input_configuration.h"
+
+#include <utils/StrongPointer.h>
+
+#include <initializer_list>
+
+namespace droidinput = android;
+
+namespace android
+{
+class EventHubInterface;
+}
+
+namespace mir
+{
+namespace graphics
+{
+class ViewableArea;
+}
+namespace input
+{
+class CursorListener;
+class EventFilter;
+
+namespace android
+{
+class FakeEventHub;
+}
+}
+namespace test
+{
+namespace doubles
+{
+
+class FakeEventHubInputConfiguration : public input::android::DefaultInputConfiguration
+{
+public:
+    FakeEventHubInputConfiguration(std::initializer_list<std::shared_ptr<mir::input::EventFilter> const> const& filters,
+                                   std::shared_ptr<mir::graphics::ViewableArea> const& view_area,
+                                   std::shared_ptr<mir::input::CursorListener> const& cursor_listener);
+    virtual ~FakeEventHubInputConfiguration();
+
+    droidinput::sp<droidinput::EventHubInterface> the_event_hub();
+    input::android::FakeEventHub* the_fake_event_hub();
+    
+
+protected:
+    FakeEventHubInputConfiguration(FakeEventHubInputConfiguration const&) = delete;
+    FakeEventHubInputConfiguration& operator=(FakeEventHubInputConfiguration const&) = delete;
+
+private:
+    droidinput::sp<input::android::FakeEventHub> event_hub;
+};
+
+}
+}
+} // namespace mir
+
+#endif /* MIR_TEST_DOUBLES_FAKE_EVENT_HUB_INPUT_CONFIGURATION_H_ */

=== modified file 'src/input/android/CMakeLists.txt'
--- src/input/android/CMakeLists.txt	2013-03-04 15:54:45 +0000
+++ src/input/android/CMakeLists.txt	2013-03-06 17:03:21 +0000
@@ -6,6 +6,7 @@
   ${CMAKE_CURRENT_SOURCE_DIR}/android_input_lexicon.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/rudimentary_input_reader_policy.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/event_filter_dispatcher_policy.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/default_android_input_configuration.cpp
 )
 
 set(

=== added file 'src/input/android/android_input_configuration.h'
--- src/input/android/android_input_configuration.h	1970-01-01 00:00:00 +0000
+++ src/input/android/android_input_configuration.h	2013-03-06 17:03:21 +0000
@@ -0,0 +1,61 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser 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 Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Robert Carr <[e-mail]>
+ */
+
+#ifndef MIR_INPUT_ANDROID_INPUT_CONFIGURATION_H_
+#define MIR_INPUT_ANDROID_INPUT_CONFIGURATION_H_
+
+#include <utils/StrongPointer.h>
+
+#include <memory>
+
+namespace droidinput = android;
+
+namespace android
+{
+class EventHubInterface;
+class InputDispatcherInterface;
+}
+
+namespace mir
+{
+namespace input
+{
+namespace android
+{
+class InputThread;
+
+class InputConfiguration
+{
+public:
+    virtual ~InputConfiguration() {}
+    
+    virtual droidinput::sp<droidinput::EventHubInterface> the_event_hub() = 0;
+    virtual droidinput::sp<droidinput::InputDispatcherInterface> the_dispatcher() = 0;
+    virtual std::shared_ptr<InputThread> the_dispatcher_thread() = 0;
+    virtual std::shared_ptr<InputThread> the_reader_thread() = 0;
+
+protected:
+    InputConfiguration() = default;
+    InputConfiguration(InputConfiguration const&) = delete;
+    InputConfiguration& operator=(InputConfiguration const&) = delete;
+};
+}
+}
+} // namespace mir
+
+#endif // MIR_INPUT_ANDROID_INPUT_CONFIGURATION_H_

=== modified file 'src/input/android/android_input_manager.cpp'
--- src/input/android/android_input_manager.cpp	2013-03-04 16:02:02 +0000
+++ src/input/android/android_input_manager.cpp	2013-03-06 17:03:21 +0000
@@ -21,12 +21,12 @@
 
 #include "android_input_manager.h"
 #include "android_input_constants.h"
-#include "event_filter_dispatcher_policy.h"
-#include "android_input_reader_policy.h"
+#include "android_input_configuration.h"
+#include "android_input_thread.h"
+#include "default_android_input_configuration.h"
 
 #include <EventHub.h>
 #include <InputDispatcher.h>
-#include <InputReader.h>
 
 #include <memory>
 #include <vector>
@@ -35,24 +35,12 @@
 namespace mi = mir::input;
 namespace mia = mi::android;
 
-mia::InputManager::InputManager(
-    const droidinput::sp<droidinput::EventHubInterface>& event_hub,
-    const std::initializer_list<std::shared_ptr<mi::EventFilter> const>& filters,
-    std::shared_ptr<mg::ViewableArea> const& view_area,
-    std::shared_ptr<mi::CursorListener> const& cursor_listener)
-        : event_hub(event_hub),
-          filter_chain(std::make_shared<mi::EventFilterChain>(filters)),
-          dispatcher(new droidinput::InputDispatcher(
-              new mia::EventFilterDispatcherPolicy(filter_chain))),
-          reader(new droidinput::InputReader(
-              event_hub,
-              new mia::InputReaderPolicy(view_area, cursor_listener),
-              dispatcher)),
-          reader_thread(new droidinput::InputReaderThread(reader)),
-          dispatcher_thread(new droidinput::InputDispatcherThread(dispatcher))
+mia::InputManager::InputManager(std::shared_ptr<mia::InputConfiguration> const& config)
+  : event_hub(config->the_event_hub()),
+    dispatcher(config->the_dispatcher()),
+    reader_thread(config->the_reader_thread()),
+    dispatcher_thread(config->the_dispatcher_thread())
 {
-    dispatcher->setInputDispatchMode(mia::DispatchEnabled, mia::DispatchUnfrozen);
-    dispatcher->setInputFilterEnabled(true);
 }
 
 mia::InputManager::~InputManager()
@@ -61,19 +49,22 @@
 
 void mia::InputManager::stop()
 {
-    dispatcher_thread->requestExit();
+    dispatcher_thread->request_stop();
     dispatcher->setInputDispatchMode(mia::DispatchDisabled, mia::DispatchFrozen);
     dispatcher_thread->join();
 
-    reader_thread->requestExit();
+    reader_thread->request_stop();
     event_hub->wake();
     reader_thread->join();
 }
 
 void mia::InputManager::start()
 {
-    reader_thread->run("InputReader", droidinput::PRIORITY_URGENT_DISPLAY);
-    dispatcher_thread->run("InputDispatcher", droidinput::PRIORITY_URGENT_DISPLAY);
+    dispatcher->setInputDispatchMode(mia::DispatchEnabled, mia::DispatchUnfrozen);
+    dispatcher->setInputFilterEnabled(true);
+
+    reader_thread->start();
+    dispatcher_thread->start();
 }
 
 std::shared_ptr<mi::InputManager> mi::create_input_manager(
@@ -81,11 +72,7 @@
     std::shared_ptr<mg::ViewableArea> const& view_area)
 {
     static const std::shared_ptr<mi::CursorListener> null_cursor_listener{};
-    droidinput::sp<droidinput::EventHubInterface> event_hub(new droidinput::EventHub());
+    auto config = std::make_shared<mia::DefaultInputConfiguration>(event_filters, view_area, null_cursor_listener);
 
-    return std::make_shared<mia::InputManager>(
-        event_hub,
-        event_filters,
-        view_area,
-        null_cursor_listener);
+    return std::make_shared<mia::InputManager>(config);
 }

=== modified file 'src/input/android/android_input_manager.h'
--- src/input/android/android_input_manager.h	2013-03-04 16:02:02 +0000
+++ src/input/android/android_input_manager.h	2013-03-06 17:03:21 +0000
@@ -21,7 +21,6 @@
 #define MIR_INPUT_ANDROID_INPUT_MANAGER_H_
 
 #include "mir/input/input_manager.h"
-#include "../event_filter_chain.h"
 
 #include <utils/StrongPointer.h>
 
@@ -30,10 +29,7 @@
 namespace android
 {
 class EventHubInterface;
-class InputDispatcher;
-class InputDispatcherThread;
-class InputReader;
-class InputReaderThread;
+class InputDispatcherInterface;
 }
 
 namespace droidinput = android;
@@ -46,20 +42,18 @@
 }
 namespace input
 {
-
 class CursorListener;
 
 namespace android
 {
+class InputThread;
+class InputConfiguration;
 
 class InputManager : public mir::input::InputManager
 {
 public:
     explicit InputManager(
-        const droidinput::sp<droidinput::EventHubInterface>& event_hub,
-        const std::initializer_list<std::shared_ptr<input::EventFilter> const>& filters,
-        std::shared_ptr<graphics::ViewableArea> const& view_area,
-        std::shared_ptr<CursorListener> const& cursor_listener);
+        std::shared_ptr<InputConfiguration> const& input_configuration);
     virtual ~InputManager();
 
     virtual void start();
@@ -71,14 +65,10 @@
 
 private:
     droidinput::sp<droidinput::EventHubInterface> event_hub;
-    std::shared_ptr<EventFilterChain> filter_chain;
-    droidinput::sp<droidinput::InputDispatcher> dispatcher;
-    droidinput::sp<droidinput::InputReader> reader;
+    droidinput::sp<droidinput::InputDispatcherInterface> dispatcher;
 
-    // It's important to keep droidinput::sp to dispatcher_thread
-    // and reader_thread or they will free themselves on exit.
-    droidinput::sp<droidinput::InputReaderThread> reader_thread;
-    droidinput::sp<droidinput::InputDispatcherThread> dispatcher_thread;
+    std::shared_ptr<InputThread> reader_thread;
+    std::shared_ptr<InputThread> dispatcher_thread;
 };
 
 }

=== added file 'src/input/android/android_input_thread.h'
--- src/input/android/android_input_thread.h	1970-01-01 00:00:00 +0000
+++ src/input/android/android_input_thread.h	2013-03-06 17:03:21 +0000
@@ -0,0 +1,47 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser 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 Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Robert Carr <[e-mail]>
+ */
+
+#ifndef MIR_INPUT_ANDROID_INPUT_THREAD_H_
+#define MIR_INPUT_ANDROID_INPUT_THREAD_H_
+
+namespace mir
+{
+namespace input
+{
+namespace android
+{
+class InputThread
+{
+public:
+    virtual ~InputThread() {}
+
+    virtual void start() = 0;
+    virtual void request_stop() = 0;
+    virtual void join() = 0;
+
+protected:
+    InputThread() {};
+    InputThread(const InputThread&) = delete;
+    InputThread& operator=(const InputThread&) = delete;
+};
+
+}
+}
+} // namespace mir
+
+#endif // MIR_INPUT_ANDROID_INPUT_THREAD_H_

=== added file 'src/input/android/default_android_input_configuration.cpp'
--- src/input/android/default_android_input_configuration.cpp	1970-01-01 00:00:00 +0000
+++ src/input/android/default_android_input_configuration.cpp	2013-03-06 17:03:21 +0000
@@ -0,0 +1,149 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser 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 Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Robert Carr <[e-mail]>
+ */
+
+#include "default_android_input_configuration.h"
+#include "event_filter_dispatcher_policy.h"
+#include "android_input_reader_policy.h"
+#include "android_input_thread.h"
+#include "../event_filter_chain.h"
+
+#include <EventHub.h>
+#include <InputDispatcher.h>
+#include <InputReader.h>
+
+namespace droidinput = android;
+
+namespace mi = mir::input;
+namespace mia = mi::android;
+namespace mg = mir::graphics;
+
+namespace
+{
+class CommonInputThread : public mia::InputThread
+{
+public:
+    CommonInputThread(std::string const& name, droidinput::sp<droidinput::Thread> const& thread)
+      : name(name),
+        thread(thread)
+    {
+    }
+    virtual ~CommonInputThread()
+    {
+    }
+    
+    void start()
+    {
+        thread->run(name.c_str(), droidinput::PRIORITY_URGENT_DISPLAY);
+    }
+    void request_stop()
+    {
+        thread->requestExit();
+    }
+    void join()
+    {
+        thread->join();
+    }
+   
+protected:
+    CommonInputThread(const CommonInputThread&) = delete;
+    CommonInputThread& operator=(const CommonInputThread&) = delete;
+
+private:
+    std::string const name;
+    droidinput::sp<droidinput::Thread> const thread;
+};
+}
+
+mia::DefaultInputConfiguration::DefaultInputConfiguration(std::initializer_list<std::shared_ptr<mi::EventFilter> const> const& filters,
+                                                          std::shared_ptr<mg::ViewableArea> const& view_area,
+                                                          std::shared_ptr<mi::CursorListener> const& cursor_listener)
+  : filter_chain(std::make_shared<mi::EventFilterChain>(filters)),
+    view_area(view_area),
+    cursor_listener(cursor_listener)
+{
+}
+
+mia::DefaultInputConfiguration::~DefaultInputConfiguration()
+{
+}
+
+droidinput::sp<droidinput::EventHubInterface> mia::DefaultInputConfiguration::the_event_hub()
+{
+    return event_hub(
+        [this]()
+        {
+            return new droidinput::EventHub();
+        });
+}
+
+droidinput::sp<droidinput::InputDispatcherPolicyInterface> mia::DefaultInputConfiguration::the_dispatcher_policy()
+{
+    return dispatcher_policy(
+        [this]()
+        {
+            return new mia::EventFilterDispatcherPolicy(filter_chain);
+        });
+}
+
+droidinput::sp<droidinput::InputDispatcherInterface> mia::DefaultInputConfiguration::the_dispatcher()
+{
+    return dispatcher(
+        [this]()
+        {
+            return new droidinput::InputDispatcher(the_dispatcher_policy());
+        });
+}
+
+droidinput::sp<droidinput::InputReaderPolicyInterface> mia::DefaultInputConfiguration::the_reader_policy()
+{
+    return reader_policy(
+        [this]()
+        {
+            return new mia::InputReaderPolicy(view_area, cursor_listener);
+        });
+}
+
+
+droidinput::sp<droidinput::InputReaderInterface> mia::DefaultInputConfiguration::the_reader()
+{
+    return reader(
+        [this]()
+        {
+            return new droidinput::InputReader(the_event_hub(), the_reader_policy(), the_dispatcher());
+        });
+}
+
+std::shared_ptr<mia::InputThread> mia::DefaultInputConfiguration::the_dispatcher_thread()
+{
+    return dispatcher_thread(
+        [this]()
+        {
+            return std::make_shared<CommonInputThread>("InputDispatcher",
+                                                       new droidinput::InputDispatcherThread(the_dispatcher()));
+        });
+}
+
+std::shared_ptr<mia::InputThread> mia::DefaultInputConfiguration::the_reader_thread()
+{
+    return reader_thread(
+        [this]()
+        {
+            return std::make_shared<CommonInputThread>("InputReader",
+                                                       new droidinput::InputReaderThread(the_reader()));
+        });
+}

=== added file 'src/input/android/default_android_input_configuration.h'
--- src/input/android/default_android_input_configuration.h	1970-01-01 00:00:00 +0000
+++ src/input/android/default_android_input_configuration.h	2013-03-06 17:03:21 +0000
@@ -0,0 +1,117 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser 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 Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Robert Carr <[e-mail]>
+ */
+
+#ifndef MIR_INPUT_ANDROID_DEFAULT_ANDROID_INPUT_CONFIGURATION_H_
+#define MIR_INPUT_ANDROID_DEFAULT_ANDROID_INPUT_CONFIGURATION_H_
+
+#include "android_input_configuration.h"
+
+#include "mir/cached_ptr.h"
+
+#include <utils/RefBase.h>
+#include <utils/StrongPointer.h>
+
+#include <functional>
+
+namespace droidinput = android;
+
+namespace android
+{
+class InputReaderInterface;
+class InputReaderPolicyInterface;
+class InputDispatcherPolicyInterface;
+}
+
+namespace mir
+{
+namespace graphics
+{
+class ViewableArea;
+}
+namespace input
+{
+class EventFilter;
+class EventFilterChain;
+class CursorListener;
+
+namespace android
+{
+
+class DefaultInputConfiguration : public InputConfiguration
+{
+public:
+    DefaultInputConfiguration(std::initializer_list<std::shared_ptr<EventFilter> const> const& filters,
+                              std::shared_ptr<graphics::ViewableArea> const& view_area,
+                              std::shared_ptr<CursorListener> const& cursor_listener);
+    virtual ~DefaultInputConfiguration();
+    
+    droidinput::sp<droidinput::EventHubInterface> the_event_hub();
+    droidinput::sp<droidinput::InputDispatcherInterface> the_dispatcher();
+    droidinput::sp<droidinput::InputReaderInterface> the_reader();
+
+    std::shared_ptr<InputThread> the_dispatcher_thread();
+    std::shared_ptr<InputThread> the_reader_thread();
+
+    virtual droidinput::sp<droidinput::InputDispatcherPolicyInterface> the_dispatcher_policy();
+    virtual droidinput::sp<droidinput::InputReaderPolicyInterface> the_reader_policy();
+
+protected:
+    DefaultInputConfiguration(DefaultInputConfiguration const&) = delete;
+    DefaultInputConfiguration& operator=(DefaultInputConfiguration const&) = delete;
+
+private:
+    template <typename Type>
+    class CachedAndroidPtr
+    {
+        droidinput::wp<Type> cache;
+        
+        CachedAndroidPtr(CachedAndroidPtr const&) = delete;
+        CachedAndroidPtr& operator=(CachedAndroidPtr const&) = delete;
+
+    public:
+        CachedAndroidPtr() = default;
+        
+        droidinput::sp<Type> operator()(std::function<droidinput::sp<Type>()> make)
+        {
+            auto result = cache.promote();
+            if (!result.get())
+            {
+                cache = result = make();
+            }
+            return result;
+        }
+    };
+
+    std::shared_ptr<EventFilterChain> const filter_chain;
+    std::shared_ptr<graphics::ViewableArea> const view_area;
+    std::shared_ptr<CursorListener> const cursor_listener;
+    
+    CachedPtr<InputThread> dispatcher_thread;
+    CachedPtr<InputThread> reader_thread;
+    CachedAndroidPtr<droidinput::EventHubInterface> event_hub;
+    CachedAndroidPtr<droidinput::InputDispatcherPolicyInterface> dispatcher_policy;
+    CachedAndroidPtr<droidinput::InputReaderPolicyInterface> reader_policy;
+    CachedAndroidPtr<droidinput::InputDispatcherInterface> dispatcher;
+    CachedAndroidPtr<droidinput::InputReaderInterface> reader;
+};
+
+}
+}
+} // namespace mir
+
+#endif // MIR_INPUT_ANDROID_DEFAULT_ANDROID_INPUT_CONFIGURATION_H_

=== modified file 'tests/integration-tests/input/android/test_android_cursor_listener.cpp'
--- tests/integration-tests/input/android/test_android_cursor_listener.cpp	2013-02-21 17:39:09 +0000
+++ tests/integration-tests/input/android/test_android_cursor_listener.cpp	2013-03-06 17:03:21 +0000
@@ -19,10 +19,12 @@
 
 #include "mir/input/event_filter.h"
 #include "src/input/android/android_input_manager.h"
+#include "src/input/android/default_android_input_configuration.h"
 #include "mir/input/cursor_listener.h"
 
 #include "mir_test/fake_shared.h"
 #include "mir_test/fake_event_hub.h"
+#include "mir_test/fake_event_hub_input_configuration.h"
 #include "mir_test_doubles/mock_event_filter.h"
 #include "mir_test/wait_condition.h"
 #include "mir_test/event_factory.h"
@@ -57,22 +59,24 @@
 {
     void SetUp()
     {
-        event_hub = new mia::FakeEventHub();
-
         static const geom::Rectangle visible_rectangle
         {
             geom::Point(),
             geom::Size{geom::Width(1024), geom::Height(1024)}
         };
 
+        configuration = std::make_shared<mtd::FakeEventHubInputConfiguration>(
+            std::initializer_list<std::shared_ptr<mi::EventFilter> const>{mt::fake_shared(event_filter)},
+            mt::fake_shared(viewable_area),
+            mt::fake_shared(cursor_listener));
+
         ON_CALL(viewable_area, view_area())
             .WillByDefault(Return(visible_rectangle));
 
-        input_manager.reset(new mia::InputManager(
-            event_hub,
-            {mt::fake_shared(event_filter)},
-            mt::fake_shared(viewable_area),
-            mt::fake_shared(cursor_listener)));
+        fake_event_hub = configuration->the_fake_event_hub();
+
+        input_manager = std::make_shared<mia::InputManager>(configuration);
+
         input_manager->start();
     }
 
@@ -81,7 +85,8 @@
         input_manager->stop();
     }
 
-    android::sp<mia::FakeEventHub> event_hub;
+    std::shared_ptr<mtd::FakeEventHubInputConfiguration> configuration;
+    mia::FakeEventHub* fake_event_hub;
     MockEventFilter event_filter;
     NiceMock<mtd::MockViewableArea> viewable_area;
     std::shared_ptr<mia::InputManager> input_manager;
@@ -106,10 +111,10 @@
     EXPECT_CALL(event_filter, handles(_))
             .WillOnce(ReturnFalseAndWakeUp(wait_condition));
 
-    event_hub->synthesize_builtin_cursor_added();
-    event_hub->synthesize_device_scan_complete();
+    fake_event_hub->synthesize_builtin_cursor_added();
+    fake_event_hub->synthesize_device_scan_complete();
 
-    event_hub->synthesize_event(mis::a_motion_event().with_movement(x, y));
+    fake_event_hub->synthesize_event(mis::a_motion_event().with_movement(x, y));
 
     wait_condition->wait_for_at_most_seconds(1);
 }

=== modified file 'tests/integration-tests/input/android/test_android_input_manager.cpp'
--- tests/integration-tests/input/android/test_android_input_manager.cpp	2013-02-05 18:12:46 +0000
+++ tests/integration-tests/input/android/test_android_input_manager.cpp	2013-03-06 17:03:21 +0000
@@ -18,15 +18,19 @@
  */
 
 #include "mir/input/event_filter.h"
+#include "src/input/android/default_android_input_configuration.h"
 #include "src/input/android/android_input_manager.h"
 
 #include "mir_test/fake_shared.h"
 #include "mir_test/fake_event_hub.h"
+#include "mir_test/fake_event_hub_input_configuration.h"
 #include "mir_test_doubles/mock_event_filter.h"
 #include "mir_test_doubles/mock_viewable_area.h"
 #include "mir_test/wait_condition.h"
 #include "mir_test/event_factory.h"
 
+#include <EventHub.h>
+
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
@@ -54,18 +58,15 @@
 class AndroidInputManagerAndEventFilterDispatcherSetup : public testing::Test
 {
 public:
-    void SetUp()
+    AndroidInputManagerAndEventFilterDispatcherSetup()
     {
+        configuration = std::make_shared<mtd::FakeEventHubInputConfiguration>(std::initializer_list<std::shared_ptr<mi::EventFilter> const>{mt::fake_shared(event_filter)}, mt::fake_shared(viewable_area), null_cursor_listener);
         ON_CALL(viewable_area, view_area())
             .WillByDefault(Return(default_view_area));
+        
+        fake_event_hub = configuration->the_fake_event_hub();
 
-        event_hub = new mia::FakeEventHub();
-        input_manager.reset(
-            new mia::InputManager(
-                event_hub,
-                {mt::fake_shared(event_filter)},
-                mt::fake_shared(viewable_area),
-                null_cursor_listener));
+        input_manager = std::make_shared<mia::InputManager>(configuration);
 
         input_manager->start();
     }
@@ -76,7 +77,8 @@
     }
 
   protected:
-    android::sp<mia::FakeEventHub> event_hub;
+    std::shared_ptr<mtd::FakeEventHubInputConfiguration> configuration;
+    mia::FakeEventHub* fake_event_hub;
     std::shared_ptr<mia::InputManager> input_manager;
     MockEventFilter event_filter;
     NiceMock<mtd::MockViewableArea> viewable_area;
@@ -96,10 +98,10 @@
             .Times(1)
             .WillOnce(ReturnFalseAndWakeUp(&wait_condition));
 
-    event_hub->synthesize_builtin_keyboard_added();
-    event_hub->synthesize_device_scan_complete();
+    fake_event_hub->synthesize_builtin_keyboard_added();
+    fake_event_hub->synthesize_device_scan_complete();
 
-    event_hub->synthesize_event(mis::a_key_down_event()
+    fake_event_hub->synthesize_event(mis::a_key_down_event()
                                 .of_scancode(KEY_ENTER));
 
     wait_condition.wait_for_at_most_seconds(1);
@@ -117,10 +119,10 @@
             .Times(1)
             .WillOnce(ReturnFalseAndWakeUp(&wait_condition));
 
-    event_hub->synthesize_builtin_cursor_added();
-    event_hub->synthesize_device_scan_complete();
+    fake_event_hub->synthesize_builtin_cursor_added();
+    fake_event_hub->synthesize_device_scan_complete();
 
-    event_hub->synthesize_event(mis::a_button_down_event().of_button(BTN_LEFT));
+    fake_event_hub->synthesize_event(mis::a_button_down_event().of_button(BTN_LEFT));
 
     wait_condition.wait_for_at_most_seconds(1);
 }
@@ -143,11 +145,11 @@
             .WillOnce(ReturnFalseAndWakeUp(&wait_condition));
     }
 
-    event_hub->synthesize_builtin_cursor_added();
-    event_hub->synthesize_device_scan_complete();
+    fake_event_hub->synthesize_builtin_cursor_added();
+    fake_event_hub->synthesize_device_scan_complete();
 
-    event_hub->synthesize_event(mis::a_motion_event().with_movement(100,100));
-    event_hub->synthesize_event(mis::a_motion_event().with_movement(100,0));
+    fake_event_hub->synthesize_event(mis::a_motion_event().with_movement(100,100));
+    fake_event_hub->synthesize_event(mis::a_motion_event().with_movement(100,0));
 
     wait_condition.wait_for_at_most_seconds(1);
 }

=== modified file 'tests/mir_test_doubles/CMakeLists.txt'
--- tests/mir_test_doubles/CMakeLists.txt	2013-03-04 15:54:45 +0000
+++ tests/mir_test_doubles/CMakeLists.txt	2013-03-06 17:03:21 +0000
@@ -13,6 +13,7 @@
 if (NOT MIR_DISABLE_INPUT)
 list(APPEND TEST_UTILS_SRCS
   fake_event_hub.cpp
+  fake_event_hub_input_configuration.cpp
 )
 endif()
 

=== added file 'tests/mir_test_doubles/fake_event_hub_input_configuration.cpp'
--- tests/mir_test_doubles/fake_event_hub_input_configuration.cpp	1970-01-01 00:00:00 +0000
+++ tests/mir_test_doubles/fake_event_hub_input_configuration.cpp	2013-03-06 17:03:21 +0000
@@ -0,0 +1,48 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser 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 Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Robert Carr <[e-mail]>
+ */
+
+#include "mir_test/fake_event_hub_input_configuration.h"
+#include "mir_test/fake_event_hub.h"
+
+namespace mi = mir::input;
+namespace mia = mi::android;
+namespace mg = mir::graphics;
+namespace mtd = mir::test::doubles;
+
+mtd::FakeEventHubInputConfiguration::FakeEventHubInputConfiguration(
+    std::initializer_list<std::shared_ptr<mir::input::EventFilter> const> const& filters,
+    std::shared_ptr<mir::graphics::ViewableArea> const& view_area,
+    std::shared_ptr<mir::input::CursorListener> const& cursor_listener)
+      : DefaultInputConfiguration(filters, view_area, cursor_listener)
+{
+    event_hub = new mia::FakeEventHub();
+}
+
+mtd::FakeEventHubInputConfiguration::~FakeEventHubInputConfiguration()
+{
+}
+
+droidinput::sp<droidinput::EventHubInterface> mtd::FakeEventHubInputConfiguration::the_event_hub()
+{
+    return event_hub;
+}
+
+mia::FakeEventHub* mtd::FakeEventHubInputConfiguration::the_fake_event_hub()
+{
+    return event_hub.get();
+}

=== modified file 'tests/unit-tests/input/android/CMakeLists.txt'
--- tests/unit-tests/input/android/CMakeLists.txt	2013-03-04 15:54:45 +0000
+++ tests/unit-tests/input/android/CMakeLists.txt	2013-03-06 17:03:21 +0000
@@ -4,6 +4,7 @@
   ${CMAKE_CURRENT_SOURCE_DIR}/test_android_pointer_controller.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_android_input_lexicon.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_android_input_reader_policy.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_android_input_manager.cpp
 )
 
 set(

=== added file 'tests/unit-tests/input/android/test_android_input_manager.cpp'
--- tests/unit-tests/input/android/test_android_input_manager.cpp	1970-01-01 00:00:00 +0000
+++ tests/unit-tests/input/android/test_android_input_manager.cpp	2013-03-06 17:03:21 +0000
@@ -0,0 +1,198 @@
+/*
+ * Copyright © 2013 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser 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 Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Robert Carr <[e-mail]>
+ */
+
+#include "src/input/android/android_input_manager.h"
+#include "src/input/android/android_input_configuration.h"
+#include "src/input/android/android_input_thread.h"
+#include "src/input/android/android_input_constants.h"
+
+#include "mir_test_doubles/mock_viewable_area.h"
+#include "mir_test/fake_shared.h"
+
+#include <InputDispatcher.h>
+#include <InputListener.h>
+#include <EventHub.h>
+#include <utils/StrongPointer.h>
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+#include <initializer_list>
+
+namespace droidinput = android;
+
+namespace mi = mir::input;
+namespace mia = mir::input::android;
+namespace mg = mir::graphics;
+namespace geom = mir::geometry;
+namespace mt = mir::test;
+namespace mtd = mt::doubles;
+
+// Mock objects
+namespace
+{
+
+struct MockInputConfiguration : public mia::InputConfiguration
+{
+    MOCK_METHOD0(the_event_hub, droidinput::sp<droidinput::EventHubInterface>());
+    MOCK_METHOD0(the_dispatcher, droidinput::sp<droidinput::InputDispatcherInterface>());
+    MOCK_METHOD0(the_dispatcher_thread, std::shared_ptr<mia::InputThread>());
+    MOCK_METHOD0(the_reader_thread, std::shared_ptr<mia::InputThread>());
+};
+
+struct MockInputDispatcher : public droidinput::InputDispatcherInterface
+{
+    // droidinput::InputDispatcher interface
+    MOCK_METHOD1(dump, void(droidinput::String8&));
+    MOCK_METHOD0(monitor, void());
+    MOCK_METHOD0(dispatchOnce, void());
+    MOCK_METHOD6(injectInputEvent, int32_t(droidinput::InputEvent const*, int32_t, int32_t, int32_t, int32_t, uint32_t));
+    MOCK_METHOD1(setInputWindows, void(droidinput::Vector<droidinput::sp<droidinput::InputWindowHandle>> const&));
+    MOCK_METHOD1(setFocusedApplication, void(droidinput::sp<droidinput::InputApplicationHandle> const&));
+    MOCK_METHOD2(setInputDispatchMode, void(bool, bool));
+    MOCK_METHOD1(setInputFilterEnabled, void(bool));
+    MOCK_METHOD2(transferTouchFocus, bool(droidinput::sp<droidinput::InputChannel> const&, droidinput::sp<droidinput::InputChannel> const&));
+    MOCK_METHOD3(registerInputChannel, droidinput::status_t(droidinput::sp<droidinput::InputChannel> const&, droidinput::sp<droidinput::InputWindowHandle> const&, bool));
+    MOCK_METHOD1(unregisterInputChannel, droidinput::status_t(droidinput::sp<droidinput::InputChannel> const&));
+
+    // droidinput::InputListener interface
+    MOCK_METHOD1(notifyConfigurationChanged, void(droidinput::NotifyConfigurationChangedArgs const*));
+    MOCK_METHOD1(notifyKey, void(droidinput::NotifyKeyArgs const*));
+    MOCK_METHOD1(notifyMotion, void(droidinput::NotifyMotionArgs const*));
+    MOCK_METHOD1(notifySwitch, void(droidinput::NotifySwitchArgs const*));
+    MOCK_METHOD1(notifyDeviceReset, void(droidinput::NotifyDeviceResetArgs const*));
+};
+
+struct MockEventHub : public droidinput::EventHubInterface
+{
+    MOCK_CONST_METHOD1(getDeviceClasses, uint32_t(int32_t));
+    MOCK_CONST_METHOD1(getDeviceIdentifier, droidinput::InputDeviceIdentifier(int32_t));
+    MOCK_CONST_METHOD2(getConfiguration, void(int32_t, droidinput::PropertyMap*));
+    MOCK_CONST_METHOD3(getAbsoluteAxisInfo, droidinput::status_t(int32_t, int, droidinput::RawAbsoluteAxisInfo*));
+    MOCK_CONST_METHOD2(hasRelativeAxis, bool(int32_t, int));
+    MOCK_CONST_METHOD2(hasInputProperty, bool(int32_t, int));
+    MOCK_CONST_METHOD5(mapKey, droidinput::status_t(int32_t, int32_t, int32_t, int32_t*, uint32_t*));
+    MOCK_CONST_METHOD3(mapAxis, droidinput::status_t(int32_t, int32_t, droidinput::AxisInfo*));
+    MOCK_METHOD1(setExcludedDevices, void(droidinput::Vector<droidinput::String8> const&));
+    MOCK_METHOD3(getEvents, size_t(int, droidinput::RawEvent*, size_t));
+    MOCK_CONST_METHOD2(getScanCodeState, int32_t(int32_t, int32_t));
+    MOCK_CONST_METHOD2(getKeyCodeState, int32_t(int32_t, int32_t));
+    MOCK_CONST_METHOD2(getSwitchState, int32_t(int32_t, int32_t));
+    MOCK_CONST_METHOD3(getAbsoluteAxisValue, droidinput::status_t(int32_t, int32_t, int32_t*));
+    MOCK_CONST_METHOD4(markSupportedKeyCodes, bool(int32_t, size_t, int32_t const*, uint8_t*));
+    MOCK_CONST_METHOD2(hasScanCode, bool(int32_t, int32_t));
+    MOCK_CONST_METHOD2(hasLed, bool(int32_t, int32_t));
+    MOCK_METHOD3(setLedState, void(int32_t, int32_t, bool));
+    MOCK_CONST_METHOD2(getVirtualKeyDefinitions, void(int32_t, droidinput::Vector<droidinput::VirtualKeyDefinition>&));
+    MOCK_CONST_METHOD1(getKeyCharacterMap, droidinput::sp<droidinput::KeyCharacterMap>(int32_t));
+    MOCK_METHOD2(setKeyboardLayoutOverlay, bool(int32_t, const droidinput::sp<droidinput::KeyCharacterMap>&));
+    MOCK_METHOD2(vibrate, void(int32_t, nsecs_t));
+    MOCK_METHOD1(cancelVibrate, void(int32_t));
+    MOCK_METHOD0(requestReopenDevices, void());
+    MOCK_METHOD0(wake, void());
+    MOCK_METHOD1(dump, void(droidinput::String8&));
+    MOCK_METHOD0(monitor, void());
+};
+
+struct MockInputThread : public mia::InputThread
+{
+    MOCK_METHOD0(start, void());
+    MOCK_METHOD0(request_stop, void());
+    MOCK_METHOD0(join, void());
+};
+
+}
+
+// Test fixture
+namespace
+{
+
+struct AndroidInputManagerSetup : public testing::Test
+{
+    void SetUp()
+    {
+        using namespace ::testing;
+
+        const geom::Rectangle default_view_area =
+            geom::Rectangle{geom::Point(),
+                            geom::Size{geom::Width(1600), geom::Height(1400)}};
+
+
+        ON_CALL(view_area, view_area())
+            .WillByDefault(Return(default_view_area));
+
+        event_hub = new MockEventHub();
+        dispatcher = new MockInputDispatcher();
+        dispatcher_thread = std::make_shared<MockInputThread>();
+        reader_thread = std::make_shared<MockInputThread>();
+
+        ON_CALL(config, the_event_hub()).WillByDefault(Return(event_hub));
+        ON_CALL(config, the_dispatcher()).WillByDefault(Return(dispatcher));
+        ON_CALL(config, the_reader_thread()).WillByDefault(Return(reader_thread));
+        ON_CALL(config, the_dispatcher_thread()).WillByDefault(Return(dispatcher_thread));
+    }
+    mtd::MockViewableArea view_area;
+
+    testing::NiceMock<MockInputConfiguration> config;
+    droidinput::sp<MockEventHub> event_hub;
+    droidinput::sp<MockInputDispatcher> dispatcher;
+    std::shared_ptr<MockInputThread> dispatcher_thread;
+    std::shared_ptr<MockInputThread> reader_thread;
+};
+
+}
+
+TEST_F(AndroidInputManagerSetup, takes_input_setup_from_configuration)
+{
+    using namespace ::testing;
+    
+    EXPECT_CALL(config, the_event_hub()).Times(1);
+    EXPECT_CALL(config, the_dispatcher()).Times(1);
+    EXPECT_CALL(config, the_reader_thread()).Times(1);
+    EXPECT_CALL(config, the_dispatcher_thread()).Times(1);
+    
+    mia::InputManager manager(mt::fake_shared(config));
+    
+}
+
+TEST_F(AndroidInputManagerSetup, start_and_stop)
+{
+    using namespace ::testing;
+    
+    EXPECT_CALL(*dispatcher, setInputDispatchMode(mia::DispatchEnabled, mia::DispatchUnfrozen)).Times(1);
+    EXPECT_CALL(*dispatcher, setInputFilterEnabled(true)).Times(1);
+
+    EXPECT_CALL(*reader_thread, start()).Times(1);
+    EXPECT_CALL(*dispatcher_thread, start()).Times(1);
+    
+    {
+        InSequence seq;
+        
+        EXPECT_CALL(*dispatcher_thread, request_stop());
+        EXPECT_CALL(*dispatcher, setInputDispatchMode(mia::DispatchDisabled, mia::DispatchFrozen)).Times(1);
+        EXPECT_CALL(*dispatcher_thread, join());
+        EXPECT_CALL(*reader_thread, request_stop());
+        EXPECT_CALL(*event_hub, wake());
+        EXPECT_CALL(*reader_thread, join());
+    }
+
+    mia::InputManager manager(mt::fake_shared(config));
+
+    manager.start();
+    manager.stop();
+}