You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
279 lines
10 KiB
279 lines
10 KiB
/*
|
|
* 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"
|
|
|
|
|
|
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
|
|
|
|
// 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
|