Merge lp:~andreas-pokorny/mir/fix-1549701-0.21.0 into lp:mir/0.21

[Andreas Pokorny]

Loads libandroid-properties.so.1 and property_get to disable key repeats on the mx4 touchscreen

Disable repeats on arale.

[Brandon Schaefer (brandontschaefer)]

LGTM (for a workaround?) Not sure why arale is self has issues with key repeat

review: Approve

[Alberto Aguirre (albaguirre)]

ok as a workaround...

review: Approve

=== modified file 'src/server/input/default_configuration.cpp'
--- src/server/input/default_configuration.cpp	2016-03-17 22:23:47 +0000
+++ src/server/input/default_configuration.cpp	2016-03-29 19:32:00 +0000
@@ -48,6 +48,7 @@
 #include "mir/abnormal_exit.h"
 #include "mir/glib_main_loop.h"
 #include "mir/log.h"
+#include "mir/shared_library.h"
 #include "mir/dispatch/action_queue.h"
 
 #include "mir_toolkit/cursors.h"
@@ -60,6 +61,36 @@
 namespace msh = mir::shell;
 namespace md = mir::dispatch;
 
+namespace
+{
+
+bool is_arale()
+{
+    try
+    {
+        mir::SharedLibrary android_properties("libandroid-properties.so.1");
+        int (*property_get)(char const*, char*, char const*) = nullptr;
+        property_get = android_properties.load_function<decltype(property_get)>("property_get");
+
+        const int property_value_max = 92;
+        char default_value[] = "";
+        char value[property_value_max];
+
+        if (property_get == nullptr)
+            return false;
+
+        property_get("ro.product.device", value, default_value);
+
+        return std::strcmp("arale", value) == 0;
+    }
+    catch(...)
+    {
+    }
+    return false;
+}
+
+}
+
 std::shared_ptr<mi::InputRegion> mir::DefaultServerConfiguration::the_input_region()
 {
     return input_region(
@@ -151,7 +182,7 @@
 
             return std::make_shared<mi::KeyRepeatDispatcher>(
                 the_event_filter_chain_dispatcher(), the_main_loop(), the_cookie_authority(),
-                enable_repeat, key_repeat_timeout, key_repeat_delay);
+                enable_repeat, key_repeat_timeout, key_repeat_delay, is_arale());
         });
 }
 

=== modified file 'src/server/input/key_repeat_dispatcher.cpp'
--- src/server/input/key_repeat_dispatcher.cpp	2016-03-17 22:23:47 +0000
+++ src/server/input/key_repeat_dispatcher.cpp	2016-03-29 19:32:00 +0000
@@ -37,11 +37,16 @@
 {
 struct DeviceRemovalFilter : mi::InputDeviceObserver
 {
-    DeviceRemovalFilter(std::function<void(MirInputDeviceId)> const& on_removal)
-        : on_removal(on_removal) {}
+    DeviceRemovalFilter(mi::KeyRepeatDispatcher* dispatcher)
+        : dispatcher{dispatcher} {}
 
-    void device_added(std::shared_ptr<mi::Device> const&) override
+    void device_added(std::shared_ptr<mi::Device> const& device) override
     {
+        if (device->name() == "mtk-tpd")
+        {
+            dispatcher->set_mtk_device(device->id());
+        }
+
     }
 
     void device_changed(std::shared_ptr<mi::Device> const&) override
@@ -50,13 +55,13 @@
 
     void device_removed(std::shared_ptr<mi::Device> const& device) override
     {
-        on_removal(device->id());
+        dispatcher->remove_device(device->id());
     }
 
     void changes_complete() override
     {
     }
-    std::function<void(MirInputDeviceId)> on_removal;
+    mi::KeyRepeatDispatcher* dispatcher;
 };
 
 }
@@ -67,25 +72,35 @@
     std::shared_ptr<mir::cookie::Authority> const& cookie_authority,
     bool repeat_enabled,
     std::chrono::milliseconds repeat_timeout,
-    std::chrono::milliseconds repeat_delay)
+    std::chrono::milliseconds repeat_delay,
+    bool disable_repeat_on_mtk_touchpad)
     : next_dispatcher(next_dispatcher),
       alarm_factory(factory),
       cookie_authority(cookie_authority),
       repeat_enabled(repeat_enabled),
       repeat_timeout(repeat_timeout),
-      repeat_delay(repeat_delay)
+      repeat_delay(repeat_delay),
+      disable_repeat_on_mtk_touchpad(disable_repeat_on_mtk_touchpad)
 {
 }
 
 void mi::KeyRepeatDispatcher::set_input_device_hub(std::shared_ptr<InputDeviceHub> const& hub)
 {
-    hub->add_observer(std::make_shared<DeviceRemovalFilter>(
-            [this](MirInputDeviceId id)
-            {
-                std::unique_lock<std::mutex> lock(repeat_state_mutex);
-                repeat_state_by_device.erase(id); // destructor cancels alarms
-            }
-            ));
+    hub->add_observer(std::make_shared<DeviceRemovalFilter>(this));
+}
+
+void mi::KeyRepeatDispatcher::set_mtk_device(MirInputDeviceId id)
+{
+    std::lock_guard<std::mutex> lock(repeat_state_mutex);
+    mtk_tpd_id = id;
+}
+
+void mi::KeyRepeatDispatcher::remove_device(MirInputDeviceId id)
+{
+    std::lock_guard<std::mutex> lock(repeat_state_mutex);
+    repeat_state_by_device.erase(id); // destructor cancels alarms
+    if (mtk_tpd_id.is_set() && mtk_tpd_id.value() == id)
+        mtk_tpd_id.consume();
 }
 
 mi::KeyRepeatDispatcher::KeyboardState& mi::KeyRepeatDispatcher::ensure_state_for_device_locked(std::lock_guard<std::mutex> const&, MirInputDeviceId id)
@@ -100,12 +115,16 @@
     {
 	return next_dispatcher->dispatch(event);
     }
-    
+
     if (mir_event_get_type(&event) == mir_event_type_input)
     {
         auto iev = mir_event_get_input_event(&event);
         if (mir_input_event_get_type(iev) != mir_input_event_type_key)
             return next_dispatcher->dispatch(event);
+        auto device_id = mir_input_event_get_device_id(iev);
+        if (disable_repeat_on_mtk_touchpad && mtk_tpd_id.is_set() && device_id == mtk_tpd_id.value())
+            return next_dispatcher->dispatch(event);
+
         if (!handle_key_input(mir_input_event_get_device_id(iev), mir_input_event_get_keyboard_event(iev)))
             return next_dispatcher->dispatch(event);
         else

=== modified file 'src/server/input/key_repeat_dispatcher.h'
--- src/server/input/key_repeat_dispatcher.h	2016-03-17 22:23:47 +0000
+++ src/server/input/key_repeat_dispatcher.h	2016-03-29 19:32:00 +0000
@@ -21,6 +21,7 @@
 
 #include "mir/input/input_dispatcher.h"
 #include "mir/input/input_device_observer.h"
+#include "mir/optional_value.h"
 
 #include <memory>
 #include <chrono>
@@ -49,7 +50,8 @@
                         std::shared_ptr<cookie::Authority> const& cookie_authority,
                         bool repeat_enabled,
                         std::chrono::milliseconds repeat_timeout, /* timeout before sending first repeat */
-                        std::chrono::milliseconds repeat_delay /* delay between repeated keys */);
+                        std::chrono::milliseconds repeat_delay, /* delay between repeated keys */
+                        bool disable_repeat_on_mtk_touchpad);
 
     // InputDispatcher
     bool dispatch(MirEvent const& event) override;
@@ -58,6 +60,8 @@
 
     void set_input_device_hub(std::shared_ptr<InputDeviceHub> const& hub);
 
+    void set_mtk_device(MirInputDeviceId id);
+    void remove_device(MirInputDeviceId id);
 private:
     std::mutex repeat_state_mutex;
 
@@ -67,6 +71,8 @@
     bool const repeat_enabled;
     std::chrono::milliseconds repeat_timeout;
     std::chrono::milliseconds repeat_delay;
+    bool const disable_repeat_on_mtk_touchpad;
+    optional_value<MirInputDeviceId> mtk_tpd_id;
 
     struct KeyboardState
     {

=== modified file 'tests/unit-tests/input/test_key_repeat_dispatcher.cpp'
--- tests/unit-tests/input/test_key_repeat_dispatcher.cpp	2016-03-17 22:23:47 +0000
+++ tests/unit-tests/input/test_key_repeat_dispatcher.cpp	2016-03-29 19:32:00 +0000
@@ -33,6 +33,8 @@
 #include "mir/test/doubles/mock_input_dispatcher.h"
 #include "mir/test/doubles/mock_input_device_hub.h"
 
+#include "linux/input-event-codes.h"
+
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
 
@@ -76,10 +78,18 @@
 struct StubDevice : public mi::Device
 {
     MirInputDeviceId device_id;
+    std::string device_name;
+
     StubDevice(MirInputDeviceId id) : device_id(id) {}
-    MirInputDeviceId id() const { return device_id;}
+    StubDevice(MirInputDeviceId id, std::string device_name) : device_id{id}, device_name{device_name}
+    {
+    }
+    MirInputDeviceId id() const
+    {
+        return device_id;
+    }
     mi::DeviceCapabilities capabilities() const {return mi::DeviceCapability::keyboard;}
-    std::string name() const {return {};}
+    std::string name() const {return device_name;}
     std::string unique_id() const {return {};}
 
     mir::optional_value<mi::PointerConfiguration> pointer_configuration() const {return {};}
@@ -90,8 +100,8 @@
 
 struct KeyRepeatDispatcher : public testing::Test
 {
-    KeyRepeatDispatcher()
-        : dispatcher(mock_next_dispatcher, mock_alarm_factory, cookie_authority, true, repeat_time, repeat_delay)
+    KeyRepeatDispatcher(bool on_arale = false)
+        : dispatcher(mock_next_dispatcher, mock_alarm_factory, cookie_authority, true, repeat_time, repeat_delay, on_arale)
     {
         ON_CALL(hub,add_observer(_)).WillByDefault(SaveArg<0>(&observer));
         dispatcher.set_input_device_hub(mt::fake_shared(hub));
@@ -123,6 +133,24 @@
         return mev::make_event(test_device, std::chrono::nanoseconds(0), std::vector<uint8_t>{}, mir_keyboard_action_up, 0, 0, mir_input_event_modifier_alt);
     }
 };
+
+struct KeyRepeatDispatcherOnArale : KeyRepeatDispatcher
+{
+    KeyRepeatDispatcherOnArale() : KeyRepeatDispatcher(true){};
+    MirInputDeviceId mtk_id = 32;
+    void add_mtk_tpd()
+    {
+        StubDevice dev(mtk_id, "mtk-tpd");
+        observer->device_added(mt::fake_shared(dev));
+        observer->changes_complete();
+    }
+
+    mir::EventUPtr mtk_key_down_event()
+    {
+        return mev::make_event(mtk_id, std::chrono::nanoseconds(0), std::vector<uint8_t>{}, mir_keyboard_action_down, 0,
+                               KEY_LEFTALT, mir_input_event_modifier_none);
+    }
+};
 }
 
 TEST_F(KeyRepeatDispatcher, forwards_start_stop)
@@ -182,3 +210,31 @@
     simulate_device_removal();
     EXPECT_THAT(alarm_canceled, Eq(true));
 }
+
+TEST_F(KeyRepeatDispatcherOnArale, no_repeat_alarm_on_mtk_tpd)
+{
+    EXPECT_CALL(*mock_alarm_factory, create_alarm_adapter(_)).Times(0);
+    EXPECT_CALL(*mock_next_dispatcher, dispatch(mt::KeyDownEvent())).Times(1);
+    EXPECT_CALL(*mock_next_dispatcher, dispatch(mt::KeyRepeatEvent())).Times(0);
+
+    add_mtk_tpd();
+    dispatcher.dispatch(*mtk_key_down_event());
+}
+
+TEST_F(KeyRepeatDispatcherOnArale, repeat_for_regular_keys)
+{
+    MockAlarm *mock_alarm = new MockAlarm;
+    std::function<void()> alarm_function;
+
+    EXPECT_CALL(*mock_alarm_factory, create_alarm_adapter(_)).Times(1).
+        WillOnce(DoAll(SaveArg<0>(&alarm_function), Return(mock_alarm)));
+    // Once for initial down and again when invoked
+    EXPECT_CALL(*mock_alarm, reschedule_in(repeat_delay)).Times(1).WillOnce(Return(true));
+    EXPECT_CALL(*mock_alarm, reschedule_in(repeat_time)).Times(1).WillOnce(Return(true));
+    EXPECT_CALL(*mock_next_dispatcher, dispatch(mt::KeyDownEvent())).Times(1);
+    EXPECT_CALL(*mock_next_dispatcher, dispatch(mt::KeyRepeatEvent())).Times(1);
+
+    add_mtk_tpd();
+    dispatcher.dispatch(*a_key_down_event());
+    alarm_function();
+}