Add palm suppression feature to EventConverterEvdev

ui/events/ozone/evdev/touch_event_converter_evdev.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/events/ozone/evdev/touch_event_converter_evdev.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <linux/input.h>
 #include <poll.h>
@@ skipping 13 matching lines @@
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event.h"
 #include "ui/events/devices/device_data_manager.h"
 #include "ui/events/devices/device_util_linux.h"
 #include "ui/events/event.h"
 #include "ui/events/event_constants.h"
 #include "ui/events/event_switches.h"
 #include "ui/events/event_utils.h"
 #include "ui/events/ozone/evdev/device_event_dispatcher_evdev.h"
+#include "ui/events/ozone/evdev/palm_suppression_filter.h"
 #include "ui/events/ozone/evdev/touch_evdev_types.h"
 #include "ui/events/ozone/evdev/touch_noise/touch_noise_finder.h"
 #include "ui/ozone/public/input_controller.h"
 
 namespace {
 
 const int kMaxTrackingId = 0xffff;  // TRKID_MAX in kernel.
 
 struct TouchCalibration {
   int bezel_left;
@@ skipping 62 matching lines @@
     int id,
     const EventDeviceInfo& devinfo,
     DeviceEventDispatcherEvdev* dispatcher)
     : EventConverterEvdev(fd,
                           path,
                           id,
                           devinfo.device_type(),
                           devinfo.name(),
                           devinfo.vendor_id(),
                           devinfo.product_id()),
-      dispatcher_(dispatcher) {
+      dispatcher_(dispatcher),
+      palm_filter_(nullptr) {
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kExtraTouchNoiseFiltering)) {
     touch_noise_finder_.reset(new TouchNoiseFinder);
   }
   touch_evdev_debug_buffer_.Initialize(devinfo);
 }
 
 TouchEventConverterEvdev::~TouchEventConverterEvdev() {
 }
 
 void TouchEventConverterEvdev::Initialize(const EventDeviceInfo& info) {
   has_mt_ = info.HasMultitouch();
+  has_pen_ = info.HasKeyEvent(BTN_TOOL_PEN);
 
   if (has_mt_) {
     pressure_min_ = info.GetAbsMinimum(ABS_MT_PRESSURE);
     pressure_max_ = info.GetAbsMaximum(ABS_MT_PRESSURE);
     x_min_tuxels_ = info.GetAbsMinimum(ABS_MT_POSITION_X);
     x_num_tuxels_ = info.GetAbsMaximum(ABS_MT_POSITION_X) - x_min_tuxels_ + 1;
     y_min_tuxels_ = info.GetAbsMinimum(ABS_MT_POSITION_Y);
     y_num_tuxels_ = info.GetAbsMaximum(ABS_MT_POSITION_Y) - y_min_tuxels_ + 1;
     touch_points_ =
         std::min<int>(info.GetAbsMaximum(ABS_MT_SLOT) + 1, kNumTouchEvdevSlots);
+    major_max_ = info.GetAbsMaximum(ABS_MT_TOUCH_MAJOR);
     current_slot_ = info.GetAbsValue(ABS_MT_SLOT);
   } else {
     pressure_min_ = info.GetAbsMinimum(ABS_PRESSURE);
     pressure_max_ = info.GetAbsMaximum(ABS_PRESSURE);
     x_min_tuxels_ = info.GetAbsMinimum(ABS_X);
     x_num_tuxels_ = info.GetAbsMaximum(ABS_X) - x_min_tuxels_ + 1;
     y_min_tuxels_ = info.GetAbsMinimum(ABS_Y);
     y_num_tuxels_ = info.GetAbsMaximum(ABS_Y) - y_min_tuxels_ + 1;
+    major_max_ = std::numeric_limits<int>::max();
     touch_points_ = 1;
     current_slot_ = 0;
   }
 
   quirk_left_mouse_button_ =
       !has_mt_ && !info.HasKeyEvent(BTN_TOUCH) && info.HasKeyEvent(BTN_LEFT);
 
   // Apply --touch-calibration.
   if (type() == INPUT_DEVICE_INTERNAL) {
     TouchCalibration cal = {};
@@ skipping 21 matching lines @@
           ABS_MT_TRACKING_ID, i, kTrackingIdForUnusedSlot);
       events_[i].touching = (events_[i].tracking_id >= 0);
       events_[i].slot = i;
 
       // Dirty the slot so we'll update the consumer at the first opportunity.
       // We can't dispatch here as this is currently called on the worker pool.
       // TODO(spang): Move initialization off worker pool.
       events_[i].altered = true;
 
       // Optional bits.
-      events_[i].radius_x =
-          info.GetAbsMtSlotValueWithDefault(ABS_MT_TOUCH_MAJOR, i, 0) / 2.0f;
+      int touch_major =
+          info.GetAbsMtSlotValueWithDefault(ABS_MT_TOUCH_MAJOR, i, 0);
+      events_[i].radius_x = touch_major / 2.0f;
       events_[i].radius_y =
           info.GetAbsMtSlotValueWithDefault(ABS_MT_TOUCH_MINOR, i, 0) / 2.0f;
       events_[i].pressure = ScalePressure(
           info.GetAbsMtSlotValueWithDefault(ABS_MT_PRESSURE, i, 0));
+      events_[i].is_palm = (touch_major == major_max_);

[spang, 2016/08/23 23:32:29]

Are we confident all MT drivers have the touch major axis (including USB
devices)? Otherwise this is probably (0 == 0) and will drop everything.

[denniskempin, 2016/08/25 23:27:45]

Of course we shouldn't rely on this. I should have thought of that, thanks for
catching this!

     }
   } else {
     // TODO(spang): Add key state to EventDeviceInfo to allow initial contact.
     // (and make sure to take into account quirk_left_mouse_button_)
     events_[0].x = 0;
     events_[0].y = 0;
     events_[0].tracking_id = kTrackingIdForUnusedSlot;
     events_[0].touching = false;
     events_[0].slot = 0;
     events_[0].radius_x = 0;
     events_[0].radius_y = 0;
     events_[0].pressure = 0;
     events_[0].tool_code = 0;
+    events_[0].is_palm = false;
   }
+
+  if (palm_filter_)
+    palm_filter_->Reset();

[spang, 2016/08/23 23:32:29]

Why should losing sync cancel suppression? Dropped events seems orthogonal to
stylus use.

[denniskempin, 2016/08/25 23:27:45]

Done.

 }
 
 void TouchEventConverterEvdev::Reinitialize() {
   ReleaseButtons();
 
   EventDeviceInfo info;
   if (!info.Initialize(fd_, path_)) {
     LOG(ERROR) << "Failed to synchronize state for touch device: "
                << path_.value();
     Stop();
     return;
   }
   Initialize(info);
 }
 
 bool TouchEventConverterEvdev::HasTouchscreen() const {
   return true;
 }
 
+bool TouchEventConverterEvdev::HasPen() const {
+  return has_pen_;
+}
+
 gfx::Size TouchEventConverterEvdev::GetTouchscreenSize() const {
   return gfx::Size(x_num_tuxels_, y_num_tuxels_);
 }
 
 int TouchEventConverterEvdev::GetTouchPoints() const {
   return touch_points_;
 }
 
 void TouchEventConverterEvdev::OnEnabled() {
   ReportEvents(EventTimeForNow());
 }
 
 void TouchEventConverterEvdev::OnDisabled() {
   ReleaseTouches();
   ReleaseButtons();
+  if (palm_filter_)
+    palm_filter_->Reset();
 }
 
 void TouchEventConverterEvdev::OnFileCanReadWithoutBlocking(int fd) {
   TRACE_EVENT1("evdev",
                "TouchEventConverterEvdev::OnFileCanReadWithoutBlocking", "fd",
                fd);
 
   input_event inputs[kNumTouchEvdevSlots * 6 + 1];
   ssize_t read_size = read(fd, inputs, sizeof(inputs));
   if (read_size < 0) {
@@ skipping 22 matching lines @@
 }
 
 void TouchEventConverterEvdev::DumpTouchEventLog(const char* filename) {
   touch_evdev_debug_buffer_.DumpLog(filename);
 }
 
 void TouchEventConverterEvdev::SetTouchEventLoggingEnabled(bool enabled) {
   touch_logging_enabled_ = enabled;
 }
 
+void TouchEventConverterEvdev::SetPalmSuppressionFilter(
+    PalmSuppressionFilter* palm_filter) {
+  palm_filter_ = palm_filter;
+}
+
 void TouchEventConverterEvdev::ProcessMultitouchEvent(
     const input_event& input) {
   if (touch_logging_enabled_)
     touch_evdev_debug_buffer_.ProcessEvent(current_slot_, &input);
 
   if (input.type == EV_SYN) {
     ProcessSyn(input);
   } else if (dropped_events_) {
     // Do nothing. This branch indicates we have lost sync with the driver.
   } else if (input.type == EV_ABS) {
@@ skipping 51 matching lines @@
       // Do not change tool types while touching to prevent inconsistencies
       // from switching between Mouse and TouchEvents.
       if (events_[current_slot_].was_touching)
         break;
 
       if (input.value > 0) {
         events_[current_slot_].tool_code = input.code;
       } else {
         events_[current_slot_].tool_code = 0;
       }
+      events_[current_slot_].altered = true;
       break;
     default:
       NOTIMPLEMENTED() << "invalid code for EV_KEY: " << input.code;
   }
 }
 
 void TouchEventConverterEvdev::ProcessAbs(const input_event& input) {
   switch (input.code) {
     case ABS_MT_TOUCH_MAJOR:
       // TODO(spang): If we have all of major, minor, and orientation,
       // we can scale the ellipse correctly. However on the Pixel we get
       // neither minor nor orientation, so this is all we can do.
       events_[current_slot_].radius_x = input.value / 2.0f;
+
+      // The MT protocol cannot communicate cancelled touches, so some kernel
+      // drivers will identify palms by setting touch major to max.
+      events_[current_slot_].is_palm = (input.value == major_max_);
       break;
     case ABS_MT_TOUCH_MINOR:
       events_[current_slot_].radius_y = input.value / 2.0f;
       break;
     case ABS_MT_POSITION_X:
       events_[current_slot_].x = input.value;
       break;
     case ABS_MT_POSITION_Y:
       events_[current_slot_].y = input.value;
       break;
@@ skipping 32 matching lines @@
     default:
       NOTIMPLEMENTED() << "invalid code for EV_SYN: " << input.code;
   }
 }
 
 EventType TouchEventConverterEvdev::GetEventTypeForTouch(
     const InProgressTouchEvdev& touch) {
   if (touch.cancelled)
     return ET_UNKNOWN;
 
+  if (touch.is_palm) {
+    if (touch.touching && !touch.was_touching)
+      return ET_UNKNOWN;
+    return ET_TOUCH_CANCELLED;
+  }
+
   if (touch_noise_finder_ && touch_noise_finder_->SlotHasNoise(touch.slot)) {
     if (touch.touching && !touch.was_touching)
       return ET_UNKNOWN;
     return ET_TOUCH_CANCELLED;
   }
 
   if (touch.touching)
     return touch.was_touching ? ET_TOUCH_MOVED : ET_TOUCH_PRESSED;
   return touch.was_touching ? ET_TOUCH_RELEASED : ET_UNKNOWN;
 }
 
 void TouchEventConverterEvdev::ReportTouchEvent(
     const InProgressTouchEvdev& event,
     EventType event_type,
     base::TimeTicks timestamp) {
-  dispatcher_->DispatchTouchEvent(TouchEventParams(
-      input_device_.id, event.slot, event_type, gfx::PointF(event.x, event.y),
-      GetEventPointerDetails(event), timestamp));
+  TouchEventParams params(input_device_.id, event.slot, event_type,
+                          gfx::PointF(event.x, event.y),
+                          GetEventPointerDetails(event), timestamp);
+  if (!palm_filter_ || palm_filter_->FilterTouch(params))

[spang, 2016/08/23 23:32:29]

I'm nervous about putting filtering this late because it's fairly hard to see
that it's not filtering out cancels, lifts of slots, or generally any events
which are necessary to keep downstream code in sync.

The decision about what type of event to send to get the client into the desired
state happens a bit earlier, in GetEventTypeForTouch(). We should change that
code to decide "cancel" for any filtering we need, including  suppression of all
contacts while a stylus is in range.

I think you just need to do something like:

   bool is_noise = touch_noise_finder_ &&
touch_noise_finder_->SlotHasNoise(touch.slot);
   bool is_palm = touch.is_palm || (palm_filter_ &&
palm_filter_->FilterTouch(touch));

   if (is_noise || is_palm) {
      // Cancel this touch.
      if (touch.touching && !touch.was_touching)
        return ET_UNKNOWN;
      return ET_TOUCH_CANCELLED;
    }

+    dispatcher_->DispatchTouchEvent(params);
 }
 
 void TouchEventConverterEvdev::ReportStylusEvent(
     const InProgressTouchEvdev& event,
     base::TimeTicks timestamp) {
   if (event.btn_left.changed)
     ReportButton(BTN_LEFT, event.btn_left.down, event, timestamp);
   if (event.btn_right.changed)
     ReportButton(BTN_RIGHT, event.btn_right.down, event, timestamp);
   if (event.btn_middle.changed)
@@ skipping 20 matching lines @@
   }
 
   if (touch_noise_finder_)
     touch_noise_finder_->HandleTouches(events_, timestamp);
 
   for (size_t i = 0; i < events_.size(); i++) {
     InProgressTouchEvdev* event = &events_[i];
     if (!event->altered)
       continue;
 
+    if (has_pen_ && palm_filter_) {
+      palm_filter_->EnableSuppression(event->tool_code > 0, timestamp);
+    }
+
     if (event->tool_code > 0) {
       ReportStylusEvent(*event, timestamp);
     } else {
       EventType event_type = GetEventTypeForTouch(*event);
       if (event_type == ET_UNKNOWN || event_type == ET_TOUCH_CANCELLED)
         event->cancelled = true;
 
       if (event_type != ET_UNKNOWN)
         ReportTouchEvent(*event, event_type, timestamp);
     }
@@ skipping 53 matching lines @@
   if (pressure_max_ - pressure_min_)
     pressure /= pressure_max_ - pressure_min_;
   return pressure;
 }
 
 int TouchEventConverterEvdev::NextTrackingId() {
   return next_tracking_id_++ & kMaxTrackingId;
 }
 
 }  // namespace ui