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);
@@ skipping 59 matching lines @@
     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;
   }
+
+  if (palm_filter_)
+    palm_filter_->Reset();
 }
 
 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,
@@ skipping 18 matching lines @@
       break;
     case ABS_MT_SLOT:
       if (input.value >= 0 &&
           static_cast<size_t>(input.value) < events_.size()) {
         current_slot_ = input.value;
       } else {
         LOG(ERROR) << "invalid touch event index: " << input.value;
         return;
       }
       break;
+    case ABS_MT_TOOL_TYPE:
+      if (input.value == MT_TOOL_PALM)
+        events_[current_slot_].is_palm = true;
     default:
       DVLOG(5) << "unhandled code for EV_ABS: " << input.code;
       return;
   }
   events_[current_slot_].altered = true;
 }
 
 void TouchEventConverterEvdev::ProcessSyn(const input_event& input) {
   switch (input.code) {
     case SYN_REPORT:
       ReportEvents(EventConverterEvdev::TimeTicksFromInputEvent(input));
       break;
     case SYN_DROPPED:
       // Some buffer has overrun. We ignore all events up to and
       // including the next SYN_REPORT.
       dropped_events_ = true;
       break;
     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)
+    return ET_TOUCH_CANCELLED;
+
   if (touch_noise_finder_ && touch_noise_finder_->SlotHasNoise(touch.slot)) {
     if (touch.touching && !touch.was_touching)

[spang, 2016/08/22 20:52:13]

Do we need this same check so that a new slot doesn't report a cancel (which
would look spurious from client's perspective)?

Or does your check in ReportTouchEvent() handle that?

[denniskempin, 2016/08/23 22:28:12]

Done.

       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))
+    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