Merge lp:~andreas-pokorny/mir/contact-info-as-extension into lp:mir

[Andreas Pokorny]

Allow the evdev platform to run on non-Ubuntu systems.

The Ubuntu version of libinput provides additional symbols, allowing to
access touch information. This is an intermediate solution until the
patch to libinput gets accepted upstream.

This loads the touch contact functions via dlsym - so evdev platform will compile and run on fedora or debian.

This is only meant as an intermediate step until the change in libinput gets upstreamed.

[Daniel van Vugt (vanvugt)]

Sounds like a plan...

(1) This is a bit weird though:
  dladdr(dlsym(nullptr, "main"), &exec_info);
Why not use dlsym(RTLD_DEFAULT, "libinput_event_touch_get_major_transformed") to search the current process instead? You shouldn't need the Dl_info either... Just search for the functions using RTLD_DEFAULT.
  Alternatively, just provide a raw implementation of the relevant functions, and check to see if there is a (second) system-provided version to use by searching RTLD_NEXT.

(2) Why would the fallback touch_major and touch_minor functions return different values?

review: Needs Fixing

[Andreas Pokorny (andreas-pokorny)]

> Sounds like a plan...
>
> (1) This is a bit weird though:
> dladdr(dlsym(nullptr, "main"), &exec_info);
> Why not use dlsym(RTLD_DEFAULT, "libinput_event_touch_get_major_transformed")
> to search the current process instead? You shouldn't need the Dl_info
> either... Just search for the functions using RTLD_DEFAULT.
> Alternatively, just provide a raw implementation of the relevant functions,
> and check to see if there is a (second) system-provided version to use by
> searching RTLD_NEXT.

Hmm ok I have not thought about that. I think the latter would fail because of mock_libinput.cpp. Will try the former now..

> (2) Why would the fallback touch_major and touch_minor functions return
> different values?

Usually the larger diameter is returned via major and the small diameter with touch minor.

[Daniel van Vugt (vanvugt)]

OK, thanks.

I don't think the template function is necessary but it's not so important. I would have just made a lookup table:

typedef void (*FunPtr)();
static const struct
{
    char const* name;
    FunPtr* ptr;
} fun[] =
{
    {"libinput_event_touch_get_major_transformed", (FunPtr*)&get_touch_major},
    ...
};

And then loop through the array, indirectly filling out the pointed-to function pointers.

review: Approve

[Mir CI Bot (mir-ci-bot)]

review: Approve (continuous-integration)

=== modified file 'src/platforms/evdev/libinput_device.cpp'
--- src/platforms/evdev/libinput_device.cpp	2017-03-14 02:26:28 +0000
+++ src/platforms/evdev/libinput_device.cpp	2017-05-01 16:20:55 +0000
@@ -38,6 +38,7 @@
 
 #include <libinput.h>
 #include <linux/input.h>  // only used to get constants for input reports
+#include <dlfcn.h>
 
 #include <boost/exception/diagnostic_information.hpp>
 #include <cstring>
@@ -50,8 +51,68 @@
 namespace mie = mi::evdev;
 using namespace std::literals::chrono_literals;
 
+namespace
+{
+double touch_major(libinput_event_touch*, uint32_t, uint32_t)
+{
+    return 8;
+}
+double touch_minor(libinput_event_touch*, uint32_t, uint32_t)
+{
+    return 6;
+}
+double pressure(libinput_event_touch*)
+{
+    return 0.8;
+}
+double orientation(libinput_event_touch*)
+{
+    return 0;
+}
+
+template<typename T> auto load_function(char const* sym)
+{
+    T result{};
+    dlerror();
+    (void*&)result = dlsym(RTLD_DEFAULT, sym);
+    char const *error = dlerror();
+
+    if (error)
+        throw std::runtime_error(error);
+    if (!result)
+        throw std::runtime_error("no valid function address");
+
+    return result;
+}
+}
+
+struct mie::LibInputDevice::ContactExtension
+{
+    ContactExtension()
+    {
+        constexpr const char touch_major_sym[] = "libinput_event_touch_get_major_transformed";
+        constexpr const char touch_minor_sym[] = "libinput_event_touch_get_minor_transformed";
+        constexpr const char orientation_sym[] = "libinput_event_touch_get_orientation";
+        constexpr const char pressure_sym[] = "libinput_event_touch_get_pressure";
+
+        try
+        {
+            get_touch_major = load_function<decltype(&touch_major)>(touch_major_sym);
+            get_touch_minor = load_function<decltype(&touch_minor)>(touch_minor_sym);
+            get_orientation = load_function<decltype(&orientation)>(orientation_sym);
+            get_pressure = load_function<decltype(&pressure)>(pressure_sym);
+        }
+        catch(...) {}
+    }
+
+    decltype(&touch_major) get_touch_major{&touch_major};
+    decltype(&touch_minor) get_touch_minor{&touch_minor};
+    decltype(&pressure) get_pressure{&pressure};
+    decltype(&orientation) get_orientation{&orientation};
+};
+
 mie::LibInputDevice::LibInputDevice(std::shared_ptr<mi::InputReport> const& report, LibInputDevicePtr dev)
-    : report{report}, pointer_pos{0, 0}, button_state{0}
+    : contact_extension{std::make_unique<ContactExtension>()}, report{report}, pointer_pos{0, 0}, button_state{0}
 {
     add_device_of_group(std::move(dev));
 }
@@ -300,11 +361,11 @@
     uint32_t height = info.output_size.height.as_int();
 
     data.action = action;
-    data.pressure = libinput_event_touch_get_pressure(touch);
     data.x = libinput_event_touch_get_x_transformed(touch, width);
     data.y = libinput_event_touch_get_y_transformed(touch, height);
-    data.major = libinput_event_touch_get_major_transformed(touch, width, height);
-    data.minor = libinput_event_touch_get_minor_transformed(touch, width, height);
+    data.major = contact_extension->get_touch_major(touch, width, height);
+    data.minor = contact_extension->get_touch_minor(touch, width, height);
+    data.pressure = contact_extension->get_pressure(touch);
 
     info.transform_to_scene(data.x, data.y);
 }

=== modified file 'src/platforms/evdev/libinput_device.h'
--- src/platforms/evdev/libinput_device.h	2017-03-20 11:46:27 +0000
+++ src/platforms/evdev/libinput_device.h	2017-05-01 16:20:55 +0000
@@ -81,6 +81,9 @@
     bool is_output_active() const;
     OutputInfo get_output_info() const;
 
+    struct ContactExtension;
+    std::unique_ptr<ContactExtension> contact_extension;
+
     std::shared_ptr<InputReport> report;
     std::vector<LibInputDevicePtr> devices;
 

=== modified file 'tests/mir_test_doubles/mock_libinput.cpp'
--- tests/mir_test_doubles/mock_libinput.cpp	2017-03-14 02:26:28 +0000
+++ tests/mir_test_doubles/mock_libinput.cpp	2017-05-01 16:20:55 +0000
@@ -278,32 +278,32 @@
     return global_libinput->libinput_event_touch_get_y_transformed(event, height);
 }
 
-double libinput_event_touch_get_major(libinput_event_touch* event)
+extern "C" double libinput_event_touch_get_major(libinput_event_touch* event)
 {
     return global_libinput->libinput_event_touch_get_major(event);
 }
 
-double libinput_event_touch_get_minor(libinput_event_touch* event)
+extern "C" double libinput_event_touch_get_minor(libinput_event_touch* event)
 {
     return global_libinput->libinput_event_touch_get_minor(event);
 }
 
-double libinput_event_touch_get_major_transformed(libinput_event_touch* event, uint32_t width, uint32_t height)
+extern "C" double libinput_event_touch_get_major_transformed(libinput_event_touch* event, uint32_t width, uint32_t height)
 {
     return global_libinput->libinput_event_touch_get_major_transformed(event, width, height);
 }
 
-double libinput_event_touch_get_minor_transformed(libinput_event_touch* event, uint32_t width, uint32_t height)
+extern "C" double libinput_event_touch_get_minor_transformed(libinput_event_touch* event, uint32_t width, uint32_t height)
 {
     return global_libinput->libinput_event_touch_get_minor_transformed(event, width, height);
 }
 
-double libinput_event_touch_get_pressure(libinput_event_touch* event)
+extern "C" double libinput_event_touch_get_pressure(libinput_event_touch* event)
 {
     return global_libinput->libinput_event_touch_get_pressure(event);
 }
 
-double libinput_event_touch_get_orientation(libinput_event_touch* event)
+extern "C" double libinput_event_touch_get_orientation(libinput_event_touch* event)
 {
     return global_libinput->libinput_event_touch_get_orientation(event);
 }