ozone: evdev: Add gamepad support

ui/events/event.h

 // Copyright (c) 2012 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.
 
 #ifndef UI_EVENTS_EVENT_H_
 #define UI_EVENTS_EVENT_H_
 
 #include <stdint.h>
 
 #include <memory>
@@ skipping 17 matching lines @@
 #include "ui/gfx/geometry/point_conversions.h"
 #include "ui/latency/latency_info.h"
 
 namespace gfx {
 class Transform;
 }
 
 namespace ui {
 class CancelModeEvent;
 class EventTarget;
+class GamepadEvent;
 class KeyEvent;
 class LocatedEvent;
 class MouseEvent;
 class MouseWheelEvent;
 class PointerEvent;
 class ScrollEvent;
 class TouchEvent;
 enum class DomCode;
 class Event;
 class MouseWheelEvent;
@@ skipping 62 matching lines @@
   bool IsControlDown() const { return (flags_ & EF_CONTROL_DOWN) != 0; }
   bool IsAltDown() const { return (flags_ & EF_ALT_DOWN) != 0; }
   bool IsCommandDown() const { return (flags_ & EF_COMMAND_DOWN) != 0; }
   bool IsAltGrDown() const { return (flags_ & EF_ALTGR_DOWN) != 0; }
   bool IsCapsLockOn() const { return (flags_ & EF_CAPS_LOCK_ON) != 0; }
 
   bool IsCancelModeEvent() const {
     return type_ == ET_CANCEL_MODE;
   }
 
+  bool IsGamepadEvent() const {
+    return type_ == ET_GAMEPAD_BTN_PRESSED ||
+           type_ == ET_GAMEPAD_BTN_RELEASED || type_ == ET_GAMEPAD_ABS_MOVED ||
+           type_ == ET_GAMEPAD_FRAME;
+  }
+
   bool IsKeyEvent() const {
     return type_ == ET_KEY_PRESSED || type_ == ET_KEY_RELEASED;
   }
 
   bool IsMouseEvent() const {
     return type_ == ET_MOUSE_PRESSED ||
            type_ == ET_MOUSE_DRAGGED ||
            type_ == ET_MOUSE_RELEASED ||
            type_ == ET_MOUSE_MOVED ||
            type_ == ET_MOUSE_ENTERED ||
@@ skipping 104 matching lines @@
   // IsCancelModeEvent() must be true as a precondition to calling these
   // methods.
   CancelModeEvent* AsCancelModeEvent();
   const CancelModeEvent* AsCancelModeEvent() const;
 
   // Convenience methods to cast |this| to a GestureEvent. IsGestureEvent()
   // must be true as a precondition to calling these methods.
   GestureEvent* AsGestureEvent();
   const GestureEvent* AsGestureEvent() const;
 
+  GamepadEvent* AsGamepadEvent();
+  const GamepadEvent* AsGamepadEvent() const;
+
   // Convenience methods to cast |this| to a KeyEvent. IsKeyEvent()
   // must be true as a precondition to calling these methods.
   KeyEvent* AsKeyEvent();
   const KeyEvent* AsKeyEvent() const;
 
   // Convenience methods to cast |this| to a LocatedEvent. IsLocatedEvent()
   // must be true as a precondition to calling these methods.
   LocatedEvent* AsLocatedEvent();
   const LocatedEvent* AsLocatedEvent() const;
 
@@ skipping 499 matching lines @@
 
   int changed_button_flags() const { return changed_button_flags_; }
   void set_changed_button_flags(int flags) { changed_button_flags_ = flags; }
   const PointerDetails& pointer_details() const { return details_; }
 
  private:
   int changed_button_flags_;
   PointerDetails details_;
 };
 
+// A Gamepad event is very straignt forward. It contains the event type,
+// timestamp, event code and value. The code and vaule should follow w3c
+// "standard" gamepad.
+class EVENTS_EXPORT GamepadEvent : public Event {
+ public:
+  GamepadEvent(EventType type,
+               double value,
+               uint16_t code,
+               base::TimeTicks timestamp);
+
+  GamepadEvent(const GamepadEvent& gamepad_event);
+
+  double get_value() const { return value_; }
+  uint16_t get_code() const { return code_; }
+
+ private:
+  double value_;
+  uint16_t code_;

[sadrul, 2017/04/12 18:03:58]

Can you document what |value_| and |code_| represent? I went over
https://www.w3.org/TR/gamepad/, and couldn't figure out their meaning.

[jkwang, 2017/04/12 20:51:55]

Interface is here.
interface Gamepad {
    readonly attribute DOMString           id;
    readonly attribute long                index;
    readonly attribute boolean             connected;
    readonly attribute DOMHighResTimeStamp timestamp;
    readonly attribute GamepadMappingType  mapping;
    readonly attribute double[]            axes;
    readonly attribute GamepadButton[]     buttons;
};

Code is the index of axes or button, value is the axes value or button value.
The meaning is defined in ui/events/webgamepad_constants.h	. I will add more
comments here.

+};

[sadrul, 2017/04/10 18:14:05]

I feel like this should simply be a PointerEvent, with type set to a new 
POINTER_TYPE_GAMEPAD.

[jkwang, 2017/04/10 18:19:08]

Would it be confusing?

[dtapuska, 2017/04/10 19:13:35]

Game pad logically has no pointer position does it?

Gamepad isn't combined in W3C land so I guess the question is what similarities
exist between a pointing device and a gamepad device. I think a keyboard might
have more similarities to a gamepad device than a pointer (keys dowm,
repetition, etc). So I'm on the fence. 

I think to be a pointer you need a logical x/y location presented by the
hwd/device. I don't think a gamepad device presents that.

[jkwang, 2017/04/10 20:07:47]

Mostly, gamepad report EV_ABS and EV_KEY. So mapping it to "generic axis moving"
and Key event won't be a bad idea. (If my memory is correct, it is what was done
in android.) However, the event_converter part of gamepad does not really fit
into the keyboard event_converter. To map gamepads to w3c standard, we sometimes
need to map axis to button. With that said, I did not find a "generic axis
event". AND, the w3c gamepad button carry a double value
(https://www.w3.org/TR/gamepad/ )! If we are going to reuse KeyEvent, we need to
do some invasive change. I really want to avoid that.

+
 // A KeyEvent is really two distinct classes, melded together due to the
 // DOM legacy of Windows key events: a keystroke event (is_char_ == false),
 // or a character event (is_char_ == true).
 //
 // For a keystroke event,
 // -- |bool is_char_| is false.
 // -- |EventType Event::type()| can be ET_KEY_PRESSED or ET_KEY_RELEASED.
 // -- |DomCode code_| and |int Event::flags()| represent the physical key event.
 //    - code_ is a platform-independent representation of the physical key,
 //      based on DOM UI Events KeyboardEvent |code| values. It does not
@@ skipping 275 matching lines @@
   // dispatched. This field gets a non-zero value only for gestures that are
   // released through TouchDispositionGestureFilter::SendGesture. The gesture
   // events that aren't fired directly in response to processing a touch-event
   // (e.g. timer fired ones), this id is zero. See crbug.com/618738.
   uint32_t unique_touch_event_id_;
 };
 
 }  // namespace ui
 
 #endif  // UI_EVENTS_EVENT_H_