Support pen in TouchEventConverterEvdev

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 60 matching lines @@
       return ABS_MT_POSITION_Y;
     case ABS_PRESSURE:
       return ABS_MT_PRESSURE;
     case ABS_DISTANCE:
       return ABS_MT_DISTANCE;
     default:
       return -1;
   }
 }
 
-ui::EventPointerType GetPointerTypeFromEvent(
+ui::PointerDetails GetEventPointerDetails(
     const ui::InProgressTouchEvdev& event) {
-  return (event.tool_code == BTN_TOOL_PEN)
-             ? ui::EventPointerType::POINTER_TYPE_PEN
-             : ui::EventPointerType::POINTER_TYPE_TOUCH;
+  ui::EventPointerType type;
+  switch (event.tool_code) {
+    case BTN_TOOL_PEN:
+      type = ui::EventPointerType::POINTER_TYPE_PEN;
+      break;
+    default:
+      type = ui::EventPointerType::POINTER_TYPE_TOUCH;
+  }
+  return ui::PointerDetails(type, event.radius_x, event.radius_y,
+                            event.pressure,
+                            /* tilt_x */ 0.0f,
+                            /* tilt_y */ 0.0f);
 }
 
 const int kTrackingIdForUnusedSlot = -1;
 
 }  // namespace
 
 namespace ui {
 
 TouchEventConverterEvdev::TouchEventConverterEvdev(
     int fd,
@@ skipping 54 matching lines @@
     x_num_tuxels_ -= cal.bezel_left + cal.bezel_right;
     y_min_tuxels_ += cal.bezel_top;
     y_num_tuxels_ -= cal.bezel_top + cal.bezel_bottom;
 
     VLOG(1) << "applying touch calibration: "
             << base::StringPrintf("[%d, %d, %d, %d]", cal.bezel_left,
                                   cal.bezel_right, cal.bezel_top,
                                   cal.bezel_bottom);
   }
 
+  // TODO(denniskempin): Use EVIOCGKEY to synchronize key state.
+
   events_.resize(touch_points_);
 
   if (has_mt_) {
     for (size_t i = 0; i < events_.size(); ++i) {
       events_[i].x = info.GetAbsMtSlotValueWithDefault(ABS_MT_POSITION_X, i, 0);
       events_[i].y = info.GetAbsMtSlotValueWithDefault(ABS_MT_POSITION_Y, i, 0);
       events_[i].tracking_id = info.GetAbsMtSlotValueWithDefault(
           ABS_MT_TRACKING_ID, i, kTrackingIdForUnusedSlot);
       events_[i].touching = (events_[i].tracking_id >= 0);
       events_[i].slot = i;
@@ skipping 20 matching lines @@
     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;
   }
 }
 
 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;
 }
 
 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();
 }
 
 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 71 matching lines @@
           event.value ? NextTrackingId() : kTrackingIdForUnusedSlot;
       ProcessMultitouchEvent(emulated_event);
     }
   }
 }
 
 void TouchEventConverterEvdev::ProcessKey(const input_event& input) {
   switch (input.code) {
     case BTN_TOUCH:
     case BTN_LEFT:
+      events_[current_slot_].btn_left.down = input.value;
+      events_[current_slot_].btn_left.changed = true;
+      break;
+    case BTN_STYLUS:
+      events_[current_slot_].btn_right.down = input.value;
+      events_[current_slot_].btn_right.changed = true;
+      break;
+    case BTN_STYLUS2:
+      events_[current_slot_].btn_middle.down = input.value;
+      events_[current_slot_].btn_middle.changed = true;
       break;
     case BTN_TOOL_PEN:
+      // 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;
       }
       break;
     default:
       NOTIMPLEMENTED() << "invalid code for EV_KEY: " << input.code;
   }
 }
@@ skipping 61 matching lines @@
     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::ReportEvent(const InProgressTouchEvdev& event,
-                                           EventType event_type,
-                                           base::TimeTicks timestamp) {
-  PointerDetails details(GetPointerTypeFromEvent(event), event.radius_x,
-                         event.radius_y, event.pressure,
-                         /* tilt_x */ 0.0f,
-                         /* tilt_y */ 0.0f);
-  dispatcher_->DispatchTouchEvent(
-      TouchEventParams(input_device_.id, event.slot, event_type,
-                       gfx::PointF(event.x, event.y), details, timestamp));
+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));
+}
+
+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)
+    ReportButton(BTN_MIDDLE, event.btn_middle.down, event, timestamp);
+
+  dispatcher_->DispatchMouseMoveEvent(MouseMoveEventParams(
+      input_device_.id, EF_DIRECT_INPUT, gfx::PointF(event.x, event.y),
+      GetEventPointerDetails(event), timestamp));
+}
+
+void TouchEventConverterEvdev::ReportButton(unsigned int button,
+                                            bool down,
+                                            const InProgressTouchEvdev& event,
+                                            base::TimeTicks timestamp) {
+  dispatcher_->DispatchMouseButtonEvent(MouseButtonEventParams(
+      input_device_.id, EF_DIRECT_INPUT, gfx::PointF(event.x, event.y), button,
+      down, false /* allow_remap */, GetEventPointerDetails(event), timestamp));
 }
 
 void TouchEventConverterEvdev::ReportEvents(base::TimeTicks timestamp) {
   if (dropped_events_) {
     Reinitialize();
     dropped_events_ = false;
   }
 
   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;
 
-    EventType event_type = GetEventTypeForTouch(*event);
-    if (event_type == ET_UNKNOWN || event_type == ET_TOUCH_CANCELLED)
-      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)
-      ReportEvent(*event, event_type, timestamp);
+      if (event_type != ET_UNKNOWN)
+        ReportTouchEvent(*event, event_type, timestamp);
+    }
 
     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;
 }
 
 void TouchEventConverterEvdev::ReleaseTouches() {
   for (size_t slot = 0; slot < events_.size(); slot++)
     UpdateTrackingId(slot, kTrackingIdForUnusedSlot);
 
   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;
+      event->btn_left.changed = true;
+    }
+    if (event->btn_right.down) {
+      event->btn_right.down = false;
+      event->btn_right.changed = true;
+    }
+    if (event->btn_middle.down) {
+      event->btn_middle.down = false;
+      event->btn_middle.changed = true;
+    }
+  }
+
+  ReportEvents(EventTimeForNow());
+}
+
 float TouchEventConverterEvdev::ScalePressure(int32_t value) {
   float pressure = value - pressure_min_;
   if (pressure_max_ - pressure_min_)
     pressure /= pressure_max_ - pressure_min_;
   return pressure;
 }
 
 int TouchEventConverterEvdev::NextTrackingId() {
   return next_tracking_id_++ & kMaxTrackingId;
 }
 
 }  // namespace ui