// 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_keyboard_configuration.h"
#include <linux/input.h>
#include <wayland-server-core.h>
#include <wayland-server-protocol-core.h>
#include <xkbcommon/xkbcommon.h>
#include <string_view>
#include "ash/ime/ime_controller_impl.h"
#include "ash/shell.h"
#include "base/containers/contains.h"
#include "base/feature_list.h"
#include "base/memory/free_deleter.h"
#include "base/memory/raw_ptr.h"
#include "base/task/current_thread.h"
#include "base/task/thread_pool.h"
#include "components/exo/keyboard.h"
#include "components/exo/keyboard_device_configuration_delegate.h"
#include "components/exo/keyboard_observer.h"
#include "components/exo/wayland/server_util.h"
#include "ui/base/ime/ash/input_method_manager.h"
#include "ui/events/devices/device_data_manager.h"
#include "ui/events/devices/input_device_event_observer.h"
#include "ui/events/event_constants.h"
#include "ui/events/keycodes/scoped_xkb.h" // nogncheck
#include "ui/events/ozone/evdev/event_device_util.h"
#include "ui/events/ozone/layout/xkb/xkb_keyboard_layout_engine.h"
#include "ui/events/ozone/layout/xkb/xkb_modifier_converter.h"
#include "ui/ozone/public/input_controller.h"
#include "ui/ozone/public/ozone_platform.h"
namespace exo::wayland {
namespace {
////////////////////////////////////////////////////////////////////////////////
// keyboard_device_configuration interface:
class WaylandKeyboardDeviceConfigurationDelegate
: public ash::input_method::InputMethodManager::ImeMenuObserver,
public KeyboardDeviceConfigurationDelegate,
public KeyboardObserver,
public ash::ImeController::Observer,
public ui::InputDeviceEventObserver {
public:
WaylandKeyboardDeviceConfigurationDelegate(wl_resource* resource,
Keyboard* keyboard)
: resource_(resource), keyboard_(keyboard) {
keyboard_->SetDeviceConfigurationDelegate(this);
keyboard_->AddObserver(this);
ash::ImeControllerImpl* ime_controller =
ash::Shell::Get()->ime_controller();
ime_controller->AddObserver(this);
ui::DeviceDataManager::GetInstance()->AddObserver(this);
ash::input_method::InputMethodManager::Get()->AddImeMenuObserver(this);
// Call this once to setup initial installed keyboard layout data.
ImeMenuListChanged();
ProcessKeyBitsUpdate();
OnKeyboardLayoutNameChanged(ime_controller->keyboard_layout_name());
}
WaylandKeyboardDeviceConfigurationDelegate(
const WaylandKeyboardDeviceConfigurationDelegate&) = delete;
WaylandKeyboardDeviceConfigurationDelegate& operator=(
const WaylandKeyboardDeviceConfigurationDelegate&) = delete;
~WaylandKeyboardDeviceConfigurationDelegate() override {
ash::input_method::InputMethodManager::Get()->RemoveImeMenuObserver(this);
ui::DeviceDataManager::GetInstance()->RemoveObserver(this);
ash::Shell::Get()->ime_controller()->RemoveObserver(this);
if (keyboard_) {
keyboard_->SetDeviceConfigurationDelegate(nullptr);
keyboard_->RemoveObserver(this);
}
}
// Overridden from KeyboardObserver:
void OnKeyboardDestroying(Keyboard* keyboard) override {
keyboard_ = nullptr;
}
// Overridden from KeyboardDeviceConfigurationDelegate:
void OnKeyboardTypeChanged(bool is_physical) override {
zcr_keyboard_device_configuration_v1_send_type_change(
resource_,
is_physical
? ZCR_KEYBOARD_DEVICE_CONFIGURATION_V1_KEYBOARD_TYPE_PHYSICAL
: ZCR_KEYBOARD_DEVICE_CONFIGURATION_V1_KEYBOARD_TYPE_VIRTUAL);
wl_client_flush(client());
}
// Overridden from ImeController::Observer:
void OnCapsLockChanged(bool enabled) override {}
void OnKeyboardLayoutNameChanged(const std::string& layout_name) override {
zcr_keyboard_device_configuration_v1_send_layout_change(
resource_, layout_name.c_str());
wl_client_flush(client());
}
// Overridden from ui::InputDeviceEventObserver:
void OnInputDeviceConfigurationChanged(uint8_t input_device_types) override {
if (!(input_device_types & ui::InputDeviceEventObserver::kKeyboard)) {
return;
}
ProcessKeyBitsUpdate();
}
// ash::input_method::InputMethodManager::ImeMenuObserver:
void ImeMenuActivationChanged(bool) override {}
void ImeMenuListChanged() override {
// We'll scan ime list changes and notify if a new one was installed.
// However if we're not sending event to the client, we can return early.
if (wl_resource_get_version(resource_) <
ZCR_KEYBOARD_DEVICE_CONFIGURATION_V1_LAYOUT_INSTALL_SINCE_VERSION) {
return;
}
ash::input_method::InputMethodManager::State* state =
ash::input_method::InputMethodManager::Get()->GetActiveIMEState().get();
if (!state) {
return;
}
std::vector<ash::input_method::InputMethodDescriptor>
enabled_ime_descriptors = state->GetEnabledInputMethods();
for (const auto& descriptor : enabled_ime_descriptors) {
const std::string& keyboard_layout = descriptor.keyboard_layout();
if (!base::Contains(installed_keyboard_layouts_, keyboard_layout)) {
sequenced_task_runner_->PostTaskAndReplyWithResult(
FROM_HERE,
base::BindOnce(
&WaylandKeyboardDeviceConfigurationDelegate::GetXkbKeymap,
keyboard_layout),
base::BindOnce(&WaylandKeyboardDeviceConfigurationDelegate::
OnKeyboardLayoutInstalled,
weak_factory_.GetWeakPtr(), keyboard_layout));
}
}
installed_keyboard_layouts_.clear();
for (const auto& descriptor : enabled_ime_descriptors) {
const std::string& keyboard_layout = descriptor.keyboard_layout();
installed_keyboard_layouts_.insert(keyboard_layout);
}
}
void ImeMenuItemsChanged(
const std::string&,
const std::vector<ash::input_method::InputMethodManager::MenuItem>&)
override {}
private:
void OnKeyboardLayoutInstalled(
const std::string& layout_name,
std::unique_ptr<char, base::FreeDeleter> keymap_str) {
// Wayland methods should be run in UI Thread.
DCHECK(base::CurrentUIThread::IsSet());
std::string_view keymap = keymap_str.get();
// Send the content of |keymap| with trailing '\0' termination via shared
// memory.
base::UnsafeSharedMemoryRegion shared_keymap_region =
base::UnsafeSharedMemoryRegion::Create(keymap.size() + 1);
base::WritableSharedMemoryMapping shared_keymap =
shared_keymap_region.Map();
base::subtle::PlatformSharedMemoryRegion platform_shared_keymap =
base::UnsafeSharedMemoryRegion::TakeHandleForSerialization(
std::move(shared_keymap_region));
DCHECK(shared_keymap.IsValid());
std::memcpy(shared_keymap.memory(), keymap.data(), keymap.size());
static_cast<uint8_t*>(shared_keymap.memory())[keymap.size()] = '\0';
zcr_keyboard_device_configuration_v1_send_layout_install(
resource_, layout_name.c_str(), WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1,
platform_shared_keymap.GetPlatformHandle().fd, keymap.size() + 1);
wl_client_flush(client());
}
// Notify key bits update.
void ProcessKeyBitsUpdate() {
if (wl_resource_get_version(resource_) <
ZCR_KEYBOARD_DEVICE_CONFIGURATION_V1_SUPPORTED_KEY_BITS_SINCE_VERSION) {
return;
}
// Preparing wayland keybits.
wl_array wl_key_bits;
wl_array_init(&wl_key_bits);
size_t key_bits_len = EVDEV_BITS_TO_INT64(KEY_CNT) * 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) {
wl_array_release(&wl_key_bits);
return;
}
memset(wl_key_bits_ptr, 0, key_bits_len);
ui::InputController* input_controller =
ui::OzonePlatform::GetInstance()->GetInputController();
// Combine supported key bits from all keyboard into single key bits.
for (const ui::InputDevice& device :
ui::DeviceDataManager::GetInstance()->GetKeyboardDevices()) {
const std::vector<uint64_t>& key_bits =
input_controller->GetKeyboardKeyBits(device.id);
for (size_t i = 0; i < key_bits.size(); i++) {
wl_key_bits_ptr[i] |= key_bits[i];
}
}
zcr_keyboard_device_configuration_v1_send_supported_key_bits(resource_,
&wl_key_bits);
wl_array_release(&wl_key_bits);
wl_client_flush(client());
}
// This method shouldn't run on UI thread since it involves I/O operation.
static std::unique_ptr<char, base::FreeDeleter> GetXkbKeymap(
const std::string& layout_name) {
std::unique_ptr<xkb_context, ui::XkbContextDeleter> xkb_context{
xkb_context_new(XKB_CONTEXT_NO_FLAGS)};
std::string layout_id, layout_variant;
ui::XkbKeyboardLayoutEngine::ParseLayoutName(layout_name, &layout_id,
&layout_variant);
xkb_rule_names names = {.rules = nullptr,
.model = "pc101",
.layout = layout_id.c_str(),
.variant = layout_variant.c_str(),
.options = ""};
std::unique_ptr<xkb_keymap, ui::XkbKeymapDeleter> xkb_keymap(
xkb_keymap_new_from_names(xkb_context.get(), &names,
XKB_KEYMAP_COMPILE_NO_FLAGS));
return std::unique_ptr<char, base::FreeDeleter>(
xkb_keymap_get_as_string(xkb_keymap.get(), XKB_KEYMAP_FORMAT_TEXT_V1));
}
wl_client* client() const { return wl_resource_get_client(resource_); }
raw_ptr<wl_resource> resource_;
raw_ptr<Keyboard> keyboard_;
// List of acknowledged installed keyboard layouts. Used to determine if there
// are new keyboard layouts installed.
std::set<std::string> installed_keyboard_layouts_;
scoped_refptr<base::SequencedTaskRunner> sequenced_task_runner_{
base::ThreadPool::CreateSequencedTaskRunner(
{base::MayBlock(), base::TaskPriority::BEST_EFFORT})};
base::WeakPtrFactory<WaylandKeyboardDeviceConfigurationDelegate>
weak_factory_{this};
};
void keyboard_device_configuration_destroy(wl_client* client,
wl_resource* resource) {
wl_resource_destroy(resource);
}
const struct zcr_keyboard_device_configuration_v1_interface
keyboard_device_configuration_implementation = {
keyboard_device_configuration_destroy};
////////////////////////////////////////////////////////////////////////////////
// keyboard_configuration interface:
void keyboard_configuration_get_keyboard_device_configuration(
wl_client* client,
wl_resource* resource,
uint32_t id,
wl_resource* keyboard_resource) {
Keyboard* keyboard = GetUserDataAs<Keyboard>(keyboard_resource);
if (keyboard->HasDeviceConfigurationDelegate()) {
wl_resource_post_error(
resource,
ZCR_KEYBOARD_CONFIGURATION_V1_ERROR_DEVICE_CONFIGURATION_EXISTS,
"keyboard has already been associated with a device configuration "
"object");
return;
}
wl_resource* keyboard_device_configuration_resource = wl_resource_create(
client, &zcr_keyboard_device_configuration_v1_interface,
wl_resource_get_version(resource), id);
SetImplementation(
keyboard_device_configuration_resource,
&keyboard_device_configuration_implementation,
std::make_unique<WaylandKeyboardDeviceConfigurationDelegate>(
keyboard_device_configuration_resource, keyboard));
}
const struct zcr_keyboard_configuration_v1_interface
keyboard_configuration_implementation = {
keyboard_configuration_get_keyboard_device_configuration};
} // namespace
void bind_keyboard_configuration(wl_client* client,
void* data,
uint32_t version,
uint32_t id) {
wl_resource* resource = wl_resource_create(
client, &zcr_keyboard_configuration_v1_interface,
std::min<uint32_t>(version,
zcr_keyboard_configuration_v1_interface.version),
id);
wl_resource_set_implementation(
resource, &keyboard_configuration_implementation, data, nullptr);
}
} // namespace exo::wayland
Codebase Browser
chromium