Merge lp:~robertcarr/mir/input-injecter-api into lp:mir

[Robert Carr]

Implement input injection API to satisfy the shell hud use case.

Implement input injection API to satisfy the shell hud use case.

-- Still work in progress -- needs a little cleanup and an additional unit test for android input lexicon. Just getting some early air. --

[lp:~robertcarr/mir/input-injecter-api]

1104. By Robert Carr on 2013-10-02

Complete android input lexicon reversal tests

1105. By Robert Carr on 2013-10-02

Merge development branch

1106. By Robert Carr on 2013-10-02

Clarify exception case

1107. By Robert Carr on 2013-10-03

Cleanup

1108. By Robert Carr on 2013-10-03

Cleanup

1109. By Robert Carr on 2013-10-03

Fix unitialized event structures in test

1110. By Robert Carr on 2013-10-04

Correct uninitialized portion of android event to silence valgrind errors

1111. By Robert Carr on 2013-10-04

Correct ordering

Unmerged revisions

1111. By Robert Carr on 2013-10-04

Correct ordering

1110. By Robert Carr on 2013-10-04

Correct uninitialized portion of android event to silence valgrind errors

1109. By Robert Carr on 2013-10-03

Fix unitialized event structures in test

1108. By Robert Carr on 2013-10-03

Cleanup

1107. By Robert Carr on 2013-10-03

Cleanup

1106. By Robert Carr on 2013-10-02

Clarify exception case

1105. By Robert Carr on 2013-10-02

Merge development branch

1104. By Robert Carr on 2013-10-02

Complete android input lexicon reversal tests

1103. By Robert Carr on 2013-10-01

Implement injected dispatch of motion events. ACceptance test passes

1102. By Robert Carr on 2013-10-01

Support reverse motion event mapping

=== modified file '3rd_party/android-input/android/frameworks/base/services/input/InputDispatcher.cpp'
--- 3rd_party/android-input/android/frameworks/base/services/input/InputDispatcher.cpp	2013-08-28 03:41:48 +0000
+++ 3rd_party/android-input/android/frameworks/base/services/input/InputDispatcher.cpp	2013-10-01 22:23:19 +0000
@@ -4266,6 +4266,61 @@
     return haveSlipperyForegroundWindow;
 }
 
+void InputDispatcher::publishEventToConnectionLocked(sp<Connection> const& connection, InputEvent const* event)
+{
+    switch (event->getType())
+    {
+        case AINPUT_EVENT_TYPE_KEY:
+        {
+            auto seq = DispatchEntry::nextSeq();
+            auto kev = static_cast<KeyEvent const*>(event);
+            auto status = connection->inputPublisher.publishKeyEvent(seq,
+                    kev->getDeviceId(), kev->getSource(),
+                    kev->getAction(), kev->getFlags(),
+                    kev->getKeyCode(), kev->getScanCode(),
+                    kev->getMetaState(), kev->getRepeatCount(), kev->getDownTime(),
+                    kev->getEventTime());
+
+            input_report->published_key_event(connection->inputChannel->getFd(),
+                                              seq,
+                                              kev->getEventTime());
+            break;
+        }
+        case AINPUT_EVENT_TYPE_MOTION:
+        {
+            auto seq = DispatchEntry::nextSeq();
+            auto mev = static_cast<MotionEvent const*>(event);
+            auto status = connection->inputPublisher.publishMotionEvent(seq,
+                    mev->getDeviceId(), mev->getSource(),
+                    mev->getAction(), mev->getFlags(),
+                    mev->getEdgeFlags(), mev->getMetaState(), mev->getButtonState(),
+                    mev->getXOffset(), mev->getYOffset(),
+                    mev->getXPrecision(), mev->getYPrecision(),                                               
+                    mev->getDownTime(), mev->getEventTime(),
+                    mev->getPointerCount(), mev->getPointerProperties(), mev->getSamplePointerCoords());
+            input_report->published_motion_event(connection->inputChannel->getFd(),
+                                                 seq,
+                                                 mev->getEventTime());
+        }
+        default:
+            break;
+    }
+}
+
+
+void InputDispatcher::injectEventToWindow(sp<InputWindowHandle> const& windowHandle, InputEvent const* event)
+{
+    AutoMutex _l(mLock);
+    
+    auto index = getConnectionIndexLocked(windowHandle->getInfo()->inputChannel);
+    
+    if (index >= 0)
+    {
+        auto connection = mConnectionsByFd.valueAt(index);
+        publishEventToConnectionLocked(connection, event);
+    }
+}
+
 
 // --- InputDispatcherThread ---
 

=== modified file '3rd_party/android-input/android/frameworks/base/services/input/InputDispatcher.h'
--- 3rd_party/android-input/android/frameworks/base/services/input/InputDispatcher.h	2013-05-30 19:24:29 +0000
+++ 3rd_party/android-input/android/frameworks/base/services/input/InputDispatcher.h	2013-10-01 22:23:19 +0000
@@ -323,6 +323,13 @@
      * This method may be called on any thread.
      */
     virtual void setKeyboardFocus(const sp<InputWindowHandle>& windowHandle) = 0;
+    
+    /*
+     * Asynchronously publish an event directly to a given input channel.
+     *
+     * This method may be called on any thread.
+     */
+    virtual void injectEventToWindow(sp<InputWindowHandle> const& windowHandle, InputEvent const* event) = 0;
     /*
      * Notify that a window handle is about to vanish
 
@@ -423,6 +430,8 @@
     virtual status_t registerInputChannel(const sp<InputChannel>& inputChannel,
             const sp<InputWindowHandle>& inputWindowHandle, bool monitor);
     virtual status_t unregisterInputChannel(const sp<InputChannel>& inputChannel);
+
+    void injectEventToWindow(sp<InputWindowHandle> const& windowHandle, InputEvent const* event);
     
 private:
     std::shared_ptr<mir::input::InputReport> const input_report;
@@ -586,10 +595,10 @@
             return targetFlags & InputTarget::FLAG_SPLIT;
         }
 
+        static uint32_t nextSeq();
+
     private:
         static android_atomic_int32_t sNextSeqAtomic;
-
-        static uint32_t nextSeq();
     };
 
     // A command entry captures state and behavior for an action to be performed in the
@@ -1117,6 +1126,8 @@
             int32_t injectionResult, nsecs_t timeSpentWaitingForApplication);
 
     void setKeyboardFocusLocked(const sp<InputWindowHandle>& windowHandle);
+
+    void publishEventToConnectionLocked(sp<Connection> const& connection, InputEvent const* event);
 };
 
 /* Enqueues and dispatches input events, endlessly. */

=== modified file 'include/server/mir/default_server_configuration.h'
--- include/server/mir/default_server_configuration.h	2013-09-27 16:53:41 +0000
+++ include/server/mir/default_server_configuration.h	2013-10-01 22:23:19 +0000
@@ -58,6 +58,7 @@
 class SurfaceBuilder;
 class SurfaceController;
 class InputTargeter;
+class InputInjecter;
 class SessionContainer;
 class FocusSetter;
 class FocusSequence;
@@ -225,6 +226,7 @@
     virtual std::shared_ptr<input::CompositeEventFilter> the_composite_event_filter();
     virtual std::shared_ptr<surfaces::InputRegistrar> the_input_registrar();
     virtual std::shared_ptr<shell::InputTargeter> the_input_targeter();
+    virtual std::shared_ptr<shell::InputInjecter> the_input_injecter();
     virtual std::shared_ptr<input::CursorListener> the_cursor_listener();
     virtual std::shared_ptr<input::InputRegion>    the_input_region();
     /** @} */
@@ -263,6 +265,7 @@
     CachedPtr<input::InputRegion>     input_region;
     CachedPtr<surfaces::InputRegistrar> input_registrar;
     CachedPtr<shell::InputTargeter> input_targeter;
+    CachedPtr<shell::InputInjecter> input_injecter;
     CachedPtr<input::CursorListener> cursor_listener;
     CachedPtr<graphics::Platform>     graphics_platform;
     CachedPtr<graphics::BufferInitializer> buffer_initializer;

=== modified file 'include/server/mir/input/android/dispatcher_input_configuration.h'
--- include/server/mir/input/android/dispatcher_input_configuration.h	2013-09-10 16:42:04 +0000
+++ include/server/mir/input/android/dispatcher_input_configuration.h	2013-10-01 22:23:19 +0000
@@ -93,6 +93,7 @@
     std::shared_ptr<surfaces::InputRegistrar> the_input_registrar();
     std::shared_ptr<shell::InputTargeter> the_input_targeter();
     std::shared_ptr<input::InputManager> the_input_manager();
+    std::shared_ptr<shell::InputInjecter> the_input_injecter();
 
     void set_input_targets(std::shared_ptr<input::InputTargets> const& targets);
 
@@ -119,6 +120,7 @@
     CachedPtr<InputRegistrar> input_registrar;
 
     CachedPtr<shell::InputTargeter> input_targeter;
+    CachedPtr<shell::InputInjecter> input_injecter;
 
     CachedAndroidPtr<droidinput::InputDispatcherPolicyInterface> dispatcher_policy;
 };

=== modified file 'include/server/mir/input/input_configuration.h'
--- include/server/mir/input/input_configuration.h	2013-05-24 19:27:37 +0000
+++ include/server/mir/input/input_configuration.h	2013-10-01 22:23:19 +0000
@@ -30,6 +30,7 @@
 namespace shell
 {
 class InputTargeter;
+class InputInjecter;
 }
 namespace input
 {
@@ -44,6 +45,7 @@
     virtual std::shared_ptr<surfaces::InputRegistrar> the_input_registrar() = 0;
     virtual std::shared_ptr<shell::InputTargeter> the_input_targeter() = 0;
     virtual std::shared_ptr<input::InputManager> the_input_manager() = 0;
+    virtual std::shared_ptr<shell::InputInjecter> the_input_injecter() = 0;
     
     virtual void set_input_targets(std::shared_ptr<input::InputTargets> const& targets) = 0;
 

=== modified file 'include/server/mir/input/null_input_configuration.h'
--- include/server/mir/input/null_input_configuration.h	2013-05-28 13:31:27 +0000
+++ include/server/mir/input/null_input_configuration.h	2013-10-01 22:23:19 +0000
@@ -34,6 +34,7 @@
 
     std::shared_ptr<surfaces::InputRegistrar> the_input_registrar();
     std::shared_ptr<shell::InputTargeter> the_input_targeter();
+    std::shared_ptr<shell::InputInjecter> the_input_injecter();
     std::shared_ptr<InputManager> the_input_manager();
     
     void set_input_targets(std::shared_ptr<InputTargets> const& /* targets */);

=== added file 'include/server/mir/shell/input_injecter.h'
--- include/server/mir/shell/input_injecter.h	1970-01-01 00:00:00 +0000
+++ include/server/mir/shell/input_injecter.h	2013-10-01 22:23:19 +0000
@@ -0,0 +1,55 @@
+/*
+ * 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_INJECTER_H_
+#define MIR_SHELL_INPUT_INJECTER_H_
+
+#include "mir_toolkit/event.h"
+
+#include <memory>
+
+namespace mir
+{
+
+namespace input
+{
+class InputChannel;
+}
+
+namespace shell
+{
+
+/// An interface used to control the selection of keyboard input focus.
+class InputInjecter
+{
+public:
+    virtual ~InputInjecter() = default;
+    
+    virtual void inject_input(std::shared_ptr<input::InputChannel const> const& target,
+                              MirEvent const& ev) = 0;
+
+protected:
+    InputInjecter() = default;
+    InputInjecter(InputInjecter const&) = delete;
+    InputInjecter& operator=(InputInjecter const&) = delete;
+};
+
+}
+} // namespace mir
+
+#endif // MIR_SHELL_INPUT_INJECTER_H_

=== modified file 'include/server/mir/shell/surface.h'
--- include/server/mir/shell/surface.h	2013-08-28 03:41:48 +0000
+++ include/server/mir/shell/surface.h	2013-10-01 22:23:19 +0000
@@ -26,6 +26,7 @@
 #include "mir/surfaces/surface.h"
 
 #include "mir_toolkit/common.h"
+#include "mir_toolkit/event.h"
 
 #include <string>
 
@@ -42,6 +43,7 @@
 class SurfaceBuilder;
 class SurfaceConfigurator;
 class SurfaceController;
+class InputInjecter;
 struct SurfaceCreationParameters;
 
 class Surface : public frontend::ClientTrackingSurface, public shell::SurfaceBufferAccess
@@ -90,6 +92,8 @@
     virtual void allow_framedropping(bool); 
     
     virtual void raise(std::shared_ptr<SurfaceController> const& controller);
+    
+    virtual void inject_input(std::shared_ptr<InputInjecter> const& injecter, MirEvent const& ev);
 private:
     bool set_type(MirSurfaceType t);  // Use configure() to make public changes
     bool set_state(MirSurfaceState s);

=== modified file 'include/shared/mir/input/android/android_input_lexicon.h'
--- include/shared/mir/input/android/android_input_lexicon.h	2013-04-24 05:22:20 +0000
+++ include/shared/mir/input/android/android_input_lexicon.h	2013-10-01 22:23:19 +0000
@@ -42,6 +42,7 @@
 {
 public:
     static void translate(const droidinput::InputEvent *android_event, MirEvent &mir_event);
+    static void translate(MirEvent const& mir_event, droidinput::InputEvent **android_event);
 };
 
 }

=== modified file 'include/test/mir_test_doubles/mock_input_dispatcher.h'
--- include/test/mir_test_doubles/mock_input_dispatcher.h	2013-05-24 18:23:48 +0000
+++ include/test/mir_test_doubles/mock_input_dispatcher.h	2013-10-01 22:23:19 +0000
@@ -48,6 +48,8 @@
     
     MOCK_METHOD1(setKeyboardFocus, void(droidinput::sp<droidinput::InputWindowHandle> const&));
     MOCK_METHOD1(notifyWindowRemoved, void(droidinput::sp<droidinput::InputWindowHandle> const&));
+    
+    MOCK_METHOD2(injectEventToWindow, void(droidinput::sp<droidinput::InputWindowHandle> const&, droidinput::InputEvent const*));
 
     // droidinput::InputListener interface
     MOCK_METHOD1(notifyConfigurationChanged, void(droidinput::NotifyConfigurationChangedArgs const*));

=== modified file 'src/server/default_server_configuration.cpp'
--- src/server/default_server_configuration.cpp	2013-09-30 08:41:27 +0000
+++ src/server/default_server_configuration.cpp	2013-10-01 22:23:19 +0000
@@ -45,6 +45,7 @@
 #include "mir/shell/graphics_display_layout.h"
 #include "mir/shell/surface_configurator.h"
 #include "mir/shell/broadcasting_session_event_sink.h"
+#include "mir/shell/input_injecter.h"
 #include "mir/graphics/cursor.h"
 #include "mir/graphics/nested/host_connection.h"
 #include "mir/shell/null_session_listener.h"
@@ -929,6 +930,15 @@
         });
 }
 
+std::shared_ptr<msh::InputInjecter> mir::DefaultServerConfiguration::the_input_injecter()
+{
+    return input_injecter(
+        [&]() -> std::shared_ptr<msh::InputInjecter>
+        {
+            return the_input_configuration()->the_input_injecter();
+        });
+}
+
 std::shared_ptr<ms::InputRegistrar> mir::DefaultServerConfiguration::the_input_registrar()
 {
     return input_registrar(

=== modified file 'src/server/input/android/CMakeLists.txt'
--- src/server/input/android/CMakeLists.txt	2013-09-06 10:06:15 +0000
+++ src/server/input/android/CMakeLists.txt	2013-10-01 22:23:19 +0000
@@ -11,6 +11,7 @@
   ${CMAKE_CURRENT_SOURCE_DIR}/android_input_window_handle.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/android_input_registrar.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/android_input_targeter.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/android_input_injecter.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/android_input_target_enumerator.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/dispatcher_input_configuration.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/input_dispatcher_manager.cpp

=== added file 'src/server/input/android/android_input_injecter.cpp'
--- src/server/input/android/android_input_injecter.cpp	1970-01-01 00:00:00 +0000
+++ src/server/input/android/android_input_injecter.cpp	2013-10-01 22:23:19 +0000
@@ -0,0 +1,58 @@
+/*
+ * 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]>
+ */
+
+#include "android_input_injecter.h"
+#include "android_input_registrar.h"
+
+#include "android_input_window_handle.h"
+#include "android_input_application_handle.h"
+
+#include "mir/input/android/android_input_lexicon.h"
+
+#include <InputDispatcher.h>
+
+#include <boost/throw_exception.hpp>
+
+#include <stdexcept>
+#include <mutex>
+
+namespace mi = mir::input;
+namespace mia = mi::android;
+namespace ms = mir::surfaces;
+
+mia::InputInjecter::InputInjecter(droidinput::sp<droidinput::InputDispatcherInterface> const& input_dispatcher,
+                                  std::shared_ptr<mia::WindowHandleRepository> const& repository) :
+    input_dispatcher(input_dispatcher),
+    repository(repository)
+{
+}
+
+mia::InputInjecter::~InputInjecter() noexcept(true) {}
+
+void mia::InputInjecter::inject_input(std::shared_ptr<mi::InputChannel const> const& focus_channel,
+                                      MirEvent const& ev)
+{
+    auto window_handle = repository->handle_for_channel(focus_channel);
+    
+    if (window_handle == NULL)
+        BOOST_THROW_EXCEPTION(std::logic_error("Attempt to inject input to an unregistered input channel"));
+
+    droidinput::InputEvent *android_event;
+    mia::Lexicon::translate(ev, &android_event);
+    input_dispatcher->injectEventToWindow(window_handle, android_event);
+}

=== added file 'src/server/input/android/android_input_injecter.h'
--- src/server/input/android/android_input_injecter.h	1970-01-01 00:00:00 +0000
+++ src/server/input/android/android_input_injecter.h	2013-10-01 22:23:19 +0000
@@ -0,0 +1,69 @@
+/*
+ * 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_INPUT_ANDROID_INJECTER_H_
+#define MIR_INPUT_ANDROID_INJECTER_H_
+
+#include "mir/shell/input_injecter.h"
+
+#include <utils/StrongPointer.h>
+
+#include <mutex>
+
+namespace android
+{
+class InputDispatcherInterface;
+class InputWindowHandle;
+}
+
+namespace droidinput = android;
+
+namespace mir
+{
+namespace input
+{
+namespace android
+{
+class InputConfiguration;
+class WindowHandleRepository;
+
+class InputInjecter : public shell::InputInjecter
+{
+public:
+    explicit InputInjecter(droidinput::sp<droidinput::InputDispatcherInterface> const& input_dispatcher,
+                           std::shared_ptr<WindowHandleRepository> const& repository);
+    virtual ~InputInjecter() noexcept(true);
+
+    void inject_input(std::shared_ptr<input::InputChannel const> const& target,
+                      MirEvent const& ev);
+
+protected:
+    InputInjecter(const InputInjecter&) = delete;
+    InputInjecter& operator=(const InputInjecter&) = delete;
+
+private:
+    droidinput::sp<droidinput::InputDispatcherInterface> input_dispatcher;
+
+    std::shared_ptr<WindowHandleRepository> const repository;
+};
+
+}
+}
+} // namespace mir
+
+#endif // MIR_INPUT_ANDROID_INJECTER_H_

=== modified file 'src/server/input/android/dispatcher_input_configuration.cpp'
--- src/server/input/android/dispatcher_input_configuration.cpp	2013-09-10 16:42:04 +0000
+++ src/server/input/android/dispatcher_input_configuration.cpp	2013-10-01 22:23:19 +0000
@@ -22,6 +22,7 @@
 #include "android_input_thread.h"
 #include "android_input_registrar.h"
 #include "android_input_targeter.h"
+#include "android_input_injecter.h"
 #include "android_input_target_enumerator.h"
 #include "android_input_manager.h"
 #include "mir/input/event_filter.h"
@@ -135,6 +136,15 @@
         });
 }
 
+std::shared_ptr<msh::InputInjecter> mia::DispatcherInputConfiguration::the_input_injecter()
+{
+    return input_injecter(
+        [this]()
+        {
+            return std::make_shared<mia::InputInjecter>(the_dispatcher(), the_window_handle_repository());
+        });
+}
+
 bool mia::DispatcherInputConfiguration::is_key_repeat_enabled()
 {
     return true;

=== modified file 'src/server/input/null_input_configuration.cpp'
--- src/server/input/null_input_configuration.cpp	2013-08-28 03:41:48 +0000
+++ src/server/input/null_input_configuration.cpp	2013-10-01 22:23:19 +0000
@@ -20,6 +20,7 @@
 
 #include "mir/surfaces/input_registrar.h"
 #include "mir/shell/input_targeter.h"
+#include "mir/shell/input_injecter.h"
 #include "mir/input/input_manager.h"
 
 namespace mi = mir::input;
@@ -73,6 +74,13 @@
     }
 };
 
+struct NullInputInjecter : public msh::InputInjecter
+{
+    void inject_input(std::shared_ptr<mi::InputChannel const> const&, MirEvent const&)
+    {
+    }
+};
+
 }
 
 std::shared_ptr<ms::InputRegistrar> mi::NullInputConfiguration::the_input_registrar()
@@ -85,6 +93,11 @@
     return std::make_shared<NullInputTargeter>();
 }
 
+std::shared_ptr<msh::InputInjecter> mi::NullInputConfiguration::the_input_injecter()
+{
+    return std::make_shared<NullInputInjecter>();
+}
+
 std::shared_ptr<mi::InputManager> mi::NullInputConfiguration::the_input_manager()
 {
     return std::make_shared<NullInputManager>();

=== modified file 'src/server/shell/surface.cpp'
--- src/server/shell/surface.cpp	2013-08-28 03:41:48 +0000
+++ src/server/shell/surface.cpp	2013-10-01 22:23:19 +0000
@@ -21,6 +21,7 @@
 #include "mir/shell/surface_configurator.h"
 #include "mir/shell/surface_controller.h"
 #include "mir/shell/input_targeter.h"
+#include "mir/shell/input_injecter.h"
 #include "mir/input/input_channel.h"
 #include "mir/frontend/event_sink.h"
 
@@ -349,3 +350,15 @@
         BOOST_THROW_EXCEPTION(std::runtime_error("Invalid surface"));
     }
 }
+
+void msh::Surface::inject_input(std::shared_ptr<msh::InputInjecter> const& injecter, MirEvent const& ev)
+{
+    if (auto const& s = surface.lock())
+    {
+        injecter->inject_input(s->input_channel(), ev);
+    }
+    else
+    {
+        BOOST_THROW_EXCEPTION(std::runtime_error("Invalid surface"));
+    }
+}

=== modified file 'src/shared/input/android/android_input_lexicon.cpp'
--- src/shared/input/android/android_input_lexicon.cpp	2013-08-28 03:41:48 +0000
+++ src/shared/input/android/android_input_lexicon.cpp	2013-10-01 22:23:19 +0000
@@ -81,3 +81,61 @@
 
 }
 
+void mia::Lexicon::translate(MirEvent const& mir_event, droidinput::InputEvent **android_event)
+{
+    switch (mir_event.type)
+    {
+        case mir_event_type_key:
+        {
+            auto key_event = new droidinput::KeyEvent();
+            key_event->initialize(mir_event.key.device_id, mir_event.key.source_id, 
+                mir_event.key.action, mir_event.key.flags, mir_event.key.key_code,
+                mir_event.key.scan_code, mir_event.key.modifiers, 
+                mir_event.key.repeat_count, mir_event.key.down_time, mir_event.key.event_time);
+            *android_event = key_event;
+            break;
+        }
+        case mir_event_type_motion:
+        {
+            auto motion_event = new droidinput::MotionEvent();
+            auto const& mmev = mir_event.motion;
+            auto pc = mmev.pointer_count;
+
+            droidinput::PointerProperties *pointer_properties = new droidinput::PointerProperties[pc];
+            droidinput::PointerCoords *pointer_coords = new droidinput::PointerCoords[pc];
+            
+            for (unsigned int i = 0; i < pc; i++)
+            {
+                auto const& mir_coords = mmev.pointer_coordinates[i];
+                pointer_properties[i].id = mir_coords.id;
+
+                auto &coords = pointer_coords[i];
+                coords.setAxisValue(AMOTION_EVENT_AXIS_X, mir_coords.x);
+                coords.setAxisValue(AMOTION_EVENT_AXIS_Y, mir_coords.y);
+                coords.setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR,
+                                    mir_coords.touch_major);
+                coords.setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR,
+                                    mir_coords.touch_minor);
+                coords.setAxisValue(AMOTION_EVENT_AXIS_SIZE, mir_coords.size);
+                coords.setAxisValue(AMOTION_EVENT_AXIS_PRESSURE,
+                                    mir_coords.pressure);
+                coords.setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION,
+                                    mir_coords.orientation);
+            }
+            
+            motion_event->initialize(mmev.device_id, mmev.source_id, mmev.action, mmev.flags,
+                                     mmev.edge_flags, mmev.modifiers, mmev.button_state,
+                                     mmev.x_offset, mmev.y_offset, mmev.x_precision, mmev.y_precision,
+                                     mmev.down_time, mmev.event_time, mmev.pointer_count,
+                                     pointer_properties, pointer_coords);
+            *android_event = motion_event;
+            
+            delete pointer_properties;
+            delete pointer_coords;
+        }
+        case mir_event_type_surface:
+        default:
+            // TODO: LOL
+            break;
+    }
+}

=== modified file 'tests/acceptance-tests/test_client_input.cpp'
--- tests/acceptance-tests/test_client_input.cpp	2013-09-25 18:39:57 +0000
+++ tests/acceptance-tests/test_client_input.cpp	2013-10-01 22:23:19 +0000
@@ -23,6 +23,8 @@
 #include "mir/shell/surface.h"
 #include "mir/shell/session_container.h"
 #include "mir/shell/session.h"
+#include "mir/shell/focus_sequence.h"
+#include "mir/shell/input_injecter.h"
 #include "mir/surfaces/surface_controller.h"
 #include "mir/surfaces/surface_stack_model.h"
 
@@ -943,3 +945,122 @@
     launch_client_process(client_1);
     launch_client_process(client_2);
 }
+
+
+TEST_F(TestClientInput, clients_receive_shell_injected_key_input_per_norm)
+{
+    using namespace ::testing;
+    
+    static std::string const test_client_name = "1";
+
+    mtf::CrossProcessSync fence;
+
+    struct ServerConfiguration : mtf::InputTestingServerConfiguration
+    {
+        mtf::CrossProcessSync input_cb_setup_fence;
+
+        ServerConfiguration(const mtf::CrossProcessSync& input_cb_setup_fence) 
+                : input_cb_setup_fence(input_cb_setup_fence)
+        {
+        }
+
+        std::shared_ptr<msh::Surface> the_most_default_surface()
+        {
+            return the_shell_focus_sequence()->default_focus()->default_surface();
+        }
+
+        void inject_event_to_default_surface(MirEvent &ev)
+        {
+            the_most_default_surface()->inject_input(the_input_injecter(), ev);
+        }
+        
+        void inject_input()
+        {
+            wait_until_client_appears(test_client_name);
+            input_cb_setup_fence.wait_for_signal_ready_for();
+
+            MirEvent ev;
+            ev.type = mir_event_type_key;
+            ev.key.action = mir_key_action_down;
+
+            inject_event_to_default_surface(ev);
+        }
+    } server_config(fence);
+    launch_server_process(server_config);
+    
+    struct KeyReceivingClient : InputClient
+    {
+        KeyReceivingClient(const mtf::CrossProcessSync& fence) : InputClient(fence, test_client_name) {}
+        void expect_input(mt::WaitCondition& events_received) override
+        {
+            using namespace ::testing;
+            InSequence seq;
+
+            EXPECT_CALL(*handler, handle_input(KeyDownEvent())).Times(1)
+                .WillOnce(mt::WakeUp(&events_received));
+        }
+    } client_config(fence);
+    launch_client_process(client_config);
+}
+
+TEST_F(TestClientInput, clients_receive_shell_injected_pointer_input_per_norm)
+{
+    using namespace ::testing;
+    
+    static std::string const test_client_name = "1";
+
+    mtf::CrossProcessSync fence;
+
+    struct ServerConfiguration : mtf::InputTestingServerConfiguration
+    {
+        mtf::CrossProcessSync input_cb_setup_fence;
+
+        ServerConfiguration(const mtf::CrossProcessSync& input_cb_setup_fence) 
+                : input_cb_setup_fence(input_cb_setup_fence)
+        {
+        }
+
+        std::shared_ptr<msh::Surface> the_most_default_surface()
+        {
+            return the_shell_focus_sequence()->default_focus()->default_surface();
+        }
+
+        void inject_event_to_default_surface(MirEvent &ev)
+        {
+            the_most_default_surface()->inject_input(the_input_injecter(), ev);
+        }
+        
+        void inject_input()
+        {
+            wait_until_client_appears(test_client_name);
+            input_cb_setup_fence.wait_for_signal_ready_for();
+
+            MirEvent ev;
+            ev.type = mir_event_type_motion;
+            auto &mev = ev.motion;
+            mev.action = mir_motion_action_down;
+            mev.button_state = mir_motion_button_primary;
+
+            mev.pointer_count = 1;
+            mev.pointer_coordinates[0].x = 1;
+            mev.pointer_coordinates[0].y = 1;
+
+            inject_event_to_default_surface(ev);
+        }
+    } server_config(fence);
+    launch_server_process(server_config);
+    
+    struct MotionReceivingClient : InputClient
+    {
+        MotionReceivingClient(const mtf::CrossProcessSync& fence) : InputClient(fence, test_client_name) {}
+        void expect_input(mt::WaitCondition& events_received) override
+        {
+            using namespace ::testing;
+            InSequence seq;
+
+            EXPECT_CALL(*handler, handle_input(ButtonDownEvent(1, 1))).Times(1)
+                .WillOnce(mt::WakeUp(&events_received));
+        }
+    } client_config(fence);
+    launch_client_process(client_config);
+}

=== modified file 'tests/unit-tests/input/android/CMakeLists.txt'
--- tests/unit-tests/input/android/CMakeLists.txt	2013-08-28 03:41:48 +0000
+++ tests/unit-tests/input/android/CMakeLists.txt	2013-10-01 22:23:19 +0000
@@ -8,6 +8,7 @@
   ${CMAKE_CURRENT_SOURCE_DIR}/test_android_input_application_handle.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_android_input_window_handle.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_android_input_targeter.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_android_input_injecter.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_android_input_target_enumerator.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_android_input_registrar.cpp
 )

=== added file 'tests/unit-tests/input/android/test_android_input_injecter.cpp'
--- tests/unit-tests/input/android/test_android_input_injecter.cpp	1970-01-01 00:00:00 +0000
+++ tests/unit-tests/input/android/test_android_input_injecter.cpp	2013-10-01 22:23:19 +0000
@@ -0,0 +1,93 @@
+/*
+ * 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]>
+ */
+
+#include "src/server/input/android/android_input_injecter.h"
+#include "src/server/input/android/android_input_registrar.h"
+#include "src/server/input/android/android_window_handle_repository.h"
+
+#include "mir/input/input_channel.h"
+
+#include "mir_test_doubles/mock_input_dispatcher.h"
+#include "mir_test_doubles/stub_input_channel.h"
+
+#include "mir_test/fake_shared.h"
+#include "mir_test_doubles/stub_input_channel.h"
+#include "mir_test_doubles/stub_input_handles.h"
+#include "mir_test_doubles/mock_window_handle_repository.h"
+
+#include <InputWindow.h>
+#include <InputApplication.h>
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+#include <sys/types.h>
+#include <sys/socket.h>
+
+#include <stdexcept>
+
+namespace mi = mir::input;
+namespace mia = mi::android;
+namespace mt = mir::test;
+namespace mtd = mt::doubles;
+
+TEST(AndroidInputInjecterSetup, inject_input_throw_behavior)
+{
+    using namespace ::testing;
+
+    droidinput::sp<mtd::MockInputDispatcher> dispatcher = new mtd::MockInputDispatcher;
+    mtd::MockWindowHandleRepository repository;
+    mia::InputInjecter injecter(dispatcher, mt::fake_shared(repository));
+
+    std::shared_ptr<mi::InputChannel const> stub_channel = std::make_shared<mtd::StubInputChannel>();
+
+    EXPECT_CALL(repository, handle_for_channel(stub_channel))
+        .Times(1)
+        .WillOnce(Return(droidinput::sp<droidinput::InputWindowHandle>()));
+
+    EXPECT_THROW({
+            // We can't inject input to unregistered channels
+            MirEvent ev;
+            memset(&ev, 0, sizeof(MirEvent));
+
+            injecter.inject_input(stub_channel, ev);
+    }, std::logic_error);
+}
+
+TEST(AndroidInputInjecterSetup, inject_input_behavior)
+{
+    using namespace ::testing;
+
+    std::shared_ptr<mi::InputChannel const> stub_channel = std::make_shared<mtd::StubInputChannel>();
+    mtd::MockWindowHandleRepository repository;
+
+    droidinput::sp<mtd::MockInputDispatcher> dispatcher = new mtd::MockInputDispatcher;
+    droidinput::sp<droidinput::InputWindowHandle> stub_window_handle = new mtd::StubWindowHandle;
+    
+    EXPECT_CALL(*dispatcher, injectEventToWindow(stub_window_handle, _))
+        .Times(1);
+    EXPECT_CALL(repository, handle_for_channel(stub_channel))
+        .Times(1)
+        .WillOnce(Return(stub_window_handle));
+    mia::InputInjecter injecter(dispatcher, mt::fake_shared(repository));
+
+    MirEvent ev;
+
+    memset(&ev, 0, sizeof(MirEvent));    
+    injecter.inject_input(stub_channel, ev);
+}

=== modified file 'tests/unit-tests/input/android/test_android_input_lexicon.cpp'
--- tests/unit-tests/input/android/test_android_input_lexicon.cpp	2013-08-28 03:41:48 +0000
+++ tests/unit-tests/input/android/test_android_input_lexicon.cpp	2013-10-01 22:23:19 +0000
@@ -27,6 +27,7 @@
 namespace mi = mir::input;
 namespace mia = mir::input::android;
 
+// Translate key events from android::KeyEvent to MirEvent
 TEST(AndroidInputLexicon, translates_key_events)
 {
     using namespace ::testing;
@@ -71,6 +72,54 @@
     delete android_key_ev;
 }
 
+// Translate MirEvent to android::KeyEvent
+TEST(AndroidInputLexicon, translates_key_events_in_reverse)
+{
+    using namespace ::testing;
+
+    const int32_t device_id = 1;
+    const int32_t source_id = 2;
+    const int32_t action = 3;
+    const int32_t flags = 4;
+    const int32_t key_code = 5;
+    const int32_t scan_code = 6;
+    const int32_t meta_state = 7;
+    const int32_t repeat_count = 8;
+    const nsecs_t down_time = 9;
+    const nsecs_t event_time = 10;
+    
+    MirEvent mir_ev;
+    mir_ev.type = mir_event_type_key;
+    mir_ev.key.device_id = device_id;
+    mir_ev.key.source_id = source_id;
+    mir_ev.key.action = static_cast<MirKeyAction>(action);
+    mir_ev.key.flags = static_cast<MirKeyFlag>(flags);
+    mir_ev.key.key_code = key_code;
+    mir_ev.key.scan_code = scan_code;
+    mir_ev.key.modifiers = meta_state;
+    mir_ev.key.repeat_count = repeat_count;
+    mir_ev.key.down_time = down_time;
+    mir_ev.key.event_time = event_time;
+
+    droidinput::InputEvent *aev;
+    mia::Lexicon::translate(mir_ev, &aev);
+    auto android_key_ev = dynamic_cast<droidinput::KeyEvent*>(aev);
+
+    EXPECT_EQ(device_id, android_key_ev->getDeviceId());
+    EXPECT_EQ(source_id, android_key_ev->getSource());
+    EXPECT_EQ(action, android_key_ev->getAction());
+    EXPECT_EQ(flags, android_key_ev->getFlags());
+    EXPECT_EQ(meta_state, android_key_ev->getMetaState());
+    EXPECT_EQ(AINPUT_EVENT_TYPE_KEY, android_key_ev->getType());
+    EXPECT_EQ(key_code, android_key_ev->getKeyCode());
+    EXPECT_EQ(scan_code, android_key_ev->getScanCode());
+    EXPECT_EQ(repeat_count, android_key_ev->getRepeatCount());
+    EXPECT_EQ(down_time, android_key_ev->getDownTime());
+    EXPECT_EQ(event_time, android_key_ev->getEventTime());
+
+    delete android_key_ev;
+}
+
 TEST(AndroidInputLexicon, translates_single_pointer_motion_events)
 {
     using namespace ::testing;
@@ -160,10 +209,110 @@
     EXPECT_EQ(mir_pointer_coords->pressure, pressure);
     EXPECT_EQ(mir_pointer_coords->orientation, orientation);
 
-
     delete android_motion_ev;
 }
 
+TEST(AndroidInputLexicon, translates_single_pointer_motion_events_in_reverse)
+{
+    using namespace ::testing;
+
+    // Common event properties
+    const int32_t device_id = 1;
+    const int32_t source_id = 2;
+    const int32_t action = 3;
+    const int32_t flags = 4;
+    const int32_t edge_flags = 5;
+    const int32_t meta_state = 6;
+    const int32_t button_state = 7;
+    const float x_offset = 8;
+    const float y_offset = 9;
+    const float x_precision = 10;
+    const float y_precision = 11;
+    const nsecs_t down_time = 12;
+    const nsecs_t event_time = 13;
+    const size_t pointer_count = 1;
+
+    // Set up the MirEvent for translation
+    // General event properties
+    MirEvent mir_ev;
+    auto mmev = &mir_ev.motion;
+    mir_ev.type = mir_event_type_motion;
+    // General motion event properties
+    mmev->device_id = device_id;
+    mmev->source_id = source_id;
+    mmev->action = action;
+    mmev->flags = static_cast<MirMotionFlag>(flags);
+    mmev->edge_flags = edge_flags;
+    mmev->modifiers = meta_state;
+    mmev->button_state = static_cast<MirMotionButton>(button_state);
+    mmev->down_time = down_time;
+    mmev->event_time = event_time;
+    mmev->x_offset = x_offset;
+    mmev->y_offset = y_offset;
+    mmev->x_precision = x_precision;
+    mmev->y_precision = y_precision;
+    mmev->pointer_count = pointer_count;
+
+    // Pointer specific properties
+    const int pointer_id = 1;
+    const float x_axis = 100.0;
+    const float y_axis = 200.0;
+    const float touch_minor = 300.0;
+    const float touch_major = 400.0;
+    const float size = 500.0;
+    const float pressure = 600.0;
+    const float orientation = 700.0;
+
+    auto coords = &mmev->pointer_coordinates[0];
+    coords->id = pointer_id;
+    coords->x = x_axis;
+    coords->y = y_axis;
+    coords->raw_x = x_axis;
+    coords->raw_y = y_axis;
+    coords->touch_minor = touch_minor;
+    coords->touch_major = touch_major;
+    coords->size = size;
+    coords->pressure = pressure;
+    coords->orientation = orientation;
+
+    droidinput::InputEvent *android_ev;
+    mia::Lexicon::translate(mir_ev, &android_ev);
+
+    // Verify the produced android event
+    // General event properties
+    EXPECT_EQ(AINPUT_EVENT_TYPE_MOTION, android_ev->getType());
+    // Motion event properties
+    auto android_mev = static_cast<droidinput::MotionEvent*>(android_ev);
+    EXPECT_EQ(device_id, android_mev->getDeviceId());
+    EXPECT_EQ(source_id, android_mev->getSource());
+    EXPECT_EQ(action, android_mev->getAction());
+    EXPECT_EQ(flags, android_mev->getFlags());
+    EXPECT_EQ(edge_flags, android_mev->getEdgeFlags());
+    EXPECT_EQ(meta_state, android_mev->getMetaState());
+    EXPECT_EQ(button_state, android_mev->getButtonState());
+    EXPECT_EQ(down_time, android_mev->getDownTime());
+    EXPECT_EQ(event_time, android_mev->getEventTime());
+    EXPECT_EQ(x_offset, android_mev->getXOffset());
+    EXPECT_EQ(y_offset, android_mev->getYOffset());
+    EXPECT_EQ(x_precision, android_mev->getXPrecision());
+    EXPECT_EQ(y_precision, android_mev->getYPrecision());
+    EXPECT_EQ(pointer_count, android_mev->getPointerCount());
+
+    // Pointer properties and coordinates
+    auto a_pp = android_mev->getPointerProperties(0);
+    auto a_pc = android_mev->getRawPointerCoords(0);
+    EXPECT_EQ(pointer_id, a_pp->id);
+    EXPECT_EQ(x_axis, a_pc->getAxisValue(AMOTION_EVENT_AXIS_X));
+    EXPECT_EQ(y_axis, a_pc->getAxisValue(AMOTION_EVENT_AXIS_Y));
+    EXPECT_EQ(touch_major, a_pc->getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR));
+    EXPECT_EQ(touch_minor, a_pc->getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR));
+    EXPECT_EQ(size, a_pc->getAxisValue(AMOTION_EVENT_AXIS_SIZE));
+    EXPECT_EQ(pressure, a_pc->getAxisValue(AMOTION_EVENT_AXIS_PRESSURE));
+    EXPECT_EQ(orientation, a_pc->getAxisValue(AMOTION_EVENT_AXIS_ORIENTATION));
+
+    delete android_ev;
+}
+
 TEST(AndroidInputLexicon, translates_multi_pointer_motion_events)
 {
     using namespace ::testing;