Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Fix a regression with MotionEvent parceling."

Browse Source
This commit is contained in:
Jeff Brown
2011-02-17 13:03:15 -08:00
committed by Android (Google) Code Review
parent 45fde07742 ebbd5d14ad
commit 2172ab226b
11 changed files with 637 additions and 192 deletions
Download Patch File Download Diff File Expand all files Collapse all files

58
core/jni/android_view_MotionEvent.cpp
View File

@@ -188,23 +188,23 @@ static bool validatePointerCoords(JNIEnv* env, jobject pointerCoordsObj) {
static void pointerCoordsToNative(JNIEnv* env, jobject pointerCoordsObj,
float xOffset, float yOffset, PointerCoords* outRawPointerCoords) {
outRawPointerCoords->clear();
outRawPointerCoords->setAxisValue(AINPUT_MOTION_AXIS_X,
outRawPointerCoords->setAxisValue(AMOTION_EVENT_AXIS_X,
env->GetFloatField(pointerCoordsObj, gPointerCoordsClassInfo.x) - xOffset);
outRawPointerCoords->setAxisValue(AINPUT_MOTION_AXIS_Y,
outRawPointerCoords->setAxisValue(AMOTION_EVENT_AXIS_Y,
env->GetFloatField(pointerCoordsObj, gPointerCoordsClassInfo.y) - yOffset);
outRawPointerCoords->setAxisValue(AINPUT_MOTION_AXIS_PRESSURE,
outRawPointerCoords->setAxisValue(AMOTION_EVENT_AXIS_PRESSURE,
env->GetFloatField(pointerCoordsObj, gPointerCoordsClassInfo.pressure));
outRawPointerCoords->setAxisValue(AINPUT_MOTION_AXIS_SIZE,
outRawPointerCoords->setAxisValue(AMOTION_EVENT_AXIS_SIZE,
env->GetFloatField(pointerCoordsObj, gPointerCoordsClassInfo.size));
outRawPointerCoords->setAxisValue(AINPUT_MOTION_AXIS_TOUCH_MAJOR,
outRawPointerCoords->setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR,
env->GetFloatField(pointerCoordsObj, gPointerCoordsClassInfo.touchMajor));
outRawPointerCoords->setAxisValue(AINPUT_MOTION_AXIS_TOUCH_MINOR,
outRawPointerCoords->setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR,
env->GetFloatField(pointerCoordsObj, gPointerCoordsClassInfo.touchMinor));
outRawPointerCoords->setAxisValue(AINPUT_MOTION_AXIS_TOOL_MAJOR,
outRawPointerCoords->setAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR,
env->GetFloatField(pointerCoordsObj, gPointerCoordsClassInfo.toolMajor));
outRawPointerCoords->setAxisValue(AINPUT_MOTION_AXIS_TOOL_MINOR,
outRawPointerCoords->setAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR,
env->GetFloatField(pointerCoordsObj, gPointerCoordsClassInfo.toolMinor));
outRawPointerCoords->setAxisValue(AINPUT_MOTION_AXIS_ORIENTATION,
outRawPointerCoords->setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION,
env->GetFloatField(pointerCoordsObj, gPointerCoordsClassInfo.orientation));
uint32_t bits = env->GetIntField(pointerCoordsObj,
@@ -254,34 +254,34 @@ static jfloatArray obtainPackedAxisValuesArray(JNIEnv* env, uint32_t minSize,
static void pointerCoordsFromNative(JNIEnv* env, const PointerCoords* rawPointerCoords,
float xOffset, float yOffset, jobject outPointerCoordsObj) {
env->SetFloatField(outPointerCoordsObj, gPointerCoordsClassInfo.x,
rawPointerCoords->getAxisValue(AINPUT_MOTION_AXIS_X) + xOffset);
rawPointerCoords->getAxisValue(AMOTION_EVENT_AXIS_X) + xOffset);
env->SetFloatField(outPointerCoordsObj, gPointerCoordsClassInfo.y,
rawPointerCoords->getAxisValue(AINPUT_MOTION_AXIS_Y) + yOffset);
rawPointerCoords->getAxisValue(AMOTION_EVENT_AXIS_Y) + yOffset);
env->SetFloatField(outPointerCoordsObj, gPointerCoordsClassInfo.pressure,
rawPointerCoords->getAxisValue(AINPUT_MOTION_AXIS_PRESSURE));
rawPointerCoords->getAxisValue(AMOTION_EVENT_AXIS_PRESSURE));
env->SetFloatField(outPointerCoordsObj, gPointerCoordsClassInfo.size,
rawPointerCoords->getAxisValue(AINPUT_MOTION_AXIS_SIZE));
rawPointerCoords->getAxisValue(AMOTION_EVENT_AXIS_SIZE));
env->SetFloatField(outPointerCoordsObj, gPointerCoordsClassInfo.touchMajor,
rawPointerCoords->getAxisValue(AINPUT_MOTION_AXIS_TOUCH_MAJOR));
rawPointerCoords->getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR));
env->SetFloatField(outPointerCoordsObj, gPointerCoordsClassInfo.touchMinor,
rawPointerCoords->getAxisValue(AINPUT_MOTION_AXIS_TOUCH_MINOR));
rawPointerCoords->getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR));
env->SetFloatField(outPointerCoordsObj, gPointerCoordsClassInfo.toolMajor,
rawPointerCoords->getAxisValue(AINPUT_MOTION_AXIS_TOOL_MAJOR));
rawPointerCoords->getAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR));
env->SetFloatField(outPointerCoordsObj, gPointerCoordsClassInfo.toolMinor,
rawPointerCoords->getAxisValue(AINPUT_MOTION_AXIS_TOOL_MINOR));
rawPointerCoords->getAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR));
env->SetFloatField(outPointerCoordsObj, gPointerCoordsClassInfo.orientation,
rawPointerCoords->getAxisValue(AINPUT_MOTION_AXIS_ORIENTATION));
rawPointerCoords->getAxisValue(AMOTION_EVENT_AXIS_ORIENTATION));
const uint32_t unpackedAxisBits = 0
| (1 << AINPUT_MOTION_AXIS_X)
| (1 << AINPUT_MOTION_AXIS_Y)
| (1 << AINPUT_MOTION_AXIS_PRESSURE)
| (1 << AINPUT_MOTION_AXIS_SIZE)
| (1 << AINPUT_MOTION_AXIS_TOUCH_MAJOR)
| (1 << AINPUT_MOTION_AXIS_TOUCH_MINOR)
| (1 << AINPUT_MOTION_AXIS_TOOL_MAJOR)
| (1 << AINPUT_MOTION_AXIS_TOOL_MINOR)
| (1 << AINPUT_MOTION_AXIS_ORIENTATION);
| (1 << AMOTION_EVENT_AXIS_X)
| (1 << AMOTION_EVENT_AXIS_Y)
| (1 << AMOTION_EVENT_AXIS_PRESSURE)
| (1 << AMOTION_EVENT_AXIS_SIZE)
| (1 << AMOTION_EVENT_AXIS_TOUCH_MAJOR)
| (1 << AMOTION_EVENT_AXIS_TOUCH_MINOR)
| (1 << AMOTION_EVENT_AXIS_TOOL_MAJOR)
| (1 << AMOTION_EVENT_AXIS_TOOL_MINOR)
| (1 << AMOTION_EVENT_AXIS_ORIENTATION);
uint32_t outBits = 0;
uint32_t remainingBits = rawPointerCoords->bits & ~unpackedAxisBits;
@@ -610,7 +610,7 @@ static jint android_view_MotionEvent_nativeReadFromParcel(JNIEnv* env, jclass cl
Parcel* parcel = parcelForJavaObject(env, parcelObj);
status_t status = event->readFromParcel(parcel);
if (!status) {
if (status) {
if (!nativePtr) {
delete event;
}
@@ -626,7 +626,7 @@ static void android_view_MotionEvent_nativeWriteToParcel(JNIEnv* env, jclass cla
Parcel* parcel = parcelForJavaObject(env, parcelObj);
status_t status = event->writeToParcel(parcel);
if (!status) {
if (status) {
jniThrowRuntimeException(env, "Failed to write MotionEvent parcel.");
}
}

51
include/ui/Input.h
View File

@@ -170,7 +170,7 @@ struct InputConfiguration {
* Pointer coordinate data.
*/
struct PointerCoords {
static const size_t MAX_AXES = 15; // 15 so that sizeof(PointerCoords) == 16 * 4 == 64
enum { MAX_AXES = 15 }; // 15 so that sizeof(PointerCoords) == 16 * 4 == 64
// Bitfield of axes that are present in this structure.
uint32_t bits; // 32bits are enough for now, can raise to 64bit when needed
@@ -192,14 +192,14 @@ struct PointerCoords {
return values[index];
}
inline void setAxisValue(int32_t axis, float value) {
inline status_t setAxisValue(int32_t axis, float value) {
uint32_t axisBit = 1 << axis;
uint32_t index = __builtin_popcount(bits & (axisBit - 1));
if (!(bits & axisBit)) {
uint32_t count = __builtin_popcount(bits);
if (count >= MAX_AXES) {
tooManyAxes(axis);
return;
return NO_MEMORY;
}
bits |= axisBit;
for (uint32_t i = count; i > index; i--) {
@@ -207,6 +207,7 @@ struct PointerCoords {
}
}
values[index] = value;
return OK;
}
inline float* editAxisValue(int32_t axis) {
@@ -351,49 +352,49 @@ public:
float getRawAxisValue(int32_t axis, size_t pointerIndex) const;
inline float getRawX(size_t pointerIndex) const {
return getRawAxisValue(AINPUT_MOTION_AXIS_X, pointerIndex);
return getRawAxisValue(AMOTION_EVENT_AXIS_X, pointerIndex);
}
inline float getRawY(size_t pointerIndex) const {
return getRawAxisValue(AINPUT_MOTION_AXIS_Y, pointerIndex);
return getRawAxisValue(AMOTION_EVENT_AXIS_Y, pointerIndex);
}
float getAxisValue(int32_t axis, size_t pointerIndex) const;
inline float getX(size_t pointerIndex) const {
return getAxisValue(AINPUT_MOTION_AXIS_X, pointerIndex);
return getAxisValue(AMOTION_EVENT_AXIS_X, pointerIndex);
}
inline float getY(size_t pointerIndex) const {
return getAxisValue(AINPUT_MOTION_AXIS_Y, pointerIndex);
return getAxisValue(AMOTION_EVENT_AXIS_Y, pointerIndex);
}
inline float getPressure(size_t pointerIndex) const {
return getAxisValue(AINPUT_MOTION_AXIS_PRESSURE, pointerIndex);
return getAxisValue(AMOTION_EVENT_AXIS_PRESSURE, pointerIndex);
}
inline float getSize(size_t pointerIndex) const {
return getAxisValue(AINPUT_MOTION_AXIS_SIZE, pointerIndex);
return getAxisValue(AMOTION_EVENT_AXIS_SIZE, pointerIndex);
}
inline float getTouchMajor(size_t pointerIndex) const {
return getAxisValue(AINPUT_MOTION_AXIS_TOUCH_MAJOR, pointerIndex);
return getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, pointerIndex);
}
inline float getTouchMinor(size_t pointerIndex) const {
return getAxisValue(AINPUT_MOTION_AXIS_TOUCH_MINOR, pointerIndex);
return getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, pointerIndex);
}
inline float getToolMajor(size_t pointerIndex) const {
return getAxisValue(AINPUT_MOTION_AXIS_TOOL_MAJOR, pointerIndex);
return getAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, pointerIndex);
}
inline float getToolMinor(size_t pointerIndex) const {
return getAxisValue(AINPUT_MOTION_AXIS_TOOL_MINOR, pointerIndex);
return getAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, pointerIndex);
}
inline float getOrientation(size_t pointerIndex) const {
return getAxisValue(AINPUT_MOTION_AXIS_ORIENTATION, pointerIndex);
return getAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, pointerIndex);
}
inline size_t getHistorySize() const { return mSampleEventTimes.size() - 1; }
@@ -410,59 +411,59 @@ public:
inline float getHistoricalRawX(size_t pointerIndex, size_t historicalIndex) const {
return getHistoricalRawAxisValue(
AINPUT_MOTION_AXIS_X, pointerIndex, historicalIndex);
AMOTION_EVENT_AXIS_X, pointerIndex, historicalIndex);
}
inline float getHistoricalRawY(size_t pointerIndex, size_t historicalIndex) const {
return getHistoricalRawAxisValue(
AINPUT_MOTION_AXIS_Y, pointerIndex, historicalIndex);
AMOTION_EVENT_AXIS_Y, pointerIndex, historicalIndex);
}
float getHistoricalAxisValue(int32_t axis, size_t pointerIndex, size_t historicalIndex) const;
inline float getHistoricalX(size_t pointerIndex, size_t historicalIndex) const {
return getHistoricalAxisValue(
AINPUT_MOTION_AXIS_X, pointerIndex, historicalIndex);
AMOTION_EVENT_AXIS_X, pointerIndex, historicalIndex);
}
inline float getHistoricalY(size_t pointerIndex, size_t historicalIndex) const {
return getHistoricalAxisValue(
AINPUT_MOTION_AXIS_Y, pointerIndex, historicalIndex);
AMOTION_EVENT_AXIS_Y, pointerIndex, historicalIndex);
}
inline float getHistoricalPressure(size_t pointerIndex, size_t historicalIndex) const {
return getHistoricalAxisValue(
AINPUT_MOTION_AXIS_PRESSURE, pointerIndex, historicalIndex);
AMOTION_EVENT_AXIS_PRESSURE, pointerIndex, historicalIndex);
}
inline float getHistoricalSize(size_t pointerIndex, size_t historicalIndex) const {
return getHistoricalAxisValue(
AINPUT_MOTION_AXIS_SIZE, pointerIndex, historicalIndex);
AMOTION_EVENT_AXIS_SIZE, pointerIndex, historicalIndex);
}
inline float getHistoricalTouchMajor(size_t pointerIndex, size_t historicalIndex) const {
return getHistoricalAxisValue(
AINPUT_MOTION_AXIS_TOUCH_MAJOR, pointerIndex, historicalIndex);
AMOTION_EVENT_AXIS_TOUCH_MAJOR, pointerIndex, historicalIndex);
}
inline float getHistoricalTouchMinor(size_t pointerIndex, size_t historicalIndex) const {
return getHistoricalAxisValue(
AINPUT_MOTION_AXIS_TOUCH_MINOR, pointerIndex, historicalIndex);
AMOTION_EVENT_AXIS_TOUCH_MINOR, pointerIndex, historicalIndex);
}
inline float getHistoricalToolMajor(size_t pointerIndex, size_t historicalIndex) const {
return getHistoricalAxisValue(
AINPUT_MOTION_AXIS_TOOL_MAJOR, pointerIndex, historicalIndex);
AMOTION_EVENT_AXIS_TOOL_MAJOR, pointerIndex, historicalIndex);
}
inline float getHistoricalToolMinor(size_t pointerIndex, size_t historicalIndex) const {
return getHistoricalAxisValue(
AINPUT_MOTION_AXIS_TOOL_MINOR, pointerIndex, historicalIndex);
AMOTION_EVENT_AXIS_TOOL_MINOR, pointerIndex, historicalIndex);
}
inline float getHistoricalOrientation(size_t pointerIndex, size_t historicalIndex) const {
return getHistoricalAxisValue(
AINPUT_MOTION_AXIS_ORIENTATION, pointerIndex, historicalIndex);
AMOTION_EVENT_AXIS_ORIENTATION, pointerIndex, historicalIndex);
}
void initialize(

30
libs/ui/Input.cpp
View File

@@ -362,10 +362,10 @@ float MotionEvent::getRawAxisValue(int32_t axis, size_t pointerIndex) const {
float MotionEvent::getAxisValue(int32_t axis, size_t pointerIndex) const {
float value = getRawPointerCoords(pointerIndex)->getAxisValue(axis);
switch (axis) {
case AINPUT_MOTION_AXIS_X:
case AMOTION_EVENT_AXIS_X:
value += mXOffset;
break;
case AINPUT_MOTION_AXIS_Y:
case AMOTION_EVENT_AXIS_Y:
value += mYOffset;
break;
}
@@ -386,10 +386,10 @@ float MotionEvent::getHistoricalAxisValue(int32_t axis, size_t pointerIndex,
size_t historicalIndex) const {
float value = getHistoricalRawPointerCoords(pointerIndex, historicalIndex)->getAxisValue(axis);
switch (axis) {
case AINPUT_MOTION_AXIS_X:
case AMOTION_EVENT_AXIS_X:
value += mXOffset;
break;
case AINPUT_MOTION_AXIS_Y:
case AMOTION_EVENT_AXIS_Y:
value += mYOffset;
break;
}
@@ -419,12 +419,12 @@ void MotionEvent::scale(float scaleFactor) {
PointerCoords& c = mSamplePointerCoords.editItemAt(i);
// No need to scale pressure or size since they are normalized.
// No need to scale orientation since it is meaningless to do so.
scaleAxisValue(c, AINPUT_MOTION_AXIS_X, scaleFactor);
scaleAxisValue(c, AINPUT_MOTION_AXIS_Y, scaleFactor);
scaleAxisValue(c, AINPUT_MOTION_AXIS_TOUCH_MAJOR, scaleFactor);
scaleAxisValue(c, AINPUT_MOTION_AXIS_TOUCH_MINOR, scaleFactor);
scaleAxisValue(c, AINPUT_MOTION_AXIS_TOOL_MAJOR, scaleFactor);
scaleAxisValue(c, AINPUT_MOTION_AXIS_TOOL_MINOR, scaleFactor);
scaleAxisValue(c, AMOTION_EVENT_AXIS_X, scaleFactor);
scaleAxisValue(c, AMOTION_EVENT_AXIS_Y, scaleFactor);
scaleAxisValue(c, AMOTION_EVENT_AXIS_TOUCH_MAJOR, scaleFactor);
scaleAxisValue(c, AMOTION_EVENT_AXIS_TOUCH_MINOR, scaleFactor);
scaleAxisValue(c, AMOTION_EVENT_AXIS_TOOL_MAJOR, scaleFactor);
scaleAxisValue(c, AMOTION_EVENT_AXIS_TOOL_MINOR, scaleFactor);
}
}
@@ -471,8 +471,8 @@ void MotionEvent::transform(const SkMatrix* matrix) {
size_t numSamples = mSamplePointerCoords.size();
for (size_t i = 0; i < numSamples; i++) {
PointerCoords& c = mSamplePointerCoords.editItemAt(i);
float* xPtr = c.editAxisValue(AINPUT_MOTION_AXIS_X);
float* yPtr = c.editAxisValue(AINPUT_MOTION_AXIS_Y);
float* xPtr = c.editAxisValue(AMOTION_EVENT_AXIS_X);
float* yPtr = c.editAxisValue(AMOTION_EVENT_AXIS_Y);
if (xPtr && yPtr) {
float x = *xPtr + oldXOffset;
float y = *yPtr + oldYOffset;
@@ -481,7 +481,7 @@ void MotionEvent::transform(const SkMatrix* matrix) {
*yPtr = SkScalarToFloat(point.fY) - newYOffset;
}
float* orientationPtr = c.editAxisValue(AINPUT_MOTION_AXIS_ORIENTATION);
float* orientationPtr = c.editAxisValue(AMOTION_EVENT_AXIS_ORIENTATION);
if (orientationPtr) {
*orientationPtr = transformAngle(matrix, *orientationPtr);
}
@@ -523,7 +523,7 @@ status_t MotionEvent::readFromParcel(Parcel* parcel) {
for (size_t i = 0; i < pointerCount; i++) {
mSamplePointerCoords.push();
status_t status = mSamplePointerCoords.editTop().readFromParcel(parcel);
if (!status) {
if (status) {
return status;
}
}
@@ -559,7 +559,7 @@ status_t MotionEvent::writeToParcel(Parcel* parcel) const {
parcel->writeInt64(mSampleEventTimes.itemAt(h));
for (size_t i = 0; i < pointerCount; i++) {
status_t status = (pc++)->writeToParcel(parcel);
if (!status) {
if (status) {
return status;
}
}

7
libs/ui/tests/Android.mk
View File

@@ -7,6 +7,7 @@ ifneq ($(TARGET_SIMULATOR),true)
# Build the unit tests.
test_src_files := \
InputChannel_test.cpp \
InputEvent_test.cpp \
InputPublisherAndConsumer_test.cpp
shared_libraries := \
@@ -18,7 +19,8 @@ shared_libraries := \
libhardware \
libhardware_legacy \
libui \
libstlport
libstlport \
libskia
static_libraries := \
libgtest \
@@ -28,7 +30,8 @@ c_includes := \
bionic \
bionic/libstdc++/include \
external/gtest/include \
external/stlport/stlport
external/stlport/stlport \
external/skia/include/core
module_tags := eng tests

18
libs/ui/tests/InputChannel_test.cpp
View File

@@ -1,6 +1,18 @@
//
// Copyright 2010 The Android Open Source Project
//
/*
* Copyright (C) 2010 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.
*/
#include <ui/InputTransport.h>
#include <utils/Timers.h>

417
libs/ui/tests/InputEvent_test.cpp Normal file
View File

@@ -0,0 +1,417 @@
/*
* Copyright (C) 2011 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.
*/
#include <ui/Input.h>
#include <gtest/gtest.h>
#include <binder/Parcel.h>
namespace android {
class BaseTest : public testing::Test {
protected:
virtual void SetUp() { }
virtual void TearDown() { }
};
// --- PointerCoordsTest ---
class PointerCoordsTest : public BaseTest {
};
TEST_F(PointerCoordsTest, ClearSetsBitsToZero) {
PointerCoords coords;
coords.clear();
ASSERT_EQ(0U, coords.bits);
}
TEST_F(PointerCoordsTest, AxisValues) {
float* valuePtr;
PointerCoords coords;
coords.clear();
// Check invariants when no axes are present.
ASSERT_EQ(0, coords.getAxisValue(0))
<< "getAxisValue should return zero because axis is not present";
ASSERT_EQ(0, coords.getAxisValue(1))
<< "getAxisValue should return zero because axis is not present";
ASSERT_EQ(NULL, coords.editAxisValue(0))
<< "editAxisValue should return null because axis is not present";
// Set first axis.
ASSERT_EQ(OK, coords.setAxisValue(1, 5));
ASSERT_EQ(0x00000002U, coords.bits);
ASSERT_EQ(5, coords.values[0]);
ASSERT_EQ(0, coords.getAxisValue(0))
<< "getAxisValue should return zero because axis is not present";
ASSERT_EQ(5, coords.getAxisValue(1))
<< "getAxisValue should return value of axis";
// Set an axis with a higher id than all others. (appending value at the end)
ASSERT_EQ(OK, coords.setAxisValue(3, 2));
ASSERT_EQ(0x0000000aU, coords.bits);
ASSERT_EQ(5, coords.values[0]);
ASSERT_EQ(2, coords.values[1]);
ASSERT_EQ(0, coords.getAxisValue(0))
<< "getAxisValue should return zero because axis is not present";
ASSERT_EQ(5, coords.getAxisValue(1))
<< "getAxisValue should return value of axis";
ASSERT_EQ(0, coords.getAxisValue(2))
<< "getAxisValue should return zero because axis is not present";
ASSERT_EQ(2, coords.getAxisValue(3))
<< "getAxisValue should return value of axis";
// Set an axis with an id lower than all others. (prepending value at beginning)
ASSERT_EQ(OK, coords.setAxisValue(0, 4));
ASSERT_EQ(0x0000000bU, coords.bits);
ASSERT_EQ(4, coords.values[0]);
ASSERT_EQ(5, coords.values[1]);
ASSERT_EQ(2, coords.values[2]);
ASSERT_EQ(4, coords.getAxisValue(0))
<< "getAxisValue should return value of axis";
ASSERT_EQ(5, coords.getAxisValue(1))
<< "getAxisValue should return value of axis";
ASSERT_EQ(0, coords.getAxisValue(2))
<< "getAxisValue should return zero because axis is not present";
ASSERT_EQ(2, coords.getAxisValue(3))
<< "getAxisValue should return value of axis";
// Edit an existing axis value in place.
valuePtr = coords.editAxisValue(1);
ASSERT_EQ(5, *valuePtr)
<< "editAxisValue should return pointer to axis value";
*valuePtr = 7;
ASSERT_EQ(7, coords.getAxisValue(1))
<< "getAxisValue should return value of axis";
// Set an axis with an id between the others. (inserting value in the middle)
ASSERT_EQ(OK, coords.setAxisValue(2, 1));
ASSERT_EQ(0x0000000fU, coords.bits);
ASSERT_EQ(4, coords.values[0]);
ASSERT_EQ(7, coords.values[1]);
ASSERT_EQ(1, coords.values[2]);
ASSERT_EQ(2, coords.values[3]);
ASSERT_EQ(4, coords.getAxisValue(0))
<< "getAxisValue should return value of axis";
ASSERT_EQ(7, coords.getAxisValue(1))
<< "getAxisValue should return value of axis";
ASSERT_EQ(1, coords.getAxisValue(2))
<< "getAxisValue should return value of axis";
ASSERT_EQ(2, coords.getAxisValue(3))
<< "getAxisValue should return value of axis";
// Set an existing axis value in place.
ASSERT_EQ(OK, coords.setAxisValue(1, 6));
ASSERT_EQ(0x0000000fU, coords.bits);
ASSERT_EQ(4, coords.values[0]);
ASSERT_EQ(6, coords.values[1]);
ASSERT_EQ(1, coords.values[2]);
ASSERT_EQ(2, coords.values[3]);
ASSERT_EQ(4, coords.getAxisValue(0))
<< "getAxisValue should return value of axis";
ASSERT_EQ(6, coords.getAxisValue(1))
<< "getAxisValue should return value of axis";
ASSERT_EQ(1, coords.getAxisValue(2))
<< "getAxisValue should return value of axis";
ASSERT_EQ(2, coords.getAxisValue(3))
<< "getAxisValue should return value of axis";
// Set maximum number of axes.
for (size_t axis = 4; axis < PointerCoords::MAX_AXES; axis++) {
ASSERT_EQ(OK, coords.setAxisValue(axis, axis));
}
ASSERT_EQ(PointerCoords::MAX_AXES, __builtin_popcount(coords.bits));
// Try to set one more axis beyond maximum number.
// Ensure bits are unchanged.
ASSERT_EQ(NO_MEMORY, coords.setAxisValue(PointerCoords::MAX_AXES, 100));
ASSERT_EQ(PointerCoords::MAX_AXES, __builtin_popcount(coords.bits));
}
TEST_F(PointerCoordsTest, ReadAndWriteParcel) {
Parcel parcel;
PointerCoords inCoords;
inCoords.clear();
PointerCoords outCoords;
// Round trip with empty coords.
inCoords.writeToParcel(&parcel);
parcel.setDataPosition(0);
outCoords.readFromParcel(&parcel);
ASSERT_EQ(0U, outCoords.bits);
// Round trip with some values.
parcel.freeData();
inCoords.setAxisValue(2, 5);
inCoords.setAxisValue(5, 8);
inCoords.writeToParcel(&parcel);
parcel.setDataPosition(0);
outCoords.readFromParcel(&parcel);
ASSERT_EQ(outCoords.bits, inCoords.bits);
ASSERT_EQ(outCoords.values[0], inCoords.values[0]);
ASSERT_EQ(outCoords.values[1], inCoords.values[1]);
}
// --- KeyEventTest ---
class KeyEventTest : public BaseTest {
};
TEST_F(KeyEventTest, Properties) {
KeyEvent event;
// Initialize and get properties.
const nsecs_t ARBITRARY_DOWN_TIME = 1;
const nsecs_t ARBITRARY_EVENT_TIME = 2;
event.initialize(2, AINPUT_SOURCE_GAMEPAD, AKEY_EVENT_ACTION_DOWN,
AKEY_EVENT_FLAG_FROM_SYSTEM, AKEYCODE_BUTTON_X, 121,
AMETA_ALT_ON, 1, ARBITRARY_DOWN_TIME, ARBITRARY_EVENT_TIME);
ASSERT_EQ(AINPUT_EVENT_TYPE_KEY, event.getType());
ASSERT_EQ(2, event.getDeviceId());
ASSERT_EQ(AINPUT_SOURCE_GAMEPAD, event.getSource());
ASSERT_EQ(AKEY_EVENT_ACTION_DOWN, event.getAction());
ASSERT_EQ(AKEY_EVENT_FLAG_FROM_SYSTEM, event.getFlags());
ASSERT_EQ(AKEYCODE_BUTTON_X, event.getKeyCode());
ASSERT_EQ(121, event.getScanCode());
ASSERT_EQ(AMETA_ALT_ON, event.getMetaState());
ASSERT_EQ(1, event.getRepeatCount());
ASSERT_EQ(ARBITRARY_DOWN_TIME, event.getDownTime());
ASSERT_EQ(ARBITRARY_EVENT_TIME, event.getEventTime());
// Set source.
event.setSource(AINPUT_SOURCE_JOYSTICK);
ASSERT_EQ(AINPUT_SOURCE_JOYSTICK, event.getSource());
}
// --- MotionEventTest ---
class MotionEventTest : public BaseTest {
};
TEST_F(MotionEventTest, Properties) {
MotionEvent event;
// Initialize, add samples and get properties.
const nsecs_t ARBITRARY_DOWN_TIME = 1;
const nsecs_t ARBITRARY_EVENT_TIME = 2;
const float X_OFFSET = 1.0f;
const float Y_OFFSET = 1.1f;
int32_t pointerIds[] = { 1, 2 };
PointerCoords pointerCoords[2];
pointerCoords[0].clear();
pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_X, 10);
pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_Y, 11);
pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 12);
pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_SIZE, 13);
pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, 14);
pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, 15);
pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, 16);
pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, 17);
pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, 18);
pointerCoords[1].clear();
pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_X, 20);
pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_Y, 21);
pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 22);
pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_SIZE, 23);
pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, 24);
pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, 25);
pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, 26);
pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, 27);
pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, 28);
event.initialize(2, AINPUT_SOURCE_TOUCHSCREEN, AMOTION_EVENT_ACTION_MOVE,
AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED,
AMOTION_EVENT_EDGE_FLAG_TOP, AMETA_ALT_ON,
X_OFFSET, Y_OFFSET, 2.0f, 2.1f,
ARBITRARY_DOWN_TIME, ARBITRARY_EVENT_TIME,
2, pointerIds, pointerCoords);
pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_X, 110);
pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_Y, 111);
pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 112);
pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_SIZE, 113);
pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, 114);
pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, 115);
pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, 116);
pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, 117);
pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, 118);
pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_X, 120);
pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_Y, 121);
pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 122);
pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_SIZE, 123);
pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, 124);
pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, 125);
pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, 126);
pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, 127);
pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, 128);
event.addSample(ARBITRARY_EVENT_TIME + 1, pointerCoords);
pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_X, 210);
pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_Y, 211);
pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 212);
pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_SIZE, 213);
pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, 214);
pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, 215);
pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, 216);
pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, 217);
pointerCoords[0].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, 218);
pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_X, 220);
pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_Y, 221);
pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 222);
pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_SIZE, 223);
pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, 224);
pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, 225);
pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, 226);
pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, 227);
pointerCoords[1].setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, 228);
event.addSample(ARBITRARY_EVENT_TIME + 2, pointerCoords);
ASSERT_EQ(AINPUT_EVENT_TYPE_MOTION, event.getType());
ASSERT_EQ(2, event.getDeviceId());
ASSERT_EQ(AINPUT_SOURCE_TOUCHSCREEN, event.getSource());
ASSERT_EQ(AMOTION_EVENT_ACTION_MOVE, event.getAction());
ASSERT_EQ(AMOTION_EVENT_FLAG_WINDOW_IS_OBSCURED, event.getFlags());
ASSERT_EQ(AMOTION_EVENT_EDGE_FLAG_TOP, event.getEdgeFlags());
ASSERT_EQ(AMETA_ALT_ON, event.getMetaState());
ASSERT_EQ(X_OFFSET, event.getXOffset());
ASSERT_EQ(Y_OFFSET, event.getYOffset());
ASSERT_EQ(2.0f, event.getXPrecision());
ASSERT_EQ(2.1f, event.getYPrecision());
ASSERT_EQ(ARBITRARY_DOWN_TIME, event.getDownTime());
ASSERT_EQ(2U, event.getPointerCount());
ASSERT_EQ(1, event.getPointerId(0));
ASSERT_EQ(2, event.getPointerId(1));
ASSERT_EQ(2U, event.getHistorySize());
// Get data.
ASSERT_EQ(ARBITRARY_EVENT_TIME, event.getHistoricalEventTime(0));
ASSERT_EQ(ARBITRARY_EVENT_TIME + 1, event.getHistoricalEventTime(1));
ASSERT_EQ(ARBITRARY_EVENT_TIME + 2, event.getEventTime());
ASSERT_EQ(11, event.getHistoricalRawPointerCoords(0, 0)->
getAxisValue(AMOTION_EVENT_AXIS_Y));
ASSERT_EQ(21, event.getHistoricalRawPointerCoords(1, 0)->
getAxisValue(AMOTION_EVENT_AXIS_Y));
ASSERT_EQ(111, event.getHistoricalRawPointerCoords(0, 1)->
getAxisValue(AMOTION_EVENT_AXIS_Y));
ASSERT_EQ(121, event.getHistoricalRawPointerCoords(1, 1)->
getAxisValue(AMOTION_EVENT_AXIS_Y));
ASSERT_EQ(211, event.getRawPointerCoords(0)->
getAxisValue(AMOTION_EVENT_AXIS_Y));
ASSERT_EQ(221, event.getRawPointerCoords(1)->
getAxisValue(AMOTION_EVENT_AXIS_Y));
ASSERT_EQ(11, event.getHistoricalRawAxisValue(AMOTION_EVENT_AXIS_Y, 0, 0));
ASSERT_EQ(21, event.getHistoricalRawAxisValue(AMOTION_EVENT_AXIS_Y, 1, 0));
ASSERT_EQ(111, event.getHistoricalRawAxisValue(AMOTION_EVENT_AXIS_Y, 0, 1));
ASSERT_EQ(121, event.getHistoricalRawAxisValue(AMOTION_EVENT_AXIS_Y, 1, 1));
ASSERT_EQ(211, event.getRawAxisValue(AMOTION_EVENT_AXIS_Y, 0));
ASSERT_EQ(221, event.getRawAxisValue(AMOTION_EVENT_AXIS_Y, 1));
ASSERT_EQ(10, event.getHistoricalRawX(0, 0));
ASSERT_EQ(20, event.getHistoricalRawX(1, 0));
ASSERT_EQ(110, event.getHistoricalRawX(0, 1));
ASSERT_EQ(120, event.getHistoricalRawX(1, 1));
ASSERT_EQ(210, event.getRawX(0));
ASSERT_EQ(220, event.getRawX(1));
ASSERT_EQ(11, event.getHistoricalRawY(0, 0));
ASSERT_EQ(21, event.getHistoricalRawY(1, 0));
ASSERT_EQ(111, event.getHistoricalRawY(0, 1));
ASSERT_EQ(121, event.getHistoricalRawY(1, 1));
ASSERT_EQ(211, event.getRawY(0));
ASSERT_EQ(221, event.getRawY(1));
ASSERT_EQ(X_OFFSET + 10, event.getHistoricalX(0, 0));
ASSERT_EQ(X_OFFSET + 20, event.getHistoricalX(1, 0));
ASSERT_EQ(X_OFFSET + 110, event.getHistoricalX(0, 1));
ASSERT_EQ(X_OFFSET + 120, event.getHistoricalX(1, 1));
ASSERT_EQ(X_OFFSET + 210, event.getX(0));
ASSERT_EQ(X_OFFSET + 220, event.getX(1));
ASSERT_EQ(Y_OFFSET + 11, event.getHistoricalY(0, 0));
ASSERT_EQ(Y_OFFSET + 21, event.getHistoricalY(1, 0));
ASSERT_EQ(Y_OFFSET + 111, event.getHistoricalY(0, 1));
ASSERT_EQ(Y_OFFSET + 121, event.getHistoricalY(1, 1));
ASSERT_EQ(Y_OFFSET + 211, event.getY(0));
ASSERT_EQ(Y_OFFSET + 221, event.getY(1));
ASSERT_EQ(12, event.getHistoricalPressure(0, 0));
ASSERT_EQ(22, event.getHistoricalPressure(1, 0));
ASSERT_EQ(112, event.getHistoricalPressure(0, 1));
ASSERT_EQ(122, event.getHistoricalPressure(1, 1));
ASSERT_EQ(212, event.getPressure(0));
ASSERT_EQ(222, event.getPressure(1));
ASSERT_EQ(13, event.getHistoricalSize(0, 0));
ASSERT_EQ(23, event.getHistoricalSize(1, 0));
ASSERT_EQ(113, event.getHistoricalSize(0, 1));
ASSERT_EQ(123, event.getHistoricalSize(1, 1));
ASSERT_EQ(213, event.getSize(0));
ASSERT_EQ(223, event.getSize(1));
ASSERT_EQ(14, event.getHistoricalTouchMajor(0, 0));
ASSERT_EQ(24, event.getHistoricalTouchMajor(1, 0));
ASSERT_EQ(114, event.getHistoricalTouchMajor(0, 1));
ASSERT_EQ(124, event.getHistoricalTouchMajor(1, 1));
ASSERT_EQ(214, event.getTouchMajor(0));
ASSERT_EQ(224, event.getTouchMajor(1));
ASSERT_EQ(15, event.getHistoricalTouchMinor(0, 0));
ASSERT_EQ(25, event.getHistoricalTouchMinor(1, 0));
ASSERT_EQ(115, event.getHistoricalTouchMinor(0, 1));
ASSERT_EQ(125, event.getHistoricalTouchMinor(1, 1));
ASSERT_EQ(215, event.getTouchMinor(0));
ASSERT_EQ(225, event.getTouchMinor(1));
ASSERT_EQ(16, event.getHistoricalToolMajor(0, 0));
ASSERT_EQ(26, event.getHistoricalToolMajor(1, 0));
ASSERT_EQ(116, event.getHistoricalToolMajor(0, 1));
ASSERT_EQ(126, event.getHistoricalToolMajor(1, 1));
ASSERT_EQ(216, event.getToolMajor(0));
ASSERT_EQ(226, event.getToolMajor(1));
ASSERT_EQ(17, event.getHistoricalToolMinor(0, 0));
ASSERT_EQ(27, event.getHistoricalToolMinor(1, 0));
ASSERT_EQ(117, event.getHistoricalToolMinor(0, 1));
ASSERT_EQ(127, event.getHistoricalToolMinor(1, 1));
ASSERT_EQ(217, event.getToolMinor(0));
ASSERT_EQ(227, event.getToolMinor(1));
ASSERT_EQ(18, event.getHistoricalOrientation(0, 0));
ASSERT_EQ(28, event.getHistoricalOrientation(1, 0));
ASSERT_EQ(118, event.getHistoricalOrientation(0, 1));
ASSERT_EQ(128, event.getHistoricalOrientation(1, 1));
ASSERT_EQ(218, event.getOrientation(0));
ASSERT_EQ(228, event.getOrientation(1));
}
} // namespace android

80
libs/ui/tests/InputPublisherAndConsumer_test.cpp
View File

@@ -1,6 +1,18 @@
//
// Copyright 2010 The Android Open Source Project
//
/*
* Copyright (C) 2010 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.
*/
#include <ui/InputTransport.h>
#include <utils/Timers.h>
@@ -161,15 +173,15 @@ void InputPublisherAndConsumerTest::PublishAndConsumeMotionEvent(
samplePointerCoords.push();
PointerCoords& pc = samplePointerCoords.editTop();
pc.clear();
pc.setAxisValue(AINPUT_MOTION_AXIS_X, 100 * i + j);
pc.setAxisValue(AINPUT_MOTION_AXIS_Y, 200 * i + j);
pc.setAxisValue(AINPUT_MOTION_AXIS_PRESSURE, 0.5 * i + j);
pc.setAxisValue(AINPUT_MOTION_AXIS_SIZE, 0.7 * i + j);
pc.setAxisValue(AINPUT_MOTION_AXIS_TOUCH_MAJOR, 1.5 * i + j);
pc.setAxisValue(AINPUT_MOTION_AXIS_TOUCH_MINOR, 1.7 * i + j);
pc.setAxisValue(AINPUT_MOTION_AXIS_TOOL_MAJOR, 2.5 * i + j);
pc.setAxisValue(AINPUT_MOTION_AXIS_TOOL_MAJOR, 2.7 * i + j);
pc.setAxisValue(AINPUT_MOTION_AXIS_ORIENTATION, 3.5 * i + j);
pc.setAxisValue(AMOTION_EVENT_AXIS_X, 100 * i + j);
pc.setAxisValue(AMOTION_EVENT_AXIS_Y, 200 * i + j);
pc.setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, 0.5 * i + j);
pc.setAxisValue(AMOTION_EVENT_AXIS_SIZE, 0.7 * i + j);
pc.setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, 1.5 * i + j);
pc.setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, 1.7 * i + j);
pc.setAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, 2.5 * i + j);
pc.setAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, 2.7 * i + j);
pc.setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, 3.5 * i + j);
}
}
@@ -241,27 +253,27 @@ void InputPublisherAndConsumerTest::PublishAndConsumeMotionEvent(
for (size_t i = 0; i < pointerCount; i++) {
SCOPED_TRACE(i);
size_t offset = sampleIndex * pointerCount + i;
EXPECT_EQ(samplePointerCoords[offset].getAxisValue(AINPUT_MOTION_AXIS_X),
EXPECT_EQ(samplePointerCoords[offset].getAxisValue(AMOTION_EVENT_AXIS_X),
motionEvent->getHistoricalRawX(i, sampleIndex));
EXPECT_EQ(samplePointerCoords[offset].getAxisValue(AINPUT_MOTION_AXIS_Y),
EXPECT_EQ(samplePointerCoords[offset].getAxisValue(AMOTION_EVENT_AXIS_Y),
motionEvent->getHistoricalRawY(i, sampleIndex));
EXPECT_EQ(samplePointerCoords[offset].getAxisValue(AINPUT_MOTION_AXIS_X) + xOffset,
EXPECT_EQ(samplePointerCoords[offset].getAxisValue(AMOTION_EVENT_AXIS_X) + xOffset,
motionEvent->getHistoricalX(i, sampleIndex));
EXPECT_EQ(samplePointerCoords[offset].getAxisValue(AINPUT_MOTION_AXIS_Y) + yOffset,
EXPECT_EQ(samplePointerCoords[offset].getAxisValue(AMOTION_EVENT_AXIS_Y) + yOffset,
motionEvent->getHistoricalY(i, sampleIndex));
EXPECT_EQ(samplePointerCoords[offset].getAxisValue(AINPUT_MOTION_AXIS_PRESSURE),
EXPECT_EQ(samplePointerCoords[offset].getAxisValue(AMOTION_EVENT_AXIS_PRESSURE),
motionEvent->getHistoricalPressure(i, sampleIndex));
EXPECT_EQ(samplePointerCoords[offset].getAxisValue(AINPUT_MOTION_AXIS_SIZE),
EXPECT_EQ(samplePointerCoords[offset].getAxisValue(AMOTION_EVENT_AXIS_SIZE),
motionEvent->getHistoricalSize(i, sampleIndex));
EXPECT_EQ(samplePointerCoords[offset].getAxisValue(AINPUT_MOTION_AXIS_TOUCH_MAJOR),
EXPECT_EQ(samplePointerCoords[offset].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR),
motionEvent->getHistoricalTouchMajor(i, sampleIndex));
EXPECT_EQ(samplePointerCoords[offset].getAxisValue(AINPUT_MOTION_AXIS_TOUCH_MINOR),
EXPECT_EQ(samplePointerCoords[offset].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR),
motionEvent->getHistoricalTouchMinor(i, sampleIndex));
EXPECT_EQ(samplePointerCoords[offset].getAxisValue(AINPUT_MOTION_AXIS_TOOL_MAJOR),
EXPECT_EQ(samplePointerCoords[offset].getAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR),
motionEvent->getHistoricalToolMajor(i, sampleIndex));
EXPECT_EQ(samplePointerCoords[offset].getAxisValue(AINPUT_MOTION_AXIS_TOOL_MINOR),
EXPECT_EQ(samplePointerCoords[offset].getAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR),
motionEvent->getHistoricalToolMinor(i, sampleIndex));
EXPECT_EQ(samplePointerCoords[offset].getAxisValue(AINPUT_MOTION_AXIS_ORIENTATION),
EXPECT_EQ(samplePointerCoords[offset].getAxisValue(AMOTION_EVENT_AXIS_ORIENTATION),
motionEvent->getHistoricalOrientation(i, sampleIndex));
}
}
@@ -271,27 +283,27 @@ void InputPublisherAndConsumerTest::PublishAndConsumeMotionEvent(
for (size_t i = 0; i < pointerCount; i++) {
SCOPED_TRACE(i);
size_t offset = lastSampleIndex * pointerCount + i;
EXPECT_EQ(samplePointerCoords[offset].getAxisValue(AINPUT_MOTION_AXIS_X),
EXPECT_EQ(samplePointerCoords[offset].getAxisValue(AMOTION_EVENT_AXIS_X),
motionEvent->getRawX(i));
EXPECT_EQ(samplePointerCoords[offset].getAxisValue(AINPUT_MOTION_AXIS_Y),
EXPECT_EQ(samplePointerCoords[offset].getAxisValue(AMOTION_EVENT_AXIS_Y),
motionEvent->getRawY(i));
EXPECT_EQ(samplePointerCoords[offset].getAxisValue(AINPUT_MOTION_AXIS_X) + xOffset,
EXPECT_EQ(samplePointerCoords[offset].getAxisValue(AMOTION_EVENT_AXIS_X) + xOffset,
motionEvent->getX(i));
EXPECT_EQ(samplePointerCoords[offset].getAxisValue(AINPUT_MOTION_AXIS_Y) + yOffset,
EXPECT_EQ(samplePointerCoords[offset].getAxisValue(AMOTION_EVENT_AXIS_Y) + yOffset,
motionEvent->getY(i));
EXPECT_EQ(samplePointerCoords[offset].getAxisValue(AINPUT_MOTION_AXIS_PRESSURE),
EXPECT_EQ(samplePointerCoords[offset].getAxisValue(AMOTION_EVENT_AXIS_PRESSURE),
motionEvent->getPressure(i));
EXPECT_EQ(samplePointerCoords[offset].getAxisValue(AINPUT_MOTION_AXIS_SIZE),
EXPECT_EQ(samplePointerCoords[offset].getAxisValue(AMOTION_EVENT_AXIS_SIZE),
motionEvent->getSize(i));
EXPECT_EQ(samplePointerCoords[offset].getAxisValue(AINPUT_MOTION_AXIS_TOUCH_MAJOR),
EXPECT_EQ(samplePointerCoords[offset].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR),
motionEvent->getTouchMajor(i));
EXPECT_EQ(samplePointerCoords[offset].getAxisValue(AINPUT_MOTION_AXIS_TOUCH_MINOR),
EXPECT_EQ(samplePointerCoords[offset].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR),
motionEvent->getTouchMinor(i));
EXPECT_EQ(samplePointerCoords[offset].getAxisValue(AINPUT_MOTION_AXIS_TOOL_MAJOR),
EXPECT_EQ(samplePointerCoords[offset].getAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR),
motionEvent->getToolMajor(i));
EXPECT_EQ(samplePointerCoords[offset].getAxisValue(AINPUT_MOTION_AXIS_TOOL_MINOR),
EXPECT_EQ(samplePointerCoords[offset].getAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR),
motionEvent->getToolMinor(i));
EXPECT_EQ(samplePointerCoords[offset].getAxisValue(AINPUT_MOTION_AXIS_ORIENTATION),
EXPECT_EQ(samplePointerCoords[offset].getAxisValue(AMOTION_EVENT_AXIS_ORIENTATION),
motionEvent->getOrientation(i));
}

50
native/include/android/input.h
View File

@@ -320,6 +320,21 @@ enum {
AMOTION_EVENT_EDGE_FLAG_RIGHT = 0x08
};
/*
* Constants that identify each individual axis of a motion event.
*/
enum {
AMOTION_EVENT_AXIS_X = 0,
AMOTION_EVENT_AXIS_Y = 1,
AMOTION_EVENT_AXIS_PRESSURE = 2,
AMOTION_EVENT_AXIS_SIZE = 3,
AMOTION_EVENT_AXIS_TOUCH_MAJOR = 4,
AMOTION_EVENT_AXIS_TOUCH_MINOR = 5,
AMOTION_EVENT_AXIS_TOOL_MAJOR = 6,
AMOTION_EVENT_AXIS_TOOL_MINOR = 7,
AMOTION_EVENT_AXIS_ORIENTATION = 8,
};
/*
* Input sources.
*
@@ -362,21 +377,6 @@ enum {
AINPUT_KEYBOARD_TYPE_ALPHABETIC = 2,
};
/*
* Constants that identify each individual axis of a motion event.
*/
enum {
AINPUT_MOTION_AXIS_X = 0,
AINPUT_MOTION_AXIS_Y = 1,
AINPUT_MOTION_AXIS_PRESSURE = 2,
AINPUT_MOTION_AXIS_SIZE = 3,
AINPUT_MOTION_AXIS_TOUCH_MAJOR = 4,
AINPUT_MOTION_AXIS_TOUCH_MINOR = 5,
AINPUT_MOTION_AXIS_TOOL_MAJOR = 6,
AINPUT_MOTION_AXIS_TOOL_MINOR = 7,
AINPUT_MOTION_AXIS_ORIENTATION = 8,
};
/*
* Constants used to retrieve information about the range of motion for a particular
* coordinate of a motion event.
@@ -384,18 +384,18 @@ enum {
* Refer to the documentation on android.view.InputDevice for more details about input sources
* and their correct interpretation.
*
* DEPRECATION NOTICE: These constants are deprecated. Use AINPUT_MOTION_AXIS_* constants instead.
* DEPRECATION NOTICE: These constants are deprecated. Use AMOTION_EVENT_AXIS_* constants instead.
*/
enum {
AINPUT_MOTION_RANGE_X = AINPUT_MOTION_AXIS_X,
AINPUT_MOTION_RANGE_Y = AINPUT_MOTION_AXIS_Y,
AINPUT_MOTION_RANGE_PRESSURE = AINPUT_MOTION_AXIS_PRESSURE,
AINPUT_MOTION_RANGE_SIZE = AINPUT_MOTION_AXIS_SIZE,
AINPUT_MOTION_RANGE_TOUCH_MAJOR = AINPUT_MOTION_AXIS_TOUCH_MAJOR,
AINPUT_MOTION_RANGE_TOUCH_MINOR = AINPUT_MOTION_AXIS_TOUCH_MINOR,
AINPUT_MOTION_RANGE_TOOL_MAJOR = AINPUT_MOTION_AXIS_TOOL_MAJOR,
AINPUT_MOTION_RANGE_TOOL_MINOR = AINPUT_MOTION_AXIS_TOOL_MINOR,
AINPUT_MOTION_RANGE_ORIENTATION = AINPUT_MOTION_AXIS_ORIENTATION,
AINPUT_MOTION_RANGE_X = AMOTION_EVENT_AXIS_X,
AINPUT_MOTION_RANGE_Y = AMOTION_EVENT_AXIS_Y,
AINPUT_MOTION_RANGE_PRESSURE = AMOTION_EVENT_AXIS_PRESSURE,
AINPUT_MOTION_RANGE_SIZE = AMOTION_EVENT_AXIS_SIZE,
AINPUT_MOTION_RANGE_TOUCH_MAJOR = AMOTION_EVENT_AXIS_TOUCH_MAJOR,
AINPUT_MOTION_RANGE_TOUCH_MINOR = AMOTION_EVENT_AXIS_TOUCH_MINOR,
AINPUT_MOTION_RANGE_TOOL_MAJOR = AMOTION_EVENT_AXIS_TOOL_MAJOR,
AINPUT_MOTION_RANGE_TOOL_MINOR = AMOTION_EVENT_AXIS_TOOL_MINOR,
AINPUT_MOTION_RANGE_ORIENTATION = AMOTION_EVENT_AXIS_ORIENTATION,
} __attribute__ ((deprecated));

44
services/input/InputDispatcher.cpp
View File

@@ -483,9 +483,9 @@ bool InputDispatcher::enqueueInboundEventLocked(EventEntry* entry) {
&& mInputTargetWaitCause == INPUT_TARGET_WAIT_CAUSE_APPLICATION_NOT_READY
&& mInputTargetWaitApplication != NULL) {
int32_t x = int32_t(motionEntry->firstSample.pointerCoords[0].
getAxisValue(AINPUT_MOTION_AXIS_X));
getAxisValue(AMOTION_EVENT_AXIS_X));
int32_t y = int32_t(motionEntry->firstSample.pointerCoords[0].
getAxisValue(AINPUT_MOTION_AXIS_Y));
getAxisValue(AMOTION_EVENT_AXIS_Y));
const InputWindow* touchedWindow = findTouchedWindowAtLocked(x, y);
if (touchedWindow
&& touchedWindow->inputWindowHandle != NULL
@@ -890,15 +890,15 @@ void InputDispatcher::logOutboundMotionDetailsLocked(const char* prefix, const M
"touchMajor=%f, touchMinor=%f, toolMajor=%f, toolMinor=%f, "
"orientation=%f",
i, entry->pointerIds[i],
sample->pointerCoords[i].getAxisValue(AINPUT_MOTION_AXIS_X),
sample->pointerCoords[i].getAxisValue(AINPUT_MOTION_AXIS_Y),
sample->pointerCoords[i].getAxisValue(AINPUT_MOTION_AXIS_PRESSURE),
sample->pointerCoords[i].getAxisValue(AINPUT_MOTION_AXIS_SIZE),
sample->pointerCoords[i].getAxisValue(AINPUT_MOTION_AXIS_TOUCH_MAJOR),
sample->pointerCoords[i].getAxisValue(AINPUT_MOTION_AXIS_TOUCH_MINOR),
sample->pointerCoords[i].getAxisValue(AINPUT_MOTION_AXIS_TOOL_MAJOR),
sample->pointerCoords[i].getAxisValue(AINPUT_MOTION_AXIS_TOOL_MINOR),
sample->pointerCoords[i].getAxisValue(AINPUT_MOTION_AXIS_ORIENTATION));
sample->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_X),
sample->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_Y),
sample->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_PRESSURE),
sample->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_SIZE),
sample->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR),
sample->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR),
sample->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR),
sample->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR),
sample->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_ORIENTATION));
}
// Keep in mind that due to batching, it is possible for the number of samples actually
@@ -1195,9 +1195,9 @@ int32_t InputDispatcher::findTouchedWindowTargetsLocked(nsecs_t currentTime,
int32_t pointerIndex = getMotionEventActionPointerIndex(action);
int32_t x = int32_t(entry->firstSample.pointerCoords[pointerIndex].
getAxisValue(AINPUT_MOTION_AXIS_X));
getAxisValue(AMOTION_EVENT_AXIS_X));
int32_t y = int32_t(entry->firstSample.pointerCoords[pointerIndex].
getAxisValue(AINPUT_MOTION_AXIS_Y));
getAxisValue(AMOTION_EVENT_AXIS_Y));
const InputWindow* newTouchedWindow = NULL;
const InputWindow* topErrorWindow = NULL;
@@ -2284,15 +2284,15 @@ void InputDispatcher::notifyMotion(nsecs_t eventTime, int32_t deviceId, uint32_t
"touchMajor=%f, touchMinor=%f, toolMajor=%f, toolMinor=%f, "
"orientation=%f",
i, pointerIds[i],
pointerCoords[i].getAxisValue(AINPUT_MOTION_AXIS_X),
pointerCoords[i].getAxisValue(AINPUT_MOTION_AXIS_Y),
pointerCoords[i].getAxisValue(AINPUT_MOTION_AXIS_PRESSURE),
pointerCoords[i].getAxisValue(AINPUT_MOTION_AXIS_SIZE),
pointerCoords[i].getAxisValue(AINPUT_MOTION_AXIS_TOUCH_MAJOR),
pointerCoords[i].getAxisValue(AINPUT_MOTION_AXIS_TOUCH_MINOR),
pointerCoords[i].getAxisValue(AINPUT_MOTION_AXIS_TOOL_MAJOR),
pointerCoords[i].getAxisValue(AINPUT_MOTION_AXIS_TOOL_MINOR),
pointerCoords[i].getAxisValue(AINPUT_MOTION_AXIS_ORIENTATION));
pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_X),
pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_Y),
pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_PRESSURE),
pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_SIZE),
pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR),
pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR),
pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR),
pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR),
pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_ORIENTATION));
}
#endif
if (! validateMotionEvent(action, pointerCount, pointerIds)) {

36
services/input/InputReader.cpp
View File

@@ -1294,14 +1294,14 @@ void CursorInputMapper::sync(nsecs_t when) {
}
float x, y;
mPointerController->getPosition(&x, &y);
pointerCoords.setAxisValue(AINPUT_MOTION_AXIS_X, x);
pointerCoords.setAxisValue(AINPUT_MOTION_AXIS_Y, y);
pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_X, x);
pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_Y, y);
} else {
pointerCoords.setAxisValue(AINPUT_MOTION_AXIS_X, deltaX);
pointerCoords.setAxisValue(AINPUT_MOTION_AXIS_Y, deltaY);
pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_X, deltaX);
pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_Y, deltaY);
}
pointerCoords.setAxisValue(AINPUT_MOTION_AXIS_PRESSURE, mLocked.down ? 1.0f : 0.0f);
pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, mLocked.down ? 1.0f : 0.0f);
} // release lock
int32_t metaState = mContext->getGlobalMetaState();
@@ -2686,15 +2686,15 @@ void TouchInputMapper::dispatchTouch(nsecs_t when, uint32_t policyFlags,
// Write output coords.
PointerCoords& out = pointerCoords[outIndex];
out.clear();
out.setAxisValue(AINPUT_MOTION_AXIS_X, x);
out.setAxisValue(AINPUT_MOTION_AXIS_Y, y);
out.setAxisValue(AINPUT_MOTION_AXIS_PRESSURE, pressure);
out.setAxisValue(AINPUT_MOTION_AXIS_SIZE, size);
out.setAxisValue(AINPUT_MOTION_AXIS_TOUCH_MAJOR, touchMajor);
out.setAxisValue(AINPUT_MOTION_AXIS_TOUCH_MINOR, touchMinor);
out.setAxisValue(AINPUT_MOTION_AXIS_TOOL_MAJOR, toolMajor);
out.setAxisValue(AINPUT_MOTION_AXIS_TOOL_MINOR, toolMinor);
out.setAxisValue(AINPUT_MOTION_AXIS_ORIENTATION, orientation);
out.setAxisValue(AMOTION_EVENT_AXIS_X, x);
out.setAxisValue(AMOTION_EVENT_AXIS_Y, y);
out.setAxisValue(AMOTION_EVENT_AXIS_PRESSURE, pressure);
out.setAxisValue(AMOTION_EVENT_AXIS_SIZE, size);
out.setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR, touchMajor);
out.setAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR, touchMinor);
out.setAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR, toolMajor);
out.setAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR, toolMinor);
out.setAxisValue(AMOTION_EVENT_AXIS_ORIENTATION, orientation);
pointerIds[outIndex] = int32_t(id);
@@ -2706,8 +2706,8 @@ void TouchInputMapper::dispatchTouch(nsecs_t when, uint32_t policyFlags,
// Check edge flags by looking only at the first pointer since the flags are
// global to the event.
if (motionEventAction == AMOTION_EVENT_ACTION_DOWN) {
float x = pointerCoords[0].getAxisValue(AINPUT_MOTION_AXIS_X);
float y = pointerCoords[0].getAxisValue(AINPUT_MOTION_AXIS_Y);
float x = pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_X);
float y = pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_Y);
if (x <= 0) {
motionEventEdgeFlags |= AMOTION_EVENT_EDGE_FLAG_LEFT;
@@ -3857,8 +3857,8 @@ void JoystickInputMapper::sync(nsecs_t when) {
if (motionAxisChanged) {
PointerCoords pointerCoords;
pointerCoords.clear();
pointerCoords.setAxisValue(AINPUT_MOTION_AXIS_X, mAxes.x.value);
pointerCoords.setAxisValue(AINPUT_MOTION_AXIS_Y, mAxes.y.value);
pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_X, mAxes.x.value);
pointerCoords.setAxisValue(AMOTION_EVENT_AXIS_Y, mAxes.y.value);
int32_t pointerId = 0;
getDispatcher()->notifyMotion(when, getDeviceId(), AINPUT_SOURCE_JOYSTICK, 0,

38
services/input/tests/InputReader_test.cpp
View File

@@ -1473,15 +1473,15 @@ protected:
float x, float y, float pressure, float size,
float touchMajor, float touchMinor, float toolMajor, float toolMinor,
float orientation) {
ASSERT_NEAR(x, coords.getAxisValue(AINPUT_MOTION_AXIS_X), 1);
ASSERT_NEAR(y, coords.getAxisValue(AINPUT_MOTION_AXIS_Y), 1);
ASSERT_NEAR(pressure, coords.getAxisValue(AINPUT_MOTION_AXIS_PRESSURE), EPSILON);
ASSERT_NEAR(size, coords.getAxisValue(AINPUT_MOTION_AXIS_SIZE), EPSILON);
ASSERT_NEAR(touchMajor, coords.getAxisValue(AINPUT_MOTION_AXIS_TOUCH_MAJOR), 1);
ASSERT_NEAR(touchMinor, coords.getAxisValue(AINPUT_MOTION_AXIS_TOUCH_MINOR), 1);
ASSERT_NEAR(toolMajor, coords.getAxisValue(AINPUT_MOTION_AXIS_TOOL_MAJOR), 1);
ASSERT_NEAR(toolMinor, coords.getAxisValue(AINPUT_MOTION_AXIS_TOOL_MINOR), 1);
ASSERT_NEAR(orientation, coords.getAxisValue(AINPUT_MOTION_AXIS_ORIENTATION), EPSILON);
ASSERT_NEAR(x, coords.getAxisValue(AMOTION_EVENT_AXIS_X), 1);
ASSERT_NEAR(y, coords.getAxisValue(AMOTION_EVENT_AXIS_Y), 1);
ASSERT_NEAR(pressure, coords.getAxisValue(AMOTION_EVENT_AXIS_PRESSURE), EPSILON);
ASSERT_NEAR(size, coords.getAxisValue(AMOTION_EVENT_AXIS_SIZE), EPSILON);
ASSERT_NEAR(touchMajor, coords.getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR), 1);
ASSERT_NEAR(touchMinor, coords.getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR), 1);
ASSERT_NEAR(toolMajor, coords.getAxisValue(AMOTION_EVENT_AXIS_TOOL_MAJOR), 1);
ASSERT_NEAR(toolMinor, coords.getAxisValue(AMOTION_EVENT_AXIS_TOOL_MINOR), 1);
ASSERT_NEAR(orientation, coords.getAxisValue(AMOTION_EVENT_AXIS_ORIENTATION), EPSILON);
}
};
@@ -2892,8 +2892,8 @@ TEST_F(SingleTouchInputMapperTest, Process_WhenNotOrientationAware_DoesNotRotate
processSync(mapper);
ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
ASSERT_NEAR(50, args.pointerCoords[0].getAxisValue(AINPUT_MOTION_AXIS_X), 1);
ASSERT_NEAR(75, args.pointerCoords[0].getAxisValue(AINPUT_MOTION_AXIS_Y), 1);
ASSERT_NEAR(50, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_X), 1);
ASSERT_NEAR(75, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_Y), 1);
processUp(mapper);
processSync(mapper);
@@ -2914,8 +2914,8 @@ TEST_F(SingleTouchInputMapperTest, Process_WhenOrientationAware_RotatesMotions)
processSync(mapper);
ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
ASSERT_NEAR(50, args.pointerCoords[0].getAxisValue(AINPUT_MOTION_AXIS_X), 1);
ASSERT_NEAR(75, args.pointerCoords[0].getAxisValue(AINPUT_MOTION_AXIS_Y), 1);
ASSERT_NEAR(50, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_X), 1);
ASSERT_NEAR(75, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_Y), 1);
processUp(mapper);
processSync(mapper);
@@ -2927,8 +2927,8 @@ TEST_F(SingleTouchInputMapperTest, Process_WhenOrientationAware_RotatesMotions)
processSync(mapper);
ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
ASSERT_NEAR(75, args.pointerCoords[0].getAxisValue(AINPUT_MOTION_AXIS_X), 1);
ASSERT_NEAR(DISPLAY_WIDTH - 50, args.pointerCoords[0].getAxisValue(AINPUT_MOTION_AXIS_Y), 1);
ASSERT_NEAR(75, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_X), 1);
ASSERT_NEAR(DISPLAY_WIDTH - 50, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_Y), 1);
processUp(mapper);
processSync(mapper);
@@ -2940,8 +2940,8 @@ TEST_F(SingleTouchInputMapperTest, Process_WhenOrientationAware_RotatesMotions)
processSync(mapper);
ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
ASSERT_NEAR(DISPLAY_WIDTH - 50, args.pointerCoords[0].getAxisValue(AINPUT_MOTION_AXIS_X), 1);
ASSERT_NEAR(DISPLAY_HEIGHT - 75, args.pointerCoords[0].getAxisValue(AINPUT_MOTION_AXIS_Y), 1);
ASSERT_NEAR(DISPLAY_WIDTH - 50, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_X), 1);
ASSERT_NEAR(DISPLAY_HEIGHT - 75, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_Y), 1);
processUp(mapper);
processSync(mapper);
@@ -2953,8 +2953,8 @@ TEST_F(SingleTouchInputMapperTest, Process_WhenOrientationAware_RotatesMotions)
processSync(mapper);
ASSERT_NO_FATAL_FAILURE(mFakeDispatcher->assertNotifyMotionWasCalled(&args));
ASSERT_NEAR(DISPLAY_HEIGHT - 75, args.pointerCoords[0].getAxisValue(AINPUT_MOTION_AXIS_X), 1);
ASSERT_NEAR(50, args.pointerCoords[0].getAxisValue(AINPUT_MOTION_AXIS_Y), 1);
ASSERT_NEAR(DISPLAY_HEIGHT - 75, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_X), 1);
ASSERT_NEAR(50, args.pointerCoords[0].getAxisValue(AMOTION_EVENT_AXIS_Y), 1);
processUp(mapper);
processSync(mapper);