1 // Copyright 2014 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "ui/events/x/hotplug_event_handler_x11.h"
6
7 #include <X11/extensions/XInput.h>
8 #include <X11/extensions/XInput2.h>
9
10 #include <cmath>
11 #include <set>
12 #include <string>
13 #include <vector>
14
15 #include "base/command_line.h"
16 #include "base/files/file_enumerator.h"
17 #include "base/logging.h"
18 #include "base/process/launch.h"
19 #include "base/strings/string_util.h"
20 #include "base/sys_info.h"
21 #include "ui/events/device_hotplug_event_observer.h"
22 #include "ui/events/touchscreen_device.h"
23 #include "ui/gfx/x/x11_types.h"
24
25 namespace ui {
26
27 namespace {
28
29 // We consider the touchscreen to be internal if it is an I2c device.
30 // With the device id, we can query X to get the device's dev input
31 // node eventXXX. Then we search all the dev input nodes registered
32 // by I2C devices to see if we can find eventXXX.
IsTouchscreenInternal(XDisplay * dpy,int device_id)33 bool IsTouchscreenInternal(XDisplay* dpy, int device_id) {
34 using base::FileEnumerator;
35 using base::FilePath;
36
37 #if !defined(CHROMEOS)
38 return false;
39 #else
40 if (!base::SysInfo::IsRunningOnChromeOS())
41 return false;
42 #endif
43
44 // Input device has a property "Device Node" pointing to its dev input node,
45 // e.g. Device Node (250): "/dev/input/event8"
46 Atom device_node = XInternAtom(dpy, "Device Node", False);
47 if (device_node == None)
48 return false;
49
50 Atom actual_type;
51 int actual_format;
52 unsigned long nitems, bytes_after;
53 unsigned char* data;
54 XDevice* dev = XOpenDevice(dpy, device_id);
55 if (!dev)
56 return false;
57
58 if (XGetDeviceProperty(dpy,
59 dev,
60 device_node,
61 0,
62 1000,
63 False,
64 AnyPropertyType,
65 &actual_type,
66 &actual_format,
67 &nitems,
68 &bytes_after,
69 &data) != Success) {
70 XCloseDevice(dpy, dev);
71 return false;
72 }
73 base::FilePath dev_node_path(reinterpret_cast<char*>(data));
74 XFree(data);
75 XCloseDevice(dpy, dev);
76
77 std::string event_node = dev_node_path.BaseName().value();
78 if (event_node.empty() || !StartsWithASCII(event_node, "event", false))
79 return false;
80
81 // Extract id "XXX" from "eventXXX"
82 std::string event_node_id = event_node.substr(5);
83
84 // I2C input device registers its dev input node at
85 // /sys/bus/i2c/devices/*/input/inputXXX/eventXXX
86 FileEnumerator i2c_enum(FilePath(FILE_PATH_LITERAL("/sys/bus/i2c/devices/")),
87 false,
88 base::FileEnumerator::DIRECTORIES);
89 for (FilePath i2c_name = i2c_enum.Next(); !i2c_name.empty();
90 i2c_name = i2c_enum.Next()) {
91 FileEnumerator input_enum(i2c_name.Append(FILE_PATH_LITERAL("input")),
92 false,
93 base::FileEnumerator::DIRECTORIES,
94 FILE_PATH_LITERAL("input*"));
95 for (base::FilePath input = input_enum.Next(); !input.empty();
96 input = input_enum.Next()) {
97 if (input.BaseName().value().substr(5) == event_node_id)
98 return true;
99 }
100 }
101
102 return false;
103 }
104
105 } // namespace
106
HotplugEventHandlerX11(DeviceHotplugEventObserver * delegate)107 HotplugEventHandlerX11::HotplugEventHandlerX11(
108 DeviceHotplugEventObserver* delegate)
109 : delegate_(delegate) {
110 }
111
~HotplugEventHandlerX11()112 HotplugEventHandlerX11::~HotplugEventHandlerX11() {
113 }
114
OnHotplugEvent()115 void HotplugEventHandlerX11::OnHotplugEvent() {
116 const XIDeviceList& device_list =
117 DeviceListCacheX::GetInstance()->GetXI2DeviceList(gfx::GetXDisplay());
118 HandleTouchscreenDevices(device_list);
119 }
120
HandleTouchscreenDevices(const XIDeviceList & x11_devices)121 void HotplugEventHandlerX11::HandleTouchscreenDevices(
122 const XIDeviceList& x11_devices) {
123 std::vector<TouchscreenDevice> devices;
124 Display* display = gfx::GetXDisplay();
125 Atom valuator_x = XInternAtom(display, "Abs MT Position X", False);
126 Atom valuator_y = XInternAtom(display, "Abs MT Position Y", False);
127 if (valuator_x == None || valuator_y == None)
128 return;
129
130 std::set<int> no_match_touchscreen;
131 for (int i = 0; i < x11_devices.count; i++) {
132 if (!x11_devices[i].enabled || x11_devices[i].use != XIFloatingSlave)
133 continue; // Assume all touchscreens are floating slaves
134
135 double width = -1.0;
136 double height = -1.0;
137 bool is_direct_touch = false;
138
139 for (int j = 0; j < x11_devices[i].num_classes; j++) {
140 XIAnyClassInfo* class_info = x11_devices[i].classes[j];
141
142 if (class_info->type == XIValuatorClass) {
143 XIValuatorClassInfo* valuator_info =
144 reinterpret_cast<XIValuatorClassInfo*>(class_info);
145
146 if (valuator_x == valuator_info->label) {
147 // Ignore X axis valuator with unexpected properties
148 if (valuator_info->number == 0 && valuator_info->mode == Absolute &&
149 valuator_info->min == 0.0) {
150 width = valuator_info->max;
151 }
152 } else if (valuator_y == valuator_info->label) {
153 // Ignore Y axis valuator with unexpected properties
154 if (valuator_info->number == 1 && valuator_info->mode == Absolute &&
155 valuator_info->min == 0.0) {
156 height = valuator_info->max;
157 }
158 }
159 }
160 #if defined(USE_XI2_MT)
161 if (class_info->type == XITouchClass) {
162 XITouchClassInfo* touch_info =
163 reinterpret_cast<XITouchClassInfo*>(class_info);
164 is_direct_touch = touch_info->mode == XIDirectTouch;
165 }
166 #endif
167 }
168
169 // Touchscreens should have absolute X and Y axes, and be direct touch
170 // devices.
171 if (width > 0.0 && height > 0.0 && is_direct_touch) {
172 bool is_internal =
173 IsTouchscreenInternal(display, x11_devices[i].deviceid);
174 devices.push_back(TouchscreenDevice(
175 x11_devices[i].deviceid, gfx::Size(width, height), is_internal));
176 }
177 }
178
179 delegate_->OnTouchscreenDevicesUpdated(devices);
180 }
181
182 } // namespace ui
183