/*
* Copyright (C) 2015 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#define LOG_TAG "InputDevice"
//#define LOG_NDEBUG 0
// Enables debug output for processing input events
#define DEBUG_INPUT_EVENTS 0
#include "InputDevice.h"
#include <linux/input.h>
#define __STDC_FORMAT_MACROS
#include <cinttypes>
#include <cstdlib>
#include <string>
#include <utils/Log.h>
#include <utils/Timers.h>
#include "InputHost.h"
#include "InputHub.h"
#include "MouseInputMapper.h"
#include "SwitchInputMapper.h"
#define MSC_ANDROID_TIME_SEC 0x6
#define MSC_ANDROID_TIME_USEC 0x7
namespace android {
static InputBus getInputBus(const std::shared_ptr<InputDeviceNode>& node) {
switch (node->getBusType()) {
case BUS_USB:
return INPUT_BUS_USB;
case BUS_BLUETOOTH:
return INPUT_BUS_BT;
case BUS_RS232:
return INPUT_BUS_SERIAL;
default:
// TODO: check for other linux bus types that might not be built-in
return INPUT_BUS_BUILTIN;
}
}
static uint32_t getAbsAxisUsage(int32_t axis, uint32_t deviceClasses) {
// Touch devices get dibs on touch-related axes.
if (deviceClasses & INPUT_DEVICE_CLASS_TOUCH) {
switch (axis) {
case ABS_X:
case ABS_Y:
case ABS_PRESSURE:
case ABS_TOOL_WIDTH:
case ABS_DISTANCE:
case ABS_TILT_X:
case ABS_TILT_Y:
case ABS_MT_SLOT:
case ABS_MT_TOUCH_MAJOR:
case ABS_MT_TOUCH_MINOR:
case ABS_MT_WIDTH_MAJOR:
case ABS_MT_WIDTH_MINOR:
case ABS_MT_ORIENTATION:
case ABS_MT_POSITION_X:
case ABS_MT_POSITION_Y:
case ABS_MT_TOOL_TYPE:
case ABS_MT_BLOB_ID:
case ABS_MT_TRACKING_ID:
case ABS_MT_PRESSURE:
case ABS_MT_DISTANCE:
return INPUT_DEVICE_CLASS_TOUCH;
}
}
// External stylus gets the pressure axis
if (deviceClasses & INPUT_DEVICE_CLASS_EXTERNAL_STYLUS) {
if (axis == ABS_PRESSURE) {
return INPUT_DEVICE_CLASS_EXTERNAL_STYLUS;
}
}
// Joystick devices get the rest.
return INPUT_DEVICE_CLASS_JOYSTICK;
}
EvdevDevice::EvdevDevice(InputHostInterface* host, const std::shared_ptr<InputDeviceNode>& node) :
mHost(host), mDeviceNode(node), mDeviceDefinition(mHost->createDeviceDefinition()) {
InputBus bus = getInputBus(node);
mInputId = mHost->createDeviceIdentifier(
node->getName().c_str(),
node->getProductId(),
node->getVendorId(),
bus,
node->getUniqueId().c_str());
createMappers();
configureDevice();
// If we found a need for at least one mapper, register the device with the
// host. If there were no mappers, this device is effectively ignored, as
// the host won't know about it.
if (mMappers.size() > 0) {
mDeviceHandle = mHost->registerDevice(mInputId, mDeviceDefinition);
for (const auto& mapper : mMappers) {
mapper->setDeviceHandle(mDeviceHandle);
}
}
}
void EvdevDevice::createMappers() {
// See if this is a cursor device such as a trackball or mouse.
if (mDeviceNode->hasKey(BTN_MOUSE)
&& mDeviceNode->hasRelativeAxis(REL_X)
&& mDeviceNode->hasRelativeAxis(REL_Y)) {
mClasses |= INPUT_DEVICE_CLASS_CURSOR;
mMappers.push_back(std::make_unique<MouseInputMapper>());
}
bool isStylus = false;
bool haveGamepadButtons = mDeviceNode->hasKeyInRange(BTN_MISC, BTN_MOUSE) ||
mDeviceNode->hasKeyInRange(BTN_JOYSTICK, BTN_DIGI);
// See if this is a touch pad or stylus.
// Is this a new modern multi-touch driver?
if (mDeviceNode->hasAbsoluteAxis(ABS_MT_POSITION_X)
&& mDeviceNode->hasAbsoluteAxis(ABS_MT_POSITION_Y)) {
// Some joysticks such as the PS3 controller report axes that conflict
// with the ABS_MT range. Try to confirm that the device really is a
// touch screen.
if (mDeviceNode->hasKey(BTN_TOUCH) || !haveGamepadButtons) {
mClasses |= INPUT_DEVICE_CLASS_TOUCH | INPUT_DEVICE_CLASS_TOUCH_MT;
//mMappers.push_back(std::make_unique<MultiTouchInputMapper>());
}
// Is this an old style single-touch driver?
} else if (mDeviceNode->hasKey(BTN_TOUCH)
&& mDeviceNode->hasAbsoluteAxis(ABS_X)
&& mDeviceNode->hasAbsoluteAxis(ABS_Y)) {
mClasses |= INPUT_DEVICE_CLASS_TOUCH;
//mMappers.push_back(std::make_unique<SingleTouchInputMapper>());
// Is this a BT stylus?
} else if ((mDeviceNode->hasAbsoluteAxis(ABS_PRESSURE) || mDeviceNode->hasKey(BTN_TOUCH))
&& !mDeviceNode->hasAbsoluteAxis(ABS_X) && !mDeviceNode->hasAbsoluteAxis(ABS_Y)) {
mClasses |= INPUT_DEVICE_CLASS_EXTERNAL_STYLUS;
//mMappers.push_back(std::make_unique<ExternalStylusInputMapper>());
isStylus = true;
mClasses &= ~INPUT_DEVICE_CLASS_KEYBOARD;
}
// See if this is a keyboard. Ignore everything in the button range except
// for joystick and gamepad buttons which are handled like keyboards for the
// most part.
// Keyboard will try to claim some of the stylus buttons but we really want
// to reserve those so we can fuse it with the touch screen data. Note this
// means an external stylus cannot also be a keyboard device.
if (!isStylus) {
bool haveKeyboardKeys = mDeviceNode->hasKeyInRange(0, BTN_MISC) ||
mDeviceNode->hasKeyInRange(KEY_OK, KEY_CNT);
if (haveKeyboardKeys || haveGamepadButtons) {
mClasses |= INPUT_DEVICE_CLASS_KEYBOARD;
//mMappers.push_back(std::make_unique<KeyboardInputMapper>());
}
}
// See if this device is a joystick.
// Assumes that joysticks always have gamepad buttons in order to
// distinguish them from other devices such as accelerometers that also have
// absolute axes.
if (haveGamepadButtons) {
uint32_t assumedClasses = mClasses | INPUT_DEVICE_CLASS_JOYSTICK;
for (int i = 0; i < ABS_CNT; ++i) {
if (mDeviceNode->hasAbsoluteAxis(i)
&& getAbsAxisUsage(i, assumedClasses) == INPUT_DEVICE_CLASS_JOYSTICK) {
mClasses = assumedClasses;
//mMappers.push_back(std::make_unique<JoystickInputMapper>());
break;
}
}
}
// Check whether this device has switches.
for (int i = 0; i < SW_CNT; ++i) {
if (mDeviceNode->hasSwitch(i)) {
mClasses |= INPUT_DEVICE_CLASS_SWITCH;
mMappers.push_back(std::make_unique<SwitchInputMapper>());
break;
}
}
// Check whether this device supports the vibrator.
// TODO: decide if this is necessary.
if (mDeviceNode->hasForceFeedback(FF_RUMBLE)) {
mClasses |= INPUT_DEVICE_CLASS_VIBRATOR;
//mMappers.push_back(std::make_unique<VibratorInputMapper>());
}
ALOGD("device %s classes=0x%x %zu mappers", mDeviceNode->getPath().c_str(), mClasses,
mMappers.size());
}
void EvdevDevice::configureDevice() {
for (const auto& mapper : mMappers) {
auto reportDef = mHost->createInputReportDefinition();
if (mapper->configureInputReport(mDeviceNode.get(), reportDef)) {
mDeviceDefinition->addReport(reportDef);
} else {
mHost->freeReportDefinition(reportDef);
}
reportDef = mHost->createOutputReportDefinition();
if (mapper->configureOutputReport(mDeviceNode.get(), reportDef)) {
mDeviceDefinition->addReport(reportDef);
} else {
mHost->freeReportDefinition(reportDef);
}
}
}
void EvdevDevice::processInput(InputEvent& event, nsecs_t currentTime) {
#if DEBUG_INPUT_EVENTS
std::string log;
log.append("---InputEvent for device %s---\n");
log.append(" when: %" PRId64 "\n");
log.append(" type: %d\n");
log.append(" code: %d\n");
log.append(" value: %d\n");
ALOGD(log.c_str(), mDeviceNode->getPath().c_str(), event.when, event.type, event.code,
event.value);
#endif
if (event.type == EV_MSC) {
if (event.code == MSC_ANDROID_TIME_SEC) {
mOverrideSec = event.value;
} else if (event.code == MSC_ANDROID_TIME_USEC) {
mOverrideUsec = event.value;
}
return;
}
if (mOverrideSec || mOverrideUsec) {
event.when = s2ns(mOverrideSec) + us2ns(mOverrideUsec);
ALOGV("applied override time %d.%06d", mOverrideSec, mOverrideUsec);
if (event.type == EV_SYN && event.code == SYN_REPORT) {
mOverrideSec = 0;
mOverrideUsec = 0;
}
}
// Bug 7291243: Add a guard in case the kernel generates timestamps
// that appear to be far into the future because they were generated
// using the wrong clock source.
//
// This can happen because when the input device is initially opened
// it has a default clock source of CLOCK_REALTIME. Any input events
// enqueued right after the device is opened will have timestamps
// generated using CLOCK_REALTIME. We later set the clock source
// to CLOCK_MONOTONIC but it is already too late.
//
// Invalid input event timestamps can result in ANRs, crashes and
// and other issues that are hard to track down. We must not let them
// propagate through the system.
//
// Log a warning so that we notice the problem and recover gracefully.
if (event.when >= currentTime + s2ns(10)) {
// Double-check. Time may have moved on.
auto time = systemTime(SYSTEM_TIME_MONOTONIC);
if (event.when > time) {
ALOGW("An input event from %s has a timestamp that appears to have "
"been generated using the wrong clock source (expected "
"CLOCK_MONOTONIC): event time %" PRId64 ", current time %" PRId64
", call time %" PRId64 ". Using current time instead.",
mDeviceNode->getPath().c_str(), event.when, time, currentTime);
event.when = time;
} else {
ALOGV("Event time is ok but failed the fast path and required an extra "
"call to systemTime: event time %" PRId64 ", current time %" PRId64
", call time %" PRId64 ".", event.when, time, currentTime);
}
}
for (size_t i = 0; i < mMappers.size(); ++i) {
mMappers[i]->process(event);
}
}
} // namespace android