1 /*
2 * Copyright (C) 2015 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #define LOG_TAG "InputDevice"
18 //#define LOG_NDEBUG 0
19
20 // Enables debug output for processing input events
21 #define DEBUG_INPUT_EVENTS 0
22
23 #include "InputDevice.h"
24
25 #include <linux/input.h>
26
27 #define __STDC_FORMAT_MACROS
28 #include <cinttypes>
29 #include <cstdlib>
30 #include <string>
31
32 #include <utils/Log.h>
33 #include <utils/Timers.h>
34
35 #include "InputHost.h"
36 #include "InputHub.h"
37 #include "MouseInputMapper.h"
38 #include "SwitchInputMapper.h"
39
40 #define MSC_ANDROID_TIME_SEC 0x6
41 #define MSC_ANDROID_TIME_USEC 0x7
42
43 namespace android {
44
getInputBus(const std::shared_ptr<InputDeviceNode> & node)45 static InputBus getInputBus(const std::shared_ptr<InputDeviceNode>& node) {
46 switch (node->getBusType()) {
47 case BUS_USB:
48 return INPUT_BUS_USB;
49 case BUS_BLUETOOTH:
50 return INPUT_BUS_BT;
51 case BUS_RS232:
52 return INPUT_BUS_SERIAL;
53 default:
54 // TODO: check for other linux bus types that might not be built-in
55 return INPUT_BUS_BUILTIN;
56 }
57 }
58
getAbsAxisUsage(int32_t axis,uint32_t deviceClasses)59 static uint32_t getAbsAxisUsage(int32_t axis, uint32_t deviceClasses) {
60 // Touch devices get dibs on touch-related axes.
61 if (deviceClasses & INPUT_DEVICE_CLASS_TOUCH) {
62 switch (axis) {
63 case ABS_X:
64 case ABS_Y:
65 case ABS_PRESSURE:
66 case ABS_TOOL_WIDTH:
67 case ABS_DISTANCE:
68 case ABS_TILT_X:
69 case ABS_TILT_Y:
70 case ABS_MT_SLOT:
71 case ABS_MT_TOUCH_MAJOR:
72 case ABS_MT_TOUCH_MINOR:
73 case ABS_MT_WIDTH_MAJOR:
74 case ABS_MT_WIDTH_MINOR:
75 case ABS_MT_ORIENTATION:
76 case ABS_MT_POSITION_X:
77 case ABS_MT_POSITION_Y:
78 case ABS_MT_TOOL_TYPE:
79 case ABS_MT_BLOB_ID:
80 case ABS_MT_TRACKING_ID:
81 case ABS_MT_PRESSURE:
82 case ABS_MT_DISTANCE:
83 return INPUT_DEVICE_CLASS_TOUCH;
84 }
85 }
86
87 // External stylus gets the pressure axis
88 if (deviceClasses & INPUT_DEVICE_CLASS_EXTERNAL_STYLUS) {
89 if (axis == ABS_PRESSURE) {
90 return INPUT_DEVICE_CLASS_EXTERNAL_STYLUS;
91 }
92 }
93
94 // Joystick devices get the rest.
95 return INPUT_DEVICE_CLASS_JOYSTICK;
96 }
97
EvdevDevice(InputHostInterface * host,const std::shared_ptr<InputDeviceNode> & node)98 EvdevDevice::EvdevDevice(InputHostInterface* host, const std::shared_ptr<InputDeviceNode>& node) :
99 mHost(host), mDeviceNode(node), mDeviceDefinition(mHost->createDeviceDefinition()) {
100
101 InputBus bus = getInputBus(node);
102 mInputId = mHost->createDeviceIdentifier(
103 node->getName().c_str(),
104 node->getProductId(),
105 node->getVendorId(),
106 bus,
107 node->getUniqueId().c_str());
108
109 createMappers();
110 configureDevice();
111
112 // If we found a need for at least one mapper, register the device with the
113 // host. If there were no mappers, this device is effectively ignored, as
114 // the host won't know about it.
115 if (mMappers.size() > 0) {
116 mDeviceHandle = mHost->registerDevice(mInputId, mDeviceDefinition);
117 for (const auto& mapper : mMappers) {
118 mapper->setDeviceHandle(mDeviceHandle);
119 }
120 }
121 }
122
createMappers()123 void EvdevDevice::createMappers() {
124 // See if this is a cursor device such as a trackball or mouse.
125 if (mDeviceNode->hasKey(BTN_MOUSE)
126 && mDeviceNode->hasRelativeAxis(REL_X)
127 && mDeviceNode->hasRelativeAxis(REL_Y)) {
128 mClasses |= INPUT_DEVICE_CLASS_CURSOR;
129 mMappers.push_back(std::make_unique<MouseInputMapper>());
130 }
131
132 bool isStylus = false;
133 bool haveGamepadButtons = mDeviceNode->hasKeyInRange(BTN_MISC, BTN_MOUSE) ||
134 mDeviceNode->hasKeyInRange(BTN_JOYSTICK, BTN_DIGI);
135
136 // See if this is a touch pad or stylus.
137 // Is this a new modern multi-touch driver?
138 if (mDeviceNode->hasAbsoluteAxis(ABS_MT_POSITION_X)
139 && mDeviceNode->hasAbsoluteAxis(ABS_MT_POSITION_Y)) {
140 // Some joysticks such as the PS3 controller report axes that conflict
141 // with the ABS_MT range. Try to confirm that the device really is a
142 // touch screen.
143 if (mDeviceNode->hasKey(BTN_TOUCH) || !haveGamepadButtons) {
144 mClasses |= INPUT_DEVICE_CLASS_TOUCH | INPUT_DEVICE_CLASS_TOUCH_MT;
145 //mMappers.push_back(std::make_unique<MultiTouchInputMapper>());
146 }
147 // Is this an old style single-touch driver?
148 } else if (mDeviceNode->hasKey(BTN_TOUCH)
149 && mDeviceNode->hasAbsoluteAxis(ABS_X)
150 && mDeviceNode->hasAbsoluteAxis(ABS_Y)) {
151 mClasses |= INPUT_DEVICE_CLASS_TOUCH;
152 //mMappers.push_back(std::make_unique<SingleTouchInputMapper>());
153 // Is this a BT stylus?
154 } else if ((mDeviceNode->hasAbsoluteAxis(ABS_PRESSURE) || mDeviceNode->hasKey(BTN_TOUCH))
155 && !mDeviceNode->hasAbsoluteAxis(ABS_X) && !mDeviceNode->hasAbsoluteAxis(ABS_Y)) {
156 mClasses |= INPUT_DEVICE_CLASS_EXTERNAL_STYLUS;
157 //mMappers.push_back(std::make_unique<ExternalStylusInputMapper>());
158 isStylus = true;
159 mClasses &= ~INPUT_DEVICE_CLASS_KEYBOARD;
160 }
161
162 // See if this is a keyboard. Ignore everything in the button range except
163 // for joystick and gamepad buttons which are handled like keyboards for the
164 // most part.
165 // Keyboard will try to claim some of the stylus buttons but we really want
166 // to reserve those so we can fuse it with the touch screen data. Note this
167 // means an external stylus cannot also be a keyboard device.
168 if (!isStylus) {
169 bool haveKeyboardKeys = mDeviceNode->hasKeyInRange(0, BTN_MISC) ||
170 mDeviceNode->hasKeyInRange(KEY_OK, KEY_CNT);
171 if (haveKeyboardKeys || haveGamepadButtons) {
172 mClasses |= INPUT_DEVICE_CLASS_KEYBOARD;
173 //mMappers.push_back(std::make_unique<KeyboardInputMapper>());
174 }
175 }
176
177 // See if this device is a joystick.
178 // Assumes that joysticks always have gamepad buttons in order to
179 // distinguish them from other devices such as accelerometers that also have
180 // absolute axes.
181 if (haveGamepadButtons) {
182 uint32_t assumedClasses = mClasses | INPUT_DEVICE_CLASS_JOYSTICK;
183 for (int i = 0; i < ABS_CNT; ++i) {
184 if (mDeviceNode->hasAbsoluteAxis(i)
185 && getAbsAxisUsage(i, assumedClasses) == INPUT_DEVICE_CLASS_JOYSTICK) {
186 mClasses = assumedClasses;
187 //mMappers.push_back(std::make_unique<JoystickInputMapper>());
188 break;
189 }
190 }
191 }
192
193 // Check whether this device has switches.
194 for (int i = 0; i < SW_CNT; ++i) {
195 if (mDeviceNode->hasSwitch(i)) {
196 mClasses |= INPUT_DEVICE_CLASS_SWITCH;
197 mMappers.push_back(std::make_unique<SwitchInputMapper>());
198 break;
199 }
200 }
201
202 // Check whether this device supports the vibrator.
203 // TODO: decide if this is necessary.
204 if (mDeviceNode->hasForceFeedback(FF_RUMBLE)) {
205 mClasses |= INPUT_DEVICE_CLASS_VIBRATOR;
206 //mMappers.push_back(std::make_unique<VibratorInputMapper>());
207 }
208
209 ALOGD("device %s classes=0x%x %zu mappers", mDeviceNode->getPath().c_str(), mClasses,
210 mMappers.size());
211 }
212
configureDevice()213 void EvdevDevice::configureDevice() {
214 for (const auto& mapper : mMappers) {
215 auto reportDef = mHost->createInputReportDefinition();
216 if (mapper->configureInputReport(mDeviceNode.get(), reportDef)) {
217 mDeviceDefinition->addReport(reportDef);
218 } else {
219 mHost->freeReportDefinition(reportDef);
220 }
221
222 reportDef = mHost->createOutputReportDefinition();
223 if (mapper->configureOutputReport(mDeviceNode.get(), reportDef)) {
224 mDeviceDefinition->addReport(reportDef);
225 } else {
226 mHost->freeReportDefinition(reportDef);
227 }
228 }
229 }
230
processInput(InputEvent & event,nsecs_t currentTime)231 void EvdevDevice::processInput(InputEvent& event, nsecs_t currentTime) {
232 #if DEBUG_INPUT_EVENTS
233 std::string log;
234 log.append("---InputEvent for device %s---\n");
235 log.append(" when: %" PRId64 "\n");
236 log.append(" type: %d\n");
237 log.append(" code: %d\n");
238 log.append(" value: %d\n");
239 ALOGD(log.c_str(), mDeviceNode->getPath().c_str(), event.when, event.type, event.code,
240 event.value);
241 #endif
242
243 if (event.type == EV_MSC) {
244 if (event.code == MSC_ANDROID_TIME_SEC) {
245 mOverrideSec = event.value;
246 } else if (event.code == MSC_ANDROID_TIME_USEC) {
247 mOverrideUsec = event.value;
248 }
249 return;
250 }
251
252 if (mOverrideSec || mOverrideUsec) {
253 event.when = s2ns(mOverrideSec) + us2ns(mOverrideUsec);
254 ALOGV("applied override time %d.%06d", mOverrideSec, mOverrideUsec);
255
256 if (event.type == EV_SYN && event.code == SYN_REPORT) {
257 mOverrideSec = 0;
258 mOverrideUsec = 0;
259 }
260 }
261
262 // Bug 7291243: Add a guard in case the kernel generates timestamps
263 // that appear to be far into the future because they were generated
264 // using the wrong clock source.
265 //
266 // This can happen because when the input device is initially opened
267 // it has a default clock source of CLOCK_REALTIME. Any input events
268 // enqueued right after the device is opened will have timestamps
269 // generated using CLOCK_REALTIME. We later set the clock source
270 // to CLOCK_MONOTONIC but it is already too late.
271 //
272 // Invalid input event timestamps can result in ANRs, crashes and
273 // and other issues that are hard to track down. We must not let them
274 // propagate through the system.
275 //
276 // Log a warning so that we notice the problem and recover gracefully.
277 if (event.when >= currentTime + s2ns(10)) {
278 // Double-check. Time may have moved on.
279 auto time = systemTime(SYSTEM_TIME_MONOTONIC);
280 if (event.when > time) {
281 ALOGW("An input event from %s has a timestamp that appears to have "
282 "been generated using the wrong clock source (expected "
283 "CLOCK_MONOTONIC): event time %" PRId64 ", current time %" PRId64
284 ", call time %" PRId64 ". Using current time instead.",
285 mDeviceNode->getPath().c_str(), event.when, time, currentTime);
286 event.when = time;
287 } else {
288 ALOGV("Event time is ok but failed the fast path and required an extra "
289 "call to systemTime: event time %" PRId64 ", current time %" PRId64
290 ", call time %" PRId64 ".", event.when, time, currentTime);
291 }
292 }
293
294 for (size_t i = 0; i < mMappers.size(); ++i) {
295 mMappers[i]->process(event);
296 }
297 }
298
299 } // namespace android
300