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 111 matching lines @@
     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;
     touch_points_ = 1;
+    major_max_ = 0;
     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 = {};
     GetTouchCalibration(&cal);
@@ skipping 20 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].cancelled = (major_max_ > 0 && touch_major == major_max_);
     }
   } 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].cancelled = false;
   }
 }
 
 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 (enable_palm_suppression_callback_) {
+    enable_palm_suppression_callback_.Run(false);
+  }
 }
 
 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) {
     if (errno == EINTR || errno == EAGAIN)
       return;
     if (errno != ENODEV)
       PLOG(ERROR) << "error reading device " << path_.value();
     Stop();
     return;
   }
 
-  if (!enabled_) {
-    dropped_events_ = true;
-    return;
-  }
-
   for (unsigned i = 0; i < read_size / sizeof(*inputs); i++) {
     if (!has_mt_) {
       // Emulate the device as an MT device with only 1 slot by inserting extra
       // MT protocol events in the stream.
       EmulateMultitouchEvent(inputs[i]);
     }
 
     ProcessMultitouchEvent(inputs[i]);
   }
 }
 
 void TouchEventConverterEvdev::DumpTouchEventLog(const char* filename) {
   touch_evdev_debug_buffer_.DumpLog(filename);
 }
 
 void TouchEventConverterEvdev::SetTouchEventLoggingEnabled(bool enabled) {
   touch_logging_enabled_ = enabled;
 }
 
+void TouchEventConverterEvdev::SetPalmSuppressionCallback(
+    const base::Callback<void(bool)>& callback) {
+  enable_palm_suppression_callback_ = callback;
+}
+
 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 53 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.
+      if (major_max_ > 0 && input.value == major_max_)
+        events_[current_slot_].cancelled = true;
       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 29 matching lines @@
       // 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)
+  if (touch.was_cancelled)
     return ET_UNKNOWN;
 
-  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.cancelled)
+    return touch.was_touching ? ET_TOUCH_CANCELLED : ET_UNKNOWN;
 
   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) {
@@ skipping 33 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 (enable_palm_suppression_callback_)
+      enable_palm_suppression_callback_.Run(event->tool_code > 0);
+
+    if (touch_noise_finder_ && touch_noise_finder_->SlotHasNoise(event->slot))
+      event->cancelled = true;
+
     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);
     }
 
+    event->was_cancelled = event->cancelled;
     event->was_touching = event->touching;
     event->altered = false;
     event->btn_left.changed = false;
     event->btn_right.changed = false;
     event->btn_middle.changed = false;
   }
 }
 
 void TouchEventConverterEvdev::UpdateTrackingId(int slot, int tracking_id) {
   InProgressTouchEvdev* event = &events_[slot];
 
   if (event->tracking_id == tracking_id)
     return;
 
   event->tracking_id = tracking_id;
   event->touching = (tracking_id >= 0);
   event->altered = true;
 
-  if (tracking_id >= 0)
-    event->cancelled = false;
+  if (tracking_id >= 0) {
+    event->was_cancelled = false;
+    event->cancelled = !enabled_;
+  }
 }
 
 void TouchEventConverterEvdev::ReleaseTouches() {
-  for (size_t slot = 0; slot < events_.size(); slot++)
-    UpdateTrackingId(slot, kTrackingIdForUnusedSlot);
+  for (size_t slot = 0; slot < events_.size(); slot++) {
+    events_[slot].cancelled = true;
+    events_[slot].altered = true;
+  }
 
   ReportEvents(EventTimeForNow());
 }
 
 void TouchEventConverterEvdev::ReleaseButtons() {
   for (size_t slot = 0; slot < events_.size(); slot++) {
     InProgressTouchEvdev* event = &events_[slot];
 
     if (event->btn_left.down) {
       event->btn_left.down = false;
@@ skipping 17 matching lines @@
   if (pressure_max_ - pressure_min_)
     pressure /= pressure_max_ - pressure_min_;
   return pressure;
 }
 
 int TouchEventConverterEvdev::NextTrackingId() {
   return next_tracking_id_++ & kMaxTrackingId;
 }
 
 }  // namespace ui