Merge lp:~dandrader/mir/mergeFakeInputReaders into lp:mir

[Daniel d'Andrada]

android-input - Merge the two existing FakeEventHub implementations

-Enables the FakeEventHub from tests/unit-tests/android_input/input_reader.cpp
 to be used elsewhere
-No need to keep two distinct implementations.
-Reduces confusion in the test code base.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:1096
http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-ci/63/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-saucy-i386-build/2191
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-saucy-amd64-build/2076
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-saucy-amd64-ci/63
        deb: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-saucy-amd64-ci/63/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins:8080/job/mir-team-mir-development-branch-ci/63/rebuild

review: Approve (continuous-integration)

[Daniel van Vugt (vanvugt)]

I thought all 3rd party code had to live under 3rd_party/ ?

Seems like we're not doing that any more. e.g. tests/mir_test_doubles/fake_event_hub.cpp

review: Needs Information

[Daniel d'Andrada (dandrader)]

> I thought all 3rd party code had to live under 3rd_party/ ?
>
> Seems like we're not doing that any more. e.g.
> tests/mir_test_doubles/fake_event_hub.cpp

So what directory structure you suggest for those tests and fake implementations?

Bear in mind that I'm preparing the ground for my modifications to android-input, so it won't be strictly 3rd party.

[Daniel van Vugt (vanvugt)]

I don't know. I'm not sure if it's worth blocking on yet... Unless this is the first time we've put 3rd party code outside of 3rd_party. Maybe racarr had a plan in mind?

[Alan Griffiths (alan-griffiths)]

I think we need a discussion about migrating this code into our codebase. We obviously relax our rules for style in 3rd_party, but under include, src or test it ought to conform.

237 +using mir::input::android::FakeEventHub;
238 +using namespace android;

Nit, but project style is to use namespace aliases in preference to bringing names into global namespace.

~~~~

242 + const nsecs_t ARBITRARY_TIME = 1234;

UPPERCASE is reserved for macros - http://unity.ubuntu.com/mir/cppguide/index.html?showone=Constant_Names#Constant_Names

review: Needs Information

[Daniel d'Andrada (dandrader)]

> 237 +using mir::input::android::FakeEventHub;
> 238 +using namespace android;
>
> Nit, but project style is to use namespace aliases in preference to bringing
> names into global namespace.

But what's the advantage of prepending everything with namespace acronyms? IMHO this is an unnecessary clutter/boilerplate that just hampers readability.

In this specific case we would have:
void mia::FakeEventHub::foo()
As opposed to simply:
void FakeEventHub::foo()

What good is that "mia::" prefix bringing us? We are inside fake_event_hub.cpp and we refer to no other FakeEventHub from any other namespace. Actually no other FakeEventHub even exist in our code base.

It makes all the sense in the world to avoid the "using foo;" in header files as it unwittingly contaminates anyone that includes it but what's the point of avoiding it in .cpp files?

You use namespaces to avoid naming clashes. But if there are no possible clashes to be had, what's the point? It's just clutter and the "using ..." declaration was invented to solve that.

Can we have a discussion on changing the project style regarding that?

[Daniel d'Andrada (dandrader)]

> 242 + const nsecs_t ARBITRARY_TIME = 1234;
>
> UPPERCASE is reserved for macros - http://unity.ubuntu.com/mir/cppguide/index.
> html?showone=Constant_Names#Constant_Names

Done.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:1097
http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-ci/72/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-saucy-i386-build/2201
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-saucy-amd64-build/2086
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-saucy-amd64-ci/72
        deb: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-saucy-amd64-ci/72/artifact/work/output/*zip*/output.zip

Click here to trigger a rebuild:
http://s-jenkins:8080/job/mir-team-mir-development-branch-ci/72/rebuild

review: Approve (continuous-integration)

[Daniel van Vugt (vanvugt)]

I agree with Daniel. Namespace aliases just hamper readability. I prefer carefully placed "using namespace". There's less syntactical coupling and it's more readable. We have already begun landing code of that style (my own).

[Daniel d'Andrada (dandrader)]

> I don't know. I'm not sure if it's worth blocking on yet... Unless this is the
> first time we've put 3rd party code outside of 3rd_party.

There's tests/unit-tests/android_input/input_reader.cpp already

[Alan Griffiths (alan-griffiths)]

Better landed and deal with any remaining issues later

review: Approve

[Robert Carr (robertcarr)]

Sorry! Looked at this yesterday afternoon but forgot to comment

LGTM

review: Approve

=== modified file 'include/test/mir_test/fake_event_hub.h'
--- include/test/mir_test/fake_event_hub.h	2013-05-13 09:35:44 +0000
+++ include/test/mir_test/fake_event_hub.h	2013-10-02 11:08:26 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2012 Canonical Ltd.
+ * Copyright © 2012-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,
@@ -13,7 +13,8 @@
  * 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]
+ * Authored by: Robert Carr <[e-mail]>
+ *              Daniel d'Andrada <[e-mail]>
  */
 
 #ifndef MIR_TEST_FAKE_EVENT_HUB_H_
@@ -43,6 +44,29 @@
 class FakeEventHub : public droidinput::EventHubInterface
 {
 public:
+    struct KeyInfo {
+        int32_t keyCode;
+        uint32_t flags;
+    };
+
+    typedef struct FakeDevice
+    {
+        uint32_t classes;
+        droidinput::InputDeviceIdentifier identifier;
+        droidinput::PropertyMap configuration;
+        droidinput::KeyedVector<int, droidinput::RawAbsoluteAxisInfo> absoluteAxes;
+        droidinput::KeyedVector<int, bool> relativeAxes;
+        droidinput::KeyedVector<int32_t, int32_t> keyCodeStates;
+        droidinput::KeyedVector<int32_t, int32_t> scanCodeStates;
+        droidinput::KeyedVector<int32_t, int32_t> switchStates;
+        droidinput::KeyedVector<int32_t, int32_t> absoluteAxisValue;
+        droidinput::KeyedVector<int32_t, KeyInfo> keysByScanCode;
+        droidinput::KeyedVector<int32_t, KeyInfo> keysByUsageCode;
+        droidinput::KeyedVector<int32_t, bool> leds;
+        droidinput::Vector<droidinput::VirtualKeyDefinition> virtualKeys;
+        std::map<int, bool> input_properties;
+    } FakeDevice;
+
     FakeEventHub();
     virtual ~FakeEventHub();
 
@@ -52,62 +76,41 @@
     // cursor device in the android input stack.
     static const int BuiltInCursorID = droidinput::BUILT_IN_KEYBOARD_ID + 1;
 
-    virtual uint32_t getDeviceClasses(int32_t deviceId) const;
-
-    virtual droidinput::InputDeviceIdentifier getDeviceIdentifier(int32_t deviceId) const;
-
-    virtual void getConfiguration(int32_t deviceId,
-            droidinput::PropertyMap* outConfiguration) const;
-
-    virtual droidinput::status_t getAbsoluteAxisInfo(int32_t deviceId, int axis,
-            droidinput::RawAbsoluteAxisInfo* outAxisInfo) const;
-
-    virtual bool hasRelativeAxis(int32_t deviceId, int axis) const;
-
-    virtual bool hasInputProperty(int32_t deviceId, int property) const;
-
-    virtual droidinput::status_t mapKey(int32_t deviceId, int32_t scanCode, int32_t usageCode,
-            int32_t* outKeycode, uint32_t* outFlags) const;
-
-    virtual droidinput::status_t mapAxis(int32_t deviceId, int32_t scanCode,
-            droidinput::AxisInfo* outAxisInfo) const;
-
-    virtual void setExcludedDevices(const droidinput::Vector<droidinput::String8>& devices);
-
-    virtual size_t getEvents(int timeoutMillis, droidinput::RawEvent* buffer,
-            size_t bufferSize);
-
-    virtual int32_t getScanCodeState(int32_t deviceId, int32_t scanCode) const;
-    virtual int32_t getKeyCodeState(int32_t deviceId, int32_t keyCode) const;
-    virtual int32_t getSwitchState(int32_t deviceId, int32_t sw) const;
-    virtual droidinput::status_t getAbsoluteAxisValue(int32_t deviceId, int32_t axis,
-                                          int32_t* outValue) const;
-
-    virtual bool markSupportedKeyCodes(int32_t deviceId, size_t numCodes,
-            const int32_t* keyCodes, uint8_t* outFlags) const;
-
-    virtual bool hasScanCode(int32_t deviceId, int32_t scanCode) const;
-    virtual bool hasLed(int32_t deviceId, int32_t led) const;
-    virtual void setLedState(int32_t deviceId, int32_t led, bool on);
-
-    virtual void getVirtualKeyDefinitions(int32_t deviceId,
-            droidinput::Vector<droidinput::VirtualKeyDefinition>& outVirtualKeys) const;
-
-    virtual droidinput::sp<droidinput::KeyCharacterMap> getKeyCharacterMap(int32_t deviceId) const;
-    virtual bool setKeyboardLayoutOverlay(int32_t deviceId,
-                                          const droidinput::sp<droidinput::KeyCharacterMap>& map);
-
-    virtual void vibrate(int32_t deviceId, nsecs_t duration);
-    virtual void cancelVibrate(int32_t deviceId);
-
-    virtual void requestReopenDevices();
-
-    virtual void wake();
-
-    virtual void dump(droidinput::String8& dump);
-
-    virtual void monitor();
-    virtual void flush();
+    // From EventHubInterface
+    uint32_t getDeviceClasses(int32_t deviceId) const override;
+    droidinput::InputDeviceIdentifier getDeviceIdentifier(int32_t deviceId) const override;
+    void getConfiguration(int32_t deviceId, droidinput::PropertyMap* outConfiguration) const override;
+    droidinput::status_t getAbsoluteAxisInfo(int32_t deviceId, int axis,
+                                  droidinput::RawAbsoluteAxisInfo* outAxisInfo) const override;
+    bool hasRelativeAxis(int32_t deviceId, int axis) const override;
+    bool hasInputProperty(int32_t deviceId, int property) const override;
+    droidinput::status_t mapKey(int32_t deviceId, int32_t scanCode, int32_t usageCode, int32_t* outKeycode,
+            uint32_t* outFlags) const override;
+    droidinput::status_t mapAxis(int32_t deviceId, int32_t scanCode,
+            droidinput::AxisInfo* outAxisInfo) const override;
+    void setExcludedDevices(const droidinput::Vector<droidinput::String8>& devices) override;
+    size_t getEvents(int timeoutMillis, droidinput::RawEvent* buffer, size_t bufferSize) override;
+    int32_t getScanCodeState(int32_t deviceId, int32_t scanCode) const override;
+    int32_t getKeyCodeState(int32_t deviceId, int32_t keyCode) const override;
+    int32_t getSwitchState(int32_t deviceId, int32_t sw) const override;
+    droidinput::status_t getAbsoluteAxisValue(int32_t deviceId, int32_t axis, int32_t* outValue) const override;
+    bool markSupportedKeyCodes(int32_t deviceId, size_t numCodes, const int32_t* keyCodes,
+            uint8_t* outFlags) const override;
+    bool hasScanCode(int32_t deviceId, int32_t scanCode) const override;
+    bool hasLed(int32_t deviceId, int32_t led) const override;
+    void setLedState(int32_t deviceId, int32_t led, bool on) override;
+    void getVirtualKeyDefinitions(int32_t deviceId,
+            droidinput::Vector<droidinput::VirtualKeyDefinition>& outVirtualKeys) const override;
+    droidinput::sp<droidinput::KeyCharacterMap> getKeyCharacterMap(int32_t deviceId) const override;
+    bool setKeyboardLayoutOverlay(int32_t deviceId,
+            const droidinput::sp<droidinput::KeyCharacterMap>& map) override;
+    void vibrate(int32_t deviceId, nsecs_t duration) override;
+    void cancelVibrate(int32_t deviceId) override;
+    void requestReopenDevices() override;
+    void wake() override;
+    void dump(droidinput::String8& dump) override;
+    void monitor() override;
+    void flush() override;
 
     void synthesize_builtin_keyboard_added();
     void synthesize_builtin_cursor_added();
@@ -116,22 +119,43 @@
     void synthesize_event(const synthesis::KeyParameters &parameters);
     void synthesize_event(const synthesis::ButtonParameters &parameters);
     void synthesize_event(const synthesis::MotionParameters &parameters);
+    void synthesize_event(nsecs_t when, int32_t deviceId, int32_t type, int32_t code, int32_t value);
+
+    void addDevice(int32_t deviceId, const std::string& name, uint32_t classes);
+    void removeDevice(int32_t deviceId);
+    void finishDeviceScan();
+    void addConfigurationProperty(int32_t device_id, const std::string& key, const std::string& value);
+    void addConfigurationMap(int32_t device_id, const droidinput::PropertyMap* configuration);
+    void addAbsoluteAxis(int32_t device_id, int axis, int32_t minValue, int32_t maxValue,
+                           int flat, int fuzz, int resolution = 0);
+    void addRelativeAxis(int32_t device_id, int32_t axis);
+    void setKeyCodeState(int32_t deviceId, int32_t keyCode, int32_t state);
+    void setScanCodeState(int32_t deviceId, int32_t scanCode, int32_t state);
+    void setSwitchState(int32_t deviceId, int32_t switchCode, int32_t state);
+    void setAbsoluteAxisValue(int32_t deviceId, int32_t axis, int32_t value);
+    void addKey(int32_t deviceId, int32_t scanCode, int32_t usageCode, int32_t keyCode, uint32_t flags);
+    void addLed(int32_t deviceId, int32_t led, bool initialState);
+    bool getLedState(int32_t deviceId, int32_t led);
+    droidinput::Vector<std::string>& getExcludedDevices();
+    void addVirtualKeyDefinition(int32_t deviceId, const droidinput::VirtualKeyDefinition& definition);
+    const FakeDevice* getDevice(int32_t deviceId) const;
+    FakeDevice* getDevice(int32_t deviceId);
+    size_t eventsQueueSize() const;
 
     // list of RawEvents available for consumption via getEvents
     std::mutex guard;
     std::list<droidinput::RawEvent> events_available;
 
-    typedef struct FakeDevice
-    {
-        uint32_t classes;
-        droidinput::InputDeviceIdentifier identifier;
-        std::map<int, bool> input_properties;
-    } FakeDevice;
 
     std::map<int32_t, FakeDevice> device_from_id;
 
     droidinput::KeyMap keymap;
 
+    droidinput::Vector<droidinput::String8> excluded_devices;
+
+private:
+    const KeyInfo* getKey(const FakeDevice* device, int32_t scanCode, int32_t usageCode) const;
+
 };
 }
 }

=== modified file 'tests/mir_test_doubles/fake_event_hub.cpp'
--- tests/mir_test_doubles/fake_event_hub.cpp	2013-05-13 09:35:44 +0000
+++ tests/mir_test_doubles/fake_event_hub.cpp	2013-10-02 11:08:26 +0000
@@ -1,6 +1,25 @@
+/*
+ * Copyright (C) 2012-2013 Canonical Ltd.
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 #include "mir_test/fake_event_hub.h"
 
+// from android-input
 #include <androidfw/Keyboard.h>
+#include <std/Errors.h>
+
 #include <thread>
 #include <chrono>
 
@@ -17,19 +36,26 @@
 using droidinput::VirtualKeyDefinition;
 
 namespace mi = mir::input;
-namespace mia = mir::input::android;
 namespace mis = mir::input::synthesis;
 
-mia::FakeEventHub::FakeEventHub()
+using mir::input::android::FakeEventHub;
+using namespace android;
+
+namespace {
+    // An arbitrary time value.
+    const nsecs_t arbitrary_time = 1234;
+} // anonymous namespace
+
+FakeEventHub::FakeEventHub()
 {
     keymap.loadGenericMaps();
 }
 
-mia::FakeEventHub::~FakeEventHub()
+FakeEventHub::~FakeEventHub()
 {
 }
 
-uint32_t mia::FakeEventHub::getDeviceClasses(int32_t deviceId) const
+uint32_t FakeEventHub::getDeviceClasses(int32_t deviceId) const
 {
     if (deviceId == BuiltInKeyboardID)
     {
@@ -52,7 +78,7 @@
     }
 }
 
-InputDeviceIdentifier mia::FakeEventHub::getDeviceIdentifier(int32_t deviceId) const
+InputDeviceIdentifier FakeEventHub::getDeviceIdentifier(int32_t deviceId) const
 {
     auto fake_device_iterator = device_from_id.find(deviceId);
 
@@ -66,38 +92,51 @@
     }
 }
 
-void mia::FakeEventHub::getConfiguration(int32_t deviceId, PropertyMap* outConfiguration) const
+void FakeEventHub::getConfiguration(int32_t deviceId, PropertyMap* outConfiguration) const
 {
-    (void)deviceId;
-    (void)outConfiguration;
+    auto device_iterator = device_from_id.find(deviceId);
+    if (device_iterator != device_from_id.end())
+    {
+        *outConfiguration = device_iterator->second.configuration;
+    }
 }
 
-status_t mia::FakeEventHub::getAbsoluteAxisInfo(int32_t deviceId, int axis,
+status_t FakeEventHub::getAbsoluteAxisInfo(int32_t deviceId, int axis,
         RawAbsoluteAxisInfo* outAxisInfo) const
 {
-    (void)deviceId;
-    (void)axis;
-    (void)outAxisInfo;
+    outAxisInfo->clear();
+    const FakeDevice* device = getDevice(deviceId);
+    if (device)
+    {
+        ssize_t index = device->absoluteAxes.indexOfKey(axis);
+        if (index >= 0)
+        {
+            *outAxisInfo = device->absoluteAxes.valueAt(index);
+            return OK;
+        }
+    }
     return -1;
 }
 
-bool mia::FakeEventHub::hasRelativeAxis(int32_t deviceId, int axis) const
+bool FakeEventHub::hasRelativeAxis(int32_t deviceId, int axis) const
 {
-    (void)deviceId;
-    (void)axis;
+    const FakeDevice* device = getDevice(deviceId);
+    if (device)
+    {
+        return device->relativeAxes.indexOfKey(axis) >= 0;
+    }
     return false;
 }
 
-bool mia::FakeEventHub::hasInputProperty(int32_t deviceId, int property) const
+bool FakeEventHub::hasInputProperty(int32_t deviceId, int property) const
 {
-    auto fake_device_iterator = device_from_id.find(deviceId);
+    const FakeDevice* device = getDevice(deviceId);
 
-    if (fake_device_iterator != device_from_id.end())
+    if (device)
     {
-        auto property_iterator =
-            fake_device_iterator->second.input_properties.find(property);
+        auto property_iterator = device->input_properties.find(property);
 
-        if (property_iterator != fake_device_iterator->second.input_properties.end())
+        if (property_iterator != device->input_properties.end())
         {
             return property_iterator->second;
         }
@@ -112,30 +151,71 @@
     }
 }
 
-status_t mia::FakeEventHub::mapKey(int32_t deviceId, int32_t scanCode, int32_t usageCode,
+status_t FakeEventHub::mapKey(int32_t deviceId, int32_t scanCode, int32_t usageCode,
                               int32_t* outKeycode, uint32_t* outFlags) const
 {
-    (void)deviceId;
-    (void)usageCode;
-    keymap.keyLayoutMap->mapKey(scanCode, usageCode, outKeycode, outFlags);
-    return droidinput::OK;
-}
-
-status_t mia::FakeEventHub::mapAxis(int32_t deviceId, int32_t scanCode,
+    const FakeDevice* device = getDevice(deviceId);
+    if (device)
+    {
+        const KeyInfo* key = getKey(device, scanCode, usageCode);
+        if (key)
+        {
+            if (outKeycode)
+            {
+                *outKeycode = key->keyCode;
+            }
+            if (outFlags)
+            {
+                *outFlags = key->flags;
+            }
+            return OK;
+        }
+        return NAME_NOT_FOUND;
+    }
+    else
+    {
+        keymap.keyLayoutMap->mapKey(scanCode, usageCode, outKeycode, outFlags);
+        return droidinput::OK;
+    }
+}
+
+const FakeEventHub::KeyInfo* FakeEventHub::getKey(const FakeDevice* device,
+                                                  int32_t scanCode, int32_t usageCode) const
+{
+    if (usageCode)
+    {
+        ssize_t index = device->keysByUsageCode.indexOfKey(usageCode);
+        if (index >= 0)
+        {
+            return &device->keysByUsageCode.valueAt(index);
+        }
+    }
+    if (scanCode)
+    {
+        ssize_t index = device->keysByScanCode.indexOfKey(scanCode);
+        if (index >= 0)
+        {
+            return &device->keysByScanCode.valueAt(index);
+        }
+    }
+    return NULL;
+}
+
+status_t FakeEventHub::mapAxis(int32_t deviceId, int32_t scanCode,
                                AxisInfo* outAxisInfo) const
 {
     (void)deviceId;
     (void)scanCode;
     (void)outAxisInfo;
-    return -1;
+    return NAME_NOT_FOUND;
 }
 
-void mia::FakeEventHub::setExcludedDevices(const Vector<String8>& devices)
+void FakeEventHub::setExcludedDevices(const Vector<String8>& devices)
 {
-    (void)devices;
+    excluded_devices = devices;
 }
 
-size_t mia::FakeEventHub::getEvents(int timeoutMillis, RawEvent* buffer, size_t bufferSize)
+size_t FakeEventHub::getEvents(int timeoutMillis, RawEvent* buffer, size_t bufferSize)
 {
     size_t num_events_obtained = 0;
     (void) timeoutMillis;
@@ -155,82 +235,145 @@
     return num_events_obtained;
 }
 
-int32_t mia::FakeEventHub::getScanCodeState(int32_t deviceId, int32_t scanCode) const
-{
-    (void)deviceId;
-    (void)scanCode;
-    return AKEY_STATE_UNKNOWN;
-}
-
-int32_t mia::FakeEventHub::getKeyCodeState(int32_t deviceId, int32_t keyCode) const
-{
-    (void)deviceId;
-    (void)keyCode;
-    return AKEY_STATE_UNKNOWN;
-}
-
-int32_t mia::FakeEventHub::getSwitchState(int32_t deviceId, int32_t sw) const
-{
-    (void)deviceId;
-    (void)sw;
-    return AKEY_STATE_UNKNOWN;
-}
-
-status_t mia::FakeEventHub::getAbsoluteAxisValue(int32_t deviceId, int32_t axis,
+int32_t FakeEventHub::getScanCodeState(int32_t deviceId, int32_t scanCode) const
+{
+    const FakeDevice* device = getDevice(deviceId);
+    if (device)
+    {
+        ssize_t index = device->scanCodeStates.indexOfKey(scanCode);
+        if (index >= 0)
+        {
+            return device->scanCodeStates.valueAt(index);
+        }
+    }
+    return AKEY_STATE_UNKNOWN;
+}
+
+int32_t FakeEventHub::getKeyCodeState(int32_t deviceId, int32_t keyCode) const
+{
+    const FakeDevice* device = getDevice(deviceId);
+    if (device)
+    {
+        ssize_t index = device->keyCodeStates.indexOfKey(keyCode);
+        if (index >= 0)
+        {
+            return device->keyCodeStates.valueAt(index);
+        }
+    }
+    return AKEY_STATE_UNKNOWN;
+}
+
+int32_t FakeEventHub::getSwitchState(int32_t deviceId, int32_t sw) const
+{
+    const FakeDevice* device = getDevice(deviceId);
+    if (device)
+    {
+        ssize_t index = device->switchStates.indexOfKey(sw);
+        if (index >= 0)
+        {
+            return device->switchStates.valueAt(index);
+        }
+    }
+    return AKEY_STATE_UNKNOWN;
+}
+
+status_t FakeEventHub::getAbsoluteAxisValue(int32_t deviceId, int32_t axis,
         int32_t* outValue) const
 {
-    (void)deviceId;
-    (void)axis;
-    (void)outValue;
+    const FakeDevice* device = getDevice(deviceId);
+    if (device)
+    {
+        ssize_t index = device->absoluteAxisValue.indexOfKey(axis);
+        if (index >= 0)
+        {
+            *outValue = device->absoluteAxisValue.valueAt(index);
+            return OK;
+        }
+    }
+    *outValue = 0;
     return -1;
 }
 
-bool mia::FakeEventHub::markSupportedKeyCodes(int32_t deviceId, size_t numCodes,
+bool FakeEventHub::markSupportedKeyCodes(int32_t deviceId, size_t numCodes,
         const int32_t* keyCodes,
         uint8_t* outFlags) const
 {
-    (void)deviceId;
-    (void)numCodes;
-    (void)keyCodes;
-    (void)outFlags;
-    return true;
-}
-
-bool mia::FakeEventHub::hasScanCode(int32_t deviceId, int32_t scanCode) const
-{
-    (void)deviceId;
-    (void)scanCode;
-    return false;
-}
-
-bool mia::FakeEventHub::hasLed(int32_t deviceId, int32_t led) const
-{
-    (void)deviceId;
-    (void)led;
-    return false;
-}
-
-void mia::FakeEventHub::setLedState(int32_t deviceId, int32_t led, bool on)
-{
-    (void)deviceId;
-    (void)led;
-    (void)on;
-}
-
-void mia::FakeEventHub::getVirtualKeyDefinitions(int32_t deviceId,
+    bool result = false;
+    const FakeDevice* device = getDevice(deviceId);
+    if (device)
+    {
+        for (size_t i = 0; i < numCodes; i++)
+        {
+            for (size_t j = 0; j < device->keysByScanCode.size(); j++)
+            {
+                if (keyCodes[i] == device->keysByScanCode.valueAt(j).keyCode)
+                {
+                    outFlags[i] = 1;
+                    result = true;
+                }
+            }
+            for (size_t j = 0; j < device->keysByUsageCode.size(); j++)
+            {
+                if (keyCodes[i] == device->keysByUsageCode.valueAt(j).keyCode)
+                {
+                    outFlags[i] = 1;
+                    result = true;
+                }
+            }
+        }
+    }
+    return result;
+}
+
+bool FakeEventHub::hasScanCode(int32_t deviceId, int32_t scanCode) const
+{
+    const FakeDevice* device = getDevice(deviceId);
+    if (device)
+    {
+        ssize_t index = device->keysByScanCode.indexOfKey(scanCode);
+        return index >= 0;
+    }
+    return false;
+}
+
+bool FakeEventHub::hasLed(int32_t deviceId, int32_t led) const
+{
+    const FakeDevice* device = getDevice(deviceId);
+    return device && device->leds.indexOfKey(led) >= 0;
+}
+
+void FakeEventHub::setLedState(int32_t deviceId, int32_t led, bool on)
+{
+    FakeDevice* device = getDevice(deviceId);
+    if (device)
+    {
+        ssize_t index = device->leds.indexOfKey(led);
+        if (index >= 0)
+        {
+            device->leds.replaceValueAt(led, on);
+        }
+    }
+}
+
+void FakeEventHub::getVirtualKeyDefinitions(int32_t deviceId,
         Vector<VirtualKeyDefinition>& outVirtualKeys) const
 {
-    (void)deviceId;
-    (void)outVirtualKeys;
+    outVirtualKeys.clear();
+
+    const FakeDevice* device = getDevice(deviceId);
+    if (device)
+    {
+        outVirtualKeys.appendVector(device->virtualKeys);
+    }
 }
 
-sp<KeyCharacterMap> mia::FakeEventHub::getKeyCharacterMap(int32_t deviceId) const
+sp<KeyCharacterMap> FakeEventHub::getKeyCharacterMap(int32_t deviceId) const
 {
     (void)deviceId;
     return sp<KeyCharacterMap>();
 }
 
-bool mia::FakeEventHub::setKeyboardLayoutOverlay(int32_t deviceId,
+bool FakeEventHub::setKeyboardLayoutOverlay(int32_t deviceId,
         const sp<KeyCharacterMap>& map)
 {
     (void)deviceId;
@@ -238,39 +381,39 @@
     return true;
 }
 
-void mia::FakeEventHub::vibrate(int32_t deviceId, nsecs_t duration)
+void FakeEventHub::vibrate(int32_t deviceId, nsecs_t duration)
 {
     (void)deviceId;
     (void)duration;
 }
 
-void mia::FakeEventHub::cancelVibrate(int32_t deviceId)
+void FakeEventHub::cancelVibrate(int32_t deviceId)
 {
     (void)deviceId;
 }
 
-void mia::FakeEventHub::requestReopenDevices()
-{
-}
-
-void mia::FakeEventHub::wake()
-{
-}
-
-void mia::FakeEventHub::dump(droidinput::String8& dump)
+void FakeEventHub::requestReopenDevices()
+{
+}
+
+void FakeEventHub::wake()
+{
+}
+
+void FakeEventHub::dump(droidinput::String8& dump)
 {
     (void)dump;
 }
 
-void mia::FakeEventHub::monitor()
-{
-}
-
-void mia::FakeEventHub::flush()
-{
-}
-
-void mia::FakeEventHub::synthesize_builtin_keyboard_added()
+void FakeEventHub::monitor()
+{
+}
+
+void FakeEventHub::flush()
+{
+}
+
+void FakeEventHub::synthesize_builtin_keyboard_added()
 {
     RawEvent event;
     event.when = 0;
@@ -281,7 +424,7 @@
     events_available.push_back(event);
 }
 
-void mia::FakeEventHub::synthesize_builtin_cursor_added()
+void FakeEventHub::synthesize_builtin_cursor_added()
 {
     RawEvent event;
     event.when = 0;
@@ -292,7 +435,7 @@
     events_available.push_back(event);
 }
 
-void mia::FakeEventHub::synthesize_device_scan_complete()
+void FakeEventHub::synthesize_device_scan_complete()
 {
     RawEvent event;
     event.when = 0;
@@ -302,7 +445,7 @@
     events_available.push_back(event);
 }
 
-void mia::FakeEventHub::synthesize_event(const mis::KeyParameters &parameters)
+void FakeEventHub::synthesize_event(const mis::KeyParameters &parameters)
 {
     RawEvent event;
     event.when = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
@@ -323,7 +466,7 @@
     events_available.push_back(event);
 }
 
-void mia::FakeEventHub::synthesize_event(const mis::ButtonParameters &parameters)
+void FakeEventHub::synthesize_event(const mis::ButtonParameters &parameters)
 {
     RawEvent event;
     event.when = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
@@ -349,7 +492,7 @@
     events_available.push_back(event);
 }
 
-void mia::FakeEventHub::synthesize_event(const mis::MotionParameters &parameters)
+void FakeEventHub::synthesize_event(const mis::MotionParameters &parameters)
 {
     RawEvent event;
     event.when = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::system_clock::now().time_since_epoch()).count();
@@ -373,3 +516,175 @@
     event.code = SYN_REPORT;
     events_available.push_back(event);
 }
+
+void FakeEventHub::synthesize_event(nsecs_t when, int32_t device_id, int32_t type, int32_t code, int32_t value)
+{
+    RawEvent event;
+    event.when = when;
+    event.deviceId = device_id;
+    event.type = type;
+    event.code = code;
+    event.value = value;
+
+    {
+        std::lock_guard<std::mutex> lg(guard);
+        events_available.push_back(event);
+    }
+
+    if (type == EV_ABS)
+    {
+        setAbsoluteAxisValue(device_id, code, value);
+    }
+}
+
+void FakeEventHub::addDevice(int32_t deviceId, const std::string& name, uint32_t classes)
+{
+    FakeDevice device;
+    device.classes = classes;
+    device.identifier.name = name;
+    device_from_id.insert(std::pair<int32_t, FakeDevice>(deviceId, device));
+
+    synthesize_event(arbitrary_time, deviceId, EventHubInterface::DEVICE_ADDED, 0, 0);
+}
+
+void FakeEventHub::removeDevice(int32_t device_id)
+{
+    device_from_id.erase(device_id);
+
+    synthesize_event(arbitrary_time, device_id, EventHubInterface::DEVICE_REMOVED, 0, 0);
+}
+
+void FakeEventHub::finishDeviceScan()
+{
+    synthesize_event(arbitrary_time, 0, EventHubInterface::FINISHED_DEVICE_SCAN, 0, 0);
+}
+
+void FakeEventHub::addConfigurationProperty(int32_t device_id, const std::string& key, const std::string& value)
+{
+    FakeDevice& device = device_from_id.at(device_id);
+    device.configuration.addProperty(key, value);
+}
+
+void FakeEventHub::addConfigurationMap(int32_t device_id, const PropertyMap* configuration)
+{
+    FakeDevice& device = device_from_id.at(device_id);
+    device.configuration.addAll(configuration);
+}
+
+void FakeEventHub::addAbsoluteAxis(int32_t device_id, int axis,
+        int32_t minValue, int32_t maxValue, int flat, int fuzz, int resolution)
+{
+    FakeDevice& device = device_from_id.at(device_id);
+
+    RawAbsoluteAxisInfo info;
+    info.valid = true;
+    info.minValue = minValue;
+    info.maxValue = maxValue;
+    info.flat = flat;
+    info.fuzz = fuzz;
+    info.resolution = resolution;
+    device.absoluteAxes.add(axis, info);
+}
+
+void FakeEventHub::addRelativeAxis(int32_t device_id, int32_t axis)
+{
+    FakeDevice& device = device_from_id.at(device_id);
+    device.relativeAxes.add(axis, true);
+}
+
+void FakeEventHub::setKeyCodeState(int32_t deviceId, int32_t keyCode, int32_t state)
+{
+    FakeDevice& device = device_from_id.at(deviceId);
+    device.keyCodeStates.replaceValueFor(keyCode, state);
+}
+
+void FakeEventHub::setScanCodeState(int32_t deviceId, int32_t scanCode, int32_t state)
+{
+    FakeDevice& device = device_from_id.at(deviceId);
+    device.scanCodeStates.replaceValueFor(scanCode, state);
+}
+
+void FakeEventHub::setSwitchState(int32_t deviceId, int32_t switchCode, int32_t state)
+{
+    FakeDevice& device = device_from_id.at(deviceId);
+    device.switchStates.replaceValueFor(switchCode, state);
+}
+
+void FakeEventHub::setAbsoluteAxisValue(int32_t deviceId, int32_t axis, int32_t value)
+{
+    FakeDevice& device = device_from_id.at(deviceId);
+    device.absoluteAxisValue.replaceValueFor(axis, value);
+}
+
+void FakeEventHub::addKey(int32_t deviceId, int32_t scanCode, int32_t usageCode,
+                          int32_t keyCode, uint32_t flags)
+{
+    FakeDevice& device = device_from_id.at(deviceId);
+    KeyInfo info;
+    info.keyCode = keyCode;
+    info.flags = flags;
+    if (scanCode)
+    {
+        device.keysByScanCode.add(scanCode, info);
+    }
+    if (usageCode)
+    {
+        device.keysByUsageCode.add(usageCode, info);
+    }
+}
+
+void FakeEventHub::addLed(int32_t deviceId, int32_t led, bool initialState)
+{
+    FakeDevice& device = device_from_id.at(deviceId);
+    device.leds.add(led, initialState);
+}
+
+bool FakeEventHub::getLedState(int32_t deviceId, int32_t led)
+{
+    FakeDevice& device = device_from_id.at(deviceId);
+    return device.leds.valueFor(led);
+}
+
+Vector<std::string>& FakeEventHub::getExcludedDevices()
+{
+    return excluded_devices;
+}
+
+void FakeEventHub::addVirtualKeyDefinition(int32_t deviceId, const VirtualKeyDefinition& definition)
+{
+    FakeDevice& device = device_from_id.at(deviceId);
+    device.virtualKeys.push(definition);
+}
+
+FakeEventHub::FakeDevice* FakeEventHub::getDevice(int32_t deviceId)
+{
+    auto fake_device_iterator = device_from_id.find(deviceId);
+
+    if (fake_device_iterator != device_from_id.end())
+    {
+        return &(fake_device_iterator->second);
+    }
+    else
+    {
+        return nullptr;
+    }
+}
+
+const FakeEventHub::FakeDevice* FakeEventHub::getDevice(int32_t deviceId) const
+{
+    auto fake_device_iterator = device_from_id.find(deviceId);
+
+    if (fake_device_iterator != device_from_id.end())
+    {
+        return &(fake_device_iterator->second);
+    }
+    else
+    {
+        return nullptr;
+    }
+}
+
+size_t FakeEventHub::eventsQueueSize() const
+{
+    return events_available.size();
+}

=== modified file 'tests/unit-tests/android_input/input_reader.cpp'
--- tests/unit-tests/android_input/input_reader.cpp	2013-09-26 08:25:01 +0000
+++ tests/unit-tests/android_input/input_reader.cpp	2013-10-02 11:08:26 +0000
@@ -1,4 +1,5 @@
 /*
+ * Copyright (C) 2013 Canonical Ltd.
  * Copyright (C) 2010 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
@@ -25,10 +26,12 @@
 
 #include <mir/logging/logger.h>
 #include <mir/logging/input_report.h>
+#include <mir_test/fake_event_hub.h>
 
 namespace ml  = mir::logging;
 
 using std::string;
+using mir::input::android::FakeEventHub;
 
 namespace
 {
@@ -298,415 +301,6 @@
     }
 };
 
-
-// --- FakeEventHub ---
-
-class FakeEventHub : public EventHubInterface {
-    struct KeyInfo {
-        int32_t keyCode;
-        uint32_t flags;
-    };
-
-    struct Device {
-        InputDeviceIdentifier identifier;
-        uint32_t classes;
-        PropertyMap configuration;
-        KeyedVector<int, RawAbsoluteAxisInfo> absoluteAxes;
-        KeyedVector<int, bool> relativeAxes;
-        KeyedVector<int32_t, int32_t> keyCodeStates;
-        KeyedVector<int32_t, int32_t> scanCodeStates;
-        KeyedVector<int32_t, int32_t> switchStates;
-        KeyedVector<int32_t, int32_t> absoluteAxisValue;
-        KeyedVector<int32_t, KeyInfo> keysByScanCode;
-        KeyedVector<int32_t, KeyInfo> keysByUsageCode;
-        KeyedVector<int32_t, bool> leds;
-        Vector<VirtualKeyDefinition> virtualKeys;
-
-        Device(uint32_t classes) :
-                classes(classes) {
-        }
-    };
-
-    KeyedVector<int32_t, Device*> mDevices;
-    Vector<String8> mExcludedDevices;
-    List<RawEvent> mEvents;
-
-protected:
-    virtual ~FakeEventHub() {
-        for (size_t i = 0; i < mDevices.size(); i++) {
-            delete mDevices.valueAt(i);
-        }
-    }
-
-public:
-    FakeEventHub() { }
-
-    void addDevice(int32_t deviceId, const String8& name, uint32_t classes) {
-        Device* device = new Device(classes);
-        device->identifier.name = name;
-        mDevices.add(deviceId, device);
-
-        enqueueEvent(ARBITRARY_TIME, deviceId, EventHubInterface::DEVICE_ADDED, 0, 0);
-    }
-
-    void removeDevice(int32_t deviceId) {
-        delete mDevices.valueFor(deviceId);
-        mDevices.removeItem(deviceId);
-
-        enqueueEvent(ARBITRARY_TIME, deviceId, EventHubInterface::DEVICE_REMOVED, 0, 0);
-    }
-
-    void finishDeviceScan() {
-        enqueueEvent(ARBITRARY_TIME, 0, EventHubInterface::FINISHED_DEVICE_SCAN, 0, 0);
-    }
-
-    void addConfigurationProperty(int32_t deviceId, const String8& key, const String8& value) {
-        Device* device = getDevice(deviceId);
-        device->configuration.addProperty(key, value);
-    }
-
-    void addConfigurationMap(int32_t deviceId, const PropertyMap* configuration) {
-        Device* device = getDevice(deviceId);
-        device->configuration.addAll(configuration);
-    }
-
-    void addAbsoluteAxis(int32_t deviceId, int axis,
-            int32_t minValue, int32_t maxValue, int flat, int fuzz, int resolution = 0) {
-        Device* device = getDevice(deviceId);
-
-        RawAbsoluteAxisInfo info;
-        info.valid = true;
-        info.minValue = minValue;
-        info.maxValue = maxValue;
-        info.flat = flat;
-        info.fuzz = fuzz;
-        info.resolution = resolution;
-        device->absoluteAxes.add(axis, info);
-    }
-
-    void addRelativeAxis(int32_t deviceId, int32_t axis) {
-        Device* device = getDevice(deviceId);
-        device->relativeAxes.add(axis, true);
-    }
-
-    void setKeyCodeState(int32_t deviceId, int32_t keyCode, int32_t state) {
-        Device* device = getDevice(deviceId);
-        device->keyCodeStates.replaceValueFor(keyCode, state);
-    }
-
-    void setScanCodeState(int32_t deviceId, int32_t scanCode, int32_t state) {
-        Device* device = getDevice(deviceId);
-        device->scanCodeStates.replaceValueFor(scanCode, state);
-    }
-
-    void setSwitchState(int32_t deviceId, int32_t switchCode, int32_t state) {
-        Device* device = getDevice(deviceId);
-        device->switchStates.replaceValueFor(switchCode, state);
-    }
-
-    void setAbsoluteAxisValue(int32_t deviceId, int32_t axis, int32_t value) {
-        Device* device = getDevice(deviceId);
-        device->absoluteAxisValue.replaceValueFor(axis, value);
-    }
-
-    void addKey(int32_t deviceId, int32_t scanCode, int32_t usageCode,
-            int32_t keyCode, uint32_t flags) {
-        Device* device = getDevice(deviceId);
-        KeyInfo info;
-        info.keyCode = keyCode;
-        info.flags = flags;
-        if (scanCode) {
-            device->keysByScanCode.add(scanCode, info);
-        }
-        if (usageCode) {
-            device->keysByUsageCode.add(usageCode, info);
-        }
-    }
-
-    void addLed(int32_t deviceId, int32_t led, bool initialState) {
-        Device* device = getDevice(deviceId);
-        device->leds.add(led, initialState);
-    }
-
-    bool getLedState(int32_t deviceId, int32_t led) {
-        Device* device = getDevice(deviceId);
-        return device->leds.valueFor(led);
-    }
-
-    Vector<String8>& getExcludedDevices() {
-        return mExcludedDevices;
-    }
-
-    void addVirtualKeyDefinition(int32_t deviceId, const VirtualKeyDefinition& definition) {
-        Device* device = getDevice(deviceId);
-        device->virtualKeys.push(definition);
-    }
-
-    void enqueueEvent(nsecs_t when, int32_t deviceId, int32_t type,
-            int32_t code, int32_t value) {
-        RawEvent event;
-        event.when = when;
-        event.deviceId = deviceId;
-        event.type = type;
-        event.code = code;
-        event.value = value;
-        mEvents.push_back(event);
-
-        if (type == EV_ABS) {
-            setAbsoluteAxisValue(deviceId, code, value);
-        }
-    }
-
-    void assertQueueIsEmpty() {
-        ASSERT_EQ(size_t(0), mEvents.size())
-                << "Expected the event queue to be empty (fully consumed).";
-    }
-
-private:
-    Device* getDevice(int32_t deviceId) const {
-        ssize_t index = mDevices.indexOfKey(deviceId);
-        return index >= 0 ? mDevices.valueAt(index) : NULL;
-    }
-
-    virtual uint32_t getDeviceClasses(int32_t deviceId) const {
-        Device* device = getDevice(deviceId);
-        return device ? device->classes : 0;
-    }
-
-    virtual InputDeviceIdentifier getDeviceIdentifier(int32_t deviceId) const {
-        Device* device = getDevice(deviceId);
-        return device ? device->identifier : InputDeviceIdentifier();
-    }
-
-    virtual void getConfiguration(int32_t deviceId, PropertyMap* outConfiguration) const {
-        Device* device = getDevice(deviceId);
-        if (device) {
-            *outConfiguration = device->configuration;
-        }
-    }
-
-    virtual status_t getAbsoluteAxisInfo(int32_t deviceId, int axis,
-            RawAbsoluteAxisInfo* outAxisInfo) const {
-        outAxisInfo->clear();
-        Device* device = getDevice(deviceId);
-        if (device) {
-            ssize_t index = device->absoluteAxes.indexOfKey(axis);
-            if (index >= 0) {
-                *outAxisInfo = device->absoluteAxes.valueAt(index);
-                return OK;
-            }
-        }
-        return -1;
-    }
-
-    virtual bool hasRelativeAxis(int32_t deviceId, int axis) const {
-        Device* device = getDevice(deviceId);
-        if (device) {
-            return device->relativeAxes.indexOfKey(axis) >= 0;
-        }
-        return false;
-    }
-
-    bool hasInputProperty(int32_t deviceId, int property) const override {
-        (void)deviceId;
-        (void)property;
-        return false;
-    }
-
-    virtual status_t mapKey(int32_t deviceId, int32_t scanCode, int32_t usageCode,
-            int32_t* outKeycode, uint32_t* outFlags) const {
-        Device* device = getDevice(deviceId);
-        if (device) {
-            const KeyInfo* key = getKey(device, scanCode, usageCode);
-            if (key) {
-                if (outKeycode) {
-                    *outKeycode = key->keyCode;
-                }
-                if (outFlags) {
-                    *outFlags = key->flags;
-                }
-                return OK;
-            }
-        }
-        return NAME_NOT_FOUND;
-    }
-
-    const KeyInfo* getKey(Device* device, int32_t scanCode, int32_t usageCode) const {
-        if (usageCode) {
-            ssize_t index = device->keysByUsageCode.indexOfKey(usageCode);
-            if (index >= 0) {
-                return &device->keysByUsageCode.valueAt(index);
-            }
-        }
-        if (scanCode) {
-            ssize_t index = device->keysByScanCode.indexOfKey(scanCode);
-            if (index >= 0) {
-                return &device->keysByScanCode.valueAt(index);
-            }
-        }
-        return NULL;
-    }
-
-    status_t mapAxis(int32_t deviceId, int32_t scanCode, AxisInfo* outAxisInfo) const override {
-        (void)deviceId;
-        (void)scanCode;
-        (void)outAxisInfo;
-        return NAME_NOT_FOUND;
-    }
-
-    virtual void setExcludedDevices(const Vector<String8>& devices) {
-        mExcludedDevices = devices;
-    }
-
-    size_t getEvents(int timeoutMillis, RawEvent* buffer, size_t bufferSize) override {
-        (void)timeoutMillis;
-        (void)bufferSize;
-
-        if (mEvents.empty()) {
-            return 0;
-        }
-
-        *buffer = *mEvents.begin();
-        mEvents.erase(mEvents.begin());
-        return 1;
-    }
-
-    int32_t getScanCodeState(int32_t deviceId, int32_t scanCode) const override {
-        Device* device = getDevice(deviceId);
-        if (device) {
-            ssize_t index = device->scanCodeStates.indexOfKey(scanCode);
-            if (index >= 0) {
-                return device->scanCodeStates.valueAt(index);
-            }
-        }
-        return AKEY_STATE_UNKNOWN;
-    }
-
-    int32_t getKeyCodeState(int32_t deviceId, int32_t keyCode) const override {
-        Device* device = getDevice(deviceId);
-        if (device) {
-            ssize_t index = device->keyCodeStates.indexOfKey(keyCode);
-            if (index >= 0) {
-                return device->keyCodeStates.valueAt(index);
-            }
-        }
-        return AKEY_STATE_UNKNOWN;
-    }
-
-    int32_t getSwitchState(int32_t deviceId, int32_t sw) const override {
-        Device* device = getDevice(deviceId);
-        if (device) {
-            ssize_t index = device->switchStates.indexOfKey(sw);
-            if (index >= 0) {
-                return device->switchStates.valueAt(index);
-            }
-        }
-        return AKEY_STATE_UNKNOWN;
-    }
-
-    virtual status_t getAbsoluteAxisValue(int32_t deviceId, int32_t axis,
-            int32_t* outValue) const {
-        Device* device = getDevice(deviceId);
-        if (device) {
-            ssize_t index = device->absoluteAxisValue.indexOfKey(axis);
-            if (index >= 0) {
-                *outValue = device->absoluteAxisValue.valueAt(index);
-                return OK;
-            }
-        }
-        *outValue = 0;
-        return -1;
-    }
-
-    virtual bool markSupportedKeyCodes(int32_t deviceId, size_t numCodes, const int32_t* keyCodes,
-            uint8_t* outFlags) const {
-        bool result = false;
-        Device* device = getDevice(deviceId);
-        if (device) {
-            for (size_t i = 0; i < numCodes; i++) {
-                for (size_t j = 0; j < device->keysByScanCode.size(); j++) {
-                    if (keyCodes[i] == device->keysByScanCode.valueAt(j).keyCode) {
-                        outFlags[i] = 1;
-                        result = true;
-                    }
-                }
-                for (size_t j = 0; j < device->keysByUsageCode.size(); j++) {
-                    if (keyCodes[i] == device->keysByUsageCode.valueAt(j).keyCode) {
-                        outFlags[i] = 1;
-                        result = true;
-                    }
-                }
-            }
-        }
-        return result;
-    }
-
-    virtual bool hasScanCode(int32_t deviceId, int32_t scanCode) const {
-        Device* device = getDevice(deviceId);
-        if (device) {
-            ssize_t index = device->keysByScanCode.indexOfKey(scanCode);
-            return index >= 0;
-        }
-        return false;
-    }
-
-    virtual bool hasLed(int32_t deviceId, int32_t led) const {
-        Device* device = getDevice(deviceId);
-        return device && device->leds.indexOfKey(led) >= 0;
-    }
-
-    virtual void setLedState(int32_t deviceId, int32_t led, bool on) {
-        Device* device = getDevice(deviceId);
-        if (device) {
-            ssize_t index = device->leds.indexOfKey(led);
-            if (index >= 0) {
-                device->leds.replaceValueAt(led, on);
-            } else {
-                ADD_FAILURE()
-                        << "Attempted to set the state of an LED that the EventHub declared "
-                        "was not present.  led=" << led;
-            }
-        }
-    }
-
-    void getVirtualKeyDefinitions(int32_t deviceId,
-            Vector<VirtualKeyDefinition>& outVirtualKeys) const override {
-        outVirtualKeys.clear();
-
-        Device* device = getDevice(deviceId);
-        if (device) {
-            outVirtualKeys.appendVector(device->virtualKeys);
-        }
-    }
-
-    sp<KeyCharacterMap> getKeyCharacterMap(int32_t deviceId) const override {
-        (void)deviceId;
-        return NULL;
-    }
-
-    bool setKeyboardLayoutOverlay(int32_t deviceId, const sp<KeyCharacterMap>& map) override {
-        (void)deviceId;
-        (void)map;
-        return false;
-    }
-
-    void vibrate(int32_t /*deviceId*/, nsecs_t /*duration*/) override {}
-
-    void cancelVibrate(int32_t /*deviceId*/) override {}
-
-    void wake() override {}
-
-    void dump(String8& /*dump*/) override {}
-
-    void monitor() override {}
-
-    void flush() override {}
-
-    void requestReopenDevices() override {}
-
-};
-
-
 // --- FakeInputReaderContext ---
 
 class FakeInputReaderContext : public InputReaderContext {
@@ -1001,7 +595,8 @@
         mFakeEventHub->finishDeviceScan();
         mReader->loopOnce();
         mReader->loopOnce();
-        mFakeEventHub->assertQueueIsEmpty();
+        ASSERT_EQ(size_t(0), mFakeEventHub->eventsQueueSize())
+            << "Expected the event queue to be empty (fully consumed).";
     }
 
     FakeInputMapper* addDeviceWithFakeInputMapper(int32_t deviceId,
@@ -1017,16 +612,16 @@
 };
 
 TEST_F(InputReaderTest, GetInputDevices) {
-    ASSERT_NO_FATAL_FAILURE(addDevice(1, String8("keyboard"),
+    ASSERT_NO_FATAL_FAILURE(addDevice(2, String8("keyboard"),
             INPUT_DEVICE_CLASS_KEYBOARD, NULL));
-    ASSERT_NO_FATAL_FAILURE(addDevice(2, String8("ignored"),
+    ASSERT_NO_FATAL_FAILURE(addDevice(3, String8("ignored"),
             0, NULL)); // no classes so device will be ignored
 
     Vector<InputDeviceInfo> inputDevices;
     mReader->getInputDevices(inputDevices);
 
     ASSERT_EQ(1U, inputDevices.size());
-    ASSERT_EQ(1, inputDevices[0].getId());
+    ASSERT_EQ(2, inputDevices[0].getId());
     ASSERT_STREQ("keyboard", inputDevices[0].getIdentifier().name.c_str());
     ASSERT_EQ(AINPUT_KEYBOARD_TYPE_NON_ALPHABETIC, inputDevices[0].getKeyboardType());
     ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, inputDevices[0].getSources());
@@ -1035,7 +630,7 @@
     // Should also have received a notification describing the new input devices.
     inputDevices = mFakePolicy->getInputDevices();
     ASSERT_EQ(1U, inputDevices.size());
-    ASSERT_EQ(1, inputDevices[0].getId());
+    ASSERT_EQ(2, inputDevices[0].getId());
     ASSERT_STREQ("keyboard", inputDevices[0].getIdentifier().name.c_str());
     ASSERT_EQ(AINPUT_KEYBOARD_TYPE_NON_ALPHABETIC, inputDevices[0].getKeyboardType());
     ASSERT_EQ(AINPUT_SOURCE_KEYBOARD, inputDevices[0].getSources());
@@ -1159,7 +754,7 @@
 }
 
 TEST_F(InputReaderTest, LoopOnce_WhenDeviceScanFinished_SendsConfigurationChanged) {
-    addDevice(1, String8("ignored"), INPUT_DEVICE_CLASS_KEYBOARD, NULL);
+    addDevice(2, String8("ignored"), INPUT_DEVICE_CLASS_KEYBOARD, NULL);
 
     NotifyConfigurationChangedArgs args{0};
 
@@ -1172,9 +767,9 @@
     ASSERT_NO_FATAL_FAILURE(mapper = addDeviceWithFakeInputMapper(1, String8("fake"),
             INPUT_DEVICE_CLASS_KEYBOARD, AINPUT_SOURCE_KEYBOARD, NULL));
 
-    mFakeEventHub->enqueueEvent(0, 1, EV_KEY, KEY_A, 1);
+    mFakeEventHub->synthesize_event(0, 1, EV_KEY, KEY_A, 1);
     mReader->loopOnce();
-    ASSERT_NO_FATAL_FAILURE(mFakeEventHub->assertQueueIsEmpty());
+    EXPECT_EQ(size_t(0), mFakeEventHub->eventsQueueSize());
 
     RawEvent event;
     ASSERT_NO_FATAL_FAILURE(mapper->assertProcessWasCalled(&event));
@@ -1227,7 +822,7 @@
 };
 
 const char* InputDeviceTest::DEVICE_NAME = "device";
-const int32_t InputDeviceTest::DEVICE_ID = 1;
+const int32_t InputDeviceTest::DEVICE_ID = 2;
 const int32_t InputDeviceTest::DEVICE_GENERATION = 2;
 const uint32_t InputDeviceTest::DEVICE_CLASSES = INPUT_DEVICE_CLASS_KEYBOARD
         | INPUT_DEVICE_CLASS_TOUCH | INPUT_DEVICE_CLASS_JOYSTICK;
@@ -1479,7 +1074,7 @@
 };
 
 const char* InputMapperTest::DEVICE_NAME = "device";
-const int32_t InputMapperTest::DEVICE_ID = 1;
+const int32_t InputMapperTest::DEVICE_ID = 2;
 const int32_t InputMapperTest::DEVICE_GENERATION = 2;
 const uint32_t InputMapperTest::DEVICE_CLASSES = 0; // not needed for current tests