chromium/ui/events/ozone/evdev/gamepad_event_converter_evdev.cc

// Copyright 2017 The Chromium Authors
// 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/gamepad_event_converter_evdev.h"

#include <errno.h>
#include <linux/input.h>
#include <stddef.h>
#include <stdint.h>
#include <sys/ioctl.h>

#include "base/logging.h"
#include "base/posix/eintr_wrapper.h"
#include "base/trace_event/trace_event.h"
#include "ui/events/event_utils.h"
#include "ui/events/ozone/evdev/device_event_dispatcher_evdev.h"
#include "ui/events/ozone/gamepad/gamepad_event.h"
#include "ui/events/ozone/gamepad/gamepad_provider_ozone.h"

namespace {
constexpr int kInvalidEffectId = …;
}

namespace ui {

GamepadEventConverterEvdev::GamepadEventConverterEvdev(
    base::ScopedFD fd,
    base::FilePath path,
    int id,
    const EventDeviceInfo& devinfo,
    DeviceEventDispatcherEvdev* dispatcher)
    : … { … }

GamepadEventConverterEvdev::~GamepadEventConverterEvdev() { … }

bool GamepadEventConverterEvdev::HasGamepad() const { … }

void GamepadEventConverterEvdev::PlayVibrationEffect(uint8_t amplitude,
                                                     uint16_t duration_millis) { … }

void GamepadEventConverterEvdev::StopVibration() { … }

int GamepadEventConverterEvdev::StoreRumbleEffect(const base::ScopedFD& fd,
                                                  int effect_id,
                                                  uint16_t duration,
                                                  uint16_t start_delay,
                                                  uint16_t strong_magnitude,
                                                  uint16_t weak_magnitude) { … }

void GamepadEventConverterEvdev::StartOrStopEffect(const base::ScopedFD& fd,
                                                   int effect_id,
                                                   bool do_start) { … }

void GamepadEventConverterEvdev::DestroyEffect(const base::ScopedFD& fd,
                                               int effect_id) { … }

ssize_t GamepadEventConverterEvdev::WriteEvent(
    const base::ScopedFD& fd,
    const struct input_event& event) { … }

int GamepadEventConverterEvdev::UploadFfEffect(const base::ScopedFD& fd,
                                               struct ff_effect* effect) { … }

void GamepadEventConverterEvdev::OnFileCanReadWithoutBlocking(int fd) { … }
void GamepadEventConverterEvdev::OnDisabled() { … }

std::vector<ui::GamepadDevice::Axis>
GamepadEventConverterEvdev::GetGamepadAxes() const { … }

bool GamepadEventConverterEvdev::GetGamepadRumbleCapability() const { … }

std::vector<uint64_t> GamepadEventConverterEvdev::GetGamepadKeyBits() const { … }

void GamepadEventConverterEvdev::ProcessEvent(const input_event& evdev_ev) { … }

void GamepadEventConverterEvdev::ProcessEvdevKey(
    uint16_t code,
    int value,
    const base::TimeTicks& timestamp) { … }

void GamepadEventConverterEvdev::ProcessEvdevAbs(
    uint16_t code,
    int value,
    const base::TimeTicks& timestamp) { … }

void GamepadEventConverterEvdev::ResetGamepad() { … }

void GamepadEventConverterEvdev::ResyncGamepad() { … }

void GamepadEventConverterEvdev::OnSync(const base::TimeTicks& timestamp) { … }

std::ostream& GamepadEventConverterEvdev::DescribeForLog(
    std::ostream& os) const { … }

}  //  namespace ui