blob: 309477fd2b550236fe9dae3b9e94f4e6b1a9509c [file] [log] [blame]
// Copyright 2014 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/platform/x11/x11_hotplug_event_handler.h"
#include <stdint.h>
#include <X11/Xatom.h>
#include <X11/extensions/XInput.h>
#include <X11/extensions/XInput2.h>
#include <algorithm>
#include <cmath>
#include <set>
#include <string>
#include <vector>
#include "base/bind.h"
#include "base/command_line.h"
#include "base/location.h"
#include "base/logging.h"
#include "base/process/launch.h"
#include "base/single_thread_task_runner.h"
#include "base/strings/string_util.h"
#include "base/sys_info.h"
#include "base/thread_task_runner_handle.h"
#include "base/threading/worker_pool.h"
#include "ui/events/devices/device_data_manager.h"
#include "ui/events/devices/device_hotplug_event_observer.h"
#include "ui/events/devices/device_util_linux.h"
#include "ui/events/devices/input_device.h"
#include "ui/events/devices/keyboard_device.h"
#include "ui/events/devices/touchscreen_device.h"
#include "ui/gfx/x/x11_types.h"
#ifndef XI_PROP_PRODUCT_ID
#define XI_PROP_PRODUCT_ID "Device Product ID"
#endif
namespace ui {
namespace {
// Names of all known internal devices that should not be considered as
// keyboards.
// TODO(rsadam@): Identify these devices using udev rules. (Crbug.com/420728.)
const char* kKnownInvalidKeyboardDeviceNames[] = {"Power Button",
"Sleep Button",
"Video Bus",
"gpio-keys.5",
"gpio-keys.12",
"ROCKCHIP-I2S Headset Jack"};
const char* kCachedAtomList[] = {
"Abs MT Position X",
"Abs MT Position Y",
XI_KEYBOARD,
XI_MOUSE,
XI_TOUCHPAD,
XI_TOUCHSCREEN,
XI_PROP_PRODUCT_ID,
NULL,
};
enum DeviceType {
DEVICE_TYPE_KEYBOARD,
DEVICE_TYPE_MOUSE,
DEVICE_TYPE_TOUCHPAD,
DEVICE_TYPE_TOUCHSCREEN,
DEVICE_TYPE_OTHER
};
typedef base::Callback<void(const std::vector<KeyboardDevice>&)>
KeyboardDeviceCallback;
typedef base::Callback<void(const std::vector<TouchscreenDevice>&)>
TouchscreenDeviceCallback;
typedef base::Callback<void(const std::vector<InputDevice>&)>
InputDeviceCallback;
// Used for updating the state on the UI thread once device information is
// parsed on helper threads.
struct UiCallbacks {
KeyboardDeviceCallback keyboard_callback;
TouchscreenDeviceCallback touchscreen_callback;
InputDeviceCallback mouse_callback;
InputDeviceCallback touchpad_callback;
base::Closure hotplug_finished_callback;
};
// Stores a copy of the XIValuatorClassInfo values so X11 device processing can
// happen on a worker thread. This is needed since X11 structs are not copyable.
struct ValuatorClassInfo {
ValuatorClassInfo(const XIValuatorClassInfo& info)
: label(info.label),
max(info.max),
min(info.min),
mode(info.mode),
number(info.number) {}
Atom label;
double max;
double min;
int mode;
int number;
};
// Stores a copy of the XITouchClassInfo values so X11 device processing can
// happen on a worker thread. This is needed since X11 structs are not copyable.
struct TouchClassInfo {
TouchClassInfo() : mode(0), num_touches(0) {}
explicit TouchClassInfo(const XITouchClassInfo& info)
: mode(info.mode), num_touches(info.num_touches) {}
int mode;
int num_touches;
};
struct DeviceInfo {
DeviceInfo(const XIDeviceInfo& device,
DeviceType type,
const base::FilePath& path,
uint16_t vendor,
uint16_t product)
: id(device.deviceid),
name(device.name),
vendor_id(vendor),
product_id(product),
use(device.use),
type(type),
path(path) {
for (int i = 0; i < device.num_classes; ++i) {
switch (device.classes[i]->type) {
case XIValuatorClass:
valuator_class_infos.push_back(ValuatorClassInfo(
*reinterpret_cast<XIValuatorClassInfo*>(device.classes[i])));
break;
case XITouchClass:
// A device can have at most one XITouchClassInfo. Ref:
// http://manpages.ubuntu.com/manpages/saucy/man3/XIQueryDevice.3.html
DCHECK(!touch_class_info.mode);
touch_class_info = TouchClassInfo(
*reinterpret_cast<XITouchClassInfo*>(device.classes[i]));
break;
default:
break;
}
}
}
// Unique device identifier.
int id;
// Internal device name.
std::string name;
// USB-style device identifiers.
uint16_t vendor_id;
uint16_t product_id;
// Device type (ie: XIMasterPointer)
int use;
// Specifies the type of the device.
DeviceType type;
// Path to the actual device (ie: /dev/input/eventXX)
base::FilePath path;
std::vector<ValuatorClassInfo> valuator_class_infos;
TouchClassInfo touch_class_info;
};
// X11 display cache used on worker threads. This is filled on the UI thread and
// passed in to the worker threads.
struct DisplayState {
Atom mt_position_x;
Atom mt_position_y;
};
// Returns true if |name| is the name of a known invalid keyboard device. Note,
// this may return false negatives.
bool IsKnownInvalidKeyboardDevice(const std::string& name) {
std::string trimmed(name);
base::TrimWhitespaceASCII(name, base::TRIM_TRAILING, &trimmed);
for (const char* device_name : kKnownInvalidKeyboardDeviceNames) {
if (trimmed == device_name)
return true;
}
return false;
}
// Returns true if |name| is the name of a known XTEST device. Note, this may
// return false negatives.
bool IsTestDevice(const std::string& name) {
return name.find("XTEST") != std::string::npos;
}
base::FilePath GetDevicePath(XDisplay* dpy, const XIDeviceInfo& device) {
// Skip the main pointer and keyboard since XOpenDevice() generates a
// BadDevice error when passed these devices.
if (device.use == XIMasterPointer || device.use == XIMasterKeyboard)
return base::FilePath();
// Input device has a property "Device Node" pointing to its dev input node,
// e.g. Device Node (250): "/dev/input/event8"
Atom device_node = XInternAtom(dpy, "Device Node", False);
if (device_node == None)
return base::FilePath();
Atom actual_type;
int actual_format;
unsigned long nitems, bytes_after;
unsigned char* data;
XDevice* dev = XOpenDevice(dpy, device.deviceid);
if (!dev)
return base::FilePath();
if (XGetDeviceProperty(dpy,
dev,
device_node,
0,
1000,
False,
AnyPropertyType,
&actual_type,
&actual_format,
&nitems,
&bytes_after,
&data) != Success) {
XCloseDevice(dpy, dev);
return base::FilePath();
}
std::string path;
// Make sure the returned value is a string.
if (actual_type == XA_STRING && actual_format == 8)
path = reinterpret_cast<char*>(data);
XFree(data);
XCloseDevice(dpy, dev);
return base::FilePath(path);
}
// Helper used to parse keyboard information. When it is done it uses
// |reply_runner| and |callback| to update the state on the UI thread.
void HandleKeyboardDevicesInWorker(
const std::vector<DeviceInfo>& device_infos,
scoped_refptr<base::TaskRunner> reply_runner,
const KeyboardDeviceCallback& callback) {
std::vector<KeyboardDevice> devices;
for (const DeviceInfo& device_info : device_infos) {
if (device_info.type != DEVICE_TYPE_KEYBOARD)
continue;
if (device_info.use != XISlaveKeyboard)
continue; // Assume all keyboards are keyboard slaves
if (IsKnownInvalidKeyboardDevice(device_info.name))
continue; // Skip invalid devices.
InputDeviceType type = GetInputDeviceTypeFromPath(device_info.path);
KeyboardDevice keyboard(device_info.id, type, device_info.name);
devices.push_back(keyboard);
}
reply_runner->PostTask(FROM_HERE, base::Bind(callback, devices));
}
// Helper used to parse mouse information. When it is done it uses
// |reply_runner| and |callback| to update the state on the UI thread.
void HandleMouseDevicesInWorker(const std::vector<DeviceInfo>& device_infos,
scoped_refptr<base::TaskRunner> reply_runner,
const InputDeviceCallback& callback) {
std::vector<InputDevice> devices;
for (const DeviceInfo& device_info : device_infos) {
if (device_info.type != DEVICE_TYPE_MOUSE ||
device_info.use != XISlavePointer) {
continue;
}
InputDeviceType type = GetInputDeviceTypeFromPath(device_info.path);
devices.push_back(InputDevice(device_info.id, type, device_info.name));
}
reply_runner->PostTask(FROM_HERE, base::Bind(callback, devices));
}
// Helper used to parse touchpad information. When it is done it uses
// |reply_runner| and |callback| to update the state on the UI thread.
void HandleTouchpadDevicesInWorker(const std::vector<DeviceInfo>& device_infos,
scoped_refptr<base::TaskRunner> reply_runner,
const InputDeviceCallback& callback) {
std::vector<InputDevice> devices;
for (const DeviceInfo& device_info : device_infos) {
if (device_info.type != DEVICE_TYPE_TOUCHPAD ||
device_info.use != XISlavePointer) {
continue;
}
InputDeviceType type = GetInputDeviceTypeFromPath(device_info.path);
devices.push_back(InputDevice(device_info.id, type, device_info.name));
}
reply_runner->PostTask(FROM_HERE, base::Bind(callback, devices));
}
// Helper used to parse touchscreen information. When it is done it uses
// |reply_runner| and |callback| to update the state on the UI thread.
void HandleTouchscreenDevicesInWorker(
const std::vector<DeviceInfo>& device_infos,
const DisplayState& display_state,
scoped_refptr<base::TaskRunner> reply_runner,
const TouchscreenDeviceCallback& callback) {
std::vector<TouchscreenDevice> devices;
if (display_state.mt_position_x == None ||
display_state.mt_position_y == None)
return;
for (const DeviceInfo& device_info : device_infos) {
if (device_info.type != DEVICE_TYPE_TOUCHSCREEN ||
(device_info.use != XIFloatingSlave &&
device_info.use != XISlavePointer)) {
continue;
}
// Touchscreens should be direct touch devices.
if (device_info.touch_class_info.mode != XIDirectTouch)
continue;
double max_x = -1.0;
double max_y = -1.0;
for (const ValuatorClassInfo& valuator : device_info.valuator_class_infos) {
if (display_state.mt_position_x == valuator.label) {
// Ignore X axis valuator with unexpected properties
if (valuator.number == 0 && valuator.mode == Absolute &&
valuator.min == 0.0) {
max_x = valuator.max;
}
} else if (display_state.mt_position_y == valuator.label) {
// Ignore Y axis valuator with unexpected properties
if (valuator.number == 1 && valuator.mode == Absolute &&
valuator.min == 0.0) {
max_y = valuator.max;
}
}
}
// Touchscreens should have absolute X and Y axes.
if (max_x > 0.0 && max_y > 0.0) {
InputDeviceType type = GetInputDeviceTypeFromPath(device_info.path);
// |max_x| and |max_y| are inclusive values, so we need to add 1 to get
// the size.
devices.push_back(
TouchscreenDevice(device_info.id, type, device_info.name,
gfx::Size(max_x + 1, max_y + 1),
device_info.touch_class_info.num_touches));
}
}
reply_runner->PostTask(FROM_HERE, base::Bind(callback, devices));
}
// Called on a worker thread to parse the device information.
void HandleHotplugEventInWorker(
const std::vector<DeviceInfo>& devices,
const DisplayState& display_state,
scoped_refptr<base::TaskRunner> reply_runner,
const UiCallbacks& callbacks) {
HandleTouchscreenDevicesInWorker(
devices, display_state, reply_runner, callbacks.touchscreen_callback);
HandleKeyboardDevicesInWorker(
devices, reply_runner, callbacks.keyboard_callback);
HandleMouseDevicesInWorker(devices, reply_runner, callbacks.mouse_callback);
HandleTouchpadDevicesInWorker(devices, reply_runner,
callbacks.touchpad_callback);
reply_runner->PostTask(FROM_HERE, callbacks.hotplug_finished_callback);
}
DeviceHotplugEventObserver* GetHotplugEventObserver() {
return DeviceDataManager::GetInstance();
}
void OnKeyboardDevices(const std::vector<KeyboardDevice>& devices) {
GetHotplugEventObserver()->OnKeyboardDevicesUpdated(devices);
}
void OnTouchscreenDevices(const std::vector<TouchscreenDevice>& devices) {
GetHotplugEventObserver()->OnTouchscreenDevicesUpdated(devices);
}
void OnMouseDevices(const std::vector<InputDevice>& devices) {
GetHotplugEventObserver()->OnMouseDevicesUpdated(devices);
}
void OnTouchpadDevices(const std::vector<InputDevice>& devices) {
GetHotplugEventObserver()->OnTouchpadDevicesUpdated(devices);
}
void OnHotplugFinished() {
GetHotplugEventObserver()->OnDeviceListsComplete();
}
} // namespace
X11HotplugEventHandler::X11HotplugEventHandler()
: atom_cache_(gfx::GetXDisplay(), kCachedAtomList) {
}
X11HotplugEventHandler::~X11HotplugEventHandler() {
}
void X11HotplugEventHandler::OnHotplugEvent() {
Display* display = gfx::GetXDisplay();
const XDeviceList& device_list_xi =
DeviceListCacheX11::GetInstance()->GetXDeviceList(display);
const XIDeviceList& device_list_xi2 =
DeviceListCacheX11::GetInstance()->GetXI2DeviceList(display);
const int kMaxDeviceNum = 128;
DeviceType device_types[kMaxDeviceNum];
for (int i = 0; i < kMaxDeviceNum; ++i)
device_types[i] = DEVICE_TYPE_OTHER;
for (int i = 0; i < device_list_xi.count; ++i) {
int id = device_list_xi[i].id;
if (id < 0 || id >= kMaxDeviceNum)
continue;
Atom type = device_list_xi[i].type;
if (type == atom_cache_.GetAtom(XI_KEYBOARD))
device_types[id] = DEVICE_TYPE_KEYBOARD;
else if (type == atom_cache_.GetAtom(XI_MOUSE))
device_types[id] = DEVICE_TYPE_MOUSE;
else if (type == atom_cache_.GetAtom(XI_TOUCHPAD))
device_types[id] = DEVICE_TYPE_TOUCHPAD;
else if (type == atom_cache_.GetAtom(XI_TOUCHSCREEN))
device_types[id] = DEVICE_TYPE_TOUCHSCREEN;
}
std::vector<DeviceInfo> device_infos;
for (int i = 0; i < device_list_xi2.count; ++i) {
const XIDeviceInfo& device = device_list_xi2[i];
if (!device.enabled || IsTestDevice(device.name))
continue;
DeviceType device_type =
(device.deviceid >= 0 && device.deviceid < kMaxDeviceNum)
? device_types[device.deviceid]
: DEVICE_TYPE_OTHER;
// Obtain the USB-style vendor and product identifiers.
// (On Linux, XI2 makes this available for all evdev devices.
uint32_t* product_info;
Atom type;
int format_return;
unsigned long num_items_return;
unsigned long bytes_after_return;
uint16_t vendor = 0;
uint16_t product = 0;
if (XIGetProperty(gfx::GetXDisplay(), device.deviceid,
atom_cache_.GetAtom(XI_PROP_PRODUCT_ID), 0, 2, 0,
XA_INTEGER, &type, &format_return, &num_items_return,
&bytes_after_return,
reinterpret_cast<unsigned char**>(&product_info)) == 0 &&
product_info) {
if (num_items_return == 2) {
vendor = product_info[0];
product = product_info[1];
}
XFree(product_info);
}
device_infos.push_back(DeviceInfo(
device, device_type, GetDevicePath(display, device), vendor, product));
}
// X11 is not thread safe, so first get all the required state.
DisplayState display_state;
display_state.mt_position_x = atom_cache_.GetAtom("Abs MT Position X");
display_state.mt_position_y = atom_cache_.GetAtom("Abs MT Position Y");
UiCallbacks callbacks;
callbacks.keyboard_callback = base::Bind(&OnKeyboardDevices);
callbacks.touchscreen_callback = base::Bind(&OnTouchscreenDevices);
callbacks.mouse_callback = base::Bind(&OnMouseDevices);
callbacks.touchpad_callback = base::Bind(&OnTouchpadDevices);
callbacks.hotplug_finished_callback = base::Bind(&OnHotplugFinished);
// Parsing the device information may block, so delegate the operation to a
// worker thread. Once the device information is extracted the parsed devices
// will be returned via the callbacks.
base::WorkerPool::PostTask(
FROM_HERE,
base::Bind(&HandleHotplugEventInWorker, device_infos, display_state,
base::ThreadTaskRunnerHandle::Get(), callbacks),
true /* task_is_slow */);
}
} // namespace ui