Add support for new input sources.
Added several new coordinate values to MotionEvents to capture
touch major/minor area, tool major/minor area and orientation.
Renamed NDK input constants per convention.
Added InputDevice class in Java which will eventually provide
useful information about available input devices.
Added APIs for manufacturing new MotionEvent objects with multiple
pointers and all necessary coordinate data.
Fixed a bug in the input dispatcher where it could get stuck with
a pointer down forever.
Fixed a bug in the WindowManager where the input window list could
end up containing stale removed windows.
Fixed a bug in the WindowManager where the input channel was being
removed only after the final animation transition had taken place
which caused spurious WINDOW DIED log messages to be printed.
Change-Id: Ie55084da319b20aad29b28a0499b8dd98bb5da68
diff --git a/libs/ui/InputReader.cpp b/libs/ui/InputReader.cpp
index 0a21db7..cd4654a 100644
--- a/libs/ui/InputReader.cpp
+++ b/libs/ui/InputReader.cpp
@@ -29,6 +29,7 @@
#include <unistd.h>
#include <errno.h>
#include <limits.h>
+#include <math.h>
/** Amount that trackball needs to move in order to generate a key event. */
#define TRACKBALL_MOVEMENT_THRESHOLD 6
@@ -60,33 +61,33 @@
int32_t mask;
switch (keyCode) {
case AKEYCODE_ALT_LEFT:
- mask = META_ALT_LEFT_ON;
+ mask = AMETA_ALT_LEFT_ON;
break;
case AKEYCODE_ALT_RIGHT:
- mask = META_ALT_RIGHT_ON;
+ mask = AMETA_ALT_RIGHT_ON;
break;
case AKEYCODE_SHIFT_LEFT:
- mask = META_SHIFT_LEFT_ON;
+ mask = AMETA_SHIFT_LEFT_ON;
break;
case AKEYCODE_SHIFT_RIGHT:
- mask = META_SHIFT_RIGHT_ON;
+ mask = AMETA_SHIFT_RIGHT_ON;
break;
case AKEYCODE_SYM:
- mask = META_SYM_ON;
+ mask = AMETA_SYM_ON;
break;
default:
return oldMetaState;
}
int32_t newMetaState = down ? oldMetaState | mask : oldMetaState & ~ mask
- & ~ (META_ALT_ON | META_SHIFT_ON);
+ & ~ (AMETA_ALT_ON | AMETA_SHIFT_ON);
- if (newMetaState & (META_ALT_LEFT_ON | META_ALT_RIGHT_ON)) {
- newMetaState |= META_ALT_ON;
+ if (newMetaState & (AMETA_ALT_LEFT_ON | AMETA_ALT_RIGHT_ON)) {
+ newMetaState |= AMETA_ALT_ON;
}
- if (newMetaState & (META_SHIFT_LEFT_ON | META_SHIFT_RIGHT_ON)) {
- newMetaState |= META_SHIFT_ON;
+ if (newMetaState & (AMETA_SHIFT_LEFT_ON | AMETA_SHIFT_RIGHT_ON)) {
+ newMetaState |= AMETA_SHIFT_ON;
}
return newMetaState;
@@ -324,11 +325,26 @@
InputDevice::MultiTouchScreenState::Accumulator::FIELD_ABS_MT_TOUCH_MAJOR;
pointer->absMTTouchMajor = rawEvent->value;
break;
+ case ABS_MT_TOUCH_MINOR:
+ pointer->fields |=
+ InputDevice::MultiTouchScreenState::Accumulator::FIELD_ABS_MT_TOUCH_MINOR;
+ pointer->absMTTouchMinor = rawEvent->value;
+ break;
case ABS_MT_WIDTH_MAJOR:
pointer->fields |=
InputDevice::MultiTouchScreenState::Accumulator::FIELD_ABS_MT_WIDTH_MAJOR;
pointer->absMTWidthMajor = rawEvent->value;
break;
+ case ABS_MT_WIDTH_MINOR:
+ pointer->fields |=
+ InputDevice::MultiTouchScreenState::Accumulator::FIELD_ABS_MT_WIDTH_MINOR;
+ pointer->absMTWidthMinor = rawEvent->value;
+ break;
+ case ABS_MT_ORIENTATION:
+ pointer->fields |=
+ InputDevice::MultiTouchScreenState::Accumulator::FIELD_ABS_MT_ORIENTATION;
+ pointer->absMTOrientation = rawEvent->value;
+ break;
case ABS_MT_TRACKING_ID:
pointer->fields |=
InputDevice::MultiTouchScreenState::Accumulator::FIELD_ABS_MT_TRACKING_ID;
@@ -408,17 +424,17 @@
int32_t keyEventAction;
if (down) {
device->keyboard.current.downTime = when;
- keyEventAction = KEY_EVENT_ACTION_DOWN;
+ keyEventAction = AKEY_EVENT_ACTION_DOWN;
} else {
- keyEventAction = KEY_EVENT_ACTION_UP;
+ keyEventAction = AKEY_EVENT_ACTION_UP;
}
- int32_t keyEventFlags = KEY_EVENT_FLAG_FROM_SYSTEM;
+ int32_t keyEventFlags = AKEY_EVENT_FLAG_FROM_SYSTEM;
if (policyActions & InputReaderPolicyInterface::ACTION_WOKE_HERE) {
- keyEventFlags = keyEventFlags | KEY_EVENT_FLAG_WOKE_HERE;
+ keyEventFlags = keyEventFlags | AKEY_EVENT_FLAG_WOKE_HERE;
}
- mDispatcher->notifyKey(when, device->id, INPUT_EVENT_NATURE_KEY, policyFlags,
+ mDispatcher->notifyKey(when, device->id, AINPUT_SOURCE_KEYBOARD, policyFlags,
keyEventAction, keyEventFlags, keyCode, scanCode,
device->keyboard.current.metaState,
device->keyboard.current.downTime);
@@ -473,11 +489,29 @@
continue;
}
+ out->pointers[outCount].x = in->accumulator.pointers[inIndex].absMTPositionX;
+ out->pointers[outCount].y = in->accumulator.pointers[inIndex].absMTPositionY;
+
+ out->pointers[outCount].touchMajor = in->accumulator.pointers[inIndex].absMTTouchMajor;
+ out->pointers[outCount].touchMinor = (fields
+ & InputDevice::MultiTouchScreenState::Accumulator::FIELD_ABS_MT_TOUCH_MINOR) != 0
+ ? in->accumulator.pointers[inIndex].absMTTouchMinor
+ : in->accumulator.pointers[inIndex].absMTTouchMajor;
+
+ out->pointers[outCount].toolMajor = in->accumulator.pointers[inIndex].absMTWidthMajor;
+ out->pointers[outCount].toolMinor = (fields
+ & InputDevice::MultiTouchScreenState::Accumulator::FIELD_ABS_MT_WIDTH_MINOR) != 0
+ ? in->accumulator.pointers[inIndex].absMTWidthMinor
+ : in->accumulator.pointers[inIndex].absMTWidthMajor;
+
+ out->pointers[outCount].orientation = (fields
+ & InputDevice::MultiTouchScreenState::Accumulator::FIELD_ABS_MT_ORIENTATION) != 0
+ ? in->accumulator.pointers[inIndex].absMTOrientation : 0;
+
+ // Derive an approximation of pressure and size.
// FIXME assignment of pressure may be incorrect, probably better to let
// pressure = touch / width. Later on we pass width to MotionEvent as a size, which
// isn't quite right either. Should be using touch for that.
- out->pointers[outCount].x = in->accumulator.pointers[inIndex].absMTPositionX;
- out->pointers[outCount].y = in->accumulator.pointers[inIndex].absMTPositionY;
out->pointers[outCount].pressure = in->accumulator.pointers[inIndex].absMTTouchMajor;
out->pointers[outCount].size = in->accumulator.pointers[inIndex].absMTWidthMajor;
@@ -556,6 +590,11 @@
out->pointers[0].y = in->current.y;
out->pointers[0].pressure = in->current.pressure;
out->pointers[0].size = in->current.size;
+ out->pointers[0].touchMajor = in->current.pressure;
+ out->pointers[0].touchMinor = in->current.pressure;
+ out->pointers[0].toolMajor = in->current.size;
+ out->pointers[0].toolMinor = in->current.size;
+ out->pointers[0].orientation = 0;
out->idToIndex[0] = 0;
out->idBits.markBit(0);
}
@@ -635,8 +674,8 @@
device->touchScreen.currentVirtualKey.keyCode,
device->touchScreen.currentVirtualKey.scanCode);
#endif
- dispatchVirtualKey(when, device, policyFlags, KEY_EVENT_ACTION_UP,
- KEY_EVENT_FLAG_FROM_SYSTEM | KEY_EVENT_FLAG_VIRTUAL_HARD_KEY);
+ dispatchVirtualKey(when, device, policyFlags, AKEY_EVENT_ACTION_UP,
+ AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY);
return true; // consumed
}
@@ -658,9 +697,9 @@
device->touchScreen.currentVirtualKey.keyCode,
device->touchScreen.currentVirtualKey.scanCode);
#endif
- dispatchVirtualKey(when, device, policyFlags, KEY_EVENT_ACTION_UP,
- KEY_EVENT_FLAG_FROM_SYSTEM | KEY_EVENT_FLAG_VIRTUAL_HARD_KEY
- | KEY_EVENT_FLAG_CANCELED);
+ dispatchVirtualKey(when, device, policyFlags, AKEY_EVENT_ACTION_UP,
+ AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY
+ | AKEY_EVENT_FLAG_CANCELED);
return true; // consumed
default:
@@ -679,8 +718,8 @@
device->touchScreen.currentVirtualKey.keyCode,
device->touchScreen.currentVirtualKey.scanCode);
#endif
- dispatchVirtualKey(when, device, policyFlags, KEY_EVENT_ACTION_DOWN,
- KEY_EVENT_FLAG_FROM_SYSTEM | KEY_EVENT_FLAG_VIRTUAL_HARD_KEY);
+ dispatchVirtualKey(when, device, policyFlags, AKEY_EVENT_ACTION_DOWN,
+ AKEY_EVENT_FLAG_FROM_SYSTEM | AKEY_EVENT_FLAG_VIRTUAL_HARD_KEY);
return true; // consumed
}
}
@@ -698,15 +737,15 @@
nsecs_t downTime = device->touchScreen.currentVirtualKey.downTime;
int32_t metaState = globalMetaState();
- if (keyEventAction == KEY_EVENT_ACTION_DOWN) {
+ if (keyEventAction == AKEY_EVENT_ACTION_DOWN) {
mPolicy->virtualKeyDownFeedback();
}
int32_t policyActions = mPolicy->interceptKey(when, device->id,
- keyEventAction == KEY_EVENT_ACTION_DOWN, keyCode, scanCode, policyFlags);
+ keyEventAction == AKEY_EVENT_ACTION_DOWN, keyCode, scanCode, policyFlags);
if (applyStandardInputDispatchPolicyActions(when, policyActions, & policyFlags)) {
- mDispatcher->notifyKey(when, device->id, INPUT_EVENT_NATURE_KEY, policyFlags,
+ mDispatcher->notifyKey(when, device->id, AINPUT_SOURCE_KEYBOARD, policyFlags,
keyEventAction, keyEventFlags, keyCode, scanCode, metaState, downTime);
}
}
@@ -725,7 +764,7 @@
if (currentIdBits == lastIdBits) {
// No pointer id changes so this is a move event.
// The dispatcher takes care of batching moves so we don't have to deal with that here.
- int32_t motionEventAction = MOTION_EVENT_ACTION_MOVE;
+ int32_t motionEventAction = AMOTION_EVENT_ACTION_MOVE;
dispatchTouch(when, device, policyFlags, & device->touchScreen.currentTouch,
currentIdBits, motionEventAction);
} else {
@@ -743,10 +782,10 @@
int32_t motionEventAction;
if (activeIdBits.isEmpty()) {
- motionEventAction = MOTION_EVENT_ACTION_UP;
+ motionEventAction = AMOTION_EVENT_ACTION_UP;
} else {
- motionEventAction = MOTION_EVENT_ACTION_POINTER_UP
- | (upId << MOTION_EVENT_ACTION_POINTER_INDEX_SHIFT);
+ motionEventAction = AMOTION_EVENT_ACTION_POINTER_UP
+ | (upId << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT);
}
dispatchTouch(when, device, policyFlags, & device->touchScreen.lastTouch,
@@ -761,11 +800,11 @@
int32_t motionEventAction;
if (oldActiveIdBits.isEmpty()) {
- motionEventAction = MOTION_EVENT_ACTION_DOWN;
+ motionEventAction = AMOTION_EVENT_ACTION_DOWN;
device->touchScreen.downTime = when;
} else {
- motionEventAction = MOTION_EVENT_ACTION_POINTER_DOWN
- | (downId << MOTION_EVENT_ACTION_POINTER_INDEX_SHIFT);
+ motionEventAction = AMOTION_EVENT_ACTION_POINTER_DOWN
+ | (downId << AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT);
}
dispatchTouch(when, device, policyFlags, & device->touchScreen.currentTouch,
@@ -813,11 +852,17 @@
float size = float(touch->pointers[index].size
- precalculated.sizeOrigin) * precalculated.sizeScale;
+ float orientation = float(touch->pointers[index].orientation)
+ * precalculated.orientationScale;
+
+ bool vertical = abs(orientation) <= M_PI / 8;
+
switch (mDisplayOrientation) {
case InputReaderPolicyInterface::ROTATION_90: {
float xTemp = x;
x = y;
y = mDisplayWidth - xTemp;
+ vertical = ! vertical;
break;
}
case InputReaderPolicyInterface::ROTATION_180: {
@@ -829,16 +874,35 @@
float xTemp = x;
x = mDisplayHeight - y;
y = xTemp;
+ vertical = ! vertical;
break;
}
}
+ float touchMajor, touchMinor, toolMajor, toolMinor;
+ if (vertical) {
+ touchMajor = float(touch->pointers[index].touchMajor) * precalculated.yScale;
+ touchMinor = float(touch->pointers[index].touchMinor) * precalculated.xScale;
+ toolMajor = float(touch->pointers[index].toolMajor) * precalculated.yScale;
+ toolMinor = float(touch->pointers[index].toolMinor) * precalculated.xScale;
+ } else {
+ touchMajor = float(touch->pointers[index].touchMajor) * precalculated.xScale;
+ touchMinor = float(touch->pointers[index].touchMinor) * precalculated.yScale;
+ toolMajor = float(touch->pointers[index].toolMajor) * precalculated.xScale;
+ toolMinor = float(touch->pointers[index].toolMinor) * precalculated.yScale;
+ }
+
pointerIds[pointerCount] = int32_t(id);
pointerCoords[pointerCount].x = x;
pointerCoords[pointerCount].y = y;
pointerCoords[pointerCount].pressure = pressure;
pointerCoords[pointerCount].size = size;
+ pointerCoords[pointerCount].touchMajor = touchMajor;
+ pointerCoords[pointerCount].touchMinor = touchMinor;
+ pointerCoords[pointerCount].toolMajor = toolMajor;
+ pointerCoords[pointerCount].toolMinor = toolMinor;
+ pointerCoords[pointerCount].orientation = orientation;
pointerCount += 1;
}
@@ -847,21 +911,21 @@
// global to the event.
// XXX Maybe we should revise the edge flags API to work on a per-pointer basis.
int32_t motionEventEdgeFlags = 0;
- if (motionEventAction == MOTION_EVENT_ACTION_DOWN) {
+ if (motionEventAction == AMOTION_EVENT_ACTION_DOWN) {
if (pointerCoords[0].x <= 0) {
- motionEventEdgeFlags |= MOTION_EVENT_EDGE_FLAG_LEFT;
+ motionEventEdgeFlags |= AMOTION_EVENT_EDGE_FLAG_LEFT;
} else if (pointerCoords[0].x >= orientedWidth) {
- motionEventEdgeFlags |= MOTION_EVENT_EDGE_FLAG_RIGHT;
+ motionEventEdgeFlags |= AMOTION_EVENT_EDGE_FLAG_RIGHT;
}
if (pointerCoords[0].y <= 0) {
- motionEventEdgeFlags |= MOTION_EVENT_EDGE_FLAG_TOP;
+ motionEventEdgeFlags |= AMOTION_EVENT_EDGE_FLAG_TOP;
} else if (pointerCoords[0].y >= orientedHeight) {
- motionEventEdgeFlags |= MOTION_EVENT_EDGE_FLAG_BOTTOM;
+ motionEventEdgeFlags |= AMOTION_EVENT_EDGE_FLAG_BOTTOM;
}
}
nsecs_t downTime = device->touchScreen.downTime;
- mDispatcher->notifyMotion(when, device->id, INPUT_EVENT_NATURE_TOUCH, policyFlags,
+ mDispatcher->notifyMotion(when, device->id, AINPUT_SOURCE_TOUCHSCREEN, policyFlags,
motionEventAction, globalMetaState(), motionEventEdgeFlags,
pointerCount, pointerIds, pointerCoords,
0, 0, downTime);
@@ -912,9 +976,9 @@
int32_t motionEventAction;
if (downChanged) {
- motionEventAction = down ? MOTION_EVENT_ACTION_DOWN : MOTION_EVENT_ACTION_UP;
+ motionEventAction = down ? AMOTION_EVENT_ACTION_DOWN : AMOTION_EVENT_ACTION_UP;
} else {
- motionEventAction = MOTION_EVENT_ACTION_MOVE;
+ motionEventAction = AMOTION_EVENT_ACTION_MOVE;
}
int32_t pointerId = 0;
@@ -925,6 +989,11 @@
? device->trackball.accumulator.relY * device->trackball.precalculated.yScale : 0;
pointerCoords.pressure = 1.0f; // XXX Consider making this 1.0f if down, 0 otherwise.
pointerCoords.size = 0;
+ pointerCoords.touchMajor = 0;
+ pointerCoords.touchMinor = 0;
+ pointerCoords.toolMajor = 0;
+ pointerCoords.toolMinor = 0;
+ pointerCoords.orientation = 0;
float temp;
switch (mDisplayOrientation) {
@@ -946,8 +1015,8 @@
break;
}
- mDispatcher->notifyMotion(when, device->id, INPUT_EVENT_NATURE_TRACKBALL, policyFlags,
- motionEventAction, globalMetaState(), MOTION_EVENT_EDGE_FLAG_NONE,
+ mDispatcher->notifyMotion(when, device->id, AINPUT_SOURCE_TRACKBALL, policyFlags,
+ motionEventAction, globalMetaState(), AMOTION_EVENT_EDGE_FLAG_NONE,
1, & pointerId, & pointerCoords,
device->trackball.precalculated.xPrecision,
device->trackball.precalculated.yPrecision,
@@ -1079,6 +1148,8 @@
& device->touchScreen.parameters.pressureAxis);
configureAbsoluteAxisInfo(device, ABS_MT_WIDTH_MAJOR, "Size",
& device->touchScreen.parameters.sizeAxis);
+ configureAbsoluteAxisInfo(device, ABS_MT_ORIENTATION, "Orientation",
+ & device->touchScreen.parameters.orientationAxis);
} else if (device->isSingleTouchScreen()) {
configureAbsoluteAxisInfo(device, ABS_X, "X",
& device->touchScreen.parameters.xAxis);
@@ -1088,6 +1159,7 @@
& device->touchScreen.parameters.pressureAxis);
configureAbsoluteAxisInfo(device, ABS_TOOL_WIDTH, "Size",
& device->touchScreen.parameters.sizeAxis);
+ device->touchScreen.parameters.orientationAxis.valid = false;
}
if (device->isTouchScreen()) {
@@ -1117,6 +1189,14 @@
device->touchScreen.precalculated.sizeOrigin = 0;
device->touchScreen.precalculated.sizeScale = 1.0f;
}
+
+ if (device->touchScreen.parameters.orientationAxis.valid
+ && device->touchScreen.parameters.orientationAxis.maxValue > 0) {
+ device->touchScreen.precalculated.orientationScale =
+ M_PI_4 / device->touchScreen.parameters.orientationAxis.maxValue;
+ } else {
+ device->touchScreen.precalculated.orientationScale = 0.0f;
+ }
}
if (device->isTrackball()) {
@@ -1347,7 +1427,7 @@
AutoMutex _l(mExportedStateLock);
if (mExportedVirtualScanCode == scanCode) {
- return KEY_STATE_VIRTUAL;
+ return AKEY_STATE_VIRTUAL;
}
} // release exported state lock
@@ -1360,7 +1440,7 @@
AutoMutex _l(mExportedStateLock);
if (mExportedVirtualKeyCode == keyCode) {
- return KEY_STATE_VIRTUAL;
+ return AKEY_STATE_VIRTUAL;
}
} // release exported state lock