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 
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 
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 
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 
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 
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 
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