Merge lp:~robertcarr/mir/reflow-input-focus-selection into lp:~mir-team/mir/trunk

[Robert Carr]

Rework interface between DispatcherController and shell in terms of an InputTargetListener

This branch reworks the DispatcherController and shell in terms of an input target listener.

While this rework is generally useful (preparing for touch picking by maintaining full window list, general efficiency/cleanliness) it was driven by a bug in the old code. Recreating the window handles caused the input fds to be closed, so it was not possible to cycle focus (noticed this when input stops working in the demo shell after you alt tab ;))

TEST_F(AndroidInputManagerDispatcherInterceptSetup, changing_focus_changes_event_recipient)

is the test which failed before.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:609
http://jenkins.qa.ubuntu.com/job/mir-ci/402/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-android-raring-i386-build/405/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-clang-raring-amd64-build/288/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/407/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-vm-ci-build/./distribution=precise,flavor=amd64/184

Click here to trigger a rebuild:
http://s-jenkins:8080/job/mir-ci/402/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:610
http://jenkins.qa.ubuntu.com/job/mir-ci/403/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-raring-i386-build/406
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-clang-raring-amd64-build/289/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/408/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-vm-ci-build/./distribution=precise,flavor=amd64/186

Click here to trigger a rebuild:
http://s-jenkins:8080/job/mir-ci/403/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:612
http://jenkins.qa.ubuntu.com/job/mir-ci/406/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-raring-i386-build/410
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-clang-raring-amd64-build/293/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/411
        deb: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/411/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-vm-ci-build/./distribution=precise,flavor=amd64/190

Click here to trigger a rebuild:
http://s-jenkins:8080/job/mir-ci/406/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:613
http://jenkins.qa.ubuntu.com/job/mir-ci/407/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-raring-i386-build/412
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-raring-amd64-build/295
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/412
        deb: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/412/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-vm-ci-build/./distribution=precise,flavor=amd64/191

Click here to trigger a rebuild:
http://s-jenkins:8080/job/mir-ci/407/rebuild

review: Approve (continuous-integration)

[Alan Griffiths (alan-griffiths)]

"GNU Lesser General Public" outside of client/shared libraries

review: Needs Fixing

[Alan Griffiths (alan-griffiths)]

Hmm there are merge conflicts too

[Robert Carr (robertcarr)]

Merged trunk! Fixed licenses.

[Alexandros Frantzis (afrantzis)]

704 -mia::EventFilterDispatcherPolicy::EventFilterDispatcherPolicy(std::shared_ptr<mi::EventFilter> const& event_filter) :
705 - event_filter(event_filter)
706 +mia::EventFilterDispatcherPolicy::EventFilterDispatcherPolicy(std::shared_ptr<mi::EventFilter> const& event_filter, bool key_repeat_enabled) :
707 + event_filter(event_filter),
708 + key_repeat_enabled(key_repeat_enabled)

Are these changes (and other related changes) relevant to this MP?

167 +#define MIR_SHELL_INPUT_LISTENER_H_

Mismatch between file/class name and include guard.

review: Needs Fixing

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:614
http://jenkins.qa.ubuntu.com/job/mir-ci/434/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-raring-i386-build/447
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-raring-amd64-build/330
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/439
        deb: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/439/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-vm-ci-build/./distribution=precise,flavor=amd64/209

Click here to trigger a rebuild:
http://s-jenkins:8080/job/mir-ci/434/rebuild

review: Approve (continuous-integration)

[Alan Griffiths (alan-griffiths)]

Now there are merge conflicts

review: Needs Fixing

[Robert Carr (robertcarr)]

Trunk merged, header guards fixed.

Key-repeat-enabled changes are useful for the test. Without disabling key repeat, the tests are racey or the code becomes noisy (need to trigger key release events, handle more events, etc...)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:616
http://jenkins.qa.ubuntu.com/job/mir-ci/456/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-raring-i386-build/481
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-raring-amd64-build/364
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/461
        deb: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/461/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins:8080/job/mir-ci/456/rebuild

review: Approve (continuous-integration)

[Alan Griffiths (alan-griffiths)]

$ bin/unit-tests | grep "GMOCK WARNING:" | wc -l
2

review: Needs Fixing

[Robert Carr (robertcarr)]

Fixed gmock warnings

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:617
http://jenkins.qa.ubuntu.com/job/mir-ci/464/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-raring-i386-build/494
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-raring-amd64-build/377
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/469
        deb: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/469/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-vm-ci-build/./distribution=precise,flavor=amd64/224

Click here to trigger a rebuild:
http://s-jenkins:8080/job/mir-ci/464/rebuild

review: Approve (continuous-integration)

[Alan Griffiths (alan-griffiths)]

OK

review: Approve

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:618
http://jenkins.qa.ubuntu.com/job/mir-ci/467/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-raring-i386-build/497
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-raring-amd64-build/380
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/472
        deb: http://jenkins.qa.ubuntu.com/job/mir-quantal-amd64-ci/472/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-vm-ci-build/./distribution=precise,flavor=amd64/226

Click here to trigger a rebuild:
http://s-jenkins:8080/job/mir-ci/467/rebuild

review: Approve (continuous-integration)

[Kevin DuBois (kdub)]

looks good to me too

review: Approve

=== modified file 'include/server/mir/default_server_configuration.h'
--- include/server/mir/default_server_configuration.h	2013-04-19 15:59:41 +0000
+++ include/server/mir/default_server_configuration.h	2013-04-22 15:55:31 +0000
@@ -50,7 +50,7 @@
 {
 class SurfaceFactory;
 class SurfaceBuilder;
-class InputFocusSelector;
+class InputTargetListener;
 class SessionContainer;
 class FocusSetter;
 class FocusSequence;
@@ -156,7 +156,6 @@
     /** @name shell configuration - dependencies
      * dependencies of shell on the rest of the Mir
      *  @{ */
-    virtual std::shared_ptr<shell::InputFocusSelector> the_input_focus_selector();
     virtual std::shared_ptr<shell::SurfaceBuilder>     the_surface_builder();
     /** @} */
 
@@ -178,6 +177,7 @@
      *  @{ */
     virtual std::shared_ptr<input::android::InputConfiguration> the_input_configuration();
     virtual std::initializer_list<std::shared_ptr<input::EventFilter> const> the_event_filters();
+    virtual std::shared_ptr<shell::InputTargetListener> the_input_target_listener();
     /** @} */
 
     /** @name logging configuration - customization
@@ -197,7 +197,7 @@
     CachedPtr<frontend::Shell> session_manager;
     std::shared_ptr<input::android::InputConfiguration> input_configuration;
     CachedPtr<input::InputManager>    input_manager;
-    CachedPtr<shell::InputFocusSelector> input_focus_selector;
+    CachedPtr<shell::InputTargetListener> input_target_listener;
     CachedPtr<graphics::Platform>     graphics_platform;
     CachedPtr<graphics::BufferInitializer> buffer_initializer;
     CachedPtr<compositor::GraphicBufferAllocator> buffer_allocator;

=== modified file 'include/server/mir/input/input_manager.h'
--- include/server/mir/input/input_manager.h	2013-04-16 09:08:29 +0000
+++ include/server/mir/input/input_manager.h	2013-04-22 15:55:31 +0000
@@ -21,7 +21,6 @@
 #define MIR_INPUT_INPUT_MANAGER_H_
 
 #include "mir/input/input_channel_factory.h"
-#include "mir/shell/input_focus_selector.h"
 
 #include <memory>
 

=== modified file 'include/server/mir/input/null_input_manager.h'
--- include/server/mir/input/null_input_manager.h	2013-04-16 09:08:29 +0000
+++ include/server/mir/input/null_input_manager.h	2013-04-22 15:55:31 +0000
@@ -40,11 +40,6 @@
         return std::shared_ptr<InputChannel>();
     }
 
-    virtual void set_input_focus_to(std::shared_ptr<input::SessionTarget> const& /* session */,
-                                    std::shared_ptr<input::SurfaceTarget> const& /* surface */)
-    {
-    }
-
 protected:
     NullInputManager(const NullInputManager&) = delete;
     NullInputManager& operator=(const NullInputManager&) = delete;

=== renamed file 'include/server/mir/input/null_input_focus_selector.h' => 'include/server/mir/input/null_input_target_listener.h'
--- include/server/mir/input/null_input_focus_selector.h	2013-04-17 02:04:35 +0000
+++ include/server/mir/input/null_input_target_listener.h	2013-04-22 15:55:31 +0000
@@ -16,33 +16,48 @@
  * Authored by: Robert Carr <[e-mail]>
  */
 
-#ifndef MIR_INPUT_NULL_INPUT_FOCUS_SELECTOR_H_
-#define MIR_INPUT_NULL_INPUT_FOCUS_SELECTOR_H_
+#ifndef MIR_INPUT_NULL_INPUT_TARGET_LISTENER_H_
+#define MIR_INPUT_NULL_INPUT_TARGET_LISTENER_H_
 
-#include "mir/shell/input_focus_selector.h"
+#include "mir/shell/input_target_listener.h"
 
 namespace mir
 {
 namespace input
 {
 
-class NullInputFocusSelector : public shell::InputFocusSelector
+class NullInputTargetListener : public shell::InputTargetListener
 {
 public:
-    NullInputFocusSelector() {};
-    virtual ~NullInputFocusSelector() {}
+    NullInputTargetListener() {};
+    virtual ~NullInputTargetListener() noexcept(true) {}
     
-    virtual void set_input_focus_to(std::shared_ptr<input::SessionTarget> const&,
-                                    std::shared_ptr<input::SurfaceTarget> const&)
+    virtual void input_application_opened(std::shared_ptr<input::SessionTarget> const&)
+    {
+    }
+    virtual void input_application_closed(std::shared_ptr<input::SessionTarget> const&)
+    {
+    }
+    virtual void input_surface_opened(std::shared_ptr<input::SessionTarget> const&,
+                                      std::shared_ptr<input::SurfaceTarget> const&)
+    {
+    }
+    virtual void input_surface_closed(std::shared_ptr<input::SurfaceTarget> const&)
+    {
+    }
+    virtual void focus_changed(std::shared_ptr<input::SurfaceTarget> const&)
+    {
+    }
+    virtual void focus_cleared()
     {
     }
 
 protected:
-    NullInputFocusSelector(const NullInputFocusSelector&) = delete;
-    NullInputFocusSelector& operator=(const NullInputFocusSelector&) = delete;
+    NullInputTargetListener(const NullInputTargetListener&) = delete;
+    NullInputTargetListener& operator=(const NullInputTargetListener&) = delete;
 };
 
 }
 }
 
-#endif // MIR_INPUT_NULL_INPUT_FOCUS_SELECTOR_H_
+#endif // MIR_INPUT_NULL_INPUT_TARGET_LISTENER_H_

=== modified file 'include/server/mir/shell/application_session.h'
--- include/server/mir/shell/application_session.h	2013-04-16 17:42:26 +0000
+++ include/server/mir/shell/application_session.h	2013-04-22 15:55:31 +0000
@@ -30,11 +30,13 @@
 {
 class SurfaceFactory;
 class Surface;
+class InputTargetListener;
 
 class ApplicationSession : public Session
 {
 public:
-    explicit ApplicationSession(std::shared_ptr<SurfaceFactory> const& surface_factory, std::string const& session_name);
+    explicit ApplicationSession(std::shared_ptr<SurfaceFactory> const& surface_factory, 
+        std::shared_ptr<InputTargetListener> const& input_target_listener, std::string const& session_name);
     ~ApplicationSession();
 
     frontend::SurfaceId create_surface(frontend::SurfaceCreationParameters const& params);
@@ -58,6 +60,7 @@
 
 private:
     std::shared_ptr<SurfaceFactory> const surface_factory;
+    std::shared_ptr<InputTargetListener> const input_target_listener;
     std::string const session_name;
 
     frontend::SurfaceId next_id();

=== removed file 'include/server/mir/shell/input_focus_selector.h'
--- include/server/mir/shell/input_focus_selector.h	2013-04-16 09:08:29 +0000
+++ include/server/mir/shell/input_focus_selector.h	1970-01-01 00:00:00 +0000
@@ -1,52 +0,0 @@
-/*
- * Copyright © 2013 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: Robert Carr <[e-mail]>
- */
-
-#ifndef MIR_SHELL_INPUT_FOCUS_SELECTOR_H_
-#define MIR_SHELL_INPUT_FOCUS_SELECTOR_H_
-
-#include <memory>
-
-namespace mir
-{
-namespace input
-{
-class SessionTarget;
-class SurfaceTarget;
-}
-
-namespace shell
-{
-
-class InputFocusSelector
-{
-public:
-    virtual ~InputFocusSelector() {}
-
-    virtual void set_input_focus_to(std::shared_ptr<input::SessionTarget> const& focus_application,
-                                    std::shared_ptr<input::SurfaceTarget> const& focus_surface) = 0;
-
-protected:
-    InputFocusSelector() = default;
-    InputFocusSelector(InputFocusSelector const&) = delete;
-    InputFocusSelector& operator=(InputFocusSelector const&) = delete;
-};
-
-}
-} // namespace mir
-
-#endif // MIR_SHELL_INPUT_FOCUS_SELECTOR_H_

=== added file 'include/server/mir/shell/input_target_listener.h'
--- include/server/mir/shell/input_target_listener.h	1970-01-01 00:00:00 +0000
+++ include/server/mir/shell/input_target_listener.h	2013-04-22 15:55:31 +0000
@@ -0,0 +1,59 @@
+/*
+ * Copyright © 2013 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: Robert Carr <[e-mail]>
+ */
+
+#ifndef MIR_SHELL_INPUT_TARGET_LISTENER_H_
+#define MIR_SHELL_INPUT_TARGET_LISTENER_H_
+
+#include <memory>
+
+namespace mir
+{
+namespace input
+{
+class SessionTarget;
+class SurfaceTarget;
+}
+
+namespace shell
+{
+
+class InputTargetListener
+{
+public:
+    virtual ~InputTargetListener() = default;
+    
+    virtual void input_application_opened(std::shared_ptr<input::SessionTarget> const& application) = 0;
+    virtual void input_application_closed(std::shared_ptr<input::SessionTarget> const& application) = 0;
+
+    virtual void input_surface_opened(std::shared_ptr<input::SessionTarget> const& application,
+                                      std::shared_ptr<input::SurfaceTarget> const& opened_surface) = 0;
+    virtual void input_surface_closed(std::shared_ptr<input::SurfaceTarget> const& closed_surface) = 0;
+
+    virtual void focus_changed(std::shared_ptr<input::SurfaceTarget> const& focus_surface) = 0;
+    virtual void focus_cleared() = 0;
+
+protected:
+    InputTargetListener() = default;
+    InputTargetListener(InputTargetListener const&) = delete;
+    InputTargetListener& operator=(InputTargetListener const&) = delete;
+};
+
+}
+} // namespace mir
+
+#endif // MIR_SHELL_INPUT_TARGET_LISTENER_H_

=== modified file 'include/server/mir/shell/session_manager.h'
--- include/server/mir/shell/session_manager.h	2013-04-19 09:15:31 +0000
+++ include/server/mir/shell/session_manager.h	2013-04-22 15:55:31 +0000
@@ -40,15 +40,17 @@
 class SessionContainer;
 class FocusSequence;
 class FocusSetter;
+class InputTargetListener;
 class Session;
 
 class SessionManager : public frontend::Shell
 {
 public:
     explicit SessionManager(std::shared_ptr<SurfaceFactory> const& surface_factory,
-                            std::shared_ptr<SessionContainer> const& session_container,
+                            std::shared_ptr<SessionContainer> const& app_container,
                             std::shared_ptr<FocusSequence> const& focus_sequence,
-                            std::shared_ptr<FocusSetter> const& focus_setter);
+                            std::shared_ptr<FocusSetter> const& focus_setter,
+                            std::shared_ptr<InputTargetListener> const& input_target_listener);
     virtual ~SessionManager();
 
     virtual std::shared_ptr<frontend::Session> open_session(std::string const& name);
@@ -71,6 +73,7 @@
     std::shared_ptr<SessionContainer> const app_container;
     std::shared_ptr<FocusSequence> const focus_sequence;
     std::shared_ptr<FocusSetter> const focus_setter;
+    std::shared_ptr<InputTargetListener> const input_target_listener;
 
     std::mutex mutex;
     std::weak_ptr<Session> focus_application;

=== modified file 'include/server/mir/shell/single_visibility_focus_mechanism.h'
--- include/server/mir/shell/single_visibility_focus_mechanism.h	2013-04-16 09:08:29 +0000
+++ include/server/mir/shell/single_visibility_focus_mechanism.h	2013-04-22 15:55:31 +0000
@@ -28,13 +28,11 @@
 namespace shell
 {
 class SessionContainer;
-class InputFocusSelector;
 
 class SingleVisibilityFocusMechanism : public FocusSetter
 {
 public:
-    explicit SingleVisibilityFocusMechanism(std::shared_ptr<SessionContainer> const& app_container,
-                                            std::shared_ptr<shell::InputFocusSelector> const& input_selector);
+    explicit SingleVisibilityFocusMechanism(std::shared_ptr<SessionContainer> const& app_container);
     virtual ~SingleVisibilityFocusMechanism() {}
 
     void set_focus_to(std::shared_ptr<shell::Session> const& new_focus);
@@ -44,7 +42,6 @@
     SingleVisibilityFocusMechanism& operator=(const SingleVisibilityFocusMechanism&) = delete;
 private:
     std::shared_ptr<SessionContainer> const app_container;
-    std::shared_ptr<shell::InputFocusSelector> const input_selector;
 };
 
 }

=== removed file 'include/test/mir_test_doubles/mock_input_focus_selector.h'
--- include/test/mir_test_doubles/mock_input_focus_selector.h	2013-04-16 09:08:29 +0000
+++ include/test/mir_test_doubles/mock_input_focus_selector.h	1970-01-01 00:00:00 +0000
@@ -1,40 +0,0 @@
-/*
- * Copyright © 2013 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: Robert Carr <[e-mail]>
- */
-
-#ifndef MIR_TEST_DOUBLES_MOCK_INPUT_FOCUS_SELECTOR_H_
-#define MIR_TEST_DOUBLES_MOCK_INPUT_FOCUS_SELECTOR_H_
-
-#include "mir/shell/input_focus_selector.h"
-
-namespace mir
-{
-namespace test
-{
-namespace doubles
-{
-
-struct MockInputFocusSelector : public shell::InputFocusSelector
-{
-    MOCK_METHOD2(set_input_focus_to, void(std::shared_ptr<input::SessionTarget> const&, std::shared_ptr<input::SurfaceTarget> const&));
-};
-
-}
-}
-} // namespace mir
-
-#endif // MIR_TEST_DOUBLES_MOCK_INPUT_FOCUS_SELECTOR_H_

=== added file 'include/test/mir_test_doubles/mock_input_target_listener.h'
--- include/test/mir_test_doubles/mock_input_target_listener.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/mock_input_target_listener.h	2013-04-22 15:55:31 +0000
@@ -0,0 +1,49 @@
+/*
+ * Copyright © 2013 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: Robert Carr <[e-mail]>
+ */
+
+#ifndef MIR_TEST_DOUBLES_MOCK_INPUT_TARGET_LISTENER_H_
+#define MIR_TEST_DOUBLES_MOCK_INPUT_TARGET_LISTENER_H_
+
+#include "mir/shell/input_target_listener.h"
+
+#include <gmock/gmock.h>
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+
+struct MockInputTargetListener : public shell::InputTargetListener
+{
+    virtual ~MockInputTargetListener() noexcept(true) {}
+    MOCK_METHOD1(input_application_opened, void(std::shared_ptr<input::SessionTarget> const& application));
+    MOCK_METHOD1(input_application_closed, void(std::shared_ptr<input::SessionTarget> const& application));
+    MOCK_METHOD2(input_surface_opened, void(std::shared_ptr<input::SessionTarget> const& application,
+        std::shared_ptr<input::SurfaceTarget> const& opened_surface));
+    MOCK_METHOD1(input_surface_closed, void(std::shared_ptr<input::SurfaceTarget> const& closed_surface));
+    MOCK_METHOD1(focus_changed, void(std::shared_ptr<input::SurfaceTarget> const& focus_surface));
+    MOCK_METHOD0(focus_cleared, void());
+};
+
+}
+}
+} // namespace mir
+
+#endif // MIR_TEST_DOUBLES_MOCK_INPUT_TARGET_LISTENER_H_

=== added file 'include/test/mir_test_doubles/stub_input_target_listener.h'
--- include/test/mir_test_doubles/stub_input_target_listener.h	1970-01-01 00:00:00 +0000
+++ include/test/mir_test_doubles/stub_input_target_listener.h	2013-04-22 15:55:31 +0000
@@ -0,0 +1,59 @@
+/*
+ * Copyright © 2013 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: Robert Carr <[e-mail]>
+ */
+
+#ifndef MIR_TEST_DOUBLES_STUB_INPUT_LISTENER_H_
+#define MIR_TEST_DOUBLES_STUB_INPUT_LISTENER_H_
+
+#include "mir/shell/input_target_listener.h"
+
+namespace mir
+{
+namespace test
+{
+namespace doubles
+{
+
+struct StubInputTargetListener : public shell::InputTargetListener
+{
+    void input_application_opened(std::shared_ptr<input::SessionTarget> const&)
+    {
+    }
+    void input_application_closed(std::shared_ptr<input::SessionTarget> const&)
+    {
+    }
+    void input_surface_opened(std::shared_ptr<input::SessionTarget> const&,
+                              std::shared_ptr<input::SurfaceTarget> const&)
+    {
+    }
+    void input_surface_closed(std::shared_ptr<input::SurfaceTarget> const&)
+    {
+    }
+    void focus_changed(std::shared_ptr<input::SurfaceTarget> const&)
+    {
+    }
+    
+    void focus_cleared()
+    {
+    }
+};
+
+}
+}
+} // namespace mir
+
+#endif // MIR_TEST_DOUBLES_STUB_INPUT_LISTENER_H_

=== modified file 'include/test/mir_test_framework/testing_server_configuration.h'
--- include/test/mir_test_framework/testing_server_configuration.h	2013-04-16 09:08:29 +0000
+++ include/test/mir_test_framework/testing_server_configuration.h	2013-04-22 15:55:31 +0000
@@ -49,7 +49,7 @@
     // to avoid starting and stopping the full android input stack for tests
     // which do not leverage input.
     std::shared_ptr<input::InputManager> the_input_manager();
-    std::shared_ptr<shell::InputFocusSelector> the_input_focus_selector();
+    std::shared_ptr<shell::InputTargetListener> the_input_target_listener();
 
     virtual std::string the_socket_file() const;
     using DefaultServerConfiguration::the_options;

=== modified file 'src/server/default_server_configuration.cpp'
--- src/server/default_server_configuration.cpp	2013-04-19 12:49:42 +0000
+++ src/server/default_server_configuration.cpp	2013-04-22 15:55:31 +0000
@@ -45,7 +45,7 @@
 #include "mir/graphics/buffer_initializer.h"
 #include "mir/graphics/null_display_report.h"
 #include "mir/input/null_input_manager.h"
-#include "mir/input/null_input_focus_selector.h"
+#include "mir/input/null_input_target_listener.h"
 #include "input/android/default_android_input_configuration.h"
 #include "input/android/android_input_manager.h"
 #include "input/android/android_dispatcher_controller.h"
@@ -310,8 +310,7 @@
         [this]
         {
             return std::make_shared<msh::SingleVisibilityFocusMechanism>(
-                the_shell_session_container(),
-                the_input_focus_selector());
+                the_shell_session_container());
         });
 }
 
@@ -347,7 +346,8 @@
                 the_shell_surface_factory(),
                 the_shell_session_container(),
                 the_shell_focus_sequence(),
-                the_shell_focus_setter());
+                the_shell_focus_setter(),
+                the_input_target_listener());
         });
 }
 
@@ -562,15 +562,15 @@
     return the_input_manager();
 }
 
-std::shared_ptr<msh::InputFocusSelector> mir::DefaultServerConfiguration::the_input_focus_selector()
+std::shared_ptr<msh::InputTargetListener> mir::DefaultServerConfiguration::the_input_target_listener()
 {
-    return input_focus_selector(
-        [&]() -> std::shared_ptr<msh::InputFocusSelector>
+    return input_target_listener(
+        [&]() -> std::shared_ptr<msh::InputTargetListener>
         {
             if (the_options()->get("enable-input", false))
                 return std::make_shared<mia::DispatcherController>(the_input_configuration());
             else
-                return std::make_shared<mi::NullInputFocusSelector>();
+                return std::make_shared<mi::NullInputTargetListener>();
         });
 }
 

=== modified file 'src/server/display_server.cpp'
--- src/server/display_server.cpp	2013-04-19 14:52:23 +0000
+++ src/server/display_server.cpp	2013-04-22 15:55:31 +0000
@@ -31,9 +31,9 @@
 
 namespace mc = mir::compositor;
 namespace mf = mir::frontend;
-namespace msh = mir::shell;
 namespace mg = mir::graphics;
 namespace mi = mir::input;
+namespace msh = mir::shell;
 
 namespace
 {

=== modified file 'src/server/input/android/android_dispatcher_controller.cpp'
--- src/server/input/android/android_dispatcher_controller.cpp	2013-04-11 23:06:12 +0000
+++ src/server/input/android/android_dispatcher_controller.cpp	2013-04-22 15:55:31 +0000
@@ -25,35 +25,85 @@
 
 #include <InputDispatcher.h>
 
+#include <boost/throw_exception.hpp>
+
+#include <stdexcept>
+#include <mutex>
+
 namespace mi = mir::input;
 namespace mia = mi::android;
 
 mia::DispatcherController::DispatcherController(std::shared_ptr<mia::InputConfiguration> const& config) :
-    input_dispatcher(config->the_dispatcher()),
-    focused_window_handle(0),
-    focused_application_handle(0)
-{
-}
-
-void mia::DispatcherController::set_input_focus_to(std::shared_ptr<mi::SessionTarget> const& session,
-    std::shared_ptr<mi::SurfaceTarget> const& surface)
-{
-    if (focused_window_handle.get())
-    {
-        input_dispatcher->unregisterInputChannel(focused_window_handle->getInfo()->inputChannel);
-        focused_window_handle.clear();
-        focused_application_handle.clear();
-    }
+    input_dispatcher(config->the_dispatcher())
+{
+}
+
+void mia::DispatcherController::input_application_opened(std::shared_ptr<mi::SessionTarget> const& session)
+{
+    std::unique_lock<std::mutex> lock(handles_mutex);
+    if (application_handles.find(session) != application_handles.end())
+        BOOST_THROW_EXCEPTION(std::logic_error("An application was opened twice"));
+    application_handles[session] = new mia::InputApplicationHandle(session);
+}
+
+void mia::DispatcherController::input_application_closed(std::shared_ptr<mi::SessionTarget> const& session)
+{
+    std::unique_lock<std::mutex> lock(handles_mutex);
+    if (application_handles.find(session) == application_handles.end())
+        BOOST_THROW_EXCEPTION(std::logic_error("An application was closed twice"));
+    application_handles.erase(session);
+}
+
+void mia::DispatcherController::input_surface_opened(std::shared_ptr<mi::SessionTarget> const& session,
+                                                     std::shared_ptr<input::SurfaceTarget> const& opened_surface)
+{
+    std::unique_lock<std::mutex> lock(handles_mutex);
+    auto application_handle = application_handles.find(session);
+    if (application_handle == application_handles.end())
+        BOOST_THROW_EXCEPTION(std::logic_error("A surface was opened for an unopened application"));
+    if (window_handles.find(opened_surface) != window_handles.end())
+        BOOST_THROW_EXCEPTION(std::logic_error("A surface was opened twice"));
+
+    droidinput::sp<droidinput::InputWindowHandle> window_handle = new mia::InputWindowHandle(application_handle->second, opened_surface);
+    input_dispatcher->registerInputChannel(window_handle->getInfo()->inputChannel, window_handle, false);
+    
+    window_handles[opened_surface] = window_handle;
+}
+
+void mia::DispatcherController::input_surface_closed(std::shared_ptr<input::SurfaceTarget> const& closed_surface)
+{
+    std::unique_lock<std::mutex> lock(handles_mutex);
+    auto it = window_handles.find(closed_surface);
+    if (it == window_handles.end())
+        BOOST_THROW_EXCEPTION(std::logic_error("A surface was closed twice"));
+
+    input_dispatcher->unregisterInputChannel(it->second->getInfo()->inputChannel);
+    window_handles.erase(it);
+}
+
+void mia::DispatcherController::focus_cleared()
+{
+    droidinput::Vector<droidinput::sp<droidinput::InputWindowHandle>> empty_windows;
+    droidinput::sp<droidinput::InputApplicationHandle> null_application = nullptr;
+    
+    input_dispatcher->setFocusedApplication(null_application);
+    input_dispatcher->setInputWindows(empty_windows);
+}
+
+void mia::DispatcherController::focus_changed(std::shared_ptr<mi::SurfaceTarget> const& surface)
+{
+    std::unique_lock<std::mutex> lock(handles_mutex);
+
+    auto window_handle = window_handles[surface];
+
+    if (!window_handle.get())
+        BOOST_THROW_EXCEPTION(std::logic_error("Focus changed to an unopened surface"));
+    auto application_handle = window_handle->inputApplicationHandle;
+    
+    input_dispatcher->setFocusedApplication(application_handle);
 
     droidinput::Vector<droidinput::sp<droidinput::InputWindowHandle>> windows;
-    if (surface)
-    {
-        focused_application_handle = new mia::InputApplicationHandle(session);
-        focused_window_handle = new mia::InputWindowHandle(focused_application_handle, surface);
-        input_dispatcher->setFocusedApplication(focused_application_handle);
+    windows.push_back(window_handle);
 
-        input_dispatcher->registerInputChannel(focused_window_handle->getInfo()->inputChannel, focused_window_handle, false);
-        windows.push_back(focused_window_handle);
-    }
     input_dispatcher->setInputWindows(windows);
 }

=== modified file 'src/server/input/android/android_dispatcher_controller.h'
--- src/server/input/android/android_dispatcher_controller.h	2013-04-11 23:06:12 +0000
+++ src/server/input/android/android_dispatcher_controller.h	2013-04-22 15:55:31 +0000
@@ -19,10 +19,13 @@
 #ifndef MIR_INPUT_ANDROID_DISPATCHER_CONTROLLER_H_
 #define MIR_INPUT_ANDROID_DISPATCHER_CONTROLLER_H_
 
-#include "mir/shell/input_focus_selector.h"
+#include "mir/shell/input_target_listener.h"
 
 #include <utils/StrongPointer.h>
 
+#include <map>
+#include <mutex>
+
 namespace android
 {
 class InputDispatcherInterface;
@@ -40,13 +43,21 @@
 {
 class InputConfiguration;
 
-class DispatcherController : public shell::InputFocusSelector
+class DispatcherController : public shell::InputTargetListener
 {
 public:
     explicit DispatcherController(std::shared_ptr<InputConfiguration> const& input_configuration);
-    virtual ~DispatcherController() = default;
+    virtual ~DispatcherController() noexcept(true) {}
     
-    void set_input_focus_to(std::shared_ptr<input::SessionTarget> const& session, std::shared_ptr<input::SurfaceTarget> const& surface);
+    void input_application_opened(std::shared_ptr<input::SessionTarget> const& application);
+    void input_application_closed(std::shared_ptr<input::SessionTarget> const& application);
+
+    void input_surface_opened(std::shared_ptr<input::SessionTarget> const& application,
+       std::shared_ptr<input::SurfaceTarget> const& opened_surface);
+    void input_surface_closed(std::shared_ptr<input::SurfaceTarget> const& closed_surface);
+
+    void focus_changed(std::shared_ptr<input::SurfaceTarget> const& focus_surface);
+    void focus_cleared();
 
 protected:
     DispatcherController(const DispatcherController&) = delete;
@@ -55,8 +66,10 @@
 private:
     droidinput::sp<droidinput::InputDispatcherInterface> input_dispatcher;
 
-    droidinput::sp<droidinput::InputWindowHandle> focused_window_handle;
-    droidinput::sp<droidinput::InputApplicationHandle> focused_application_handle;
+    std::map<std::shared_ptr<input::SessionTarget>, droidinput::sp<droidinput::InputApplicationHandle>> application_handles;
+    std::map<std::shared_ptr<input::SurfaceTarget>, droidinput::sp<droidinput::InputWindowHandle>> window_handles;
+
+    std::mutex handles_mutex;
 };
 
 }

=== modified file 'src/server/input/android/default_android_input_configuration.cpp'
--- src/server/input/android/default_android_input_configuration.cpp	2013-04-16 09:08:29 +0000
+++ src/server/input/android/default_android_input_configuration.cpp	2013-04-22 15:55:31 +0000
@@ -98,7 +98,7 @@
     return dispatcher_policy(
         [this]()
         {
-            return new mia::EventFilterDispatcherPolicy(filter_chain);
+            return new mia::EventFilterDispatcherPolicy(filter_chain, is_key_repeat_enabled());
         });
 }
 
@@ -149,3 +149,8 @@
                                                        new droidinput::InputReaderThread(the_reader()));
         });
 }
+
+bool mia::DefaultInputConfiguration::is_key_repeat_enabled()
+{
+    return true;
+}

=== modified file 'src/server/input/android/default_android_input_configuration.h'
--- src/server/input/android/default_android_input_configuration.h	2013-04-16 09:08:29 +0000
+++ src/server/input/android/default_android_input_configuration.h	2013-04-22 15:55:31 +0000
@@ -69,6 +69,8 @@
 
     virtual droidinput::sp<droidinput::InputDispatcherPolicyInterface> the_dispatcher_policy();
     virtual droidinput::sp<droidinput::InputReaderPolicyInterface> the_reader_policy();
+    
+    virtual bool is_key_repeat_enabled();
 
 protected:
     DefaultInputConfiguration(DefaultInputConfiguration const&) = delete;

=== modified file 'src/server/input/android/event_filter_dispatcher_policy.cpp'
--- src/server/input/android/event_filter_dispatcher_policy.cpp	2013-04-16 09:27:00 +0000
+++ src/server/input/android/event_filter_dispatcher_policy.cpp	2013-04-22 15:55:31 +0000
@@ -21,8 +21,9 @@
 namespace mi = mir::input;
 namespace mia = mi::android;
 
-mia::EventFilterDispatcherPolicy::EventFilterDispatcherPolicy(std::shared_ptr<mi::EventFilter> const& event_filter) :
-  event_filter(event_filter)
+mia::EventFilterDispatcherPolicy::EventFilterDispatcherPolicy(std::shared_ptr<mi::EventFilter> const& event_filter, bool key_repeat_enabled) :
+  event_filter(event_filter),
+  key_repeat_enabled(key_repeat_enabled)
 {
 }
 
@@ -46,7 +47,7 @@
 
 bool mia::EventFilterDispatcherPolicy::isKeyRepeatEnabled()
 {
-    return true;
+    return key_repeat_enabled;
 }
 
 bool mia::EventFilterDispatcherPolicy::filterInputEvent(const droidinput::InputEvent* input_event, uint32_t /*policy_flags*/)

=== modified file 'src/server/input/android/event_filter_dispatcher_policy.h'
--- src/server/input/android/event_filter_dispatcher_policy.h	2013-04-16 09:08:29 +0000
+++ src/server/input/android/event_filter_dispatcher_policy.h	2013-04-22 15:55:31 +0000
@@ -40,7 +40,7 @@
 class EventFilterDispatcherPolicy : public droidinput::InputDispatcherPolicyInterface
 {
 public:
-    EventFilterDispatcherPolicy(std::shared_ptr<EventFilter> const& event_filter);
+    EventFilterDispatcherPolicy(std::shared_ptr<EventFilter> const& event_filter, bool key_repeat_enabled);
     virtual ~EventFilterDispatcherPolicy() {}
 
     void notifyConfigurationChanged(nsecs_t when);
@@ -71,6 +71,7 @@
     EventFilterDispatcherPolicy& operator=(const EventFilterDispatcherPolicy&) = delete;
 private:
     std::shared_ptr<EventFilter> event_filter;
+    bool key_repeat_enabled;
 };
 
 }

=== modified file 'src/server/shell/application_session.cpp'
--- src/server/shell/application_session.cpp	2013-04-16 17:42:26 +0000
+++ src/server/shell/application_session.cpp	2013-04-22 15:55:31 +0000
@@ -18,8 +18,8 @@
 
 #include "mir/shell/application_session.h"
 #include "mir/shell/surface.h"
-
 #include "mir/shell/surface_factory.h"
+#include "mir/shell/input_target_listener.h"
 
 #include <boost/throw_exception.hpp>
 
@@ -32,9 +32,11 @@
 namespace msh = mir::shell;
 
 msh::ApplicationSession::ApplicationSession(
-    std::shared_ptr<SurfaceFactory> const& surface_factory,
+    std::shared_ptr<msh::SurfaceFactory> const& surface_factory,
+    std::shared_ptr<msh::InputTargetListener> const& input_target_listener,
     std::string const& session_name) :
     surface_factory(surface_factory),
+    input_target_listener(input_target_listener),
     session_name(session_name),
     next_surface_id(0)
 {
@@ -46,6 +48,7 @@
     std::unique_lock<std::mutex> lock(surfaces_mutex);
     for (auto const& pair_id_surface : surfaces)
     {
+        input_target_listener->input_surface_closed(pair_id_surface.second);
         pair_id_surface.second->destroy();
     }
 }
@@ -95,6 +98,7 @@
     std::unique_lock<std::mutex> lock(surfaces_mutex);
     auto p = checked_find(id);
 
+    input_target_listener->input_surface_closed(p->second);
     p->second->destroy();
     surfaces.erase(p);
 }

=== modified file 'src/server/shell/session_manager.cpp'
--- src/server/shell/session_manager.cpp	2013-04-19 09:15:31 +0000
+++ src/server/shell/session_manager.cpp	2013-04-22 15:55:31 +0000
@@ -23,6 +23,8 @@
 #include "mir/shell/focus_sequence.h"
 #include "mir/shell/focus_setter.h"
 #include "mir/shell/session.h"
+#include "mir/shell/surface.h"
+#include "mir/shell/input_target_listener.h"
 
 #include <memory>
 #include <cassert>
@@ -31,20 +33,22 @@
 namespace mf = mir::frontend;
 namespace msh = mir::shell;
 
-msh::SessionManager::SessionManager(
-    std::shared_ptr<msh::SurfaceFactory> const& surface_factory,
+msh::SessionManager::SessionManager(std::shared_ptr<msh::SurfaceFactory> const& surface_factory,
     std::shared_ptr<msh::SessionContainer> const& container,
     std::shared_ptr<msh::FocusSequence> const& sequence,
-    std::shared_ptr<msh::FocusSetter> const& focus_setter) :
+    std::shared_ptr<msh::FocusSetter> const& focus_setter,
+    std::shared_ptr<msh::InputTargetListener> const& input_target_listener) :
     surface_factory(surface_factory),
     app_container(container),
     focus_sequence(sequence),
-    focus_setter(focus_setter)
+    focus_setter(focus_setter),
+    input_target_listener(input_target_listener)
 {
     assert(surface_factory);
     assert(sequence);
     assert(container);
     assert(focus_setter);
+    assert(input_target_listener);
 }
 
 msh::SessionManager::~SessionManager()
@@ -53,25 +57,36 @@
 
 std::shared_ptr<mf::Session> msh::SessionManager::open_session(std::string const& name)
 {
-    auto new_session = std::make_shared<msh::ApplicationSession>(surface_factory, name);
+    auto new_session = std::make_shared<msh::ApplicationSession>(surface_factory, input_target_listener, name);
 
     app_container->insert_session(new_session);
+    
+    input_target_listener->input_application_opened(new_session);
 
     set_focus_to_locked(std::unique_lock<std::mutex>(mutex), new_session);
 
     return new_session;
 }
 
-inline void msh::SessionManager::set_focus_to_locked(std::unique_lock<std::mutex> const&, std::shared_ptr<Session> const& next_focus)
+inline void msh::SessionManager::set_focus_to_locked(std::unique_lock<std::mutex> const&, std::shared_ptr<Session> const& shell_session)
 {
-    focus_application = next_focus;
-    focus_setter->set_focus_to(next_focus);
+    auto old_focus = focus_application.lock();
+
+    focus_application = shell_session;
+    focus_setter->set_focus_to(shell_session);
+
+    if (shell_session && shell_session->default_surface())
+        input_target_listener->focus_changed(shell_session->default_surface());
+    else if (shell_session == old_focus || !shell_session)
+        input_target_listener->focus_cleared();
 }
 
 void msh::SessionManager::close_session(std::shared_ptr<mf::Session> const& session)
 {
     auto shell_session = std::dynamic_pointer_cast<Session>(session);
 
+    input_target_listener->input_application_closed(shell_session);
+
     app_container->remove_session(shell_session);
 
     std::unique_lock<std::mutex> lock(mutex);
@@ -133,9 +148,11 @@
     mf::SurfaceCreationParameters const& params)
 {
     auto shell_session = std::dynamic_pointer_cast<Session>(session);
-    auto id = session->create_surface(params);
+    auto id = shell_session->create_surface(params);
+
+    input_target_listener->input_surface_opened(shell_session,
+        std::dynamic_pointer_cast<msh::Surface>(shell_session->get_surface(id)));
     set_focus_to_locked(std::unique_lock<std::mutex>(mutex), shell_session);
 
     return id;
 }
-

=== modified file 'src/server/shell/single_visibility_focus_mechanism.cpp'
--- src/server/shell/single_visibility_focus_mechanism.cpp	2013-04-18 22:57:01 +0000
+++ src/server/shell/single_visibility_focus_mechanism.cpp	2013-04-22 15:55:31 +0000
@@ -19,7 +19,6 @@
 #include "mir/shell/session_container.h"
 #include "mir/frontend/session.h"
 #include "mir/shell/single_visibility_focus_mechanism.h"
-#include "mir/shell/input_focus_selector.h"
 
 #include "mir/shell/session.h"
 #include "mir/shell/surface.h"
@@ -27,10 +26,8 @@
 namespace mf = mir::frontend;
 namespace msh = mir::shell;
 
-msh::SingleVisibilityFocusMechanism::SingleVisibilityFocusMechanism(std::shared_ptr<msh::SessionContainer> const& app_container,
-    std::shared_ptr<msh::InputFocusSelector> const& input_selector)
-  : app_container(app_container),
-    input_selector(input_selector)
+msh::SingleVisibilityFocusMechanism::SingleVisibilityFocusMechanism(std::shared_ptr<msh::SessionContainer> const& app_container)
+  : app_container(app_container)
 {
 }
 
@@ -41,8 +38,6 @@
         if (session == focus_session)
         {
             session->show();
-
-            input_selector->set_input_focus_to(focus_session, focus_session->default_surface());
         }
         else
         {

=== modified file 'tests/acceptance-tests/test_client_input.cpp'
--- tests/acceptance-tests/test_client_input.cpp	2013-04-17 07:31:40 +0000
+++ tests/acceptance-tests/test_client_input.cpp	2013-04-22 15:55:31 +0000
@@ -65,10 +65,9 @@
 
     }
     
-    void set_input_focus_to(
-        std::shared_ptr<mi::SessionTarget> const& session, std::shared_ptr<mi::SurfaceTarget> const& surface) override
+    void focus_changed(std::shared_ptr<mi::SurfaceTarget> const& surface) override
     {
-        DispatcherController::set_input_focus_to(session, surface);
+        DispatcherController::focus_changed(surface);
         
         // We need a synchronization primitive inorder to halt test event injection
         // until after a surface has taken focus (lest the events be discarded).
@@ -122,10 +121,10 @@
             });
     }
 
-    std::shared_ptr<msh::InputFocusSelector>
-    the_input_focus_selector() override
+    std::shared_ptr<msh::InputTargetListener>
+    the_input_target_listener() override
     {
-        return input_focus_selector(
+        return input_target_listener(
             [this]()
             {
                 return std::make_shared<FocusNotifyingDispatcherController>(mt::fake_shared(input_config), on_focus_set);

=== modified file 'tests/acceptance-tests/test_focus_selection.cpp'
--- tests/acceptance-tests/test_focus_selection.cpp	2013-04-18 02:52:30 +0000
+++ tests/acceptance-tests/test_focus_selection.cpp	2013-04-22 15:55:31 +0000
@@ -24,11 +24,11 @@
 #include "mir/shell/organising_surface_factory.h"
 #include "mir/shell/session_manager.h"
 #include "mir/graphics/display.h"
-#include "mir/shell/input_focus_selector.h"
+#include "mir/shell/input_target_listener.h"
 
 #include "mir_test_framework/display_server_test_fixture.h"
 #include "mir_test_doubles/mock_focus_setter.h"
-#include "mir_test_doubles/mock_input_focus_selector.h"
+#include "mir_test_doubles/mock_input_target_listener.h"
 
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
@@ -36,7 +36,8 @@
 namespace mf = mir::frontend;
 namespace msh = mir::shell;
 namespace mi = mir::input;
-namespace mtd = mir::test::doubles;
+namespace mt = mir::test;
+namespace mtd = mt::doubles;
 namespace mtf = mir_test_framework;
 
 namespace
@@ -46,6 +47,7 @@
 
 namespace
 {
+
 struct ClientConfigCommon : TestingClientConfiguration
 {
     ClientConfigCommon() :
@@ -121,18 +123,10 @@
 {
     return arg != std::shared_ptr<msh::Session>();
 }
-MATCHER(NonNullSessionTarget, "")
-{
-    return arg != std::shared_ptr<mi::SessionTarget>();
-}
 MATCHER(NonNullSurfaceTarget, "")
 {
     return arg != std::shared_ptr<mi::SurfaceTarget>();
 }
-MATCHER(NullSurfaceTarget, "")
-{
-    return arg == std::shared_ptr<mi::SurfaceTarget>();
-}
 }
 
 TEST_F(BespokeDisplayServerTestFixture, sessions_creating_surface_receive_focus)
@@ -148,7 +142,6 @@
                 using namespace ::testing;
 
                 auto focus_setter = std::make_shared<mtd::MockFocusSetter>();
-
                 {
                     InSequence seq;
                     // Once on application registration and once on surface creation
@@ -174,30 +167,37 @@
 {
     struct ServerConfig : TestingServerConfiguration
     {
-        std::shared_ptr<mtd::MockInputFocusSelector> focus_selector;
+        std::shared_ptr<mtd::MockInputTargetListener> target_listener;
         bool expected;
 
         ServerConfig()
-          : focus_selector(std::make_shared<mtd::MockInputFocusSelector>()),
+          : target_listener(std::make_shared<mtd::MockInputTargetListener>()),
             expected(false)
         {
         }
 
-        std::shared_ptr<msh::InputFocusSelector>
-        the_input_focus_selector() override
+        std::shared_ptr<msh::InputTargetListener>
+        the_input_target_listener() override
         {
             using namespace ::testing;
 
             if (!expected)
             {
-                InSequence seq;
+                
+                EXPECT_CALL(*target_listener, input_application_opened(_)).Times(AtLeast(0));
+                EXPECT_CALL(*target_listener, input_application_closed(_)).Times(AtLeast(0));
+                EXPECT_CALL(*target_listener, input_surface_opened(_,_)).Times(AtLeast(0));
+                EXPECT_CALL(*target_listener, input_surface_closed(_)).Times(AtLeast(0));
+                EXPECT_CALL(*target_listener, focus_cleared()).Times(AtLeast(0));
 
-                EXPECT_CALL(*focus_selector, set_input_focus_to(NonNullSessionTarget(), NullSurfaceTarget())).Times(1);
-                EXPECT_CALL(*focus_selector, set_input_focus_to(NonNullSessionTarget(), NonNullSurfaceTarget())).Times(1);
-                expected = true;
+                {
+                    InSequence seq;
+                    EXPECT_CALL(*target_listener, focus_changed(NonNullSurfaceTarget())).Times(1);
+                    expected = true;
+                }
             }
 
-            return focus_selector;
+            return target_listener;
         }
     } server_config;
 

=== modified file 'tests/death-tests/test_application_manager_death.cpp'
--- tests/death-tests/test_application_manager_death.cpp	2013-03-21 03:32:59 +0000
+++ tests/death-tests/test_application_manager_death.cpp	2013-04-22 15:55:31 +0000
@@ -30,11 +30,12 @@
 //  ::testing::FLAGS_gtest_death_test_style = "threadsafe";
 // leads to the test failing under valgrind
     EXPECT_EXIT(
-                std::shared_ptr<msh::SurfaceFactory> factory;
-                mir::shell::SessionManager app(factory,
+                std::shared_ptr<msh::SurfaceFactory> surface_factory;
+                mir::shell::SessionManager app(surface_factory,
                                                std::shared_ptr<msh::SessionContainer>(),
                                                std::shared_ptr<msh::FocusSequence>(),
-                                               std::shared_ptr<msh::FocusSetter>()),
+                                               std::shared_ptr<msh::FocusSetter>(),
+                                               std::shared_ptr<msh::InputTargetListener>()),
                 ::testing::KilledBySignal(SIGABRT),
                 ".*");
 }

=== modified file 'tests/integration-tests/input/android/test_android_input_manager.cpp'
--- tests/integration-tests/input/android/test_android_input_manager.cpp	2013-04-10 23:48:23 +0000
+++ tests/integration-tests/input/android/test_android_input_manager.cpp	2013-04-22 15:55:31 +0000
@@ -171,7 +171,7 @@
 struct MockDispatcherPolicy : public mia::EventFilterDispatcherPolicy
 {
     MockDispatcherPolicy(std::shared_ptr<mi::EventFilter> const& filter)
-      : EventFilterDispatcherPolicy(filter)
+      : EventFilterDispatcherPolicy(filter, false)
     {
     }
     MOCK_METHOD3(interceptKeyBeforeDispatching, nsecs_t(droidinput::sp<droidinput::InputWindowHandle> const&,
@@ -211,24 +211,31 @@
         ON_CALL(viewable_area, view_area())
             .WillByDefault(Return(default_view_area));
         input_manager = std::make_shared<mia::InputManager>(configuration);
-        input_focus_selector = std::make_shared<mia::DispatcherController>(configuration);
+        input_target_listener = std::make_shared<mia::DispatcherController>(configuration);
 
         dispatcher_policy = configuration->the_mock_dispatcher_policy();
 
     }
 
+    ~AndroidInputManagerDispatcherInterceptSetup()
+    {
+        input_manager->stop();
+    }
+
     // TODO: It would be nice if it were possible to mock the interface between
     // droidinput::InputChannel and droidinput::InputDispatcher rather than use
     // valid fds to allow non-throwing construction of a real input channel.
     void SetUp()
     {
-        test_input_fd = socket(AF_UNIX, SOCK_SEQPACKET, 0);
         input_manager->start();
     }
-    void TearDown()
+    
+    int test_fd()
     {
-        input_manager->stop();
-        close(test_input_fd);
+        int fds[2];
+        // Closed by droidinput InputChannel on shutdown
+        socketpair(AF_UNIX, SOCK_SEQPACKET, 0, fds);
+        return fds[0];
     }
 
     MockEventFilter event_filter;
@@ -238,9 +245,7 @@
     droidinput::sp<MockDispatcherPolicy> dispatcher_policy;
 
     std::shared_ptr<mia::InputManager> input_manager;
-    std::shared_ptr<msh::InputFocusSelector> input_focus_selector;
-
-    int test_input_fd;
+    std::shared_ptr<msh::InputTargetListener> input_target_listener;
 };
 
 MATCHER_P(WindowHandleWithInputFd, input_fd, "")
@@ -259,14 +264,18 @@
     mt::WaitCondition wait_condition;
 
     mtd::StubSessionTarget session;
-    mtd::StubSurfaceTarget surface(test_input_fd);
+    
+    auto input_fd = test_fd();
+    mtd::StubSurfaceTarget surface(input_fd);
 
     EXPECT_CALL(event_filter, handles(_)).Times(1).WillOnce(Return(false));
     // We return -1 here to skip publishing of the event (to an unconnected test socket!).
-    EXPECT_CALL(*dispatcher_policy, interceptKeyBeforeDispatching(WindowHandleWithInputFd(test_input_fd), _, _))
+    EXPECT_CALL(*dispatcher_policy, interceptKeyBeforeDispatching(WindowHandleWithInputFd(input_fd), _, _))
         .Times(1).WillOnce(DoAll(mt::WakeUp(&wait_condition), Return(-1)));
 
-    input_focus_selector->set_input_focus_to(mt::fake_shared(session), mt::fake_shared(surface));
+    input_target_listener->input_application_opened(mt::fake_shared(session));
+    input_target_listener->input_surface_opened(mt::fake_shared(session), mt::fake_shared(surface));
+    input_target_listener->focus_changed(mt::fake_shared(surface));
 
     fake_event_hub->synthesize_builtin_keyboard_added();
     fake_event_hub->synthesize_device_scan_complete();
@@ -275,3 +284,52 @@
 
     wait_condition.wait_for_at_most_seconds(1);
 }
+
+TEST_F(AndroidInputManagerDispatcherInterceptSetup, changing_focus_changes_event_recipient)
+{
+    using namespace ::testing;
+
+    mt::WaitCondition wait1, wait2, wait3;
+
+    mtd::StubSessionTarget session;
+    
+    auto input_fd_1 = test_fd();
+    mtd::StubSurfaceTarget surface1(input_fd_1);
+    auto input_fd_2 = test_fd();
+    mtd::StubSurfaceTarget surface2(input_fd_2);
+
+    input_target_listener->input_application_opened(mt::fake_shared(session));
+    input_target_listener->input_surface_opened(mt::fake_shared(session), mt::fake_shared(surface1));
+    input_target_listener->input_surface_opened(mt::fake_shared(session), mt::fake_shared(surface2));
+
+    EXPECT_CALL(event_filter, handles(_)).Times(3).WillRepeatedly(Return(false));
+
+    {
+        InSequence seq;
+
+        EXPECT_CALL(*dispatcher_policy, interceptKeyBeforeDispatching(WindowHandleWithInputFd(input_fd_1), _, _))
+            .Times(1).WillOnce(DoAll(mt::WakeUp(&wait1), Return(-1)));
+        EXPECT_CALL(*dispatcher_policy, interceptKeyBeforeDispatching(WindowHandleWithInputFd(input_fd_2), _, _))
+            .Times(1).WillOnce(DoAll(mt::WakeUp(&wait2), Return(-1)));
+        EXPECT_CALL(*dispatcher_policy, interceptKeyBeforeDispatching(WindowHandleWithInputFd(input_fd_1), _, _))
+            .Times(1).WillOnce(DoAll(mt::WakeUp(&wait3), Return(-1)));
+    }
+
+    fake_event_hub->synthesize_builtin_keyboard_added();
+    fake_event_hub->synthesize_device_scan_complete();
+
+    input_target_listener->focus_changed(mt::fake_shared(surface1));
+    fake_event_hub->synthesize_event(mis::a_key_down_event()
+                                .of_scancode(KEY_1));
+    wait1.wait_for_at_most_seconds(1);
+
+    input_target_listener->focus_changed(mt::fake_shared(surface2));
+    fake_event_hub->synthesize_event(mis::a_key_down_event()
+                                .of_scancode(KEY_2));
+    wait2.wait_for_at_most_seconds(1);
+
+    input_target_listener->focus_changed(mt::fake_shared(surface1));
+    fake_event_hub->synthesize_event(mis::a_key_down_event()
+                                .of_scancode(KEY_3));
+    wait3.wait_for_at_most_seconds(5);
+} 

=== modified file 'tests/integration-tests/input/android/test_fake_event_hub_to_event_filter.cpp'
--- tests/integration-tests/input/android/test_fake_event_hub_to_event_filter.cpp	2013-04-02 18:26:40 +0000
+++ tests/integration-tests/input/android/test_fake_event_hub_to_event_filter.cpp	2013-04-22 15:55:31 +0000
@@ -56,7 +56,7 @@
     void SetUp()
     {
         event_hub = new mia::FakeEventHub();
-        dispatcher_policy = new mia::EventFilterDispatcherPolicy(mt::fake_shared(event_filter));
+        dispatcher_policy = new mia::EventFilterDispatcherPolicy(mt::fake_shared(event_filter), false);
         reader_policy = new mia::RudimentaryInputReaderPolicy();
         dispatcher = new droidinput::InputDispatcher(dispatcher_policy);
         reader = new droidinput::InputReader(event_hub, reader_policy, dispatcher);

=== modified file 'tests/integration-tests/shell/test_session_manager.cpp'
--- tests/integration-tests/shell/test_session_manager.cpp	2013-04-18 00:00:55 +0000
+++ tests/integration-tests/shell/test_session_manager.cpp	2013-04-22 15:55:31 +0000
@@ -33,6 +33,7 @@
 #include "mir_test/fake_shared.h"
 #include "mir_test_doubles/mock_surface_factory.h"
 #include "mir_test_doubles/mock_focus_setter.h"
+#include "mir_test_doubles/stub_input_target_listener.h"
 
 namespace mc = mir::compositor;
 namespace mf = mir::frontend;
@@ -44,19 +45,22 @@
 TEST(TestSessionManagerAndFocusSelectionStrategy, cycle_focus)
 {
     using namespace ::testing;
+
     mtd::MockSurfaceFactory surface_factory;
     std::shared_ptr<msh::DefaultSessionContainer> container(new msh::DefaultSessionContainer());
     msh::RegistrationOrderFocusSequence sequence(container);
-    mtd::MockFocusSetter focus_changer;
+    mtd::MockFocusSetter focus_setter;
     std::shared_ptr<mf::Session> new_session;
+    mtd::StubInputTargetListener input_target_listener;
 
     msh::SessionManager session_manager(
             mt::fake_shared(surface_factory),
             container,
             mt::fake_shared(sequence),
-            mt::fake_shared(focus_changer));
-
-    EXPECT_CALL(focus_changer, set_focus_to(_)).Times(3);
+            mt::fake_shared(focus_setter),
+            mt::fake_shared(input_target_listener));
+    
+    EXPECT_CALL(focus_setter, set_focus_to(_)).Times(3);
 
     auto session1 = session_manager.open_session("Visual Basic Studio");
     auto session2 = session_manager.open_session("Microsoft Access");
@@ -64,9 +68,9 @@
 
     {
       InSequence seq;
-      EXPECT_CALL(focus_changer, set_focus_to(Eq(session1))).Times(1);
-      EXPECT_CALL(focus_changer, set_focus_to(Eq(session2))).Times(1);
-      EXPECT_CALL(focus_changer, set_focus_to(Eq(session3))).Times(1);
+      EXPECT_CALL(focus_setter, set_focus_to(Eq(session1))).Times(1);
+      EXPECT_CALL(focus_setter, set_focus_to(Eq(session2))).Times(1);
+      EXPECT_CALL(focus_setter, set_focus_to(Eq(session3))).Times(1);
     }
 
     session_manager.focus_next();
@@ -77,19 +81,22 @@
 TEST(TestSessionManagerAndFocusSelectionStrategy, closing_applications_transfers_focus)
 {
     using namespace ::testing;
+
     mtd::MockSurfaceFactory surface_factory;
-    std::shared_ptr<msh::DefaultSessionContainer> model(new msh::DefaultSessionContainer());
-    msh::RegistrationOrderFocusSequence sequence(model);
-    mtd::MockFocusSetter focus_changer;
+    std::shared_ptr<msh::DefaultSessionContainer> container(new msh::DefaultSessionContainer());
+    msh::RegistrationOrderFocusSequence sequence(container);
+    mtd::MockFocusSetter focus_setter;
     std::shared_ptr<mf::Session> new_session;
+    mtd::StubInputTargetListener input_target_listener;
 
     msh::SessionManager session_manager(
-        mt::fake_shared(surface_factory),
-        model,
-        mt::fake_shared(sequence),
-        mt::fake_shared(focus_changer));
+            mt::fake_shared(surface_factory),
+            container,
+            mt::fake_shared(sequence),
+            mt::fake_shared(focus_setter),
+            mt::fake_shared(input_target_listener));
 
-    EXPECT_CALL(focus_changer, set_focus_to(_)).Times(3);
+    EXPECT_CALL(focus_setter, set_focus_to(_)).Times(3);
 
     auto session1 = session_manager.open_session("Visual Basic Studio");
     auto session2 = session_manager.open_session("Microsoft Access");
@@ -97,8 +104,8 @@
 
     {
       InSequence seq;
-      EXPECT_CALL(focus_changer, set_focus_to(Eq(session2))).Times(1);
-      EXPECT_CALL(focus_changer, set_focus_to(Eq(session1))).Times(1);
+      EXPECT_CALL(focus_setter, set_focus_to(Eq(session2))).Times(1);
+      EXPECT_CALL(focus_setter, set_focus_to(Eq(session1))).Times(1);
     }
 
     session_manager.close_session(session3);

=== modified file 'tests/mir_test_framework/testing_server_options.cpp'
--- tests/mir_test_framework/testing_server_options.cpp	2013-04-18 15:20:45 +0000
+++ tests/mir_test_framework/testing_server_options.cpp	2013-04-22 15:55:31 +0000
@@ -29,7 +29,7 @@
 #include "mir/compositor/graphic_buffer_allocator.h"
 #include "mir/input/input_channel.h"
 #include "mir/input/input_manager.h"
-#include "mir/shell/input_focus_selector.h"
+#include "mir/input/null_input_target_listener.h"
 #include "src/server/input/android/android_input_manager.h"
 #include "src/server/input/android/android_dispatcher_controller.h"
 
@@ -159,14 +159,6 @@
     }
 };
 
-class StubInputFocusSelector : public msh::InputFocusSelector
-{
-public:
-    void set_input_focus_to(std::shared_ptr<mi::SessionTarget> const& /* session */, std::shared_ptr<mi::SurfaceTarget> const& /* surface */)
-    {
-    }
-};
-
 }
 
 mtf::TestingServerConfiguration::TestingServerConfiguration() :
@@ -184,14 +176,14 @@
         return std::make_shared<StubInputManager>();
 }
 
-std::shared_ptr<msh::InputFocusSelector> mtf::TestingServerConfiguration::the_input_focus_selector()
+std::shared_ptr<msh::InputTargetListener> mtf::TestingServerConfiguration::the_input_target_listener()
 {
     auto options = the_options();
  
    if (options->get("tests-use-real-input", false))
         return std::make_shared<mia::DispatcherController>(the_input_configuration());
     else
-        return std::make_shared<StubInputFocusSelector>();
+        return std::make_shared<mi::NullInputTargetListener>();
 }
 
 std::shared_ptr<mg::Platform> mtf::TestingServerConfiguration::the_graphics_platform()

=== modified file 'tests/unit-tests/input/android/test_android_dispatcher_controller.cpp'
--- tests/unit-tests/input/android/test_android_dispatcher_controller.cpp	2013-04-15 14:39:18 +0000
+++ tests/unit-tests/input/android/test_android_dispatcher_controller.cpp	2013-04-22 15:55:31 +0000
@@ -31,6 +31,8 @@
 #include <sys/types.h>
 #include <sys/socket.h>
 
+#include <stdexcept>
+
 namespace mi = mir::input;
 namespace mia = mi::android;
 namespace mt = mir::test;
@@ -47,12 +49,16 @@
     void SetUp() override
     {
         test_input_fd = socket(AF_UNIX, SOCK_SEQPACKET, 0);
+        
+        dispatcher = new mtd::MockInputDispatcher();
     }
     void TearDown() override
     {
         close(test_input_fd);
     }
     int test_input_fd;
+    droidinput::sp<mtd::MockInputDispatcher> dispatcher;
+    mtd::MockInputConfiguration config;
 };
 
 static bool
@@ -104,30 +110,151 @@
 
 }
 
-TEST_F(AndroidDispatcherControllerFdSetup, set_input_focus)
-{
-    using namespace ::testing;
-
-    auto dispatcher = new mtd::MockInputDispatcher(); // We need droidinput::sp
-    mtd::MockInputConfiguration config;
-    EXPECT_CALL(config, the_dispatcher()).Times(1)
-        .WillOnce(Return(dispatcher));
-
-    auto session = std::make_shared<mtd::StubSessionTarget>();
-    auto surface = std::make_shared<mtd::StubSurfaceTarget>(test_input_fd);
+TEST_F(AndroidDispatcherControllerFdSetup, input_application_opened_behavior)
+{    
+    using namespace ::testing;
+
+    EXPECT_CALL(config, the_dispatcher()).Times(1)
+        .WillOnce(Return(dispatcher));
+    mia::DispatcherController controller(mt::fake_shared(config));
+    
+    auto session = std::make_shared<mtd::StubSessionTarget>();
+    controller.input_application_opened(session);
+    EXPECT_THROW({
+            // An application can not be opened twice!
+            controller.input_application_opened(session);
+    }, std::logic_error);
+}
+
+TEST_F(AndroidDispatcherControllerFdSetup, input_application_closed_behavior)
+{    
+    using namespace ::testing;
+
+    EXPECT_CALL(config, the_dispatcher()).Times(1)
+        .WillOnce(Return(dispatcher));
+    mia::DispatcherController controller(mt::fake_shared(config));
+    
+    auto session = std::make_shared<mtd::StubSessionTarget>();
+    EXPECT_THROW({
+            // We can't close an application which is not open
+            controller.input_application_closed(session);
+    }, std::logic_error);
+    controller.input_application_opened(session);
+    controller.input_application_closed(session);
+    EXPECT_THROW({
+            // Nor can we close an application twice
+            controller.input_application_closed(session);
+    }, std::logic_error);
+}
+
+TEST_F(AndroidDispatcherControllerFdSetup, input_surface_opened_behavior)
+{    
+    using namespace ::testing;
+
+    auto session = std::make_shared<mtd::StubSessionTarget>();
+    auto surface = std::make_shared<mtd::StubSurfaceTarget>(test_input_fd);
+
+    EXPECT_CALL(config, the_dispatcher()).Times(1)
+        .WillOnce(Return(dispatcher));
+    EXPECT_CALL(*dispatcher, registerInputChannel(_, WindowHandleFor(session, surface), false)).Times(1)
+        .WillOnce(Return(droidinput::OK));
+
+    mia::DispatcherController controller(mt::fake_shared(config));
+    
+    EXPECT_THROW({
+            // We can't open a surface with an unopened session!
+            controller.input_surface_opened(session, surface);
+     }, std::logic_error);
+     controller.input_application_opened(session);
+     controller.input_surface_opened(session, surface);
+     EXPECT_THROW({
+             // We can't open a surface twice
+             controller.input_surface_opened(session, surface);
+     }, std::logic_error);
+}
+
+TEST_F(AndroidDispatcherControllerFdSetup, input_surface_closed_behavior)
+{
+    using namespace ::testing;
+
+    auto session = std::make_shared<mtd::StubSessionTarget>();
+    auto surface = std::make_shared<mtd::StubSurfaceTarget>(test_input_fd);
+
+    EXPECT_CALL(config, the_dispatcher()).Times(1)
+        .WillOnce(Return(dispatcher));
+    EXPECT_CALL(*dispatcher, registerInputChannel(_, WindowHandleFor(session, surface), false)).Times(1)
+        .WillOnce(Return(droidinput::OK));
+    EXPECT_CALL(*dispatcher, unregisterInputChannel(_)).Times(1);
+    mia::DispatcherController controller(mt::fake_shared(config));
+    
+    controller.input_application_opened(session);
+
+    EXPECT_THROW({
+            // We can't close a surface which hasn't been opened
+            controller.input_surface_closed(surface);
+    }, std::logic_error);
+    controller.input_surface_opened(session, surface);
+    controller.input_surface_closed(surface);
+    EXPECT_THROW({
+            // Nor can we close a surface twice
+            controller.input_surface_closed(surface);
+    }, std::logic_error);
+}
+
+TEST_F(AndroidDispatcherControllerFdSetup, on_focus_cleared)
+{
+    using namespace ::testing;
+
+    EXPECT_CALL(config, the_dispatcher()).Times(1)
+        .WillOnce(Return(dispatcher));
+
+    EXPECT_CALL(*dispatcher, setFocusedApplication(droidinput::sp<droidinput::InputApplicationHandle>(0))).Times(1);
+    EXPECT_CALL(*dispatcher, setInputWindows(EmptyVector())).Times(1);
+
+    mia::DispatcherController controller(mt::fake_shared(config));
+    
+    controller.focus_cleared();
+}
+
+TEST_F(AndroidDispatcherControllerFdSetup, on_focus_changed)
+{
+    using namespace ::testing;
+
+    auto session = std::make_shared<mtd::StubSessionTarget>();
+    auto surface = std::make_shared<mtd::StubSurfaceTarget>(test_input_fd);
+
+    EXPECT_CALL(config, the_dispatcher()).Times(1)
+        .WillOnce(Return(dispatcher));
+    EXPECT_CALL(*dispatcher, registerInputChannel(_, WindowHandleFor(session, surface), false)).Times(1)
+        .WillOnce(Return(droidinput::OK));
 
     {
         InSequence seq;
         EXPECT_CALL(*dispatcher, setFocusedApplication(ApplicationHandleFor(session))).Times(1);
-        EXPECT_CALL(*dispatcher, registerInputChannel(_, WindowHandleFor(session, surface), false)).Times(1)
-            .WillOnce(Return(droidinput::OK));
         EXPECT_CALL(*dispatcher, setInputWindows(VectorContainingWindowHandleFor(session, surface))).Times(1);
-        EXPECT_CALL(*dispatcher, unregisterInputChannel(_)).Times(1);
-        EXPECT_CALL(*dispatcher, setInputWindows(EmptyVector())).Times(1);
     }
 
     mia::DispatcherController controller(mt::fake_shared(config));
-
-    controller.set_input_focus_to(session, surface);
-    controller.set_input_focus_to(session, std::shared_ptr<mi::SurfaceTarget>());
+    
+    controller.input_application_opened(session);
+    controller.input_surface_opened(session, surface);
+
+    controller.focus_changed(surface);
+}
+
+TEST_F(AndroidDispatcherControllerFdSetup, on_focus_changed_throw_behavior)
+{
+    using namespace ::testing;
+
+    EXPECT_CALL(config, the_dispatcher()).Times(1)
+        .WillOnce(Return(dispatcher));
+
+    auto surface = std::make_shared<mtd::StubSurfaceTarget>(test_input_fd);
+
+    mia::DispatcherController controller(mt::fake_shared(config));
+
+    EXPECT_THROW({
+            // We can't focus surfaces which never opened
+            controller.focus_changed(surface);
+    }, std::logic_error);
 }

=== modified file 'tests/unit-tests/input/android/test_event_filter_input_dispatcher_policy.cpp'
--- tests/unit-tests/input/android/test_event_filter_input_dispatcher_policy.cpp	2013-03-22 16:41:59 +0000
+++ tests/unit-tests/input/android/test_event_filter_input_dispatcher_policy.cpp	2013-04-22 15:55:31 +0000
@@ -37,7 +37,7 @@
     using namespace ::testing;
     droidinput::KeyEvent ev;
     mtd::MockEventFilter filter;
-    mia::EventFilterDispatcherPolicy policy(mt::fake_shared(filter));
+    mia::EventFilterDispatcherPolicy policy(mt::fake_shared(filter), true);
     uint32_t policy_flags;
 
     EXPECT_CALL(filter, handles(_)).Times(1).WillOnce(Return(false));

=== modified file 'tests/unit-tests/shell/test_application_session.cpp'
--- tests/unit-tests/shell/test_application_session.cpp	2013-04-17 18:18:31 +0000
+++ tests/unit-tests/shell/test_application_session.cpp	2013-04-22 15:55:31 +0000
@@ -22,6 +22,7 @@
 #include "mir_test/fake_shared.h"
 #include "mir_test_doubles/mock_surface_factory.h"
 #include "mir_test_doubles/mock_surface.h"
+#include "mir_test_doubles/stub_input_target_listener.h"
 #include "mir_test_doubles/stub_surface_builder.h"
 #include "mir_test_doubles/stub_surface.h"
 
@@ -51,7 +52,8 @@
     EXPECT_CALL(surface_factory, create_surface(_));
     EXPECT_CALL(*mock_surface, destroy());
 
-    msh::ApplicationSession session(mt::fake_shared(surface_factory), "Foo");
+    mtd::StubInputTargetListener input_listener;
+    msh::ApplicationSession session(mt::fake_shared(surface_factory), mt::fake_shared(input_listener), "Foo");
 
     mf::SurfaceCreationParameters params;
     auto surf = session.create_surface(params);
@@ -75,7 +77,8 @@
             .WillOnce(Return(std::make_shared<NiceMock<mtd::MockSurface>>(mt::fake_shared(surface_builder))));
     }
 
-    msh::ApplicationSession app_session(mt::fake_shared(surface_factory), "Foo");
+    mtd::StubInputTargetListener input_listener;
+    msh::ApplicationSession app_session(mt::fake_shared(surface_factory), mt::fake_shared(input_listener), "Foo");
 
     mf::SurfaceCreationParameters params;
     auto id1 = app_session.create_surface(params);
@@ -105,7 +108,8 @@
     mtd::MockSurfaceFactory surface_factory;
     ON_CALL(surface_factory, create_surface(_)).WillByDefault(Return(mock_surface));
 
-    msh::ApplicationSession app_session(mt::fake_shared(surface_factory), "Foo");
+    mtd::StubInputTargetListener input_listener;
+    msh::ApplicationSession app_session(mt::fake_shared(surface_factory), mt::fake_shared(input_listener), "Foo");
 
     EXPECT_CALL(surface_factory, create_surface(_));
 
@@ -130,7 +134,8 @@
     using namespace ::testing;
 
     mtd::MockSurfaceFactory surface_factory;
-    msh::ApplicationSession app_session(mt::fake_shared(surface_factory), "Foo");
+    mtd::StubInputTargetListener input_listener;
+    msh::ApplicationSession app_session(mt::fake_shared(surface_factory), mt::fake_shared(input_listener), "Foo");
     mf::SurfaceId invalid_surface_id(1);
 
     EXPECT_THROW({
@@ -143,7 +148,8 @@
     using namespace ::testing;
 
     mtd::MockSurfaceFactory surface_factory;
-    msh::ApplicationSession app_session(mt::fake_shared(surface_factory), "Foo");
+    mtd::StubInputTargetListener input_listener;
+    msh::ApplicationSession app_session(mt::fake_shared(surface_factory), mt::fake_shared(input_listener), "Foo");
     mf::SurfaceId invalid_surface_id(1);
 
     EXPECT_THROW({

=== modified file 'tests/unit-tests/shell/test_registration_order_focus_sequence.cpp'
--- tests/unit-tests/shell/test_registration_order_focus_sequence.cpp	2013-04-18 00:00:55 +0000
+++ tests/unit-tests/shell/test_registration_order_focus_sequence.cpp	2013-04-22 15:55:31 +0000
@@ -22,8 +22,11 @@
 #include "mir/shell/registration_order_focus_sequence.h"
 #include "mir/frontend/surface_creation_parameters.h"
 #include "mir/surfaces/surface.h"
+
 #include "mir_test_doubles/mock_buffer_bundle.h"
 #include "mir_test_doubles/mock_surface_factory.h"
+#include "mir_test_doubles/stub_input_target_listener.h"
+#include "mir_test/fake_shared.h"
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
@@ -32,7 +35,8 @@
 namespace mc = mir::compositor;
 namespace msh = mir::shell;
 namespace ms = mir::surfaces;
-namespace mtd = mir::test::doubles;
+namespace mt = mir::test;
+namespace mtd = mt::doubles;
 
 namespace
 {
@@ -45,6 +49,7 @@
     }
     std::shared_ptr<mtd::MockSurfaceFactory> factory;
     std::shared_ptr<msh::DefaultSessionContainer> container;
+    mtd::StubInputTargetListener input_listener;
 
     static std::string const testing_app_name1;
     static std::string const testing_app_name2;
@@ -60,9 +65,9 @@
 {
     using namespace ::testing;
 
-    auto app1 = std::make_shared<msh::ApplicationSession>(factory, testing_app_name1);
-    auto app2 = std::make_shared<msh::ApplicationSession>(factory, testing_app_name2);
-    auto app3 = std::make_shared<msh::ApplicationSession>(factory, testing_app_name3);
+    auto app1 = std::make_shared<msh::ApplicationSession>(factory, mt::fake_shared(input_listener), testing_app_name1);
+    auto app2 = std::make_shared<msh::ApplicationSession>(factory, mt::fake_shared(input_listener), testing_app_name2);
+    auto app3 = std::make_shared<msh::ApplicationSession>(factory, mt::fake_shared(input_listener), testing_app_name3);
 
     container->insert_session(app1);
     container->insert_session(app2);
@@ -78,9 +83,9 @@
 {
     using namespace ::testing;
 
-    auto app1 = std::make_shared<msh::ApplicationSession>(factory, testing_app_name1);
-    auto app2 = std::make_shared<msh::ApplicationSession>(factory, testing_app_name2);
-    auto app3 = std::make_shared<msh::ApplicationSession>(factory, testing_app_name3);
+    auto app1 = std::make_shared<msh::ApplicationSession>(factory, mt::fake_shared(input_listener), testing_app_name1);
+    auto app2 = std::make_shared<msh::ApplicationSession>(factory, mt::fake_shared(input_listener), testing_app_name2);
+    auto app3 = std::make_shared<msh::ApplicationSession>(factory, mt::fake_shared(input_listener), testing_app_name3);
     container->insert_session(app1);
     container->insert_session(app2);
     container->insert_session(app3);
@@ -95,7 +100,7 @@
 {
     using namespace ::testing;
 
-    auto app1 = std::make_shared<msh::ApplicationSession>(factory, testing_app_name1);
+    auto app1 = std::make_shared<msh::ApplicationSession>(factory, mt::fake_shared(input_listener), testing_app_name1);
     container->insert_session(app1);
 
     msh::RegistrationOrderFocusSequence focus_sequence(container);
@@ -107,8 +112,8 @@
 {
     using namespace ::testing;
 
-    auto app1 = std::make_shared<msh::ApplicationSession>(factory, testing_app_name1);
-    auto app2 = std::make_shared<msh::ApplicationSession>(factory, testing_app_name2);
+    auto app1 = std::make_shared<msh::ApplicationSession>(factory, mt::fake_shared(input_listener), testing_app_name1);
+    auto app2 = std::make_shared<msh::ApplicationSession>(factory, mt::fake_shared(input_listener), testing_app_name2);
     auto null_session = std::shared_ptr<msh::ApplicationSession>();
 
     msh::RegistrationOrderFocusSequence focus_sequence(container);
@@ -124,7 +129,7 @@
 {
     using namespace ::testing;
 
-    auto invalid_session = std::make_shared<msh::ApplicationSession>(factory, testing_app_name1);
+    auto invalid_session = std::make_shared<msh::ApplicationSession>(factory, mt::fake_shared(input_listener), testing_app_name1);
     auto null_session = std::shared_ptr<msh::ApplicationSession>();
 
     msh::RegistrationOrderFocusSequence focus_sequence(container);

=== modified file 'tests/unit-tests/shell/test_session_manager.cpp'
--- tests/unit-tests/shell/test_session_manager.cpp	2013-04-18 22:29:24 +0000
+++ tests/unit-tests/shell/test_session_manager.cpp	2013-04-22 15:55:31 +0000
@@ -21,15 +21,19 @@
 #include "mir/shell/session_manager.h"
 #include "mir/shell/default_session_container.h"
 #include "mir/shell/session.h"
+#include "mir/shell/input_target_listener.h"
 #include "mir/frontend/surface_creation_parameters.h"
 #include "mir/surfaces/surface.h"
 #include "mir/input/input_channel.h"
+
+#include "mir_test/fake_shared.h"
 #include "mir_test_doubles/mock_buffer_bundle.h"
-#include "mir_test/fake_shared.h"
 #include "mir_test_doubles/mock_surface_factory.h"
 #include "mir_test_doubles/mock_focus_setter.h"
 #include "mir_test_doubles/null_buffer_bundle.h"
 #include "mir_test_doubles/stub_surface_builder.h"
+#include "mir_test_doubles/stub_input_target_listener.h"
+#include "mir_test_doubles/mock_input_target_listener.h"
 
 #include "mir/shell/surface.h"
 
@@ -56,7 +60,7 @@
     ~MockSessionContainer() noexcept {}
 };
 
-struct MockFocusSequence: public msh::FocusSequence
+struct MockFocusSequence : public msh::FocusSequence
 {
     MOCK_CONST_METHOD1(successor_of, std::shared_ptr<msh::Session>(std::shared_ptr<msh::Session> const&));
     MOCK_CONST_METHOD1(predecessor_of, std::shared_ptr<msh::Session>(std::shared_ptr<msh::Session> const&));
@@ -68,16 +72,18 @@
     SessionManagerSetup()
       : session_manager(mt::fake_shared(surface_factory),
                         mt::fake_shared(container),
-                        mt::fake_shared(sequence),
-                        mt::fake_shared(focus_setter))
+                        mt::fake_shared(focus_sequence),
+                        mt::fake_shared(focus_setter),
+                        mt::fake_shared(input_target_listener))
     {
     }
 
     mtd::StubSurfaceBuilder surface_builder;
     mtd::MockSurfaceFactory surface_factory;
     testing::NiceMock<MockSessionContainer> container;    // Inelegant but some tests need a stub
-    MockFocusSequence sequence;
+    MockFocusSequence focus_sequence;
     testing::NiceMock<mtd::MockFocusSetter> focus_setter; // Inelegant but some tests need a stub
+    mtd::StubInputTargetListener input_target_listener;
 
     msh::SessionManager session_manager;
 };
@@ -93,7 +99,7 @@
     EXPECT_CALL(focus_setter, set_focus_to(_));
     EXPECT_CALL(focus_setter, set_focus_to(std::shared_ptr<msh::Session>())).Times(1);
 
-    EXPECT_CALL(sequence, default_focus()).WillOnce(Return((std::shared_ptr<msh::Session>())));
+    EXPECT_CALL(focus_sequence, default_focus()).WillOnce(Return((std::shared_ptr<msh::Session>())));
 
     auto session = session_manager.open_session("Visual Basic Studio");
     session_manager.close_session(session);
@@ -118,7 +124,7 @@
     EXPECT_CALL(focus_setter, set_focus_to(_)).Times(1);
     EXPECT_CALL(focus_setter, set_focus_to(std::shared_ptr<msh::Session>())).Times(1);
 
-    EXPECT_CALL(sequence, default_focus()).WillOnce(Return((std::shared_ptr<msh::Session>())));
+    EXPECT_CALL(focus_sequence, default_focus()).WillOnce(Return((std::shared_ptr<msh::Session>())));
 
     auto session = session_manager.open_session("Visual Basic Studio");
     session->create_surface(mf::a_surface().of_size(geom::Size{geom::Width{1024}, geom::Height{768}}));
@@ -164,7 +170,7 @@
     session_manager.tag_session_with_lightdm_id(session1, 1);
     session_manager.focus_session_with_lightdm_id(1);
 
-    EXPECT_CALL(sequence, default_focus()).WillOnce(Return(shell_session2));
+    EXPECT_CALL(focus_sequence, default_focus()).WillOnce(Return(shell_session2));
     EXPECT_CALL(focus_setter, set_focus_to(Eq(shell_session2)));
 
     session_manager.close_session(session1);
@@ -193,3 +199,62 @@
     session_manager.create_surface_for(session1, mf::a_surface());
 }
 
+namespace
+{
+
+struct SessionManagerInputTargetListenerSetup : public testing::Test
+{
+    SessionManagerInputTargetListenerSetup()
+      : session_manager(mt::fake_shared(surface_factory),
+                        mt::fake_shared(container),
+                        mt::fake_shared(focus_sequence),
+                        mt::fake_shared(focus_setter),
+                        mt::fake_shared(input_target_listener))
+    {
+    }
+
+    mtd::StubSurfaceBuilder surface_builder;
+    mtd::MockSurfaceFactory surface_factory;
+    testing::NiceMock<MockSessionContainer> container;    // Inelegant but some tests need a stub
+    testing::NiceMock<MockFocusSequence> focus_sequence;
+    testing::NiceMock<mtd::MockFocusSetter> focus_setter; // Inelegant but some tests need a stub
+    mtd::MockInputTargetListener input_target_listener;
+
+    msh::SessionManager session_manager;
+};
+
+}
+
+TEST_F(SessionManagerInputTargetListenerSetup, listener_is_notified_of_session_and_surfacelifecycle)
+{
+    using namespace ::testing;
+
+    std::shared_ptr<mi::InputChannel> null_input_channel;
+    ON_CALL(surface_factory, create_surface(_)).WillByDefault(
+       Return(std::make_shared<msh::Surface>(
+           mt::fake_shared(surface_builder),
+           mf::a_surface(),
+           null_input_channel)));
+    EXPECT_CALL(surface_factory, create_surface(_)).Times(1);
+
+    EXPECT_CALL(focus_sequence, default_focus()).WillOnce(Return((std::shared_ptr<msh::Session>())));
+    {
+        InSequence seq;
+
+        EXPECT_CALL(input_target_listener, input_application_opened(_))
+            .Times(1);
+        EXPECT_CALL(input_target_listener, input_surface_opened(_, _)).Times(1);
+        EXPECT_CALL(input_target_listener, focus_changed(_)).Times(1);
+        EXPECT_CALL(input_target_listener, input_surface_closed(_)).Times(1);
+        EXPECT_CALL(input_target_listener, input_application_closed(_))
+            .Times(1);
+        EXPECT_CALL(input_target_listener, focus_cleared()).Times(1);
+    }
+
+    {
+        auto session = session_manager.open_session("test");
+        auto surf = session_manager.create_surface_for(session, mf::a_surface());
+        session->destroy_surface(surf);
+        session_manager.close_session(session);
+    }
+}

=== modified file 'tests/unit-tests/shell/test_single_visibility_focus_mechanism.cpp'
--- tests/unit-tests/shell/test_single_visibility_focus_mechanism.cpp	2013-04-19 15:33:04 +0000
+++ tests/unit-tests/shell/test_single_visibility_focus_mechanism.cpp	2013-04-22 15:55:31 +0000
@@ -27,7 +27,6 @@
 #include "mir_test_doubles/mock_buffer_bundle.h"
 #include "mir_test/fake_shared.h"
 #include "mir_test_doubles/mock_surface_factory.h"
-#include "mir_test_doubles/mock_input_focus_selector.h"
 #include "mir_test_doubles/stub_surface.h"
 #include "mir_test_doubles/mock_surface.h"
 #include "mir_test_doubles/stub_surface_builder.h"
@@ -64,8 +63,6 @@
 {
     using namespace ::testing;
 
-    NiceMock<mtd::MockInputFocusSelector> input_focus_selector;
-
     NiceMock<MockShellSession> app1, app2, app3;
     msh::DefaultSessionContainer model;
 
@@ -73,7 +70,7 @@
     ON_CALL(app2, default_surface()).WillByDefault(Return(std::shared_ptr<msh::Surface>()));
     ON_CALL(app3, default_surface()).WillByDefault(Return(std::shared_ptr<msh::Surface>()));
 
-    msh::SingleVisibilityFocusMechanism focus_mechanism(mt::fake_shared(model), mt::fake_shared(input_focus_selector));
+    msh::SingleVisibilityFocusMechanism focus_mechanism(mt::fake_shared(model));
 
     EXPECT_CALL(app1, show()).Times(1);
     EXPECT_CALL(app2, hide()).Times(1);
@@ -89,23 +86,3 @@
 
     focus_mechanism.set_focus_to(mt::fake_shared(app1));
 }
-
-TEST(SingleVisibilityFocusMechanism, mechanism_sets_input_focus_from_default_surface)
-{
-    using namespace ::testing;
-
-    mtd::MockInputFocusSelector input_focus_selector;
-    msh::DefaultSessionContainer model;
-    auto session = std::make_shared<NiceMock<MockShellSession>>();
-    auto surface = std::make_shared<mtd::MockSurface>(std::make_shared<mtd::StubSurfaceBuilder>());
-
-    msh::SingleVisibilityFocusMechanism focus_mechanism(mt::fake_shared(model), mt::fake_shared(input_focus_selector));
-
-    EXPECT_CALL(*session, default_surface()).Times(1).WillOnce(Return(surface));
-
-    EXPECT_CALL(input_focus_selector, set_input_focus_to(Eq(session), Eq(surface))).Times(1);
-
-    model.insert_session(session);
-    focus_mechanism.set_focus_to(session);
-}
-

=== modified file 'tests/unit-tests/shell/test_the_session_container_implementation.cpp'
--- tests/unit-tests/shell/test_the_session_container_implementation.cpp	2013-04-18 00:00:55 +0000
+++ tests/unit-tests/shell/test_the_session_container_implementation.cpp	2013-04-22 15:55:31 +0000
@@ -22,6 +22,7 @@
 #include "mir/frontend/surface_creation_parameters.h"
 #include "mir/surfaces/surface.h"
 #include "mir_test_doubles/mock_buffer_bundle.h"
+#include "mir_test_doubles/stub_input_target_listener.h"
 #include "mir_test_doubles/mock_surface_factory.h"
 
 #include <gmock/gmock.h>
@@ -38,8 +39,10 @@
     auto factory = std::make_shared<mtd::MockSurfaceFactory>();
     msh::DefaultSessionContainer container;
 
-    container.insert_session(std::make_shared<msh::ApplicationSession>(factory, "Visual Studio 7"));
-    container.insert_session(std::make_shared<msh::ApplicationSession>(factory, "Visual Studio 8"));
+    container.insert_session(std::make_shared<msh::ApplicationSession>(factory, std::make_shared<mtd::StubInputTargetListener>(), 
+        "Visual Studio 7"));
+    container.insert_session(std::make_shared<msh::ApplicationSession>(factory, std::make_shared<mtd::StubInputTargetListener>(), 
+        "Visual Studio 8"));
 
     struct local
     {
@@ -64,8 +67,8 @@
     auto factory = std::make_shared<mtd::MockSurfaceFactory>();
     msh::DefaultSessionContainer container;
 
-    auto session = std::make_shared<msh::ApplicationSession>(factory,
-                                                               "Visual Studio 7");
+    auto session = std::make_shared<msh::ApplicationSession>(factory, std::make_shared<mtd::StubInputTargetListener>(), 
+        "Visual Studio 7");
     EXPECT_THROW({
         container.remove_session(session);
     }, std::logic_error);