// Copyright 2018 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifdef UNSAFE_BUFFERS_BUILD
// TODO(crbug.com/40285824): Remove this and convert code to safer constructs.
#pragma allow_unsafe_buffers
#endif
#include "components/exo/wayland/zcr_gaming_input.h"
#include <gaming-input-unstable-v2-server-protocol.h>
#include <wayland-server-core.h>
#include <wayland-server-protocol-core.h>
#include <memory>
#include "base/feature_list.h"
#include "base/memory/raw_ptr.h"
#include "components/exo/gamepad.h"
#include "components/exo/gamepad_delegate.h"
#include "components/exo/gamepad_observer.h"
#include "components/exo/gaming_seat.h"
#include "components/exo/gaming_seat_delegate.h"
#include "components/exo/wayland/server_util.h"
#include "ui/events/devices/gamepad_device.h"
namespace exo {
namespace wayland {
namespace {
unsigned int GetGamepadBusType(ui::InputDeviceType type) {
switch (type) {
case ui::INPUT_DEVICE_BLUETOOTH:
return ZCR_GAMING_SEAT_V2_BUS_TYPE_BLUETOOTH;
default:
// Internal and unknown types also default to USB.
return ZCR_GAMING_SEAT_V2_BUS_TYPE_USB;
}
}
////////////////////////////////////////////////////////////////////////////////
// gaming_input_interface:
// Handles the vibration requests sent by the client for a gamepad.
class WaylandGamepadVibratorImpl : public GamepadObserver {
public:
explicit WaylandGamepadVibratorImpl(Gamepad* gamepad) : gamepad_(gamepad) {
gamepad_->AddObserver(this);
}
WaylandGamepadVibratorImpl(const WaylandGamepadVibratorImpl& other) = delete;
WaylandGamepadVibratorImpl& operator=(
const WaylandGamepadVibratorImpl& other) = delete;
~WaylandGamepadVibratorImpl() override {
if (gamepad_)
gamepad_->RemoveObserver(this);
}
void OnVibrate(wl_array* duration_millis,
wl_array* amplitudes,
int32_t repeat) {
std::vector<int64_t> extracted_durations;
int64_t* p;
const uint8_t* duration_millis_end =
static_cast<uint8_t*>(duration_millis->data) + duration_millis->size;
for (p = static_cast<int64_t*>(duration_millis->data);
(const uint8_t*)p < duration_millis_end; p++) {
extracted_durations.emplace_back(*p);
}
const uint8_t* amplitudes_start = static_cast<uint8_t*>(amplitudes->data);
size_t amplitude_size = amplitudes->size / sizeof(uint8_t);
const uint8_t* amplitudes_end = amplitudes_start + amplitude_size;
std::vector<uint8_t> extracted_amplitudes(amplitudes_start, amplitudes_end);
if (gamepad_)
gamepad_->Vibrate(extracted_durations, extracted_amplitudes, repeat);
}
void OnCancelVibration() {
if (gamepad_)
gamepad_->CancelVibration();
}
// Overridden from GamepadObserver
void OnGamepadDestroying(Gamepad* gamepad) override {
DCHECK_EQ(gamepad_, gamepad);
gamepad_ = nullptr;
}
private:
raw_ptr<Gamepad> gamepad_;
};
void gamepad_vibrator_vibrate(wl_client* client,
wl_resource* resource,
wl_array* duration_millis,
wl_array* amplitudes,
int32_t repeat) {
GetUserDataAs<WaylandGamepadVibratorImpl>(resource)->OnVibrate(
duration_millis, amplitudes, repeat);
}
void gamepad_vibrator_cancel_vibration(wl_client* client,
wl_resource* resource) {
GetUserDataAs<WaylandGamepadVibratorImpl>(resource)->OnCancelVibration();
}
void gamepad_vibrator_destroy(wl_client* client, wl_resource* resource) {
wl_resource_destroy(resource);
}
const struct zcr_gamepad_vibrator_v2_interface gamepad_vibrator_implementation =
{gamepad_vibrator_vibrate, gamepad_vibrator_cancel_vibration,
gamepad_vibrator_destroy};
// Gamepad delegate class that forwards gamepad events to the client resource.
class WaylandGamepadDelegate : public GamepadDelegate {
public:
explicit WaylandGamepadDelegate(wl_resource* gamepad_resource)
: gamepad_resource_(gamepad_resource) {}
WaylandGamepadDelegate(const WaylandGamepadDelegate&) = delete;
WaylandGamepadDelegate& operator=(const WaylandGamepadDelegate&) = delete;
~WaylandGamepadDelegate() override = default;
// If gamepad_resource_ is destroyed first, ResetGamepadResource will
// be called to remove the resource from delegate, and delegate won't
// do anything after that. If delegate is destructed first, it will
// set the data to null in the gamepad_resource_, then the resource
// destroy won't reset the delegate (cause it's gone).
static void ResetGamepadResource(wl_resource* resource) {
WaylandGamepadDelegate* delegate =
GetUserDataAs<WaylandGamepadDelegate>(resource);
if (delegate) {
delegate->gamepad_resource_ = nullptr;
}
}
// Override from GamepadDelegate:
void OnRemoved() override {
if (!gamepad_resource_) {
return;
}
zcr_gamepad_v2_send_removed(gamepad_resource_);
wl_client_flush(client());
// Reset the user data in gamepad_resource.
wl_resource_set_user_data(gamepad_resource_, nullptr);
}
void OnAxis(int axis, double value, base::TimeTicks time_stamp) override {
if (!gamepad_resource_) {
return;
}
zcr_gamepad_v2_send_axis(gamepad_resource_,
TimeTicksToMilliseconds(time_stamp), axis,
wl_fixed_from_double(value));
}
void OnButton(int button, bool pressed, base::TimeTicks time_stamp) override {
if (!gamepad_resource_) {
return;
}
uint32_t state = pressed ? ZCR_GAMEPAD_V2_BUTTON_STATE_PRESSED
: ZCR_GAMEPAD_V2_BUTTON_STATE_RELEASED;
zcr_gamepad_v2_send_button(gamepad_resource_,
TimeTicksToMilliseconds(time_stamp), button,
state, wl_fixed_from_double(0));
}
void OnFrame(base::TimeTicks time_stamp) override {
if (!gamepad_resource_) {
return;
}
zcr_gamepad_v2_send_frame(gamepad_resource_,
TimeTicksToMilliseconds(time_stamp));
wl_client_flush(client());
}
void ConfigureDevice(Gamepad* gamepad) {
for (const auto& axis : gamepad->device.axes) {
zcr_gamepad_v2_send_axis_added(gamepad_resource_, axis.code,
axis.min_value, axis.max_value, axis.flat,
axis.fuzz, axis.resolution);
}
if (gamepad->device.supports_vibration_rumble &&
wl_resource_get_version(gamepad_resource_) >=
ZCR_GAMEPAD_V2_VIBRATOR_ADDED_SINCE_VERSION) {
wl_resource* gamepad_vibrator_resource =
wl_resource_create(wl_resource_get_client(gamepad_resource_),
&zcr_gamepad_vibrator_v2_interface,
wl_resource_get_version(gamepad_resource_), 0);
SetImplementation(gamepad_vibrator_resource,
&gamepad_vibrator_implementation,
std::make_unique<WaylandGamepadVibratorImpl>(gamepad));
zcr_gamepad_v2_send_vibrator_added(gamepad_resource_,
gamepad_vibrator_resource);
}
if (wl_resource_get_version(gamepad_resource_) >=
ZCR_GAMEPAD_V2_SUPPORTED_KEY_BITS_SINCE_VERSION) {
// Sending key_bits.
wl_array wl_key_bits;
wl_array_init(&wl_key_bits);
std::vector<uint64_t> key_bits =
ui::OzonePlatform::GetInstance()
->GetInputController()
->GetGamepadKeyBits(gamepad->device.id);
size_t key_bits_len = key_bits.size() * sizeof(uint64_t);
uint64_t* wl_key_bits_ptr =
static_cast<uint64_t*>(wl_array_add(&wl_key_bits, key_bits_len));
if (wl_key_bits_ptr) {
memcpy(wl_key_bits_ptr, key_bits.data(), key_bits_len);
zcr_gamepad_v2_send_supported_key_bits(gamepad_resource_, &wl_key_bits);
}
wl_array_release(&wl_key_bits);
}
zcr_gamepad_v2_send_activated(gamepad_resource_);
}
private:
// The client who own this gamepad instance.
wl_client* client() const {
return wl_resource_get_client(gamepad_resource_);
}
// The gamepad resource associated with the gamepad.
raw_ptr<wl_resource> gamepad_resource_;
};
void gamepad_destroy(wl_client* client, wl_resource* resource) {
wl_resource_destroy(resource);
}
const struct zcr_gamepad_v2_interface gamepad_implementation = {
gamepad_destroy};
// GamingSeat delegate that provide gamepad added.
class WaylandGamingSeatDelegate : public GamingSeatDelegate {
public:
explicit WaylandGamingSeatDelegate(wl_resource* gaming_seat_resource)
: gaming_seat_resource_{gaming_seat_resource} {}
WaylandGamingSeatDelegate(const WaylandGamingSeatDelegate&) = delete;
WaylandGamingSeatDelegate& operator=(const WaylandGamingSeatDelegate&) =
delete;
// Override from GamingSeatDelegate:
void OnGamingSeatDestroying(GamingSeat*) override { delete this; }
bool CanAcceptGamepadEventsForSurface(Surface* surface) const override {
wl_resource* surface_resource = GetSurfaceResource(surface);
return surface_resource &&
wl_resource_get_client(surface_resource) ==
wl_resource_get_client(gaming_seat_resource_);
}
void GamepadAdded(Gamepad& gamepad) override {
wl_resource* gamepad_resource =
wl_resource_create(wl_resource_get_client(gaming_seat_resource_),
&zcr_gamepad_v2_interface,
wl_resource_get_version(gaming_seat_resource_), 0);
zcr_gaming_seat_v2_send_gamepad_added_with_device_info(
gaming_seat_resource_, gamepad_resource, gamepad.device.name.c_str(),
GetGamepadBusType(gamepad.device.type), gamepad.device.vendor_id,
gamepad.device.product_id, gamepad.device.version);
std::unique_ptr<WaylandGamepadDelegate> gamepad_delegate =
std::make_unique<WaylandGamepadDelegate>(gamepad_resource);
wl_resource_set_implementation(
gamepad_resource, &gamepad_implementation, gamepad_delegate.get(),
&WaylandGamepadDelegate::ResetGamepadResource);
gamepad_delegate->ConfigureDevice(&gamepad);
gamepad.SetDelegate(std::move(gamepad_delegate));
wl_client_flush(wl_resource_get_client(gaming_seat_resource_));
}
private:
// The gaming seat resource associated with the gaming seat.
const raw_ptr<wl_resource> gaming_seat_resource_;
};
void gaming_seat_destroy(wl_client* client, wl_resource* resource) {
wl_resource_destroy(resource);
}
const struct zcr_gaming_seat_v2_interface gaming_seat_implementation = {
gaming_seat_destroy};
void gaming_input_get_gaming_seat(wl_client* client,
wl_resource* resource,
uint32_t id,
wl_resource* seat) {
wl_resource* gaming_seat_resource =
wl_resource_create(client, &zcr_gaming_seat_v2_interface,
wl_resource_get_version(resource), id);
SetImplementation(gaming_seat_resource, &gaming_seat_implementation,
std::make_unique<GamingSeat>(
new WaylandGamingSeatDelegate(gaming_seat_resource)));
}
void gaming_input_destroy(wl_client* client, wl_resource* resource) {
wl_resource_destroy(resource);
}
const struct zcr_gaming_input_v2_interface gaming_input_implementation = {
gaming_input_get_gaming_seat, gaming_input_destroy};
} // namespace
void bind_gaming_input(wl_client* client,
void* data,
uint32_t version,
uint32_t id) {
wl_resource* resource =
wl_resource_create(client, &zcr_gaming_input_v2_interface, version, id);
wl_resource_set_implementation(resource, &gaming_input_implementation,
nullptr, nullptr);
}
} // namespace wayland
} // namespace exo
Codebase Browser
chromium