ozone: evdev: Add gamepad support

ui/events/ozone/evdev/input_device_factory_evdev.cc

 // Copyright 2015 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/input_device_factory_evdev.h"
 
 #include <fcntl.h>
 #include <linux/input.h>
 #include <stddef.h>
 
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/threading/worker_pool.h"
 #include "base/time/time.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/ozone/evdev/device_event_dispatcher_evdev.h"
 #include "ui/events/ozone/evdev/event_converter_evdev_impl.h"
 #include "ui/events/ozone/evdev/event_device_info.h"
+#include "ui/events/ozone/evdev/gamepad_event_converter_evdev.h"
 #include "ui/events/ozone/evdev/tablet_event_converter_evdev.h"
 #include "ui/events/ozone/evdev/touch_event_converter_evdev.h"
+#include "ui/events/ozone/gamepad/gamepad_provider_ozone.h"
 
 #if defined(USE_EVDEV_GESTURES)
 #include "ui/events/ozone/evdev/libgestures_glue/event_reader_libevdev_cros.h"
 #include "ui/events/ozone/evdev/libgestures_glue/gesture_feedback.h"
 #include "ui/events/ozone/evdev/libgestures_glue/gesture_interpreter_libevdev_cros.h"
 #include "ui/events/ozone/evdev/libgestures_glue/gesture_property_provider.h"
 #endif
 
 #ifndef EVIOCSCLOCKID
 #define EVIOCSCLOCKID _IOW('E', 0xa0, int)
@@ skipping 71 matching lines @@
     converter->Initialize(devinfo);
     return std::move(converter);
   }
 
   // Graphics tablet
   if (devinfo.HasTablet())
     return base::WrapUnique<EventConverterEvdev>(new TabletEventConverterEvdev(
         std::move(fd), params.path, params.id, params.cursor, devinfo,
         params.dispatcher));
 
+  if (devinfo.HasGamepad()) {
+    return base::WrapUnique<EventConverterEvdev>(new GamepadEventConverterEvdev(
+        std::move(fd), params.path, params.id, devinfo, params.dispatcher));
+  }
+
   // Everything else: use EventConverterEvdevImpl.
   return base::WrapUnique<EventConverterEvdevImpl>(
       new EventConverterEvdevImpl(std::move(fd), params.path, params.id,
                                   devinfo, params.cursor, params.dispatcher));
 }
 
 // Open an input device and construct an EventConverterEvdev.
 std::unique_ptr<EventConverterEvdev> OpenInputDevice(
     const OpenInputDeviceParams& params) {
   const base::FilePath& path = params.path;
@@ skipping 234 matching lines @@
     touchscreen_list_dirty_ = true;
 
   if (converter->HasKeyboard())
     keyboard_list_dirty_ = true;
 
   if (converter->HasMouse())
     mouse_list_dirty_ = true;
 
   if (converter->HasTouchpad())
     touchpad_list_dirty_ = true;
+
+  if (converter->HasGamepad())
+    gamepad_list_dirty_ = true;
 }
 
 void InputDeviceFactoryEvdev::NotifyDevicesUpdated() {
   if (!startup_devices_enumerated_ || pending_device_changes_)
     return;  // No update until full scan done and no pending operations.
   if (touchscreen_list_dirty_)
     NotifyTouchscreensUpdated();
   if (keyboard_list_dirty_)
     NotifyKeyboardsUpdated();
   if (mouse_list_dirty_)
     NotifyMouseDevicesUpdated();
   if (touchpad_list_dirty_)
     NotifyTouchpadDevicesUpdated();
+  if (gamepad_list_dirty_)
+    NotifyGamepadDevicesUpdated();
   if (!startup_devices_opened_) {
     dispatcher_->DispatchDeviceListsComplete();
     startup_devices_opened_ = true;
   }
   touchscreen_list_dirty_ = false;
   keyboard_list_dirty_ = false;
   mouse_list_dirty_ = false;
   touchpad_list_dirty_ = false;
+  gamepad_list_dirty_ = false;
 }
 
 void InputDeviceFactoryEvdev::NotifyTouchscreensUpdated() {
   std::vector<TouchscreenDevice> touchscreens;
   for (auto it = converters_.begin(); it != converters_.end(); ++it) {
     if (it->second->HasTouchscreen()) {
       TouchscreenDevice device(it->second->input_device(),
           it->second->GetTouchscreenSize(), it->second->GetTouchPoints());
       if (it->second->HasPen())
         device.is_stylus = true;
@@ skipping 30 matching lines @@
   std::vector<InputDevice> touchpads;
   for (auto it = converters_.begin(); it != converters_.end(); ++it) {
     if (it->second->HasTouchpad()) {
       touchpads.push_back(it->second->input_device());
     }
   }
 
   dispatcher_->DispatchTouchpadDevicesUpdated(touchpads);
 }
 
+void InputDeviceFactoryEvdev::NotifyGamepadDevicesUpdated() {
+  std::vector<InputDevice> gamepads;
+  for (auto it = converters_.begin(); it != converters_.end(); ++it) {
+    if (it->second->HasGamepad()) {
+      gamepads.push_back(it->second->input_device());
+    }
+  }
+
+  dispatcher_->DispatchGamepadDevicesUpdated(gamepads);
+}
+
 void InputDeviceFactoryEvdev::SetIntPropertyForOneType(
     const EventDeviceType type,
     const std::string& name,
     int value) {
 #if defined(USE_EVDEV_GESTURES)
   std::vector<int> ids;
   gesture_property_provider_->GetDeviceIdsByType(type, &ids);
   for (size_t i = 0; i < ids.size(); ++i) {
     SetGestureIntProperty(gesture_property_provider_.get(), ids[i], name,
                           value);
@@ skipping 22 matching lines @@
   if (enabled == palm_suppression_enabled_)
     return;
   palm_suppression_enabled_ = enabled;
 
   for (const auto& it : converters_) {
     it.second->SetEnabled(IsDeviceEnabled(it.second.get()));
   }
 }
 
 }  // namespace ui